From 577c3553dd6939e998c78c5a389750aac3a67f8b Mon Sep 17 00:00:00 2001 From: Florin Coras Date: Thu, 21 Apr 2016 00:45:40 +0200 Subject: Convert lisp-gpe encap to interface tx node With this change, one lisp-gpe interface is created per vrf/overlay tenant and its tx node is used as encapsulator (or tunnel ingress). For all intents and purposes, the tx node inherits all functions previously performed by the lisp-gpe-encap node and it maintains said node's position in lisp-gpe's data-path graph. Chiefly, this opens the possibility to chain interface features, like IPSec, transparently with LISP. Furthermore, it brings basic data plane support for vrfs and LISP instance-ids (or virtual network instances as per RFC7364). Other changes include improvements to lisp-gpe enable and disable sequences and corresponding API/VAT fixes. Change-Id: I085500450660a976b587b1a720e282f6e728d580 Signed-off-by: Florin Coras --- vnet/Makefile.am | 2 +- vnet/vnet/lisp-cp/control.c | 100 ++++++- vnet/vnet/lisp-cp/control.h | 10 +- vnet/vnet/lisp-gpe/decap.c | 65 +++-- vnet/vnet/lisp-gpe/encap.c | 232 --------------- vnet/vnet/lisp-gpe/interface.c | 516 ++++++++++++++++++++++++++++++++++ vnet/vnet/lisp-gpe/lisp_gpe.c | 425 +++++++++++----------------- vnet/vnet/lisp-gpe/lisp_gpe.h | 36 ++- vnet/vnet/lisp-gpe/lisp_gpe_error.def | 1 + 9 files changed, 856 insertions(+), 531 deletions(-) delete mode 100644 vnet/vnet/lisp-gpe/encap.c create mode 100644 vnet/vnet/lisp-gpe/interface.c (limited to 'vnet') diff --git a/vnet/Makefile.am b/vnet/Makefile.am index 2ce40f3ec72..f7c1f30b520 100644 --- a/vnet/Makefile.am +++ b/vnet/Makefile.am @@ -477,7 +477,7 @@ endif libvnet_la_SOURCES += \ vnet/lisp-gpe/lisp_gpe.c \ - vnet/lisp-gpe/encap.c \ + vnet/lisp-gpe/interface.c \ vnet/lisp-gpe/decap.c nobase_include_HEADERS += \ diff --git a/vnet/vnet/lisp-cp/control.c b/vnet/vnet/lisp-cp/control.c index 3448fb3e058..f067cf6d762 100644 --- a/vnet/vnet/lisp-cp/control.c +++ b/vnet/vnet/lisp-cp/control.c @@ -18,7 +18,8 @@ #include #include -/* Adds mapping to map-cache but does NOT program LISP forwarding */ +/* Stores mapping in map-cache. It does NOT program data plane forwarding for + * remote/learned mappings. */ int vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, u32 * map_index_result) @@ -32,11 +33,12 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, if (a->is_add) { /* TODO check if overwriting and take appropriate actions */ - if (mi != GID_LOOKUP_MISS) { + if (mi != GID_LOOKUP_MISS) + { clib_warning("eid %U found in the eid-table", format_ip_address, &a->deid); return VNET_API_ERROR_VALUE_EXIST; - } + } pool_get(lcm->mapping_pool, m); m->eid = a->deid; @@ -65,18 +67,17 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, { /* mark as local */ vec_add1(lcm->local_mappings_indexes, map_index); - - /* XXX do something else? */ } map_index_result[0] = map_index; } else { - if (mi == GID_LOOKUP_MISS) { + if (mi == GID_LOOKUP_MISS) + { clib_warning("eid %U not found in the eid-table", format_ip_address, &a->deid); return VNET_API_ERROR_INVALID_VALUE; - } + } /* clear locator-set to eids binding */ eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids, @@ -115,6 +116,66 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, return 0; } +/* Stores mapping in map-cache and programs data plane for local mappings. */ +int +vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a, + u32 * map_index_result) +{ + uword * table_id, * refc; + u32 rv; + vnet_lisp_gpe_add_del_iface_args_t _ai, *ai = &_ai; + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main (); + + /* store/remove mapping from map-cache */ + rv = vnet_lisp_add_del_mapping (a, map_index_result); + if (rv) + return rv; + + table_id = hash_get(lcm->table_id_by_vni, /* default for now */ 0); + + if (!table_id) + { + clib_warning ("vni %d not associated to a vrf!", 0); + return VNET_API_ERROR_INVALID_VALUE; + } + + refc = hash_get(lcm->dp_if_refcount_by_vni, 0); + + /* enable/disable data-plane interface */ + if (a->is_add) + { + /* create interface or update refcount */ + if (!refc) + { + ai->is_add = 1; + ai->vni = 0; /* default for now, pass vni as parameter */ + ai->table_id = table_id[0]; + vnet_lisp_gpe_add_del_iface (ai, 0); + } + else + { + refc[0]++; + } + } + else + { + /* since this is a remove for an existing eid, the iface should exist */ + ASSERT(refc != 0); + refc[0]--; + + /* remove iface if needed */ + if (refc[0] == 0) + { + ai->is_add = 0; + ai->vni = 0; /* default for now, pass vni as parameter */ + ai->table_id = table_id[0]; + vnet_lisp_gpe_add_del_iface (ai, 0); + } + } + + return rv; +} + static clib_error_t * lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) @@ -171,7 +232,7 @@ lisp_add_del_local_eid_command_fn (vlib_main_t * vm, unformat_input_t * input, a->locator_set_index = locator_set_index; a->local = 1; - vnet_lisp_add_del_mapping (a, &map_index); + vnet_lisp_add_del_local_mapping (a, &map_index); done: vec_free(eids); return error; @@ -650,7 +711,8 @@ lisp_add_del_locator_set_command_fn (vlib_main_t * vm, unformat_input_t * input, VLIB_CLI_COMMAND (lisp_cp_add_del_locator_set_command) = { .path = "lisp locator-set", - .short_help = "lisp locator-set add/del ", + .short_help = "lisp locator-set add/del iface " + " ", .function = lisp_add_del_locator_set_command_fn, }; @@ -1251,7 +1313,7 @@ del_fwd_entry (lisp_cp_main_t * lcm, u32 src_map_index, a->is_add = 0; a->dlocator = fe->dst_loc; a->slocator = fe->src_loc; - a->iid = 0; // XXX should be part of mapping/eid + a->vni = 0; // XXX should be part of mapping/eid gid_address_copy(&a->deid, &fe->deid); vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index); @@ -1268,8 +1330,9 @@ add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index) locator_set_t * dst_ls, * src_ls; u32 i, minp = ~0; locator_t * dl = 0; - uword * feip = 0; + uword * feip = 0, * tidp; vnet_lisp_gpe_add_del_fwd_entry_args_t _a, * a = &_a; + memset (a, 0, sizeof(*a)); /* remove entry if it already exists */ @@ -1334,10 +1397,20 @@ add_fwd_entry (lisp_cp_main_t* lcm, u32 src_map_index, u32 dst_map_index) } gid_address_copy (&a->deid, &dst_map->eid); - a->iid = 0; // XXX should be part of mapping/eid + a->vni = 0; // XXX should be part of mapping/eid + + tidp = hash_get(lcm->table_id_by_vni, a->vni); + if (!tidp) + { + clib_warning("vni %d not associated to a vrf!", a->vni); + return; + } + a->table_id = tidp[0]; + u8 ipver = ip_prefix_version(&gid_address_ippref(&a->deid)); a->decap_next_index = (ipver == IP4) ? LISP_GPE_INPUT_NEXT_IP4_INPUT : LISP_GPE_INPUT_NEXT_IP6_INPUT; + /* XXX tunnels work only with IP4 now */ vnet_lisp_gpe_add_del_fwd_entry (a, &sw_if_index); @@ -1611,6 +1684,9 @@ lisp_cp_init (vlib_main_t *vm) gid_dictionary_init (&lcm->mapping_index_by_gid); gid_dictionary_init (&lcm->mapping_index_by_gid); + /* default vrf mapped to vni 0 */ + hash_set(lcm->table_id_by_vni, 0, 0); + udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp, lisp_cp_input_node.index, 1 /* is_ip4 */); udp_register_dst_port (vm, UDP_DST_PORT_lisp_cp6, diff --git a/vnet/vnet/lisp-cp/control.h b/vnet/vnet/lisp-cp/control.h index 53d90fca8e5..f87a6d5ea25 100644 --- a/vnet/vnet/lisp-cp/control.h +++ b/vnet/vnet/lisp-cp/control.h @@ -91,6 +91,12 @@ typedef struct /* vector of map-resolver addresses */ ip_address_t * map_resolvers; + /* Lookup vrf by vni */ + uword * table_id_by_vni; + + /* Number of src prefixes in a vni that use an interface */ + uword * dp_if_refcount_by_vni; + /* commodity */ ip4_main_t * im4; ip6_main_t * im6; @@ -122,7 +128,6 @@ typedef struct int vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a, u32 * ls_index); - int vnet_lisp_add_del_locator_set_name (vnet_lisp_add_del_locator_set_args_t * a, u32 * ls_index); @@ -146,6 +151,9 @@ typedef struct int vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t *a, u32 * map_index); +int +vnet_lisp_add_del_local_mapping (vnet_lisp_add_del_mapping_args_t * a, + u32 * map_index_result); typedef struct { diff --git a/vnet/vnet/lisp-gpe/decap.c b/vnet/vnet/lisp-gpe/decap.c index 356dbf2e858..5d88462b416 100644 --- a/vnet/vnet/lisp-gpe/decap.c +++ b/vnet/vnet/lisp-gpe/decap.c @@ -52,7 +52,6 @@ next_proto_to_next_index[LISP_GPE_NEXT_PROTOS] ={ LISP_GPE_INPUT_NEXT_DROP, LISP_GPE_INPUT_NEXT_IP4_INPUT, LISP_GPE_INPUT_NEXT_IP6_INPUT, - LISP_GPE_INPUT_NEXT_DROP, LISP_GPE_INPUT_NEXT_DROP }; @@ -85,6 +84,7 @@ lisp_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node, u32 n_left_from, next_index, * from, * to_next; lisp_gpe_tunnel_key_t last_key; u32 pkts_decapsulated = 0; + lisp_gpe_main_t * lgm = &lisp_gpe_main; memset (&last_key, 0xff, sizeof (last_key)); @@ -104,8 +104,8 @@ lisp_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node, u32 bi0, bi1; vlib_buffer_t * b0, * b1; ip4_udp_lisp_gpe_header_t * iul0, * iul1; - u32 error0, error1; - u32 next0, next1; + u32 next0, next1, error0, error1; + uword * si0, * si1; next0 = next1 = LISP_GPE_INPUT_NEXT_IP4_INPUT; @@ -156,14 +156,35 @@ lisp_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node, vnet_update_l2_len (b0); vnet_update_l2_len (b1); - /* TODO hash to map iid to fib */ - vnet_buffer(b0)->sw_if_index[VLIB_TX] = iul0->lisp.iid; - vnet_buffer(b1)->sw_if_index[VLIB_TX] = iul1->lisp.iid; + /* map iid/vni to lisp-gpe sw_if_index which is used by ipx_input to + * decide the rx vrf and the input features to be applied */ + si0 = hash_get(lgm->tunnel_term_sw_if_index_by_vni, iul0->lisp.iid); + si1 = hash_get(lgm->tunnel_term_sw_if_index_by_vni, iul1->lisp.iid); - pkts_decapsulated += 2; + if (si0) + { + vnet_buffer(b0)->sw_if_index[VLIB_RX] = si0[0]; + pkts_decapsulated++; + error0 = 0; + } + else + { + next0 = LISP_GPE_INPUT_NEXT_DROP; + error0 = LISP_GPE_ERROR_NO_SUCH_TUNNEL; + } + + if (si1) + { + vnet_buffer(b1)->sw_if_index[VLIB_RX] = si1[0]; + pkts_decapsulated++; + error0 = 0; + } + else + { + next1 = LISP_GPE_INPUT_NEXT_DROP; + error1 = LISP_GPE_ERROR_NO_SUCH_TUNNEL; + } - /* TODO error handling if security is implemented */ - error0 = error1 = 0; b0->error = error0 ? node->errors[error0] : 0; b1->error = error1 ? node->errors[error1] : 0; @@ -197,6 +218,7 @@ lisp_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node, u32 next0; ip4_udp_lisp_gpe_header_t * iul0; u32 error0; + uword * si0; bi0 = from[0]; to_next[0] = bi0; @@ -228,18 +250,29 @@ lisp_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node, /* Required to make the l2 tag push / pop code work on l2 subifs */ vnet_update_l2_len (b0); - /* TODO hash to map iid to fib */ - vnet_buffer(b0)->sw_if_index[VLIB_TX] = iul0->lisp.iid; - pkts_decapsulated ++; + /* map iid/vni to lisp-gpe sw_if_index which is used by ipx_input to + * decide the rx vrf and the input features to be applied */ + si0 = hash_get(lgm->tunnel_term_sw_if_index_by_vni, iul0->lisp.iid); + + if (si0) + { + vnet_buffer(b0)->sw_if_index[VLIB_RX] = si0[0]; + pkts_decapsulated++; + error0 = 0; + } + else + { + next0 = LISP_GPE_INPUT_NEXT_DROP; + error0 = LISP_GPE_ERROR_NO_SUCH_TUNNEL; + } /* TODO error handling if security is implemented */ - error0 = 0; b0->error = error0 ? node->errors[error0] : 0; - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) + if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) { - lisp_gpe_rx_trace_t *tr - = vlib_add_trace (vm, node, b0, sizeof (*tr)); + lisp_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b0, + sizeof(*tr)); tr->next_index = next0; tr->error = error0; tr->h = iul0->lisp; diff --git a/vnet/vnet/lisp-gpe/encap.c b/vnet/vnet/lisp-gpe/encap.c deleted file mode 100644 index a8158782d8c..00000000000 --- a/vnet/vnet/lisp-gpe/encap.c +++ /dev/null @@ -1,232 +0,0 @@ -/* - * Copyright (c) 2016 Cisco and/or its affiliates. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include - -/* Statistics (not really errors) */ -#define foreach_lisp_gpe_encap_error \ -_(ENCAPSULATED, "good packets encapsulated") - -static char * lisp_gpe_encap_error_strings[] = { -#define _(sym,string) string, - foreach_lisp_gpe_encap_error -#undef _ -}; - -typedef enum { -#define _(sym,str) LISP_GPE_ENCAP_ERROR_##sym, - foreach_lisp_gpe_encap_error -#undef _ - LISP_GPE_ENCAP_N_ERROR, -} lisp_gpe_encap_error_t; - -typedef enum -{ - LISP_GPE_ENCAP_NEXT_DROP, - LISP_GPE_ENCAP_NEXT_IP4_LOOKUP, - LISP_GPE_ENCAP_N_NEXT, -} lisp_gpe_encap_next_t; - -typedef struct -{ - u32 tunnel_index; -} lisp_gpe_encap_trace_t; - -u8 * -format_lisp_gpe_encap_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 *); - lisp_gpe_encap_trace_t * t = va_arg (*args, lisp_gpe_encap_trace_t *); - - s = format (s, "LISP-GPE-ENCAP: tunnel %d", t->tunnel_index); - return s; -} - -static uword -lisp_gpe_encap (vlib_main_t * vm, vlib_node_runtime_t * node, - vlib_frame_t * from_frame) -{ - u32 n_left_from, next_index, * from, * to_next; - lisp_gpe_main_t * lgm = &lisp_gpe_main; - u32 pkts_encapsulated = 0; - - from = vlib_frame_vector_args (from_frame); - n_left_from = 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 >= 4 && n_left_to_next >= 2) - { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 adj_index0, adj_index1, tunnel_index0, tunnel_index1; - ip_adjacency_t * adj0, * adj1; - lisp_gpe_tunnel_t * t0, * t1; - - next0 = next1 = LISP_GPE_ENCAP_NEXT_IP4_LOOKUP; - - /* Prefetch next iteration. */ - { - vlib_buffer_t * p2, *p3; - - p2 = vlib_get_buffer (vm, from[2]); - p3 = vlib_get_buffer (vm, from[3]); - - vlib_prefetch_buffer_header(p2, LOAD); - vlib_prefetch_buffer_header(p3, LOAD); - - CLIB_PREFETCH(p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH(p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD); - } - - bi0 = from[0]; - bi1 = from[1]; - to_next[0] = bi0; - to_next[1] = bi1; - from += 2; - to_next += 2; - n_left_to_next -= 2; - n_left_from -= 2; - - b0 = vlib_get_buffer (vm, bi0); - b1 = vlib_get_buffer (vm, bi1); - - /* Get adjacency and from it the tunnel_index */ - adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX]; - adj_index1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX]; - - adj0 = ip_get_adjacency (lgm->lookup_main, adj_index0); - adj1 = ip_get_adjacency (lgm->lookup_main, adj_index1); - - tunnel_index0 = adj0->rewrite_header.sw_if_index; - tunnel_index1 = adj1->rewrite_header.sw_if_index; - - t0 = pool_elt_at_index (lgm->tunnels, tunnel_index0); - t1 = pool_elt_at_index (lgm->tunnels, tunnel_index1); - - ASSERT(t0 != 0); - ASSERT(t1 != 0); - - ASSERT (sizeof(ip4_udp_lisp_gpe_header_t) == 36); - ip4_udp_encap_two (vm, b0, b1, t0->rewrite, t1->rewrite, 36); - - /* Reset to look up tunnel partner in the configured FIB */ - vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index; - vnet_buffer(b1)->sw_if_index[VLIB_TX] = t1->encap_fib_index; - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - lisp_gpe_encap_trace_t *tr = vlib_add_trace (vm, node, b0, - sizeof(*tr)); - tr->tunnel_index = t0 - lgm->tunnels; - } - if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) - { - lisp_gpe_encap_trace_t *tr = vlib_add_trace (vm, node, b1, - sizeof(*tr)); - tr->tunnel_index = t1 - lgm->tunnels; - } - - pkts_encapsulated += 2; - - vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, - n_left_to_next, bi0, bi1, next0, - next1); - } - - while (n_left_from > 0 && n_left_to_next > 0) - { - vlib_buffer_t * b0; - u32 bi0, adj_index0, tunnel_index0; - u32 next0 = LISP_GPE_ENCAP_NEXT_IP4_LOOKUP; - lisp_gpe_tunnel_t * t0 = 0; - ip_adjacency_t * adj0; - - 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); - - /* Get adjacency and from it the tunnel_index */ - adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX]; - adj0 = ip_get_adjacency (lgm->lookup_main, adj_index0); - - tunnel_index0 = adj0->rewrite_header.sw_if_index; - t0 = pool_elt_at_index (lgm->tunnels, tunnel_index0); - - ASSERT(t0 != 0); - - ASSERT (sizeof(ip4_udp_lisp_gpe_header_t) == 36); - ip4_udp_encap_one (vm, b0, t0->rewrite, 36); - - /* Reset to look up tunnel partner in the configured FIB */ - vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index; - - pkts_encapsulated++; - - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - lisp_gpe_encap_trace_t *tr = vlib_add_trace (vm, node, b0, - sizeof(*tr)); - tr->tunnel_index = t0 - lgm->tunnels; - } - vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, - n_left_to_next, bi0, next0); - } - - vlib_put_next_frame (vm, node, next_index, n_left_to_next); - } - vlib_node_increment_counter (vm, node->node_index, - LISP_GPE_ENCAP_ERROR_ENCAPSULATED, - pkts_encapsulated); - return from_frame->n_vectors; -} - -VLIB_REGISTER_NODE (lisp_gpe_encap_node) = { - .function = lisp_gpe_encap, - .name = "lisp-gpe-encap", - .vector_size = sizeof (u32), - .format_trace = format_lisp_gpe_encap_trace, - .type = VLIB_NODE_TYPE_INTERNAL, - - .n_errors = ARRAY_LEN(lisp_gpe_encap_error_strings), - .error_strings = lisp_gpe_encap_error_strings, - - .n_next_nodes = LISP_GPE_ENCAP_N_NEXT, - - .next_nodes = { - [LISP_GPE_ENCAP_NEXT_DROP] = "error-drop", - [LISP_GPE_ENCAP_NEXT_IP4_LOOKUP] = "ip4-lookup", - }, -}; diff --git a/vnet/vnet/lisp-gpe/interface.c b/vnet/vnet/lisp-gpe/interface.c new file mode 100644 index 00000000000..0f7f6fcaea5 --- /dev/null +++ b/vnet/vnet/lisp-gpe/interface.c @@ -0,0 +1,516 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +#define foreach_lisp_gpe_tx_next \ + _(DROP, "error-drop") \ + _(IP4_LOOKUP, "ip4-lookup") + +typedef enum +{ +#define _(sym,str) LISP_GPE_TX_NEXT_##sym, + foreach_lisp_gpe_tx_next +#undef _ + LISP_GPE_TX_N_NEXT, +} lisp_gpe_tx_next_t; + +typedef struct +{ + u32 tunnel_index; +} lisp_gpe_tx_trace_t; + +u8 * +format_lisp_gpe_tx_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 *); + lisp_gpe_tx_trace_t * t = va_arg (*args, lisp_gpe_tx_trace_t *); + + s = format (s, "LISP-GPE-TX: tunnel %d", t->tunnel_index); + return s; +} + +static uword +lisp_gpe_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node, + vlib_frame_t * from_frame) +{ + u32 n_left_from, next_index, * from, * to_next; + lisp_gpe_main_t * lgm = &lisp_gpe_main; + u32 pkts_encapsulated = 0; + + from = vlib_frame_vector_args (from_frame); + n_left_from = 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 >= 4 && n_left_to_next >= 2) + { + u32 bi0, bi1; + vlib_buffer_t * b0, * b1; + u32 next0, next1; + u32 adj_index0, adj_index1, tunnel_index0, tunnel_index1; + ip_adjacency_t * adj0, * adj1; + lisp_gpe_tunnel_t * t0, * t1; + + next0 = next1 = LISP_GPE_TX_NEXT_IP4_LOOKUP; + + /* Prefetch next iteration. */ + { + vlib_buffer_t * p2, *p3; + + p2 = vlib_get_buffer (vm, from[2]); + p3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header(p2, LOAD); + vlib_prefetch_buffer_header(p3, LOAD); + + CLIB_PREFETCH(p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD); + CLIB_PREFETCH(p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD); + } + + bi0 = from[0]; + bi1 = from[1]; + to_next[0] = bi0; + to_next[1] = bi1; + from += 2; + to_next += 2; + n_left_to_next -= 2; + n_left_from -= 2; + + b0 = vlib_get_buffer (vm, bi0); + b1 = vlib_get_buffer (vm, bi1); + + /* Get adjacency and from it the tunnel_index */ + adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX]; + adj_index1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX]; + + adj0 = ip_get_adjacency (lgm->lookup_main, adj_index0); + adj1 = ip_get_adjacency (lgm->lookup_main, adj_index1); + + tunnel_index0 = adj0->rewrite_header.node_index; + tunnel_index1 = adj1->rewrite_header.node_index; + + t0 = pool_elt_at_index (lgm->tunnels, tunnel_index0); + t1 = pool_elt_at_index (lgm->tunnels, tunnel_index1); + + ASSERT(t0 != 0); + ASSERT(t1 != 0); + + ASSERT (sizeof(ip4_udp_lisp_gpe_header_t) == 36); + ip4_udp_encap_two (vm, b0, b1, t0->rewrite, t1->rewrite, 36); + + /* Reset to look up tunnel partner in the configured FIB */ + vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index; + vnet_buffer(b1)->sw_if_index[VLIB_TX] = t1->encap_fib_index; + + if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) + { + lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0, + sizeof(*tr)); + tr->tunnel_index = t0 - lgm->tunnels; + } + if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) + { + lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b1, + sizeof(*tr)); + tr->tunnel_index = t1 - lgm->tunnels; + } + + pkts_encapsulated += 2; + + vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, + n_left_to_next, bi0, bi1, next0, + next1); + } + + while (n_left_from > 0 && n_left_to_next > 0) + { + vlib_buffer_t * b0; + u32 bi0, adj_index0, tunnel_index0; + u32 next0 = LISP_GPE_TX_NEXT_IP4_LOOKUP; + lisp_gpe_tunnel_t * t0 = 0; + ip_adjacency_t * adj0; + + 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); + + /* Get adjacency and from it the tunnel_index */ + adj_index0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX]; + adj0 = ip_get_adjacency (lgm->lookup_main, adj_index0); + + tunnel_index0 = adj0->rewrite_header.node_index; + t0 = pool_elt_at_index (lgm->tunnels, tunnel_index0); + + ASSERT(t0 != 0); + + ASSERT (sizeof(ip4_udp_lisp_gpe_header_t) == 36); + ip4_udp_encap_one (vm, b0, t0->rewrite, 36); + + /* Reset to look up tunnel partner in the configured FIB */ + vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index; + + pkts_encapsulated++; + + if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) + { + lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0, + sizeof(*tr)); + tr->tunnel_index = t0 - lgm->tunnels; + } + vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, + n_left_to_next, bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + vlib_node_increment_counter (vm, node->node_index, + LISP_GPE_ERROR_ENCAPSULATED, pkts_encapsulated); + return from_frame->n_vectors; +} + +static u8 * +format_lisp_gpe_name (u8 * s, va_list * args) +{ + u32 dev_instance = va_arg (*args, u32); + return format (s, "lisp_gpe%d", dev_instance); +} + +VNET_DEVICE_CLASS (lisp_gpe_device_class,static) = { + .name = "LISP_GPE", + .format_device_name = format_lisp_gpe_name, + .format_tx_trace = format_lisp_gpe_tx_trace, + .tx_function = lisp_gpe_interface_tx, + .no_flatten_output_chains = 1, +}; + +static uword +dummy_set_rewrite (vnet_main_t * vnm, u32 sw_if_index, u32 l3_type, + void * dst_address, void * rewrite, uword max_rewrite_bytes) +{ + return 0; +} + +u8 * +format_lisp_gpe_header_with_length (u8 * s, va_list * args) +{ + lisp_gpe_header_t * h = va_arg (*args, lisp_gpe_header_t *); + u32 max_header_bytes = va_arg (*args, u32); + u32 header_bytes; + + header_bytes = sizeof (h[0]); + if (max_header_bytes != 0 && header_bytes > max_header_bytes) + return format (s, "lisp-gpe header truncated"); + + s = format (s, "flags: "); +#define _(n,v) if (h->flags & v) s = format (s, "%s ", #n); + foreach_lisp_gpe_flag_bit; +#undef _ + + s = format (s, "\n ver_res %d res %d next_protocol %d iid %d(%x)", + h->ver_res, h->res, h->next_protocol, + clib_net_to_host_u32 (h->iid), + clib_net_to_host_u32 (h->iid)); + return s; +} + +VNET_HW_INTERFACE_CLASS (lisp_gpe_hw_class) = { + .name = "LISP_GPE", + .format_header = format_lisp_gpe_header_with_length, + .set_rewrite = dummy_set_rewrite, +}; + +int +add_del_ip_prefix_route (ip_prefix_t * dst_prefix, u32 table_id, + ip_adjacency_t * add_adj, u8 is_add, u32 * adj_index) +{ + uword * p; + + if (ip_prefix_version(dst_prefix) == IP4) + { + ip4_main_t * im4 = &ip4_main; + ip4_add_del_route_args_t a; + ip4_address_t addr = ip_prefix_v4(dst_prefix); + + memset(&a, 0, sizeof(a)); + a.flags = IP4_ROUTE_FLAG_TABLE_ID; + a.table_index_or_table_id = table_id; + a.adj_index = ~0; + a.dst_address_length = ip_prefix_len(dst_prefix); + a.dst_address = addr; + a.flags |= is_add ? IP4_ROUTE_FLAG_ADD : IP4_ROUTE_FLAG_DEL; + a.add_adj = add_adj; + a.n_add_adj = 1; + ip4_add_del_route (im4, &a); + + if (is_add) + { + p = ip4_get_route (im4, table_id, 0, addr.as_u8, + ip_prefix_len(dst_prefix)); + if (p == 0) + { + clib_warning("Failed to insert route for eid %U!", + format_ip4_address_and_length, addr.as_u8, + ip_prefix_len(dst_prefix)); + return -1; + } + adj_index[0] = p[0]; + } + } + else + { + ip6_main_t * im6 = &ip6_main; + ip6_add_del_route_args_t a; + ip6_address_t addr = ip_prefix_v6(dst_prefix); + + memset(&a, 0, sizeof(a)); + a.flags = IP6_ROUTE_FLAG_TABLE_ID; + a.table_index_or_table_id = table_id; + a.adj_index = ~0; + a.dst_address_length = ip_prefix_len(dst_prefix); + a.dst_address = addr; + a.flags |= is_add ? IP6_ROUTE_FLAG_ADD : IP6_ROUTE_FLAG_DEL; + a.add_adj = add_adj; + a.n_add_adj = 1; + + ip6_add_del_route (im6, &a); + + if (is_add) + { + adj_index[0] = ip6_get_route (im6, table_id, 0, &addr, + ip_prefix_len(dst_prefix)); + if (adj_index[0] == 0) + { + clib_warning("Failed to insert route for eid %U!", + format_ip6_address_and_length, addr.as_u8, + ip_prefix_len(dst_prefix)); + return -1; + } + } + } + return 0; +} + +static void +add_del_lisp_gpe_default_route (u32 table_id, u8 is_v4, u8 is_add) +{ + lisp_gpe_main_t * lgm = &lisp_gpe_main; + ip_adjacency_t adj; + ip_prefix_t prefix; + u32 adj_index = 0; + + /* setup adjacency */ + memset (&adj, 0, sizeof(adj)); + + adj.n_adj = 1; + adj.explicit_fib_index = ~0; + adj.lookup_next_index = lgm->ip4_lookup_next_lgpe_ip4_lookup; + /* default route has tunnel_index ~0 */ + adj.rewrite_header.sw_if_index = ~0; + + /* set prefix to 0/0 */ + memset(&prefix, 0, sizeof(prefix)); + ip_prefix_version(&prefix) = is_v4 ? IP4 : IP6; + + /* add/delete route for prefix */ + add_del_ip_prefix_route (&prefix, table_id, &adj, is_add, &adj_index); +} + +static void +lisp_gpe_iface_set_table (u32 sw_if_index, u32 table_id, u8 is_ip4) +{ + if (is_ip4) + { + ip4_main_t * im4 = &ip4_main; + ip4_fib_t * fib; + fib = find_ip4_fib_by_table_index_or_id (im4, table_id, + IP4_ROUTE_FLAG_TABLE_ID); + + /* fib's created if it doesn't exist */ + ASSERT(fib != 0); + + vec_validate(im4->fib_index_by_sw_if_index, sw_if_index); + im4->fib_index_by_sw_if_index[sw_if_index] = fib->index; + } + else + { + ip6_main_t * im6 = &ip6_main; + ip6_fib_t * fib; + fib = find_ip6_fib_by_table_index_or_id (im6, table_id, + IP6_ROUTE_FLAG_TABLE_ID); + + /* fib's created if it doesn't exist */ + ASSERT(fib != 0); + + vec_validate(im6->fib_index_by_sw_if_index, sw_if_index); + im6->fib_index_by_sw_if_index[sw_if_index] = fib->index; + } +} + +void +vnet_lisp_gpe_add_del_iface (vnet_lisp_gpe_add_del_iface_args_t * a, + u32 * hw_if_indexp) +{ + lisp_gpe_main_t * lgm = &lisp_gpe_main; + vnet_main_t * vnm = lgm->vnet_main; + vnet_hw_interface_t * hi; + u32 hw_if_index = ~0, lookup_next_index, flen; + uword * hip, * vni; + + hip = hash_get(lgm->lisp_gpe_hw_if_index_by_table_id, a->table_id); + + if (a->is_add) + { + if (hip) + { + clib_warning ("Interface for vrf %d already exists", a->table_id); + return; + } + + /* create hw lisp_gpeX iface if needed, otherwise reuse existing */ + flen = vec_len(lgm->free_lisp_gpe_tunnel_hw_if_indices); + if (flen > 0) + { + hw_if_index = lgm->free_lisp_gpe_tunnel_hw_if_indices[flen - 1]; + _vec_len(lgm->free_lisp_gpe_tunnel_hw_if_indices) -= 1; + } + else + { + hw_if_index = vnet_register_interface (vnm, + lisp_gpe_device_class.index, + a->table_id, + lisp_gpe_hw_class.index, 0); + } + + hi = vnet_get_hw_interface (vnm, hw_if_index); + hash_set(lgm->lisp_gpe_hw_if_index_by_table_id, a->table_id, hw_if_index); + + /* set tunnel termination: post decap, packets are tagged as having been + * originated by lisp-gpe interface */ + hash_set(lgm->tunnel_term_sw_if_index_by_vni, a->vni, hi->sw_if_index); + hash_set(lgm->vni_by_tunnel_term_sw_if_index, hi->sw_if_index, a->vni); + + /* set ingress arc from lgpe_ip4_lookup */ + lookup_next_index = vlib_node_add_next (lgm->vlib_main, + lgpe_ip4_lookup_node.index, + hi->output_node_index); + hash_set(lgm->lgpe_ip4_lookup_next_index_by_table_id, a->table_id, + lookup_next_index); + + /* insert default routes that point to lgpe-ipx-lookup */ + add_del_lisp_gpe_default_route (a->table_id, /* is_v4 */1, 1); + add_del_lisp_gpe_default_route (a->table_id, /* is_v4 */0, 1); + + /* set egress arcs */ +#define _(sym,str) vlib_node_add_named_next_with_slot (vnm->vlib_main, \ + hi->tx_node_index, str, LISP_GPE_TX_NEXT_##sym); + foreach_lisp_gpe_tx_next +#undef _ + + /* set interface in appropriate v4 and v6 FIBs */ + lisp_gpe_iface_set_table (hi->sw_if_index, a->table_id, 1); + lisp_gpe_iface_set_table (hi->sw_if_index, a->table_id, 0); + + /* enable interface */ + vnet_sw_interface_set_flags (vnm, hi->sw_if_index, + VNET_SW_INTERFACE_FLAG_ADMIN_UP); + vnet_hw_interface_set_flags (vnm, hi->hw_if_index, + VNET_HW_INTERFACE_FLAG_LINK_UP); + } + else + { + if (hip == 0) + { + clib_warning("The interface for vrf %d doesn't exist", a->table_id); + return; + } + hi = vnet_get_hw_interface (vnm, hip[0]); + + /* disable interface */ + vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 0/* down */); + vnet_hw_interface_set_flags (vnm, hi->hw_if_index, 0/* down */); + hash_unset(lgm->lisp_gpe_hw_if_index_by_table_id, a->table_id); + vec_add1(lgm->free_lisp_gpe_tunnel_hw_if_indices, hi->hw_if_index); + + /* clean tunnel termination and vni to sw_if_index binding */ + vni = hash_get(lgm->vni_by_tunnel_term_sw_if_index, hi->sw_if_index); + hash_unset(lgm->tunnel_term_sw_if_index_by_vni, vni[0]); + hash_unset(lgm->vni_by_tunnel_term_sw_if_index, hi->sw_if_index); + + /* unset default routes */ + add_del_lisp_gpe_default_route (a->table_id, /* is_v4 */1, 0); + add_del_lisp_gpe_default_route (a->table_id, /* is_v4 */0, 0); + } +} + +static clib_error_t * +lisp_gpe_add_del_iface_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, * line_input = &_line_input; + u8 is_add = 1; + u32 table_id; + + vnet_lisp_gpe_add_del_iface_args_t _a, * a = &_a; + + /* 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, "add")) + is_add = 1; + else if (unformat (line_input, "del")) + is_add = 0; + else if (unformat (line_input, "vrf %d", &table_id)) + ; + else + { + return clib_error_return (0, "parse error: '%U'", + format_unformat_error, line_input); + } + } + + a->is_add = is_add; + a->table_id = table_id; + vnet_lisp_gpe_add_del_iface (a, 0); + return 0; +} + +VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command, static) = { + .path = "lisp gpe iface", + .short_help = "lisp gpe iface add/del table-index vrf ", + .function = lisp_gpe_add_del_iface_command_fn, +}; diff --git a/vnet/vnet/lisp-gpe/lisp_gpe.c b/vnet/vnet/lisp-gpe/lisp_gpe.c index b8072494c2c..fd1e1a4608e 100644 --- a/vnet/vnet/lisp-gpe/lisp_gpe.c +++ b/vnet/vnet/lisp-gpe/lisp_gpe.c @@ -177,7 +177,7 @@ ip4_sd_fib_clear_src_fib (lisp_gpe_main_t * lgm, ip4_fib_t * fib) int ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, - ip_prefix_t * src_prefix, u32 table_index, + ip_prefix_t * src_prefix, u32 table_id, ip_adjacency_t * add_adj, u8 is_add) { uword * p; @@ -196,7 +196,7 @@ ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, memset(&src, 0, sizeof(src)); /* lookup dst adj */ - p = ip4_get_route (lgm->im4, table_index, 0, dst.as_u8, dst_address_length); + p = ip4_get_route (lgm->im4, table_id, 0, dst.as_u8, dst_address_length); if (is_add) { @@ -209,7 +209,7 @@ ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, memset(&a, 0, sizeof(a)); a.flags = IP4_ROUTE_FLAG_TABLE_ID; - a.table_index_or_table_id = table_index; /* vrf */ + a.table_index_or_table_id = table_id; /* vrf */ a.adj_index = ~0; a.dst_address_length = dst_address_length; a.dst_address = dst; @@ -220,7 +220,7 @@ ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, ip4_add_del_route (lgm->im4, &a); /* lookup dst adj to obtain the adj index */ - p = ip4_get_route (lgm->im4, table_index, 0, dst.as_u8, + p = ip4_get_route (lgm->im4, table_id, 0, dst.as_u8, dst_address_length); if (p == 0) { @@ -283,7 +283,7 @@ ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, /* .. and remove dst route */ memset(&a, 0, sizeof(a)); a.flags = IP4_ROUTE_FLAG_TABLE_ID; - a.table_index_or_table_id = table_index; /* vrf */ + a.table_index_or_table_id = table_id; /* vrf */ a.adj_index = ~0; a.dst_address_length = dst_address_length; a.dst_address = dst; @@ -297,7 +297,7 @@ ip4_sd_fib_add_del_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, static void * ip4_sd_fib_get_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, - ip_prefix_t * src_prefix, u32 table_index) + ip_prefix_t * src_prefix, u32 table_id) { uword * p; ip4_address_t dst = ip_prefix_v4(dst_prefix), src; @@ -313,7 +313,7 @@ ip4_sd_fib_get_route (lisp_gpe_main_t * lgm, ip_prefix_t * dst_prefix, memset(&src, 0, sizeof(src)); /* lookup dst adj */ - p = ip4_get_route (lgm->im4, table_index, 0, dst.as_u8, dst_address_length); + p = ip4_get_route (lgm->im4, table_id, 0, dst.as_u8, dst_address_length); if (p == 0) return p; @@ -326,7 +326,6 @@ typedef enum { LGPE_IP4_LOOKUP_NEXT_DROP, LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP, - LGPE_IP4_LOOKUP_NEXT_LGPE_ENCAP, LGPE_IP4_LOOKUP_N_NEXT, } lgpe_ip4_lookup_next_t; @@ -468,6 +467,12 @@ lgpe_ip4_lookup (vlib_main_t * vm, vlib_node_runtime_t * node, next0 = src_adj0->lookup_next_index; next1 = src_adj1->lookup_next_index; + + /* prepare buffer for lisp-gpe output node */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = + src_adj0->rewrite_header.sw_if_index; + vnet_buffer (b1)->sw_if_index[VLIB_TX] = + src_adj1->rewrite_header.sw_if_index; } else { @@ -479,6 +484,7 @@ lgpe_ip4_lookup (vlib_main_t * vm, vlib_node_runtime_t * node, src_adj0 = ip_get_adjacency (lgm->lookup_main, src_adj_index0); next0 = src_adj0->lookup_next_index; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = src_adj_index0; } if (src_fib_index1 != (u32) ~0) { @@ -488,6 +494,7 @@ lgpe_ip4_lookup (vlib_main_t * vm, vlib_node_runtime_t * node, src_adj1 = ip_get_adjacency (lgm->lookup_main, src_adj_index1); next1 = src_adj1->lookup_next_index; + vnet_buffer (b1)->sw_if_index[VLIB_TX] = src_adj_index1; } } @@ -530,6 +537,9 @@ lgpe_ip4_lookup (vlib_main_t * vm, vlib_node_runtime_t * node, src_adj0 = ip_get_adjacency (lgm->lookup_main, src_adj_index0); next0 = src_adj0->lookup_next_index; + /* prepare packet for lisp-gpe output node */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = + src_adj0->rewrite_header.sw_if_index; done: vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -551,7 +561,6 @@ VLIB_REGISTER_NODE (lgpe_ip4_lookup_node) = { .next_nodes = { [LGPE_IP4_LOOKUP_NEXT_DROP] = "error-drop", [LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP] = "lisp-cp-lookup", - [LGPE_IP4_LOOKUP_NEXT_LGPE_ENCAP] = "lisp-gpe-encap", }, }; @@ -592,7 +601,7 @@ lisp_gpe_rewrite (lisp_gpe_tunnel_t * t) lisp0->ver_res = t->ver_res; lisp0->res = t->res; lisp0->next_protocol = t->next_protocol; - lisp0->iid = clib_host_to_net_u32 (t->iid); + lisp0->iid = clib_host_to_net_u32 (t->vni); t->rewrite = rw; return 0; @@ -615,7 +624,7 @@ _(flags) \ _(next_protocol) \ _(ver_res) \ _(res) \ -_(iid) +_(vni) static u32 add_del_tunnel (vnet_lisp_gpe_add_del_fwd_entry_args_t *a, u32 * tun_index_res) @@ -629,7 +638,7 @@ add_del_tunnel (vnet_lisp_gpe_add_del_fwd_entry_args_t *a, u32 * tun_index_res) memset(&key, 0, sizeof(key)); gid_address_copy(&key.eid, &a->deid); key.dst_loc = ip_addr_v4(&a->dlocator).as_u32; - key.iid = clib_host_to_net_u32 (a->iid); + key.iid = clib_host_to_net_u32 (a->vni); p = mhash_get (&lgm->lisp_gpe_tunnel_by_key, &key); @@ -688,6 +697,41 @@ add_del_tunnel (vnet_lisp_gpe_add_del_fwd_entry_args_t *a, u32 * tun_index_res) return 0; } +static int +add_del_negative_fwd_entry (lisp_gpe_main_t * lgm, + vnet_lisp_gpe_add_del_fwd_entry_args_t * a) +{ + ip_adjacency_t adj; + /* setup adjacency for eid */ + memset (&adj, 0, sizeof(adj)); + adj.n_adj = 1; + adj.explicit_fib_index = ~0; + + ip_prefix_t * dpref = &gid_address_ippref(&a->deid); + ip_prefix_t * spref = &gid_address_ippref(&a->seid); + + switch (a->action) + { + case NO_ACTION: + /* TODO update timers? */ + case FORWARD_NATIVE: + /* TODO check if route/next-hop for eid exists in fib and add + * more specific for the eid with the next-hop found */ + case SEND_MAP_REQUEST: + /* TODO insert tunnel that always sends map-request */ + case DROP: + /* for drop fwd entries, just add route, no need to add encap tunnel */ + adj.lookup_next_index = LGPE_IP4_LOOKUP_NEXT_DROP; + + /* add/delete route for prefix */ + return ip4_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj, + a->is_add); + break; + default: + return -1; + } +} + int vnet_lisp_gpe_add_del_fwd_entry (vnet_lisp_gpe_add_del_fwd_entry_args_t * a, u32 * hw_if_indexp) @@ -695,66 +739,59 @@ vnet_lisp_gpe_add_del_fwd_entry (vnet_lisp_gpe_add_del_fwd_entry_args_t * a, lisp_gpe_main_t * lgm = &lisp_gpe_main; ip_adjacency_t adj, * adjp; u32 * adj_index, rv, tun_index = ~0; - ip_prefix_t * dpref = &gid_address_ippref(&a->deid); - ip_prefix_t * spref = &gid_address_ippref(&a->seid); + ip_prefix_t * dpref, * spref; + uword * lookup_next_index, * lgpe_sw_if_index; + + /* treat negative fwd entries separately */ + if (a->is_negative) + return add_del_negative_fwd_entry (lgm, a); + + /* add/del tunnel to tunnels pool and prepares rewrite */ + rv = add_del_tunnel (a, &tun_index); + if (rv) + return rv; + + dpref = &gid_address_ippref(&a->deid); + spref = &gid_address_ippref(&a->seid); /* setup adjacency for eid */ memset (&adj, 0, sizeof(adj)); adj.n_adj = 1; adj.explicit_fib_index = ~0; - /* treat negative fwd entries separately */ - if (a->is_negative) + if (a->is_add) { - switch (a->action) - { - case NO_ACTION: - /* TODO update timers? */ - case FORWARD_NATIVE: - /* TODO check if route/next-hop for eid exists in fib and add - * more specific for the eid with the next-hop found */ - case SEND_MAP_REQUEST: - /* TODO insert tunnel that always sends map-request */ - case DROP: - /* for drop fwd entries, just add route, no need to add encap tunnel */ - adj.lookup_next_index = LGPE_IP4_LOOKUP_NEXT_DROP; - - /* add/delete route for prefix */ - rv = ip4_sd_fib_add_del_route (lgm, dpref, spref, a->iid, &adj, - a->is_add); - return rv; - break; - default: - return -1; - } + /* send packets that hit this adj to lisp-gpe interface output node in + * requested vrf. */ + lookup_next_index = hash_get(lgm->lgpe_ip4_lookup_next_index_by_table_id, + a->table_id); + lgpe_sw_if_index = hash_get(lgm->lisp_gpe_hw_if_index_by_table_id, + a->table_id); + + /* the assumption is that the interface must've been created before + * programming the dp */ + ASSERT(lookup_next_index != 0); + ASSERT(lgpe_sw_if_index != 0); + + adj.lookup_next_index = lookup_next_index[0]; + adj.rewrite_header.node_index = tun_index; + adj.rewrite_header.sw_if_index = lgpe_sw_if_index[0]; } - /* send packets that hit this adj to lisp-gpe encap */ - adj.lookup_next_index = LGPE_IP4_LOOKUP_NEXT_LGPE_ENCAP; + /* add/delete route for prefix */ + rv = ip4_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj, + a->is_add); - /* add/delete route for prefix - * TODO use hash to decide fib instead of using iid in clear */ - rv = ip4_sd_fib_add_del_route (lgm, dpref, spref, a->iid, &adj, a->is_add); - - if (rv) - return rv; - - /* add/del tunnel to tunnels pool */ - rv = add_del_tunnel (a, &tun_index); - - /* reuse sw_if_index for storing the tunnel index */ - if (a->is_add) + /* check that everything worked */ + if (CLIB_DEBUG && a->is_add) { - adj_index = ip4_sd_fib_get_route(lgm, dpref, spref, a->iid); - if (!adj_index) - { - clib_warning("Failed to insert fwd entry! For %U", - format_ip4_address_and_length, ip_prefix_v4(dpref), - ip_prefix_len(dpref)); - return -1; - } + adj_index = ip4_sd_fib_get_route (lgm, dpref, spref, a->table_id); + ASSERT(adj_index != 0); + adjp = ip_get_adjacency (lgm->lookup_main, adj_index[0]); - adjp->rewrite_header.sw_if_index = tun_index; + + ASSERT(adjp != 0); + ASSERT(adjp->rewrite_header.node_index == tun_index); } return rv; @@ -810,7 +847,8 @@ lisp_gpe_add_del_fwd_entry_command_fn (vlib_main_t * vm, if (vec_len (eids) != vec_len (slocators)) { - error = clib_error_return (0, "number of eids not equal to that of locators."); + error = clib_error_return (0, "number of eids not equal to that of " + "locators."); goto done; } @@ -837,105 +875,11 @@ lisp_gpe_add_del_fwd_entry_command_fn (vlib_main_t * vm, VLIB_CLI_COMMAND (add_del_lisp_gpe_mapping_tunnel_command, static) = { .path = "lisp gpe maptunnel", - .short_help = "lisp gpe maptunnel eid sloc dloc [del]", + .short_help = "lisp gpe maptunnel eid sloc " + "dloc [del]", .function = lisp_gpe_add_del_fwd_entry_command_fn, }; -int -add_del_ip_prefix_route (ip_prefix_t * dst_prefix, u32 table_id, - ip_adjacency_t * add_adj, u8 is_add, u32 * adj_index) -{ - uword * p; - - if (ip_prefix_version(dst_prefix) == IP4) - { - ip4_main_t * im4 = &ip4_main; - ip4_add_del_route_args_t a; - ip4_address_t addr = ip_prefix_v4(dst_prefix); - - memset(&a, 0, sizeof(a)); - a.flags = IP4_ROUTE_FLAG_TABLE_ID; - a.table_index_or_table_id = table_id; - a.adj_index = ~0; - a.dst_address_length = ip_prefix_len(dst_prefix); - a.dst_address = addr; - a.flags |= is_add ? IP4_ROUTE_FLAG_ADD : IP4_ROUTE_FLAG_DEL; - a.add_adj = add_adj; - a.n_add_adj = 1; - ip4_add_del_route (im4, &a); - - if (is_add) - { - p = ip4_get_route (im4, table_id, 0, addr.as_u8, - ip_prefix_len(dst_prefix)); - if (p == 0) - { - clib_warning("Failed to insert route for eid %U!", - format_ip4_address_and_length, addr.as_u8, - ip_prefix_len(dst_prefix)); - return -1; - } - adj_index[0] = p[0]; - } - } - else - { - ip6_main_t * im6 = &ip6_main; - ip6_add_del_route_args_t a; - ip6_address_t addr = ip_prefix_v6(dst_prefix); - - memset(&a, 0, sizeof(a)); - a.flags = IP6_ROUTE_FLAG_TABLE_ID; - a.table_index_or_table_id = table_id; - a.adj_index = ~0; - a.dst_address_length = ip_prefix_len(dst_prefix); - a.dst_address = addr; - a.flags |= is_add ? IP6_ROUTE_FLAG_ADD : IP6_ROUTE_FLAG_DEL; - a.add_adj = add_adj; - a.n_add_adj = 1; - - ip6_add_del_route (im6, &a); - - if (is_add) - { - adj_index[0] = ip6_get_route (im6, table_id, 0, &addr, - ip_prefix_len(dst_prefix)); - if (adj_index[0] == 0) - { - clib_warning("Failed to insert route for eid %U!", - format_ip6_address_and_length, addr.as_u8, - ip_prefix_len(dst_prefix)); - return -1; - } - } - } - return 0; -} - -static void -add_del_lisp_gpe_default_route (u8 is_v4, u8 is_add) -{ - lisp_gpe_main_t * lgm = &lisp_gpe_main; - ip_adjacency_t adj; - ip_prefix_t prefix; - u32 adj_index = 0; - - /* setup adjacency */ - memset (&adj, 0, sizeof(adj)); - adj.n_adj = 1; - adj.explicit_fib_index = ~0; - adj.lookup_next_index = lgm->ip4_lookup_next_lgpe_ip4_lookup; - /* default route has tunnel_index ~0 */ - adj.rewrite_header.sw_if_index = ~0; - - /* set prefix to 0/0 */ - memset(&prefix, 0, sizeof(prefix)); - ip_prefix_version(&prefix) = is_v4 ? IP4 : IP6; - - /* add/delete route for prefix XXX default table only */ - add_del_ip_prefix_route (&prefix, 0, &adj, is_add, &adj_index); -} - static u8 * format_decap_next (u8 * s, va_list * args) { @@ -949,8 +893,6 @@ format_decap_next (u8 * s, va_list * args) return format (s, "ip4"); case LISP_GPE_INPUT_NEXT_IP6_INPUT: return format (s, "ip6"); - case LISP_GPE_INPUT_NEXT_LISP_GPE_ENCAP: - return format (s, "nsh-lisp-gpe"); default: return format (s, "unknown %d", next_index); } @@ -981,7 +923,7 @@ format_lisp_gpe_tunnel (u8 * s, va_list * args) s = format (s, "next_protocol %d ver_res %x res %x\n", t->next_protocol, t->ver_res, t->res); - s = format (s, "iid %d (0x%x)\n", t->iid, t->iid); + s = format (s, "iid %d (0x%x)\n", t->vni, t->vni); return s; } @@ -1009,106 +951,74 @@ VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) = { .function = show_lisp_gpe_tunnel_command_fn, }; -static u8 * -format_lisp_gpe_name (u8 * s, va_list * args) -{ - u32 dev_instance = va_arg (*args, u32); - return format (s, "lisp_gpe_tunnel%d", dev_instance); -} - -static uword -dummy_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node, - vlib_frame_t * frame) -{ - clib_warning("you shouldn't be here, leaking buffers..."); - return frame->n_vectors; -} - -VNET_DEVICE_CLASS (lisp_gpe_device_class,static) = { - .name = "LISP_GPE", - .format_device_name = format_lisp_gpe_name, - .format_tx_trace = format_lisp_gpe_encap_trace, - .tx_function = dummy_interface_tx, -}; - -static uword -dummy_set_rewrite (vnet_main_t * vnm, u32 sw_if_index, u32 l3_type, - void * dst_address, void * rewrite, uword max_rewrite_bytes) -{ - return 0; -} - -u8 * -format_lisp_gpe_header_with_length (u8 * s, va_list * args) -{ - lisp_gpe_header_t * h = va_arg (*args, lisp_gpe_header_t *); - u32 max_header_bytes = va_arg (*args, u32); - u32 header_bytes; - - header_bytes = sizeof (h[0]); - if (max_header_bytes != 0 && header_bytes > max_header_bytes) - return format (s, "gre-nsh header truncated"); - - s = format (s, "flags: "); -#define _(n,v) if (h->flags & v) s = format (s, "%s ", #n); - foreach_lisp_gpe_flag_bit; -#undef _ - - s = format (s, "\n ver_res %d res %d next_protocol %d iid %d(%x)", - h->ver_res, h->res, h->next_protocol, - clib_net_to_host_u32 (h->iid), - clib_net_to_host_u32 (h->iid)); - return s; -} - -VNET_HW_INTERFACE_CLASS (lisp_gpe_hw_class) = { - .name = "LISP_GPE", - .format_header = format_lisp_gpe_header_with_length, - .set_rewrite = dummy_set_rewrite, -}; - -void -vnet_lisp_gpe_add_del_iface (vnet_lisp_gpe_add_del_iface_args_t * a, - u32 * hw_if_indexp) +clib_error_t * +vnet_lisp_gpe_enable_disable (vnet_lisp_gpe_enable_disable_args_t * a) { lisp_gpe_main_t * lgm = &lisp_gpe_main; vnet_main_t * vnm = lgm->vnet_main; - vnet_hw_interface_t * hi; - u32 hw_if_index = ~0; - if (a->is_add) + if (a->is_en) { - /* create hw lisp_gpe0 iface */ - hw_if_index = vnet_register_interface (vnm, lisp_gpe_device_class.index, 0, - lisp_gpe_hw_class.index, 0); - - hi = vnet_get_hw_interface (vnm, hw_if_index); - hi->output_node_index = lisp_gpe_encap_node.index; - lgm->lisp_gpe_hw_if_index = hw_if_index; - /* add lgpe_ip4_lookup as possible next_node for ip4 lookup */ - lgm->ip4_lookup_next_lgpe_ip4_lookup = vlib_node_add_next ( - vnm->vlib_main, ip4_lookup_node.index, lgpe_ip4_lookup_node.index); - - /* insert default routes that points at lisp-gpe-encap */ - add_del_lisp_gpe_default_route(/* is_v4 */1, 1); - add_del_lisp_gpe_default_route(/* is_v4 */0, 1); + if (lgm->ip4_lookup_next_lgpe_ip4_lookup == ~0) + { + lgm->ip4_lookup_next_lgpe_ip4_lookup = vlib_node_add_next ( + vnm->vlib_main, ip4_lookup_node.index, + lgpe_ip4_lookup_node.index); + } + else + { + /* ask cp to re-add ifaces and defaults */ + } } else { - vnet_sw_interface_set_flags (vnm, lgm->lisp_gpe_hw_if_index, - 0 /* down */); + CLIB_UNUSED(uword * val); + hash_pair_t * p; + u32 * table_ids = 0, * table_id; + lisp_gpe_tunnel_key_t * tunnels = 0, * tunnel; + vnet_lisp_gpe_add_del_fwd_entry_args_t _at, * at = &_at; + vnet_lisp_gpe_add_del_iface_args_t _ai, * ai= &_ai; + + /* remove all tunnels */ + mhash_foreach(tunnel, val, &lgm->lisp_gpe_tunnel_by_key, ({ + vec_add1(tunnels, tunnel[0]); + })); + + vec_foreach(tunnel, tunnels) { + memset(at, 0, sizeof(at[0])); + at->is_add = 0; + gid_address_copy(&at->deid, &tunnel->eid); + ip_addr_v4(&at->dlocator).as_u32= tunnel->dst_loc; + vnet_lisp_gpe_add_del_fwd_entry (at, 0); + } + vec_free(tunnels); + + /* disable all ifaces */ + hash_foreach_pair(p, lgm->lisp_gpe_hw_if_index_by_table_id, ({ + vec_add1(table_ids, p->key); + })); + + vec_foreach(table_id, table_ids) { + ai->is_add = 0; + ai->table_id = table_id[0]; + + /* disables interface and removes defaults */ + vnet_lisp_gpe_add_del_iface(ai, 0); + } + vec_free(table_ids); } + + return 0; } static clib_error_t * -lisp_gpe_add_del_iface_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +lisp_gpe_enable_disable_command_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) { unformat_input_t _line_input, * line_input = &_line_input; - u8 is_add = 1; - vnet_lisp_gpe_add_del_iface_args_t _a, * a = &_a; + u8 is_en = 1; + vnet_lisp_gpe_enable_disable_args_t _a, * a = &_a; /* Get a line of input. */ if (! unformat_user (input, unformat_line_input, line_input)) @@ -1116,26 +1026,24 @@ lisp_gpe_add_del_iface_command_fn (vlib_main_t * vm, while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "up")) - is_add = 1; - else if (unformat (line_input, "down")) - is_add = 0; + if (unformat (line_input, "enable")) + is_en = 1; + else if (unformat (line_input, "disable")) + is_en = 0; else { return clib_error_return (0, "parse error: '%U'", format_unformat_error, line_input); } } - - a->is_add = is_add; - vnet_lisp_gpe_add_del_iface (a, 0); - return 0; + a->is_en = is_en; + return vnet_lisp_gpe_enable_disable (a); } -VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command, static) = { - .path = "lisp gpe iface", - .short_help = "lisp gpe iface [del]", - .function = lisp_gpe_add_del_iface_command_fn, +VLIB_CLI_COMMAND (enable_disable_lisp_gpe_command, static) = { + .path = "lisp gpe", + .short_help = "lisp gpe [enable|disable]", + .function = lisp_gpe_enable_disable_command_fn, }; clib_error_t * @@ -1154,7 +1062,8 @@ lisp_gpe_init (vlib_main_t *vm) lgm->vlib_main = vm; lgm->im4 = &ip4_main; lgm->lookup_main = &ip4_main.lookup_main; - + lgm->ip4_lookup_next_lgpe_ip4_lookup = ~0; + mhash_init (&lgm->lisp_gpe_tunnel_by_key, sizeof(uword), sizeof(lisp_gpe_tunnel_key_t)); diff --git a/vnet/vnet/lisp-gpe/lisp_gpe.h b/vnet/vnet/lisp-gpe/lisp_gpe.h index 7e86d57fc1a..1452b7984fe 100644 --- a/vnet/vnet/lisp-gpe/lisp_gpe.h +++ b/vnet/vnet/lisp-gpe/lisp_gpe.h @@ -74,15 +74,14 @@ typedef struct u8 ver_res; u8 res; u8 next_protocol; - u32 iid; + u32 vni; } lisp_gpe_tunnel_t; #define foreach_lisp_gpe_input_next \ _(DROP, "error-drop") \ _(IP4_INPUT, "ip4-input") \ _(IP6_INPUT, "ip6-input") \ -_(ETHERNET_INPUT, "ethernet-input") \ -_(LISP_GPE_ENCAP, "lisp-gpe-encap") +_(ETHERNET_INPUT, "ethernet-input") typedef enum { #define _(s,n) LISP_GPE_INPUT_NEXT_##s, @@ -96,7 +95,7 @@ typedef enum { #include #undef lisp_gpe_error LISP_GPE_N_ERROR, -} lisp_gpe_input_error_t; +} lisp_gpe_error_t; /* As a first step, reuse v4 fib. The goal of the typedef is to shield * consumers from future updates that may result in the lisp ip4 fib diverging @@ -114,13 +113,18 @@ typedef struct lisp_gpe_main /* lookup tunnel by key */ mhash_t lisp_gpe_tunnel_by_key; - /* lookup tunnel by adjacency index */ - uword * lisp_gpe_tunnel_by_adj_index; + /* lookup decap tunnel termination sw_if_index by vni and vice versa */ + uword * tunnel_term_sw_if_index_by_vni; + uword * vni_by_tunnel_term_sw_if_index; /* Free vlib hw_if_indices */ u32 * free_lisp_gpe_tunnel_hw_if_indices; - u32 lisp_gpe_hw_if_index; + /* Lookup lisp-gpe interfaces by vrf */ + uword * lisp_gpe_hw_if_index_by_table_id; + + /* Lookup lgpe_ip4_lookup_next by vrf */ + uword * lgpe_ip4_lookup_next_index_by_table_id; /* next node indexes that points ip4 lookup to lisp gpe lookup and lisp cp */ u32 ip4_lookup_next_lgpe_ip4_lookup; @@ -136,10 +140,9 @@ lisp_gpe_main_t lisp_gpe_main; extern vlib_node_registration_t lgpe_ip4_lookup_node; extern vlib_node_registration_t lisp_gpe_input_node; -extern vlib_node_registration_t lisp_gpe_encap_node; u8 * -format_lisp_gpe_encap_trace (u8 * s, va_list * args); +format_lisp_gpe_tx_trace (u8 * s, va_list * args); u8 * format_lisp_gpe_header_with_length (u8 * s, va_list * args); @@ -154,7 +157,7 @@ typedef struct u8 ver_res; u8 res; u8 next_protocol; - u32 iid; /* host byte order */ + u32 vni; /* host byte order */ } vnet_lisp_gpe_add_del_tunnel_args_t; int @@ -164,12 +167,22 @@ vnet_lisp_gpe_add_del_tunnel (vnet_lisp_gpe_add_del_tunnel_args_t *a, typedef struct { u8 is_add; + u32 table_id; /* vrf */ + u32 vni; /* host byte order */ } vnet_lisp_gpe_add_del_iface_args_t; void vnet_lisp_gpe_add_del_iface (vnet_lisp_gpe_add_del_iface_args_t *a, u32 * hw_if_indexp); +typedef struct +{ + u8 is_en; +} vnet_lisp_gpe_enable_disable_args_t; + +clib_error_t * +vnet_lisp_gpe_enable_disable (vnet_lisp_gpe_enable_disable_args_t *a); + typedef enum { NO_ACTION, @@ -194,7 +207,8 @@ typedef struct u8 ver_res; u8 res; u8 next_protocol; - u32 iid; /* host byte order */ + u32 vni; /* host byte order */ + u32 table_id; } vnet_lisp_gpe_add_del_fwd_entry_args_t; int diff --git a/vnet/vnet/lisp-gpe/lisp_gpe_error.def b/vnet/vnet/lisp-gpe/lisp_gpe_error.def index f002ecaeac0..c4c3f75d8eb 100644 --- a/vnet/vnet/lisp-gpe/lisp_gpe_error.def +++ b/vnet/vnet/lisp-gpe/lisp_gpe_error.def @@ -13,5 +13,6 @@ * limitations under the License. */ +lisp_gpe_error (ENCAPSULATED, "good packets encapsulated") lisp_gpe_error (DECAPSULATED, "good packets decapsulated") lisp_gpe_error (NO_SUCH_TUNNEL, "no such tunnel packets") -- cgit 1.2.3-korg