1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2015 Intel Corporation 3 */ 4 5 #include <cmdline_parse.h> 6 #include <cmdline_parse_num.h> 7 #include <cmdline_parse_string.h> 8 #include <cmdline_parse_etheraddr.h> 9 #include <cmdline_socket.h> 10 #include <cmdline.h> 11 12 #include "rte_ethtool.h" 13 #include "ethapp.h" 14 15 #define EEPROM_DUMP_CHUNKSIZE 1024 16 17 18 struct pcmd_get_params { 19 cmdline_fixed_string_t cmd; 20 }; 21 struct pcmd_int_params { 22 cmdline_fixed_string_t cmd; 23 uint16_t port; 24 }; 25 struct pcmd_intstr_params { 26 cmdline_fixed_string_t cmd; 27 uint16_t port; 28 cmdline_fixed_string_t opt; 29 }; 30 struct pcmd_intmac_params { 31 cmdline_fixed_string_t cmd; 32 uint16_t port; 33 struct rte_ether_addr mac; 34 }; 35 struct pcmd_str_params { 36 cmdline_fixed_string_t cmd; 37 cmdline_fixed_string_t opt; 38 }; 39 struct pcmd_vlan_params { 40 cmdline_fixed_string_t cmd; 41 uint16_t port; 42 cmdline_fixed_string_t mode; 43 uint16_t vid; 44 }; 45 struct pcmd_intintint_params { 46 cmdline_fixed_string_t cmd; 47 uint16_t port; 48 uint16_t tx; 49 uint16_t rx; 50 }; 51 52 53 /* Parameter-less commands */ 54 cmdline_parse_token_string_t pcmd_quit_token_cmd = 55 TOKEN_STRING_INITIALIZER(struct pcmd_get_params, cmd, "quit"); 56 cmdline_parse_token_string_t pcmd_stats_token_cmd = 57 TOKEN_STRING_INITIALIZER(struct pcmd_get_params, cmd, "stats"); 58 cmdline_parse_token_string_t pcmd_drvinfo_token_cmd = 59 TOKEN_STRING_INITIALIZER(struct pcmd_get_params, cmd, "drvinfo"); 60 cmdline_parse_token_string_t pcmd_link_token_cmd = 61 TOKEN_STRING_INITIALIZER(struct pcmd_get_params, cmd, "link"); 62 63 /* Commands taking just port id */ 64 cmdline_parse_token_string_t pcmd_open_token_cmd = 65 TOKEN_STRING_INITIALIZER(struct pcmd_int_params, cmd, "open"); 66 cmdline_parse_token_string_t pcmd_stop_token_cmd = 67 TOKEN_STRING_INITIALIZER(struct pcmd_int_params, cmd, "stop"); 68 cmdline_parse_token_string_t pcmd_rxmode_token_cmd = 69 TOKEN_STRING_INITIALIZER(struct pcmd_int_params, cmd, "rxmode"); 70 cmdline_parse_token_string_t pcmd_portstats_token_cmd = 71 TOKEN_STRING_INITIALIZER(struct pcmd_int_params, cmd, "portstats"); 72 cmdline_parse_token_num_t pcmd_int_token_port = 73 TOKEN_NUM_INITIALIZER(struct pcmd_int_params, port, RTE_UINT16); 74 75 /* Commands taking port id and string */ 76 cmdline_parse_token_string_t pcmd_eeprom_token_cmd = 77 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, cmd, "eeprom"); 78 cmdline_parse_token_string_t pcmd_module_eeprom_token_cmd = 79 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, cmd, 80 "module-eeprom"); 81 cmdline_parse_token_string_t pcmd_mtu_token_cmd = 82 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, cmd, "mtu"); 83 cmdline_parse_token_string_t pcmd_regs_token_cmd = 84 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, cmd, "regs"); 85 86 cmdline_parse_token_num_t pcmd_intstr_token_port = 87 TOKEN_NUM_INITIALIZER(struct pcmd_intstr_params, port, RTE_UINT16); 88 cmdline_parse_token_string_t pcmd_intstr_token_opt = 89 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, opt, NULL); 90 91 /* Commands taking port id and a MAC address string */ 92 cmdline_parse_token_string_t pcmd_macaddr_token_cmd = 93 TOKEN_STRING_INITIALIZER(struct pcmd_intmac_params, cmd, "macaddr"); 94 cmdline_parse_token_num_t pcmd_intmac_token_port = 95 TOKEN_NUM_INITIALIZER(struct pcmd_intmac_params, port, RTE_UINT16); 96 cmdline_parse_token_etheraddr_t pcmd_intmac_token_mac = 97 TOKEN_ETHERADDR_INITIALIZER(struct pcmd_intmac_params, mac); 98 99 /* Command taking just a MAC address */ 100 cmdline_parse_token_string_t pcmd_validate_token_cmd = 101 TOKEN_STRING_INITIALIZER(struct pcmd_intmac_params, cmd, "validate"); 102 103 104 /* Commands taking port id and two integers */ 105 cmdline_parse_token_string_t pcmd_ringparam_token_cmd = 106 TOKEN_STRING_INITIALIZER(struct pcmd_intintint_params, cmd, 107 "ringparam"); 108 cmdline_parse_token_num_t pcmd_intintint_token_port = 109 TOKEN_NUM_INITIALIZER(struct pcmd_intintint_params, port, 110 RTE_UINT16); 111 cmdline_parse_token_num_t pcmd_intintint_token_tx = 112 TOKEN_NUM_INITIALIZER(struct pcmd_intintint_params, tx, RTE_UINT16); 113 cmdline_parse_token_num_t pcmd_intintint_token_rx = 114 TOKEN_NUM_INITIALIZER(struct pcmd_intintint_params, rx, RTE_UINT16); 115 116 117 /* Pause commands */ 118 cmdline_parse_token_string_t pcmd_pause_token_cmd = 119 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, cmd, "pause"); 120 cmdline_parse_token_num_t pcmd_pause_token_port = 121 TOKEN_NUM_INITIALIZER(struct pcmd_intstr_params, port, RTE_UINT16); 122 cmdline_parse_token_string_t pcmd_pause_token_opt = 123 TOKEN_STRING_INITIALIZER(struct pcmd_intstr_params, 124 opt, "all#tx#rx#none"); 125 126 /* VLAN commands */ 127 cmdline_parse_token_string_t pcmd_vlan_token_cmd = 128 TOKEN_STRING_INITIALIZER(struct pcmd_vlan_params, cmd, "vlan"); 129 cmdline_parse_token_num_t pcmd_vlan_token_port = 130 TOKEN_NUM_INITIALIZER(struct pcmd_vlan_params, port, RTE_UINT16); 131 cmdline_parse_token_string_t pcmd_vlan_token_mode = 132 TOKEN_STRING_INITIALIZER(struct pcmd_vlan_params, mode, "add#del"); 133 cmdline_parse_token_num_t pcmd_vlan_token_vid = 134 TOKEN_NUM_INITIALIZER(struct pcmd_vlan_params, vid, RTE_UINT16); 135 136 137 static void 138 pcmd_quit_callback(__rte_unused void *ptr_params, 139 struct cmdline *ctx, 140 __rte_unused void *ptr_data) 141 { 142 cmdline_quit(ctx); 143 } 144 145 146 static void 147 pcmd_drvinfo_callback(__rte_unused void *ptr_params, 148 __rte_unused struct cmdline *ctx, 149 __rte_unused void *ptr_data) 150 { 151 struct ethtool_drvinfo info; 152 uint16_t id_port; 153 154 RTE_ETH_FOREACH_DEV(id_port) { 155 memset(&info, 0, sizeof(info)); 156 if (rte_ethtool_get_drvinfo(id_port, &info)) { 157 printf("Error getting info for port %i\n", id_port); 158 return; 159 } 160 printf("Port %i driver: %s (ver: %s)\n", 161 id_port, info.driver, info.version 162 ); 163 printf("firmware-version: %s\n", info.fw_version); 164 printf("bus-info: %s\n", info.bus_info); 165 } 166 } 167 168 169 static void 170 pcmd_link_callback(__rte_unused void *ptr_params, 171 __rte_unused struct cmdline *ctx, 172 __rte_unused void *ptr_data) 173 { 174 uint16_t id_port; 175 int stat_port; 176 177 RTE_ETH_FOREACH_DEV(id_port) { 178 if (!rte_eth_dev_is_valid_port(id_port)) 179 continue; 180 stat_port = rte_ethtool_get_link(id_port); 181 switch (stat_port) { 182 case 0: 183 printf("Port %i: Down\n", id_port); 184 break; 185 case 1: 186 printf("Port %i: Up\n", id_port); 187 break; 188 default: 189 printf("Port %i: Error getting link status\n", 190 id_port 191 ); 192 break; 193 } 194 } 195 printf("\n"); 196 } 197 198 199 static void 200 pcmd_regs_callback(void *ptr_params, 201 __rte_unused struct cmdline *ctx, 202 __rte_unused void *ptr_data) 203 { 204 struct pcmd_intstr_params *params = ptr_params; 205 int len_regs; 206 struct ethtool_regs regs; 207 unsigned char *buf_data; 208 FILE *fp_regs; 209 210 if (!rte_eth_dev_is_valid_port(params->port)) { 211 printf("Error: Invalid port number %i\n", params->port); 212 return; 213 } 214 len_regs = rte_ethtool_get_regs_len(params->port); 215 if (len_regs > 0) { 216 printf("Port %i: %i bytes\n", params->port, len_regs); 217 buf_data = malloc(len_regs); 218 if (buf_data == NULL) { 219 printf("Error allocating %i bytes for buffer\n", 220 len_regs); 221 return; 222 } 223 if (!rte_ethtool_get_regs(params->port, ®s, buf_data)) { 224 fp_regs = fopen(params->opt, "wb"); 225 if (fp_regs == NULL) { 226 printf("Error opening '%s' for writing\n", 227 params->opt); 228 } else { 229 if ((int)fwrite(buf_data, 230 1, len_regs, 231 fp_regs) != len_regs) 232 printf("Error writing '%s'\n", 233 params->opt); 234 fclose(fp_regs); 235 } 236 } 237 free(buf_data); 238 } else if (len_regs == -ENOTSUP) 239 printf("Port %i: Operation not supported\n", params->port); 240 else 241 printf("Port %i: Error getting registers\n", params->port); 242 } 243 244 245 static void 246 pcmd_eeprom_callback(void *ptr_params, 247 __rte_unused struct cmdline *ctx, 248 __rte_unused void *ptr_data) 249 { 250 struct pcmd_intstr_params *params = ptr_params; 251 struct ethtool_eeprom info_eeprom; 252 int len_eeprom; 253 int pos_eeprom; 254 int stat; 255 unsigned char bytes_eeprom[EEPROM_DUMP_CHUNKSIZE]; 256 FILE *fp_eeprom; 257 258 if (!rte_eth_dev_is_valid_port(params->port)) { 259 printf("Error: Invalid port number %i\n", params->port); 260 return; 261 } 262 len_eeprom = rte_ethtool_get_eeprom_len(params->port); 263 if (len_eeprom > 0) { 264 fp_eeprom = fopen(params->opt, "wb"); 265 if (fp_eeprom == NULL) { 266 printf("Error opening '%s' for writing\n", 267 params->opt); 268 return; 269 } 270 printf("Total EEPROM length: %i bytes\n", len_eeprom); 271 info_eeprom.len = EEPROM_DUMP_CHUNKSIZE; 272 for (pos_eeprom = 0; 273 pos_eeprom < len_eeprom; 274 pos_eeprom += EEPROM_DUMP_CHUNKSIZE) { 275 info_eeprom.offset = pos_eeprom; 276 if (pos_eeprom + EEPROM_DUMP_CHUNKSIZE > len_eeprom) 277 info_eeprom.len = len_eeprom - pos_eeprom; 278 else 279 info_eeprom.len = EEPROM_DUMP_CHUNKSIZE; 280 stat = rte_ethtool_get_eeprom( 281 params->port, &info_eeprom, bytes_eeprom 282 ); 283 if (stat != 0) { 284 printf("EEPROM read error %i\n", stat); 285 break; 286 } 287 if (fwrite(bytes_eeprom, 288 1, info_eeprom.len, 289 fp_eeprom) != info_eeprom.len) { 290 printf("Error writing '%s'\n", params->opt); 291 break; 292 } 293 } 294 fclose(fp_eeprom); 295 } else if (len_eeprom == 0) 296 printf("Port %i: Device does not have EEPROM\n", params->port); 297 else if (len_eeprom == -ENOTSUP) 298 printf("Port %i: Operation not supported\n", params->port); 299 else 300 printf("Port %i: Error getting EEPROM\n", params->port); 301 } 302 303 304 static void 305 pcmd_module_eeprom_callback(void *ptr_params, 306 __rte_unused struct cmdline *ctx, 307 __rte_unused void *ptr_data) 308 { 309 struct pcmd_intstr_params *params = ptr_params; 310 struct ethtool_eeprom info_eeprom; 311 uint32_t module_info[2]; 312 int stat; 313 unsigned char bytes_eeprom[EEPROM_DUMP_CHUNKSIZE]; 314 FILE *fp_eeprom; 315 316 if (!rte_eth_dev_is_valid_port(params->port)) { 317 printf("Error: Invalid port number %i\n", params->port); 318 return; 319 } 320 321 stat = rte_ethtool_get_module_info(params->port, module_info); 322 if (stat != 0) { 323 printf("Module EEPROM information read error %i\n", stat); 324 return; 325 } 326 327 info_eeprom.len = module_info[1]; 328 info_eeprom.offset = 0; 329 330 stat = rte_ethtool_get_module_eeprom(params->port, 331 &info_eeprom, bytes_eeprom); 332 if (stat != 0) { 333 printf("Module EEPROM read error %i\n", stat); 334 return; 335 } 336 337 fp_eeprom = fopen(params->opt, "wb"); 338 if (fp_eeprom == NULL) { 339 printf("Error opening '%s' for writing\n", params->opt); 340 return; 341 } 342 printf("Total plugin module EEPROM length: %i bytes\n", 343 info_eeprom.len); 344 if (fwrite(bytes_eeprom, 1, info_eeprom.len, 345 fp_eeprom) != info_eeprom.len) { 346 printf("Error writing '%s'\n", params->opt); 347 } 348 fclose(fp_eeprom); 349 } 350 351 352 static void 353 pcmd_pause_callback(void *ptr_params, 354 __rte_unused struct cmdline *ctx, 355 void *ptr_data) 356 { 357 struct pcmd_intstr_params *params = ptr_params; 358 struct ethtool_pauseparam info; 359 int stat; 360 361 if (!rte_eth_dev_is_valid_port(params->port)) { 362 printf("Error: Invalid port number %i\n", params->port); 363 return; 364 } 365 if (ptr_data != NULL) { 366 stat = rte_ethtool_get_pauseparam(params->port, &info); 367 } else { 368 memset(&info, 0, sizeof(info)); 369 if (strcasecmp("all", params->opt) == 0) { 370 info.tx_pause = 1; 371 info.rx_pause = 1; 372 } else if (strcasecmp("tx", params->opt) == 0) { 373 info.tx_pause = 1; 374 info.rx_pause = 0; 375 } else if (strcasecmp("rx", params->opt) == 0) { 376 info.tx_pause = 0; 377 info.rx_pause = 1; 378 } else { 379 info.tx_pause = 0; 380 info.rx_pause = 0; 381 } 382 /* Assume auto-negotiation wanted */ 383 info.autoneg = 1; 384 stat = rte_ethtool_set_pauseparam(params->port, &info); 385 } 386 if (stat == 0) { 387 if (info.rx_pause && info.tx_pause) 388 printf("Port %i: Tx & Rx Paused\n", params->port); 389 else if (info.rx_pause) 390 printf("Port %i: Rx Paused\n", params->port); 391 else if (info.tx_pause) 392 printf("Port %i: Tx Paused\n", params->port); 393 else 394 printf("Port %i: Tx & Rx not paused\n", params->port); 395 } else if (stat == -ENOTSUP) 396 printf("Port %i: Operation not supported\n", params->port); 397 else 398 printf("Port %i: Error %i\n", params->port, stat); 399 } 400 401 402 static void 403 pcmd_open_callback(__rte_unused void *ptr_params, 404 __rte_unused struct cmdline *ctx, 405 __rte_unused void *ptr_data) 406 { 407 struct pcmd_int_params *params = ptr_params; 408 int stat; 409 410 if (!rte_eth_dev_is_valid_port(params->port)) { 411 printf("Error: Invalid port number %i\n", params->port); 412 return; 413 } 414 lock_port(params->port); 415 stat = rte_ethtool_net_open(params->port); 416 mark_port_active(params->port); 417 unlock_port(params->port); 418 if (stat == 0) 419 return; 420 else if (stat == -ENOTSUP) 421 printf("Port %i: Operation not supported\n", params->port); 422 else 423 printf("Port %i: Error opening device\n", params->port); 424 } 425 426 static void 427 pcmd_stop_callback(__rte_unused void *ptr_params, 428 __rte_unused struct cmdline *ctx, 429 __rte_unused void *ptr_data) 430 { 431 struct pcmd_int_params *params = ptr_params; 432 int stat; 433 434 if (!rte_eth_dev_is_valid_port(params->port)) { 435 printf("Error: Invalid port number %i\n", params->port); 436 return; 437 } 438 lock_port(params->port); 439 stat = rte_ethtool_net_stop(params->port); 440 mark_port_inactive(params->port); 441 unlock_port(params->port); 442 if (stat == 0) 443 return; 444 else if (stat == -ENOTSUP) 445 printf("Port %i: Operation not supported\n", params->port); 446 else 447 printf("Port %i: Error stopping device\n", params->port); 448 } 449 450 451 static void 452 pcmd_rxmode_callback(void *ptr_params, 453 __rte_unused struct cmdline *ctx, 454 __rte_unused void *ptr_data) 455 { 456 struct pcmd_intstr_params *params = ptr_params; 457 int stat; 458 459 if (!rte_eth_dev_is_valid_port(params->port)) { 460 printf("Error: Invalid port number %i\n", params->port); 461 return; 462 } 463 stat = rte_ethtool_net_set_rx_mode(params->port); 464 if (stat == 0) 465 return; 466 else if (stat == -ENOTSUP) 467 printf("Port %i: Operation not supported\n", params->port); 468 else 469 printf("Port %i: Error setting rx mode\n", params->port); 470 } 471 472 473 static void 474 pcmd_macaddr_callback(void *ptr_params, 475 __rte_unused struct cmdline *ctx, 476 void *ptr_data) 477 { 478 struct pcmd_intmac_params *params = ptr_params; 479 struct rte_ether_addr mac_addr; 480 int stat; 481 482 stat = 0; 483 if (!rte_eth_dev_is_valid_port(params->port)) { 484 printf("Error: Invalid port number %i\n", params->port); 485 return; 486 } 487 if (ptr_data != NULL) { 488 lock_port(params->port); 489 stat = rte_ethtool_net_set_mac_addr(params->port, 490 ¶ms->mac); 491 mark_port_newmac(params->port); 492 unlock_port(params->port); 493 if (stat == 0) { 494 printf("MAC address changed\n"); 495 return; 496 } 497 } else { 498 stat = rte_ethtool_net_get_mac_addr(params->port, &mac_addr); 499 if (stat == 0) { 500 printf( 501 "Port %i MAC Address: %02x:%02x:%02x:%02x:%02x:%02x\n", 502 params->port, 503 mac_addr.addr_bytes[0], 504 mac_addr.addr_bytes[1], 505 mac_addr.addr_bytes[2], 506 mac_addr.addr_bytes[3], 507 mac_addr.addr_bytes[4], 508 mac_addr.addr_bytes[5]); 509 return; 510 } 511 } 512 513 printf("Port %i: Error %s\n", params->port, 514 strerror(-stat)); 515 } 516 517 static void 518 pcmd_mtu_callback(void *ptr_params, 519 __rte_unused struct cmdline *ctx, 520 __rte_unused void *ptr_data) 521 { 522 struct pcmd_intstr_params *params = ptr_params; 523 int stat; 524 int new_mtu; 525 char *ptr_parse_end; 526 527 if (!rte_eth_dev_is_valid_port(params->port)) { 528 printf("Error: Invalid port number %i\n", params->port); 529 return; 530 } 531 new_mtu = strtoul(params->opt, &ptr_parse_end, 10); 532 if (*ptr_parse_end != '\0' || 533 new_mtu < RTE_ETHER_MIN_MTU || 534 new_mtu > RTE_ETHER_MAX_JUMBO_FRAME_LEN) { 535 printf("Port %i: Invalid MTU value\n", params->port); 536 return; 537 } 538 stat = rte_ethtool_net_change_mtu(params->port, new_mtu); 539 if (stat == 0) 540 printf("Port %i: MTU set to %i\n", params->port, new_mtu); 541 else if (stat == -ENOTSUP) 542 printf("Port %i: Operation not supported\n", params->port); 543 else 544 printf("Port %i: Error setting MTU\n", params->port); 545 } 546 547 548 549 static void pcmd_portstats_callback(__rte_unused void *ptr_params, 550 __rte_unused struct cmdline *ctx, 551 __rte_unused void *ptr_data) 552 { 553 struct pcmd_int_params *params = ptr_params; 554 struct rte_eth_stats stat_info; 555 int stat; 556 557 if (!rte_eth_dev_is_valid_port(params->port)) { 558 printf("Error: Invalid port number %i\n", params->port); 559 return; 560 } 561 stat = rte_ethtool_net_get_stats64(params->port, &stat_info); 562 if (stat == 0) { 563 printf("Port %i stats\n", params->port); 564 printf(" In: %" PRIu64 " (%" PRIu64 " bytes)\n" 565 " Out: %"PRIu64" (%"PRIu64 " bytes)\n" 566 " Err: %"PRIu64"\n", 567 stat_info.ipackets, 568 stat_info.ibytes, 569 stat_info.opackets, 570 stat_info.obytes, 571 stat_info.ierrors+stat_info.oerrors 572 ); 573 } else if (stat == -ENOTSUP) 574 printf("Port %i: Operation not supported\n", params->port); 575 else 576 printf("Port %i: Error fetching statistics\n", params->port); 577 } 578 579 static void pcmd_ringparam_callback(__rte_unused void *ptr_params, 580 __rte_unused struct cmdline *ctx, 581 void *ptr_data) 582 { 583 struct pcmd_intintint_params *params = ptr_params; 584 struct ethtool_ringparam ring_data; 585 struct ethtool_ringparam ring_params; 586 int stat; 587 588 if (!rte_eth_dev_is_valid_port(params->port)) { 589 printf("Error: Invalid port number %i\n", params->port); 590 return; 591 } 592 if (ptr_data == NULL) { 593 stat = rte_ethtool_get_ringparam(params->port, &ring_data); 594 if (stat == 0) { 595 printf("Port %i ring parameters\n" 596 " Rx Pending: %i (%i max)\n" 597 " Tx Pending: %i (%i max)\n", 598 params->port, 599 ring_data.rx_pending, 600 ring_data.rx_max_pending, 601 ring_data.tx_pending, 602 ring_data.tx_max_pending); 603 } 604 } else { 605 if (params->tx < 1 || params->rx < 1) { 606 printf("Error: Invalid parameters\n"); 607 return; 608 } 609 memset(&ring_params, 0, sizeof(struct ethtool_ringparam)); 610 ring_params.tx_pending = params->tx; 611 ring_params.rx_pending = params->rx; 612 lock_port(params->port); 613 stat = rte_ethtool_set_ringparam(params->port, &ring_params); 614 unlock_port(params->port); 615 } 616 if (stat == 0) 617 return; 618 else if (stat == -ENOTSUP) 619 printf("Port %i: Operation not supported\n", params->port); 620 else 621 printf("Port %i: Error fetching statistics\n", params->port); 622 } 623 624 static void pcmd_validate_callback(void *ptr_params, 625 __rte_unused struct cmdline *ctx, 626 __rte_unused void *ptr_data) 627 { 628 struct pcmd_intmac_params *params = ptr_params; 629 630 if (rte_ethtool_net_validate_addr(0, ¶ms->mac)) 631 printf("Address is unicast\n"); 632 else 633 printf("Address is not unicast\n"); 634 } 635 636 637 static void pcmd_vlan_callback(__rte_unused void *ptr_params, 638 __rte_unused struct cmdline *ctx, 639 __rte_unused void *ptr_data) 640 { 641 struct pcmd_vlan_params *params = ptr_params; 642 int stat; 643 644 if (!rte_eth_dev_is_valid_port(params->port)) { 645 printf("Error: Invalid port number %i\n", params->port); 646 return; 647 } 648 stat = 0; 649 650 if (strcasecmp("add", params->mode) == 0) { 651 stat = rte_ethtool_net_vlan_rx_add_vid( 652 params->port, params->vid 653 ); 654 if (stat == 0) 655 printf("VLAN vid %i added\n", params->vid); 656 657 } else if (strcasecmp("del", params->mode) == 0) { 658 stat = rte_ethtool_net_vlan_rx_kill_vid( 659 params->port, params->vid 660 ); 661 if (stat == 0) 662 printf("VLAN vid %i removed\n", params->vid); 663 } else { 664 /* Should not happen! */ 665 printf("Error: Bad mode %s\n", params->mode); 666 } 667 if (stat == -ENOTSUP) 668 printf("Port %i: Operation not supported\n", params->port); 669 else if (stat == -ENOSYS) 670 printf("Port %i: VLAN filtering disabled\n", params->port); 671 else if (stat != 0) 672 printf("Port %i: Error changing VLAN setup (code %i)\n", 673 params->port, -stat); 674 } 675 676 677 cmdline_parse_inst_t pcmd_quit = { 678 .f = pcmd_quit_callback, 679 .data = NULL, 680 .help_str = "quit\n Exit program", 681 .tokens = {(void *)&pcmd_quit_token_cmd, NULL}, 682 }; 683 cmdline_parse_inst_t pcmd_drvinfo = { 684 .f = pcmd_drvinfo_callback, 685 .data = NULL, 686 .help_str = "drvinfo\n Print driver info", 687 .tokens = {(void *)&pcmd_drvinfo_token_cmd, NULL}, 688 }; 689 cmdline_parse_inst_t pcmd_link = { 690 .f = pcmd_link_callback, 691 .data = NULL, 692 .help_str = "link\n Print port link states", 693 .tokens = {(void *)&pcmd_link_token_cmd, NULL}, 694 }; 695 cmdline_parse_inst_t pcmd_regs = { 696 .f = pcmd_regs_callback, 697 .data = NULL, 698 .help_str = "regs <port_id> <filename>\n" 699 " Dump port register(s) to file", 700 .tokens = { 701 (void *)&pcmd_regs_token_cmd, 702 (void *)&pcmd_intstr_token_port, 703 (void *)&pcmd_intstr_token_opt, 704 NULL 705 }, 706 }; 707 cmdline_parse_inst_t pcmd_eeprom = { 708 .f = pcmd_eeprom_callback, 709 .data = NULL, 710 .help_str = "eeprom <port_id> <filename>\n Dump EEPROM to file", 711 .tokens = { 712 (void *)&pcmd_eeprom_token_cmd, 713 (void *)&pcmd_intstr_token_port, 714 (void *)&pcmd_intstr_token_opt, 715 NULL 716 }, 717 }; 718 cmdline_parse_inst_t pcmd_module_eeprom = { 719 .f = pcmd_module_eeprom_callback, 720 .data = NULL, 721 .help_str = "module-eeprom <port_id> <filename>\n" 722 " Dump plugin module EEPROM to file", 723 .tokens = { 724 (void *)&pcmd_module_eeprom_token_cmd, 725 (void *)&pcmd_intstr_token_port, 726 (void *)&pcmd_intstr_token_opt, 727 NULL 728 }, 729 }; 730 cmdline_parse_inst_t pcmd_pause_noopt = { 731 .f = pcmd_pause_callback, 732 .data = (void *)0x01, 733 .help_str = "pause <port_id>\n Print port pause state", 734 .tokens = { 735 (void *)&pcmd_pause_token_cmd, 736 (void *)&pcmd_pause_token_port, 737 NULL 738 }, 739 }; 740 cmdline_parse_inst_t pcmd_pause = { 741 .f = pcmd_pause_callback, 742 .data = NULL, 743 .help_str = 744 "pause <port_id> <all|tx|rx|none>\n Pause/unpause port", 745 .tokens = { 746 (void *)&pcmd_pause_token_cmd, 747 (void *)&pcmd_pause_token_port, 748 (void *)&pcmd_pause_token_opt, 749 NULL 750 }, 751 }; 752 cmdline_parse_inst_t pcmd_open = { 753 .f = pcmd_open_callback, 754 .data = NULL, 755 .help_str = "open <port_id>\n Open port", 756 .tokens = { 757 (void *)&pcmd_open_token_cmd, 758 (void *)&pcmd_int_token_port, 759 NULL 760 }, 761 }; 762 cmdline_parse_inst_t pcmd_stop = { 763 .f = pcmd_stop_callback, 764 .data = NULL, 765 .help_str = "stop <port_id>\n Stop port", 766 .tokens = { 767 (void *)&pcmd_stop_token_cmd, 768 (void *)&pcmd_int_token_port, 769 NULL 770 }, 771 }; 772 cmdline_parse_inst_t pcmd_rxmode = { 773 .f = pcmd_rxmode_callback, 774 .data = NULL, 775 .help_str = "rxmode <port_id>\n Toggle port Rx mode", 776 .tokens = { 777 (void *)&pcmd_rxmode_token_cmd, 778 (void *)&pcmd_int_token_port, 779 NULL 780 }, 781 }; 782 cmdline_parse_inst_t pcmd_macaddr_get = { 783 .f = pcmd_macaddr_callback, 784 .data = NULL, 785 .help_str = "macaddr <port_id>\n" 786 " Get MAC address", 787 .tokens = { 788 (void *)&pcmd_macaddr_token_cmd, 789 (void *)&pcmd_intstr_token_port, 790 NULL 791 }, 792 }; 793 cmdline_parse_inst_t pcmd_macaddr = { 794 .f = pcmd_macaddr_callback, 795 .data = (void *)0x01, 796 .help_str = 797 "macaddr <port_id> <mac_addr>\n" 798 " Set MAC address", 799 .tokens = { 800 (void *)&pcmd_macaddr_token_cmd, 801 (void *)&pcmd_intmac_token_port, 802 (void *)&pcmd_intmac_token_mac, 803 NULL 804 }, 805 }; 806 cmdline_parse_inst_t pcmd_mtu = { 807 .f = pcmd_mtu_callback, 808 .data = NULL, 809 .help_str = "mtu <port_id> <mtu_value>\n" 810 " Change MTU", 811 .tokens = { 812 (void *)&pcmd_mtu_token_cmd, 813 (void *)&pcmd_intstr_token_port, 814 (void *)&pcmd_intstr_token_opt, 815 NULL 816 }, 817 }; 818 cmdline_parse_inst_t pcmd_portstats = { 819 .f = pcmd_portstats_callback, 820 .data = NULL, 821 .help_str = "portstats <port_id>\n" 822 " Print port eth statistics", 823 .tokens = { 824 (void *)&pcmd_portstats_token_cmd, 825 (void *)&pcmd_int_token_port, 826 NULL 827 }, 828 }; 829 cmdline_parse_inst_t pcmd_ringparam = { 830 .f = pcmd_ringparam_callback, 831 .data = NULL, 832 .help_str = "ringparam <port_id>\n" 833 " Print ring parameters", 834 .tokens = { 835 (void *)&pcmd_ringparam_token_cmd, 836 (void *)&pcmd_intintint_token_port, 837 NULL 838 }, 839 }; 840 cmdline_parse_inst_t pcmd_ringparam_set = { 841 .f = pcmd_ringparam_callback, 842 .data = (void *)1, 843 .help_str = "ringparam <port_id> <tx_param> <rx_param>\n" 844 " Set ring parameters", 845 .tokens = { 846 (void *)&pcmd_ringparam_token_cmd, 847 (void *)&pcmd_intintint_token_port, 848 (void *)&pcmd_intintint_token_tx, 849 (void *)&pcmd_intintint_token_rx, 850 NULL 851 }, 852 }; 853 cmdline_parse_inst_t pcmd_validate = { 854 .f = pcmd_validate_callback, 855 .data = NULL, 856 .help_str = "validate <mac_addr>\n" 857 " Check that MAC address is valid unicast address", 858 .tokens = { 859 (void *)&pcmd_validate_token_cmd, 860 (void *)&pcmd_intmac_token_mac, 861 NULL 862 }, 863 }; 864 cmdline_parse_inst_t pcmd_vlan = { 865 .f = pcmd_vlan_callback, 866 .data = NULL, 867 .help_str = "vlan <port_id> <add|del> <vlan_id>\n" 868 " Add/remove VLAN id", 869 .tokens = { 870 (void *)&pcmd_vlan_token_cmd, 871 (void *)&pcmd_vlan_token_port, 872 (void *)&pcmd_vlan_token_mode, 873 (void *)&pcmd_vlan_token_vid, 874 NULL 875 }, 876 }; 877 878 879 cmdline_parse_ctx_t list_prompt_commands[] = { 880 (cmdline_parse_inst_t *)&pcmd_drvinfo, 881 (cmdline_parse_inst_t *)&pcmd_eeprom, 882 (cmdline_parse_inst_t *)&pcmd_module_eeprom, 883 (cmdline_parse_inst_t *)&pcmd_link, 884 (cmdline_parse_inst_t *)&pcmd_macaddr_get, 885 (cmdline_parse_inst_t *)&pcmd_macaddr, 886 (cmdline_parse_inst_t *)&pcmd_mtu, 887 (cmdline_parse_inst_t *)&pcmd_open, 888 (cmdline_parse_inst_t *)&pcmd_pause_noopt, 889 (cmdline_parse_inst_t *)&pcmd_pause, 890 (cmdline_parse_inst_t *)&pcmd_portstats, 891 (cmdline_parse_inst_t *)&pcmd_regs, 892 (cmdline_parse_inst_t *)&pcmd_ringparam, 893 (cmdline_parse_inst_t *)&pcmd_ringparam_set, 894 (cmdline_parse_inst_t *)&pcmd_rxmode, 895 (cmdline_parse_inst_t *)&pcmd_stop, 896 (cmdline_parse_inst_t *)&pcmd_validate, 897 (cmdline_parse_inst_t *)&pcmd_vlan, 898 (cmdline_parse_inst_t *)&pcmd_quit, 899 NULL 900 }; 901 902 903 void ethapp_main(void) 904 { 905 struct cmdline *ctx_cmdline; 906 907 ctx_cmdline = cmdline_stdin_new(list_prompt_commands, "EthApp> "); 908 cmdline_interact(ctx_cmdline); 909 cmdline_stdin_exit(ctx_cmdline); 910 } 911