examples/ethtool/ethtool-app/ethapp.c

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