aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/configure.ac1
-rw-r--r--src/plugins/Makefile.am4
-rw-r--r--src/plugins/l2e.am28
-rw-r--r--src/plugins/l2e/l2e.api38
-rw-r--r--src/plugins/l2e/l2e.c485
-rw-r--r--src/plugins/l2e/l2e.h41
-rw-r--r--src/plugins/l2e/l2e_all_api_h.h17
-rw-r--r--src/plugins/l2e/l2e_api.c162
-rw-r--r--src/plugins/l2e/l2e_msg_enum.h28
-rw-r--r--src/vnet/dpo/l2_bridge_dpo.c2
-rw-r--r--src/vnet/l2/l2_input.h1
-rw-r--r--src/vpp-api/vom/Makefile.am3
-rw-r--r--src/vpp-api/vom/bridge_domain.cpp2
-rw-r--r--src/vpp-api/vom/l2_emulation.cpp167
-rw-r--r--src/vpp-api/vom/l2_emulation.hpp180
-rw-r--r--src/vpp-api/vom/l2_emulation_cmds.cpp107
-rw-r--r--src/vpp-api/vom/l2_emulation_cmds.hpp102
-rw-r--r--test/test_dvr.py242
-rw-r--r--test/vpp_papi_provider.py12
19 files changed, 1592 insertions, 30 deletions
diff --git a/src/configure.ac b/src/configure.ac
index b4c0c707b2e..0e7540366ab 100644
--- a/src/configure.ac
+++ b/src/configure.ac
@@ -222,6 +222,7 @@ PLUGIN_ENABLED(pppoe)
PLUGIN_ENABLED(sixrd)
PLUGIN_ENABLED(nat)
PLUGIN_ENABLED(stn)
+PLUGIN_ENABLED(l2e)
###############################################################################
# Dependency checks
diff --git a/src/plugins/Makefile.am b/src/plugins/Makefile.am
index 746b4e0662c..03aef227cfb 100644
--- a/src/plugins/Makefile.am
+++ b/src/plugins/Makefile.am
@@ -87,6 +87,10 @@ if ENABLE_STN_PLUGIN
include stn.am
endif
+if ENABLE_L2E_PLUGIN
+include l2e.am
+endif
+
include ../suffix-rules.mk
# Remove *.la files
diff --git a/src/plugins/l2e.am b/src/plugins/l2e.am
new file mode 100644
index 00000000000..da2c456417b
--- /dev/null
+++ b/src/plugins/l2e.am
@@ -0,0 +1,28 @@
+# Copyright (c) 2016 Cisco Systems, Inc.
+# 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.
+
+vppplugins_LTLIBRARIES += l2e_plugin.la
+
+l2e_plugin_la_SOURCES = \
+ l2e/l2e.c \
+ l2e/l2e_api.c
+
+API_FILES += l2e/l2e.api
+
+noinst_HEADERS += \
+ l2e/l2e.h \
+ l2e/l2e_all_api_h.h \
+ l2e/l2e_msg_enum.h \
+ l2e/l2e.api.h
+
+# vi:syntax=automake
diff --git a/src/plugins/l2e/l2e.api b/src/plugins/l2e/l2e.api
new file mode 100644
index 00000000000..172ed48a22b
--- /dev/null
+++ b/src/plugins/l2e/l2e.api
@@ -0,0 +1,38 @@
+/* Hey Emacs use -*- mode: C -*- */
+/*
+ * Copyright (c) 2016 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.
+ */
+
+vl_api_version 1.0.0
+
+/** \brief L2 emulation at L3
+ @param client_index - opaque cookie to identify the sender
+ @param context - sender context, to match reply w/ request
+ @param sw_if_index - interface the operation is applied to
+ @param enable - Turn the service on or off
+*/
+autoreply define l2_emulation
+{
+ u32 client_index;
+ u32 context;
+ u32 sw_if_index;
+ u32 ip_table_id;
+ u8 enable;
+};
+
+/*
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/plugins/l2e/l2e.c b/src/plugins/l2e/l2e.c
new file mode 100644
index 00000000000..633d1f92838
--- /dev/null
+++ b/src/plugins/l2e/l2e.c
@@ -0,0 +1,485 @@
+/*
+ * l2_emulation.h : Extract L3 packets from the L2 input and feed
+ * them into the L3 path.
+ *
+ * Copyright (c) 2013 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.
+ */
+
+#include <plugins/l2e/l2e.h>
+#include <vnet/l2/l2_input.h>
+
+/**
+ * Grouping of global data for the L2 emulation feature
+ */
+typedef struct l2_emulation_main_t_
+{
+ /**
+ * Next nodes for L2 output features
+ */
+ u32 l2_input_feat_next[32];
+} l2_emulation_main_t;
+
+static l2_emulation_main_t l2_emulation_main;
+
+/**
+ * Per-interface L2 configuration
+ */
+typedef struct l2_emulation_t_
+{
+ /**
+ * Enabled or Disabled.
+ * this is required since one L3 protocl can be enabled, but others not
+ */
+ u8 enabled;
+} l2_emulation_t;
+
+/**
+ * A zero'd out struct we can use in the vec_validate
+ */
+static const l2_emulation_t ezero = { };
+
+/**
+ * Per-interface vector of emulation configs
+ */
+l2_emulation_t *l2_emulations;
+
+void
+l2_emulation_enable (u32 sw_if_index)
+{
+ vec_validate_init_empty (l2_emulations, sw_if_index, ezero);
+
+ l2_emulation_t *l23e = &l2_emulations[sw_if_index];
+
+ l23e->enabled = 1;
+
+ /*
+ * L3 enable the interface - using IP unnumbered from the control
+ * plane may not be possible since there may be no BVI interface
+ * to which to unnumber
+ */
+ ip4_sw_interface_enable_disable (sw_if_index, 1);
+ ip6_sw_interface_enable_disable (sw_if_index, 1);
+
+ l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_L2_EMULATION, 1);
+}
+
+
+void
+l2_emulation_disable (u32 sw_if_index)
+{
+ if (vec_len (l2_emulations) >= sw_if_index)
+ {
+ l2_emulation_t *l23e = &l2_emulations[sw_if_index];
+ memset (l23e, 0, sizeof (*l23e));
+
+ l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_L2_EMULATION, 0);
+ ip4_sw_interface_enable_disable (sw_if_index, 0);
+ ip6_sw_interface_enable_disable (sw_if_index, 0);
+ }
+}
+
+static clib_error_t *
+l2_emulation_interface_add_del (vnet_main_t * vnm,
+ u32 sw_if_index, u32 is_add)
+{
+ if (is_add)
+ {
+ vec_validate_init_empty (l2_emulations, sw_if_index, ezero);
+ }
+
+ return (NULL);
+}
+
+VNET_SW_INTERFACE_ADD_DEL_FUNCTION (l2_emulation_interface_add_del);
+
+static clib_error_t *
+l2_emulation_cli (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+ vnet_main_t *vnm = vnet_get_main ();
+ u32 sw_if_index = ~0;
+ u8 enable = 1;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "%U", unformat_vnet_sw_interface,
+ vnm, &sw_if_index))
+ ;
+ else if (unformat (input, "enable"))
+ enable = 1;
+ else if (unformat (input, "disable"))
+ enable = 0;
+ else
+ break;
+ }
+
+ if (~0 == sw_if_index)
+ return clib_error_return (0, "interface must be specified");
+
+ if (enable)
+ l2_emulation_enable (sw_if_index);
+ else
+ l2_emulation_disable (sw_if_index);
+
+ return (NULL);
+}
+
+/*?
+ * Configure l2 emualtion.
+ * When the interface is in L2 mode, configure the extraction of L3
+ * packets out of the L2 path and into the L3 path.
+ *
+ * @cliexpar
+ * @cliexstart{set interface l2 input l2-emulation <interface-name> [disable]
+ * @cliexend
+ ?*/
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (l2_emulation_cli_node, static) = {
+ .path = "set interface l2 l2-emulation",
+ .short_help =
+ "set interface l2 l2-emulation <interface-name> [disable|enable]\n",
+ .function = l2_emulation_cli,
+};
+/* *INDENT-ON* */
+
+static clib_error_t *
+l2_emulation_show (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+ vnet_main_t *vnm = vnet_get_main ();
+ l2_emulation_t *l23e;
+ u32 sw_if_index;
+
+ vec_foreach_index (sw_if_index, l2_emulations)
+ {
+ l23e = &l2_emulations[sw_if_index];
+ if (l23e->enabled)
+ {
+ vlib_cli_output (vm, "%U\n",
+ format_vnet_sw_if_index_name, vnm, sw_if_index);
+ }
+ }
+ return (NULL);
+}
+
+/*?
+ * Show l2 emulation.
+ * When the interface is in L2 mode, configure the extraction of L3
+ * packets out of the L2 path and into the L3 path.
+ *
+ * @cliexpar
+ * @cliexstart{show interface l2 l2-emulation
+ * @cliexend
+ ?*/
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (l2_emulation_show_node, static) = {
+ .path = "show interface l2 l2-emulation",
+ .short_help = "show interface l2 l2-emulation\n",
+ .function = l2_emulation_show,
+};
+/* *INDENT-ON* */
+
+#define foreach_l2_emulation \
+ _(IP4, "Extract IPv4") \
+ _(IP6, "Extract IPv6")
+
+typedef enum
+{
+#define _(sym,str) L2_EMULATION_ERROR_##sym,
+ foreach_l2_emulation
+#undef _
+ L2_EMULATION_N_ERROR,
+} l2_emulation_error_t;
+
+static char *l2_emulation_error_strings[] = {
+#define _(sym,string) string,
+ foreach_l2_emulation
+#undef _
+};
+
+typedef enum
+{
+#define _(sym,str) L2_EMULATION_NEXT_##sym,
+ foreach_l2_emulation
+#undef _
+ L2_EMULATION_N_NEXT,
+} l2_emulation_next_t;
+
+/**
+ * per-packet trace data
+ */
+typedef struct l2_emulation_trace_t_
+{
+ /* per-pkt trace data */
+ u8 extracted;
+} l2_emulation_trace_t;
+
+static uword
+l2_emulation_node_fn (vlib_main_t * vm,
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
+{
+ l2_emulation_main_t *em = &l2_emulation_main;
+ u32 n_left_from, *from, *to_next;
+ l2_emulation_next_t next_index;
+ u32 ip4_hits = 0;
+ u32 ip6_hits = 0;
+
+ next_index = 0;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ 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)
+ {
+ vlib_buffer_t *b0, *b1;
+ u32 sw_if_index0, sw_if_index1;
+ u16 ether_type0, ether_type1;
+ u32 next0 = ~0, next1 = ~0;
+ u8 l2_len0, l2_len1;
+ u32 bi0, bi1;
+ u8 *h0, *h1;
+
+ bi0 = to_next[0] = from[0];
+ bi1 = to_next[1] = from[1];
+
+ from += 2;
+ n_left_from -= 2;
+ to_next += 2;
+ n_left_to_next -= 2;
+
+ b0 = vlib_get_buffer (vm, bi0);
+ b1 = vlib_get_buffer (vm, bi1);
+ l2_len0 = vnet_buffer (b0)->l2.l2_len;
+ l2_len1 = vnet_buffer (b1)->l2.l2_len;
+
+ h0 = vlib_buffer_get_current (b0);
+ h1 = vlib_buffer_get_current (b1);
+
+ ether_type0 = clib_net_to_host_u16 (*(u16 *) (h0 + l2_len0 - 2));
+ ether_type1 = clib_net_to_host_u16 (*(u16 *) (h1 + l2_len1 - 2));
+ sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
+
+ /*
+ * only extract unicast
+ */
+ if (PREDICT_TRUE (!(h0[0] & 0x1)))
+ {
+ switch (ether_type0)
+ {
+ case ETHERNET_TYPE_IP4:
+ ASSERT (l2_emulations[sw_if_index0].enabled);
+ ++ip4_hits;
+ next0 = L2_EMULATION_NEXT_IP4;
+ vlib_buffer_advance (b0, l2_len0);
+ break;
+ case ETHERNET_TYPE_IP6:
+ ASSERT (l2_emulations[sw_if_index0].enabled);
+ ++ip6_hits;
+ next0 = L2_EMULATION_NEXT_IP6;
+ vlib_buffer_advance (b0, l2_len0);
+ default:
+ break;
+ }
+ }
+ if (PREDICT_TRUE (!(h1[0] & 0x1)))
+ {
+ switch (ether_type1)
+ {
+ case ETHERNET_TYPE_IP4:
+ ASSERT (l2_emulations[sw_if_index1].enabled);
+ ++ip4_hits;
+ next1 = L2_EMULATION_NEXT_IP4;
+ vlib_buffer_advance (b1, l2_len1);
+ break;
+ case ETHERNET_TYPE_IP6:
+ ASSERT (l2_emulations[sw_if_index1].enabled);
+ ++ip6_hits;
+ next1 = L2_EMULATION_NEXT_IP6;
+ vlib_buffer_advance (b1, l2_len1);
+ default:
+ break;
+ }
+ }
+ if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+ && (b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ l2_emulation_trace_t *t =
+ vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->extracted = (next0 != ~0);
+ }
+ if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+ && (b1->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ l2_emulation_trace_t *t =
+ vlib_add_trace (vm, node, b1, sizeof (*t));
+ t->extracted = (next1 != ~0);
+ }
+
+ /* Determine the next node and remove ourself from bitmap */
+ if (PREDICT_TRUE (next0 == ~0))
+ next0 = vnet_l2_feature_next (b0, em->l2_input_feat_next,
+ L2INPUT_FEAT_L2_EMULATION);
+
+ /* Determine the next node and remove ourself from bitmap */
+ if (PREDICT_TRUE (next1 == ~0))
+ next1 = vnet_l2_feature_next (b1, em->l2_input_feat_next,
+ L2INPUT_FEAT_L2_EMULATION);
+
+ 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)
+ {
+ vlib_buffer_t *b0;
+ u32 sw_if_index0;
+ u16 ether_type0;
+ u32 next0 = ~0;
+ u8 l2_len0;
+ u32 bi0;
+ u8 *h0;
+
+ bi0 = from[0];
+ to_next[0] = bi0;
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+ l2_len0 = vnet_buffer (b0)->l2.l2_len;
+
+ h0 = vlib_buffer_get_current (b0);
+ ether_type0 = clib_net_to_host_u16 (*(u16 *) (h0 + l2_len0 - 2));
+ sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+
+ /*
+ * only extract unicast
+ */
+ if (PREDICT_TRUE (!(h0[0] & 0x1)))
+ {
+ switch (ether_type0)
+ {
+ case ETHERNET_TYPE_IP4:
+ ASSERT (l2_emulations[sw_if_index0].enabled);
+ ++ip4_hits;
+ next0 = L2_EMULATION_NEXT_IP4;
+ vlib_buffer_advance (b0, l2_len0);
+ break;
+ case ETHERNET_TYPE_IP6:
+ ASSERT (l2_emulations[sw_if_index0].enabled);
+ ++ip6_hits;
+ next0 = L2_EMULATION_NEXT_IP6;
+ vlib_buffer_advance (b0, l2_len0);
+ default:
+ break;
+ }
+ }
+
+ if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+ && (b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ l2_emulation_trace_t *t =
+ vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->extracted = (next0 != ~0);
+ }
+
+ /* Determine the next node and remove ourself from bitmap */
+ if (PREDICT_TRUE (next0 == ~0))
+ next0 = vnet_l2_feature_next (b0, em->l2_input_feat_next,
+ L2INPUT_FEAT_L2_EMULATION);
+
+ /* verify speculative enqueue, maybe switch current next frame */
+ 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);
+ }
+
+ vlib_node_increment_counter (vm, node->node_index,
+ L2_EMULATION_ERROR_IP4, ip4_hits);
+ vlib_node_increment_counter (vm, node->node_index,
+ L2_EMULATION_ERROR_IP6, ip6_hits);
+
+ return frame->n_vectors;
+}
+
+/* packet trace format function */
+static u8 *
+format_l2_emulation_trace (u8 * s, va_list * args)
+{
+ CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
+ CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
+ l2_emulation_trace_t *t = va_arg (*args, l2_emulation_trace_t *);
+
+ s = format (s, "l2-emulation: %s", (t->extracted ? "yes" : "no"));
+
+ return s;
+}
+
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (l2_emulation_node) = {
+ .function = l2_emulation_node_fn,
+ .name = "l2-emulation",
+ .vector_size = sizeof (u32),
+ .format_trace = format_l2_emulation_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_errors = ARRAY_LEN(l2_emulation_error_strings),
+ .error_strings = l2_emulation_error_strings,
+
+ .n_next_nodes = L2_EMULATION_N_NEXT,
+
+ /* edit / add dispositions here */
+ .next_nodes = {
+ [L2_EMULATION_NEXT_IP4] = "ip4-input",
+ [L2_EMULATION_NEXT_IP6] = "ip6-input",
+ },
+};
+/* *INDENT-ON* */
+
+VLIB_NODE_FUNCTION_MULTIARCH (l2_emulation_node, l2_emulation_node_fn);
+
+
+static clib_error_t *
+l2_emulation_init (vlib_main_t * vm)
+{
+ l2_emulation_main_t *em = &l2_emulation_main;
+
+ /* Initialize the feature next-node indexes */
+ feat_bitmap_init_next_nodes (vm,
+ l2_emulation_node.index,
+ L2INPUT_N_FEAT,
+ l2input_get_feat_names (),
+ em->l2_input_feat_next);
+
+ return 0;
+}
+
+VLIB_INIT_FUNCTION (l2_emulation_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/plugins/l2e/l2e.h b/src/plugins/l2e/l2e.h
new file mode 100644
index 00000000000..954950149f9
--- /dev/null
+++ b/src/plugins/l2e/l2e.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2013 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.
+ */
+
+#ifndef included_vnet_l2_emulation_h
+#define included_vnet_l2_emulation_h
+
+#include <vlib/vlib.h>
+#include <vnet/vnet.h>
+
+/**
+ * L2 Emulation is a feautre that is applied to L2 ports to 'extract'
+ * IP packets from the L2 path and inject them into the L3 path (i.e.
+ * into the appropriate ip[4|6]_input node).
+ * L3 routes in the table_id for that interface should then be configured
+ * as DVR routes, therefore the forwarded packet has the L2 header
+ * preserved and togehter the L3 routed system behaves like an L2 bridge.
+ */
+extern void l2_emulation_enable (u32 sw_if_index);
+extern void l2_emulation_disable (u32 sw_if_index);
+
+#endif
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/plugins/l2e/l2e_all_api_h.h b/src/plugins/l2e/l2e_all_api_h.h
new file mode 100644
index 00000000000..44fad6bf64e
--- /dev/null
+++ b/src/plugins/l2e/l2e_all_api_h.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2016 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.
+ */
+/* Include the generated file, see BUILT_SOURCES in Makefile.am */
+#include <l2e/l2e.api.h>
+
diff --git a/src/plugins/l2e/l2e_api.c b/src/plugins/l2e/l2e_api.c
new file mode 100644
index 00000000000..470427e8952
--- /dev/null
+++ b/src/plugins/l2e/l2e_api.c
@@ -0,0 +1,162 @@
+/*
+ *------------------------------------------------------------------
+ * l2e_api.c - layer 2 emulation api
+ *
+ * Copyright (c) 2016 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.
+ *------------------------------------------------------------------
+ */
+
+#include <vnet/vnet.h>
+#include <vnet/plugin/plugin.h>
+
+#include <vnet/interface.h>
+#include <vnet/api_errno.h>
+#include <vpp/app/version.h>
+
+#include <l2e/l2e.h>
+
+#include <vlibapi/api.h>
+#include <vlibmemory/api.h>
+
+/* define message IDs */
+#include <l2e/l2e_msg_enum.h>
+
+#define vl_typedefs /* define message structures */
+#include <l2e/l2e_all_api_h.h>
+#undef vl_typedefs
+
+#define vl_endianfun /* define message structures */
+#include <l2e/l2e_all_api_h.h>
+#undef vl_endianfun
+
+/* instantiate all the print functions we know about */
+#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
+#define vl_printfun
+#include <l2e/l2e_all_api_h.h>
+#undef vl_printfun
+
+/* Get the API version number */
+#define vl_api_version(n,v) static u32 api_version=(v);
+#include <acl/acl_all_api_h.h>
+#undef vl_api_version
+
+#include <vlibapi/api_helper_macros.h>
+
+#define foreach_l2e_api_msg \
+_(L2_EMULATION, l2_emulation)
+
+/**
+ * L2 Emulation Main
+ */
+typedef struct l2_emulation_main_t_
+{
+ u16 msg_id_base;
+} l2_emulation_main_t;
+
+static l2_emulation_main_t l2_emulation_main;
+
+#define L2E_MSG_BASE l2_emulation_main.msg_id_base
+
+static void
+vl_api_l2_emulation_t_handler (vl_api_l2_emulation_t * mp)
+{
+ vl_api_l2_emulation_reply_t *rmp;
+ int rv = 0;
+
+ VALIDATE_SW_IF_INDEX (mp);
+
+ u32 sw_if_index = ntohl (mp->sw_if_index);
+
+ if (mp->enable)
+ l2_emulation_enable (sw_if_index);
+ else
+ l2_emulation_disable (sw_if_index);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO (VL_API_L2_EMULATION_REPLY + L2E_MSG_BASE);
+}
+
+/*
+ * l2_api_hookup
+ * Add vpe's API message handlers to the table.
+ * vlib has alread mapped shared memory and
+ * added the client registration handlers.
+ * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
+ */
+#define vl_msg_name_crc_list
+#include <l2e/l2e_all_api_h.h>
+#undef vl_msg_name_crc_list
+
+static void
+setup_message_id_table (api_main_t * am)
+{
+#define _(id,n,crc) \
+ vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + L2E_MSG_BASE);
+ foreach_vl_msg_name_crc_l2e;
+#undef _
+}
+
+static void
+l2e_api_hookup (vlib_main_t * vm)
+{
+#define _(N,n) \
+ vl_msg_api_set_handlers(VL_API_##N + L2E_MSG_BASE, \
+ #n, \
+ vl_api_##n##_t_handler, \
+ vl_noop_handler, \
+ vl_api_##n##_t_endian, \
+ vl_api_##n##_t_print, \
+ sizeof(vl_api_##n##_t), 1);
+ foreach_l2e_api_msg;
+#undef _
+}
+
+static clib_error_t *
+l2e_init (vlib_main_t * vm)
+{
+ api_main_t *am = &api_main;
+ l2_emulation_main_t *l2em = &l2_emulation_main;
+ u8 *name = format (0, "l2e_%08x%c", api_version, 0);
+
+ /* Ask for a correctly-sized block of API message decode slots */
+ l2em->msg_id_base = vl_msg_api_get_msg_ids ((char *) name,
+ VL_MSG_FIRST_AVAILABLE);
+
+ l2e_api_hookup (vm);
+
+ /* Add our API messages to the global name_crc hash table */
+ setup_message_id_table (am);
+
+ vec_free (name);
+ return (NULL);
+}
+
+VLIB_API_INIT_FUNCTION (l2e_init);
+
+/* *INDENT-OFF* */
+VLIB_PLUGIN_REGISTER () = {
+ .version = VPP_BUILD_VER,
+ .description = "L2 Emulation",
+};
+/* *INDENT-ON* */
+
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/src/plugins/l2e/l2e_msg_enum.h b/src/plugins/l2e/l2e_msg_enum.h
new file mode 100644
index 00000000000..85c8328c703
--- /dev/null
+++ b/src/plugins/l2e/l2e_msg_enum.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2016 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.
+ */
+#ifndef included_l2e_msg_enum_h
+#define included_l2e_msg_enum_h
+
+#include <vppinfra/byte_order.h>
+
+#define vl_msg_id(n,h) n,
+typedef enum {
+#include <l2e/l2e_all_api_h.h>
+ /* We'll want to know how many messages IDs we need... */
+ VL_MSG_FIRST_AVAILABLE,
+} vl_msg_id_t;
+#undef vl_msg_id
+
+#endif
diff --git a/src/vnet/dpo/l2_bridge_dpo.c b/src/vnet/dpo/l2_bridge_dpo.c
index 7317fcdacc3..fd92a61e960 100644
--- a/src/vnet/dpo/l2_bridge_dpo.c
+++ b/src/vnet/dpo/l2_bridge_dpo.c
@@ -312,7 +312,7 @@ l2_bridge_dpo_inline (vlib_main_t * vm,
vnet_buffer(b0)->sw_if_index[VLIB_TX] = l2b0->l2b_sw_if_index;
/*
- * take that, and rewind it back...
+ * take that, rewind it back...
*/
len0 = ((u8*)vlib_buffer_get_current(b0) -
(u8*)ethernet_buffer_get_header(b0));
diff --git a/src/vnet/l2/l2_input.h b/src/vnet/l2/l2_input.h
index e8a6c776cef..dc9d95484ee 100644
--- a/src/vnet/l2/l2_input.h
+++ b/src/vnet/l2/l2_input.h
@@ -112,6 +112,7 @@ l2input_bd_config (u32 bd_index)
_(FWD, "l2-fwd") \
_(RW, "l2-rw") \
_(LEARN, "l2-learn") \
+ _(L2_EMULATION, "l2-emulation") \
_(VTR, "l2-input-vtr") \
_(VPATH, "vpath-input-l2") \
_(ACL, "l2-input-acl") \
diff --git a/src/vpp-api/vom/Makefile.am b/src/vpp-api/vom/Makefile.am
index 8eab140896a..b1fbfeedb35 100644
--- a/src/vpp-api/vom/Makefile.am
+++ b/src/vpp-api/vom/Makefile.am
@@ -72,6 +72,8 @@ libvom_la_SOURCES = \
ip_unnumbered.cpp \
l2_binding_cmds.cpp \
l2_binding.cpp \
+ l2_emulation_cmds.cpp \
+ l2_emulation.cpp \
l3_binding_cmds.cpp \
l3_binding.cpp \
lldp_binding_cmds.cpp \
@@ -130,6 +132,7 @@ vominclude_HEADERS = \
interface_span.hpp \
ip_unnumbered.hpp \
l2_binding.hpp \
+ l2_emulation.hpp \
l3_binding.hpp \
lldp_binding.hpp \
lldp_global.hpp \
diff --git a/src/vpp-api/vom/bridge_domain.cpp b/src/vpp-api/vom/bridge_domain.cpp
index ef737d971bc..17144a67ca9 100644
--- a/src/vpp-api/vom/bridge_domain.cpp
+++ b/src/vpp-api/vom/bridge_domain.cpp
@@ -67,7 +67,7 @@ bridge_domain::id() const
bool
bridge_domain::operator==(const bridge_domain& b) const
{
- return (id() == b.id());
+ return ((m_learning_mode == b.m_learning_mode) && id() == b.id());
}
void
diff --git a/src/vpp-api/vom/l2_emulation.cpp b/src/vpp-api/vom/l2_emulation.cpp
new file mode 100644
index 00000000000..2a2757616be
--- /dev/null
+++ b/src/vpp-api/vom/l2_emulation.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2017 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.
+ */
+
+#include "vom/l2_emulation.hpp"
+#include "vom/l2_emulation_cmds.hpp"
+
+namespace VOM {
+/**
+ * A DB of all the L2 Configs
+ */
+singular_db<l2_emulation::key_t, l2_emulation> l2_emulation::m_db;
+
+l2_emulation::event_handler l2_emulation::m_evh;
+
+/**
+ * Construct a new object matching the desried state
+ */
+l2_emulation::l2_emulation(const interface& itf)
+ : m_itf(itf.singular())
+ , m_emulation(0)
+{
+}
+
+l2_emulation::l2_emulation(const l2_emulation& o)
+ : m_itf(o.m_itf)
+ , m_emulation(0)
+{
+}
+
+const l2_emulation::key_t&
+l2_emulation::key() const
+{
+ return (m_itf->key());
+}
+
+bool
+l2_emulation::operator==(const l2_emulation& l) const
+{
+ return ((*m_itf == *l.m_itf));
+}
+
+std::shared_ptr<l2_emulation>
+l2_emulation::find(const key_t& key)
+{
+ return (m_db.find(key));
+}
+
+void
+l2_emulation::sweep()
+{
+ if (m_emulation && handle_t::INVALID != m_itf->handle()) {
+ HW::enqueue(
+ new l2_emulation_cmds::enable_cmd(m_emulation, m_itf->handle()));
+ }
+
+ // no need to undo the VTR operation.
+ HW::write();
+}
+
+void
+l2_emulation::replay()
+{
+ if (m_emulation && handle_t::INVALID != m_itf->handle()) {
+ HW::enqueue(
+ new l2_emulation_cmds::disable_cmd(m_emulation, m_itf->handle()));
+ }
+}
+
+l2_emulation::~l2_emulation()
+{
+ sweep();
+
+ // not in the DB anymore.
+ m_db.release(m_itf->key(), this);
+}
+
+std::string
+l2_emulation::to_string() const
+{
+ std::ostringstream s;
+ s << "L2-emulation:[" << m_itf->to_string() << "]";
+
+ return (s.str());
+}
+
+void
+l2_emulation::update(const l2_emulation& desired)
+{
+ /*
+ * the desired state is always that the interface should be created
+ */
+ if (rc_t::OK != m_emulation.rc()) {
+ HW::enqueue(
+ new l2_emulation_cmds::enable_cmd(m_emulation, m_itf->handle()));
+ }
+}
+
+std::shared_ptr<l2_emulation>
+l2_emulation::find_or_add(const l2_emulation& temp)
+{
+ return (m_db.find_or_add(temp.m_itf->key(), temp));
+}
+
+std::shared_ptr<l2_emulation>
+l2_emulation::singular() const
+{
+ return find_or_add(*this);
+}
+
+void
+l2_emulation::dump(std::ostream& os)
+{
+ m_db.dump(os);
+}
+
+l2_emulation::event_handler::event_handler()
+{
+ OM::register_listener(this);
+ inspect::register_handler({ "l2e" }, "L2 Emulation", this);
+}
+
+void
+l2_emulation::event_handler::handle_replay()
+{
+ m_db.replay();
+}
+
+void
+l2_emulation::event_handler::handle_populate(const client_db::key_t& key)
+{
+ /**
+ * This is done while populating the bridge-domain
+ */
+}
+
+dependency_t
+l2_emulation::event_handler::order() const
+{
+ return (dependency_t::BINDING);
+}
+
+void
+l2_emulation::event_handler::show(std::ostream& os)
+{
+ m_db.dump(os);
+}
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "mozilla")
+ * End:
+ */
diff --git a/src/vpp-api/vom/l2_emulation.hpp b/src/vpp-api/vom/l2_emulation.hpp
new file mode 100644
index 00000000000..faf4df8b0a7
--- /dev/null
+++ b/src/vpp-api/vom/l2_emulation.hpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2017 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.
+ */
+
+#ifndef __VOM_L2_EMULATION_H__
+#define __VOM_L2_EMULATION_H__
+
+#include "vom/bridge_domain.hpp"
+#include "vom/hw.hpp"
+#include "vom/inspect.hpp"
+#include "vom/interface.hpp"
+#include "vom/object_base.hpp"
+#include "vom/om.hpp"
+#include "vom/singular_db.hpp"
+
+namespace VOM {
+/**
+ * A Clas representing the binding of an L2 interface to a bridge-domain
+ * and the properties of that binding.
+ */
+class l2_emulation : public object_base
+{
+public:
+ /**
+ * Key type for an L2 emulation in the singular DB
+ */
+ typedef interface::key_t key_t;
+
+ /**
+ * Construct a new object matching the desried state
+ */
+ l2_emulation(const interface& itf);
+
+ /**
+ * Copy Constructor
+ */
+ l2_emulation(const l2_emulation& o);
+
+ /**
+ * Destructor
+ */
+ ~l2_emulation();
+
+ /**
+ * Return the binding's key
+ */
+ const key_t& key() const;
+
+ /**
+ * Comparison operator - for UT
+ */
+ bool operator==(const l2_emulation& l) const;
+
+ /**
+ * Return the 'singular instance' of the L2 config that matches this
+ * object
+ */
+ std::shared_ptr<l2_emulation> singular() const;
+
+ /**
+ * convert to string format for debug purposes
+ */
+ std::string to_string() const;
+
+ /**
+ * Dump all l2_emulations into the stream provided
+ */
+ static void dump(std::ostream& os);
+
+ /**
+ * Static function to find the bridge_domain in the model
+ */
+ static std::shared_ptr<l2_emulation> find(const key_t& key);
+
+private:
+ /**
+ * Class definition for listeners to OM events
+ */
+ class event_handler : public OM::listener, public inspect::command_handler
+ {
+ public:
+ event_handler();
+ virtual ~event_handler() = default;
+
+ /**
+ * Handle a populate event
+ */
+ void handle_populate(const client_db::key_t& key);
+
+ /**
+ * Handle a replay event
+ */
+ void handle_replay();
+
+ /**
+ * Show the object in the Singular DB
+ */
+ void show(std::ostream& os);
+
+ /**
+ * Get the sortable Id of the listener
+ */
+ dependency_t order() const;
+ };
+
+ /**
+ * event_handler to register with OM
+ */
+ static event_handler m_evh;
+
+ /**
+ * Enquue commonds to the VPP command Q for the update
+ */
+ void update(const l2_emulation& obj);
+
+ /**
+ * Find or Add the singular instance in the DB
+ */
+ static std::shared_ptr<l2_emulation> find_or_add(const l2_emulation& temp);
+
+ /*
+ * It's the OM class that calls singular()
+ */
+ friend class OM;
+
+ /**
+ * It's the singular_db class that calls replay()
+ */
+ friend class singular_db<key_t, l2_emulation>;
+
+ /**
+ * Sweep/reap the object if still stale
+ */
+ void sweep(void);
+
+ /**
+ * replay the object to create it in hardware
+ */
+ void replay(void);
+
+ /**
+ * A reference counting pointer the interface that this L2 layer
+ * represents. By holding the reference here, we can guarantee that
+ * this object will outlive the interface
+ */
+ const std::shared_ptr<interface> m_itf;
+
+ /**
+ * HW configuration for the emulation. The bool representing the
+ * enable/disable.
+ */
+ HW::item<bool> m_emulation;
+
+ /**
+ * A map of all L2 emulation configurations
+ */
+ static singular_db<key_t, l2_emulation> m_db;
+};
+};
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "mozilla")
+ * End:
+ */
+
+#endif
diff --git a/src/vpp-api/vom/l2_emulation_cmds.cpp b/src/vpp-api/vom/l2_emulation_cmds.cpp
new file mode 100644
index 00000000000..07107d6ff58
--- /dev/null
+++ b/src/vpp-api/vom/l2_emulation_cmds.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2017 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.
+ */
+
+#include "vom/l2_emulation_cmds.hpp"
+
+DEFINE_VAPI_MSG_IDS_L2E_API_JSON;
+
+namespace VOM {
+namespace l2_emulation_cmds {
+enable_cmd::enable_cmd(HW::item<bool>& item, const handle_t& itf)
+ : rpc_cmd(item)
+ , m_itf(itf)
+{
+}
+
+bool
+enable_cmd::operator==(const enable_cmd& other) const
+{
+ return (m_itf == other.m_itf);
+}
+
+rc_t
+enable_cmd::issue(connection& con)
+{
+ msg_t req(con.ctx(), std::ref(*this));
+
+ auto& payload = req.get_request().get_payload();
+ payload.sw_if_index = m_itf.value();
+ payload.enable = 1;
+
+ VAPI_CALL(req.execute());
+
+ m_hw_item.set(wait());
+
+ return (rc_t::OK);
+}
+
+std::string
+enable_cmd::to_string() const
+{
+ std::ostringstream s;
+ s << "L2-emulation: " << m_hw_item.to_string()
+ << " itf:" << m_itf.to_string();
+
+ return (s.str());
+}
+
+disable_cmd::disable_cmd(HW::item<bool>& item, const handle_t& itf)
+ : rpc_cmd(item)
+ , m_itf(itf)
+{
+}
+
+bool
+disable_cmd::operator==(const disable_cmd& other) const
+{
+ return (m_itf == other.m_itf);
+}
+
+rc_t
+disable_cmd::issue(connection& con)
+{
+ msg_t req(con.ctx(), std::ref(*this));
+
+ auto& payload = req.get_request().get_payload();
+ payload.sw_if_index = m_itf.value();
+ payload.enable = 0;
+
+ VAPI_CALL(req.execute());
+
+ wait();
+
+ return (rc_t::OK);
+}
+
+std::string
+disable_cmd::to_string() const
+{
+ std::ostringstream s;
+ s << "L2-emulation: " << m_hw_item.to_string()
+ << " itf:" << m_itf.to_string();
+
+ return (s.str());
+}
+
+}; // namespace l2_emulation_cmds
+}; // namespace VOM
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "mozilla")
+ * End:
+ */
diff --git a/src/vpp-api/vom/l2_emulation_cmds.hpp b/src/vpp-api/vom/l2_emulation_cmds.hpp
new file mode 100644
index 00000000000..aeff3a8ddd7
--- /dev/null
+++ b/src/vpp-api/vom/l2_emulation_cmds.hpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2017 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.
+ */
+
+#ifndef __VOM_L2_EMULATION_CMDS_H__
+#define __VOM_L2_EMULATION_CMDS_H__
+
+#include "vom/l2_emulation.hpp"
+#include "vom/rpc_cmd.hpp"
+
+#include <vapi/l2e.api.vapi.hpp>
+
+namespace VOM {
+namespace l2_emulation_cmds {
+
+/**
+ * A functor class that enable L2 emulation to an interface
+ */
+class enable_cmd : public rpc_cmd<HW::item<bool>, rc_t, vapi::L2_emulation>
+{
+public:
+ /**
+ * Constructor
+ */
+ enable_cmd(HW::item<bool>& item, const handle_t& itf);
+
+ /**
+ * Issue the command to VPP/HW
+ */
+ rc_t issue(connection& con);
+ /**
+ * convert to string format for debug purposes
+ */
+ std::string to_string() const;
+
+ /**
+ * Comparison operator - only used for UT
+ */
+ bool operator==(const enable_cmd& i) const;
+
+private:
+ /**
+ * The interface to bind
+ */
+ const handle_t m_itf;
+};
+
+/**
+ * A cmd class that Unbinds L2 configuration from an interface
+ */
+class disable_cmd : public rpc_cmd<HW::item<bool>, rc_t, vapi::L2_emulation>
+{
+public:
+ /**
+ * Constructor
+ */
+ disable_cmd(HW::item<bool>& item, const handle_t& itf);
+
+ /**
+ * Issue the command to VPP/HW
+ */
+ rc_t issue(connection& con);
+ /**
+ * convert to string format for debug purposes
+ */
+ std::string to_string() const;
+
+ /**
+ * Comparison operator - only used for UT
+ */
+ bool operator==(const disable_cmd& i) const;
+
+private:
+ /**
+ * The interface to bind
+ */
+ const handle_t m_itf;
+};
+
+}; // namespace l2_emulation_cmds
+}; // namespace VOM
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "mozilla")
+ * End:
+ */
+
+#endif
diff --git a/test/test_dvr.py b/test/test_dvr.py
index f5d5e54a15f..e8a9c04a1bb 100644
--- a/test/test_dvr.py
+++ b/test/test_dvr.py
@@ -5,7 +5,8 @@ import unittest
from framework import VppTestCase, VppTestRunner
from vpp_sub_interface import VppSubInterface, VppDot1QSubint
-from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto
+from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto, VppIpMRoute, \
+ VppMRoutePath, MRouteEntryFlags, MRouteItfFlags
from vpp_papi_provider import L2_VTR_OP
from scapy.packet import Raw
@@ -35,6 +36,39 @@ class TestDVR(VppTestCase):
super(TestDVR, self).tearDown()
+ def send_and_assert_no_replies(self, intf, pkts):
+ self.vapi.cli("clear trace")
+ intf.add_stream(pkts)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+ for i in self.pg_interfaces:
+ i.get_capture(0)
+ i.assert_nothing_captured()
+
+ def send_and_expect(self, input, pkts, output):
+ self.vapi.cli("clear trace")
+ input.add_stream(pkts)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+ rx = output.get_capture(len(pkts))
+ return rx
+
+ def assert_same_mac_addr(self, tx, rx):
+ t_eth = tx[Ether]
+ for p in rx:
+ r_eth = p[Ether]
+ self.assertEqual(t_eth.src, r_eth.src)
+ self.assertEqual(t_eth.dst, r_eth.dst)
+
+ def assert_has_vlan_tag(self, tag, rx):
+ for p in rx:
+ r_1q = p[Dot1Q]
+ self.assertEqual(tag, r_1q.vlan)
+
+ def assert_has_no_tag(self, rx):
+ for p in rx:
+ self.assertFalse(p.haslayer(Dot1Q))
+
def test_dvr(self):
""" Distributed Virtual Router """
@@ -110,27 +144,20 @@ class TestDVR(VppTestCase):
#
# Add routes to bridge the traffic via a tagged interface
#
- route_no_tag = VppIpRoute(
+ route_with_tag = VppIpRoute(
self, ip_tag_bridged, 32,
[VppRoutePath("0.0.0.0",
sub_if_on_pg3.sw_if_index,
proto=DpoProto.DPO_PROTO_ETHERNET)])
- route_no_tag.add_vpp_config()
+ route_with_tag.add_vpp_config()
#
# Inject the packet that arrives and leaves on a non-tagged interface
# Since it's 'bridged' expect that the MAC headed is unchanged.
#
- self.pg0.add_stream(pkt_tag)
-
- self.pg_enable_capture(self.pg_interfaces)
- self.pg_start()
-
- rx = self.pg3.get_capture(1)
-
- self.assertEqual(rx[0][Ether].dst, pkt_tag[Ether].dst)
- self.assertEqual(rx[0][Ether].src, pkt_tag[Ether].src)
- self.assertEqual(rx[0][Dot1Q].vlan, 93)
+ rx = self.send_and_expect(self.pg0, pkt_tag * 65, self.pg3)
+ self.assert_same_mac_addr(pkt_tag, rx)
+ self.assert_has_vlan_tag(93, rx)
#
# Tag to tag
@@ -143,14 +170,9 @@ class TestDVR(VppTestCase):
UDP(sport=1234, dport=1234) /
Raw('\xa5' * 100))
- self.pg2.add_stream(pkt_tag_to_tag)
- self.pg_enable_capture(self.pg_interfaces)
- self.pg_start()
- rx = self.pg3.get_capture(1)
-
- self.assertEqual(rx[0][Ether].dst, pkt_tag_to_tag[Ether].dst)
- self.assertEqual(rx[0][Ether].src, pkt_tag_to_tag[Ether].src)
- self.assertEqual(rx[0][Dot1Q].vlan, 93)
+ rx = self.send_and_expect(self.pg2, pkt_tag_to_tag * 65, self.pg3)
+ self.assert_same_mac_addr(pkt_tag_to_tag, rx)
+ self.assert_has_vlan_tag(93, rx)
#
# Tag to non-Tag
@@ -163,14 +185,178 @@ class TestDVR(VppTestCase):
UDP(sport=1234, dport=1234) /
Raw('\xa5' * 100))
- self.pg2.add_stream(pkt_tag_to_non_tag)
- self.pg_enable_capture(self.pg_interfaces)
- self.pg_start()
- rx = self.pg1.get_capture(1)
+ rx = self.send_and_expect(self.pg2, pkt_tag_to_non_tag * 65, self.pg1)
+ self.assert_same_mac_addr(pkt_tag_to_tag, rx)
+ self.assert_has_no_tag(rx)
+
+ #
+ # cleanup
+ #
+ self.vapi.sw_interface_set_l2_bridge(self.pg0.sw_if_index, 1,
+ enable=0)
+ self.vapi.sw_interface_set_l2_bridge(self.pg1.sw_if_index, 1,
+ enable=0)
+ self.vapi.sw_interface_set_l2_bridge(sub_if_on_pg2.sw_if_index,
+ 1, enable=0)
+ self.vapi.sw_interface_set_l2_bridge(sub_if_on_pg3.sw_if_index,
+ 1, enable=0)
+ self.vapi.sw_interface_set_l2_bridge(self.loop0.sw_if_index,
+ 1, bvi=1, enable=0)
+
+ #
+ # the explicit route delete is require so it happens before
+ # the sbu-interface delete. subinterface delete is required
+ # because that object type does not use the object registry
+ #
+ route_no_tag.remove_vpp_config()
+ route_with_tag.remove_vpp_config()
+ sub_if_on_pg3.remove_vpp_config()
+ sub_if_on_pg2.remove_vpp_config()
+
+ def test_l2_emulation(self):
+ """ L2 Emulation """
+
+ #
+ # non distinct L3 packets, in the tag/non-tag combos
+ #
+ pkt_no_tag = (Ether(src=self.pg0.remote_mac,
+ dst=self.pg1.remote_mac) /
+ IP(src="2.2.2.2",
+ dst="1.1.1.1") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+ pkt_to_tag = (Ether(src=self.pg0.remote_mac,
+ dst=self.pg2.remote_mac) /
+ IP(src="2.2.2.2",
+ dst="1.1.1.2") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+ pkt_from_tag = (Ether(src=self.pg3.remote_mac,
+ dst=self.pg2.remote_mac) /
+ Dot1Q(vlan=93) /
+ IP(src="2.2.2.2",
+ dst="1.1.1.1") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+ pkt_from_to_tag = (Ether(src=self.pg3.remote_mac,
+ dst=self.pg2.remote_mac) /
+ Dot1Q(vlan=93) /
+ IP(src="2.2.2.2",
+ dst="1.1.1.2") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+ pkt_bcast = (Ether(src=self.pg0.remote_mac,
+ dst="ff:ff:ff:ff:ff:ff") /
+ IP(src="2.2.2.2",
+ dst="255.255.255.255") /
+ UDP(sport=1234, dport=1234) /
+ Raw('\xa5' * 100))
+
+ #
+ # A couple of sub-interfaces for tags
+ #
+ sub_if_on_pg2 = VppDot1QSubint(self, self.pg2, 92)
+ sub_if_on_pg3 = VppDot1QSubint(self, self.pg3, 93)
+ sub_if_on_pg2.admin_up()
+ sub_if_on_pg3.admin_up()
+
+ #
+ # Put all the interfaces into a new bridge domain
+ #
+ self.vapi.sw_interface_set_l2_bridge(self.pg0.sw_if_index, 1)
+ self.vapi.sw_interface_set_l2_bridge(self.pg1.sw_if_index, 1)
+ self.vapi.sw_interface_set_l2_bridge(sub_if_on_pg2.sw_if_index, 1)
+ self.vapi.sw_interface_set_l2_bridge(sub_if_on_pg3.sw_if_index, 1)
+ self.vapi.sw_interface_set_l2_tag_rewrite(sub_if_on_pg2.sw_if_index,
+ L2_VTR_OP.L2_POP_1,
+ 92)
+ self.vapi.sw_interface_set_l2_tag_rewrite(sub_if_on_pg3.sw_if_index,
+ L2_VTR_OP.L2_POP_1,
+ 93)
+
+ #
+ # Disable UU flooding, learning and ARM terminaation. makes this test
+ # easier as unicast packets are dropped if not extracted.
+ #
+ self.vapi.bridge_flags(1, 0, (1 << 0) | (1 << 3) | (1 << 4))
+
+ #
+ # Add a DVR route to steer traffic at L3
+ #
+ route_1 = VppIpRoute(self, "1.1.1.1", 32,
+ [VppRoutePath("0.0.0.0",
+ self.pg1.sw_if_index,
+ proto=DpoProto.DPO_PROTO_ETHERNET)])
+ route_2 = VppIpRoute(self, "1.1.1.2", 32,
+ [VppRoutePath("0.0.0.0",
+ sub_if_on_pg2.sw_if_index,
+ proto=DpoProto.DPO_PROTO_ETHERNET)])
+ route_1.add_vpp_config()
+ route_2.add_vpp_config()
+
+ #
+ # packets are dropped because bridge does not flood unkown unicast
+ #
+ self.send_and_assert_no_replies(self.pg0, pkt_no_tag)
+
+ #
+ # Enable L3 extraction on pgs
+ #
+ self.vapi.sw_interface_set_l2_emulation(self.pg0.sw_if_index)
+ self.vapi.sw_interface_set_l2_emulation(self.pg1.sw_if_index)
+ self.vapi.sw_interface_set_l2_emulation(sub_if_on_pg2.sw_if_index)
+ self.vapi.sw_interface_set_l2_emulation(sub_if_on_pg3.sw_if_index)
+
+ #
+ # now we expect the packet forward according to the DVR route
+ #
+ rx = self.send_and_expect(self.pg0, pkt_no_tag * 65, self.pg1)
+ self.assert_same_mac_addr(pkt_no_tag, rx)
+ self.assert_has_no_tag(rx)
+
+ rx = self.send_and_expect(self.pg0, pkt_to_tag * 65, self.pg2)
+ self.assert_same_mac_addr(pkt_to_tag, rx)
+ self.assert_has_vlan_tag(92, rx)
+
+ rx = self.send_and_expect(self.pg3, pkt_from_tag * 65, self.pg1)
+ self.assert_same_mac_addr(pkt_from_tag, rx)
+ self.assert_has_no_tag(rx)
+
+ rx = self.send_and_expect(self.pg3, pkt_from_to_tag * 65, self.pg2)
+ self.assert_same_mac_addr(pkt_from_tag, rx)
+ self.assert_has_vlan_tag(92, rx)
+
+ #
+ # but broadcast packets are still flooded
+ #
+ self.send_and_expect(self.pg0, pkt_bcast * 33, self.pg2)
+
+ #
+ # cleanup
+ #
+ self.vapi.sw_interface_set_l2_emulation(self.pg0.sw_if_index,
+ enable=0)
+ self.vapi.sw_interface_set_l2_emulation(self.pg1.sw_if_index,
+ enable=0)
+ self.vapi.sw_interface_set_l2_emulation(sub_if_on_pg2.sw_if_index,
+ enable=0)
+ self.vapi.sw_interface_set_l2_emulation(sub_if_on_pg3.sw_if_index,
+ enable=0)
+
+ self.vapi.sw_interface_set_l2_bridge(self.pg0.sw_if_index,
+ 1, enable=0)
+ self.vapi.sw_interface_set_l2_bridge(self.pg1.sw_if_index,
+ 1, enable=0)
+ self.vapi.sw_interface_set_l2_bridge(sub_if_on_pg2.sw_if_index,
+ 1, enable=0)
+ self.vapi.sw_interface_set_l2_bridge(sub_if_on_pg3.sw_if_index,
+ 1, enable=0)
+
+ route_1.remove_vpp_config()
+ route_2.remove_vpp_config()
+ sub_if_on_pg3.remove_vpp_config()
+ sub_if_on_pg2.remove_vpp_config()
- self.assertEqual(rx[0][Ether].dst, pkt_tag_to_tag[Ether].dst)
- self.assertEqual(rx[0][Ether].src, pkt_tag_to_tag[Ether].src)
- self.assertFalse(rx[0].haslayer(Dot1Q))
if __name__ == '__main__':
unittest.main(testRunner=VppTestRunner)
diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py
index aa06cfef4e9..a03677970bb 100644
--- a/test/vpp_papi_provider.py
+++ b/test/vpp_papi_provider.py
@@ -603,6 +603,18 @@ class VppPapiProvider(object):
'tag1': tag1,
'tag2': tag2})
+ def sw_interface_set_l2_emulation(
+ self,
+ sw_if_index,
+ enable=1):
+ """L2 Emulation
+ :param sw_if_index - interface the operation is applied to
+
+ """
+ return self.api(self.papi.l2_emulation,
+ {'sw_if_index': sw_if_index,
+ 'enable': enable})
+
def sw_interface_set_flags(self, sw_if_index, admin_up_down):
"""