X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fbonding%2Fcli.c;h=66aaa2e3816c8669d6dc519e476e2ea4e2cb80f5;hb=07063b8ea;hp=b2d66f9f1c868e62fd0b68e0bca7f3ecd1f39b87;hpb=9cd2d7a5a4fafadb65d772c48109d55d1e19d425;p=vpp.git diff --git a/src/vnet/bonding/cli.c b/src/vnet/bonding/cli.c index b2d66f9f1c8..66aaa2e3816 100644 --- a/src/vnet/bonding/cli.c +++ b/src/vnet/bonding/cli.c @@ -20,39 +20,157 @@ #include #include #include +#include void bond_disable_collecting_distributing (vlib_main_t * vm, slave_if_t * sif) { + bond_main_t *bm = &bond_main; bond_if_t *bif; int i; uword p; + u8 switching_active = 0; bif = bond_get_master_by_dev_instance (sif->bif_dev_instance); + clib_spinlock_lock_if_init (&bif->lockp); vec_foreach_index (i, bif->active_slaves) { p = *vec_elt_at_index (bif->active_slaves, i); if (p == sif->sw_if_index) { + if ((bif->mode == BOND_MODE_ACTIVE_BACKUP) && (i == 0) && + (vec_len (bif->active_slaves) > 1)) + /* deleting the active slave for active-backup */ + switching_active = 1; vec_del1 (bif->active_slaves, i); - hash_unset (bif->active_slave_by_sw_if_index, sif->sw_if_index); + if (sif->lacp_enabled && bif->numa_only) + { + /* For lacp mode, if we check it is a slave on local numa node, + bif->n_numa_slaves should be decreased by 1 becasue the first + bif->n_numa_slaves are all slaves on local numa node */ + if (i < bif->n_numa_slaves) + { + bif->n_numa_slaves--; + ASSERT (bif->n_numa_slaves >= 0); + } + } break; } } + + /* We get a new slave just becoming active */ + if (switching_active) + vlib_process_signal_event (bm->vlib_main, bond_process_node.index, + BOND_SEND_GARP_NA, bif->hw_if_index); + clib_spinlock_unlock_if_init (&bif->lockp); +} + +/* + * return 1 if s2 is preferred. + * return -1 if s1 is preferred. + */ +static int +bond_slave_sort (void *a1, void *a2) +{ + u32 *s1 = a1; + u32 *s2 = a2; + slave_if_t *sif1 = bond_get_slave_by_sw_if_index (*s1); + slave_if_t *sif2 = bond_get_slave_by_sw_if_index (*s2); + bond_if_t *bif; + + ALWAYS_ASSERT (sif1); + ALWAYS_ASSERT (sif2); + /* + * sort entries according to preference rules: + * 1. biggest weight + * 2. numa-node + * 3. current active slave (to prevent churning) + * 4. lowest sw_if_index (for deterministic behavior) + * + */ + if (sif2->weight > sif1->weight) + return 1; + if (sif2->weight < sif1->weight) + return -1; + else + { + if (sif2->is_local_numa > sif1->is_local_numa) + return 1; + if (sif2->is_local_numa < sif1->is_local_numa) + return -1; + else + { + bif = bond_get_master_by_dev_instance (sif1->bif_dev_instance); + /* Favor the current active slave to avoid churning */ + if (bif->active_slaves[0] == sif2->sw_if_index) + return 1; + if (bif->active_slaves[0] == sif1->sw_if_index) + return -1; + /* go for the tiebreaker as the last resort */ + if (sif1->sw_if_index > sif2->sw_if_index) + return 1; + if (sif1->sw_if_index < sif2->sw_if_index) + return -1; + else + ASSERT (0); + } + } + return 0; +} + +static void +bond_sort_slaves (bond_if_t * bif) +{ + bond_main_t *bm = &bond_main; + u32 old_active = bif->active_slaves[0]; + + vec_sort_with_function (bif->active_slaves, bond_slave_sort); + if (old_active != bif->active_slaves[0]) + vlib_process_signal_event (bm->vlib_main, bond_process_node.index, + BOND_SEND_GARP_NA, bif->hw_if_index); } void bond_enable_collecting_distributing (vlib_main_t * vm, slave_if_t * sif) { bond_if_t *bif; + bond_main_t *bm = &bond_main; + vnet_main_t *vnm = vnet_get_main (); + vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sif->sw_if_index); + int i; + uword p; bif = bond_get_master_by_dev_instance (sif->bif_dev_instance); - if (!hash_get (bif->active_slave_by_sw_if_index, sif->sw_if_index)) + clib_spinlock_lock_if_init (&bif->lockp); + vec_foreach_index (i, bif->active_slaves) + { + p = *vec_elt_at_index (bif->active_slaves, i); + if (p == sif->sw_if_index) + goto done; + } + + if (sif->lacp_enabled && bif->numa_only && (vm->numa_node == hw->numa_node)) { - hash_set (bif->active_slave_by_sw_if_index, sif->sw_if_index, - sif->sw_if_index); - vec_add1 (bif->active_slaves, sif->sw_if_index); + vec_insert_elts (bif->active_slaves, &sif->sw_if_index, 1, + bif->n_numa_slaves); + bif->n_numa_slaves++; } + else + vec_add1 (bif->active_slaves, sif->sw_if_index); + + sif->is_local_numa = (vm->numa_node == hw->numa_node) ? 1 : 0; + if (bif->mode == BOND_MODE_ACTIVE_BACKUP) + { + if (vec_len (bif->active_slaves) == 1) + /* First slave becomes active? */ + vlib_process_signal_event (bm->vlib_main, bond_process_node.index, + BOND_SEND_GARP_NA, bif->hw_if_index); + else + bond_sort_slaves (bif); + } + +done: + clib_spinlock_unlock_if_init (&bif->lockp); } int @@ -68,14 +186,18 @@ bond_dump_ifs (bond_interface_details_t ** out_bondifs) /* *INDENT-OFF* */ pool_foreach (bif, bm->interfaces, vec_add2(r_bondifs, bondif, 1); - memset (bondif, 0, sizeof (*bondif)); + clib_memset (bondif, 0, sizeof (*bondif)); + bondif->id = bif->id; bondif->sw_if_index = bif->sw_if_index; hi = vnet_get_hw_interface (vnm, bif->hw_if_index); clib_memcpy(bondif->interface_name, hi->name, MIN (ARRAY_LEN (bondif->interface_name) - 1, - strlen ((const char *) hi->name))); + vec_len ((const char *) hi->name))); + /* enforce by memset() above */ + ASSERT(0 == bondif->interface_name[ARRAY_LEN (bondif->interface_name) - 1]); bondif->mode = bif->mode; bondif->lb = bif->lb; + bondif->numa_only = bif->numa_only; bondif->active_slaves = vec_len (bif->active_slaves); bondif->slaves = vec_len (bif->slaves); ); @@ -106,7 +228,7 @@ bond_dump_slave_ifs (slave_interface_details_t ** out_slaveifs, vec_foreach (sw_if_index, bif->slaves) { vec_add2 (r_slaveifs, slaveif, 1); - memset (slaveif, 0, sizeof (*slaveif)); + clib_memset (slaveif, 0, sizeof (*slaveif)); sif = bond_get_slave_by_sw_if_index (*sw_if_index); if (sif) { @@ -114,10 +236,16 @@ bond_dump_slave_ifs (slave_interface_details_t ** out_slaveifs, hi = vnet_get_hw_interface (vnm, sw->hw_if_index); clib_memcpy (slaveif->interface_name, hi->name, MIN (ARRAY_LEN (slaveif->interface_name) - 1, - strlen ((const char *) hi->name))); + vec_len ((const char *) hi->name))); + /* enforce by memset() above */ + ASSERT (0 == + slaveif->interface_name[ARRAY_LEN (slaveif->interface_name) - + 1]); slaveif->sw_if_index = sif->sw_if_index; slaveif->is_passive = sif->is_passive; slaveif->is_long_timeout = sif->is_long_timeout; + slaveif->is_local_numa = sif->is_local_numa; + slaveif->weight = sif->weight; } } *out_slaveifs = r_slaveifs; @@ -125,18 +253,45 @@ bond_dump_slave_ifs (slave_interface_details_t ** out_slaveifs, return 0; } +/* + * Manage secondary mac addresses when attaching/detaching a slave. + * If adding, copies any secondary addresses from master to slave + * If deleting, deletes the master's secondary addresses from the slave + * + */ +static void +bond_slave_add_del_mac_addrs (bond_if_t * bif, u32 sif_sw_if_index, u8 is_add) +{ + vnet_main_t *vnm = vnet_get_main (); + ethernet_interface_t *b_ei; + mac_address_t *sec_mac; + vnet_hw_interface_t *s_hwif; + + b_ei = ethernet_get_interface (ðernet_main, bif->hw_if_index); + if (!b_ei || !b_ei->secondary_addrs) + return; + + s_hwif = vnet_get_sup_hw_interface (vnm, sif_sw_if_index); + + vec_foreach (sec_mac, b_ei->secondary_addrs) + vnet_hw_interface_add_del_mac_address (vnm, s_hwif->hw_if_index, + sec_mac->bytes, is_add); +} + static void bond_delete_neighbor (vlib_main_t * vm, bond_if_t * bif, slave_if_t * sif) { bond_main_t *bm = &bond_main; vnet_main_t *vnm = vnet_get_main (); int i; - vnet_hw_interface_t *hw; + vnet_hw_interface_t *sif_hw; + + sif_hw = vnet_get_sup_hw_interface (vnm, sif->sw_if_index); bif->port_number_bitmap = clib_bitmap_set (bif->port_number_bitmap, ntohs (sif->actor_admin.port_number) - 1, 0); - hash_unset (bm->neighbor_by_sw_if_index, sif->sw_if_index); + bm->slave_by_sw_if_index[sif->sw_if_index] = 0; vec_free (sif->last_marker_pkt); vec_free (sif->last_rx_pkt); vec_foreach_index (i, bif->slaves) @@ -151,15 +306,29 @@ bond_delete_neighbor (vlib_main_t * vm, bond_if_t * bif, slave_if_t * sif) bond_disable_collecting_distributing (vm, sif); + vnet_feature_enable_disable ("device-input", "bond-input", + sif->sw_if_index, 0, 0, 0); + /* Put back the old mac */ - hw = vnet_get_sup_hw_interface (vnm, sif->sw_if_index); - vnet_hw_interface_change_mac_address (vnm, hw->hw_if_index, + vnet_hw_interface_change_mac_address (vnm, sif_hw->hw_if_index, sif->persistent_hw_address); - pool_put (bm->neighbors, sif); + /* delete the bond's secondary/virtual mac addrs from the slave */ + bond_slave_add_del_mac_addrs (bif, sif->sw_if_index, 0 /* is_add */ ); + if ((bif->mode == BOND_MODE_LACP) && bm->lacp_enable_disable) (*bm->lacp_enable_disable) (vm, bif, sif, 0); + + if (bif->mode == BOND_MODE_LACP) + { + stat_segment_deregister_state_counter + (bm->stats[bif->sw_if_index][sif->sw_if_index].actor_state); + stat_segment_deregister_state_counter + (bm->stats[bif->sw_if_index][sif->sw_if_index].partner_state); + } + + pool_put (bm->neighbors, sif); } int @@ -171,6 +340,7 @@ bond_delete_if (vlib_main_t * vm, u32 sw_if_index) slave_if_t *sif; vnet_hw_interface_t *hw; u32 *sif_sw_if_index; + u32 *s_list = 0; hw = vnet_get_sup_hw_interface (vnm, sw_if_index); if (hw == NULL || bond_dev_class.index != hw->dev_class_index) @@ -178,12 +348,14 @@ bond_delete_if (vlib_main_t * vm, u32 sw_if_index) bif = bond_get_master_by_dev_instance (hw->dev_instance); - vec_foreach (sif_sw_if_index, bif->slaves) + vec_append (s_list, bif->slaves); + vec_foreach (sif_sw_if_index, s_list) { sif = bond_get_slave_by_sw_if_index (*sif_sw_if_index); if (sif) bond_delete_neighbor (vm, bif, sif); } + vec_free (s_list); /* bring down the interface */ vnet_hw_interface_set_flags (vnm, bif->hw_if_index, 0); @@ -193,7 +365,8 @@ bond_delete_if (vlib_main_t * vm, u32 sw_if_index) clib_bitmap_free (bif->port_number_bitmap); hash_unset (bm->bond_by_sw_if_index, bif->sw_if_index); - memset (bif, 0, sizeof (*bif)); + hash_unset (bm->id_used, bif->id); + clib_memset (bif, 0, sizeof (*bif)); pool_put (bm->interfaces, bif); return 0; @@ -226,16 +399,30 @@ bond_create_if (vlib_main_t * vm, bond_create_if_args_t * args) return; } pool_get (bm->interfaces, bif); - memset (bif, 0, sizeof (*bif)); + clib_memset (bif, 0, sizeof (*bif)); bif->dev_instance = bif - bm->interfaces; + bif->id = args->id; bif->lb = args->lb; bif->mode = args->mode; + // Adjust requested interface id + if (bif->id == ~0) + bif->id = bif->dev_instance; + if (hash_get (bm->id_used, bif->id)) + { + args->rv = VNET_API_ERROR_INSTANCE_IN_USE; + pool_put (bm->interfaces, bif); + return; + } + hash_set (bm->id_used, bif->id, 1); + // Special load-balance mode used for rr and bc if (bif->mode == BOND_MODE_ROUND_ROBIN) bif->lb = BOND_LB_RR; else if (bif->mode == BOND_MODE_BROADCAST) bif->lb = BOND_LB_BC; + else if (bif->mode == BOND_MODE_ACTIVE_BACKUP) + bif->lb = BOND_LB_AB; bif->use_custom_mac = args->hw_addr_set; if (!args->hw_addr_set) @@ -251,13 +438,14 @@ bond_create_if (vlib_main_t * vm, bond_create_if_args_t * args) } memcpy (bif->hw_address, args->hw_addr, 6); args->error = ethernet_register_interface - (vnm, bond_dev_class.index, bif - bm->interfaces /* device instance */ , + (vnm, bond_dev_class.index, bif->dev_instance /* device instance */ , bif->hw_address /* ethernet address */ , &bif->hw_if_index, 0 /* flag change */ ); if (args->error) { args->rv = VNET_API_ERROR_INVALID_REGISTRATION; + hash_unset (bm->id_used, bif->id); pool_put (bm->interfaces, bif); return; } @@ -265,6 +453,9 @@ bond_create_if (vlib_main_t * vm, bond_create_if_args_t * args) sw = vnet_get_hw_sw_interface (vnm, bif->hw_if_index); bif->sw_if_index = sw->sw_if_index; bif->group = bif->sw_if_index; + bif->numa_only = args->numa_only; + if (vlib_get_thread_main ()->n_vlib_mains > 1) + clib_spinlock_init (&bif->lockp); vnet_hw_interface_set_flags (vnm, bif->hw_if_index, VNET_HW_INTERFACE_FLAG_LINK_UP); @@ -273,6 +464,7 @@ bond_create_if (vlib_main_t * vm, bond_create_if_args_t * args) // for return args->sw_if_index = bif->sw_if_index; + args->rv = 0; } static clib_error_t * @@ -287,8 +479,10 @@ bond_create_command_fn (vlib_main_t * vm, unformat_input_t * input, if (!unformat_user (input, unformat_line_input, line_input)) return clib_error_return (0, "Missing required arguments."); + args.id = ~0; args.mode = -1; args.lb = BOND_LB_L2; + args.rv = -1; while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { if (unformat (line_input, "mode %U", unformat_bond_mode, &args.mode)) @@ -300,6 +494,16 @@ bond_create_command_fn (vlib_main_t * vm, unformat_input_t * input, else if (unformat (line_input, "hw-addr %U", unformat_ethernet_address, args.hw_addr)) args.hw_addr_set = 1; + else if (unformat (line_input, "id %u", &args.id)) + ; + else if (unformat (line_input, "numa-only")) + { + if (args.mode == BOND_MODE_LACP) + args.numa_only = 1; + else + return clib_error_return (0, + "Only lacp mode supports numa-only so far!"); + } else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); @@ -311,6 +515,10 @@ bond_create_command_fn (vlib_main_t * vm, unformat_input_t * input, bond_create_if (vm, &args); + if (!args.rv) + vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name, + vnet_get_main (), args.sw_if_index); + return args.error; } @@ -318,7 +526,8 @@ bond_create_command_fn (vlib_main_t * vm, unformat_input_t * input, VLIB_CLI_COMMAND (bond_create_command, static) = { .path = "create bond", .short_help = "create bond mode {round-robin | active-backup | broadcast | " - "{lacp | xor} [load-balance { l2 | l23 | l34 }]} [hw-addr ]", + "{lacp | xor} [load-balance { l2 | l23 | l34 } [numa-only]]} [hw-addr ] " + "[id ]", .function = bond_create_command_fn, }; /* *INDENT-ON* */ @@ -379,8 +588,10 @@ bond_enslave (vlib_main_t * vm, bond_enslave_args_t * args) bond_if_t *bif; slave_if_t *sif; vnet_interface_main_t *im = &vnm->interface_main; - vnet_hw_interface_t *hw, *hw2; + vnet_hw_interface_t *bif_hw, *sif_hw; vnet_sw_interface_t *sw; + u32 thread_index; + u32 sif_if_index; bif = bond_get_master_by_sw_if_index (args->group); if (!bif) @@ -396,19 +607,49 @@ bond_enslave (vlib_main_t * vm, bond_enslave_args_t * args) args->error = clib_error_return (0, "interface was already enslaved"); return; } - hw = vnet_get_sup_hw_interface (vnm, args->slave); - if (hw->dev_class_index == bond_dev_class.index) + sif_hw = vnet_get_sup_hw_interface (vnm, args->slave); + if (sif_hw->dev_class_index == bond_dev_class.index) { args->rv = VNET_API_ERROR_INVALID_INTERFACE; args->error = clib_error_return (0, "bond interface cannot be enslaved"); return; } + if (bif->mode == BOND_MODE_LACP) + { + u8 *name = format (0, "/if/lacp/%u/%u/state%c", bif->sw_if_index, + args->slave, 0); + + vec_validate (bm->stats, bif->sw_if_index); + vec_validate (bm->stats[bif->sw_if_index], args->slave); + + args->error = stat_segment_register_state_counter + (name, &bm->stats[bif->sw_if_index][args->slave].actor_state); + if (args->error != 0) + { + args->rv = VNET_API_ERROR_INVALID_INTERFACE; + vec_free (name); + return; + } + + vec_reset_length (name); + name = format (0, "/if/lacp/%u/%u/partner-state%c", bif->sw_if_index, + args->slave, 0); + args->error = stat_segment_register_state_counter + (name, &bm->stats[bif->sw_if_index][args->slave].partner_state); + vec_free (name); + if (args->error != 0) + { + args->rv = VNET_API_ERROR_INVALID_INTERFACE; + return; + } + } + pool_get (bm->neighbors, sif); - memset (sif, 0, sizeof (*sif)); - clib_spinlock_init (&sif->lockp); + clib_memset (sif, 0, sizeof (*sif)); sw = pool_elt_at_index (im->sw_interfaces, args->slave); - sif->port_enabled = sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP; + /* port_enabled is both admin up and hw link up */ + sif->port_enabled = vnet_sw_interface_is_up (vnm, sw->sw_if_index); sif->sw_if_index = sw->sw_if_index; sif->hw_if_index = sw->hw_if_index; sif->packet_template_index = (u8) ~ 0; @@ -423,16 +664,25 @@ bond_enslave (vlib_main_t * vm, bond_enslave_args_t * args) else sif->ttl_in_seconds = LACP_SHORT_TIMOUT_TIME; - hash_set (bm->neighbor_by_sw_if_index, sif->sw_if_index, - sif - bm->neighbors); + vec_validate_aligned (bm->slave_by_sw_if_index, sif->sw_if_index, + CLIB_CACHE_LINE_BYTES); + /* + * sif - bm->neighbors may be 0 + * Left shift it by 1 bit to distinguish the valid entry that we actually + * store from the null entries + */ + bm->slave_by_sw_if_index[sif->sw_if_index] = + (uword) (((sif - bm->neighbors) << 1) | 1); vec_add1 (bif->slaves, sif->sw_if_index); - hw = vnet_get_sup_hw_interface (vnm, sif->sw_if_index); + sif_hw = vnet_get_sup_hw_interface (vnm, sif->sw_if_index); + /* Save the old mac */ - memcpy (sif->persistent_hw_address, hw->hw_address, 6); + memcpy (sif->persistent_hw_address, sif_hw->hw_address, 6); + bif_hw = vnet_get_sup_hw_interface (vnm, bif->sw_if_index); if (bif->use_custom_mac) { - vnet_hw_interface_change_mac_address (vnm, hw->hw_if_index, + vnet_hw_interface_change_mac_address (vnm, sif_hw->hw_if_index, bif->hw_address); } else @@ -440,30 +690,55 @@ bond_enslave (vlib_main_t * vm, bond_enslave_args_t * args) // bond interface gets the mac address from the first slave if (vec_len (bif->slaves) == 1) { - memcpy (bif->hw_address, hw->hw_address, 6); - hw2 = vnet_get_sup_hw_interface (vnm, bif->sw_if_index); - vnet_hw_interface_change_mac_address (vnm, hw2->hw_if_index, - hw->hw_address); + memcpy (bif->hw_address, sif_hw->hw_address, 6); + vnet_hw_interface_change_mac_address (vnm, bif_hw->hw_if_index, + sif_hw->hw_address); } else { // subsequent slaves gets the mac address of the bond interface - vnet_hw_interface_change_mac_address (vnm, hw->hw_if_index, + vnet_hw_interface_change_mac_address (vnm, sif_hw->hw_if_index, bif->hw_address); } } - if ((bif->mode == BOND_MODE_LACP) && bm->lacp_enable_disable) + /* if there are secondary/virtual mac addrs, propagate to the slave */ + bond_slave_add_del_mac_addrs (bif, sif->sw_if_index, 1 /* is_add */ ); + + if (bif_hw->l2_if_count) { - (*bm->lacp_enable_disable) (vm, bif, sif, 1); + ethernet_set_flags (vnm, sif_hw->hw_if_index, + ETHERNET_INTERFACE_FLAG_ACCEPT_ALL); + /* ensure all packets go to ethernet-input */ + ethernet_set_rx_redirect (vnm, sif_hw, 1); } - else + + if (bif->mode == BOND_MODE_LACP) + { + if (bm->lacp_enable_disable) + (*bm->lacp_enable_disable) (vm, bif, sif, 1); + } + else if (sif->port_enabled) { bond_enable_collecting_distributing (vm, sif); } + vec_foreach_index (thread_index, bm->per_thread_data) + { + bond_per_thread_data_t *ptd = vec_elt_at_index (bm->per_thread_data, + thread_index); + + vec_validate_aligned (ptd->per_port_queue, vec_len (bif->slaves) - 1, + CLIB_CACHE_LINE_BYTES); + + vec_foreach_index (sif_if_index, ptd->per_port_queue) + { + ptd->per_port_queue[sif_if_index].n_buffers = 0; + } + } + args->rv = vnet_feature_enable_disable ("device-input", "bond-input", - hw->hw_if_index, 1, 0, 0); + sif->sw_if_index, 1, 0, 0); if (args->rv) { @@ -489,12 +764,10 @@ enslave_interface_command_fn (vlib_main_t * vm, unformat_input_t * input, args.group = ~0; while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "interface %U", + if (unformat (line_input, "%U %U", + unformat_vnet_sw_interface, vnm, &args.group, unformat_vnet_sw_interface, vnm, &args.slave)) ; - else if (unformat (line_input, "to %U", unformat_vnet_sw_interface, vnm, - &args.group)) - ; else if (unformat (line_input, "passive")) args.is_passive = 1; else if (unformat (line_input, "long-timeout")) @@ -513,7 +786,7 @@ enslave_interface_command_fn (vlib_main_t * vm, unformat_input_t * input, if (args.group == ~0) return clib_error_return (0, "Missing bond interface"); if (args.slave == ~0) - return clib_error_return (0, "please specify valid interface name"); + return clib_error_return (0, "please specify valid slave interface name"); bond_enslave (vm, &args); @@ -522,8 +795,9 @@ enslave_interface_command_fn (vlib_main_t * vm, unformat_input_t * input, /* *INDENT-OFF* */ VLIB_CLI_COMMAND (enslave_interface_command, static) = { - .path = "enslave", - .short_help = "enslave interface to [passive] [long-timeout]", + .path = "bond add", + .short_help = "bond add " + "[passive] [long-timeout]", .function = enslave_interface_command_fn, }; /* *INDENT-ON* */ @@ -560,7 +834,7 @@ detach_interface_command_fn (vlib_main_t * vm, unformat_input_t * input, args.slave = ~0; while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "interface %U", + if (unformat (line_input, "%U", unformat_vnet_sw_interface, vnm, &args.slave)) ; else @@ -575,7 +849,7 @@ detach_interface_command_fn (vlib_main_t * vm, unformat_input_t * input, if (args.error) return args.error; if (args.slave == ~0) - return clib_error_return (0, "please specify valid interface name"); + return clib_error_return (0, "please specify valid slave interface name"); bond_detach_slave (vm, &args); @@ -584,8 +858,8 @@ detach_interface_command_fn (vlib_main_t * vm, unformat_input_t * input, /* *INDENT-OFF* */ VLIB_CLI_COMMAND (detach_interface_command, static) = { - .path = "detach", - .short_help = "detach interface ", + .path = "bond del", + .short_help = "bond del ", .function = detach_interface_command_fn, }; /* *INDENT-ON* */ @@ -596,14 +870,14 @@ show_bond (vlib_main_t * vm) bond_main_t *bm = &bond_main; bond_if_t *bif; - vlib_cli_output (vm, "%-16s %-12s %-12s %-13s %-14s %s", + vlib_cli_output (vm, "%-16s %-12s %-13s %-13s %-14s %s", "interface name", "sw_if_index", "mode", "load balance", "active slaves", "slaves"); /* *INDENT-OFF* */ pool_foreach (bif, bm->interfaces, ({ - vlib_cli_output (vm, "%-16U %-12d %-12U %-13U %-14u %u", + vlib_cli_output (vm, "%-16U %-12d %-13U %-13U %-14u %u", format_bond_interface_name, bif->dev_instance, bif->sw_if_index, format_bond_mode, bif->mode, format_bond_load_balance, bif->lb, @@ -636,6 +910,14 @@ show_bond_details (vlib_main_t * vm) { vlib_cli_output (vm, " %U", format_vnet_sw_if_index_name, vnet_get_main (), *sw_if_index); + if (bif->mode == BOND_MODE_ACTIVE_BACKUP) + { + slave_if_t *sif = bond_get_slave_by_sw_if_index (*sw_if_index); + if (sif) + vlib_cli_output (vm, " weight: %u, is_local_numa: %u, " + "sw_if_index: %u", sif->weight, + sif->is_local_numa, sif->sw_if_index); + } } vlib_cli_output (vm, " number of slaves: %d", vec_len (bif->slaves)); vec_foreach (sw_if_index, bif->slaves) @@ -644,6 +926,7 @@ show_bond_details (vlib_main_t * vm) vnet_get_main (), *sw_if_index); } vlib_cli_output (vm, " device instance: %d", bif->dev_instance); + vlib_cli_output (vm, " interface id: %d", bif->id); vlib_cli_output (vm, " sw_if_index: %d", bif->sw_if_index); vlib_cli_output (vm, " hw_if_index: %d", bif->hw_if_index); })); @@ -683,6 +966,113 @@ VLIB_CLI_COMMAND (show_bond_command, static) = { }; /* *INDENT-ON* */ +void +bond_set_intf_weight (vlib_main_t * vm, bond_set_intf_weight_args_t * args) +{ + slave_if_t *sif; + bond_if_t *bif; + vnet_main_t *vnm; + u32 old_weight; + + sif = bond_get_slave_by_sw_if_index (args->sw_if_index); + if (!sif) + { + args->rv = VNET_API_ERROR_INVALID_INTERFACE; + args->error = clib_error_return (0, "Interface not enslaved"); + return; + } + bif = bond_get_master_by_dev_instance (sif->bif_dev_instance); + if (!bif) + { + args->rv = VNET_API_ERROR_INVALID_INTERFACE; + args->error = clib_error_return (0, "bond interface not found"); + return; + } + if (bif->mode != BOND_MODE_ACTIVE_BACKUP) + { + args->rv = VNET_API_ERROR_INVALID_ARGUMENT; + args->error = + clib_error_return (0, "Weight valid for active-backup only"); + return; + } + + old_weight = sif->weight; + sif->weight = args->weight; + vnm = vnet_get_main (); + /* + * No need to sort the list if the affected slave is not up (not in active + * slave set), active slave count is 1, or the current slave is already the + * primary slave and new weight > old weight. + */ + if (!vnet_sw_interface_is_up (vnm, sif->sw_if_index) || + (vec_len (bif->active_slaves) == 1) || + ((bif->active_slaves[0] == sif->sw_if_index) && + (sif->weight >= old_weight))) + return; + + bond_sort_slaves (bif); +} + +static clib_error_t * +bond_set_intf_cmd (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + bond_set_intf_weight_args_t args = { 0 }; + u32 sw_if_index = (u32) ~ 0; + unformat_input_t _line_input, *line_input = &_line_input; + vnet_main_t *vnm = vnet_get_main (); + u8 weight_enter = 0; + u32 weight = 0; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return clib_error_return (0, "Missing required arguments."); + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "sw_if_index %d", &sw_if_index)) + ; + else if (unformat (line_input, "%U", unformat_vnet_sw_interface, vnm, + &sw_if_index)) + ; + else if (unformat (line_input, "weight %u", &weight)) + weight_enter = 1; + else + { + clib_error_return (0, "unknown input `%U'", format_unformat_error, + input); + break; + } + } + + unformat_free (line_input); + if (sw_if_index == (u32) ~ 0) + { + args.rv = VNET_API_ERROR_INVALID_INTERFACE; + clib_error_return (0, "Interface name is invalid!"); + } + if (weight_enter == 0) + { + args.rv = VNET_API_ERROR_INVALID_ARGUMENT; + clib_error_return (0, "weight missing"); + } + + args.sw_if_index = sw_if_index; + args.weight = weight; + bond_set_intf_weight (vm, &args); + + return args.error; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND(set_interface_bond_cmd, static) = { + .path = "set interface bond", + .short_help = "set interface bond | sw_if_index " + " weight ", + .function = bond_set_intf_cmd, +}; +/* *INDENT-ON* */ + clib_error_t * bond_cli_init (vlib_main_t * vm) { @@ -690,7 +1080,10 @@ bond_cli_init (vlib_main_t * vm) bm->vlib_main = vm; bm->vnet_main = vnet_get_main (); - bm->neighbor_by_sw_if_index = hash_create (0, sizeof (uword)); + vec_validate_aligned (bm->slave_by_sw_if_index, 1, CLIB_CACHE_LINE_BYTES); + vec_validate_aligned (bm->per_thread_data, + vlib_get_thread_main ()->n_vlib_mains - 1, + CLIB_CACHE_LINE_BYTES); return 0; }