aboutsummaryrefslogtreecommitdiffstats
path: root/vpp/app
diff options
context:
space:
mode:
Diffstat (limited to 'vpp/app')
-rw-r--r--vpp/app/l2t.c516
-rw-r--r--vpp/app/l2t_ip6.c327
-rw-r--r--vpp/app/l2t_l2.c252
-rw-r--r--vpp/app/sticky_hash.c554
-rw-r--r--vpp/app/vpe_cli.c105
5 files changed, 1754 insertions, 0 deletions
diff --git a/vpp/app/l2t.c b/vpp/app/l2t.c
new file mode 100644
index 00000000..c230e059
--- /dev/null
+++ b/vpp/app/l2t.c
@@ -0,0 +1,516 @@
+/*
+ * 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.
+ */
+#include <vnet/vnet.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ethernet/ethernet.h>
+
+#if DPDK == 0
+#include <vnet/devices/pci/ixge.h>
+#else
+#include <vnet/devices/dpdk/dpdk.h>
+#endif
+
+#include <vppinfra/error.h>
+#include <vppinfra/hash.h>
+#include <app/l2t.h>
+
+l2t_main_t l2t_main;
+
+/* $$$$ unused?
+ * get_interface_ethernet_address
+ * paints the ethernet address for a given interface
+ * into the supplied destination
+ */
+void get_interface_ethernet_address (l2t_main_t *lm,
+ u8 *dst, u32 sw_if_index)
+{
+ ethernet_main_t *em = ethernet_get_main (lm->vlib_main);
+ ethernet_interface_t *ei;
+ vnet_hw_interface_t *hi;
+
+ hi = vnet_get_sup_hw_interface (lm->vnet_main, sw_if_index);
+ ei = pool_elt_at_index (em->interfaces, hi->hw_instance);
+ memcpy (dst, ei->address, sizeof (ei->address));
+}
+
+/* packet trace format function */
+u8 * format_l2t_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 *);
+ l2t_trace_t * t = va_arg (*args, l2t_trace_t *);
+
+ if (t->is_user_to_network)
+ s = format (s, "L2T: %U (client) -> %U (our) session %d",
+ format_ip6_address, &t->client_address,
+ format_ip6_address, &t->our_address,
+ t->session_index);
+ else
+ s = format (s, "L2T: %U (our) -> %U (client) session %d)",
+ format_ip6_address, &t->our_address,
+ format_ip6_address, &t->client_address,
+ t->session_index);
+ return s;
+}
+
+u8 * format_l2t_session (u8 * s, va_list * args)
+{
+ l2t_session_t * session = va_arg (*args, l2t_session_t *);
+ l2t_main_t * lm = &l2t_main;
+ u32 counter_index;
+ vlib_counter_t v;
+
+ s = format (s, "[%d] %U (our) %U (client) vlan-id %d rx_sw_if_index %d\n",
+ session - lm->sessions,
+ format_ip6_address, &session->our_address,
+ format_ip6_address, &session->client_address,
+ clib_net_to_host_u16(session->vlan_id), session->sw_if_index);
+
+ s = format (s, " local cookie %llx remote cookie %llx\n",
+ clib_net_to_host_u64 (session->local_cookie),
+ clib_net_to_host_u64 (session->remote_cookie));
+
+ if (session->cookie_flags & L2TP_COOKIE_ROLLOVER_LOCAL) {
+ s = format (s, " local rollover cookie %llx\n",
+ clib_net_to_host_u64 (session->lcl_ro_cookie));
+ }
+
+ s = format (s, " local session-id %d remote session-id %d\n",
+ clib_net_to_host_u32 (session->local_session_id),
+ clib_net_to_host_u32 (session->remote_session_id));
+
+ s = format (s, " l2 specific sublayer %s\n",
+ session->l2_sublayer_present ? "preset" : "absent");
+
+ counter_index =
+ session_index_to_counter_index (session - lm->sessions,
+ SESSION_COUNTER_USER_TO_NETWORK);
+
+ vlib_get_combined_counter (&lm->counter_main, counter_index, &v);
+ if (v.packets != 0)
+ s = format (s, " user-to-net: %llu pkts %llu bytes\n",
+ v.packets, v.bytes);
+
+ vlib_get_combined_counter (&lm->counter_main, counter_index+1, &v);
+
+ if (v.packets != 0)
+ s = format (s, " net-to-user: %llu pkts %llu bytes\n",
+ v.packets, v.bytes);
+ return s;
+}
+
+static clib_error_t *
+show_session_summary_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ l2t_main_t *lm = &l2t_main;
+
+ vlib_cli_output (vm, "%d active sessions\n", pool_elts (lm->sessions));
+
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (show_session_summary_command) = {
+ .path = "show session",
+ .short_help = "show session summary",
+ .function = show_session_summary_command_fn,
+};
+
+static clib_error_t *
+show_session_detail_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ l2t_session_t *session;
+ l2t_main_t *lm = &l2t_main;
+
+ pool_foreach (session, lm->sessions,
+ ({
+ vlib_cli_output (vm, "%U", format_l2t_session, session);
+ }));
+
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (show_session_detail_command) = {
+ .path = "show session detail",
+ .short_help = "show session table detail",
+ .function = show_session_detail_command_fn,
+};
+
+static clib_error_t *
+test_counters_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ l2t_session_t *session;
+ l2t_main_t *lm = &l2t_main;
+ u32 session_index;
+ u32 counter_index;
+ u32 nincr=0;
+
+ pool_foreach (session, lm->sessions,
+ ({
+ session_index = session - lm->sessions;
+ counter_index =
+ session_index_to_counter_index (session_index,
+ SESSION_COUNTER_USER_TO_NETWORK);
+ vlib_increment_combined_counter (&lm->counter_main,
+ counter_index,
+ 1/*pkt*/, 1111 /*bytes*/);
+ vlib_increment_combined_counter (&lm->counter_main,
+ counter_index+1,
+ 1/*pkt*/, 2222 /*bytes*/);
+ nincr++;
+
+ }));
+ vlib_cli_output (vm, "Incremented %d active counters\n", nincr);
+
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (test_counters_command) = {
+ .path = "test counters",
+ .short_help = "increment all active counters",
+ .function = test_counters_command_fn,
+};
+
+static clib_error_t *
+clear_counters_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ l2t_session_t *session;
+ l2t_main_t *lm = &l2t_main;
+ u32 session_index;
+ u32 counter_index;
+ u32 nincr=0;
+
+ pool_foreach (session, lm->sessions,
+ ({
+ session_index = session - lm->sessions;
+ counter_index =
+ session_index_to_counter_index (session_index,
+ SESSION_COUNTER_USER_TO_NETWORK);
+ vlib_zero_combined_counter (&lm->counter_main, counter_index);
+ vlib_zero_combined_counter (&lm->counter_main, counter_index+1);
+ nincr++;
+
+ }));
+ vlib_cli_output (vm, "Cleared %d active counters\n", nincr);
+
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (clear_counters_command) = {
+ .path = "clear counters",
+ .short_help = "clear all active counters",
+ .function = clear_counters_command_fn,
+};
+
+static clib_error_t *
+l2tp_session_add_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ ip6_address_t client_address, our_address;
+ ip6_address_t * dst_address_copy, * src_address_copy;
+ unformat_input_t _line_input, * line_input = &_line_input;
+ u32 vlan_id;
+ u32 sw_if_index = (u32)~0;
+ l2t_main_t *lm = &l2t_main;
+ l2t_session_t *s;
+ uword *p;
+ vnet_hw_interface_t * hi;
+ vnet_sw_interface_t * si;
+ u32 next_index;
+ uword vlan_and_sw_if_index_key;
+ u32 counter_index;
+ u64 local_cookie = (u64)~0, remote_cookie = (u64)~0;
+ u32 local_session_id = 1, remote_session_id = 1;
+ int our_address_set = 0, client_address_set = 0;
+ int l2_sublayer_present = 0;
+
+ /* Get a line of input. */
+ if (! unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (line_input, "client %U",
+ unformat_ip6_address, &client_address))
+ client_address_set = 1;
+ else if (unformat (line_input, "our %U",
+ unformat_ip6_address, &our_address))
+ our_address_set = 1;
+ else if (unformat (line_input, "vlan %d", &vlan_id))
+ ;
+ else if (unformat (line_input, "l2-interface %U",
+ unformat_vnet_sw_interface,
+ vnet_get_main(), &sw_if_index))
+ ;
+ else if (unformat (line_input, "interface %U",
+ unformat_vnet_sw_interface,
+ vnet_get_main(), &sw_if_index))
+ ;
+ else if (unformat (line_input, "local-cookie %llx", &local_cookie))
+ ;
+ else if (unformat (line_input, "remote-cookie %llx", &remote_cookie))
+ ;
+ else if (unformat (line_input, "local-session-id %d",
+ &local_session_id))
+ ;
+ else if (unformat (line_input, "remote-session-id %d",
+ &remote_session_id))
+ ;
+ else if (unformat (line_input, "l2-sublayer-present"))
+ l2_sublayer_present = 1;
+ else
+ return clib_error_return (0, "parse error: '%U'",
+ format_unformat_error, line_input);
+ }
+
+ unformat_free (line_input);
+
+ if (sw_if_index == (u32)~0)
+ return clib_error_return (0, "l2-interface not specified");
+ if (our_address_set == 0)
+ return clib_error_return (0, "our address not specified");
+ if (client_address_set == 0)
+ return clib_error_return (0, "client address not specified");
+
+ remote_session_id = clib_host_to_net_u32 (remote_session_id);
+ local_session_id = clib_host_to_net_u32 (local_session_id);
+
+ switch (lm->lookup_type) {
+ case L2T_LOOKUP_SRC_ADDRESS:
+ p = hash_get_mem (lm->session_by_src_address, &client_address);
+ if (p)
+ return clib_error_return
+ (0, "Session w/ client address %U already exists",
+ format_ip6_address, &client_address);
+ break;
+
+ case L2T_LOOKUP_DST_ADDRESS:
+ p = hash_get_mem (lm->session_by_dst_address, &our_address);
+ if (p)
+ return clib_error_return
+ (0, "Session w/ our address %U already exists",
+ format_ip6_address, &our_address);
+ break;
+
+ case L2T_LOOKUP_SESSION_ID:
+ p = hash_get (lm->session_by_session_id, local_session_id);
+ if (p)
+ return clib_error_return
+ (0,
+ "Session w/ local session id %d already exists",
+ clib_net_to_host_u32 (local_session_id));
+ break;
+
+ default:
+ ASSERT(0);
+ }
+
+ pool_get (lm->sessions, s);
+ memset (s, 0, sizeof (*s));
+ memcpy (&s->our_address, &our_address, sizeof (s->our_address));
+ memcpy (&s->client_address, &client_address, sizeof (s->client_address));
+ s->sw_if_index = sw_if_index;
+ s->vlan_id = clib_host_to_net_u16 (vlan_id);
+ s->local_cookie = clib_host_to_net_u64 (local_cookie);
+ l2tp_session_set_remote_cookie (s, remote_cookie);
+ s->local_session_id = local_session_id;
+ s->remote_session_id = remote_session_id;
+ s->l2_sublayer_present = l2_sublayer_present;
+
+ hi = vnet_get_sup_hw_interface (lm->vnet_main, sw_if_index);
+ si = vnet_get_sup_sw_interface (lm->vnet_main, sw_if_index);
+
+ next_index = vlib_node_add_next (vm, l2t_ip6_node.index,
+ hi->output_node_index);
+ s->l2_output_next_index = next_index;
+ s->l2_output_sw_if_index = si->sw_if_index;
+
+ /* Setup hash table entries */
+ switch (lm->lookup_type) {
+ case L2T_LOOKUP_SRC_ADDRESS:
+ src_address_copy = clib_mem_alloc (sizeof (*src_address_copy));
+ memcpy (src_address_copy, &client_address, sizeof (*src_address_copy));
+ hash_set_mem (lm->session_by_src_address, src_address_copy,
+ s - lm->sessions);
+ break;
+ case L2T_LOOKUP_DST_ADDRESS:
+ dst_address_copy = clib_mem_alloc (sizeof (*dst_address_copy));
+ memcpy (dst_address_copy, &our_address, sizeof (*dst_address_copy));
+ hash_set_mem (lm->session_by_dst_address, dst_address_copy,
+ s - lm->sessions);
+ break;
+ case L2T_LOOKUP_SESSION_ID:
+ hash_set (lm->session_by_session_id, local_session_id,
+ s - lm->sessions);
+ break;
+
+ default:
+ ASSERT(0);
+ }
+
+ vlan_and_sw_if_index_key = ((uword)(s->vlan_id)<<32) | sw_if_index;
+ hash_set (lm->session_by_vlan_and_rx_sw_if_index,
+ vlan_and_sw_if_index_key, s - lm->sessions);
+
+ /* validate counters */
+ counter_index =
+ session_index_to_counter_index (s - lm->sessions,
+ SESSION_COUNTER_USER_TO_NETWORK);
+ vlib_validate_counter (&lm->counter_main, counter_index);
+ vlib_validate_counter (&lm->counter_main, counter_index+1);
+
+ /* Set promiscuous mode on the l2 interface */
+ ethernet_set_flags (lm->vnet_main, hi->hw_if_index,
+ ETHERNET_INTERFACE_FLAG_ACCEPT_ALL);
+ vnet_hw_interface_rx_redirect_to_node (lm->vnet_main, hi->hw_if_index,
+ l2t_l2_node.index);
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (l2tp_session_add_command) = {
+ .path = "l2tp session add",
+ .short_help =
+ "l2tp session add client <ip6> our <ip6> vlan <id> local-cookie <hex> remote-cookie <hex> local-session <dec> remote-session <dec> l2-interface <int>",
+ .function = l2tp_session_add_command_fn,
+};
+
+static clib_error_t *
+l2tp_session_del_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ l2t_main_t *lm = &l2t_main;
+ u32 session_index;
+ l2t_session_t *s;
+ hash_pair_t * hp;
+ void *key;
+ uword vlan_and_sw_if_index_key;
+
+ if (!unformat (input, "%d", &session_index))
+ return clib_error_return (0, "missing session index: '%U'",
+ format_unformat_error, input);
+
+ if (pool_is_free_index (lm->sessions, session_index))
+ return clib_error_return (0, "session %d not in use", session_index);
+
+ s = pool_elt_at_index (lm->sessions, session_index);
+
+ switch (lm->lookup_type) {
+ case L2T_LOOKUP_SRC_ADDRESS:
+ hp = hash_get_pair_mem (lm->session_by_src_address, &s->client_address);
+ if (hp) {
+ key = (void *)(hp->key);
+ hash_unset_mem (lm->session_by_src_address, &s->client_address);
+ clib_mem_free (key);
+ } else
+ clib_warning ("session %d src address key %U AWOL",
+ s - lm->sessions,
+ format_ip6_address, &s->client_address);
+ break;
+
+ case L2T_LOOKUP_DST_ADDRESS:
+ hp = hash_get_pair_mem (lm->session_by_dst_address, &s->our_address);
+ if (hp) {
+ key = (void *)(hp->key);
+ hash_unset_mem (lm->session_by_dst_address, &s->our_address);
+ clib_mem_free (key);
+ } else
+ clib_warning ("session %d dst address key %U AWOL",
+ s - lm->sessions,
+ format_ip6_address, &s->our_address);
+ break;
+
+ case L2T_LOOKUP_SESSION_ID:
+ hash_unset (lm->session_by_session_id, s->local_session_id);
+ break;
+
+ default:
+ ASSERT(0);
+ }
+
+ vlan_and_sw_if_index_key = ((uword)(s->vlan_id)<<32) | s->sw_if_index;
+
+ hash_unset (lm->session_by_vlan_and_rx_sw_if_index, vlan_and_sw_if_index_key);
+
+ pool_put (lm->sessions, s);
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (l2tp_session_del_command) = {
+ .path = "l2tp session delete",
+ .short_help =
+ "l2tp session delete <session-id>",
+ .function = l2tp_session_del_command_fn,
+};
+
+static clib_error_t *
+l2tp_session_cookie_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ l2t_main_t *lm = &l2t_main;
+ u32 session_index;
+ l2t_session_t *s;
+ u64 lcl_ro_cookie = (u64)~0, rem_ro_cookie = (u64)~0;
+ u8 cookie_flags = 0;
+
+ if (!unformat (input, "%d", &session_index))
+ return clib_error_return (0, "missing session index: '%U'",
+ format_unformat_error, input);
+
+ if (pool_is_free_index (lm->sessions, session_index))
+ return clib_error_return (0, "session %d not in use", session_index);
+
+ s = pool_elt_at_index (lm->sessions, session_index);
+
+ if (unformat (input, "commit")) {
+ if (!s->cookie_flags) {
+ return clib_error_return (0,
+ "no rollover cookie ready to commit");
+ } else {
+ l2tp_session_cookie_commit (s);
+ return 0;
+ }
+ }
+ if (!unformat (input, "rollover"))
+ return clib_error_return (0, "missing 'commit|rollover': '%U'",
+ format_unformat_error, input);
+ if (unformat (input, "local %llx", &lcl_ro_cookie)) {
+ cookie_flags |= L2TP_COOKIE_ROLLOVER_LOCAL;
+ l2tp_session_set_local_rollover_cookie (s, lcl_ro_cookie);
+ }
+ if (unformat (input, "remote %llx", &rem_ro_cookie)) {
+ cookie_flags |= L2TP_COOKIE_ROLLOVER_REMOTE;
+ l2tp_session_set_remote_cookie (s, rem_ro_cookie);
+ }
+ if (!cookie_flags)
+ return clib_error_return (0, "no rollover cookie specified");
+
+ return 0;
+}
+
+static VLIB_CLI_COMMAND (l2tp_session_cookie_command) = {
+ .path = "l2tp session cookie",
+ .short_help =
+ "l2tp session cookie <session id> commit|rollover [local <hex>] [remote <hex>]",
+ .function = l2tp_session_cookie_command_fn,
+};
diff --git a/vpp/app/l2t_ip6.c b/vpp/app/l2t_ip6.c
new file mode 100644
index 00000000..ac24886a
--- /dev/null
+++ b/vpp/app/l2t_ip6.c
@@ -0,0 +1,327 @@
+/*
+ * 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.
+ */
+#include <vnet/vnet.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ethernet/ethernet.h>
+
+#if DPDK == 0
+#include <vnet/devices/pci/ixgev.h>
+#include <vnet/devices/pci/ixge.h>
+#include <vnet/devices/pci/ige.h>
+#include <vnet/devices/pci/vice.h>
+#else
+#include <vnet/devices/dpdk/dpdk.h>
+#endif
+
+#include <vppinfra/error.h>
+#include <vppinfra/hash.h>
+#include <app/l2t.h>
+
+l2t_main_t l2t_main;
+
+/* Statistics (not really errors) */
+#define foreach_l2t_ip6_error \
+_(USER_TO_NETWORK, "User (v6) to L2 network pkts") \
+_(SESSION_ID_MISMATCH, "l2tpv3 local session id mismatches") \
+_(COOKIE_MISMATCH, "l2tpv3 local cookie mismatches")
+
+static char * l2t_ip6_error_strings[] = {
+#define _(sym,string) string,
+ foreach_l2t_ip6_error
+#undef _
+};
+
+typedef enum {
+#define _(sym,str) L2T_IP6_ERROR_##sym,
+ foreach_l2t_ip6_error
+#undef _
+ L2T_IP6_N_ERROR,
+} l2t_ip6_error_t;
+
+/*
+ * Packets go to ip6-input when they don't match a mapping,
+ * example: v6 neighbor discovery. They go to ip4-input
+ * when they do match, and are decapsulated.
+ */
+typedef enum {
+ L2T_IP6_NEXT_DROP,
+ L2T_IP6_NEXT_IP6_INPUT,
+ L2T_IP6_N_NEXT,
+ /* Pseudo next, fixed in last_stage */
+ L2T_IP6_NEXT_OUTPUT = L2T_IP6_N_NEXT,
+} l2t_ip6_next_t;
+
+vlib_node_registration_t l2t_ip6_node;
+
+#define NSTAGES 3
+
+static inline void stage0 (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ u32 buffer_index)
+{
+ vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index);
+ vlib_prefetch_buffer_header (b, STORE);
+ /* l2tpv3 header is a long way away, need 2 cache lines */
+ CLIB_PREFETCH (b->data, 2*CLIB_CACHE_LINE_BYTES, STORE);
+}
+
+static inline void stage1 (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ u32 bi)
+{
+ vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+ l2t_main_t *lm = &l2t_main;
+ ip6_header_t * ip6 = vlib_buffer_get_current (b);
+ u32 session_index;
+ uword *p;
+ l2tpv3_header_t * l2t;
+
+ /* Not L2tpv3 (0x73, 0t115)? Use the normal path. */
+ if (PREDICT_FALSE(ip6->protocol != 0x73)) {
+ vnet_buffer(b)->l2t.next_index = L2T_IP6_NEXT_IP6_INPUT;
+ return;
+ }
+
+ /* Make up your minds, people... */
+ switch (lm->lookup_type) {
+ case L2T_LOOKUP_SRC_ADDRESS:
+ p = hash_get_mem (lm->session_by_src_address, &ip6->src_address);
+ break;
+ case L2T_LOOKUP_DST_ADDRESS:
+ p = hash_get_mem (lm->session_by_dst_address, &ip6->dst_address);
+ break;
+ case L2T_LOOKUP_SESSION_ID:
+ l2t = (l2tpv3_header_t*)(ip6+1);
+ p = hash_get (lm->session_by_session_id, l2t->session_id);
+ break;
+ default:
+ ASSERT(0);
+ }
+
+ if (PREDICT_FALSE(p == 0)) {
+ vnet_buffer(b)->l2t.next_index = L2T_IP6_NEXT_IP6_INPUT;
+ return;
+ } else {
+ session_index = p[0];
+ }
+
+ /* Remember mapping index, prefetch the mini counter */
+ vnet_buffer(b)->l2t.next_index = L2T_IP6_NEXT_OUTPUT;
+ vnet_buffer(b)->l2t.session_index = session_index;
+
+ /* Each mapping has 2 x (pkt, byte) counters, hence the shift */
+ CLIB_PREFETCH(lm->counter_main.mini + (p[0]<<1), CLIB_CACHE_LINE_BYTES,
+ STORE);
+}
+
+static inline u32 last_stage (vlib_main_t *vm, vlib_node_runtime_t *node,
+ u32 bi)
+{
+ vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+ l2t_main_t *lm = &l2t_main;
+ ip6_header_t * ip6 = vlib_buffer_get_current (b);
+ vlib_node_t *n = vlib_get_node (vm, l2t_ip6_node.index);
+ u32 node_counter_base_index = n->error_heap_index;
+ vlib_error_main_t * em = &vm->error_main;
+ ethernet_header_t * l2_payload;
+ l2tpv3_header_t * l2t; /* original l2 header */
+ ethernet_vlan_header_t * vh; /* synthesized 802.1q vlan header */
+ u32 counter_index;
+ l2t_session_t * session;
+ u16 payload_ethertype;
+ u8 dst_mac_address[6];
+ u8 src_mac_address[6];
+ u8 *vlan_header_pos;
+
+ /* Other-than-output pkt? We're done... */
+ if (vnet_buffer(b)->l2t.next_index != L2T_IP6_NEXT_OUTPUT)
+ return vnet_buffer(b)->l2t.next_index;
+
+ em->counters[node_counter_base_index + L2T_IP6_ERROR_USER_TO_NETWORK] += 1;
+
+ counter_index =
+ session_index_to_counter_index (vnet_buffer(b)->l2t.session_index,
+ SESSION_COUNTER_USER_TO_NETWORK);
+
+ /* per-mapping byte stats include the ethernet header */
+ vlib_increment_combined_counter (&lm->counter_main, counter_index,
+ 1 /* packet_increment */,
+ vlib_buffer_length_in_chain (vm, b) +
+ sizeof (ethernet_header_t));
+
+ session = pool_elt_at_index (lm->sessions,
+ vnet_buffer(b)->l2t.session_index);
+
+ /* build the 802.1q encaps. Advance past ip6 and l2tpv3 hds */
+ vlib_buffer_advance (b, sizeof (*ip6));
+ l2t = vlib_buffer_get_current (b);
+
+ /* $$$ wonder if we really need these checks... */
+ if (PREDICT_FALSE(l2t->session_id != session->local_session_id)) {
+ b->error = lm->ip6_error_node->
+ errors[L2T_IP6_ERROR_SESSION_ID_MISMATCH];
+ return L2T_IP6_NEXT_DROP;
+ }
+
+ if (PREDICT_FALSE(!((l2t->cookie == session->local_cookie) ||
+ ((session->cookie_flags & L2TP_COOKIE_ROLLOVER_LOCAL) &&
+ (l2t->cookie == session->lcl_ro_cookie))))) {
+ b->error = lm->ip6_error_node->
+ errors[L2T_IP6_ERROR_COOKIE_MISMATCH];
+ return L2T_IP6_NEXT_DROP;
+ }
+
+ vnet_buffer(b)->sw_if_index[VLIB_TX] = session->l2_output_sw_if_index;
+
+ vlib_buffer_advance (b, sizeof (*l2t));
+
+ /* point at currrent l2 hdr */
+ l2_payload = vlib_buffer_get_current (b);
+
+ /* $$$$ rework for speed */
+
+ /* Save type */
+ payload_ethertype = l2_payload->type;
+
+ /* Save src/dst MAC addresses */
+#define _(i) dst_mac_address[i] = l2_payload->dst_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+#define _(i) src_mac_address[i] = l2_payload->src_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+
+ /* Punch in space for 802.1q tag */
+ vlib_buffer_advance (b, -4);
+ l2_payload = vlib_buffer_get_current (b);
+
+ /* Restore MAC addresses */
+#define _(i) l2_payload->dst_address[i] = dst_mac_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+#define _(i) l2_payload->src_address[i] = src_mac_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+ /* Set (outer) ethertype to 802.1q vlan */
+ l2_payload->type = clib_host_to_net_u16 (0x8100);
+ vlan_header_pos = (u8 *)(l2_payload+1);
+#if 0
+ vlan_header_pos = session->l2_sublayer_present ?
+ vlan_header_pos : vlan_header_pos - 4;
+#endif
+ vh = (ethernet_vlan_header_t *)vlan_header_pos;
+ vh->priority_cfi_and_id = session->vlan_id;
+ vh->type = payload_ethertype;
+
+ if (PREDICT_FALSE(b->flags & VLIB_BUFFER_IS_TRACED)) {
+ l2t_trace_t *t = vlib_add_trace (vm, node, b, sizeof (*t));
+ t->is_user_to_network = 1;
+ t->our_address.as_u64[0] =
+ ip6->dst_address.as_u64[0];
+ t->our_address.as_u64[1] =
+ ip6->dst_address.as_u64[1];
+ t->client_address.as_u64[0] =
+ ip6->src_address.as_u64[0];
+ t->client_address.as_u64[1] =
+ ip6->src_address.as_u64[1];
+ t->session_index = vnet_buffer(b)->l2t.session_index;
+ t->vlan_id_host_byte_order = clib_net_to_host_u16 (session->vlan_id);
+ }
+
+ return session->l2_output_next_index;
+}
+
+#include <vnet/pipeline.h>
+
+static uword ip6_l2t_node_fn (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ l2t_main_t *lm = &l2t_main;
+ lm->ip6_error_node = vlib_node_get_runtime (vm, l2t_ip6_node.index);
+
+ return dispatch_pipeline (vm, node, frame);
+}
+
+static VLIB_REGISTER_NODE (sw6_ip6_node) = {
+ .function = ip6_l2t_node_fn,
+ .name = "ip6-l2t-input",
+ .vector_size = sizeof (u32),
+ .format_trace = format_l2t_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_errors = ARRAY_LEN(l2t_ip6_error_strings),
+ .error_strings = l2t_ip6_error_strings,
+
+ .n_next_nodes = L2T_IP6_N_NEXT,
+
+ /* edit / add dispositions here */
+ .next_nodes = {
+ [L2T_IP6_NEXT_IP6_INPUT] = "ip6-input",
+ [L2T_IP6_NEXT_DROP] = "error-drop",
+ },
+};
+
+static clib_error_t *
+l2tp_config (vlib_main_t * vm, unformat_input_t * input)
+{
+ l2t_main_t *lm = &l2t_main;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "lookup-v6-src"))
+ lm->lookup_type = L2T_LOOKUP_SRC_ADDRESS;
+ else if (unformat (input, "lookup-v6-dst"))
+ lm->lookup_type = L2T_LOOKUP_DST_ADDRESS;
+ else if (unformat (input, "lookup-session-id"))
+ lm->lookup_type = L2T_LOOKUP_SESSION_ID;
+ else return clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, input);
+ }
+ return 0;
+}
+
+VLIB_CONFIG_FUNCTION (l2tp_config, "l2tp");
+
+clib_error_t *
+l2t_ip6_init (vlib_main_t *vm)
+{
+ l2t_main_t *lm = &l2t_main;
+
+ lm->vnet_main = vnet_get_main();
+ lm->vlib_main = vm;
+ lm->lookup_type = L2T_LOOKUP_DST_ADDRESS;
+
+ lm->session_by_src_address = hash_create_mem
+ (0, sizeof (ip6_address_t) /* key bytes */,
+ sizeof (u32) /* value bytes */);
+ lm->session_by_dst_address = hash_create_mem
+ (0, sizeof (ip6_address_t) /* key bytes */,
+ sizeof (u32) /* value bytes */);
+ lm->session_by_session_id = hash_create (0, sizeof (uword));
+
+ lm->session_by_vlan_and_rx_sw_if_index = hash_create (0, sizeof (uword));
+
+#if DPDK == 0
+ vice_set_next_node (VICE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+ ixgev_set_next_node (IXGEV_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+ ixge_set_next_node (IXGE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+ ige_set_next_node (IGE_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+#else
+ dpdk_set_next_node (DPDK_RX_NEXT_IP6_INPUT, "ip6-l2t-input");
+#endif
+ return 0;
+}
+
+VLIB_INIT_FUNCTION (l2t_ip6_init);
diff --git a/vpp/app/l2t_l2.c b/vpp/app/l2t_l2.c
new file mode 100644
index 00000000..5c8327d5
--- /dev/null
+++ b/vpp/app/l2t_l2.c
@@ -0,0 +1,252 @@
+/*
+ * 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.
+ */
+#include <vnet/vnet.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ethernet/ethernet.h>
+
+#if DPDK == 0
+#include <vnet/devices/pci/ixgev.h>
+#include <vnet/devices/pci/ixge.h>
+#include <vnet/devices/pci/ige.h>
+#else
+#include <vnet/devices/dpdk/dpdk.h>
+#endif
+
+#include <vppinfra/error.h>
+#include <vppinfra/hash.h>
+#include <app/l2t.h>
+
+l2t_main_t l2t_main;
+
+/* Statistics (not really errors) */
+#define foreach_l2t_l2_error \
+_(NETWORK_TO_USER, "L2 network to user (ip6) pkts")
+
+static char * l2t_l2_error_strings[] = {
+#define _(sym,string) string,
+ foreach_l2t_l2_error
+#undef _
+};
+
+typedef enum {
+#define _(sym,str) L2T_L2_ERROR_##sym,
+ foreach_l2t_l2_error
+#undef _
+ L2T_L2_N_ERROR,
+} l2t_l2_error_t;
+
+/*
+ * Packets go to ethernet-input when they don't match a mapping
+ */
+typedef enum {
+ L2T_L2_NEXT_DROP,
+ L2T_L2_NEXT_ETHERNET_INPUT,
+ L2T_L2_NEXT_IP6_LOOKUP,
+ L2T_L2_N_NEXT,
+} l2t_l2_next_t;
+
+vlib_node_registration_t l2t_l2_node;
+
+#define NSTAGES 3
+
+static inline void stage0 (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ u32 buffer_index)
+{
+ vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index);
+ vlib_prefetch_buffer_header (b, STORE);
+ CLIB_PREFETCH (b->data, 2*CLIB_CACHE_LINE_BYTES, STORE);
+}
+
+static inline void stage1 (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ u32 bi)
+{
+ vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+ l2t_main_t *lm = &l2t_main;
+ ethernet_header_t * eh;
+ ethernet_vlan_header_t *vh;
+ u32 session_index;
+ uword *p;
+ uword vlan_and_sw_if_index_key;
+
+ /* just in case, needed to test with the tun/tap device */
+ vlib_buffer_reset(b);
+
+ eh = vlib_buffer_get_current (b);
+
+ /* Not a VLAN pkt? send to ethernet-input... */
+ if (PREDICT_FALSE(eh->type != clib_host_to_net_u16 (0x8100))) {
+ vnet_buffer(b)->l2t.next_index = L2T_L2_NEXT_ETHERNET_INPUT;
+ return;
+ }
+ vh = (ethernet_vlan_header_t *)(eh+1);
+
+ /* look up session */
+ vlan_and_sw_if_index_key = ((uword)(vh->priority_cfi_and_id)<<32)
+ | vnet_buffer(b)->sw_if_index[VLIB_RX];
+
+ p = hash_get (lm->session_by_vlan_and_rx_sw_if_index,
+ vlan_and_sw_if_index_key);
+
+ if (PREDICT_FALSE(p == 0)) {
+ /* $$$ drop here if not for our MAC? */
+ vnet_buffer(b)->l2t.next_index = L2T_L2_NEXT_ETHERNET_INPUT;
+ return;
+ } else {
+ session_index = p[0];
+ }
+
+ /* Remember mapping index, prefetch the mini counter */
+ vnet_buffer(b)->l2t.next_index = L2T_L2_NEXT_IP6_LOOKUP;
+ vnet_buffer(b)->l2t.session_index = session_index;
+
+ /* Each mapping has 2 x (pkt, byte) counters, hence the shift */
+ CLIB_PREFETCH(lm->counter_main.mini + (p[0]<<1), CLIB_CACHE_LINE_BYTES,
+ STORE);
+}
+
+static inline u32 last_stage (vlib_main_t *vm, vlib_node_runtime_t *node,
+ u32 bi)
+{
+ vlib_buffer_t *b = vlib_get_buffer (vm, bi);
+ l2t_main_t *lm = &l2t_main;
+ ethernet_header_t * eh = vlib_buffer_get_current (b);
+ vlib_node_t *n = vlib_get_node (vm, l2t_l2_node.index);
+ u32 node_counter_base_index = n->error_heap_index;
+ vlib_error_main_t * em = &vm->error_main;
+ l2tpv3_header_t * l2t; /* l2 header */
+ ethernet_vlan_header_t * vh; /* 802.1q vlan header */
+ u32 counter_index;
+ l2t_session_t *s;
+ ip6_header_t *ip6;
+ u16 payload_ethertype;
+ u8 dst_mac_address[6];
+ u8 src_mac_address[6];
+ u16 payload_length;
+ i32 backup;
+
+ /* Other-than-output pkt? We're done... */
+ if (vnet_buffer(b)->l2t.next_index != L2T_L2_NEXT_IP6_LOOKUP)
+ return vnet_buffer(b)->l2t.next_index;
+
+ vh = (ethernet_vlan_header_t *)(eh+1);
+
+ em->counters[node_counter_base_index + L2T_L2_ERROR_NETWORK_TO_USER] += 1;
+
+ counter_index =
+ session_index_to_counter_index (vnet_buffer(b)->l2t.session_index,
+ SESSION_COUNTER_NETWORK_TO_USER);
+
+ /* per-mapping byte stats include the ethernet header */
+ vlib_increment_combined_counter (&lm->counter_main, counter_index,
+ 1 /* packet_increment */,
+ vlib_buffer_length_in_chain (vm, b) +
+ sizeof (ethernet_header_t));
+
+ s = pool_elt_at_index (lm->sessions, vnet_buffer(b)->l2t.session_index);
+
+ /* Save src/dst MAC addresses */
+#define _(i) dst_mac_address[i] = eh->dst_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+#define _(i) src_mac_address[i] = eh->src_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+
+ payload_ethertype = vh->type;
+
+ /* Splice out the 802.1q vlan tag */
+ vlib_buffer_advance (b, 4);
+ eh = vlib_buffer_get_current (b);
+
+ /* restore src/dst MAC addresses */
+#define _(i) eh->dst_address[i] = dst_mac_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+#define _(i) eh->src_address[i] = src_mac_address[i];
+ _(0) _(1) _(2) _(3) _(4) _(5);
+#undef _
+ eh->type = payload_ethertype;
+
+ /* Paint on an l2tpv3 hdr */
+ backup = sizeof(*l2t);
+#if 0
+ /* back up 4 bytes less if no l2 sublayer */
+ backup -= s->l2_sublayer_present ? 0 : 4;
+#endif
+
+ vlib_buffer_advance (b, -backup);
+ l2t = vlib_buffer_get_current (b);
+
+ l2t->session_id = s->remote_session_id;
+ l2t->cookie = s->remote_cookie;
+
+#if 0
+ if (s->l2_sublayer_present)
+ l2t->l2_specific_sublayer = 0;
+#endif
+
+ /* Paint on an ip6 header */
+ vlib_buffer_advance (b, -(sizeof (*ip6)));
+ ip6 = vlib_buffer_get_current (b);
+
+ ip6->ip_version_traffic_class_and_flow_label =
+ clib_host_to_net_u32 (0x6<<28);
+
+ /* calculate ip6 payload length */
+ payload_length = vlib_buffer_length_in_chain (vm, b);
+ payload_length -= sizeof (*ip6);
+
+ ip6->payload_length = clib_host_to_net_u16 (payload_length);
+ ip6->protocol = 0x73; /* l2tpv3 */
+ ip6->hop_limit = 0xff;
+ ip6->src_address.as_u64[0] = s->our_address.as_u64[0];
+ ip6->src_address.as_u64[1] = s->our_address.as_u64[1];
+ ip6->dst_address.as_u64[0] = s->client_address.as_u64[0];
+ ip6->dst_address.as_u64[1] = s->client_address.as_u64[1];
+
+ return L2T_L2_NEXT_IP6_LOOKUP;
+}
+
+#include <vnet/pipeline.h>
+
+static uword l2t_l2_node_fn (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ return dispatch_pipeline (vm, node, frame);
+}
+
+VLIB_REGISTER_NODE (l2t_l2_node) = {
+ .function = l2t_l2_node_fn,
+ .name = "l2t-l2-input",
+ .vector_size = sizeof (u32),
+ .format_trace = format_l2t_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_errors = ARRAY_LEN(l2t_l2_error_strings),
+ .error_strings = l2t_l2_error_strings,
+
+ .n_next_nodes = L2T_L2_N_NEXT,
+
+ /* edit / add dispositions here */
+ .next_nodes = {
+ [L2T_L2_NEXT_IP6_LOOKUP] = "ip6-lookup",
+ [L2T_L2_NEXT_ETHERNET_INPUT] = "ethernet-input",
+ [L2T_L2_NEXT_DROP] = "error-drop",
+ },
+};
+
diff --git a/vpp/app/sticky_hash.c b/vpp/app/sticky_hash.c
new file mode 100644
index 00000000..63b65d5e
--- /dev/null
+++ b/vpp/app/sticky_hash.c
@@ -0,0 +1,554 @@
+/*
+ * 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.
+ */
+#include <vnet/l2/l2_classify.h>
+
+#include <vlib/vlib.h>
+#include <vnet/vnet.h>
+#include <vnet/pg/pg.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ip/ip_packet.h>
+#include <vnet/ip/ip4_packet.h>
+#include <vnet/ip/ip6_packet.h>
+#include <vppinfra/error.h>
+
+typedef struct {
+ u32 fwd_entry_index;
+ u32 rev_entry_index;
+ /* Not strictly needed, for show command */
+ u32 fib_index;
+} sticky_hash_session_t;
+
+typedef struct {
+ u32 cached_next_index;
+
+ /* next index added to l2_classify */
+ u32 fwd_miss_next_index;
+
+ /* session pool */
+ sticky_hash_session_t * sessions;
+
+ /* Forward and reverse data session setup buffers */
+ u8 fdata[3 * sizeof (u32x4)];
+ u8 rdata[3 * sizeof (u32x4)];
+
+ /* convenience variables */
+ vlib_main_t * vlib_main;
+ vnet_main_t * vnet_main;
+ vnet_classify_main_t * vnet_classify_main;
+ l2_classify_main_t * l2_classify_main;
+} sticky_hash_main_t;
+
+typedef struct {
+ /* $$$$ fill in with per-pkt trace data */
+ u32 next_index;
+ u32 sw_if_index;
+} sticky_hash_miss_trace_t;
+
+/* packet trace format function */
+static u8 * format_sticky_hash_miss_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 *);
+ sticky_hash_miss_trace_t * t = va_arg (*args, sticky_hash_miss_trace_t *);
+
+ s = format (s, "STICKY_HASH_MISS: sw_if_index %d",
+ t->sw_if_index);
+ return s;
+}
+
+typedef CLIB_PACKED(struct {
+ ethernet_header_t eh;
+ ip4_header_t ip;
+}) classify_data_or_mask_t;
+
+sticky_hash_main_t sticky_hash_main;
+
+vlib_node_registration_t sticky_hash_miss_node;
+
+#define foreach_sticky_hash_miss_error \
+_(MISSES, "forward flow classify misses")
+
+typedef enum {
+#define _(sym,str) STICKY_HASH_MISS_ERROR_##sym,
+ foreach_sticky_hash_miss_error
+#undef _
+ STICKY_HASH_MISS_N_ERROR,
+} sticky_hash_miss_error_t;
+
+static char * sticky_hash_miss_error_strings[] = {
+#define _(sym,string) string,
+ foreach_sticky_hash_miss_error
+#undef _
+};
+
+/*
+ * To drop a pkt and increment one of the previous counters:
+ *
+ * set b0->error = error_node->errors[STICKY_HASH_MISS_ERROR_EXAMPLE];
+ * set next0 to a disposition index bound to "error-drop".
+ *
+ * To manually increment the specific counter STICKY_HASH_MISS_ERROR_EXAMPLE:
+ *
+ * vlib_node_t *n = vlib_get_node (vm, sticky_hash_miss.index);
+ * u32 node_counter_base_index = n->error_heap_index;
+ * vlib_error_main_t * em = &vm->error_main;
+ * em->counters[node_counter_base_index + STICKY_HASH_MISS_ERROR_EXAMPLE] += 1;
+ *
+ */
+
+typedef enum {
+ STICKY_HASH_MISS_NEXT_IP4_INPUT,
+ STICKY_HASH_MISS_N_NEXT,
+} sticky_hash_miss_next_t;
+
+static uword
+sticky_hash_miss_node_fn (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ u32 n_left_from, * from, * to_next;
+ sticky_hash_miss_next_t next_index;
+ sticky_hash_main_t * mp = &sticky_hash_main;
+ vlib_node_t *n = vlib_get_node (vm, sticky_hash_miss_node.index);
+ u32 node_counter_base_index = n->error_heap_index;
+ vlib_error_main_t * em = &vm->error_main;
+ vnet_classify_main_t * cm = mp->vnet_classify_main;
+ ip4_main_t * im = &ip4_main;
+
+ from = vlib_frame_vector_args (frame);
+ n_left_from = frame->n_vectors;
+ 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;
+ vlib_buffer_t * b0;
+ u32 next0;
+ u32 sw_if_index0;
+ u32 fib_index0, ft_index0, rt_index0;
+ vnet_classify_table_3_t * ft0, * rt0;
+ vnet_classify_entry_3_t * fe0, * re0;
+ classify_data_or_mask_t * h0;
+ u8 was_found0;
+ ip4_fib_t * fib0;
+ sticky_hash_session_t * s;
+ u32 tmp;
+
+ /* speculatively enqueue b0 to the current next frame */
+ 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);
+
+ sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
+ next0 = mp->cached_next_index;
+
+ h0 = vlib_buffer_get_current (b0);
+
+ /* Add forward and reverse entries for this flow */
+ memcpy (mp->fdata, h0, sizeof (mp->fdata));
+ memcpy (mp->rdata, h0, sizeof (mp->rdata));
+
+ h0 = (classify_data_or_mask_t *)(mp->rdata);
+
+ /* swap src + dst addresses to form reverse data */
+ tmp = h0->ip.src_address.as_u32;
+ h0->ip.src_address.as_u32 = h0->ip.dst_address.as_u32;
+ h0->ip.dst_address.as_u32 = tmp;
+
+ /* dig up fwd + rev tables */
+ fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
+ fib0 = vec_elt_at_index (im->fibs, fib_index0);
+
+ ft_index0 = fib0->fwd_classify_table_index;
+ rt_index0 = fib0->rev_classify_table_index;
+
+ ft0 = (vnet_classify_table_3_t *)
+ pool_elt_at_index (cm->tables, ft_index0);
+ rt0 = (vnet_classify_table_3_t *)
+ pool_elt_at_index (cm->tables, rt_index0);
+
+ fe0 = vnet_classify_find_or_add_entry_3 (ft0, mp->fdata, &was_found0);
+ fe0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT;
+ fe0->advance = sizeof (ethernet_header_t);
+
+ re0 = vnet_classify_find_or_add_entry_3 (rt0, mp->rdata, 0);
+ re0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT; /* $$$ FIXME */
+ re0->advance = sizeof (ethernet_header_t);
+
+ /* Note: we could get a whole vector of misses for the same sess */
+ if (was_found0 == 0)
+ {
+ pool_get (mp->sessions, s);
+
+ fe0->opaque_index = s - mp->sessions;
+ re0->opaque_index = s - mp->sessions;
+
+ s->fwd_entry_index = fe0 - ft0->entries;
+ s->rev_entry_index = re0 - rt0->entries;
+ s->fib_index = fib_index0;
+ }
+
+ if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
+ && (b0->flags & VLIB_BUFFER_IS_TRACED))) {
+ sticky_hash_miss_trace_t *t =
+ vlib_add_trace (vm, node, b0, sizeof (*t));
+ t->sw_if_index = sw_if_index0;
+ t->next_index = next0;
+ }
+
+ em->counters[node_counter_base_index + STICKY_HASH_MISS_ERROR_MISSES]
+ += 1;
+
+ vlib_buffer_advance (b0, sizeof (ethernet_header_t));
+
+ /* 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);
+ }
+
+ return frame->n_vectors;
+}
+
+VLIB_REGISTER_NODE (sticky_hash_miss_node) = {
+ .function = sticky_hash_miss_node_fn,
+ .name = "sticky-hash-miss",
+ .vector_size = sizeof (u32),
+ .format_trace = format_sticky_hash_miss_trace,
+ .type = VLIB_NODE_TYPE_INTERNAL,
+
+ .n_errors = ARRAY_LEN(sticky_hash_miss_error_strings),
+ .error_strings = sticky_hash_miss_error_strings,
+
+ .n_next_nodes = STICKY_HASH_MISS_N_NEXT,
+
+ /* edit / add dispositions here */
+ .next_nodes = {
+ [STICKY_HASH_MISS_NEXT_IP4_INPUT] = "ip4-input",
+ },
+};
+
+clib_error_t *sticky_hash_miss_init (vlib_main_t *vm)
+{
+ sticky_hash_main_t * mp = &sticky_hash_main;
+
+ mp->vlib_main = vm;
+ mp->vnet_main = vnet_get_main();
+ mp->vnet_classify_main = &vnet_classify_main;
+ mp->l2_classify_main = &l2_classify_main;
+
+ return 0;
+}
+
+VLIB_INIT_FUNCTION (sticky_hash_miss_init);
+
+static int ip4_sticky_hash_enable_disable
+(sticky_hash_main_t * mp,
+ u32 fwd_sw_if_index, u8 * fwd_mask,
+ u32 rev_sw_if_index, u8 * rev_mask,
+ u32 nbuckets, int enable_disable)
+{
+ ip4_main_t * im = &ip4_main;
+ u32 fib_index;
+ ip4_fib_t * fib;
+ vnet_classify_main_t * cm = mp->vnet_classify_main;
+ l2_classify_main_t * l2cm = mp->l2_classify_main;
+ vnet_classify_table_3_t * ft, * rt;
+
+ fib_index = vec_elt (im->fib_index_by_sw_if_index, fwd_sw_if_index);
+ fib = vec_elt_at_index (im->fibs, fib_index);
+
+ if (fib->fwd_classify_table_index == ~0)
+ {
+ /* Set up forward table */
+ ft = (vnet_classify_table_3_t *)
+ vnet_classify_new_table (cm, fwd_mask, nbuckets,
+ 0 /* skip */, 3 /* match */);
+ fib->fwd_classify_table_index
+ = ft - (vnet_classify_table_3_t *) cm->tables;
+ mp->fwd_miss_next_index =
+ vlib_node_add_next (mp->vlib_main, l2_classify_node.index,
+ sticky_hash_miss_node.index);
+ ft->miss_next_index = mp->fwd_miss_next_index;
+
+ /* Set up reverse table */
+ rt = (vnet_classify_table_3_t *)
+ vnet_classify_new_table (cm, rev_mask, nbuckets,
+ 0 /* skip */, 3 /* match */);
+ fib->rev_classify_table_index
+ = rt - (vnet_classify_table_3_t *) cm->tables;
+ }
+
+ vec_validate
+ (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4],
+ fwd_sw_if_index);
+
+ vec_validate
+ (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6],
+ fwd_sw_if_index);
+
+ vec_validate
+ (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER],
+ fwd_sw_if_index);
+
+ l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4]
+ [fwd_sw_if_index] = fib->fwd_classify_table_index;
+
+ l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6]
+ [fwd_sw_if_index] = ~0;
+
+ l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER]
+ [fwd_sw_if_index] = ~0;
+
+
+ vec_validate
+ (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4],
+ rev_sw_if_index);
+
+ vec_validate
+ (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6],
+ rev_sw_if_index);
+
+ vec_validate
+ (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER],
+ rev_sw_if_index);
+
+
+ l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4]
+ [rev_sw_if_index] = fib->rev_classify_table_index;
+
+ l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6]
+ [rev_sw_if_index] = ~0;
+
+ l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER]
+ [rev_sw_if_index] = ~0;
+
+ vnet_l2_classify_enable_disable (fwd_sw_if_index, enable_disable);
+ vnet_l2_classify_enable_disable (rev_sw_if_index, enable_disable);
+ return 0;
+}
+
+static clib_error_t *
+ip4_sticky_hash_init_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ u32 fwd_sw_if_index = ~0, rev_sw_if_index = ~0;
+ int enable_disable = 1;
+ u32 nbuckets = 2;
+ int rv;
+ sticky_hash_main_t * mp = &sticky_hash_main;
+ classify_data_or_mask_t fwd_mask, rev_mask;
+ u8 * fm = 0, * rm = 0;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "fwd %U", unformat_vnet_sw_interface, mp->vnet_main,
+ &fwd_sw_if_index))
+ ;
+ if (unformat (input, "rev %U", unformat_vnet_sw_interface, mp->vnet_main,
+ &rev_sw_if_index))
+ ;
+ else if (unformat (input, "nbuckets %d", &nbuckets))
+ ;
+ else if (unformat (input, "disable"))
+ enable_disable = 0;
+
+ else break;
+ }
+
+ nbuckets = 1<<max_log2(nbuckets);
+
+ if (fwd_sw_if_index == ~0)
+ return clib_error_return (0, "fwd interface not set");
+
+ if (rev_sw_if_index == ~0)
+ return clib_error_return (0, "rev interface not set");
+
+ if (!is_pow2(nbuckets))
+ return clib_error_return (0, "nbuckets %d not a power of 2", nbuckets);
+
+ ASSERT(sizeof(fwd_mask) <= 3 * sizeof (u32x4));
+
+ /* Mask on src/dst address, depending on direction */
+ memset(&fwd_mask, 0, sizeof (fwd_mask));
+ memset (&fwd_mask.ip.src_address, 0xff, 4);
+
+ memset(&rev_mask, 0, sizeof (rev_mask));
+ memset (&rev_mask.ip.dst_address, 0xff, 4);
+
+ vec_validate (fm, 3 * sizeof(u32x4) - 1);
+ vec_validate (rm, 3 * sizeof(u32x4) - 1);
+
+ memcpy (fm, &fwd_mask, sizeof (fwd_mask));
+ memcpy (rm, &rev_mask, sizeof (rev_mask));
+
+ rv = ip4_sticky_hash_enable_disable (mp, fwd_sw_if_index, fm,
+ rev_sw_if_index, rm,
+ nbuckets, enable_disable);
+
+ vec_free (fm);
+ vec_free (rm);
+ switch (rv)
+ {
+ case 0:
+ return 0;
+
+ default:
+ return clib_error_return (0, "ip4_sticky_hash_enable_disable returned %d",
+ rv);
+ }
+
+ return 0;
+}
+
+VLIB_CLI_COMMAND (sticky_hash_init_command, static) = {
+ .path = "ip sticky classify",
+ .short_help = "ip sticky classify fwd <intfc> rev <intfc> "
+ "[nbuckets <nn>][disable]",
+ .function = ip4_sticky_hash_init_command_fn,
+};
+
+
+u8 * format_sticky_hash_session (u8 * s, va_list * args)
+{
+ sticky_hash_main_t * mp = va_arg(*args, sticky_hash_main_t *);
+ sticky_hash_session_t * session = va_arg(*args, sticky_hash_session_t *);
+ vnet_classify_table_3_t * t;
+ vnet_classify_entry_3_t * e;
+ ip4_main_t * im = &ip4_main;
+ vnet_classify_main_t * cm = mp->vnet_classify_main;
+ ip4_fib_t * fib;
+ classify_data_or_mask_t * match;
+
+ fib = vec_elt_at_index (im->fibs, session->fib_index);
+
+ t = (vnet_classify_table_3_t *)
+ pool_elt_at_index (cm->tables, fib->fwd_classify_table_index);
+ e = pool_elt_at_index (t->entries, session->fwd_entry_index);
+ match = (classify_data_or_mask_t *)(e->key);
+
+ s = format
+ (s,
+ "[%6d] fwd src %U next index %d session %d fib %d\n"
+ " hits %lld last-heard %.6f\n",
+ e - t->entries,
+ format_ip4_address, &match->ip.src_address,
+ e->next_index, e->opaque_index, fib->table_id,
+ e->hits, e->last_heard);
+
+ if (e->opaque_index != session - mp->sessions)
+ s = format (s, "WARNING: forward session index mismatch!\n");
+
+ t = (vnet_classify_table_3_t *)
+ pool_elt_at_index (cm->tables, fib->rev_classify_table_index);
+ e = pool_elt_at_index (t->entries, session->rev_entry_index);
+ match = (classify_data_or_mask_t *)(e->key);
+
+ s = format
+ (s,
+ "[%6d] rev dst %U next index %d session %d\n"
+ " hits %lld last-heard %.6f\n",
+ e - t->entries,
+ format_ip4_address, &match->ip.dst_address,
+ e->next_index, e->opaque_index, e->hits, e->last_heard);
+
+ if (e->opaque_index != session - mp->sessions)
+ s = format (s, "WARNING: reverse session index mismatch!\n");
+ s = format (s, "---------\n");
+
+ return s;
+}
+
+static clib_error_t *
+show_ip4_sticky_hash_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ sticky_hash_main_t * mp = &sticky_hash_main;
+ sticky_hash_session_t * s;
+ int verbose = 0;
+ int dump_classifier_tables = 0;
+ ip4_fib_t * fib;
+ ip4_main_t * im4 = &ip4_main;
+ vnet_classify_main_t * cm = mp->vnet_classify_main;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (input, "verbose"))
+ verbose = 1;
+ else if (unformat (input, "dump-tables")
+ || unformat (input, "dump-classifier-tables"))
+ dump_classifier_tables = 1;
+ else
+ break;
+ }
+
+ if (pool_elts (mp->sessions) == 0)
+ vlib_cli_output (vm, "No ip sticky hash sessions");
+
+
+ vlib_cli_output (vm, "%d active sessions\n",
+ pool_elts (mp->sessions));
+
+ vec_foreach (fib, im4->fibs)
+ {
+ if (fib->fwd_classify_table_index != ~0)
+ vlib_cli_output (vm, "fib %d fwd table: \n%U",
+ fib->table_id,
+ format_classify_table,
+ cm,
+ pool_elt_at_index
+ (cm->tables, fib->fwd_classify_table_index),
+ dump_classifier_tables);
+ if (fib->rev_classify_table_index != ~0)
+ vlib_cli_output (vm, "fib %d rev table: \n%U",
+ fib->table_id,
+ format_classify_table,
+ cm,
+ pool_elt_at_index
+ (cm->tables, fib->rev_classify_table_index),
+ dump_classifier_tables);
+ }
+
+ if (verbose)
+ {
+ pool_foreach (s, mp->sessions,
+ ({
+ vlib_cli_output (vm, "%U", format_sticky_hash_session, mp, s);
+ }));
+ }
+ return 0;
+}
+
+VLIB_CLI_COMMAND (show_sticky_hash_command, static) = {
+ .path = "show sticky classify",
+ .short_help = "Display sticky classifier tables",
+ .function = show_ip4_sticky_hash_command_fn,
+};
+
diff --git a/vpp/app/vpe_cli.c b/vpp/app/vpe_cli.c
new file mode 100644
index 00000000..23aa3cf7
--- /dev/null
+++ b/vpp/app/vpe_cli.c
@@ -0,0 +1,105 @@
+/*
+ * 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.
+ */
+#include <vnet/ip/ip.h>
+#include <vnet/ethernet/ethernet.h>
+
+typedef struct {
+ u8 mac_addr[6];
+} mac_addr_t;
+
+static clib_error_t *
+virtual_ip_cmd_fn_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ unformat_input_t _line_input, * line_input = &_line_input;
+ vnet_main_t * vnm = vnet_get_main();
+ ip4_main_t * im = &ip4_main;
+ ip_lookup_main_t * lm = &im->lookup_main;
+ ip4_address_t ip_addr, next_hop;
+ u8 mac_addr[6];
+ mac_addr_t *mac_addrs = 0;
+ u32 sw_if_index;
+ u32 i, f;
+
+ /* Get a line of input. */
+ if (! unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ if (!unformat(line_input, "%U %U",
+ unformat_ip4_address, &ip_addr,
+ unformat_vnet_sw_interface, vnm, &sw_if_index))
+ goto barf;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
+ if (unformat (line_input, "mac %U",
+ unformat_ethernet_address,
+ &mac_addr))
+ {
+ mac_addr_t *ma;
+ vec_add2 (mac_addrs, ma, 1);
+ memcpy(ma, mac_addr, sizeof (mac_addr));
+ } else {
+ barf:
+ return clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, input);
+ }
+ }
+ if (vec_len (mac_addrs) == 0)
+ goto barf;
+
+ /* Create / delete special interface route /32's */
+ next_hop.as_u32 = 0;
+
+ for (i = 0; i < vec_len(mac_addrs); i++) {
+ ip_adjacency_t adj;
+ u32 adj_index;
+
+ adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE;
+
+ vnet_rewrite_for_sw_interface
+ (vnm,
+ VNET_L3_PACKET_TYPE_IP4,
+ sw_if_index,
+ ip4_rewrite_node.index,
+ &mac_addrs[i], /* destination address */
+ &adj.rewrite_header,
+ sizeof (adj.rewrite_data));
+
+ ip_add_adjacency (lm, &adj, 1 /* one adj */,
+ &adj_index);
+
+ f = (i + 1 < vec_len(mac_addrs)) ? IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP : 0;
+ ip4_add_del_route_next_hop (im,
+ IP4_ROUTE_FLAG_ADD | f,
+ &ip_addr,
+ 32 /* insert /32's */,
+ &next_hop,
+ sw_if_index,
+ 1 /* weight */,
+ adj_index,
+ (u32)~0 /* explicit fib index */);
+ }
+
+ vec_free (mac_addrs);
+
+ return 0;
+}
+
+VLIB_CLI_COMMAND (virtual_ip_cmd_fn_command, static) = {
+ .path = "ip virtual",
+ .short_help = "ip virtual <addr> <interface> [mac <Mi>]+",
+ .function = virtual_ip_cmd_fn_command_fn,
+};