bond: testpmd support

 - Includes the ability to create new bonded devices.
 - Add /remove bonding slave devices.
 - Interogate bonded device stats/configuration
 - Change bonding modes and select balance transmit polices

Signed-off-by: Declan Doherty <declan.doherty@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index f61a31c..345be11 100644 (file)
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -84,6 +84,9 @@
 #include <cmdline_socket.h>
 #include <cmdline.h>
 #include <rte_pci_dev_ids.h>
+#ifdef RTE_LIBRTE_PMD_BOND
+#include <rte_eth_bond.h>
+#endif
 
 #include "testpmd.h"
 
@@ -412,6 +415,31 @@ static void cmd_help_long_parsed(void *parsed_result,
                        "   Show the bypass configuration for a bypass enabled NIC"
                        " using the lowest port on the NIC.\n\n"
 #endif
+#ifdef RTE_LIBRTE_PMD_BOND
+                       "create bonded device (mode) (socket)\n"
+                       "       Create a new bonded device with specific bonding mode and socket.\n\n"
+
+                       "add bonding slave (slave_id) (port_id)\n"
+                       "       Add a slave device to a bonded device.\n\n"
+
+                       "remove bonding slave (slave_id) (port_id)\n"
+                       "       Remove a slave device from a bonded device.\n\n"
+
+                       "set bonding mode (value) (port_id)\n"
+                       "       Set the bonding mode on a bonded device.\n\n"
+
+                       "set bonding primary (slave_id) (port_id)\n"
+                       "       Set the primary slave for a bonded device.\n\n"
+
+                       "show bonding config (port_id)\n"
+                       "       Show the bonding config for port_id.\n\n"
+
+                       "set bonding mac_addr (port_id) (address)\n"
+                       "       Set the MAC address of a bonded device.\n\n"
+
+                       "set bonding xmit_balance_policy (port_id) (l2|l23|l34)\n"
+                       "       Set the transmit balance policy for bonded device running in balance mode.\n\n"
+#endif
 
                        , list_pkt_forwarding_modes()
                );
@@ -3039,6 +3067,547 @@ cmdline_parse_inst_t cmd_show_bypass_config = {
 };
 #endif
 
