blob: 2142e095119d942b499c0cf653e228aae3eea749 [file] [log] [blame]
Florin Coras577c3552016-04-21 00:45:40 +02001/*
2 * Copyright (c) 2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
Florin Corasff0bf132016-09-05 19:30:35 +020016/**
17 * @file
18 * @brief Common utility functions for LISP-GPE interfaces.
19 *
20 */
21
Florin Coras577c3552016-04-21 00:45:40 +020022#include <vppinfra/error.h>
23#include <vppinfra/hash.h>
24#include <vnet/vnet.h>
25#include <vnet/ip/ip.h>
26#include <vnet/ip/udp.h>
27#include <vnet/ethernet/ethernet.h>
28#include <vnet/lisp-gpe/lisp_gpe.h>
Neale Ranns5e575b12016-10-03 09:40:25 +010029#include <vnet/lisp-gpe/lisp_gpe_fwd_entry.h>
30#include <vnet/lisp-gpe/lisp_gpe_tenant.h>
Neale Rannsb80c5362016-10-08 13:03:40 +010031#include <vnet/lisp-gpe/lisp_gpe_adjacency.h>
Neale Ranns0bfe5d82016-08-25 15:29:12 +010032#include <vnet/adj/adj.h>
33#include <vnet/fib/fib_table.h>
34#include <vnet/fib/ip4_fib.h>
35#include <vnet/fib/ip6_fib.h>
Neale Ranns5e575b12016-10-03 09:40:25 +010036#include <vnet/lisp-cp/lisp_cp_dpo.h>
37
38/**
39 * @brief The VLIB node arc/edge from the interface's TX node, to the L2
40 * load-balanceing node. Which is where all packets go
41 */
42static uword l2_arc_to_lb;
Florin Coras577c3552016-04-21 00:45:40 +020043
44#define foreach_lisp_gpe_tx_next \
45 _(DROP, "error-drop") \
Florin Coras02655bd2016-04-26 00:17:24 +020046 _(IP4_LOOKUP, "ip4-lookup") \
47 _(IP6_LOOKUP, "ip6-lookup")
Florin Coras577c3552016-04-21 00:45:40 +020048
49typedef enum
50{
51#define _(sym,str) LISP_GPE_TX_NEXT_##sym,
52 foreach_lisp_gpe_tx_next
53#undef _
Florin Coras220beac2016-08-16 23:04:00 +020054 LISP_GPE_TX_N_NEXT,
Florin Coras577c3552016-04-21 00:45:40 +020055} lisp_gpe_tx_next_t;
56
57typedef struct
58{
59 u32 tunnel_index;
60} lisp_gpe_tx_trace_t;
61
62u8 *
63format_lisp_gpe_tx_trace (u8 * s, va_list * args)
64{
65 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
66 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
Florin Coras220beac2016-08-16 23:04:00 +020067 lisp_gpe_tx_trace_t *t = va_arg (*args, lisp_gpe_tx_trace_t *);
Florin Coras577c3552016-04-21 00:45:40 +020068
69 s = format (s, "LISP-GPE-TX: tunnel %d", t->tunnel_index);
70 return s;
71}
72
Florin Coras02655bd2016-04-26 00:17:24 +020073#define is_v4_packet(_h) ((*(u8*) _h) & 0xF0) == 0x40
74
Florin Corasff0bf132016-09-05 19:30:35 +020075/**
76 * @brief LISP-GPE interface TX (encap) function.
77 * @node lisp_gpe_interface_tx
78 *
79 * The LISP-GPE interface TX (encap) function.
80 *
81 * Looks up the associated tunnel based on the adjacency hit in the SD FIB
82 * and if the tunnel is multihomed it uses the flow hash to determine
83 * sub-tunnel, and rewrite string, to be used to encapsulate the packet.
84 *
85 * @param[in] vm vlib_main_t corresponding to the current thread.
86 * @param[in] node vlib_node_runtime_t data for this node.
87 * @param[in] frame vlib_frame_t whose contents should be dispatched.
88 *
89 * @return number of vectors in frame.
90 */
Florin Coras577c3552016-04-21 00:45:40 +020091static uword
92lisp_gpe_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node,
Florin Coras220beac2016-08-16 23:04:00 +020093 vlib_frame_t * from_frame)
Florin Coras577c3552016-04-21 00:45:40 +020094{
Florin Coras220beac2016-08-16 23:04:00 +020095 u32 n_left_from, next_index, *from, *to_next;
96 lisp_gpe_main_t *lgm = &lisp_gpe_main;
Florin Coras577c3552016-04-21 00:45:40 +020097
98 from = vlib_frame_vector_args (from_frame);
99 n_left_from = from_frame->n_vectors;
100
101 next_index = node->cached_next_index;
102
103 while (n_left_from > 0)
104 {
105 u32 n_left_to_next;
106
Florin Coras220beac2016-08-16 23:04:00 +0200107 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
Florin Coras577c3552016-04-21 00:45:40 +0200108
Florin Coras577c3552016-04-21 00:45:40 +0200109 while (n_left_from > 0 && n_left_to_next > 0)
Florin Coras220beac2016-08-16 23:04:00 +0200110 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100111 u32 bi0, adj_index0, next0;
112 const ip_adjacency_t *adj0;
113 const dpo_id_t *dpo0;
Florin Coras220beac2016-08-16 23:04:00 +0200114 vlib_buffer_t *b0;
Florin Coras220beac2016-08-16 23:04:00 +0200115 u8 is_v4_0;
Florin Coras577c3552016-04-21 00:45:40 +0200116
Florin Coras220beac2016-08-16 23:04:00 +0200117 bi0 = from[0];
118 to_next[0] = bi0;
119 from += 1;
120 to_next += 1;
121 n_left_from -= 1;
122 n_left_to_next -= 1;
Florin Coras577c3552016-04-21 00:45:40 +0200123
Florin Coras220beac2016-08-16 23:04:00 +0200124 b0 = vlib_get_buffer (vm, bi0);
Florin Coras577c3552016-04-21 00:45:40 +0200125
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100126 /* Fixup the checksum and len fields in the LISP tunnel encap
127 * that was applied at the midchain node */
Florin Coras220beac2016-08-16 23:04:00 +0200128 is_v4_0 = is_v4_packet (vlib_buffer_get_current (b0));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100129 ip_udp_fixup_one (lgm->vlib_main, b0, is_v4_0);
Florin Coras577c3552016-04-21 00:45:40 +0200130
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100131 /* Follow the DPO on which the midchain is stacked */
132 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
133 adj0 = adj_get (adj_index0);
134 dpo0 = &adj0->sub_type.midchain.next_dpo;
135 next0 = dpo0->dpoi_next_node;
136 vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
Florin Coras577c3552016-04-21 00:45:40 +0200137
Florin Coras220beac2016-08-16 23:04:00 +0200138 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
139 {
140 lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
141 sizeof (*tr));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100142 tr->tunnel_index = adj_index0;
Florin Coras220beac2016-08-16 23:04:00 +0200143 }
144 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
145 n_left_to_next, bi0, next0);
146 }
Florin Coras577c3552016-04-21 00:45:40 +0200147
148 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
149 }
Florin Coras0f6b7962016-06-21 22:32:47 +0200150
Florin Coras577c3552016-04-21 00:45:40 +0200151 return from_frame->n_vectors;
152}
153
154static u8 *
155format_lisp_gpe_name (u8 * s, va_list * args)
156{
157 u32 dev_instance = va_arg (*args, u32);
158 return format (s, "lisp_gpe%d", dev_instance);
159}
160
Florin Coras220beac2016-08-16 23:04:00 +0200161/* *INDENT-OFF* */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100162VNET_DEVICE_CLASS (lisp_gpe_device_class) = {
Florin Coras577c3552016-04-21 00:45:40 +0200163 .name = "LISP_GPE",
164 .format_device_name = format_lisp_gpe_name,
165 .format_tx_trace = format_lisp_gpe_tx_trace,
166 .tx_function = lisp_gpe_interface_tx,
Florin Coras577c3552016-04-21 00:45:40 +0200167};
Florin Coras220beac2016-08-16 23:04:00 +0200168/* *INDENT-ON* */
Florin Coras577c3552016-04-21 00:45:40 +0200169
Florin Coras577c3552016-04-21 00:45:40 +0200170u8 *
171format_lisp_gpe_header_with_length (u8 * s, va_list * args)
172{
Florin Coras220beac2016-08-16 23:04:00 +0200173 lisp_gpe_header_t *h = va_arg (*args, lisp_gpe_header_t *);
Florin Coras577c3552016-04-21 00:45:40 +0200174 u32 max_header_bytes = va_arg (*args, u32);
175 u32 header_bytes;
176
177 header_bytes = sizeof (h[0]);
178 if (max_header_bytes != 0 && header_bytes > max_header_bytes)
179 return format (s, "lisp-gpe header truncated");
180
181 s = format (s, "flags: ");
182#define _(n,v) if (h->flags & v) s = format (s, "%s ", #n);
183 foreach_lisp_gpe_flag_bit;
184#undef _
185
186 s = format (s, "\n ver_res %d res %d next_protocol %d iid %d(%x)",
Florin Coras220beac2016-08-16 23:04:00 +0200187 h->ver_res, h->res, h->next_protocol,
188 clib_net_to_host_u32 (h->iid), clib_net_to_host_u32 (h->iid));
Florin Coras577c3552016-04-21 00:45:40 +0200189 return s;
190}
191
Florin Coras220beac2016-08-16 23:04:00 +0200192/* *INDENT-OFF* */
Florin Coras577c3552016-04-21 00:45:40 +0200193VNET_HW_INTERFACE_CLASS (lisp_gpe_hw_class) = {
194 .name = "LISP_GPE",
195 .format_header = format_lisp_gpe_header_with_length,
Neale Rannsb80c5362016-10-08 13:03:40 +0100196 .build_rewrite = lisp_gpe_build_rewrite,
197 .update_adjacency = lisp_gpe_update_adjacency,
Florin Coras577c3552016-04-21 00:45:40 +0200198};
Florin Coras220beac2016-08-16 23:04:00 +0200199/* *INDENT-ON* */
Florin Coras577c3552016-04-21 00:45:40 +0200200
Florin Coras1a1adc72016-07-22 01:45:30 +0200201
202typedef struct
203{
Florin Corasce1b4c72017-01-26 14:25:34 -0800204 u32 dpo_index;
Florin Coras1a1adc72016-07-22 01:45:30 +0200205} l2_lisp_gpe_tx_trace_t;
206
Neale Ranns5e575b12016-10-03 09:40:25 +0100207static u8 *
Florin Coras1a1adc72016-07-22 01:45:30 +0200208format_l2_lisp_gpe_tx_trace (u8 * s, va_list * args)
209{
210 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
211 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
Florin Coras220beac2016-08-16 23:04:00 +0200212 l2_lisp_gpe_tx_trace_t *t = va_arg (*args, l2_lisp_gpe_tx_trace_t *);
Florin Coras1a1adc72016-07-22 01:45:30 +0200213
Florin Corasce1b4c72017-01-26 14:25:34 -0800214 s = format (s, "L2-LISP-GPE-TX: load-balance %d", t->dpo_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200215 return s;
216}
217
Florin Corasff0bf132016-09-05 19:30:35 +0200218/**
219 * @brief LISP-GPE interface TX (encap) function for L2 overlays.
220 * @node l2_lisp_gpe_interface_tx
221 *
222 * The L2 LISP-GPE interface TX (encap) function.
223 *
224 * Uses bridge domain index, source and destination ethernet addresses to
225 * lookup tunnel. If the tunnel is multihomed a flow has is used to determine
226 * the sub-tunnel and therefore the rewrite string to be used to encapsulate
227 * the packets.
228 *
229 * @param[in] vm vlib_main_t corresponding to the current thread.
230 * @param[in] node vlib_node_runtime_t data for this node.
231 * @param[in] frame vlib_frame_t whose contents should be dispatched.
232 *
233 * @return number of vectors in frame.
234 */
Florin Coras1a1adc72016-07-22 01:45:30 +0200235static uword
236l2_lisp_gpe_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node,
Florin Coras220beac2016-08-16 23:04:00 +0200237 vlib_frame_t * from_frame)
Florin Coras1a1adc72016-07-22 01:45:30 +0200238{
Florin Coras220beac2016-08-16 23:04:00 +0200239 u32 n_left_from, next_index, *from, *to_next;
240 lisp_gpe_main_t *lgm = &lisp_gpe_main;
Florin Coras1a1adc72016-07-22 01:45:30 +0200241
242 from = vlib_frame_vector_args (from_frame);
243 n_left_from = from_frame->n_vectors;
244
245 next_index = node->cached_next_index;
246
247 while (n_left_from > 0)
248 {
249 u32 n_left_to_next;
250
Florin Coras220beac2016-08-16 23:04:00 +0200251 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
Florin Coras1a1adc72016-07-22 01:45:30 +0200252
Florin Coras1a1adc72016-07-22 01:45:30 +0200253 while (n_left_from > 0 && n_left_to_next > 0)
Florin Coras220beac2016-08-16 23:04:00 +0200254 {
255 vlib_buffer_t *b0;
Neale Ranns5e575b12016-10-03 09:40:25 +0100256 u32 bi0, lbi0;
Florin Coras220beac2016-08-16 23:04:00 +0200257 ethernet_header_t *e0;
Florin Coras1a1adc72016-07-22 01:45:30 +0200258
Florin Coras220beac2016-08-16 23:04:00 +0200259 bi0 = from[0];
260 to_next[0] = bi0;
261 from += 1;
262 to_next += 1;
263 n_left_from -= 1;
264 n_left_to_next -= 1;
Florin Coras1a1adc72016-07-22 01:45:30 +0200265
Florin Coras220beac2016-08-16 23:04:00 +0200266 b0 = vlib_get_buffer (vm, bi0);
267 e0 = vlib_buffer_get_current (b0);
Florin Coras1a1adc72016-07-22 01:45:30 +0200268
Neale Ranns5e575b12016-10-03 09:40:25 +0100269 vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_MAC;
Florin Coras1a1adc72016-07-22 01:45:30 +0200270
Neale Ranns5e575b12016-10-03 09:40:25 +0100271 /* lookup dst + src mac */
272 lbi0 = lisp_l2_fib_lookup (lgm, vnet_buffer (b0)->l2.bd_index,
273 e0->src_address, e0->dst_address);
274 vnet_buffer (b0)->ip.adj_index[VLIB_TX] = lbi0;
275
Florin Coras1a1adc72016-07-22 01:45:30 +0200276
Florin Coras220beac2016-08-16 23:04:00 +0200277 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
278 {
279 l2_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
280 sizeof (*tr));
Florin Corasce1b4c72017-01-26 14:25:34 -0800281 tr->dpo_index = lbi0;
Florin Coras220beac2016-08-16 23:04:00 +0200282 }
283 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
Neale Ranns5e575b12016-10-03 09:40:25 +0100284 n_left_to_next, bi0, l2_arc_to_lb);
Florin Coras220beac2016-08-16 23:04:00 +0200285 }
Florin Coras1a1adc72016-07-22 01:45:30 +0200286
287 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
Andrej Kozemcak8ebb2a12016-06-07 12:25:20 +0200288 }
289
Florin Coras1a1adc72016-07-22 01:45:30 +0200290 return from_frame->n_vectors;
291}
292
293static u8 *
294format_l2_lisp_gpe_name (u8 * s, va_list * args)
295{
296 u32 dev_instance = va_arg (*args, u32);
297 return format (s, "l2_lisp_gpe%d", dev_instance);
298}
299
Florin Coras220beac2016-08-16 23:04:00 +0200300/* *INDENT-OFF* */
Florin Coras1a1adc72016-07-22 01:45:30 +0200301VNET_DEVICE_CLASS (l2_lisp_gpe_device_class,static) = {
302 .name = "L2_LISP_GPE",
303 .format_device_name = format_l2_lisp_gpe_name,
Neale Ranns5e575b12016-10-03 09:40:25 +0100304 .format_tx_trace = format_l2_lisp_gpe_tx_trace,
Florin Coras1a1adc72016-07-22 01:45:30 +0200305 .tx_function = l2_lisp_gpe_interface_tx,
Florin Coras1a1adc72016-07-22 01:45:30 +0200306};
Florin Coras220beac2016-08-16 23:04:00 +0200307/* *INDENT-ON* */
Florin Coras1a1adc72016-07-22 01:45:30 +0200308
Florin Corasce1b4c72017-01-26 14:25:34 -0800309typedef struct
310{
311 u32 dpo_index;
312} nsh_lisp_gpe_tx_trace_t;
313
314u8 *
315format_nsh_lisp_gpe_tx_trace (u8 * s, va_list * args)
316{
317 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
318 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
319 nsh_lisp_gpe_tx_trace_t *t = va_arg (*args, nsh_lisp_gpe_tx_trace_t *);
320
321 s = format (s, "NSH-GPE-TX: tunnel %d", t->dpo_index);
322 return s;
323}
324
325/**
326 * @brief LISP-GPE interface TX for NSH overlays.
327 * @node nsh_lisp_gpe_interface_tx
328 *
329 * The NSH LISP-GPE interface TX function.
330 *
331 * @param[in] vm vlib_main_t corresponding to the current thread.
332 * @param[in] node vlib_node_runtime_t data for this node.
333 * @param[in] frame vlib_frame_t whose contents should be dispatched.
334 *
335 * @return number of vectors in frame.
336 */
337static uword
338nsh_lisp_gpe_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node,
339 vlib_frame_t * from_frame)
340{
341 u32 n_left_from, next_index, *from, *to_next;
342 lisp_gpe_main_t *lgm = &lisp_gpe_main;
343
344 from = vlib_frame_vector_args (from_frame);
345 n_left_from = from_frame->n_vectors;
346
347 next_index = node->cached_next_index;
348
349 while (n_left_from > 0)
350 {
351 u32 n_left_to_next;
352
353 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
354
355 while (n_left_from > 0 && n_left_to_next > 0)
356 {
357 vlib_buffer_t *b0;
358 u32 bi0;
359 u32 *nsh0, next0;
360 const dpo_id_t *dpo0;
361
362 bi0 = from[0];
363 to_next[0] = bi0;
364 from += 1;
365 to_next += 1;
366 n_left_from -= 1;
367 n_left_to_next -= 1;
368
369 b0 = vlib_get_buffer (vm, bi0);
370 nsh0 = vlib_buffer_get_current (b0);
371
372 vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_LCAF;
373
374 /* lookup SPI + SI (second word of the NSH header).
375 * NB: Load balancing was done by the control plane */
376 dpo0 = lisp_nsh_fib_lookup (lgm, nsh0[1]);
377
378 next0 = dpo0->dpoi_next_node;
379 vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
380
381 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
382 {
383 nsh_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
384 sizeof (*tr));
385 tr->dpo_index = dpo0->dpoi_index;
386 }
387 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
388 n_left_to_next, bi0, next0);
389 }
390
391 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
392 }
393
394 return from_frame->n_vectors;
395}
396
397static u8 *
398format_nsh_lisp_gpe_name (u8 * s, va_list * args)
399{
400 u32 dev_instance = va_arg (*args, u32);
401 return format (s, "nsh_lisp_gpe%d", dev_instance);
402}
403
404/* *INDENT-OFF* */
405VNET_DEVICE_CLASS (nsh_lisp_gpe_device_class,static) = {
406 .name = "NSH_LISP_GPE",
407 .format_device_name = format_nsh_lisp_gpe_name,
408 .format_tx_trace = format_nsh_lisp_gpe_tx_trace,
409 .tx_function = nsh_lisp_gpe_interface_tx,
410};
411/* *INDENT-ON* */
412
Florin Coras1a1adc72016-07-22 01:45:30 +0200413static vnet_hw_interface_t *
Neale Ranns5e575b12016-10-03 09:40:25 +0100414lisp_gpe_create_iface (lisp_gpe_main_t * lgm, u32 vni, u32 dp_table,
Florin Coras220beac2016-08-16 23:04:00 +0200415 vnet_device_class_t * dev_class,
416 tunnel_lookup_t * tuns)
Florin Coras1a1adc72016-07-22 01:45:30 +0200417{
418 u32 flen;
419 u32 hw_if_index = ~0;
Florin Coras220beac2016-08-16 23:04:00 +0200420 u8 *new_name;
421 vnet_hw_interface_t *hi;
422 vnet_main_t *vnm = lgm->vnet_main;
Florin Coras1a1adc72016-07-22 01:45:30 +0200423
424 /* create hw lisp_gpeX iface if needed, otherwise reuse existing */
Florin Coras220beac2016-08-16 23:04:00 +0200425 flen = vec_len (lgm->free_tunnel_hw_if_indices);
Florin Coras1a1adc72016-07-22 01:45:30 +0200426 if (flen > 0)
427 {
428 hw_if_index = lgm->free_tunnel_hw_if_indices[flen - 1];
Florin Coras220beac2016-08-16 23:04:00 +0200429 _vec_len (lgm->free_tunnel_hw_if_indices) -= 1;
Florin Coras1a1adc72016-07-22 01:45:30 +0200430
431 hi = vnet_get_hw_interface (vnm, hw_if_index);
432
433 /* rename interface */
Florin Coras220beac2016-08-16 23:04:00 +0200434 new_name = format (0, "%U", dev_class->format_device_name, vni);
Florin Coras1a1adc72016-07-22 01:45:30 +0200435
Florin Coras220beac2016-08-16 23:04:00 +0200436 vec_add1 (new_name, 0);
Florin Coras1a1adc72016-07-22 01:45:30 +0200437 vnet_rename_interface (vnm, hw_if_index, (char *) new_name);
Florin Coras220beac2016-08-16 23:04:00 +0200438 vec_free (new_name);
Florin Coras1a1adc72016-07-22 01:45:30 +0200439
440 /* clear old stats of freed interface before reuse */
Florin Coras220beac2016-08-16 23:04:00 +0200441 vnet_interface_main_t *im = &vnm->interface_main;
Florin Coras1a1adc72016-07-22 01:45:30 +0200442 vnet_interface_counter_lock (im);
Florin Coras220beac2016-08-16 23:04:00 +0200443 vlib_zero_combined_counter (&im->combined_sw_if_counters
444 [VNET_INTERFACE_COUNTER_TX],
445 hi->sw_if_index);
446 vlib_zero_combined_counter (&im->combined_sw_if_counters
447 [VNET_INTERFACE_COUNTER_RX],
448 hi->sw_if_index);
449 vlib_zero_simple_counter (&im->sw_if_counters
450 [VNET_INTERFACE_COUNTER_DROP],
451 hi->sw_if_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200452 vnet_interface_counter_unlock (im);
453 }
454 else
455 {
456 hw_if_index = vnet_register_interface (vnm, dev_class->index, vni,
Florin Coras220beac2016-08-16 23:04:00 +0200457 lisp_gpe_hw_class.index, 0);
Florin Coras1a1adc72016-07-22 01:45:30 +0200458 hi = vnet_get_hw_interface (vnm, hw_if_index);
459 }
460
Florin Coras220beac2016-08-16 23:04:00 +0200461 hash_set (tuns->hw_if_index_by_dp_table, dp_table, hw_if_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200462
463 /* set tunnel termination: post decap, packets are tagged as having been
464 * originated by lisp-gpe interface */
Florin Coras220beac2016-08-16 23:04:00 +0200465 hash_set (tuns->sw_if_index_by_vni, vni, hi->sw_if_index);
466 hash_set (tuns->vni_by_sw_if_index, hi->sw_if_index, vni);
Florin Coras1a1adc72016-07-22 01:45:30 +0200467
468 return hi;
469}
470
471static void
Neale Ranns5e575b12016-10-03 09:40:25 +0100472lisp_gpe_remove_iface (lisp_gpe_main_t * lgm, u32 hi_index, u32 dp_table,
Florin Coras220beac2016-08-16 23:04:00 +0200473 tunnel_lookup_t * tuns)
Florin Coras1a1adc72016-07-22 01:45:30 +0200474{
Florin Coras220beac2016-08-16 23:04:00 +0200475 vnet_main_t *vnm = lgm->vnet_main;
476 vnet_hw_interface_t *hi;
477 uword *vnip;
Florin Coras1a1adc72016-07-22 01:45:30 +0200478
479 hi = vnet_get_hw_interface (vnm, hi_index);
480
481 /* disable interface */
Florin Coras220beac2016-08-16 23:04:00 +0200482 vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 0 /* down */ );
483 vnet_hw_interface_set_flags (vnm, hi->hw_if_index, 0 /* down */ );
484 hash_unset (tuns->hw_if_index_by_dp_table, dp_table);
485 vec_add1 (lgm->free_tunnel_hw_if_indices, hi->hw_if_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200486
487 /* clean tunnel termination and vni to sw_if_index binding */
Florin Coras220beac2016-08-16 23:04:00 +0200488 vnip = hash_get (tuns->vni_by_sw_if_index, hi->sw_if_index);
Florin Corasf7643fd2016-08-01 15:35:20 +0200489 if (0 == vnip)
490 {
491 clib_warning ("No vni associated to interface %d", hi->sw_if_index);
492 return;
493 }
Florin Coras220beac2016-08-16 23:04:00 +0200494 hash_unset (tuns->sw_if_index_by_vni, vnip[0]);
495 hash_unset (tuns->vni_by_sw_if_index, hi->sw_if_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200496}
497
Neale Ranns5e575b12016-10-03 09:40:25 +0100498static void
499lisp_gpe_iface_set_table (u32 sw_if_index, u32 table_id)
500{
501 fib_node_index_t fib_index;
502
503 fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id);
504 vec_validate (ip4_main.fib_index_by_sw_if_index, sw_if_index);
505 ip4_main.fib_index_by_sw_if_index[sw_if_index] = fib_index;
506 ip4_sw_interface_enable_disable (sw_if_index, 1);
507
508 fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, table_id);
509 vec_validate (ip6_main.fib_index_by_sw_if_index, sw_if_index);
510 ip6_main.fib_index_by_sw_if_index[sw_if_index] = fib_index;
511 ip6_sw_interface_enable_disable (sw_if_index, 1);
512}
513
514static void
515lisp_gpe_tenant_del_default_routes (u32 table_id)
516{
517 fib_protocol_t proto;
518
519 FOR_EACH_FIB_IP_PROTOCOL (proto)
520 {
521 fib_prefix_t prefix = {
522 .fp_proto = proto,
523 };
524 u32 fib_index;
525
526 fib_index = fib_table_find (prefix.fp_proto, table_id);
527 fib_table_entry_special_remove (fib_index, &prefix, FIB_SOURCE_LISP);
528 fib_table_unlock (fib_index, prefix.fp_proto);
529 }
530}
531
532static void
533lisp_gpe_tenant_add_default_routes (u32 table_id)
534{
535 fib_protocol_t proto;
536
537 FOR_EACH_FIB_IP_PROTOCOL (proto)
538 {
539 fib_prefix_t prefix = {
540 .fp_proto = proto,
541 };
542 u32 fib_index;
543
544 /*
545 * Add a deafult route that results in a control plane punt DPO
546 */
547 fib_index = fib_table_find_or_create_and_lock (prefix.fp_proto, table_id);
548 fib_table_entry_special_dpo_add (fib_index, &prefix, FIB_SOURCE_LISP,
549 FIB_ENTRY_FLAG_EXCLUSIVE,
550 lisp_cp_dpo_get (fib_proto_to_dpo
551 (proto)));
552 }
553}
554
555
Florin Corasff0bf132016-09-05 19:30:35 +0200556/**
557 * @brief Add/del LISP-GPE L3 interface.
558 *
559 * Creates LISP-GPE interface, sets ingress arcs from lisp_gpeX_lookup,
560 * installs default routes that attract all traffic with no more specific
561 * routes to lgpe-ipx-lookup, set egress arcs to ipx-lookup, sets
562 * the interface in the right vrf and enables it.
563 *
564 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
565 * @param[in] a Parameters to create interface.
566 *
567 * @return number of vectors in frame.
568 */
Neale Ranns5e575b12016-10-03 09:40:25 +0100569u32
570lisp_gpe_add_l3_iface (lisp_gpe_main_t * lgm, u32 vni, u32 table_id)
Florin Coras1a1adc72016-07-22 01:45:30 +0200571{
Florin Coras220beac2016-08-16 23:04:00 +0200572 vnet_main_t *vnm = lgm->vnet_main;
573 tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
574 vnet_hw_interface_t *hi;
Florin Coras220beac2016-08-16 23:04:00 +0200575 uword *hip, *si;
Florin Coras1a1adc72016-07-22 01:45:30 +0200576
Neale Ranns5e575b12016-10-03 09:40:25 +0100577 hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
Florin Coras577c3552016-04-21 00:45:40 +0200578
Neale Ranns5e575b12016-10-03 09:40:25 +0100579 if (hip)
Florin Coras577c3552016-04-21 00:45:40 +0200580 {
Neale Ranns5e575b12016-10-03 09:40:25 +0100581 clib_warning ("vrf %d already mapped to a vni", table_id);
582 return ~0;
Florin Coras577c3552016-04-21 00:45:40 +0200583 }
Andrej Kozemcak8ebb2a12016-06-07 12:25:20 +0200584
Neale Ranns5e575b12016-10-03 09:40:25 +0100585 si = hash_get (l3_ifaces->sw_if_index_by_vni, vni);
586
587 if (si)
588 {
589 clib_warning ("Interface for vni %d already exists", vni);
590 }
591
592 /* create lisp iface and populate tunnel tables */
593 hi = lisp_gpe_create_iface (lgm, vni, table_id,
594 &lisp_gpe_device_class, l3_ifaces);
595
596 /* insert default routes that point to lisp-cp lookup */
597 lisp_gpe_iface_set_table (hi->sw_if_index, table_id);
598 lisp_gpe_tenant_add_default_routes (table_id);
599
600 /* enable interface */
601 vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
602 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
603 vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
604 VNET_HW_INTERFACE_FLAG_LINK_UP);
605
606 return (hi->sw_if_index);
607}
608
609void
610lisp_gpe_del_l3_iface (lisp_gpe_main_t * lgm, u32 vni, u32 table_id)
611{
612 vnet_main_t *vnm = lgm->vnet_main;
613 tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
614 vnet_hw_interface_t *hi;
615 uword *hip;
616
617 hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
618
619 if (hip == 0)
620 {
621 clib_warning ("The interface for vrf %d doesn't exist", table_id);
622 return;
623 }
624
625 hi = vnet_get_hw_interface (vnm, hip[0]);
626
627 lisp_gpe_remove_iface (lgm, hip[0], table_id, &lgm->l3_ifaces);
628
629 /* unset default routes */
630 ip4_sw_interface_enable_disable (hi->sw_if_index, 0);
631 ip6_sw_interface_enable_disable (hi->sw_if_index, 0);
632 lisp_gpe_tenant_del_default_routes (table_id);
Florin Coras577c3552016-04-21 00:45:40 +0200633}
634
Florin Corasff0bf132016-09-05 19:30:35 +0200635/**
636 * @brief Add/del LISP-GPE L2 interface.
637 *
638 * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
639 * bridge domain, sets egress arcs and enables it.
640 *
641 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
642 * @param[in] a Parameters to create interface.
643 *
644 * @return number of vectors in frame.
645 */
Neale Ranns5e575b12016-10-03 09:40:25 +0100646u32
647lisp_gpe_add_l2_iface (lisp_gpe_main_t * lgm, u32 vni, u32 bd_id)
Florin Coras1a1adc72016-07-22 01:45:30 +0200648{
Florin Coras220beac2016-08-16 23:04:00 +0200649 vnet_main_t *vnm = lgm->vnet_main;
650 tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
651 vnet_hw_interface_t *hi;
652 uword *hip, *si;
Florin Coras1a1adc72016-07-22 01:45:30 +0200653 u16 bd_index;
654
Neale Ranns5e575b12016-10-03 09:40:25 +0100655 bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
Florin Coras220beac2016-08-16 23:04:00 +0200656 hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200657
Neale Ranns5e575b12016-10-03 09:40:25 +0100658 if (hip)
Florin Coras1a1adc72016-07-22 01:45:30 +0200659 {
Neale Ranns5e575b12016-10-03 09:40:25 +0100660 clib_warning ("bridge domain %d already mapped to a vni", bd_id);
661 return ~0;
Florin Coras1a1adc72016-07-22 01:45:30 +0200662 }
663
Neale Ranns5e575b12016-10-03 09:40:25 +0100664 si = hash_get (l2_ifaces->sw_if_index_by_vni, vni);
665 if (si)
666 {
667 clib_warning ("Interface for vni %d already exists", vni);
668 return ~0;
669 }
670
671 /* create lisp iface and populate tunnel tables */
672 hi = lisp_gpe_create_iface (lgm, vni, bd_index,
673 &l2_lisp_gpe_device_class, &lgm->l2_ifaces);
674
675 /* enable interface */
676 vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
677 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
678 vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
679 VNET_HW_INTERFACE_FLAG_LINK_UP);
680
681 l2_arc_to_lb = vlib_node_add_named_next (vlib_get_main (),
682 hi->tx_node_index,
683 "l2-load-balance");
684
685 /* we're ready. add iface to l2 bridge domain */
686 set_int_l2_mode (lgm->vlib_main, vnm, MODE_L2_BRIDGE, hi->sw_if_index,
687 bd_index, 0, 0, 0);
688
689 return (hi->sw_if_index);
Florin Coras1a1adc72016-07-22 01:45:30 +0200690}
691
Neale Ranns5e575b12016-10-03 09:40:25 +0100692/**
693 * @brief Add/del LISP-GPE L2 interface.
694 *
695 * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
696 * bridge domain, sets egress arcs and enables it.
697 *
698 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
699 * @param[in] a Parameters to create interface.
700 *
701 * @return number of vectors in frame.
702 */
703void
704lisp_gpe_del_l2_iface (lisp_gpe_main_t * lgm, u32 vni, u32 bd_id)
Florin Coras1a1adc72016-07-22 01:45:30 +0200705{
Neale Ranns5e575b12016-10-03 09:40:25 +0100706 tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
707 u16 bd_index;
708 uword *hip;
Florin Coras1a1adc72016-07-22 01:45:30 +0200709
Neale Ranns5e575b12016-10-03 09:40:25 +0100710 bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
711 hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
712
713 if (hip == 0)
Florin Coras1a1adc72016-07-22 01:45:30 +0200714 {
Neale Ranns5e575b12016-10-03 09:40:25 +0100715 clib_warning ("The interface for bridge domain %d doesn't exist",
716 bd_id);
717 return;
Florin Coras1a1adc72016-07-22 01:45:30 +0200718 }
Neale Ranns5e575b12016-10-03 09:40:25 +0100719 lisp_gpe_remove_iface (lgm, hip[0], bd_index, &lgm->l2_ifaces);
Florin Coras1a1adc72016-07-22 01:45:30 +0200720}
721
Florin Corasce1b4c72017-01-26 14:25:34 -0800722/**
723 * @brief Add LISP-GPE NSH interface.
724 *
725 * Creates LISP-GPE interface, sets it in L3 mode.
726 *
727 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
728 * @param[in] a Parameters to create interface.
729 *
730 * @return sw_if_index.
731 */
732u32
733lisp_gpe_add_nsh_iface (lisp_gpe_main_t * lgm)
734{
735 vnet_main_t *vnm = lgm->vnet_main;
736 tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
737 vnet_hw_interface_t *hi;
738 uword *hip, *si;
739
740 hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
741
742 if (hip)
743 {
744 clib_warning ("NSH interface 0 already exists");
745 return ~0;
746 }
747
748 si = hash_get (nsh_ifaces->sw_if_index_by_vni, 0);
749 if (si)
750 {
751 clib_warning ("NSH interface already exists");
752 return ~0;
753 }
754
755 /* create lisp iface and populate tunnel tables */
756 hi = lisp_gpe_create_iface (lgm, 0, 0,
757 &nsh_lisp_gpe_device_class, &lgm->nsh_ifaces);
758
759 /* enable interface */
760 vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
761 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
762 vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
763 VNET_HW_INTERFACE_FLAG_LINK_UP);
764
765 return (hi->sw_if_index);
766}
767
768/**
769 * @brief Del LISP-GPE NSH interface.
770 *
771 */
772void
773lisp_gpe_del_nsh_iface (lisp_gpe_main_t * lgm)
774{
775 tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
776 uword *hip;
777
778 hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
779
780 if (hip == 0)
781 {
782 clib_warning ("The NSH 0 interface doesn't exist");
783 return;
784 }
785 lisp_gpe_remove_iface (lgm, hip[0], 0, &lgm->nsh_ifaces);
786}
787
Florin Coras577c3552016-04-21 00:45:40 +0200788static clib_error_t *
789lisp_gpe_add_del_iface_command_fn (vlib_main_t * vm, unformat_input_t * input,
Florin Coras220beac2016-08-16 23:04:00 +0200790 vlib_cli_command_t * cmd)
Florin Coras577c3552016-04-21 00:45:40 +0200791{
Florin Coras220beac2016-08-16 23:04:00 +0200792 unformat_input_t _line_input, *line_input = &_line_input;
Florin Coras577c3552016-04-21 00:45:40 +0200793 u8 is_add = 1;
Florin Coras1a1adc72016-07-22 01:45:30 +0200794 u32 table_id, vni, bd_id;
795 u8 vni_is_set = 0, vrf_is_set = 0, bd_index_is_set = 0;
Florin Corasce1b4c72017-01-26 14:25:34 -0800796 u8 nsh_iface = 0;
Florin Coras577c3552016-04-21 00:45:40 +0200797
Neale Ranns5e575b12016-10-03 09:40:25 +0100798 if (vnet_lisp_gpe_enable_disable_status () == 0)
799 {
800 return clib_error_return (0, "LISP is disabled");
801 }
Florin Coras577c3552016-04-21 00:45:40 +0200802
803 /* Get a line of input. */
Florin Coras220beac2016-08-16 23:04:00 +0200804 if (!unformat_user (input, unformat_line_input, line_input))
Florin Coras577c3552016-04-21 00:45:40 +0200805 return 0;
806
807 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
808 {
809 if (unformat (line_input, "add"))
Florin Coras220beac2016-08-16 23:04:00 +0200810 is_add = 1;
Florin Coras577c3552016-04-21 00:45:40 +0200811 else if (unformat (line_input, "del"))
Florin Coras220beac2016-08-16 23:04:00 +0200812 is_add = 0;
Florin Coras577c3552016-04-21 00:45:40 +0200813 else if (unformat (line_input, "vrf %d", &table_id))
Florin Coras220beac2016-08-16 23:04:00 +0200814 {
815 vrf_is_set = 1;
816 }
Florin Coras69ae1872016-07-19 11:52:35 +0200817 else if (unformat (line_input, "vni %d", &vni))
Florin Coras220beac2016-08-16 23:04:00 +0200818 {
819 vni_is_set = 1;
820 }
Florin Coras1a1adc72016-07-22 01:45:30 +0200821 else if (unformat (line_input, "bd %d", &bd_id))
Florin Coras220beac2016-08-16 23:04:00 +0200822 {
823 bd_index_is_set = 1;
824 }
Florin Corasce1b4c72017-01-26 14:25:34 -0800825 else if (unformat (line_input, "nsh"))
826 {
827 nsh_iface = 1;
828 }
Florin Coras577c3552016-04-21 00:45:40 +0200829 else
Florin Coras220beac2016-08-16 23:04:00 +0200830 {
831 return clib_error_return (0, "parse error: '%U'",
832 format_unformat_error, line_input);
833 }
Florin Coras577c3552016-04-21 00:45:40 +0200834 }
835
Florin Coras6085e162017-02-15 14:16:26 -0800836 if (nsh_iface)
837 {
838 if (is_add)
839 {
840 if (~0 == lisp_gpe_add_nsh_iface (&lisp_gpe_main))
841 {
842 return clib_error_return (0, "NSH interface not created");
843 }
844 }
845 else
846 {
847 lisp_gpe_del_nsh_iface (&lisp_gpe_main);
848 }
849 return (NULL);
850 }
851
Florin Coras1a1adc72016-07-22 01:45:30 +0200852 if (vrf_is_set && bd_index_is_set)
Florin Coras220beac2016-08-16 23:04:00 +0200853 return clib_error_return (0,
854 "Cannot set both vrf and brdige domain index!");
Florin Coras1a1adc72016-07-22 01:45:30 +0200855
856 if (!vni_is_set)
Florin Coras220beac2016-08-16 23:04:00 +0200857 return clib_error_return (0, "vni must be set!");
Florin Coras1a1adc72016-07-22 01:45:30 +0200858
859 if (!vrf_is_set && !bd_index_is_set)
Florin Coras220beac2016-08-16 23:04:00 +0200860 return clib_error_return (0, "vrf or bridge domain index must be set!");
Florin Coras69ae1872016-07-19 11:52:35 +0200861
Neale Ranns5e575b12016-10-03 09:40:25 +0100862 if (bd_index_is_set)
Andrej Kozemcak8ebb2a12016-06-07 12:25:20 +0200863 {
Neale Ranns5e575b12016-10-03 09:40:25 +0100864 if (is_add)
865 {
866 if (~0 == lisp_gpe_tenant_l2_iface_add_or_lock (vni, bd_id))
867 return clib_error_return (0, "L2 interface not created");
868 }
869 else
870 lisp_gpe_tenant_l2_iface_unlock (vni);
871 }
872 else
873 {
874 if (is_add)
875 {
876 if (~0 == lisp_gpe_tenant_l3_iface_add_or_lock (vni, table_id))
877 return clib_error_return (0, "L3 interface not created");
878 }
879 else
880 lisp_gpe_tenant_l3_iface_unlock (vni);
Andrej Kozemcak8ebb2a12016-06-07 12:25:20 +0200881 }
882
Neale Ranns5e575b12016-10-03 09:40:25 +0100883 return (NULL);
Florin Coras577c3552016-04-21 00:45:40 +0200884}
885
Florin Coras220beac2016-08-16 23:04:00 +0200886/* *INDENT-OFF* */
Florin Coras577c3552016-04-21 00:45:40 +0200887VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command, static) = {
Filip Tehlar82786c42017-02-20 15:20:37 +0100888 .path = "gpe iface",
889 .short_help = "gpe iface add/del vni <vni> vrf <vrf>",
Florin Coras577c3552016-04-21 00:45:40 +0200890 .function = lisp_gpe_add_del_iface_command_fn,
891};
Florin Coras220beac2016-08-16 23:04:00 +0200892/* *INDENT-ON* */
893
894/*
895 * fd.io coding-style-patch-verification: ON
896 *
897 * Local Variables:
898 * eval: (c-set-style "gnu")
899 * End:
900 */