diff options
Diffstat (limited to 'vpp/vnet/vnet/srp')
| -rw-r--r-- | vpp/vnet/vnet/srp/format.c | 147 | ||||
| -rw-r--r-- | vpp/vnet/vnet/srp/interface.c | 458 | ||||
| -rw-r--r-- | vpp/vnet/vnet/srp/node.c | 932 | ||||
| -rw-r--r-- | vpp/vnet/vnet/srp/packet.h | 204 | ||||
| -rw-r--r-- | vpp/vnet/vnet/srp/pg.c | 157 | ||||
| -rw-r--r-- | vpp/vnet/vnet/srp/srp.h | 222 |
6 files changed, 2120 insertions, 0 deletions
diff --git a/vpp/vnet/vnet/srp/format.c b/vpp/vnet/vnet/srp/format.c new file mode 100644 index 00000000..a0250cc9 --- /dev/null +++ b/vpp/vnet/vnet/srp/format.c @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * srp_format.c: srp formatting/parsing. + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/srp/srp.h> +#include <vnet/ethernet/ethernet.h> + +static u8 * format_srp_mode (u8 * s, va_list * args) +{ + u32 mode = va_arg (*args, u32); + char * t = 0; + switch (mode) + { +#define _(f) case SRP_MODE_##f: t = #f; break; + foreach_srp_mode +#undef _ + default: t = 0; break; + } + if (t) + s = format (s, "%s", t); + else + s = format (s, "unknown 0x%x", mode); + + return s; +} + +u8 * format_srp_header_with_length (u8 * s, va_list * args) +{ + srp_and_ethernet_header_t * h = va_arg (*args, srp_and_ethernet_header_t *); + u32 max_header_bytes = va_arg (*args, u32); + ethernet_main_t * em = ðernet_main; + uword indent, header_bytes; + + header_bytes = sizeof (h[0]); + if (max_header_bytes != 0 && header_bytes > max_header_bytes) + return format (s, "srp header truncated"); + + indent = format_get_indent (s); + + s = format (s, "mode %U, ring %s, priority %d, ttl %d", + format_srp_mode, h->srp.mode, + h->srp.is_inner_ring ? "inner" : "outer", + h->srp.priority, h->srp.ttl); + + s = format (s, "\n%U%U: %U -> %U", + format_white_space, indent, + format_ethernet_type, clib_net_to_host_u16 (h->ethernet.type), + format_ethernet_address, h->ethernet.src_address, + format_ethernet_address, h->ethernet.dst_address); + + if (max_header_bytes != 0 && header_bytes < max_header_bytes) + { + ethernet_type_info_t * ti; + vlib_node_t * node; + + ti = ethernet_get_type_info (em, h->ethernet.type); + node = ti ? vlib_get_node (em->vlib_main, ti->node_index) : 0; + if (node && node->format_buffer) + s = format (s, "\n%U%U", + format_white_space, indent, + node->format_buffer, (void *) h + header_bytes, + max_header_bytes - header_bytes); + } + + return s; +} + +u8 * format_srp_header (u8 * s, va_list * args) +{ + srp_header_t * m = va_arg (*args, srp_header_t *); + return format (s, "%U", format_srp_header_with_length, m, 0); +} + +uword +unformat_srp_header (unformat_input_t * input, va_list * args) +{ + u8 ** result = va_arg (*args, u8 **); + srp_and_ethernet_header_t * h; + + { + void * p; + vec_add2 (*result, p, sizeof (h[0])); + h = p; + } + + if (! unformat (input, "%U: %U -> %U", + unformat_ethernet_type_net_byte_order, &h->ethernet.type, + unformat_ethernet_address, &h->ethernet.src_address, + unformat_ethernet_address, &h->ethernet.dst_address)) + return 0; + + h->srp.mode = SRP_MODE_data; + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + u32 x; + + if (unformat (input, "control")) + h->srp.mode = SRP_MODE_control_pass_to_host; + + else if (unformat (input, "pri %d", &x)) + h->srp.priority = x; + + else if (unformat (input, "ttl %d", &x)) + h->srp.ttl = x; + + else + return 0; + } + + return 1; +} diff --git a/vpp/vnet/vnet/srp/interface.c b/vpp/vnet/vnet/srp/interface.c new file mode 100644 index 00000000..d427cc3c --- /dev/null +++ b/vpp/vnet/vnet/srp/interface.c @@ -0,0 +1,458 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * srp_interface.c: srp interfaces + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vnet/vnet.h> +#include <vnet/pg/pg.h> +#include <vnet/srp/srp.h> + +static u8* +srp_build_rewrite (vnet_main_t * vnm, + u32 sw_if_index, + vnet_link_t link_type, + const void * dst_address) +{ + vnet_hw_interface_t * hw = vnet_get_sup_hw_interface (vnm, sw_if_index); + srp_main_t * sm = &srp_main; + srp_and_ethernet_header_t * h; + u8* rewrite = NULL; + u16 type; + uword n_bytes = sizeof (h[0]); + + switch (link_type) { +#define _(a,b) case VNET_LINK_##a: type = ETHERNET_TYPE_##b; break + _ (IP4, IP4); + _ (IP6, IP6); + _ (MPLS, MPLS_UNICAST); + _ (ARP, ARP); +#undef _ + default: + return (NULL); + } + + vec_validate(rewrite, n_bytes-1); + h = (srp_and_ethernet_header_t *)rewrite; + + clib_memcpy (h->ethernet.src_address, hw->hw_address, sizeof (h->ethernet.src_address)); + if (dst_address) + clib_memcpy (h->ethernet.dst_address, dst_address, sizeof (h->ethernet.dst_address)); + else + memset (h->ethernet.dst_address, ~0, sizeof (h->ethernet.dst_address)); /* broadcast */ + + h->ethernet.type = clib_host_to_net_u16 (type); + + h->srp.as_u16 = 0; + h->srp.mode = SRP_MODE_data; + h->srp.ttl = sm->default_data_ttl; + srp_header_compute_parity (&h->srp); + + return (rewrite); +} + +static void srp_register_interface_helper (u32 * hw_if_indices_by_side, u32 redistribute); + +void serialize_srp_main (serialize_main_t * m, va_list * va) +{ + srp_main_t * sm = &srp_main; + srp_interface_t * si; + + serialize_integer (m, pool_elts (sm->interface_pool), sizeof (u32)); + pool_foreach (si, sm->interface_pool, ({ + serialize_integer (m, si->rings[SRP_RING_OUTER].hw_if_index, sizeof (u32)); + serialize_integer (m, si->rings[SRP_RING_INNER].hw_if_index, sizeof (u32)); + })); +} + +void unserialize_srp_main (serialize_main_t * m, va_list * va) +{ + u32 i, n_ifs, hw_if_indices[SRP_N_RING]; + + unserialize_integer (m, &n_ifs, sizeof (u32)); + for (i = 0; i < n_ifs; i++) + { + unserialize_integer (m, &hw_if_indices[SRP_RING_OUTER], sizeof (u32)); + unserialize_integer (m, &hw_if_indices[SRP_RING_INNER], sizeof (u32)); + srp_register_interface_helper (hw_if_indices, /* redistribute */ 0); + } +} + +static void serialize_srp_register_interface_msg (serialize_main_t * m, va_list * va) +{ + u32 * hw_if_indices = va_arg (*va, u32 *); + serialize_integer (m, hw_if_indices[SRP_SIDE_A], sizeof (hw_if_indices[SRP_SIDE_A])); + serialize_integer (m, hw_if_indices[SRP_SIDE_B], sizeof (hw_if_indices[SRP_SIDE_B])); +} + +static void unserialize_srp_register_interface_msg (serialize_main_t * m, va_list * va) +{ + CLIB_UNUSED (mc_main_t * mcm) = va_arg (*va, mc_main_t *); + u32 hw_if_indices[SRP_N_SIDE]; + srp_main_t * sm = &srp_main; + uword * p; + + unserialize_integer (m, &hw_if_indices[SRP_SIDE_A], sizeof (hw_if_indices[SRP_SIDE_A])); + unserialize_integer (m, &hw_if_indices[SRP_SIDE_B], sizeof (hw_if_indices[SRP_SIDE_B])); + + p = hash_get (sm->srp_register_interface_waiting_process_pool_index_by_hw_if_index, + hw_if_indices[0]); + if (p) + { + vlib_one_time_waiting_process_t * wp = pool_elt_at_index (sm->srp_register_interface_waiting_process_pool, p[0]); + vlib_signal_one_time_waiting_process (mcm->vlib_main, wp); + pool_put (sm->srp_register_interface_waiting_process_pool, wp); + hash_unset (sm->srp_register_interface_waiting_process_pool_index_by_hw_if_index, + hw_if_indices[0]); + } + else + srp_register_interface_helper (hw_if_indices, /* redistribute */ 0); +} + +MC_SERIALIZE_MSG (srp_register_interface_msg, static) = { + .name = "vnet_srp_register_interface", + .serialize = serialize_srp_register_interface_msg, + .unserialize = unserialize_srp_register_interface_msg, +}; + +static void srp_register_interface_helper (u32 * hw_if_indices_by_side, u32 redistribute) +{ + vnet_main_t * vnm = vnet_get_main(); + srp_main_t * sm = &srp_main; + vlib_main_t * vm = sm->vlib_main; + srp_interface_t * si; + vnet_hw_interface_t * hws[SRP_N_RING]; + uword s, * p; + + if (vm->mc_main && redistribute) + { + vlib_one_time_waiting_process_t * wp; + mc_serialize (vm->mc_main, &srp_register_interface_msg, hw_if_indices_by_side); + pool_get (sm->srp_register_interface_waiting_process_pool, wp); + hash_set (sm->srp_register_interface_waiting_process_pool_index_by_hw_if_index, + hw_if_indices_by_side[0], + wp - sm->srp_register_interface_waiting_process_pool); + vlib_current_process_wait_for_one_time_event (vm, wp); + } + + /* Check if interface has already been registered. */ + p = hash_get (sm->interface_index_by_hw_if_index, hw_if_indices_by_side[0]); + if (p) + { + si = pool_elt_at_index (sm->interface_pool, p[0]); + } + else + { + pool_get (sm->interface_pool, si); + memset (si, 0, sizeof (si[0])); + } + for (s = 0; s < SRP_N_SIDE; s++) + { + hws[s] = vnet_get_hw_interface (vnm, hw_if_indices_by_side[s]); + si->rings[s].ring = s; + si->rings[s].hw_if_index = hw_if_indices_by_side[s]; + si->rings[s].sw_if_index = hws[s]->sw_if_index; + hash_set (sm->interface_index_by_hw_if_index, hw_if_indices_by_side[s], si - sm->interface_pool); + } + + /* Inherit MAC address from outer ring. */ + clib_memcpy (si->my_address, hws[SRP_RING_OUTER]->hw_address, + vec_len (hws[SRP_RING_OUTER]->hw_address)); + + /* Default time to wait to restore signal. */ + si->config.wait_to_restore_idle_delay = 60; + si->config.ips_tx_interval = 1; +} + +void srp_register_interface (u32 * hw_if_indices_by_side) +{ + srp_register_interface_helper (hw_if_indices_by_side, /* redistribute */ 1); +} + +void srp_interface_set_hw_wrap_function (u32 hw_if_index, srp_hw_wrap_function_t * f) +{ + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + si->hw_wrap_function = f; +} + +void srp_interface_set_hw_enable_function (u32 hw_if_index, srp_hw_enable_function_t * f) +{ + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + si->hw_enable_function = f; +} + +void srp_interface_enable_ips (u32 hw_if_index) +{ + srp_main_t * sm = &srp_main; + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + + si->ips_process_enable = 1; + + vlib_node_set_state (sm->vlib_main, srp_ips_process_node.index, VLIB_NODE_STATE_POLLING); +} + +static uword +srp_is_valid_class_for_interface (vnet_main_t * vnm, u32 hw_if_index, u32 hw_class_index) +{ + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + + if (! si) + return 0; + + /* Both sides must be admin down. */ + if (vnet_sw_interface_is_admin_up (vnm, si->rings[SRP_RING_OUTER].sw_if_index)) + return 0; + if (vnet_sw_interface_is_admin_up (vnm, si->rings[SRP_RING_INNER].sw_if_index)) + return 0; + + return 1; +} + +static void +srp_interface_hw_class_change (vnet_main_t * vnm, u32 hw_if_index, + u32 old_hw_class_index, u32 new_hw_class_index) +{ + srp_main_t * sm = &srp_main; + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + vnet_hw_interface_t * hi; + vnet_device_class_t * dc; + u32 r, to_srp; + + if (!si) { + clib_warning ("srp interface no set si = 0"); + return; + } + + to_srp = new_hw_class_index == srp_hw_interface_class.index; + + /* Changing class on either outer or inner rings implies changing the class + of the other. */ + for (r = 0; r < SRP_N_RING; r++) + { + srp_interface_ring_t * ir = &si->rings[r]; + + hi = vnet_get_hw_interface (vnm, ir->hw_if_index); + dc = vnet_get_device_class (vnm, hi->dev_class_index); + + /* hw_if_index itself will be handled by caller. */ + if (ir->hw_if_index != hw_if_index) + { + vnet_hw_interface_init_for_class (vnm, ir->hw_if_index, + new_hw_class_index, + to_srp ? si - sm->interface_pool : ~0); + + if (dc->hw_class_change) + dc->hw_class_change (vnm, ir->hw_if_index, new_hw_class_index); + } + else + hi->hw_instance = to_srp ? si - sm->interface_pool : ~0; + } + + if (si->hw_enable_function) + si->hw_enable_function (si, /* enable */ to_srp); +} + +VNET_HW_INTERFACE_CLASS (srp_hw_interface_class) = { + .name = "SRP", + .format_address = format_ethernet_address, + .format_header = format_srp_header_with_length, + .format_device = format_srp_device, + .unformat_hw_address = unformat_ethernet_address, + .unformat_header = unformat_srp_header, + .build_rewrite = srp_build_rewrite, + .update_adjacency = ethernet_update_adjacency, + .is_valid_class_for_interface = srp_is_valid_class_for_interface, + .hw_class_change = srp_interface_hw_class_change, +}; + +static void serialize_srp_interface_config_msg (serialize_main_t * m, va_list * va) +{ + srp_interface_t * si = va_arg (*va, srp_interface_t *); + srp_main_t * sm = &srp_main; + + ASSERT (! pool_is_free (sm->interface_pool, si)); + serialize_integer (m, si - sm->interface_pool, sizeof (u32)); + serialize (m, serialize_f64, si->config.wait_to_restore_idle_delay); + serialize (m, serialize_f64, si->config.ips_tx_interval); +} + +static void unserialize_srp_interface_config_msg (serialize_main_t * m, va_list * va) +{ + CLIB_UNUSED (mc_main_t * mcm) = va_arg (*va, mc_main_t *); + srp_main_t * sm = &srp_main; + srp_interface_t * si; + u32 si_index; + + unserialize_integer (m, &si_index, sizeof (u32)); + si = pool_elt_at_index (sm->interface_pool, si_index); + unserialize (m, unserialize_f64, &si->config.wait_to_restore_idle_delay); + unserialize (m, unserialize_f64, &si->config.ips_tx_interval); +} + +MC_SERIALIZE_MSG (srp_interface_config_msg, static) = { + .name = "vnet_srp_interface_config", + .serialize = serialize_srp_interface_config_msg, + .unserialize = unserialize_srp_interface_config_msg, +}; + +void srp_interface_get_interface_config (u32 hw_if_index, srp_interface_config_t * c) +{ + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + ASSERT (si != 0); + c[0] = si->config; +} + +void srp_interface_set_interface_config (u32 hw_if_index, srp_interface_config_t * c) +{ + srp_main_t * sm = &srp_main; + vlib_main_t * vm = sm->vlib_main; + srp_interface_t * si = srp_get_interface_from_vnet_hw_interface (hw_if_index); + ASSERT (si != 0); + if (memcmp (&si->config, &c[0], sizeof (c[0]))) + { + si->config = c[0]; + if (vm->mc_main) + mc_serialize (vm->mc_main, &srp_interface_config_msg, si); + } +} + +#if DEBUG > 0 + +#define VNET_SIMULATED_SRP_TX_NEXT_SRP_INPUT VNET_INTERFACE_TX_N_NEXT + +/* Echo packets back to srp input. */ +static uword +simulated_srp_interface_tx (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, n_left_to_next, n_copy, * from, * to_next; + u32 next_index = VNET_SIMULATED_SRP_TX_NEXT_SRP_INPUT; + u32 i; + vlib_buffer_t * b; + + n_left_from = frame->n_vectors; + from = vlib_frame_args (frame); + + while (n_left_from > 0) + { + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); + + n_copy = clib_min (n_left_from, n_left_to_next); + + clib_memcpy (to_next, from, n_copy * sizeof (from[0])); + n_left_to_next -= n_copy; + n_left_from -= n_copy; + for (i = 0; i < n_copy; i++) + { + b = vlib_get_buffer (vm, from[i]); + /* TX interface will be fake eth; copy to RX for benefit of srp-input. */ + b->sw_if_index[VLIB_RX] = b->sw_if_index[VLIB_TX]; + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + return n_left_from; +} + +static u8 * format_simulated_srp_name (u8 * s, va_list * args) +{ + u32 dev_instance = va_arg (*args, u32); + return format (s, "fake-srp%d", dev_instance); +} + +VNET_DEVICE_CLASS (srp_simulated_device_class,static) = { + .name = "Simulated srp", + .format_device_name = format_simulated_srp_name, + .tx_function = simulated_srp_interface_tx, +}; + +static clib_error_t * +create_simulated_srp_interfaces (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + vnet_main_t * vnm = vnet_get_main(); + u8 address[6]; + u32 hw_if_index; + vnet_hw_interface_t * hi; + static u32 instance; + + if (! unformat_user (input, unformat_ethernet_address, &address)) + { + memset (address, 0, sizeof (address)); + address[0] = 0xde; + address[1] = 0xad; + address[5] = instance; + } + + hw_if_index = vnet_register_interface (vnm, + srp_simulated_device_class.index, + instance++, + srp_hw_interface_class.index, 0); + + hi = vnet_get_hw_interface (vnm, hw_if_index); + + srp_setup_node (vm, hi->output_node_index); + + hi->min_packet_bytes = 40 + 16; + + /* Standard default ethernet MTU. */ + hi->max_l3_packet_bytes[VLIB_RX] = hi->max_l3_packet_bytes[VLIB_TX] = 1500; + + vec_free (hi->hw_address); + vec_add (hi->hw_address, address, sizeof (address)); + + { + uword slot; + + slot = vlib_node_add_named_next_with_slot + (vm, hi->tx_node_index, + "srp-input", + VNET_SIMULATED_SRP_TX_NEXT_SRP_INPUT); + ASSERT (slot == VNET_SIMULATED_SRP_TX_NEXT_SRP_INPUT); + } + + return /* no error */ 0; +} + +static VLIB_CLI_COMMAND (create_simulated_srp_interface_command) = { + .path = "srp create-interfaces", + .short_help = "Create simulated srp interface", + .function = create_simulated_srp_interfaces, +}; +#endif diff --git a/vpp/vnet/vnet/srp/node.c b/vpp/vnet/vnet/srp/node.c new file mode 100644 index 00000000..897be254 --- /dev/null +++ b/vpp/vnet/vnet/srp/node.c @@ -0,0 +1,932 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * node.c: srp packet processing + * + * Copyright (c) 2011 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/ip/ip_packet.h> /* for ip_csum_fold */ +#include <vnet/srp/srp.h> + +typedef struct { + u8 packet_data[32]; +} srp_input_trace_t; + +static u8 * format_srp_input_trace (u8 * s, va_list * va) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *); + srp_input_trace_t * t = va_arg (*va, srp_input_trace_t *); + + s = format (s, "%U", format_srp_header, t->packet_data); + + return s; +} + +typedef enum { + SRP_INPUT_NEXT_ERROR, + SRP_INPUT_NEXT_ETHERNET_INPUT, + SRP_INPUT_NEXT_CONTROL, + SRP_INPUT_N_NEXT, +} srp_input_next_t; + +typedef struct { + u8 next_index; + u8 buffer_advance; + u16 error; +} srp_input_disposition_t; + +static srp_input_disposition_t srp_input_disposition_by_mode[8] = { + [SRP_MODE_reserved0] = { + .next_index = SRP_INPUT_NEXT_ERROR, + .error = SRP_ERROR_UNKNOWN_MODE, + }, + [SRP_MODE_reserved1] = { + .next_index = SRP_INPUT_NEXT_ERROR, + .error = SRP_ERROR_UNKNOWN_MODE, + }, + [SRP_MODE_reserved2] = { + .next_index = SRP_INPUT_NEXT_ERROR, + .error = SRP_ERROR_UNKNOWN_MODE, + }, + [SRP_MODE_reserved3] = { + .next_index = SRP_INPUT_NEXT_ERROR, + .error = SRP_ERROR_UNKNOWN_MODE, + }, + [SRP_MODE_keep_alive] = { + .next_index = SRP_INPUT_NEXT_ERROR, + .error = SRP_ERROR_KEEP_ALIVE_DROPPED, + }, + [SRP_MODE_data] = { + .next_index = SRP_INPUT_NEXT_ETHERNET_INPUT, + .buffer_advance = sizeof (srp_header_t), + }, + [SRP_MODE_control_pass_to_host] = { + .next_index = SRP_INPUT_NEXT_CONTROL, + }, + [SRP_MODE_control_locally_buffered_for_host] = { + .next_index = SRP_INPUT_NEXT_CONTROL, + }, +}; + +static uword +srp_input (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * from_frame) +{ + vnet_main_t * vnm = vnet_get_main(); + srp_main_t * sm = &srp_main; + u32 n_left_from, next_index, * from, * to_next; + + from = vlib_frame_vector_args (from_frame); + n_left_from = from_frame->n_vectors; + + if (node->flags & VLIB_NODE_FLAG_TRACE) + vlib_trace_frame_buffers_only (vm, node, + from, + n_left_from, + sizeof (from[0]), + sizeof (srp_input_trace_t)); + + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 n_left_to_next; + + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); + + while (n_left_from >= 4 && n_left_to_next >= 2) + { + u32 bi0, bi1, sw_if_index0, sw_if_index1; + vlib_buffer_t * b0, * b1; + u8 next0, next1, error0, error1; + srp_header_t * s0, * s1; + srp_input_disposition_t * d0, * d1; + vnet_hw_interface_t * hi0, * hi1; + srp_interface_t * si0, * si1; + + /* Prefetch next iteration. */ + { + vlib_buffer_t * b2, * b3; + + b2 = vlib_get_buffer (vm, from[2]); + b3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header (b2, LOAD); + vlib_prefetch_buffer_header (b3, LOAD); + + CLIB_PREFETCH (b2->data, sizeof (srp_header_t), LOAD); + CLIB_PREFETCH (b3->data, sizeof (srp_header_t), LOAD); + } + + bi0 = from[0]; + bi1 = from[1]; + to_next[0] = bi0; + to_next[1] = bi1; + from += 2; + to_next += 2; + n_left_to_next -= 2; + n_left_from -= 2; + + b0 = vlib_get_buffer (vm, bi0); + b1 = vlib_get_buffer (vm, bi1); + + s0 = (void *) (b0->data + b0->current_data); + s1 = (void *) (b1->data + b1->current_data); + + /* Data packets are always assigned to side A (outer ring) interface. */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + hi0 = vnet_get_sup_hw_interface (vnm, sw_if_index0); + hi1 = vnet_get_sup_hw_interface (vnm, sw_if_index1); + + si0 = pool_elt_at_index (sm->interface_pool, hi0->hw_instance); + si1 = pool_elt_at_index (sm->interface_pool, hi1->hw_instance); + + sw_if_index0 = (s0->mode == SRP_MODE_data + ? si0->rings[SRP_RING_OUTER].sw_if_index + : sw_if_index0); + sw_if_index1 = (s1->mode == SRP_MODE_data + ? si1->rings[SRP_RING_OUTER].sw_if_index + : sw_if_index1); + + vnet_buffer (b0)->sw_if_index[VLIB_RX] = sw_if_index0; + vnet_buffer (b1)->sw_if_index[VLIB_RX] = sw_if_index1; + + d0 = srp_input_disposition_by_mode + s0->mode; + d1 = srp_input_disposition_by_mode + s1->mode; + + next0 = d0->next_index; + next1 = d1->next_index; + + error0 = d0->error; + error1 = d1->error; + + vlib_buffer_advance (b0, d0->buffer_advance); + vlib_buffer_advance (b1, d1->buffer_advance); + + b0->error = node->errors[error0]; + b1->error = node->errors[error1]; + + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + + while (n_left_from > 0 && n_left_to_next > 0) + { + u32 bi0, sw_if_index0; + vlib_buffer_t * b0; + u8 next0, error0; + srp_header_t * s0; + srp_input_disposition_t * d0; + srp_interface_t * si0; + vnet_hw_interface_t * hi0; + + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_to_next -= 1; + n_left_from -= 1; + + b0 = vlib_get_buffer (vm, bi0); + + s0 = (void *) (b0->data + b0->current_data); + + /* Data packets are always assigned to side A (outer ring) interface. */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + hi0 = vnet_get_sup_hw_interface (vnm, sw_if_index0); + + si0 = pool_elt_at_index (sm->interface_pool, hi0->hw_instance); + + sw_if_index0 = (s0->mode == SRP_MODE_data + ? si0->rings[SRP_RING_OUTER].sw_if_index + : sw_if_index0); + + vnet_buffer (b0)->sw_if_index[VLIB_RX] = sw_if_index0; + + d0 = srp_input_disposition_by_mode + s0->mode; + + next0 = d0->next_index; + + error0 = d0->error; + + vlib_buffer_advance (b0, d0->buffer_advance); + + b0->error = node->errors[error0]; + + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + return from_frame->n_vectors; +} + +static char * srp_error_strings[] = { +#define _(f,s) s, + foreach_srp_error +#undef _ +}; + +static vlib_node_registration_t srp_input_node = { + .function = srp_input, + .name = "srp-input", + /* Takes a vector of packets. */ + .vector_size = sizeof (u32), + + .n_errors = SRP_N_ERROR, + .error_strings = srp_error_strings, + + .n_next_nodes = SRP_INPUT_N_NEXT, + .next_nodes = { + [SRP_INPUT_NEXT_ERROR] = "error-drop", + [SRP_INPUT_NEXT_ETHERNET_INPUT] = "ethernet-input", + [SRP_INPUT_NEXT_CONTROL] = "srp-control", + }, + + .format_buffer = format_srp_header_with_length, + .format_trace = format_srp_input_trace, + .unformat_buffer = unformat_srp_header, +}; + +static uword +srp_topology_packet (vlib_main_t * vm, u32 sw_if_index, u8 ** contents) +{ + vnet_main_t * vnm = vnet_get_main(); + vnet_hw_interface_t * hi = vnet_get_sup_hw_interface (vnm, sw_if_index); + srp_topology_header_t * t; + srp_topology_mac_binding_t * mb; + u32 nb, nmb; + + t = (void *) *contents; + + nb = clib_net_to_host_u16 (t->n_bytes_of_data_that_follows); + nmb = (nb - sizeof (t->originator_address)) / sizeof (mb[0]); + if (vec_len (*contents) < sizeof (t[0]) + nmb * sizeof (mb[0])) + return SRP_ERROR_TOPOLOGY_BAD_LENGTH; + + /* Fill in our source MAC address. */ + clib_memcpy (t->ethernet.src_address, hi->hw_address, vec_len (hi->hw_address)); + + /* Make space for our MAC binding. */ + vec_resize (*contents, sizeof (srp_topology_mac_binding_t)); + t = (void *) *contents; + t->n_bytes_of_data_that_follows = clib_host_to_net_u16 (nb + sizeof (mb[0])); + + mb = t->bindings + nmb; + + mb->flags = + ((t->srp.is_inner_ring ? SRP_TOPOLOGY_MAC_BINDING_FLAG_IS_INNER_RING : 0) + | (/* is wrapped FIXME */ 0)); + clib_memcpy (mb->address, hi->hw_address, vec_len (hi->hw_address)); + + t->control.checksum + = ~ip_csum_fold (ip_incremental_checksum (0, &t->control, + vec_len (*contents) - STRUCT_OFFSET_OF (srp_generic_control_header_t, control))); + + { + vlib_frame_t * f = vlib_get_frame_to_node (vm, hi->output_node_index); + vlib_buffer_t * b; + u32 * to_next = vlib_frame_vector_args (f); + u32 bi; + + bi = vlib_buffer_add_data (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX, + /* buffer to append to */ 0, + *contents, vec_len (*contents)); + b = vlib_get_buffer (vm, bi); + vnet_buffer (b)->sw_if_index[VLIB_RX] = vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index; + to_next[0] = bi; + f->n_vectors = 1; + vlib_put_frame_to_node (vm, hi->output_node_index, f); + } + + return SRP_ERROR_CONTROL_PACKETS_PROCESSED; +} + +typedef uword (srp_control_handler_function_t) (vlib_main_t * vm, + u32 sw_if_index, + u8 ** contents); + +static uword +srp_control_input (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * from_frame) +{ + u32 n_left_from, next_index, * from, * to_next; + vlib_node_runtime_t * error_node; + static u8 * contents; + + error_node = vlib_node_get_runtime (vm, srp_input_node.index); + + from = vlib_frame_vector_args (from_frame); + n_left_from = from_frame->n_vectors; + + if (node->flags & VLIB_NODE_FLAG_TRACE) + vlib_trace_frame_buffers_only (vm, node, + from, + n_left_from, + sizeof (from[0]), + sizeof (srp_input_trace_t)); + + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 n_left_to_next; + + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); + + while (n_left_from > 0 && n_left_to_next > 0) + { + u32 bi0, l2_len0, l3_len0; + vlib_buffer_t * b0; + u8 next0, error0; + srp_generic_control_header_t * s0; + + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_to_next -= 1; + n_left_from -= 1; + + b0 = vlib_get_buffer (vm, bi0); + + s0 = (void *) (b0->data + b0->current_data); + l2_len0 = vlib_buffer_length_in_chain (vm, b0); + l3_len0 = l2_len0 - STRUCT_OFFSET_OF (srp_generic_control_header_t, control); + + error0 = SRP_ERROR_CONTROL_PACKETS_PROCESSED; + + error0 = s0->control.version != 0 ? SRP_ERROR_CONTROL_VERSION_NON_ZERO : error0; + + { + u16 save0 = s0->control.checksum; + u16 computed0; + s0->control.checksum = 0; + computed0 = ~ip_csum_fold (ip_incremental_checksum (0, &s0->control, l3_len0)); + error0 = save0 != computed0 ? SRP_ERROR_CONTROL_BAD_CHECKSUM : error0; + } + + if (error0 == SRP_ERROR_CONTROL_PACKETS_PROCESSED) + { + static srp_control_handler_function_t * t[SRP_N_CONTROL_PACKET_TYPE] = { + [SRP_CONTROL_PACKET_TYPE_topology] = srp_topology_packet, + }; + srp_control_handler_function_t * f; + + f = 0; + if (s0->control.type < ARRAY_LEN (t)) + f = t[s0->control.type]; + + if (f) + { + vec_validate (contents, l2_len0 - 1); + vlib_buffer_contents (vm, bi0, contents); + error0 = f (vm, vnet_buffer (b0)->sw_if_index[VLIB_RX], &contents); + } + else + error0 = SRP_ERROR_UNKNOWN_CONTROL; + } + + b0->error = error_node->errors[error0]; + next0 = 0; + + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + return from_frame->n_vectors; +} + +static vlib_node_registration_t srp_control_input_node = { + .function = srp_control_input, + .name = "srp-control", + /* Takes a vector of packets. */ + .vector_size = sizeof (u32), + + .n_next_nodes = 1, + .next_nodes = { + [0] = "error-drop", + }, + + .format_buffer = format_srp_header_with_length, + .format_trace = format_srp_input_trace, + .unformat_buffer = unformat_srp_header, +}; + +static u8 * format_srp_ips_request_type (u8 * s, va_list * args) +{ + u32 x = va_arg (*args, u32); + char * t = 0; + switch (x) + { +#define _(f,n) case SRP_IPS_REQUEST_##f: t = #f; break; + foreach_srp_ips_request_type +#undef _ + default: + return format (s, "unknown 0x%x", x); + } + return format (s, "%U", format_c_identifier, t); +} + +static u8 * format_srp_ips_status (u8 * s, va_list * args) +{ + u32 x = va_arg (*args, u32); + char * t = 0; + switch (x) + { +#define _(f,n) case SRP_IPS_STATUS_##f: t = #f; break; + foreach_srp_ips_status +#undef _ + default: + return format (s, "unknown 0x%x", x); + } + return format (s, "%U", format_c_identifier, t); +} + +static u8 * format_srp_ips_state (u8 * s, va_list * args) +{ + u32 x = va_arg (*args, u32); + char * t = 0; + switch (x) + { +#define _(f) case SRP_IPS_STATE_##f: t = #f; break; + foreach_srp_ips_state +#undef _ + default: + return format (s, "unknown 0x%x", x); + } + return format (s, "%U", format_c_identifier, t); +} + +static u8 * format_srp_ring (u8 * s, va_list * args) +{ + u32 ring = va_arg (*args, u32); + return format (s, "%s", ring == SRP_RING_INNER ? "inner" : "outer"); +} + +static u8 * format_srp_ips_header (u8 * s, va_list * args) +{ + srp_ips_header_t * h = va_arg (*args, srp_ips_header_t *); + + s = format (s, "%U, %U, %U, %s-path", + format_srp_ips_request_type, h->request_type, + format_ethernet_address, h->originator_address, + format_srp_ips_status, h->status, + h->is_long_path ? "long" : "short"); + + return s; +} + +static u8 * format_srp_interface (u8 * s, va_list * args) +{ + srp_interface_t * si = va_arg (*args, srp_interface_t *); + srp_interface_ring_t * ir; + + s = format (s, "address %U, IPS state %U", + format_ethernet_address, si->my_address, + format_srp_ips_state, si->current_ips_state); + for (ir = si->rings; ir < si->rings + SRP_N_RING; ir++) + if (ir->rx_neighbor_address_valid) + s = format (s, ", %U neighbor %U", + format_srp_ring, ir->ring, + format_ethernet_address, ir->rx_neighbor_address); + + return s; +} + +u8 * format_srp_device (u8 * s, va_list * args) +{ + u32 hw_if_index = va_arg (*args, u32); + CLIB_UNUSED (int verbose) = va_arg (*args, int); + vnet_main_t * vnm = vnet_get_main(); + srp_main_t * sm = &srp_main; + vnet_hw_interface_t * hi = vnet_get_hw_interface (vnm, hw_if_index); + srp_interface_t * si = pool_elt_at_index (sm->interface_pool, hi->hw_instance); + return format (s, "%U", format_srp_interface, si); +} + +always_inline srp_interface_t * +srp_get_interface (u32 sw_if_index, srp_ring_type_t * ring) +{ + vnet_main_t * vnm = vnet_get_main(); + srp_main_t * sm = &srp_main; + vnet_hw_interface_t * hi = vnet_get_sup_hw_interface (vnm, sw_if_index); + srp_interface_t * si; + + ASSERT (hi->hw_class_index == srp_hw_interface_class.index); + si = pool_elt_at_index (sm->interface_pool, hi->hw_instance); + + ASSERT (si->rings[SRP_RING_INNER].hw_if_index == hi->hw_if_index + || si->rings[SRP_RING_OUTER].hw_if_index == hi->hw_if_index); + if (ring) + *ring = + (hi->hw_if_index == si->rings[SRP_RING_INNER].hw_if_index + ? SRP_RING_INNER + : SRP_RING_OUTER); + + return si; +} + +static void init_ips_packet (srp_interface_t * si, + srp_ring_type_t tx_ring, + srp_ips_header_t * i) +{ + memset (i, 0, sizeof (i[0])); + + i->srp.ttl = 1; + i->srp.is_inner_ring = tx_ring; + i->srp.priority = 7; + i->srp.mode = SRP_MODE_control_locally_buffered_for_host; + srp_header_compute_parity (&i->srp); + + clib_memcpy (&i->ethernet.src_address, &si->my_address, sizeof (si->my_address)); + i->ethernet.type = clib_host_to_net_u16 (ETHERNET_TYPE_SRP_CONTROL); + + /* Checksum will be filled in later. */ + i->control.version = 0; + i->control.type = SRP_CONTROL_PACKET_TYPE_ips; + i->control.ttl = 255; + + clib_memcpy (&i->originator_address, &si->my_address, sizeof (si->my_address)); +} + +static void tx_ips_packet (srp_interface_t * si, + srp_ring_type_t tx_ring, + srp_ips_header_t * i) +{ + srp_main_t * sm = &srp_main; + vnet_main_t * vnm = vnet_get_main(); + vlib_main_t * vm = sm->vlib_main; + vnet_hw_interface_t * hi = vnet_get_hw_interface (vnm, si->rings[tx_ring].hw_if_index); + vlib_frame_t * f; + vlib_buffer_t * b; + u32 * to_next, bi; + + if (! vnet_sw_interface_is_admin_up (vnm, hi->sw_if_index)) + return; + if (hi->hw_class_index != srp_hw_interface_class.index) + return; + + i->control.checksum + = ~ip_csum_fold (ip_incremental_checksum (0, &i->control, + sizeof (i[0]) - STRUCT_OFFSET_OF (srp_ips_header_t, control))); + + bi = vlib_buffer_add_data (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX, + /* buffer to append to */ 0, + i, sizeof (i[0])); + + /* FIXME trace. */ + if (0) + clib_warning ("%U %U", + format_vnet_sw_if_index_name, vnm, hi->sw_if_index, + format_srp_ips_header, i); + + b = vlib_get_buffer (vm, bi); + vnet_buffer (b)->sw_if_index[VLIB_RX] = vnet_buffer (b)->sw_if_index[VLIB_TX] = hi->sw_if_index; + + f = vlib_get_frame_to_node (vm, hi->output_node_index); + to_next = vlib_frame_vector_args (f); + to_next[0] = bi; + f->n_vectors = 1; + vlib_put_frame_to_node (vm, hi->output_node_index, f); +} + +static void serialize_srp_interface_state_msg (serialize_main_t * m, va_list * va) +{ + srp_interface_t * si = va_arg (*va, srp_interface_t *); + srp_main_t * sm = &srp_main; + int r; + + ASSERT (! pool_is_free (sm->interface_pool, si)); + serialize_integer (m, si - sm->interface_pool, sizeof (u32)); + serialize_likely_small_unsigned_integer (m, si->current_ips_state); + for (r = 0; r < SRP_N_RING; r++) + { + srp_interface_ring_t * ir = &si->rings[r]; + void * p; + serialize_likely_small_unsigned_integer (m, ir->rx_neighbor_address_valid); + if (ir->rx_neighbor_address_valid) + { + p = serialize_get (m, sizeof (ir->rx_neighbor_address)); + clib_memcpy (p, ir->rx_neighbor_address, sizeof (ir->rx_neighbor_address)); + } + serialize_likely_small_unsigned_integer (m, ir->waiting_to_restore); + if (ir->waiting_to_restore) + serialize (m, serialize_f64, ir->wait_to_restore_start_time); + } +} + +static void unserialize_srp_interface_state_msg (serialize_main_t * m, va_list * va) +{ + CLIB_UNUSED (mc_main_t * mcm) = va_arg (*va, mc_main_t *); + srp_main_t * sm = &srp_main; + srp_interface_t * si; + u32 si_index, r; + + unserialize_integer (m, &si_index, sizeof (u32)); + si = pool_elt_at_index (sm->interface_pool, si_index); + si->current_ips_state = unserialize_likely_small_unsigned_integer (m); + for (r = 0; r < SRP_N_RING; r++) + { + srp_interface_ring_t * ir = &si->rings[r]; + void * p; + ir->rx_neighbor_address_valid = unserialize_likely_small_unsigned_integer (m); + if (ir->rx_neighbor_address_valid) + { + p = unserialize_get (m, sizeof (ir->rx_neighbor_address)); + clib_memcpy (ir->rx_neighbor_address, p, sizeof (ir->rx_neighbor_address)); + } + ir->waiting_to_restore = unserialize_likely_small_unsigned_integer (m); + if (ir->waiting_to_restore) + unserialize (m, unserialize_f64, &ir->wait_to_restore_start_time); + } +} + +MC_SERIALIZE_MSG (srp_interface_state_msg, static) = { + .name = "vnet_srp_interface_state", + .serialize = serialize_srp_interface_state_msg, + .unserialize = unserialize_srp_interface_state_msg, +}; + +static int requests_switch (srp_ips_request_type_t r) +{ + static u8 t[16] = { + [SRP_IPS_REQUEST_forced_switch] = 1, + [SRP_IPS_REQUEST_manual_switch] = 1, + [SRP_IPS_REQUEST_signal_fail] = 1, + [SRP_IPS_REQUEST_signal_degrade] = 1, + }; + return (int) r < ARRAY_LEN (t) ? t[r] : 0; +} + +/* Called when an IPS control packet is received on given interface. */ +void srp_ips_rx_packet (u32 sw_if_index, srp_ips_header_t * h) +{ + vnet_main_t * vnm = vnet_get_main(); + vlib_main_t * vm = srp_main.vlib_main; + srp_ring_type_t rx_ring; + srp_interface_t * si = srp_get_interface (sw_if_index, &rx_ring); + srp_interface_ring_t * ir = &si->rings[rx_ring]; + int si_needs_broadcast = 0; + + /* FIXME trace. */ + if (0) + clib_warning ("%U %U %U", + format_time_interval, "h:m:s:u", vlib_time_now (vm), + format_vnet_sw_if_index_name, vnm, sw_if_index, + format_srp_ips_header, h); + + /* Ignore self-generated IPS packets. */ + if (! memcmp (h->originator_address, si->my_address, sizeof (h->originator_address))) + goto done; + + /* Learn neighbor address from short path messages. */ + if (! h->is_long_path) + { + if (ir->rx_neighbor_address_valid + && memcmp (ir->rx_neighbor_address, h->originator_address, sizeof (ir->rx_neighbor_address))) + { + ASSERT (0); + } + ir->rx_neighbor_address_valid = 1; + clib_memcpy (ir->rx_neighbor_address, h->originator_address, sizeof (ir->rx_neighbor_address)); + } + + switch (si->current_ips_state) + { + case SRP_IPS_STATE_idle: + /* Received {REQ,NEIGHBOR,W,S} in idle state: wrap. */ + if (requests_switch (h->request_type) + && ! h->is_long_path + && h->status == SRP_IPS_STATUS_wrapped) + { + srp_ips_header_t to_tx[2]; + + si_needs_broadcast = 1; + si->current_ips_state = SRP_IPS_STATE_wrapped; + si->hw_wrap_function (si->rings[SRP_SIDE_A].hw_if_index, /* enable_wrap */ 1); + si->hw_wrap_function (si->rings[SRP_SIDE_B].hw_if_index, /* enable_wrap */ 1); + + init_ips_packet (si, rx_ring ^ 0, &to_tx[0]); + to_tx[0].request_type = SRP_IPS_REQUEST_idle; + to_tx[0].status = SRP_IPS_STATUS_wrapped; + to_tx[0].is_long_path = 0; + tx_ips_packet (si, rx_ring ^ 0, &to_tx[0]); + + init_ips_packet (si, rx_ring ^ 1, &to_tx[1]); + to_tx[1].request_type = h->request_type; + to_tx[1].status = SRP_IPS_STATUS_wrapped; + to_tx[1].is_long_path = 1; + tx_ips_packet (si, rx_ring ^ 1, &to_tx[1]); + } + break; + + case SRP_IPS_STATE_wrapped: + if (! h->is_long_path + && h->request_type == SRP_IPS_REQUEST_idle + && h->status == SRP_IPS_STATUS_idle) + { + si_needs_broadcast = 1; + si->current_ips_state = SRP_IPS_STATE_idle; + si->hw_wrap_function (si->rings[SRP_SIDE_A].hw_if_index, /* enable_wrap */ 0); + si->hw_wrap_function (si->rings[SRP_SIDE_B].hw_if_index, /* enable_wrap */ 0); + } + break; + + case SRP_IPS_STATE_pass_thru: + /* FIXME */ + break; + + default: + abort (); + break; + } + + done: + if (vm->mc_main && si_needs_broadcast) + mc_serialize (vm->mc_main, &srp_interface_state_msg, si); +} + +/* Preform local IPS request on given interface. */ +void srp_ips_local_request (u32 sw_if_index, srp_ips_request_type_t request) +{ + vnet_main_t * vnm = vnet_get_main(); + srp_main_t * sm = &srp_main; + vlib_main_t * vm = sm->vlib_main; + srp_ring_type_t rx_ring; + srp_interface_t * si = srp_get_interface (sw_if_index, &rx_ring); + srp_interface_ring_t * ir = &si->rings[rx_ring]; + int si_needs_broadcast = 0; + + if (request == SRP_IPS_REQUEST_wait_to_restore) + { + if (si->current_ips_state != SRP_IPS_STATE_wrapped) + return; + if (! ir->waiting_to_restore) + { + ir->wait_to_restore_start_time = vlib_time_now (sm->vlib_main); + ir->waiting_to_restore = 1; + si_needs_broadcast = 1; + } + } + else + { + /* FIXME handle local signal fail. */ + si_needs_broadcast = ir->waiting_to_restore; + ir->wait_to_restore_start_time = 0; + ir->waiting_to_restore = 0; + } + + /* FIXME trace. */ + if (0) + clib_warning ("%U %U", + format_vnet_sw_if_index_name, vnm, sw_if_index, + format_srp_ips_request_type, request); + + if (vm->mc_main && si_needs_broadcast) + mc_serialize (vm->mc_main, &srp_interface_state_msg, si); +} + +static void maybe_send_ips_message (srp_interface_t * si) +{ + srp_main_t * sm = &srp_main; + srp_ips_header_t to_tx[2]; + srp_ring_type_t rx_ring = SRP_RING_OUTER; + srp_interface_ring_t * r0 = &si->rings[rx_ring ^ 0]; + srp_interface_ring_t * r1 = &si->rings[rx_ring ^ 1]; + f64 now = vlib_time_now (sm->vlib_main); + + if (! si->ips_process_enable) + return; + + if (si->current_ips_state == SRP_IPS_STATE_wrapped + && r0->waiting_to_restore + && r1->waiting_to_restore + && now >= r0->wait_to_restore_start_time + si->config.wait_to_restore_idle_delay + && now >= r1->wait_to_restore_start_time + si->config.wait_to_restore_idle_delay) + { + si->current_ips_state = SRP_IPS_STATE_idle; + r0->waiting_to_restore = r1->waiting_to_restore = 0; + r0->wait_to_restore_start_time = r1->wait_to_restore_start_time = 0; + } + + if (si->current_ips_state != SRP_IPS_STATE_idle) + return; + + init_ips_packet (si, rx_ring ^ 0, &to_tx[0]); + init_ips_packet (si, rx_ring ^ 1, &to_tx[1]); + + if (si->current_ips_state == SRP_IPS_STATE_idle) + { + to_tx[0].request_type = to_tx[1].request_type = SRP_IPS_REQUEST_idle; + to_tx[0].status = to_tx[1].status = SRP_IPS_STATUS_idle; + to_tx[0].is_long_path = to_tx[1].is_long_path = 0; + } + + else if (si->current_ips_state == SRP_IPS_STATE_wrapped) + { + to_tx[0].request_type = + (si->rings[rx_ring ^ 0].waiting_to_restore + ? SRP_IPS_REQUEST_wait_to_restore + : SRP_IPS_REQUEST_signal_fail); + to_tx[1].request_type = + (si->rings[rx_ring ^ 1].waiting_to_restore + ? SRP_IPS_REQUEST_wait_to_restore + : SRP_IPS_REQUEST_signal_fail); + to_tx[0].status = to_tx[1].status = SRP_IPS_STATUS_wrapped; + to_tx[0].is_long_path = 0; + to_tx[1].is_long_path = 1; + } + + tx_ips_packet (si, rx_ring ^ 0, &to_tx[0]); + tx_ips_packet (si, rx_ring ^ 1, &to_tx[1]); +} + +static uword +srp_ips_process (vlib_main_t * vm, + vlib_node_runtime_t * rt, + vlib_frame_t * f) +{ + srp_main_t * sm = &srp_main; + srp_interface_t * si; + + while (1) + { + pool_foreach (si, sm->interface_pool, ({ + maybe_send_ips_message (si); + })); + vlib_process_suspend (vm, 1.0); + } + + return 0; +} + +vlib_node_registration_t srp_ips_process_node = { + .function = srp_ips_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "srp-ips-process", + .state = VLIB_NODE_STATE_DISABLED, +}; + +static clib_error_t * srp_init (vlib_main_t * vm) +{ + srp_main_t * sm = &srp_main; + + sm->default_data_ttl = 255; + sm->vlib_main = vm; + vlib_register_node (vm, &srp_ips_process_node); + vlib_register_node (vm, &srp_input_node); + vlib_register_node (vm, &srp_control_input_node); + srp_setup_node (vm, srp_input_node.index); + + return 0; +} + +VLIB_INIT_FUNCTION (srp_init); diff --git a/vpp/vnet/vnet/srp/packet.h b/vpp/vnet/vnet/srp/packet.h new file mode 100644 index 00000000..96dab648 --- /dev/null +++ b/vpp/vnet/vnet/srp/packet.h @@ -0,0 +1,204 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * srp/packet.h: srp packet format. + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef included_srp_packet_h +#define included_srp_packet_h + +#include <vppinfra/byte_order.h> +#include <vppinfra/bitops.h> +#include <vnet/ethernet/packet.h> + +/* SRP version 2. */ + +#define foreach_srp_mode \ + _ (reserved0) \ + _ (reserved1) \ + _ (reserved2) \ + _ (reserved3) \ + _ (control_pass_to_host) \ + _ (control_locally_buffered_for_host) \ + _ (keep_alive) \ + _ (data) + +typedef enum { +#define _(f) SRP_MODE_##f, + foreach_srp_mode +#undef _ + SRP_N_MODE, +} srp_mode_t; + +typedef union { + /* For computing parity bit. */ + u16 as_u16; + + struct { + u8 ttl; + +#if CLIB_ARCH_IS_BIG_ENDIAN + u8 is_inner_ring : 1; + u8 mode : 3; + u8 priority : 3; + u8 parity : 1; +#endif +#if CLIB_ARCH_IS_LITTLE_ENDIAN + u8 parity : 1; + u8 priority : 3; + u8 mode : 3; + u8 is_inner_ring : 1; +#endif + }; +} srp_header_t; + +always_inline void +srp_header_compute_parity (srp_header_t * h) +{ + h->parity = 0; + h->parity = count_set_bits (h->as_u16) ^ 1; /* odd parity */ +} + +typedef struct { + srp_header_t srp; + ethernet_header_t ethernet; +} srp_and_ethernet_header_t; + +#define foreach_srp_control_packet_type \ + _ (reserved) \ + _ (topology) \ + _ (ips) + +typedef enum { +#define _(f) SRP_CONTROL_PACKET_TYPE_##f, + foreach_srp_control_packet_type +#undef _ + SRP_N_CONTROL_PACKET_TYPE, +} srp_control_packet_type_t; + +typedef CLIB_PACKED (struct { + /* Set to 0. */ + u8 version; + + srp_control_packet_type_t type : 8; + + /* IP4-like checksum of packet starting with start of control header. */ + u16 checksum; + + u16 ttl; +}) srp_control_header_t; + +typedef struct { + srp_header_t srp; + ethernet_header_t ethernet; + srp_control_header_t control; +} srp_generic_control_header_t; + +typedef struct { + u8 flags; +#define SRP_TOPOLOGY_MAC_BINDING_FLAG_IS_INNER_RING (1 << 6) +#define SRP_TOPOLOGY_MAC_BINDING_FLAG_IS_WRAPPED (1 << 5) + + /* MAC address. */ + u8 address[6]; +} srp_topology_mac_binding_t; + +typedef CLIB_PACKED (struct { + srp_header_t srp; + ethernet_header_t ethernet; + srp_control_header_t control; + + /* Length in bytes of data that follows. */ + u16 n_bytes_of_data_that_follows; + + /* MAC address of originator of this topology request. */ + u8 originator_address[6]; + + /* Bindings follow. */ + srp_topology_mac_binding_t bindings[0]; +}) srp_topology_header_t; + +#define foreach_srp_ips_request_type \ + _ (idle, 0x0) \ + _ (wait_to_restore, 0x5) \ + _ (manual_switch, 0x6) \ + _ (signal_degrade, 0x8) \ + _ (signal_fail, 0xb) \ + _ (forced_switch, 0xd) + +typedef enum { +#define _(f,n) SRP_IPS_REQUEST_##f = n, + foreach_srp_ips_request_type +#undef _ +} srp_ips_request_type_t; + +#define foreach_srp_ips_status \ + _ (idle, 0x0) \ + _ (wrapped, 0x2) + +typedef enum { +#define _(f,n) SRP_IPS_STATUS_##f = n, + foreach_srp_ips_status +#undef _ +} srp_ips_status_t; + +typedef struct { + srp_header_t srp; + ethernet_header_t ethernet; + srp_control_header_t control; + u8 originator_address[6]; + + union { + u8 ips_octet; + + struct { +#if CLIB_ARCH_IS_BIG_ENDIAN + u8 request_type : 4; + u8 is_long_path : 1; + u8 status : 3; +#endif +#if CLIB_ARCH_IS_LITTLE_ENDIAN + u8 status : 3; + u8 is_long_path : 1; + u8 request_type : 4; +#endif + }; + }; + + u8 reserved; +} srp_ips_header_t; + +#endif /* included_srp_packet_h */ diff --git a/vpp/vnet/vnet/srp/pg.c b/vpp/vnet/vnet/srp/pg.c new file mode 100644 index 00000000..54f1a3bb --- /dev/null +++ b/vpp/vnet/vnet/srp/pg.c @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * srp/pg.c: packet generator srp interface + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <vlib/vlib.h> +#include <vnet/pg/pg.h> +#include <vnet/srp/srp.h> +#include <vnet/ethernet/ethernet.h> + +typedef struct { + pg_edit_t ttl; + pg_edit_t is_inner_ring; + pg_edit_t mode; + pg_edit_t priority; + pg_edit_t parity; + pg_edit_t type; + pg_edit_t src_address; + pg_edit_t dst_address; +} pg_srp_header_t; + +static inline void +pg_srp_header_init (pg_srp_header_t * e) +{ + pg_edit_init (&e->ttl, srp_and_ethernet_header_t, srp.ttl); + pg_edit_init_bitfield (&e->is_inner_ring, srp_and_ethernet_header_t, + srp.as_u16, + 7, 1); + pg_edit_init_bitfield (&e->mode, srp_and_ethernet_header_t, + srp.as_u16, + 4, 3); + pg_edit_init_bitfield (&e->priority, srp_and_ethernet_header_t, + srp.as_u16, + 1, 3); + pg_edit_init_bitfield (&e->parity, srp_and_ethernet_header_t, + srp.as_u16, + 0, 1); + pg_edit_init (&e->type, srp_and_ethernet_header_t, ethernet.type); + pg_edit_init (&e->src_address, srp_and_ethernet_header_t, ethernet.src_address); + pg_edit_init (&e->dst_address, srp_and_ethernet_header_t, ethernet.dst_address); +} + +uword +unformat_pg_srp_header (unformat_input_t * input, va_list * args) +{ + pg_stream_t * s = va_arg (*args, pg_stream_t *); + pg_srp_header_t * e; + u32 error, group_index; + + e = pg_create_edit_group (s, sizeof (e[0]), sizeof (srp_header_t), + &group_index); + pg_srp_header_init (e); + + error = 1; + if (! unformat (input, "%U: %U -> %U", + unformat_pg_edit, + unformat_ethernet_type_net_byte_order, &e->type, + unformat_pg_edit, + unformat_ethernet_address, &e->src_address, + unformat_pg_edit, + unformat_ethernet_address, &e->dst_address)) + goto done; + + { + srp_header_t h; + + h.as_u16 = 0; + h.mode = SRP_MODE_data; + h.ttl = 255; + h.parity = count_set_bits (h.as_u16) ^ 1; + + pg_edit_set_fixed (&e->mode, h.mode); + pg_edit_set_fixed (&e->ttl, h.ttl); + pg_edit_set_fixed (&e->is_inner_ring, h.is_inner_ring); + pg_edit_set_fixed (&e->priority, h.priority); + pg_edit_set_fixed (&e->parity, h.parity); + } + + error = 0; + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "mode %U", + unformat_pg_edit, + unformat_pg_number, &e->mode)) + ; + else if (unformat (input, "ttl %U", + unformat_pg_edit, + unformat_pg_number, &e->ttl)) + ; + else if (unformat (input, "priority %U", + unformat_pg_edit, + unformat_pg_number, &e->priority)) + ; + else + break; + } + + { + ethernet_main_t * em = ðernet_main; + ethernet_type_info_t * ti = 0; + pg_node_t * pg_node = 0; + + if (e->type.type == PG_EDIT_FIXED) + { + u16 t = *(u16 *) e->type.values[PG_EDIT_LO]; + ti = ethernet_get_type_info (em, clib_net_to_host_u16 (t)); + if (ti && ti->node_index != ~0) + pg_node = pg_get_node (ti->node_index); + } + + if (pg_node && pg_node->unformat_edit + && unformat_user (input, pg_node->unformat_edit, s)) + ; + else if (! unformat_user (input, unformat_pg_payload, s)) + goto done; + } + + done: + if (error) + pg_free_edit_group (s); + return error == 0; +} + diff --git a/vpp/vnet/vnet/srp/srp.h b/vpp/vnet/vnet/srp/srp.h new file mode 100644 index 00000000..5288ebe4 --- /dev/null +++ b/vpp/vnet/vnet/srp/srp.h @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * srp.h: types/functions for srp. + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef included_srp_h +#define included_srp_h + +#include <vnet/vnet.h> +#include <vnet/srp/packet.h> +#include <vnet/ethernet/ethernet.h> +#include <vnet/pg/pg.h> + +extern vnet_hw_interface_class_t srp_hw_interface_class; + +/* See RFC 2892. */ +#define foreach_srp_ips_state \ + _ (idle) \ + _ (pass_thru) \ + _ (wrapped) + +typedef enum { +#define _(f) SRP_IPS_STATE_##f, + foreach_srp_ips_state +#undef _ + SRP_N_IPS_STATE, +} srp_ips_state_t; + +typedef enum { + SRP_RING_OUTER, + SRP_RING_INNER, + SRP_N_RING = 2, + SRP_SIDE_A = SRP_RING_OUTER, /* outer rx, inner tx */ + SRP_SIDE_B = SRP_RING_INNER, /* inner rx, outer tx */ + SRP_N_SIDE = 2, +} srp_ring_type_t; + +typedef struct { + srp_ring_type_t ring; + + /* Hardware interface for this ring/side. */ + u32 hw_if_index; + + /* Software interface corresponding to hardware interface. */ + u32 sw_if_index; + + /* Mac address of neighbor on RX fiber. */ + u8 rx_neighbor_address[6]; + + u8 rx_neighbor_address_valid; + + /* True if we are waiting to restore signal. */ + u8 waiting_to_restore; + + /* Time stamp when signal became valid. */ + f64 wait_to_restore_start_time; +} srp_interface_ring_t; + +struct srp_interface_t; +typedef void (srp_hw_wrap_function_t) (u32 hw_if_index, u32 wrap_enable); +typedef void (srp_hw_enable_function_t) (struct srp_interface_t * si, u32 wrap_enable); + +typedef struct { + /* Delay between wait to restore event and entering idle state in seconds. */ + f64 wait_to_restore_idle_delay; + + /* Number of seconds between sending ips messages to neighbors. */ + f64 ips_tx_interval; +} srp_interface_config_t; + +typedef struct srp_interface_t { + /* Current IPS state. */ + srp_ips_state_t current_ips_state; + + /* Address for this interface. */ + u8 my_address[6]; + + /* Enable IPS process handling for this interface. */ + u8 ips_process_enable; + + srp_interface_ring_t rings[SRP_N_RING]; + + /* Configurable parameters. */ + srp_interface_config_t config; + + srp_hw_wrap_function_t * hw_wrap_function; + + srp_hw_enable_function_t * hw_enable_function; +} srp_interface_t; + +typedef struct { + vlib_main_t * vlib_main; + + /* Pool of SRP interfaces. */ + srp_interface_t * interface_pool; + + uword * interface_index_by_hw_if_index; + + /* TTL to use for outgoing data packets. */ + u32 default_data_ttl; + + vlib_one_time_waiting_process_t * srp_register_interface_waiting_process_pool; + + uword * srp_register_interface_waiting_process_pool_index_by_hw_if_index; +} srp_main_t; + +/* Registers sides A/B hardware interface as being SRP capable. */ +void srp_register_interface (u32 * hw_if_indices); + +/* Enable sending IPS messages for interface implied by given vlib hardware interface. */ +void srp_interface_enable_ips (u32 hw_if_index); + +/* Set function to wrap hardware side of SRP interface. */ +void srp_interface_set_hw_wrap_function (u32 hw_if_index, srp_hw_wrap_function_t * f); + +void srp_interface_set_hw_enable_function (u32 hw_if_index, srp_hw_enable_function_t * f); + +extern vlib_node_registration_t srp_ips_process_node; + +/* Called when an IPS control packet is received on given interface. */ +void srp_ips_rx_packet (u32 sw_if_index, srp_ips_header_t * ips_packet); + +/* Preform local IPS request on given interface. */ +void srp_ips_local_request (u32 sw_if_index, srp_ips_request_type_t request); + +always_inline void +srp_ips_link_change (u32 sw_if_index, u32 link_is_up) +{ + srp_ips_local_request (sw_if_index, + link_is_up + ? SRP_IPS_REQUEST_wait_to_restore + : SRP_IPS_REQUEST_signal_fail); +} + +void srp_interface_get_interface_config (u32 hw_if_index, srp_interface_config_t * c); +void srp_interface_set_interface_config (u32 hw_if_index, srp_interface_config_t * c); + +srp_main_t srp_main; + +always_inline srp_interface_t * +srp_get_interface_from_vnet_hw_interface (u32 hw_if_index) +{ + srp_main_t * sm = &srp_main; + uword * p = hash_get (sm->interface_index_by_hw_if_index, hw_if_index); + return p ? pool_elt_at_index (sm->interface_pool, p[0]) : 0; +} + +u8 * format_srp_header (u8 * s, va_list * args); +u8 * format_srp_header_with_length (u8 * s, va_list * args); +u8 * format_srp_device (u8 * s, va_list * args); + +/* Parse srp header. */ +uword +unformat_srp_header (unformat_input_t * input, va_list * args); + +uword unformat_pg_srp_header (unformat_input_t * input, va_list * args); + +always_inline void +srp_setup_node (vlib_main_t * vm, u32 node_index) +{ + vlib_node_t * n = vlib_get_node (vm, node_index); + pg_node_t * pn = pg_get_node (node_index); + n->format_buffer = format_srp_header_with_length; + n->unformat_buffer = unformat_srp_header; + pn->unformat_edit = unformat_pg_srp_header; +} + +#define foreach_srp_error \ + _ (NONE, "no error") \ + _ (UNKNOWN_MODE, "unknown mode in SRP header") \ + _ (KEEP_ALIVE_DROPPED, "v1 keep alive mode in SRP header") \ + _ (CONTROL_PACKETS_PROCESSED, "control packets processed") \ + _ (IPS_PACKETS_PROCESSED, "IPS packets processed") \ + _ (UNKNOWN_CONTROL, "unknown control packet") \ + _ (CONTROL_VERSION_NON_ZERO, "control packet with non-zero version") \ + _ (CONTROL_BAD_CHECKSUM, "control packet with bad checksum") \ + _ (TOPOLOGY_BAD_LENGTH, "topology packet with bad length") + +typedef enum { +#define _(n,s) SRP_ERROR_##n, + foreach_srp_error +#undef _ + SRP_N_ERROR, +} srp_error_t; + +serialize_function_t serialize_srp_main, unserialize_srp_main; + +#endif /* included_srp_h */ |