+#ifdef RTE_LIBRTE_PMD_BOND
+/* *** SET BONDING MODE *** */
+struct cmd_set_bonding_mode_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t mode;
+       uint8_t value;
+       uint8_t port_id;
+};
+
+static void cmd_set_bonding_mode_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_set_bonding_mode_result *res = parsed_result;
+       portid_t port_id = res->port_id;
+
+       /* Set the bonding mode for the relevant port. */
+       if (0 != rte_eth_bond_mode_set(port_id, res->value))
+               printf("\t Failed to set bonding mode for port = %d.\n", port_id);
+}
+
+cmdline_parse_token_string_t cmd_setbonding_mode_set =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
+               set, "set");
+cmdline_parse_token_string_t cmd_setbonding_mode_bonding =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
+               bonding, "bonding");
+cmdline_parse_token_string_t cmd_setbonding_mode_mode =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
+               mode, "mode");
+cmdline_parse_token_num_t cmd_setbonding_mode_value =
+TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
+               value, UINT8);
+cmdline_parse_token_num_t cmd_setbonding_mode_port =
+TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
+               port_id, UINT8);
+
+cmdline_parse_inst_t cmd_set_bonding_mode = {
+               .f = cmd_set_bonding_mode_parsed,
+               .help_str = "set bonding mode (mode_value) (port_id): Set the bonding mode for port_id",
+               .data = NULL,
+               .tokens = {
+                               (void *) &cmd_setbonding_mode_set,
+                               (void *) &cmd_setbonding_mode_bonding,
+                               (void *) &cmd_setbonding_mode_mode,
+                               (void *) &cmd_setbonding_mode_value,
+                               (void *) &cmd_setbonding_mode_port,
+                               NULL
+               }
+};
+
+/* *** SET BALANCE XMIT POLICY *** */
+struct cmd_set_bonding_balance_xmit_policy_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t balance_xmit_policy;
+       uint8_t port_id;
+       cmdline_fixed_string_t policy;
+};
+
+static void cmd_set_bonding_balance_xmit_policy_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_set_bonding_balance_xmit_policy_result *res = parsed_result;
+       portid_t port_id = res->port_id;
+       uint8_t policy;
+
+       if (!strcmp(res->policy, "l2")) {
+               policy = BALANCE_XMIT_POLICY_LAYER2;
+       } else if (!strcmp(res->policy, "l23")) {
+               policy = BALANCE_XMIT_POLICY_LAYER23;
+       } else if (!strcmp(res->policy, "l34")) {
+               policy = BALANCE_XMIT_POLICY_LAYER34;
+       } else {
+               printf("\t Invalid xmit policy selection");
+               return;
+       }
+
+       /* Set the bonding mode for the relevant port. */
+       if (0 != rte_eth_bond_xmit_policy_set(port_id, policy)) {
+               printf("\t Failed to set bonding balance xmit policy for port = %d.\n",
+                               port_id);
+       }
+}
+
+cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_set =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
+               set, "set");
+cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_bonding =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
+               bonding, "bonding");
+cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_balance_xmit_policy =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
+               balance_xmit_policy, "balance_xmit_policy");
+cmdline_parse_token_num_t cmd_setbonding_balance_xmit_policy_port =
+TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
+               port_id, UINT8);
+cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_policy =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
+               policy, "l2#l23#l34");
+
+cmdline_parse_inst_t cmd_set_balance_xmit_policy = {
+               .f = cmd_set_bonding_balance_xmit_policy_parsed,
+               .help_str = "set bonding balance_xmit_policy (port_id) (policy_value): Set the bonding balance_xmit_policy for port_id",
+               .data = NULL,
+               .tokens = {
+                               (void *)&cmd_setbonding_balance_xmit_policy_set,
+                               (void *)&cmd_setbonding_balance_xmit_policy_bonding,
+                               (void *)&cmd_setbonding_balance_xmit_policy_balance_xmit_policy,
+                               (void *)&cmd_setbonding_balance_xmit_policy_port,
+                               (void *)&cmd_setbonding_balance_xmit_policy_policy,
+                               NULL
+               }
+};
+
+/* *** SHOW NIC BONDING CONFIGURATION *** */
+struct cmd_show_bonding_config_result {
+       cmdline_fixed_string_t show;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t config;
+       uint8_t port_id;
+};
+
+static void cmd_show_bonding_config_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_show_bonding_config_result *res = parsed_result;
+       int bonding_mode;
+       uint8_t slaves[RTE_MAX_ETHPORTS];
+       int num_slaves, num_active_slaves;
+       int primary_id;
+       int i;
+       portid_t port_id = res->port_id;
+
+       /* Display the bonding mode.*/
+       bonding_mode = rte_eth_bond_mode_get(port_id);
+       if (bonding_mode < 0) {
+               printf("\tFailed to get bonding mode for port = %d\n", port_id);
+               return;
+       } else
+               printf("\tBonding mode: %d\n", bonding_mode);
+
+       if (bonding_mode == BONDING_MODE_BALANCE) {
+               int balance_xmit_policy;
+
+               balance_xmit_policy = rte_eth_bond_xmit_policy_get(port_id);
+               if (balance_xmit_policy < 0) {
+                       printf("\tFailed to get balance xmit policy for port = %d\n",
+                                       port_id);
+                       return;
+               } else {
+                       printf("\tBalance Xmit Policy: ");
+
+                       switch (balance_xmit_policy) {
+                       case BALANCE_XMIT_POLICY_LAYER2:
+                               printf("BALANCE_XMIT_POLICY_LAYER2");
+                               break;
+                       case BALANCE_XMIT_POLICY_LAYER23:
+                               printf("BALANCE_XMIT_POLICY_LAYER23");
+                               break;
+                       case BALANCE_XMIT_POLICY_LAYER34:
+                               printf("BALANCE_XMIT_POLICY_LAYER34");
+                               break;
+                       }
+                       printf("\n");
+               }
+       }
+
+       num_slaves = rte_eth_bond_slaves_get(port_id, slaves, RTE_MAX_ETHPORTS);
+
+       if (num_slaves < 0) {
+               printf("\tFailed to get slave list for port = %d\n", port_id);
+               return;
+       }
+       if (num_slaves > 0) {
+               printf("\tSlaves (%d): [", num_slaves);
+               for (i = 0; i < num_slaves - 1; i++)
+                       printf("%d ", slaves[i]);
+
+               printf("%d]\n", slaves[num_slaves - 1]);
+       } else {
+               printf("\tSlaves: []\n");
+
+       }
+
+       num_active_slaves = rte_eth_bond_active_slaves_get(port_id, slaves,
+                       RTE_MAX_ETHPORTS);
+
+       if (num_active_slaves < 0) {
+               printf("\tFailed to get active slave list for port = %d\n", port_id);
+               return;
+       }
+       if (num_active_slaves > 0) {
+               printf("\tActive Slaves (%d): [", num_active_slaves);
+               for (i = 0; i < num_active_slaves - 1; i++)
+                       printf("%d ", slaves[i]);
+
+               printf("%d]\n", slaves[num_active_slaves - 1]);
+
+       } else {
+               printf("\tActive Slaves: []\n");
+
+       }
+
+       primary_id = rte_eth_bond_primary_get(port_id);
+       if (primary_id < 0) {
+               printf("\tFailed to get primary slave for port = %d\n", port_id);
+               return;
+       } else
+               printf("\tPrimary: [%d]\n", primary_id);
+
+}
+
+cmdline_parse_token_string_t cmd_showbonding_config_show =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
+               show, "show");
+cmdline_parse_token_string_t cmd_showbonding_config_bonding =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
+               bonding, "bonding");
+cmdline_parse_token_string_t cmd_showbonding_config_config =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
+               config, "config");
+cmdline_parse_token_num_t cmd_showbonding_config_port =
+TOKEN_NUM_INITIALIZER(struct cmd_show_bonding_config_result,
+               port_id, UINT8);
+
+cmdline_parse_inst_t cmd_show_bonding_config = {
+               .f = cmd_show_bonding_config_parsed,
+               .help_str =     "show bonding config (port_id): Show the bonding config for port_id",
+               .data = NULL,
+               .tokens = {
+                               (void *)&cmd_showbonding_config_show,
+                               (void *)&cmd_showbonding_config_bonding,
+                               (void *)&cmd_showbonding_config_config,
+                               (void *)&cmd_showbonding_config_port,
+                               NULL
+               }
+};
+
+/* *** SET BONDING PRIMARY *** */
+struct cmd_set_bonding_primary_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t primary;
+       uint8_t slave_id;
+       uint8_t port_id;
+};
+
+static void cmd_set_bonding_primary_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_set_bonding_primary_result *res = parsed_result;
+       portid_t master_port_id = res->port_id;
+       portid_t slave_port_id = res->slave_id;
+
+       /* Set the primary slave for a bonded device. */
+       if (0 != rte_eth_bond_primary_set(master_port_id, slave_port_id)) {
+               printf("\t Failed to set primary slave for port = %d.\n",
+                               master_port_id);
+               return;
+       }
+       init_port_config();
+}
+
+cmdline_parse_token_string_t cmd_setbonding_primary_set =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
+               set, "set");
+cmdline_parse_token_string_t cmd_setbonding_primary_bonding =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
+               bonding, "bonding");
+cmdline_parse_token_string_t cmd_setbonding_primary_primary =
+TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
+               primary, "primary");
+cmdline_parse_token_num_t cmd_setbonding_primary_slave =
+TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
+               slave_id, UINT8);
+cmdline_parse_token_num_t cmd_setbonding_primary_port =
+TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
+               port_id, UINT8);
+
+cmdline_parse_inst_t cmd_set_bonding_primary = {
+               .f = cmd_set_bonding_primary_parsed,
+               .help_str = "set bonding primary (slave_id) (port_id): Set the primary slave for port_id",
+               .data = NULL,
+               .tokens = {
+                               (void *)&cmd_setbonding_primary_set,
+                               (void *)&cmd_setbonding_primary_bonding,
+                               (void *)&cmd_setbonding_primary_primary,
+                               (void *)&cmd_setbonding_primary_slave,
+                               (void *)&cmd_setbonding_primary_port,
+                               NULL
+               }
+};
+
+/* *** ADD SLAVE *** */
+struct cmd_add_bonding_slave_result {
+       cmdline_fixed_string_t add;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t slave;
+       uint8_t slave_id;
+       uint8_t port_id;
+};
+
+static void cmd_add_bonding_slave_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_add_bonding_slave_result *res = parsed_result;
+       portid_t master_port_id = res->port_id;
+       portid_t slave_port_id = res->slave_id;
+
+       /* Set the primary slave for a bonded device. */
+       if (0 != rte_eth_bond_slave_add(master_port_id, slave_port_id)) {
+               printf("\t Failed to add slave %d to master port = %d.\n",
+                               slave_port_id, master_port_id);
+               return;
+       }
+       init_port_config();
+}
+
+cmdline_parse_token_string_t cmd_addbonding_slave_add =
+TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
+               add, "add");
+cmdline_parse_token_string_t cmd_addbonding_slave_bonding =
+TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
+               bonding, "bonding");
+cmdline_parse_token_string_t cmd_addbonding_slave_slave =
+TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
+               slave, "slave");
+cmdline_parse_token_num_t cmd_addbonding_slave_slaveid =
+TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
+               slave_id, UINT8);
+cmdline_parse_token_num_t cmd_addbonding_slave_port =
+TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
+               port_id, UINT8);
+
+cmdline_parse_inst_t cmd_add_bonding_slave = {
+               .f = cmd_add_bonding_slave_parsed,
+               .help_str = "add bonding slave (slave_id) (port_id): Add a slave device to a bonded device",
+               .data = NULL,
+               .tokens = {
+                               (void *)&cmd_addbonding_slave_add,
+                               (void *)&cmd_addbonding_slave_bonding,
+                               (void *)&cmd_addbonding_slave_slave,
+                               (void *)&cmd_addbonding_slave_slaveid,
+                               (void *)&cmd_addbonding_slave_port,
+                               NULL
+               }
+};
+
+/* *** REMOVE SLAVE *** */
+struct cmd_remove_bonding_slave_result {
+       cmdline_fixed_string_t remove;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t slave;
+       uint8_t slave_id;
+       uint8_t port_id;
+};
+
+static void cmd_remove_bonding_slave_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_remove_bonding_slave_result *res = parsed_result;
+       portid_t master_port_id = res->port_id;
+       portid_t slave_port_id = res->slave_id;
+
+       /* Set the primary slave for a bonded device. */
+       if (0 != rte_eth_bond_slave_remove(master_port_id, slave_port_id)) {
+               printf("\t Failed to remove slave %d from master port = %d.\n",
+                               slave_port_id, master_port_id);
+               return;
+       }
+       init_port_config();
+}
+
+cmdline_parse_token_string_t cmd_removebonding_slave_remove =
+               TOKEN_STRING_INITIALIZER(struct cmd_remove_bonding_slave_result,
+                               remove, "remove");
+cmdline_parse_token_string_t cmd_removebonding_slave_bonding =
+               TOKEN_STRING_INITIALIZER(struct cmd_remove_bonding_slave_result,
+                               bonding, "bonding");
+cmdline_parse_token_string_t cmd_removebonding_slave_slave =
+               TOKEN_STRING_INITIALIZER(struct cmd_remove_bonding_slave_result,
+                               slave, "slave");
+cmdline_parse_token_num_t cmd_removebonding_slave_slaveid =
+               TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
+                               slave_id, UINT8);
+cmdline_parse_token_num_t cmd_removebonding_slave_port =
+               TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
+                               port_id, UINT8);
+
+cmdline_parse_inst_t cmd_remove_bonding_slave = {
+               .f = cmd_remove_bonding_slave_parsed,
+               .help_str = "remove bonding slave (slave_id) (port_id): Remove a slave device from a bonded device",
+               .data = NULL,
+               .tokens = {
+                               (void *)&cmd_removebonding_slave_remove,
+                               (void *)&cmd_removebonding_slave_bonding,
+                               (void *)&cmd_removebonding_slave_slave,
+                               (void *)&cmd_removebonding_slave_slaveid,
+                               (void *)&cmd_removebonding_slave_port,
+                               NULL
+               }
+};
+
+/* *** CREATE BONDED DEVICE *** */
+struct cmd_create_bonded_device_result {
+       cmdline_fixed_string_t create;
+       cmdline_fixed_string_t bonded;
+       cmdline_fixed_string_t device;
+       uint8_t mode;
+       uint8_t socket;
+};
+
+static int bond_dev_num = 0;
+
+static void cmd_create_bonded_device_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_create_bonded_device_result *res = parsed_result;
+       char ethdev_name[RTE_ETH_NAME_MAX_LEN];
+       int port_id;
+
+       if (test_done == 0) {
+               printf("Please stop forwarding first\n");
+               return;
+       }
+
+       snprintf(ethdev_name, RTE_ETH_NAME_MAX_LEN, "eth_bond_testpmd_%d",
+                       bond_dev_num++);
+
+       /* Create a new bonded device. */
+       port_id = rte_eth_bond_create(ethdev_name, res->mode, res->socket);
+       if (port_id < 0) {
+               printf("\t Failed to create bonded device.\n");
+               return;
+       } else {
+               printf("Created new bonded device %s on (port %d).\n", ethdev_name,
+                               port_id);
+
+               /* Update number of ports */
+               nb_ports = rte_eth_dev_count();
+               reconfig(port_id);
+               rte_eth_promiscuous_enable(port_id);
+       }
+
+}
+
+cmdline_parse_token_string_t cmd_createbonded_device_create =
+               TOKEN_STRING_INITIALIZER(struct cmd_create_bonded_device_result,
+                               create, "create");
+cmdline_parse_token_string_t cmd_createbonded_device_bonded =
+               TOKEN_STRING_INITIALIZER(struct cmd_create_bonded_device_result,
+                               bonded, "bonded");
+cmdline_parse_token_string_t cmd_createbonded_device_device =
+               TOKEN_STRING_INITIALIZER(struct cmd_create_bonded_device_result,
+                               device, "device");
+cmdline_parse_token_num_t cmd_createbonded_device_mode =
+               TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
+                               mode, UINT8);
+cmdline_parse_token_num_t cmd_createbonded_device_socket =
+               TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
+                               socket, UINT8);
+
+cmdline_parse_inst_t cmd_create_bonded_device = {
+               .f = cmd_create_bonded_device_parsed,
+               .help_str = "create bonded device (mode) (socket): Create a new bonded device with specific bonding mode and socket",
+               .data = NULL,
+               .tokens = {
+                               (void *)&cmd_createbonded_device_create,
+                               (void *)&cmd_createbonded_device_bonded,
+                               (void *)&cmd_createbonded_device_device,
+                               (void *)&cmd_createbonded_device_mode,
+                               (void *)&cmd_createbonded_device_socket,
+                               NULL
+               }
+};
+
+/* *** SET MAC ADDRESS IN BONDED DEVICE *** */
+struct cmd_set_bond_mac_addr_result {
+       cmdline_fixed_string_t set;
+       cmdline_fixed_string_t bonding;
+       cmdline_fixed_string_t mac_addr;
+       uint8_t port_num;
+       struct ether_addr address;
+};
+
+static void cmd_set_bond_mac_addr_parsed(void *parsed_result,
+               __attribute__((unused))  struct cmdline *cl,
+               __attribute__((unused)) void *data)
+{
+       struct cmd_set_bond_mac_addr_result *res = parsed_result;
+       int ret;
+
+       if (res->port_num >= nb_ports) {
+               printf("Port id %d must be less than %d\n", res->port_num, nb_ports);
+               return;
+       }
+
+       ret = rte_eth_bond_mac_address_set(res->port_num, &res->address);
+
+       /* check the return value and print it if is < 0 */
+       if (ret < 0)
+               printf("set_bond_mac_addr error: (%s)\n", strerror(-ret));
+}
+
+cmdline_parse_token_string_t cmd_set_bond_mac_addr_set =
+               TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mac_addr_result, set, "set");
+cmdline_parse_token_string_t cmd_set_bond_mac_addr_bonding =
+               TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mac_addr_result, bonding,
+                               "bonding");
+cmdline_parse_token_string_t cmd_set_bond_mac_addr_mac =
+               TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mac_addr_result, mac_addr,
+                               "mac_addr");
+cmdline_parse_token_num_t cmd_set_bond_mac_addr_portnum =
+               TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mac_addr_result, port_num, UINT8);
+cmdline_parse_token_etheraddr_t cmd_set_bond_mac_addr_addr =
+               TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_bond_mac_addr_result, address);
+
+cmdline_parse_inst_t cmd_set_bond_mac_addr = {
+               .f = cmd_set_bond_mac_addr_parsed,
+               .data = (void *) 0,
+               .help_str = "set bonding mac_addr (port_id) (address): ",
+               .tokens = {
+                               (void *)&cmd_set_bond_mac_addr_set,
+                               (void *)&cmd_set_bond_mac_addr_bonding,
+                               (void *)&cmd_set_bond_mac_addr_mac,
+                               (void *)&cmd_set_bond_mac_addr_portnum,
+                               (void *)&cmd_set_bond_mac_addr_addr,
+                               NULL
+               }
+};
+
+#endif /* RTE_LIBRTE_PMD_BOND */
+
 /* *** SET FORWARDING MODE *** */
 struct cmd_set_fwd_mode_result {
        cmdline_fixed_string_t set;
@@ -6767,6 +7336,16 @@ cmdline_parse_ctx_t main_ctx[] = {
        (cmdline_parse_inst_t *)&cmd_set_bypass_event,
        (cmdline_parse_inst_t *)&cmd_set_bypass_timeout,
        (cmdline_parse_inst_t *)&cmd_show_bypass_config,
+#endif
+#ifdef RTE_LIBRTE_PMD_BOND
+       (cmdline_parse_inst_t *) &cmd_set_bonding_mode,
+       (cmdline_parse_inst_t *) &cmd_show_bonding_config,
+       (cmdline_parse_inst_t *) &cmd_set_bonding_primary,
+       (cmdline_parse_inst_t *) &cmd_add_bonding_slave,
+       (cmdline_parse_inst_t *) &cmd_remove_bonding_slave,
+       (cmdline_parse_inst_t *) &cmd_create_bonded_device,
+       (cmdline_parse_inst_t *) &cmd_set_bond_mac_addr,
+       (cmdline_parse_inst_t *) &cmd_set_balance_xmit_policy,
 #endif
        (cmdline_parse_inst_t *)&cmd_vlan_offload,
        (cmdline_parse_inst_t *)&cmd_vlan_tpid,

diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index 32f2134..c72f6ee 100644 (file)
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -252,6 +252,7 @@ void
 port_infos_display(portid_t port_id)
 {
        struct rte_port *port;
+       struct ether_addr mac_addr;
        struct rte_eth_link link;
        int vlan_offload;
        struct rte_mempool * mp;
@@ -265,7 +266,8 @@ port_infos_display(portid_t port_id)
        rte_eth_link_get_nowait(port_id, &link);
        printf("\n%s Infos for port %-2d %s\n",
               info_border, port_id, info_border);
-       print_ethaddr("MAC address: ", &port->eth_addr);
+       rte_eth_macaddr_get(port_id, &mac_addr);
+       print_ethaddr("MAC address: ", &mac_addr);
        printf("\nConnect to socket: %u", port->socket_id);
 
        if (port_numa[port_id] != NUMA_NO_CONFIG) {

diff --git a/app/test-pmd/parameters.c b/app/test-pmd/parameters.c
index 4bca0b0..9573a43 100644 (file)
--- a/app/test-pmd/parameters.c
+++ b/app/test-pmd/parameters.c
@@ -75,6 +75,9 @@
 #include <cmdline_parse.h>
 #include <cmdline_parse_etheraddr.h>
 #endif
+#ifdef RTE_LIBRTE_PMD_BOND
+#include <rte_eth_bond.h>
+#endif
 
 #include "testpmd.h"
 

diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
index 16fe596..e8a4b45 100644 (file)
--- a/app/test-pmd/testpmd.c
+++ b/app/test-pmd/testpmd.c
@@ -300,7 +300,7 @@ struct rte_fdir_conf fdir_conf = {
        .drop_queue = 127,
 };
 
-static volatile int test_done = 1; /* stop packet forwarding when set to 1. */
+volatile int test_done = 1; /* stop packet forwarding when set to 1. */
 
 struct queue_stats_mappings tx_queue_stats_mappings_array[MAX_TX_QUEUE_STATS_MAPPINGS];
 struct queue_stats_mappings rx_queue_stats_mappings_array[MAX_RX_QUEUE_STATS_MAPPINGS];
@@ -625,6 +625,32 @@ init_config(void)
                rte_exit(EXIT_FAILURE, "FAIL from init_fwd_streams()\n");
 }
 
+
+void
+reconfig(portid_t new_port_id)
+{
+       struct rte_port *port;
+
+       /* Reconfiguration of Ethernet ports. */
+       ports = rte_realloc(ports,
+                           sizeof(struct rte_port) * nb_ports,
+                           CACHE_LINE_SIZE);
+       if (ports == NULL) {
+               rte_exit(EXIT_FAILURE, "rte_realloc(%d struct rte_port) failed\n",
+                               nb_ports);
+       }
+
+       port = &ports[new_port_id];
+       rte_eth_dev_info_get(new_port_id, &port->dev_info);
+
+       /* set flag to initialize port/queue */
+       port->need_reconfig = 1;
+       port->need_reconfig_queues = 1;
+
+       init_port_config();
+}
+
+
 int
 init_fwd_streams(void)
 {
@@ -1252,7 +1278,7 @@ start_port(portid_t pid)
        portid_t pi;
        queueid_t qi;
        struct rte_port *port;
-       uint8_t *mac_addr;
+       struct ether_addr mac_addr;
 
        if (test_done == 0) {
                printf("Please stop forwarding first\n");
@@ -1380,10 +1406,11 @@ start_port(portid_t pid)
                        RTE_PORT_HANDLING, RTE_PORT_STARTED) == 0)
                        printf("Port %d can not be set into started\n", pi);
 
-               mac_addr = port->eth_addr.addr_bytes;
+               rte_eth_macaddr_get(pi, &mac_addr);
                printf("Port %d: %02X:%02X:%02X:%02X:%02X:%02X\n", pi,
-                      mac_addr[0], mac_addr[1], mac_addr[2],
-                      mac_addr[3], mac_addr[4], mac_addr[5]);
+                               mac_addr.addr_bytes[0], mac_addr.addr_bytes[1],
+                               mac_addr.addr_bytes[2], mac_addr.addr_bytes[3],
+                               mac_addr.addr_bytes[4], mac_addr.addr_bytes[5]);
 
                /* at least one port started, need checking link status */
                need_check_link_status = 1;
@@ -1826,9 +1853,6 @@ main(int argc, char** argv)
        if (diag < 0)
                rte_panic("Cannot init EAL\n");
 
-       if (rte_eal_pci_probe())
-               rte_panic("Cannot probe PCI\n");
-
        nb_ports = (portid_t) rte_eth_dev_count();
        if (nb_ports == 0)
                rte_exit(EXIT_FAILURE, "No probed ethernet devices - "

diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
index e263616..ac86bfe 100644 (file)
--- a/app/test-pmd/testpmd.h
+++ b/app/test-pmd/testpmd.h
@@ -281,6 +281,7 @@ extern uint16_t port_topology; /**< set by "--port-topology" parameter */
 extern uint8_t no_flush_rx; /**<set by "--no-flush-rx" parameter */
 extern uint8_t  mp_anon; /**< set by "--mp-anon" parameter */
 extern uint8_t no_link_check; /**<set by "--disable-link-check" parameter */
+extern volatile int test_done; /* stop packet forwarding when set to 1. */
 
 #ifdef RTE_NIC_BYPASS
 extern uint32_t bypass_timeout; /**< Store the NIC bypass watchdog timeout */
@@ -454,6 +455,7 @@ void fwd_config_display(void);
 void rxtx_config_display(void);
 void fwd_config_setup(void);
 void set_def_fwd_config(void);
+void reconfig(portid_t new_port_id);
 int init_fwd_streams(void);
 
 void port_mtu_set(portid_t port_id, uint16_t mtu);