diff options
Diffstat (limited to 'vpp/app')
| -rw-r--r-- | vpp/app/l2t.c | 516 | ||||
| -rw-r--r-- | vpp/app/l2t_ip6.c | 327 | ||||
| -rw-r--r-- | vpp/app/l2t_l2.c | 252 | ||||
| -rw-r--r-- | vpp/app/sticky_hash.c | 554 | ||||
| -rw-r--r-- | vpp/app/vpe_cli.c | 105 |
5 files changed, 1754 insertions, 0 deletions
diff --git a/vpp/app/l2t.c b/vpp/app/l2t.c new file mode 100644 index 00000000000..c230e059802 --- /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 00000000000..ac24886ad42 --- /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 00000000000..5c8327d5262 --- /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 00000000000..63b65d5e87c --- /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 00000000000..23aa3cf7ba2 --- /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, +}; |