X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Finterface.c;h=5fb2ff65fa2d8e2611ed6b4c25ac3e4a88174beb;hb=a8d266a7a4bf1188739dcd6d3ddcc8173282d95d;hp=b197aa1e0737c75587465dcbcbc74c6939da9f6f;hpb=8b30e471df4d42214619e1d6c50cc8298426b45f;p=vpp.git diff --git a/src/vnet/interface.c b/src/vnet/interface.c index b197aa1e073..5fb2ff65fa2 100644 --- a/src/vnet/interface.c +++ b/src/vnet/interface.c @@ -39,22 +39,38 @@ #include #include -#include #include #include +#include +#include +#include -#define VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE (1 << 0) -#define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE (1 << 1) +VLIB_REGISTER_LOG_CLASS (if_default_log, static) = { + .class_name = "interface", +}; + +#define log_debug(fmt,...) vlib_log_debug(if_default_log.class, fmt, __VA_ARGS__) +#define log_err(fmt,...) vlib_log_err(if_default_log.class, fmt, __VA_ARGS__) + +typedef enum vnet_interface_helper_flags_t_ +{ + VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE = (1 << 0), + VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE = (1 << 1), +} vnet_interface_helper_flags_t; static clib_error_t *vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, u32 hw_if_index, - u32 flags, - u32 helper_flags); + vnet_hw_interface_flags_t + flags, + vnet_interface_helper_flags_t + helper_flags); static clib_error_t *vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, - u32 flags, - u32 helper_flags); + vnet_sw_interface_flags_t + flags, + vnet_interface_helper_flags_t + helper_flags); static clib_error_t *vnet_hw_interface_set_class_helper (vnet_main_t * vnm, u32 hw_if_index, @@ -101,68 +117,17 @@ unserialize_vec_vnet_sw_hw_interface_state (serialize_main_t * m, } } -static void -serialize_vnet_sw_hw_interface_set_flags (serialize_main_t * m, va_list * va) -{ - vnet_sw_hw_interface_state_t *s = - va_arg (*va, vnet_sw_hw_interface_state_t *); - serialize (m, serialize_vec_vnet_sw_hw_interface_state, s, 1); -} - -static void -unserialize_vnet_sw_interface_set_flags (serialize_main_t * m, va_list * va) -{ - CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *); - vnet_sw_hw_interface_state_t s; - - unserialize (m, unserialize_vec_vnet_sw_hw_interface_state, &s, 1); - - vnet_sw_interface_set_flags_helper - (vnet_get_main (), s.sw_hw_if_index, s.flags, - /* helper_flags no redistribution */ 0); -} - -void -vnet_hw_interface_set_mtu (vnet_main_t * vnm, u32 hw_if_index, u32 mtu) -{ - vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); - - if (hi->max_packet_bytes != mtu) - { - u16 l3_pad = hi->max_packet_bytes - hi->max_l3_packet_bytes[VLIB_TX]; - hi->max_packet_bytes = mtu; - hi->max_l3_packet_bytes[VLIB_TX] = - hi->max_l3_packet_bytes[VLIB_RX] = mtu - l3_pad; - ethernet_set_flags (vnm, hw_if_index, ETHERNET_INTERFACE_FLAG_MTU); - adj_mtu_update (hw_if_index); - } -} - -static void -unserialize_vnet_hw_interface_set_flags (serialize_main_t * m, va_list * va) +static vnet_sw_interface_flags_t +vnet_hw_interface_flags_to_sw (vnet_hw_interface_flags_t hwf) { - CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *); - vnet_sw_hw_interface_state_t s; + vnet_sw_interface_flags_t swf = VNET_SW_INTERFACE_FLAG_NONE; - unserialize (m, unserialize_vec_vnet_sw_hw_interface_state, &s, 1); + if (hwf & VNET_HW_INTERFACE_FLAG_LINK_UP) + swf |= VNET_SW_INTERFACE_FLAG_ADMIN_UP; - vnet_hw_interface_set_flags_helper - (vnet_get_main (), s.sw_hw_if_index, s.flags, - /* helper_flags no redistribution */ 0); + return (swf); } -MC_SERIALIZE_MSG (vnet_sw_interface_set_flags_msg, static) = -{ -.name = "vnet_sw_interface_set_flags",.serialize = - serialize_vnet_sw_hw_interface_set_flags,.unserialize = - unserialize_vnet_sw_interface_set_flags,}; - -MC_SERIALIZE_MSG (vnet_hw_interface_set_flags_msg, static) = -{ -.name = "vnet_hw_interface_set_flags",.serialize = - serialize_vnet_sw_hw_interface_set_flags,.unserialize = - unserialize_vnet_hw_interface_set_flags,}; - void serialize_vnet_interface_state (serialize_main_t * m, va_list * va) { @@ -174,46 +139,51 @@ serialize_vnet_interface_state (serialize_main_t * m, va_list * va) /* Serialize hardware interface classes since they may have changed. Must do this before sending up/down flags. */ - /* *INDENT-OFF* */ - pool_foreach (hif, im->hw_interfaces, ({ + pool_foreach (hif, im->hw_interfaces) { vnet_hw_interface_class_t * hw_class = vnet_get_hw_interface_class (vnm, hif->hw_class_index); serialize_cstring (m, hw_class->name); - })); - /* *INDENT-ON* */ + } /* Send sw/hw interface state when non-zero. */ - /* *INDENT-OFF* */ - pool_foreach (sif, im->sw_interfaces, ({ + pool_foreach (sif, im->sw_interfaces) { if (sif->flags != 0) { vec_add2 (sts, st, 1); st->sw_hw_if_index = sif->sw_if_index; st->flags = sif->flags; } - })); - /* *INDENT-ON* */ + } vec_serialize (m, sts, serialize_vec_vnet_sw_hw_interface_state); if (sts) - _vec_len (sts) = 0; + vec_set_len (sts, 0); - /* *INDENT-OFF* */ - pool_foreach (hif, im->hw_interfaces, ({ + pool_foreach (hif, im->hw_interfaces) { if (hif->flags != 0) { vec_add2 (sts, st, 1); st->sw_hw_if_index = hif->hw_if_index; - st->flags = hif->flags; + st->flags = vnet_hw_interface_flags_to_sw(hif->flags); } - })); - /* *INDENT-ON* */ + } vec_serialize (m, sts, serialize_vec_vnet_sw_hw_interface_state); vec_free (sts); } +static vnet_hw_interface_flags_t +vnet_sw_interface_flags_to_hw (vnet_sw_interface_flags_t swf) +{ + vnet_hw_interface_flags_t hwf = VNET_HW_INTERFACE_FLAG_NONE; + + if (swf & VNET_SW_INTERFACE_FLAG_ADMIN_UP) + hwf |= VNET_HW_INTERFACE_FLAG_LINK_UP; + + return (hwf); +} + void unserialize_vnet_interface_state (serialize_main_t * m, va_list * va) { @@ -228,17 +198,21 @@ unserialize_vnet_interface_state (serialize_main_t * m, va_list * va) uword *p; clib_error_t *error; - /* *INDENT-OFF* */ - pool_foreach (hif, im->hw_interfaces, ({ + pool_foreach (hif, im->hw_interfaces) { unserialize_cstring (m, &class_name); p = hash_get_mem (im->hw_interface_class_by_name, class_name); - ASSERT (p != 0); - error = vnet_hw_interface_set_class_helper (vnm, hif->hw_if_index, p[0], /* redistribute */ 0); + if (p) + { + error = vnet_hw_interface_set_class_helper + (vnm, hif->hw_if_index, p[0], /* redistribute */ 0); + } + else + error = clib_error_return (0, "hw class %s AWOL?", class_name); + if (error) clib_error_report (error); vec_free (class_name); - })); - /* *INDENT-ON* */ + } } vec_unserialize (m, &sts, unserialize_vec_vnet_sw_hw_interface_state); @@ -249,8 +223,11 @@ unserialize_vnet_interface_state (serialize_main_t * m, va_list * va) vec_unserialize (m, &sts, unserialize_vec_vnet_sw_hw_interface_state); vec_foreach (st, sts) - vnet_hw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags, - /* no distribute */ 0); + { + vnet_hw_interface_set_flags_helper + (vnm, st->sw_hw_if_index, vnet_sw_interface_flags_to_hw (st->flags), + /* no distribute */ 0); + } vec_free (sts); } @@ -316,27 +293,22 @@ call_sw_interface_add_del_callbacks (vnet_main_t * vnm, u32 sw_if_index, (vnm, sw_if_index, is_create, vnm->sw_interface_add_del_functions); } -#define VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE (1 << 0) -#define VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE (1 << 1) - static clib_error_t * vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, u32 hw_if_index, - u32 flags, u32 helper_flags) + vnet_hw_interface_flags_t flags, + vnet_interface_helper_flags_t + helper_flags) { vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); vnet_hw_interface_class_t *hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index); - vnet_device_class_t *dev_class = - vnet_get_device_class (vnm, hi->dev_class_index); - vlib_main_t *vm = vnm->vlib_main; u32 mask; clib_error_t *error = 0; u32 is_create = (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0; mask = - (VNET_HW_INTERFACE_FLAG_LINK_UP | VNET_HW_INTERFACE_FLAG_DUPLEX_MASK | - VNET_HW_INTERFACE_FLAG_SPEED_MASK); + (VNET_HW_INTERFACE_FLAG_LINK_UP | VNET_HW_INTERFACE_FLAG_DUPLEX_MASK); flags &= mask; /* Call hardware interface add/del callbacks. */ @@ -347,19 +319,6 @@ vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, u32 hw_if_index, if (!is_create && (hi->flags & mask) == flags) goto done; - /* Some interface classes do not redistribute (e.g. are local). */ - if (!dev_class->redistribute) - helper_flags &= ~VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE; - - if (vm->mc_main - && (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE)) - { - vnet_sw_hw_interface_state_t s; - s.sw_hw_if_index = hw_if_index; - s.flags = flags; - mc_serialize (vm->mc_main, &vnet_hw_interface_set_flags_msg, &s); - } - if ((hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) != (flags & VNET_HW_INTERFACE_FLAG_LINK_UP)) { @@ -380,15 +339,18 @@ vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, u32 hw_if_index, hi->flags |= flags; done: + if (error) + log_err ("hw_set_flags_helper: %U", format_clib_error, error); return error; } static clib_error_t * vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, - u32 flags, u32 helper_flags) + vnet_sw_interface_flags_t flags, + vnet_interface_helper_flags_t + helper_flags) { vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); - vlib_main_t *vm = vnm->vlib_main; u32 mask; clib_error_t *error = 0; u32 is_create = @@ -440,15 +402,6 @@ vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, } } - /* Donot change state for slave link of bonded interfaces */ - if (si->flags & VNET_SW_INTERFACE_FLAG_BOND_SLAVE) - { - error = clib_error_return - (0, "not allowed as %U belong to a BondEthernet interface", - format_vnet_sw_interface_name, vnm, si); - goto done; - } - /* Already in the desired state? */ if ((si->flags & mask) == flags) goto done; @@ -466,16 +419,6 @@ vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, ~VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE; } - if (vm->mc_main - && (helper_flags & - VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE)) - { - vnet_sw_hw_interface_state_t s; - s.sw_hw_if_index = sw_if_index; - s.flags = flags; - mc_serialize (vm->mc_main, &vnet_sw_interface_set_flags_msg, &s); - } - /* set the flags now before invoking the registered clients * so that the state they query is consistent with the state here notified */ old_flags = si->flags; @@ -485,10 +428,13 @@ vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, error = call_elf_section_interface_callbacks (vnm, sw_if_index, flags, vnm->sw_interface_admin_up_down_functions); - si->flags = old_flags; if (error) - goto done; + { + /* restore flags on error */ + si->flags = old_flags; + goto done; + } if (si->type == VNET_SW_INTERFACE_TYPE_HARDWARE) { @@ -506,9 +452,6 @@ vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, goto done; } - /* save the si admin up flag */ - old_flags = si->flags; - /* update si admin up flag in advance if we are going admin down */ if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)) si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP; @@ -540,6 +483,7 @@ vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, hi->flags & ~VNET_HW_INTERFACE_FLAG_LINK_UP, helper_flags); + vnet_hw_if_update_runtime_data (vnm, si->hw_if_index); } } @@ -547,25 +491,72 @@ vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, si->flags |= flags; done: + if (error) + log_err ("sw_set_flags_helper: %U", format_clib_error, error); return error; } clib_error_t * -vnet_hw_interface_set_flags (vnet_main_t * vnm, u32 hw_if_index, u32 flags) +vnet_hw_interface_set_flags (vnet_main_t * vnm, u32 hw_if_index, + vnet_hw_interface_flags_t flags) { + log_debug ("hw_set_flags: hw_if_index %u flags 0x%x", hw_if_index, flags); return vnet_hw_interface_set_flags_helper (vnm, hw_if_index, flags, VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE); } clib_error_t * -vnet_sw_interface_set_flags (vnet_main_t * vnm, u32 sw_if_index, u32 flags) +vnet_sw_interface_set_flags (vnet_main_t * vnm, u32 sw_if_index, + vnet_sw_interface_flags_t flags) { + log_debug ("sw_set_flags: sw_if_index %u flags 0x%x", sw_if_index, flags); return vnet_sw_interface_set_flags_helper (vnm, sw_if_index, flags, VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE); } +void +vnet_sw_interface_admin_up (vnet_main_t * vnm, u32 sw_if_index) +{ + u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); + log_debug ("sw_admin_up: sw_if_index %u", sw_if_index); + + if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)) + { + flags |= VNET_SW_INTERFACE_FLAG_ADMIN_UP; + vnet_sw_interface_set_flags (vnm, sw_if_index, flags); + } +} + +void +vnet_sw_interface_admin_down (vnet_main_t * vnm, u32 sw_if_index) +{ + u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); + log_debug ("sw_admin_down: sw_if_index %u", sw_if_index); + + if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) + { + flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP); + vnet_sw_interface_set_flags (vnm, sw_if_index, flags); + } +} + +static void +vnet_if_update_lookup_tables (vnet_main_t *vnm, u32 sw_if_index) +{ + vnet_interface_main_t *im = &vnm->interface_main; + vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index); + + vec_validate_init_empty (im->hw_if_index_by_sw_if_index, sw_if_index, ~0); + vec_validate_init_empty (im->if_out_arc_end_next_index_by_sw_if_index, + sw_if_index, ~0); + + im->hw_if_index_by_sw_if_index[sw_if_index] = hi->hw_if_index; + im->if_out_arc_end_next_index_by_sw_if_index[sw_if_index] = + hi->if_out_arc_end_node_next_index; +} + static u32 vnet_create_sw_interface_no_callbacks (vnet_main_t * vnm, vnet_sw_interface_t * template) @@ -607,6 +598,7 @@ vnet_create_sw_interface_no_callbacks (vnet_main_t * vnm, vnet_interface_counter_unlock (im); } + vnet_if_update_lookup_tables (vnm, sw_if_index); return sw_if_index; } @@ -614,10 +606,22 @@ clib_error_t * vnet_create_sw_interface (vnet_main_t * vnm, vnet_sw_interface_t * template, u32 * sw_if_index) { + vnet_interface_main_t *im = &vnm->interface_main; clib_error_t *error; vnet_hw_interface_t *hi; vnet_device_class_t *dev_class; + if (template->sub.eth.flags.two_tags == 1 + && template->sub.eth.flags.exact_match == 1 + && (template->sub.eth.flags.inner_vlan_id_any == 1 + || template->sub.eth.flags.outer_vlan_id_any == 1)) + { + char *str = "inner-dot1q any exact-match is unsupported"; + error = clib_error_return (0, str); + log_err ("create_sw_interface: %s", str); + return error; + } + hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index); dev_class = vnet_get_device_class (vnm, hi->dev_class_index); @@ -639,11 +643,20 @@ vnet_create_sw_interface (vnet_main_t * vnm, vnet_sw_interface_t * template, if (error) { /* undo the work done by vnet_create_sw_interface_no_callbacks() */ - vnet_interface_main_t *im = &vnm->interface_main; + log_err ("create_sw_interface: set flags failed\n %U", + format_clib_error, error); + call_sw_interface_add_del_callbacks (vnm, *sw_if_index, 0); vnet_sw_interface_t *sw = pool_elt_at_index (im->sw_interfaces, *sw_if_index); pool_put (im->sw_interfaces, sw); } + else + { + vnet_sw_interface_t *sw = + pool_elt_at_index (im->sw_interfaces, *sw_if_index); + log_debug ("create_sw_interface: interface %U (sw_if_index %u) created", + format_vnet_sw_interface_name, vnm, sw, *sw_if_index); + } return error; } @@ -655,18 +668,11 @@ vnet_delete_sw_interface (vnet_main_t * vnm, u32 sw_if_index) vnet_sw_interface_t *sw = pool_elt_at_index (im->sw_interfaces, sw_if_index); + log_debug ("delete_sw_interface: sw_if_index %u, name '%U'", + sw_if_index, format_vnet_sw_if_index_name, vnm, sw_if_index); + /* Check if the interface has config and is removed from L2 BD or XConnect */ - vlib_main_t *vm = vlib_get_main (); - l2_input_config_t *config; - if (sw_if_index < vec_len (l2input_main.configs)) - { - config = vec_elt_at_index (l2input_main.configs, sw_if_index); - if (config->xconnect) - set_int_l2_mode (vm, vnm, MODE_L3, config->output_sw_if_index, 0, 0, - 0, 0); - if (config->xconnect || config->bridge) - set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0); - } + vnet_clear_sw_interface_tag (vnm, sw_if_index); /* Bring down interface in case it is up. */ if (sw->flags != 0) @@ -677,18 +683,129 @@ vnet_delete_sw_interface (vnet_main_t * vnm, u32 sw_if_index) pool_put (im->sw_interfaces, sw); } +static clib_error_t * +call_sw_interface_mtu_change_callbacks (vnet_main_t * vnm, u32 sw_if_index) +{ + return call_elf_section_interface_callbacks + (vnm, sw_if_index, 0, vnm->sw_interface_mtu_change_functions); +} + +void +vnet_sw_interface_set_mtu (vnet_main_t * vnm, u32 sw_if_index, u32 mtu) +{ + vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); + + if (si->mtu[VNET_MTU_L3] != mtu) + { + si->mtu[VNET_MTU_L3] = mtu; + log_debug ("set_mtu: interface %U, new mtu %u", + format_vnet_sw_if_index_name, vnm, sw_if_index, mtu); + + call_sw_interface_mtu_change_callbacks (vnm, sw_if_index); + } +} + +void +vnet_sw_interface_set_protocol_mtu (vnet_main_t * vnm, u32 sw_if_index, + u32 mtu[]) +{ + vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); + bool changed = false; + int i; + + for (i = 0; i < VNET_N_MTU; i++) + { + if (si->mtu[i] != mtu[i]) + { + si->mtu[i] = mtu[i]; + changed = true; + } + } + /* Notify interested parties */ + if (changed) + { + log_debug ("set_protocol_mtu: interface %U l3 %u ip4 %u ip6 %u mpls %u", + format_vnet_sw_if_index_name, vnm, sw_if_index, + mtu[VNET_MTU_L3], mtu[VNET_MTU_IP4], mtu[VNET_MTU_IP6], + mtu[VNET_MTU_MPLS]); + call_sw_interface_mtu_change_callbacks (vnm, sw_if_index); + } +} + +void +vnet_sw_interface_ip_directed_broadcast (vnet_main_t * vnm, + u32 sw_if_index, u8 enable) +{ + vnet_sw_interface_t *si; + + si = vnet_get_sw_interface (vnm, sw_if_index); + + if (enable) + si->flags |= VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST; + else + si->flags &= ~VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST; + + ip4_directed_broadcast (sw_if_index, enable); +} + +/* + * Reflect a change in hardware MTU on protocol MTUs + */ +static walk_rc_t +sw_interface_walk_callback (vnet_main_t * vnm, u32 sw_if_index, void *ctx) +{ + u32 *link_mtu = ctx; + vnet_sw_interface_set_mtu (vnm, sw_if_index, *link_mtu); + return WALK_CONTINUE; +} + +clib_error_t * +vnet_hw_interface_set_max_frame_size (vnet_main_t *vnm, u32 hw_if_index, + u32 fs) +{ + vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); + vnet_hw_interface_class_t *hw_if_class = + vnet_get_hw_interface_class (vnm, hi->hw_class_index); + clib_error_t *err = 0; + log_debug ("set_max_frame_size: interface %v, max_frame_size %u -> %u", + hi->name, hi->max_frame_size, fs); + + if (hw_if_class->set_max_frame_size == 0) + return vnet_error (VNET_ERR_UNSUPPORTED, + "hw class doesn't support changing Max Frame Size"); + + if (hi->max_frame_size != fs) + { + u32 mtu; + if (hw_if_class->set_max_frame_size) + if ((err = hw_if_class->set_max_frame_size (vnm, hi, fs))) + return err; + hi->max_frame_size = fs; + mtu = fs - hi->frame_overhead; + vnet_hw_interface_walk_sw (vnm, hw_if_index, sw_interface_walk_callback, + &mtu); + } + return 0; +} +clib_error_t * +vnet_hw_interface_set_mtu (vnet_main_t *vnm, u32 hw_if_index, u32 mtu) +{ + vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); + return vnet_hw_interface_set_max_frame_size (vnm, hw_if_index, + mtu + hi->frame_overhead); +} + static void setup_tx_node (vlib_main_t * vm, u32 node_index, vnet_device_class_t * dev_class) { vlib_node_t *n = vlib_get_node (vm, node_index); - n->function = dev_class->tx_function; n->format_trace = dev_class->format_tx_trace; - vlib_register_errors (vm, node_index, - dev_class->tx_function_n_errors, - dev_class->tx_function_error_strings); + vlib_register_errors (vm, node_index, dev_class->tx_function_n_errors, + dev_class->tx_function_error_strings, + dev_class->tx_function_error_counters); } static void @@ -700,6 +817,36 @@ setup_output_node (vlib_main_t * vm, n->unformat_buffer = hw_class->unformat_header; } +void +vnet_reset_interface_l3_output_node (vlib_main_t *vm, u32 sw_if_index) +{ + vnet_set_interface_l3_output_node (vm, sw_if_index, + (u8 *) "interface-output"); +} + +void +vnet_set_interface_l3_output_node (vlib_main_t *vm, u32 sw_if_index, + u8 *output_node) +{ + vlib_node_t *l3_node; + + l3_node = vlib_get_node_by_name (vm, output_node); + + static char *arcs[] = { + "ip4-output", + "ip6-output", + "mpls-output", + "ethernet-output", + }; + u8 a; + + for (a = 0; a < ARRAY_LEN (arcs); a++) + { + u8 arc = vnet_get_feature_arc_index (arcs[a]); + vnet_feature_modify_end_node (arc, sw_if_index, l3_node->index); + } +} + /* Register an interface instance. */ u32 vnet_register_interface (vnet_main_t * vnm, @@ -717,14 +864,20 @@ vnet_register_interface (vnet_main_t * vnm, vnet_feature_config_main_t *fcm; vnet_config_main_t *cm; u32 hw_index, i; - char *tx_node_name, *output_node_name; + vlib_node_t *if_out_node = + vlib_get_node (vm, vnet_interface_output_node.index); pool_get (im->hw_interfaces, hw); - memset (hw, 0, sizeof (*hw)); + clib_memset (hw, 0, sizeof (*hw)); + hw->trace_classify_table_index = ~0; hw_index = hw - im->hw_interfaces; hw->hw_if_index = hw_index; - hw->default_rx_mode = VNET_HW_INTERFACE_RX_MODE_POLLING; + hw->default_rx_mode = VNET_HW_IF_RX_MODE_POLLING; + + if (hw_class->tx_hash_fn_type == VNET_HASH_FN_TYPE_ETHERNET || + hw_class->tx_hash_fn_type == VNET_HASH_FN_TYPE_IP) + hw->hf = vnet_hash_default_function (hw_class->tx_hash_fn_type); if (dev_class->format_device_name) hw->name = format (0, "%U", dev_class->format_device_name, dev_instance); @@ -757,17 +910,11 @@ vnet_register_interface (vnet_main_t * vnm, hw->hw_instance = hw_instance; hw->max_rate_bits_per_sec = 0; - hw->min_packet_bytes = 0; - hw->per_packet_overhead_bytes = 0; - hw->max_l3_packet_bytes[VLIB_RX] = ~0; - hw->max_l3_packet_bytes[VLIB_TX] = ~0; + vnet_sw_interface_set_mtu (vnm, hw->sw_if_index, 0); - if (dev_class->tx_function == 0) + if (dev_class->tx_function == 0 && dev_class->tx_fn_registrations == 0) goto no_output_nodes; /* No output/tx nodes to create */ - tx_node_name = (char *) format (0, "%v-tx", hw->name); - output_node_name = (char *) format (0, "%v-output", hw->name); - /* If we have previously deleted interface nodes, re-use them. */ if (vec_len (im->deleted_hw_interface_nodes) > 0) { @@ -780,50 +927,62 @@ vnet_register_interface (vnet_main_t * vnm, hw->tx_node_index = hn->tx_node_index; hw->output_node_index = hn->output_node_index; - vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name); - vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name); + vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name); + vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name); - /* *INDENT-OFF* */ - foreach_vlib_main ({ - vnet_interface_output_runtime_t *rt; - - rt = vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index); - ASSERT (rt->is_deleted == 1); - rt->is_deleted = 0; - rt->hw_if_index = hw_index; - rt->sw_if_index = hw->sw_if_index; - rt->dev_instance = hw->dev_instance; + foreach_vlib_main () + { + vnet_interface_output_runtime_t *rt; - rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index); - rt->hw_if_index = hw_index; - rt->sw_if_index = hw->sw_if_index; - rt->dev_instance = hw->dev_instance; - }); - /* *INDENT-ON* */ + rt = + vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index); + ASSERT (rt->is_deleted == 1); + rt->is_deleted = 0; + rt->hw_if_index = hw_index; + rt->sw_if_index = hw->sw_if_index; + rt->dev_instance = hw->dev_instance; + + rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index); + rt->hw_if_index = hw_index; + rt->sw_if_index = hw->sw_if_index; + rt->dev_instance = hw->dev_instance; + } /* The new class may differ from the old one. * Functions have to be updated. */ node = vlib_get_node (vm, hw->output_node_index); - node->function = vnet_interface_output_node_multiarch_select (); node->format_trace = format_vnet_interface_output_trace; - /* *INDENT-OFF* */ - foreach_vlib_main ({ - nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index); - nrt->function = node->function; - }); - /* *INDENT-ON* */ + node->node_fn_registrations = if_out_node->node_fn_registrations; + node->function = if_out_node->function; + + foreach_vlib_main () + { + nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index); + nrt->function = node->function; + vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0, + VLIB_NODE_RUNTIME_PERF_RESET); + } node = vlib_get_node (vm, hw->tx_node_index); - node->function = dev_class->tx_function; + if (dev_class->tx_fn_registrations) + { + node->node_fn_registrations = dev_class->tx_fn_registrations; + node->function = vlib_node_get_preferred_node_fn_variant ( + vm, dev_class->tx_fn_registrations); + } + else + node->function = dev_class->tx_function; node->format_trace = dev_class->format_tx_trace; - /* *INDENT-OFF* */ - foreach_vlib_main ({ - nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index); - nrt->function = node->function; - }); - /* *INDENT-ON* */ - - _vec_len (im->deleted_hw_interface_nodes) -= 1; + + foreach_vlib_main () + { + nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index); + nrt->function = node->function; + vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0, + VLIB_NODE_RUNTIME_PERF_RESET); + } + + vec_dec_len (im->deleted_hw_interface_nodes, 1); } else { @@ -835,38 +994,50 @@ vnet_register_interface (vnet_main_t * vnm, .is_deleted = 0, }; - memset (&r, 0, sizeof (r)); + clib_memset (&r, 0, sizeof (r)); r.type = VLIB_NODE_TYPE_INTERNAL; r.runtime_data = &rt; r.runtime_data_bytes = sizeof (rt); - r.scalar_size = 0; + r.scalar_size = sizeof (vnet_hw_if_tx_frame_t); r.vector_size = sizeof (u32); r.flags = VLIB_NODE_FLAG_IS_OUTPUT; - r.name = tx_node_name; - r.function = dev_class->tx_function; + if (dev_class->tx_fn_registrations) + { + r.function = 0; + r.node_fn_registrations = dev_class->tx_fn_registrations; + } + else + r.function = dev_class->tx_function; - hw->tx_node_index = vlib_register_node (vm, &r); + hw->tx_node_index = vlib_register_node (vm, &r, "%v-tx", hw->name); vlib_node_add_named_next_with_slot (vm, hw->tx_node_index, "error-drop", VNET_INTERFACE_TX_NEXT_DROP); r.flags = 0; - r.name = output_node_name; - r.function = vnet_interface_output_node_multiarch_select (); r.format_trace = format_vnet_interface_output_trace; + if (if_out_node->node_fn_registrations) + { + r.function = 0; + r.node_fn_registrations = if_out_node->node_fn_registrations; + } + else + r.function = if_out_node->function; { static char *e[] = { "interface is down", "interface is deleted", + "no tx queue available", }; r.n_errors = ARRAY_LEN (e); r.error_strings = e; } - hw->output_node_index = vlib_register_node (vm, &r); + hw->output_node_index = + vlib_register_node (vm, &r, "%v-output", hw->name); vlib_node_add_named_next_with_slot (vm, hw->output_node_index, "error-drop", @@ -874,7 +1045,6 @@ vnet_register_interface (vnet_main_t * vnm, vlib_node_add_next_with_slot (vm, hw->output_node_index, hw->tx_node_index, VNET_INTERFACE_OUTPUT_NEXT_TX); - /* add interface to the list of "output-interface" feature arc start nodes and clone nexts from 1st interface if it exists */ fcm = vnet_feature_get_config_main (im->output_feature_arc_index); @@ -898,6 +1068,9 @@ vnet_register_interface (vnet_main_t * vnm, } } + hw->if_out_arc_end_node_next_index = vlib_node_add_next ( + vm, vnet_interface_output_arc_end_node.index, hw->tx_node_index); + vnet_if_update_lookup_tables (vnm, hw->sw_if_index); setup_output_node (vm, hw->output_node_index, hw_class); setup_tx_node (vm, hw->tx_node_index, dev_class); @@ -907,7 +1080,6 @@ no_output_nodes: VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE); vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0, VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE); - return hw_index; } @@ -926,10 +1098,14 @@ vnet_delete_hw_interface (vnet_main_t * vnm, u32 hw_if_index) /* Call delete callbacks. */ call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0); + /* delete rx & tx queues */ + vnet_hw_if_unregister_all_rx_queues (vnm, hw_if_index); + vnet_hw_if_unregister_all_tx_queues (vnm, hw_if_index); + vnet_hw_if_update_runtime_data (vnm, hw_if_index); + /* Delete any sub-interfaces. */ { u32 id, sw_if_index; - /* *INDENT-OFF* */ hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id, ({ vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); @@ -939,7 +1115,6 @@ vnet_delete_hw_interface (vnet_main_t * vnm, u32 hw_if_index) vnet_delete_sw_interface (vnm, sw_if_index); })); hash_free (hw->sub_interface_sw_if_index_by_id); - /* *INDENT-ON* */ } /* Delete software interface corresponding to hardware interface. */ @@ -950,32 +1125,30 @@ vnet_delete_hw_interface (vnet_main_t * vnm, u32 hw_if_index) /* Put output/tx nodes into recycle pool */ vnet_hw_interface_nodes_t *dn; - /* *INDENT-OFF* */ - foreach_vlib_main - ({ + foreach_vlib_main () + { vnet_interface_output_runtime_t *rt = vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index); /* Mark node runtime as deleted so output node (if called) * will drop packets. */ rt->is_deleted = 1; - }); - /* *INDENT-ON* */ + } vlib_node_rename (vm, hw->output_node_index, "interface-%d-output-deleted", hw_if_index); vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted", hw_if_index); + vlib_unregister_errors (vm, hw->output_node_index); + vlib_unregister_errors (vm, hw->tx_node_index); vec_add2 (im->deleted_hw_interface_nodes, dn, 1); dn->tx_node_index = hw->tx_node_index; dn->output_node_index = hw->output_node_index; } - hash_unset_mem (im->hw_interface_by_name, hw->name); vec_free (hw->name); - vec_free (hw->input_node_thread_index_by_queue); - vec_free (hw->dq_runtime_index_by_queue); - + vec_free (hw->hw_address); + vec_free (hw->output_node_thread_runtimes); pool_put (im->hw_interfaces, hw); } @@ -988,53 +1161,49 @@ vnet_hw_interface_walk_sw (vnet_main_t * vnm, u32 id, sw_if_index; hi = vnet_get_hw_interface (vnm, hw_if_index); - /* the super first, then the and sub interfaces */ - fn (vnm, hi->sw_if_index, ctx); + /* the super first, then the sub interfaces */ + if (WALK_STOP == fn (vnm, hi->sw_if_index, ctx)) + return; - /* *INDENT-OFF* */ hash_foreach (id, sw_if_index, hi->sub_interface_sw_if_index_by_id, ({ - fn (vnm, sw_if_index, ctx); + if (WALK_STOP == fn (vnm, sw_if_index, ctx)) + break; })); - /* *INDENT-ON* */ } -static void -serialize_vnet_hw_interface_set_class (serialize_main_t * m, va_list * va) +void +vnet_hw_interface_walk (vnet_main_t * vnm, + vnet_hw_interface_walk_t fn, void *ctx) { - u32 hw_if_index = va_arg (*va, u32); - char *hw_class_name = va_arg (*va, char *); - serialize_integer (m, hw_if_index, sizeof (hw_if_index)); - serialize_cstring (m, hw_class_name); -} + vnet_interface_main_t *im; + vnet_hw_interface_t *hi; -static void -unserialize_vnet_hw_interface_set_class (serialize_main_t * m, va_list * va) -{ - CLIB_UNUSED (mc_main_t * mc) = va_arg (*va, mc_main_t *); - vnet_main_t *vnm = vnet_get_main (); - u32 hw_if_index; - char *hw_class_name; - uword *p; - clib_error_t *error; + im = &vnm->interface_main; - unserialize_integer (m, &hw_if_index, sizeof (hw_if_index)); - unserialize_cstring (m, &hw_class_name); - p = - hash_get (vnm->interface_main.hw_interface_class_by_name, hw_class_name); - ASSERT (p != 0); - error = vnet_hw_interface_set_class_helper (vnm, hw_if_index, p[0], - /* redistribute */ 0); - if (error) - clib_error_report (error); + pool_foreach (hi, im->hw_interfaces) + { + if (WALK_STOP == fn(vnm, hi->hw_if_index, ctx)) + break; + } } -MC_SERIALIZE_MSG (vnet_hw_interface_set_class_msg, static) = +void +vnet_sw_interface_walk (vnet_main_t * vnm, + vnet_sw_interface_walk_t fn, void *ctx) { -.name = "vnet_hw_interface_set_class",.serialize = - serialize_vnet_hw_interface_set_class,.unserialize = - unserialize_vnet_hw_interface_set_class,}; + vnet_interface_main_t *im; + vnet_sw_interface_t *si; + + im = &vnm->interface_main; + + pool_foreach (si, im->sw_interfaces) + { + if (WALK_STOP == fn (vnm, si, ctx)) + break; + } +} void vnet_hw_interface_init_for_class (vnet_main_t * vnm, u32 hw_if_index, @@ -1087,13 +1256,6 @@ vnet_hw_interface_set_class_helper (vnet_main_t * vnm, u32 hw_if_index, "%v class cannot be changed from %s to %s", hi->name, old_class->name, new_class->name); - if (vnm->vlib_main->mc_main) - { - mc_serialize (vnm->vlib_main->mc_main, - &vnet_hw_interface_set_class_msg, hw_if_index, - new_class->name); - return 0; - } } if (old_class->hw_class_change) @@ -1131,11 +1293,6 @@ vnet_hw_interface_rx_redirect_to_node_helper (vnet_main_t * vnm, vnet_device_class_t *dev_class = vnet_get_device_class (vnm, hi->dev_class_index); - if (redistribute) - { - /* $$$$ fixme someday maybe */ - ASSERT (vnm->vlib_main->mc_main == 0); - } if (dev_class->rx_redirect_to_node) { dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index); @@ -1183,8 +1340,12 @@ vnet_hw_interface_compare (vnet_main_t * vnm, int vnet_sw_interface_is_p2p (vnet_main_t * vnm, u32 sw_if_index) { - vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); - if (si->type == VNET_SW_INTERFACE_TYPE_P2P) + vnet_sw_interface_t *si = vnet_get_sw_interface_or_null (vnm, sw_if_index); + if (si == NULL) + return -1; + + if ((si->type == VNET_SW_INTERFACE_TYPE_P2P) || + (si->type == VNET_SW_INTERFACE_TYPE_PIPE)) return 1; vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); @@ -1194,6 +1355,59 @@ vnet_sw_interface_is_p2p (vnet_main_t * vnm, u32 sw_if_index) return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P); } +int +vnet_sw_interface_is_nbma (vnet_main_t * vnm, u32 sw_if_index) +{ + vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); + vnet_hw_interface_class_t *hc = + vnet_get_hw_interface_class (vnm, hw->hw_class_index); + + return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_NBMA); +} + +clib_error_t * +vnet_sw_interface_supports_addressing (vnet_main_t *vnm, u32 sw_if_index) +{ + if (sw_if_index == 0) + { + return clib_error_create ( + "local0 interface doesn't support IP addressing"); + } + + if (vnet_sw_interface_is_sub (vnm, sw_if_index)) + { + vnet_sw_interface_t *si; + si = vnet_get_sw_interface_or_null (vnm, sw_if_index); + if (si && si->type == VNET_SW_INTERFACE_TYPE_SUB && + si->sub.eth.flags.exact_match == 0) + { + return clib_error_create ( + "sub-interface without exact-match doesn't support IP addressing"); + } + } + return NULL; +} + +u32 +vnet_register_device_class (vlib_main_t *vm, vnet_device_class_t *c) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_interface_main_t *im = &vnm->interface_main; + c->index = vec_len (im->device_classes); + hash_set_mem (im->device_class_by_name, c->name, c->index); + + /* to avoid confusion, please remove ".tx_function" statement + from VNET_DEVICE_CLASS() if using function candidates */ + ASSERT (c->tx_fn_registrations == 0 || c->tx_function == 0); + + if (c->tx_fn_registrations) + c->tx_function = + vlib_node_get_preferred_node_fn_variant (vm, c->tx_fn_registrations); + + vec_add1 (im->device_classes, c[0]); + return c->index; +} + clib_error_t * vnet_interface_init (vlib_main_t * vm) { @@ -1220,46 +1434,38 @@ vnet_interface_init (vlib_main_t * vm) sizeof (b->opaque), sizeof (vnet_buffer_opaque_t)); } - im->sw_if_counter_lock = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, - CLIB_CACHE_LINE_BYTES); - im->sw_if_counter_lock[0] = 1; /* should be no need */ + clib_spinlock_init (&im->sw_if_counter_lock); + clib_spinlock_lock (&im->sw_if_counter_lock); /* should be no need */ vec_validate (im->sw_if_counters, VNET_N_SIMPLE_INTERFACE_COUNTER - 1); - im->sw_if_counters[VNET_INTERFACE_COUNTER_DROP].name = "drops"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_PUNT].name = "punts"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_IP4].name = "ip4"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_IP6].name = "ip6"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_RX_NO_BUF].name = "rx-no-buf"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_RX_MISS].name = "rx-miss"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_RX_ERROR].name = "rx-error"; - im->sw_if_counters[VNET_INTERFACE_COUNTER_TX_ERROR].name = "tx-error"; - - vec_validate (im->combined_sw_if_counters, - VNET_N_COMBINED_INTERFACE_COUNTER - 1); - im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_RX].name = "rx"; - im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_TX].name = "tx"; - - im->sw_if_counter_lock[0] = 0; +#define _(E,n,p) \ + im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \ + im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n; + foreach_simple_interface_counter_name +#undef _ + vec_validate (im->combined_sw_if_counters, + VNET_N_COMBINED_INTERFACE_COUNTER - 1); +#define _(E,n,p) \ + im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \ + im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n; + foreach_combined_interface_counter_name +#undef _ + clib_spinlock_unlock (&im->sw_if_counter_lock); im->device_class_by_name = hash_create_string ( /* size */ 0, sizeof (uword)); - { - vnet_device_class_t *c; - c = vnm->device_class_registrations; - - while (c) - { - c->index = vec_len (im->device_classes); - hash_set_mem (im->device_class_by_name, c->name, c->index); - vec_add1 (im->device_classes, c[0]); - c = c->next_class_registration; - } - } + for (vnet_device_class_t *c = vnm->device_class_registrations; c; + c = c->next_class_registration) + vnet_register_device_class (vm, c); im->hw_interface_class_by_name = hash_create_string ( /* size */ 0, sizeof (uword)); + im->rxq_index_by_hw_if_index_and_queue_id = + hash_create_mem (0, sizeof (u64), sizeof (u32)); + im->txq_index_by_hw_if_index_and_queue_id = + hash_create_mem (0, sizeof (u64), sizeof (u32)); im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64), sizeof (uword)); { @@ -1282,16 +1488,15 @@ vnet_interface_init (vlib_main_t * vm) } } + /* init per-thread data */ + vec_validate_aligned (im->per_thread_data, vlib_num_workers (), + CLIB_CACHE_LINE_BYTES); + if ((error = vlib_call_init_function (vm, vnet_interface_cli_init))) return error; vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword)); -#if VLIB_BUFFER_TRACE_TRAJECTORY > 0 - if ((error = vlib_call_init_function (vm, trajectory_trace_init))) - return error; -#endif - return 0; } @@ -1363,22 +1568,68 @@ vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name) return error; } +clib_error_t * +vnet_hw_interface_add_del_mac_address (vnet_main_t * vnm, + u32 hw_if_index, + const u8 * mac_address, u8 is_add) +{ + clib_error_t *error = 0; + vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); + + vnet_device_class_t *dev_class = + vnet_get_device_class (vnm, hi->dev_class_index); + + if (!hi->hw_address) + { + error = + clib_error_return + (0, "Secondary MAC Addresses not supported for interface index %u", + hw_if_index); + goto done; + } + + if (dev_class->mac_addr_add_del_function) + error = dev_class->mac_addr_add_del_function (hi, mac_address, is_add); + + if (!error) + { + vnet_hw_interface_class_t *hw_class; + + hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index); + + if (NULL != hw_class->mac_addr_add_del_function) + error = hw_class->mac_addr_add_del_function (hi, mac_address, is_add); + } + + /* If no errors, add to the list of secondary MACs on the ethernet intf */ + if (!error) + ethernet_interface_add_del_address (ðernet_main, hw_if_index, + mac_address, is_add); + +done: + if (error) + log_err ("hw_add_del_mac_address: %U", format_clib_error, error); + return error; +} + static clib_error_t * vnet_hw_interface_change_mac_address_helper (vnet_main_t * vnm, u32 hw_if_index, - u8 * mac_address) + const u8 * mac_address) { clib_error_t *error = 0; vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); if (hi->hw_address) { + u8 *old_address = vec_dup (hi->hw_address); vnet_device_class_t *dev_class = vnet_get_device_class (vnm, hi->dev_class_index); if (dev_class->mac_addr_change_function) { error = - dev_class->mac_addr_change_function (hi, (char *) mac_address); + dev_class->mac_addr_change_function (hi, old_address, + mac_address); } if (!error) { @@ -1387,7 +1638,7 @@ vnet_hw_interface_change_mac_address_helper (vnet_main_t * vnm, hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index); if (NULL != hw_class->mac_addr_change_function) - hw_class->mac_addr_change_function (hi, (char *) mac_address); + hw_class->mac_addr_change_function (hi, old_address, mac_address); } else { @@ -1395,6 +1646,7 @@ vnet_hw_interface_change_mac_address_helper (vnet_main_t * vnm, clib_error_return (0, "MAC Address Change is not supported on this interface"); } + vec_free (old_address); } else { @@ -1408,12 +1660,94 @@ vnet_hw_interface_change_mac_address_helper (vnet_main_t * vnm, clib_error_t * vnet_hw_interface_change_mac_address (vnet_main_t * vnm, u32 hw_if_index, - u8 * mac_address) + const u8 * mac_address) { return vnet_hw_interface_change_mac_address_helper (vnm, hw_if_index, mac_address); } +static int +vnet_sw_interface_check_table_same (u32 unnumbered_sw_if_index, + u32 ip_sw_if_index) +{ + if (ip4_main.fib_index_by_sw_if_index[unnumbered_sw_if_index] != + ip4_main.fib_index_by_sw_if_index[ip_sw_if_index]) + return VNET_API_ERROR_UNEXPECTED_INTF_STATE; + + if (ip4_main.mfib_index_by_sw_if_index[unnumbered_sw_if_index] != + ip4_main.mfib_index_by_sw_if_index[ip_sw_if_index]) + return VNET_API_ERROR_UNEXPECTED_INTF_STATE; + + if (ip6_main.fib_index_by_sw_if_index[unnumbered_sw_if_index] != + ip6_main.fib_index_by_sw_if_index[ip_sw_if_index]) + return VNET_API_ERROR_UNEXPECTED_INTF_STATE; + + if (ip6_main.mfib_index_by_sw_if_index[unnumbered_sw_if_index] != + ip6_main.mfib_index_by_sw_if_index[ip_sw_if_index]) + return VNET_API_ERROR_UNEXPECTED_INTF_STATE; + + return 0; +} + +/* update the unnumbered state of an interface*/ +int +vnet_sw_interface_update_unnumbered (u32 unnumbered_sw_if_index, + u32 ip_sw_if_index, u8 enable) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_sw_interface_t *si; + u32 was_unnum; + int rv = 0; + + si = vnet_get_sw_interface (vnm, unnumbered_sw_if_index); + was_unnum = (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED); + + if (enable) + { + rv = vnet_sw_interface_check_table_same (unnumbered_sw_if_index, + ip_sw_if_index); + if (rv != 0) + return rv; + si->flags |= VNET_SW_INTERFACE_FLAG_UNNUMBERED; + si->unnumbered_sw_if_index = ip_sw_if_index; + + ip4_main.lookup_main.if_address_pool_index_by_sw_if_index + [unnumbered_sw_if_index] = + ip4_main. + lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index]; + ip6_main. + lookup_main.if_address_pool_index_by_sw_if_index + [unnumbered_sw_if_index] = + ip6_main. + lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index]; + } + else + { + /* + * Unless the interface is actually unnumbered, don't + * smash e.g. if_address_pool_index_by_sw_if_index + */ + if (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) + { + si->flags &= ~(VNET_SW_INTERFACE_FLAG_UNNUMBERED); + si->unnumbered_sw_if_index = (u32) ~0; + + ip4_main.lookup_main + .if_address_pool_index_by_sw_if_index[unnumbered_sw_if_index] = ~0; + ip6_main.lookup_main + .if_address_pool_index_by_sw_if_index[unnumbered_sw_if_index] = ~0; + } + } + + if (was_unnum != (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)) + { + ip4_sw_interface_enable_disable (unnumbered_sw_if_index, enable); + ip6_sw_interface_enable_disable (unnumbered_sw_if_index, enable); + } + + return 0; +} + vnet_l3_packet_type_t vnet_link_to_l3_proto (vnet_link_t link) { @@ -1436,6 +1770,22 @@ vnet_link_to_l3_proto (vnet_link_t link) return (0); } +vnet_mtu_t +vnet_link_to_mtu (vnet_link_t link) +{ + switch (link) + { + case VNET_LINK_IP4: + return (VNET_MTU_IP4); + case VNET_LINK_IP6: + return (VNET_MTU_IP6); + case VNET_LINK_MPLS: + return (VNET_MTU_MPLS); + default: + return (VNET_MTU_L3); + } +} + u8 * default_build_rewrite (vnet_main_t * vnm, u32 sw_if_index, @@ -1457,8 +1807,9 @@ default_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai) adj_glean_update_rewrite (ai); break; case IP_LOOKUP_NEXT_ARP: + case IP_LOOKUP_NEXT_BCAST: /* - * default rewirte in neighbour adj + * default rewrite in neighbour adj */ adj_nbr_update_rewrite (ai, @@ -1477,7 +1828,7 @@ default_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai) vnet_build_rewrite_for_sw_interface (vnm, sw_if_index, adj_get_link_type (ai), - NULL), 0, 0); + NULL), 0); break; case IP_LOOKUP_NEXT_DROP: case IP_LOOKUP_NEXT_PUNT: @@ -1492,6 +1843,96 @@ default_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai) } } +clib_error_t * +vnet_hw_interface_set_rss_queues (vnet_main_t * vnm, + vnet_hw_interface_t * hi, + clib_bitmap_t * bitmap) +{ + clib_error_t *error = 0; + vnet_device_class_t *dev_class = + vnet_get_device_class (vnm, hi->dev_class_index); + + if (dev_class->set_rss_queues_function) + { + if (clib_bitmap_count_set_bits (bitmap) == 0) + { + error = clib_error_return (0, + "must assign at least one valid rss queue"); + goto done; + } + + error = dev_class->set_rss_queues_function (vnm, hi, bitmap); + } + else + { + error = clib_error_return (0, + "setting rss queues is not supported on this interface"); + } + + if (!error) + { + clib_bitmap_free (hi->rss_queues); + hi->rss_queues = clib_bitmap_dup (bitmap); + } + +done: + if (error) + log_err ("hw_set_rss_queues: %U", format_clib_error, error); + return error; +} + +int collect_detailed_interface_stats_flag = 0; + +void +collect_detailed_interface_stats_flag_set (void) +{ + collect_detailed_interface_stats_flag = 1; +} + +void +collect_detailed_interface_stats_flag_clear (void) +{ + collect_detailed_interface_stats_flag = 0; +} + +static clib_error_t * +collect_detailed_interface_stats_cli (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, *line_input = &_line_input; + clib_error_t *error = NULL; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return clib_error_return (0, "expected enable | disable"); + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "enable") || unformat (line_input, "on")) + collect_detailed_interface_stats_flag_set (); + else if (unformat (line_input, "disable") + || unformat (line_input, "off")) + collect_detailed_interface_stats_flag_clear (); + else + { + error = clib_error_return (0, "unknown input `%U'", + format_unformat_error, line_input); + goto done; + } + } + +done: + unformat_free (line_input); + return error; +} + +VLIB_CLI_COMMAND (collect_detailed_interface_stats_command, static) = { + .path = "interface collect detailed-stats", + .short_help = "interface collect detailed-stats ", + .function = collect_detailed_interface_stats_cli, +}; + /* * fd.io coding-style-patch-verification: ON *