summaryrefslogtreecommitdiffstats
path: root/src/plugins/linux-cp/lcp_node.c
diff options
context:
space:
mode:
authorNeale Ranns <nranns@cisco.com>2020-12-24 09:16:09 +0000
committerOle Tr�an <otroan@employees.org>2021-02-04 14:16:34 +0000
commit44db1caefbf5067b0cf0073299c9f21265331412 (patch)
tree4981dc028db66398cf6dc2ca9d309aa5a7bf7a1d /src/plugins/linux-cp/lcp_node.c
parent1a52d37fc50acd479274c29c2e92b05cf32c3a6d (diff)
linux-cp: Linux Interface Mirroring for Control Plane Integration
Type: feature please see FEATURE.yaml for details. Signed-off-by: Neale Ranns <nranns@cisco.com> Signed-off-by: Matthew Smith <mgsmith@netgate.com> Signed-off-by: Jon Loeliger <jdl@netgate.com> Signed-off-by: Pim van Pelt <pim@ipng.nl> Change-Id: I04a45c15c0838906aa787e06660fa29f39f755fa
Diffstat (limited to 'src/plugins/linux-cp/lcp_node.c')
-rw-r--r--src/plugins/linux-cp/lcp_node.c919
1 files changed, 919 insertions, 0 deletions
diff --git a/src/plugins/linux-cp/lcp_node.c b/src/plugins/linux-cp/lcp_node.c
new file mode 100644
index 00000000000..7f099ffe856
--- /dev/null
+++ b/src/plugins/linux-cp/lcp_node.c
@@ -0,0 +1,919 @@
+/*
+ * lcp_enthernet_node.c : linux control plane ethernet node
+ *
+ * Copyright (c) 2021 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 <sys/socket.h>
+#include <linux/if.h>
+
+#include <plugins/linux-cp/lcp_interface.h>
+#include <plugins/linux-cp/lcp_adj.h>
+#include <linux-cp/lcp.api_enum.h>
+
+#include <vnet/feature/feature.h>
+#include <vnet/ip/ip4_packet.h>
+#include <vnet/ethernet/arp_packet.h>
+#include <vnet/ethernet/ethernet.h>
+#include <vnet/ip/ip_types.h>
+#include <vnet/ip/lookup.h>
+#include <vnet/ip/ip4.h>
+#include <vnet/ip/ip6.h>
+#include <vnet/l2/l2_input.h>
+
+#define foreach_lip_punt \
+ _ (IO, "punt to host") \
+ _ (DROP, "unknown input interface")
+
+typedef enum
+{
+#define _(sym, str) LIP_PUNT_NEXT_##sym,
+ foreach_lip_punt
+#undef _
+ LIP_PUNT_N_NEXT,
+} lip_punt_next_t;
+
+typedef struct lip_punt_trace_t_
+{
+ u32 phy_sw_if_index;
+ u32 host_sw_if_index;
+} lip_punt_trace_t;
+
+/* packet trace format function */
+static u8 *
+format_lip_punt_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 *);
+ lip_punt_trace_t *t = va_arg (*args, lip_punt_trace_t *);
+
+ s =
+ format (s, "lip-punt: %u -> %u", t->phy_sw_if_index, t->host_sw_if_index);
+
+ return s;
+}
+
+/**
+ * Pass punted packets from the PHY to the HOST.
+ */
+VLIB_NODE_FN (lip_punt_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ u32 n_left_from, *from, *to_next, n_left_to_next;
+ lip_punt_next_t next_index;
+
+ next_index = node->cached_next_index;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ while (n_left_from > 0)
+ {
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ vlib_buffer_t *b0;
+ const lcp_itf_pair_t *lip0 = NULL;
+ u32 next0 = ~0;
+ u32 bi0, lipi0;
+ u32 sw_if_index0;
+ u8 len0;
+
+ bi0 = to_next[0] = from[0];
+
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+ next0 = LIP_PUNT_NEXT_DROP;
+
+ b0 = vlib_get_buffer (vm, bi0);
+
+ sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ lipi0 = lcp_itf_pair_find_by_phy (sw_if_index0);
+ if (PREDICT_FALSE (lipi0 == INDEX_INVALID))
+ goto trace0;
+
+ lip0 = lcp_itf_pair_get (lipi0);
+ next0 = LIP_PUNT_NEXT_IO;
+ vnet_buffer (b0)->sw_if_index[VLIB_TX] = lip0->lip_host_sw_if_index;
+
+ if (PREDICT_TRUE (lip0->lip_host_type == LCP_ITF_HOST_TAP))
+ {
+ /*
+ * rewind to ethernet header
+ */
+ len0 = ((u8 *) vlib_buffer_get_current (b0) -
+ (u8 *) ethernet_buffer_get_header (b0));
+ vlib_buffer_advance (b0, -len0);
+ }
+ /* Tun packets don't need any special treatment, just need to
+ * be escorted past the TTL decrement. If we still want to use
+ * ip[46]-punt-redirect with these, we could just set the
+ * VNET_BUFFER_F_LOCALLY_ORIGINATED in an 'else {}' here and
+ * then pass to the next node on the ip[46]-punt feature arc
+ */
+
+ trace0:
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lip_punt_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->phy_sw_if_index = sw_if_index0;
+ t->host_sw_if_index =
+ (lipi0 == INDEX_INVALID) ? ~0 : lip0->lip_host_sw_if_index;
+ }
+
+ 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 frame->n_vectors;
+}
+
+VLIB_REGISTER_NODE (lip_punt_node) = {
+ .name = "linux-cp-punt",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lip_punt_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_next_nodes = LIP_PUNT_N_NEXT,
+ .next_nodes = {
+ [LIP_PUNT_NEXT_DROP] = "error-drop",
+ [LIP_PUNT_NEXT_IO] = "interface-output",
+ },
+};
+
+#define foreach_lcp_punt_l3 _ (DROP, "unknown error")
+
+typedef enum
+{
+#define _(sym, str) LCP_LOCAL_NEXT_##sym,
+ foreach_lcp_punt_l3
+#undef _
+ LCP_LOCAL_N_NEXT,
+} lcp_punt_l3_next_t;
+
+typedef struct lcp_punt_l3_trace_t_
+{
+ u32 phy_sw_if_index;
+} lcp_punt_l3_trace_t;
+
+/* packet trace format function */
+static u8 *
+format_lcp_punt_l3_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 *);
+ lcp_punt_l3_trace_t *t = va_arg (*args, lcp_punt_l3_trace_t *);
+
+ s = format (s, "linux-cp-punt-l3: %u", t->phy_sw_if_index);
+
+ return s;
+}
+
+VLIB_NODE_FN (lcp_punt_l3_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ u32 n_left_from, *from, *to_next, n_left_to_next;
+ lip_punt_next_t next_index;
+
+ next_index = node->cached_next_index;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ while (n_left_from > 0)
+ {
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ vlib_buffer_t *b0;
+ u32 next0 = LCP_LOCAL_NEXT_DROP;
+ u32 bi0;
+ index_t lipi0;
+ lcp_itf_pair_t *lip0;
+
+ bi0 = to_next[0] = from[0];
+
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+ vnet_feature_next (&next0, b0);
+
+ lipi0 =
+ lcp_itf_pair_find_by_phy (vnet_buffer (b0)->sw_if_index[VLIB_RX]);
+ if (lipi0 != INDEX_INVALID)
+ {
+ /*
+ * Avoid TTL check for packets which arrived on a tunnel and
+ * are being punted to the local host.
+ */
+ lip0 = lcp_itf_pair_get (lipi0);
+ if (lip0->lip_host_type == LCP_ITF_HOST_TUN)
+ b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+ }
+
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_punt_l3_trace_t *t =
+ vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->phy_sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ }
+
+ 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 frame->n_vectors;
+}
+
+VLIB_REGISTER_NODE (lcp_punt_l3_node) = {
+ .name = "linux-cp-punt-l3",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_punt_l3_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_next_nodes = 1,
+ .next_nodes = {
+ [LCP_LOCAL_NEXT_DROP] = "error-drop",
+ },
+};
+
+VNET_FEATURE_INIT (lcp_punt_l3_ip4, static) = {
+ .arc_name = "ip4-punt",
+ .node_name = "linux-cp-punt-l3",
+ .runs_before = VNET_FEATURES ("ip4-punt-redirect"),
+};
+
+VNET_FEATURE_INIT (lip_punt_l3_ip6, static) = {
+ .arc_name = "ip6-punt",
+ .node_name = "linux-cp-punt-l3",
+ .runs_before = VNET_FEATURES ("ip6-punt-redirect"),
+};
+
+#define foreach_lcp_xc \
+ _ (DROP, "drop") \
+ _ (XC_IP4, "x-connnect-ip4") \
+ _ (XC_IP6, "x-connnect-ip6")
+
+typedef enum
+{
+#define _(sym, str) LCP_XC_NEXT_##sym,
+ foreach_lcp_xc
+#undef _
+ LCP_XC_N_NEXT,
+} lcp_xc_next_t;
+
+typedef struct lcp_xc_trace_t_
+{
+ u32 phy_sw_if_index;
+ adj_index_t adj_index;
+} lcp_xc_trace_t;
+
+/* packet trace format function */
+static u8 *
+format_lcp_xc_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 *);
+ lcp_xc_trace_t *t = va_arg (*args, lcp_xc_trace_t *);
+
+ s = format (s, "lcp-xc: itf:%d adj:%d", t->phy_sw_if_index, t->adj_index);
+
+ return s;
+}
+
+/**
+ * X-connect all packets from the HOST to the PHY.
+ *
+ * This runs in either the IP4 or IP6 path. The MAC rewrite on the received
+ * packet from the host is used as a key to find the adjacency used on the phy.
+ * This allows this code to start the feature arc on that adjacency.
+ * Consequently, all packet sent from the host are also subject to output
+ * features, which is symmetric w.r.t. to input features.
+ */
+static_always_inline u32
+lcp_xc_inline (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame,
+ ip_address_family_t af)
+{
+ u32 n_left_from, *from, *to_next, n_left_to_next;
+ lcp_xc_next_t next_index;
+ ip_lookup_main_t *lm;
+
+ next_index = 0;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ if (AF_IP4 == af)
+ lm = &ip4_main.lookup_main;
+ else
+ lm = &ip6_main.lookup_main;
+
+ while (n_left_from > 0)
+ {
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ const ethernet_header_t *eth;
+ const lcp_itf_pair_t *lip;
+ u32 next0, bi0, lipi, ai;
+ vlib_buffer_t *b0;
+
+ bi0 = to_next[0] = from[0];
+
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+
+ lipi =
+ lcp_itf_pair_find_by_host (vnet_buffer (b0)->sw_if_index[VLIB_RX]);
+ lip = lcp_itf_pair_get (lipi);
+
+ vnet_buffer (b0)->sw_if_index[VLIB_TX] = lip->lip_phy_sw_if_index;
+ vlib_buffer_advance (b0, -lip->lip_rewrite_len);
+ eth = vlib_buffer_get_current (b0);
+
+ if (ethernet_address_cast (eth->dst_address))
+ ai = lip->lip_phy_adjs.adj_index[af];
+ else
+ ai = lcp_adj_lkup ((u8 *) eth, lip->lip_rewrite_len,
+ vnet_buffer (b0)->sw_if_index[VLIB_TX]);
+
+ if (ADJ_INDEX_INVALID != ai)
+ {
+ const ip_adjacency_t *adj;
+
+ adj = adj_get (ai);
+ vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ai;
+ next0 = adj->rewrite_header.next_index;
+ vnet_buffer (b0)->ip.save_rewrite_length = lip->lip_rewrite_len;
+
+ if (PREDICT_FALSE (adj->rewrite_header.flags &
+ VNET_REWRITE_HAS_FEATURES))
+ vnet_feature_arc_start_w_cfg_index (
+ lm->output_feature_arc_index,
+ vnet_buffer (b0)->sw_if_index[VLIB_TX], &next0, b0,
+ adj->ia_cfg_index);
+ }
+ else
+ next0 = LCP_XC_NEXT_DROP;
+
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_xc_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->phy_sw_if_index = lip->lip_phy_sw_if_index;
+ t->adj_index = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
+ }
+
+ 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 frame->n_vectors;
+}
+
+VLIB_NODE_FN (lcp_xc_ip4)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ return (lcp_xc_inline (vm, node, frame, AF_IP4));
+}
+
+VLIB_NODE_FN (lcp_xc_ip6)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ return (lcp_xc_inline (vm, node, frame, AF_IP6));
+}
+
+VLIB_REGISTER_NODE (lcp_xc_ip4) = { .name = "linux-cp-xc-ip4",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_xc_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+ .sibling_of = "ip4-rewrite" };
+
+VNET_FEATURE_INIT (lcp_xc_ip4_ucast_node, static) = {
+ .arc_name = "ip4-unicast",
+ .node_name = "linux-cp-xc-ip4",
+};
+VNET_FEATURE_INIT (lcp_xc_ip4_mcast_node, static) = {
+ .arc_name = "ip4-multicast",
+ .node_name = "linux-cp-xc-ip4",
+};
+
+VLIB_REGISTER_NODE (lcp_xc_ip6) = { .name = "linux-cp-xc-ip6",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_xc_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+ .sibling_of = "ip6-rewrite" };
+
+VNET_FEATURE_INIT (lcp_xc_ip6_ucast_node, static) = {
+ .arc_name = "ip6-unicast",
+ .node_name = "linux-cp-xc-ip6",
+};
+VNET_FEATURE_INIT (lcp_xc_ip6_mcast_node, static) = {
+ .arc_name = "ip6-multicast",
+ .node_name = "linux-cp-xc-ip6",
+};
+
+typedef enum
+{
+ LCP_XC_L3_NEXT_XC,
+ LCP_XC_L3_N_NEXT,
+} lcp_xc_l3_next_t;
+
+/**
+ * X-connect all packets from the HOST to the PHY on L3 interfaces
+ *
+ * There's only one adjacency that can be used on thises links.
+ */
+static_always_inline u32
+lcp_xc_l3_inline (vlib_main_t *vm, vlib_node_runtime_t *node,
+ vlib_frame_t *frame, ip_address_family_t af)
+{
+ u32 n_left_from, *from, *to_next, n_left_to_next;
+ lcp_xc_next_t next_index;
+
+ next_index = 0;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ while (n_left_from > 0)
+ {
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ vlib_buffer_t *b0;
+ const lcp_itf_pair_t *lip;
+ u32 next0 = ~0;
+ u32 bi0, lipi;
+
+ bi0 = to_next[0] = from[0];
+
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+
+ /* Flag buffers as locally originated. Otherwise their TTL will
+ * be checked & decremented. That would break services like BGP
+ * which set a TTL of 1 by default.
+ */
+ b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+
+ lipi =
+ lcp_itf_pair_find_by_host (vnet_buffer (b0)->sw_if_index[VLIB_RX]);
+ lip = lcp_itf_pair_get (lipi);
+
+ vnet_buffer (b0)->sw_if_index[VLIB_TX] = lip->lip_phy_sw_if_index;
+ next0 = LCP_XC_L3_NEXT_XC;
+ vnet_buffer (b0)->ip.adj_index[VLIB_TX] =
+ lip->lip_phy_adjs.adj_index[af];
+
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_xc_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->phy_sw_if_index = lip->lip_phy_sw_if_index;
+ t->adj_index = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
+ }
+
+ 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 frame->n_vectors;
+}
+
+/**
+ * X-connect all packets from the HOST to the PHY.
+ */
+VLIB_NODE_FN (lcp_xc_l3_ip4_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ return (lcp_xc_l3_inline (vm, node, frame, AF_IP4));
+}
+
+VLIB_NODE_FN (lcp_xc_l3_ip6_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ return (lcp_xc_l3_inline (vm, node, frame, AF_IP6));
+}
+
+VLIB_REGISTER_NODE (lcp_xc_l3_ip4_node) = {
+ .name = "linux-cp-xc-l3-ip4",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_xc_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_next_nodes = LCP_XC_L3_N_NEXT,
+ .next_nodes = {
+ [LCP_XC_L3_NEXT_XC] = "ip4-midchain",
+ },
+};
+
+VNET_FEATURE_INIT (lcp_xc_node_l3_ip4_unicast, static) = {
+ .arc_name = "ip4-unicast",
+ .node_name = "linux-cp-xc-l3-ip4",
+};
+
+VNET_FEATURE_INIT (lcp_xc_node_l3_ip4_multicaast, static) = {
+ .arc_name = "ip4-multicast",
+ .node_name = "linux-cp-xc-l3-ip4",
+};
+
+VLIB_REGISTER_NODE (lcp_xc_l3_ip6_node) = {
+ .name = "linux-cp-xc-l3-ip6",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_xc_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_next_nodes = LCP_XC_L3_N_NEXT,
+ .next_nodes = {
+ [LCP_XC_L3_NEXT_XC] = "ip6-midchain",
+ },
+};
+
+VNET_FEATURE_INIT (lcp_xc_node_l3_ip6_unicast, static) = {
+ .arc_name = "ip6-unicast",
+ .node_name = "linux-cp-xc-l3-ip6",
+};
+
+VNET_FEATURE_INIT (lcp_xc_node_l3_ip6_multicast, static) = {
+ .arc_name = "ip6-multicast",
+ .node_name = "linux-cp-xc-l3-ip6",
+};
+
+#define foreach_lcp_arp \
+ _ (DROP, "error-drop") \
+ _ (IO, "interface-output")
+
+typedef enum
+{
+#define _(sym, str) LCP_ARP_NEXT_##sym,
+ foreach_lcp_arp
+#undef _
+ LCP_ARP_N_NEXT,
+} lcp_arp_next_t;
+
+typedef struct lcp_arp_trace_t_
+{
+ u32 rx_sw_if_index;
+ u16 arp_opcode;
+} lcp_arp_trace_t;
+
+/* packet trace format function */
+static u8 *
+format_lcp_arp_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 *);
+ lcp_arp_trace_t *t = va_arg (*args, lcp_arp_trace_t *);
+
+ s = format (s, "rx-sw-if-index: %u opcode: %u", t->rx_sw_if_index,
+ t->arp_opcode);
+
+ return s;
+}
+
+/**
+ * punt ARP replies to the host
+ */
+VLIB_NODE_FN (lcp_arp_phy_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ u32 n_left_from, *from, *to_next, n_left_to_next;
+ lcp_arp_next_t next_index;
+ u32 reply_copies[VLIB_FRAME_SIZE];
+ u32 n_copies = 0;
+
+ next_index = node->cached_next_index;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ while (n_left_from > 0)
+ {
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from >= 2 && n_left_to_next >= 2)
+ {
+ u32 next0, next1, bi0, bi1;
+ vlib_buffer_t *b0, *b1;
+ ethernet_arp_header_t *arp0, *arp1;
+
+ 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;
+
+ next0 = next1 = LCP_ARP_NEXT_DROP;
+
+ b0 = vlib_get_buffer (vm, bi0);
+ b1 = vlib_get_buffer (vm, bi1);
+
+ arp0 = vlib_buffer_get_current (b0);
+ arp1 = vlib_buffer_get_current (b1);
+
+ vnet_feature_next (&next0, b0);
+ vnet_feature_next (&next1, b1);
+
+ /*
+ * Replies might need to be received by the host, so we
+ * make a copy of them.
+ */
+ if (arp0->opcode == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
+ {
+ lcp_itf_pair_t *lip0 = 0;
+ u32 lipi0;
+ vlib_buffer_t *c0;
+ u8 len0;
+
+ lipi0 = lcp_itf_pair_find_by_phy (
+ vnet_buffer (b0)->sw_if_index[VLIB_RX]);
+ lip0 = lcp_itf_pair_get (lipi0);
+
+ if (lip0)
+ {
+ /*
+ * rewind to eth header, copy, advance back to current
+ */
+ len0 = ((u8 *) vlib_buffer_get_current (b0) -
+ (u8 *) ethernet_buffer_get_header (b0));
+ vlib_buffer_advance (b0, -len0);
+ c0 = vlib_buffer_copy (vm, b0);
+ vlib_buffer_advance (b0, len0);
+
+ /* Send to the host */
+ vnet_buffer (c0)->sw_if_index[VLIB_TX] =
+ lip0->lip_host_sw_if_index;
+ reply_copies[n_copies++] = vlib_get_buffer_index (vm, c0);
+ }
+ }
+ if (arp1->opcode == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
+ {
+ lcp_itf_pair_t *lip1 = 0;
+ u32 lipi1;
+ vlib_buffer_t *c1;
+ u8 len1;
+
+ lipi1 = lcp_itf_pair_find_by_phy (
+ vnet_buffer (b1)->sw_if_index[VLIB_RX]);
+ lip1 = lcp_itf_pair_get (lipi1);
+
+ if (lip1)
+ {
+ /*
+ * rewind to reveal the ethernet header
+ */
+ len1 = ((u8 *) vlib_buffer_get_current (b1) -
+ (u8 *) ethernet_buffer_get_header (b1));
+ vlib_buffer_advance (b1, -len1);
+ c1 = vlib_buffer_copy (vm, b1);
+ vlib_buffer_advance (b1, len1);
+
+ /* Send to the host */
+ vnet_buffer (c1)->sw_if_index[VLIB_TX] =
+ lip1->lip_host_sw_if_index;
+ reply_copies[n_copies++] = vlib_get_buffer_index (vm, c1);
+ }
+ }
+
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_arp_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->rx_sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ }
+ if (PREDICT_FALSE ((b1->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_arp_trace_t *t = vlib_add_trace (vm, node, b1, sizeof (*t));
+ t->rx_sw_if_index = vnet_buffer (b1)->sw_if_index[VLIB_RX];
+ }
+
+ 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 next0, bi0;
+ vlib_buffer_t *b0;
+ ethernet_arp_header_t *arp0;
+ u16 arp_opcode;
+
+ bi0 = to_next[0] = from[0];
+
+ from += 1;
+ n_left_from -= 1;
+ to_next += 1;
+ n_left_to_next -= 1;
+ next0 = LCP_ARP_NEXT_DROP;
+
+ b0 = vlib_get_buffer (vm, bi0);
+ arp0 = vlib_buffer_get_current (b0);
+
+ vnet_feature_next (&next0, b0);
+
+ /*
+ * Replies might need to be received by the host, so we
+ * make a copy of them.
+ */
+ arp_opcode = clib_host_to_net_u16 (arp0->opcode);
+
+ if (arp_opcode == ETHERNET_ARP_OPCODE_reply)
+ {
+ lcp_itf_pair_t *lip0 = 0;
+ vlib_buffer_t *c0;
+ u32 lipi0;
+ u8 len0;
+
+ lipi0 = lcp_itf_pair_find_by_phy (
+ vnet_buffer (b0)->sw_if_index[VLIB_RX]);
+ lip0 = lcp_itf_pair_get (lipi0);
+
+ if (lip0)
+ {
+
+ /*
+ * rewind to reveal the ethernet header
+ */
+ len0 = ((u8 *) vlib_buffer_get_current (b0) -
+ (u8 *) ethernet_buffer_get_header (b0));
+ vlib_buffer_advance (b0, -len0);
+ c0 = vlib_buffer_copy (vm, b0);
+ vlib_buffer_advance (b0, len0);
+
+ /* Send to the host */
+ vnet_buffer (c0)->sw_if_index[VLIB_TX] =
+ lip0->lip_host_sw_if_index;
+ reply_copies[n_copies++] = vlib_get_buffer_index (vm, c0);
+ }
+ }
+
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_arp_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->rx_sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ t->arp_opcode = arp_opcode;
+ }
+
+ 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);
+ }
+
+ if (n_copies)
+ vlib_buffer_enqueue_to_single_next (vm, node, reply_copies,
+ LCP_ARP_NEXT_IO, n_copies);
+
+ return frame->n_vectors;
+}
+
+VLIB_REGISTER_NODE (lcp_arp_phy_node) = {
+ .name = "linux-cp-arp-phy",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_arp_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_errors = LINUXCP_N_ERROR,
+ .error_counters = linuxcp_error_counters,
+
+ .n_next_nodes = LCP_ARP_N_NEXT,
+ .next_nodes = {
+ [LCP_ARP_NEXT_DROP] = "error-drop",
+ [LCP_ARP_NEXT_IO] = "interface-output",
+ },
+};
+
+VNET_FEATURE_INIT (lcp_arp_phy_arp_feat, static) = {
+ .arc_name = "arp",
+ .node_name = "linux-cp-arp-phy",
+ .runs_before = VNET_FEATURES ("arp-reply"),
+};
+
+/**
+ * x-connect ARP packets from the host to the phy
+ */
+VLIB_NODE_FN (lcp_arp_host_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ u32 n_left_from, *from, *to_next, n_left_to_next;
+ lcp_arp_next_t next_index;
+
+ next_index = node->cached_next_index;
+ n_left_from = frame->n_vectors;
+ from = vlib_frame_vector_args (frame);
+
+ while (n_left_from > 0)
+ {
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ const lcp_itf_pair_t *lip0;
+ lcp_arp_next_t next0;
+ vlib_buffer_t *b0;
+ u32 bi0, lipi0;
+ u8 len0;
+
+ bi0 = to_next[0] = from[0];
+
+ from += 1;
+ n_left_from -= 1;
+ to_next += 1;
+ n_left_to_next -= 1;
+ next0 = LCP_ARP_NEXT_IO;
+
+ b0 = vlib_get_buffer (vm, bi0);
+
+ lipi0 =
+ lcp_itf_pair_find_by_host (vnet_buffer (b0)->sw_if_index[VLIB_RX]);
+ lip0 = lcp_itf_pair_get (lipi0);
+
+ /* Send to the phy */
+ vnet_buffer (b0)->sw_if_index[VLIB_TX] = lip0->lip_phy_sw_if_index;
+
+ len0 = ((u8 *) vlib_buffer_get_current (b0) -
+ (u8 *) ethernet_buffer_get_header (b0));
+ vlib_buffer_advance (b0, -len0);
+
+ if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
+ {
+ lcp_arp_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->rx_sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ }
+
+ 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 frame->n_vectors;
+}
+
+VLIB_REGISTER_NODE (lcp_arp_host_node) = {
+ .name = "linux-cp-arp-host",
+ .vector_size = sizeof (u32),
+ .format_trace = format_lcp_arp_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_errors = LINUXCP_N_ERROR,
+ .error_counters = linuxcp_error_counters,
+
+ .n_next_nodes = LCP_ARP_N_NEXT,
+ .next_nodes = {
+ [LCP_ARP_NEXT_DROP] = "error-drop",
+ [LCP_ARP_NEXT_IO] = "interface-output",
+ },
+};
+
+VNET_FEATURE_INIT (lcp_arp_host_arp_feat, static) = {
+ .arc_name = "arp",
+ .node_name = "linux-cp-arp-host",
+ .runs_before = VNET_FEATURES ("arp-reply"),
+};
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */