FD.io VPP  v19.04.2-12-g66b1689
Vector Packet Processing
interface.c
Go to the documentation of this file.
1 /*
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 
16 /**
17  * @file
18  * @brief Common utility functions for LISP-GPE interfaces.
19  *
20  */
21 
22 #include <vppinfra/error.h>
23 #include <vppinfra/hash.h>
24 #include <vnet/vnet.h>
25 #include <vnet/ip/ip.h>
26 #include <vnet/udp/udp.h>
27 #include <vnet/ethernet/ethernet.h>
28 #include <vnet/lisp-gpe/lisp_gpe.h>
32 #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>
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  */
43 
44 #define foreach_lisp_gpe_tx_next \
45  _(DROP, "error-drop") \
46  _(IP4_LOOKUP, "ip4-lookup") \
47  _(IP6_LOOKUP, "ip6-lookup")
48 
49 typedef enum
50 {
51 #define _(sym,str) LISP_GPE_TX_NEXT_##sym,
53 #undef _
56 
57 typedef struct
58 {
61 
62 u8 *
63 format_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 *);
67  lisp_gpe_tx_trace_t *t = va_arg (*args, lisp_gpe_tx_trace_t *);
68 
69  s = format (s, "LISP-GPE-TX: tunnel %d", t->tunnel_index);
70  return s;
71 }
72 
73 #define is_v4_packet(_h) ((*(u8*) _h) & 0xF0) == 0x40
74 
75 /**
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  */
91 static uword
93  vlib_frame_t * from_frame)
94 {
95  u32 n_left_from, next_index, *from, *to_next;
97 
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 
107  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
108 
109  while (n_left_from > 0 && n_left_to_next > 0)
110  {
111  u32 bi0, adj_index0, next0;
112  const ip_adjacency_t *adj0;
113  const dpo_id_t *dpo0;
114  vlib_buffer_t *b0;
115  u8 is_v4_0;
116 
117  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;
123 
124  b0 = vlib_get_buffer (vm, bi0);
125 
126  /* Fixup the checksum and len fields in the LISP tunnel encap
127  * that was applied at the midchain node */
128  is_v4_0 = is_v4_packet (vlib_buffer_get_current (b0));
129  ip_udp_fixup_one (lgm->vlib_main, b0, is_v4_0);
130 
131  /* 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;
137 
138  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));
142  tr->tunnel_index = adj_index0;
143  }
144  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
145  n_left_to_next, bi0, next0);
146  }
147 
148  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
149  }
150 
151  return from_frame->n_vectors;
152 }
153 
154 static u8 *
155 format_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 
161 /* *INDENT-OFF* */
162 VNET_DEVICE_CLASS (lisp_gpe_device_class) = {
163  .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,
167 };
168 /* *INDENT-ON* */
169 
170 u8 *
172 {
173  lisp_gpe_header_t *h = va_arg (*args, lisp_gpe_header_t *);
174  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);
184 #undef _
185 
186  s = format (s, "\n ver_res %d res %d next_protocol %d iid %d(%x)",
187  h->ver_res, h->res, h->next_protocol,
188  clib_net_to_host_u32 (h->iid << 8),
189  clib_net_to_host_u32 (h->iid << 8));
190  return s;
191 }
192 
193 /* *INDENT-OFF* */
195  .name = "LISP_GPE",
196  .format_header = format_lisp_gpe_header_with_length,
197  .build_rewrite = lisp_gpe_build_rewrite,
198  .update_adjacency = lisp_gpe_update_adjacency,
199 };
200 /* *INDENT-ON* */
201 
202 
203 typedef struct
204 {
207 
208 static u8 *
209 format_l2_lisp_gpe_tx_trace (u8 * s, va_list * args)
210 {
211  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
212  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
213  l2_lisp_gpe_tx_trace_t *t = va_arg (*args, l2_lisp_gpe_tx_trace_t *);
214 
215  s = format (s, "L2-LISP-GPE-TX: load-balance %d", t->dpo_index);
216  return s;
217 }
218 
219 /**
220  * @brief LISP-GPE interface TX (encap) function for L2 overlays.
221  * @node l2_lisp_gpe_interface_tx
222  *
223  * The L2 LISP-GPE interface TX (encap) function.
224  *
225  * Uses bridge domain index, source and destination ethernet addresses to
226  * lookup tunnel. If the tunnel is multihomed a flow has is used to determine
227  * the sub-tunnel and therefore the rewrite string to be used to encapsulate
228  * the packets.
229  *
230  * @param[in] vm vlib_main_t corresponding to the current thread.
231  * @param[in] node vlib_node_runtime_t data for this node.
232  * @param[in] frame vlib_frame_t whose contents should be dispatched.
233  *
234  * @return number of vectors in frame.
235  */
236 static uword
238  vlib_frame_t * from_frame)
239 {
240  u32 n_left_from, next_index, *from, *to_next;
242  u32 thread_index = vm->thread_index;
244 
245  from = vlib_frame_vector_args (from_frame);
246  n_left_from = from_frame->n_vectors;
247 
248  next_index = node->cached_next_index;
249 
250  while (n_left_from > 0)
251  {
252  u32 n_left_to_next;
253 
254  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
255 
256  while (n_left_from > 0 && n_left_to_next > 0)
257  {
258  vlib_buffer_t *b0;
259  u32 bi0, lbi0;
260  ethernet_header_t *e0;
261 
262  bi0 = from[0];
263  to_next[0] = bi0;
264  from += 1;
265  to_next += 1;
266  n_left_from -= 1;
267  n_left_to_next -= 1;
268 
269  b0 = vlib_get_buffer (vm, bi0);
270  e0 = vlib_buffer_get_current (b0);
271 
272  vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_MAC;
273 
274  /* lookup dst + src mac */
275  lbi0 = lisp_l2_fib_lookup (lgm, vnet_buffer (b0)->l2.bd_index,
276  e0->src_address, e0->dst_address);
277  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = lbi0;
278 
279  vlib_increment_combined_counter (cm, thread_index, lbi0, 1,
281  b0));
282  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
283  {
284  l2_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
285  sizeof (*tr));
286  tr->dpo_index = lbi0;
287  }
288  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
289  n_left_to_next, bi0, l2_arc_to_lb);
290  }
291 
292  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
293  }
294 
295  return from_frame->n_vectors;
296 }
297 
298 static u8 *
299 format_l2_lisp_gpe_name (u8 * s, va_list * args)
300 {
301  u32 dev_instance = va_arg (*args, u32);
302  return format (s, "l2_lisp_gpe%d", dev_instance);
303 }
304 
305 /* *INDENT-OFF* */
306 VNET_DEVICE_CLASS (l2_lisp_gpe_device_class,static) = {
307  .name = "L2_LISP_GPE",
308  .format_device_name = format_l2_lisp_gpe_name,
309  .format_tx_trace = format_l2_lisp_gpe_tx_trace,
310  .tx_function = l2_lisp_gpe_interface_tx,
311 };
312 /* *INDENT-ON* */
313 
314 typedef struct
315 {
318 
319 u8 *
320 format_nsh_lisp_gpe_tx_trace (u8 * s, va_list * args)
321 {
322  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
323  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
324  nsh_lisp_gpe_tx_trace_t *t = va_arg (*args, nsh_lisp_gpe_tx_trace_t *);
325 
326  s = format (s, "NSH-GPE-TX: tunnel %d", t->dpo_index);
327  return s;
328 }
329 
330 /**
331  * @brief LISP-GPE interface TX for NSH overlays.
332  * @node nsh_lisp_gpe_interface_tx
333  *
334  * The NSH LISP-GPE interface TX function.
335  *
336  * @param[in] vm vlib_main_t corresponding to the current thread.
337  * @param[in] node vlib_node_runtime_t data for this node.
338  * @param[in] frame vlib_frame_t whose contents should be dispatched.
339  *
340  * @return number of vectors in frame.
341  */
342 static uword
344  vlib_frame_t * from_frame)
345 {
346  u32 n_left_from, next_index, *from, *to_next;
348 
349  from = vlib_frame_vector_args (from_frame);
350  n_left_from = from_frame->n_vectors;
351 
352  next_index = node->cached_next_index;
353 
354  while (n_left_from > 0)
355  {
356  u32 n_left_to_next;
357 
358  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
359 
360  while (n_left_from > 0 && n_left_to_next > 0)
361  {
362  vlib_buffer_t *b0;
363  u32 bi0;
364  u32 *nsh0, next0;
365  const dpo_id_t *dpo0;
366 
367  bi0 = from[0];
368  to_next[0] = bi0;
369  from += 1;
370  to_next += 1;
371  n_left_from -= 1;
372  n_left_to_next -= 1;
373 
374  b0 = vlib_get_buffer (vm, bi0);
375  nsh0 = vlib_buffer_get_current (b0);
376 
377  vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_LCAF;
378 
379  /* lookup SPI + SI (second word of the NSH header).
380  * NB: Load balancing was done by the control plane */
381  dpo0 = lisp_nsh_fib_lookup (lgm, nsh0[1]);
382 
383  next0 = dpo0->dpoi_next_node;
384  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
385 
386  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
387  {
388  nsh_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
389  sizeof (*tr));
390  tr->dpo_index = dpo0->dpoi_index;
391  }
392  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
393  n_left_to_next, bi0, next0);
394  }
395 
396  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
397  }
398 
399  return from_frame->n_vectors;
400 }
401 
402 static u8 *
403 format_nsh_lisp_gpe_name (u8 * s, va_list * args)
404 {
405  u32 dev_instance = va_arg (*args, u32);
406  return format (s, "nsh_lisp_gpe%d", dev_instance);
407 }
408 
409 /* *INDENT-OFF* */
410 VNET_DEVICE_CLASS (nsh_lisp_gpe_device_class,static) = {
411  .name = "NSH_LISP_GPE",
412  .format_device_name = format_nsh_lisp_gpe_name,
413  .format_tx_trace = format_nsh_lisp_gpe_tx_trace,
414  .tx_function = nsh_lisp_gpe_interface_tx,
415 };
416 /* *INDENT-ON* */
417 
418 static vnet_hw_interface_t *
420  vnet_device_class_t * dev_class,
421  tunnel_lookup_t * tuns)
422 {
423  u32 flen;
424  u32 hw_if_index = ~0;
425  u8 *new_name;
427  vnet_main_t *vnm = lgm->vnet_main;
428 
429  /* create hw lisp_gpeX iface if needed, otherwise reuse existing */
430  flen = vec_len (lgm->free_tunnel_hw_if_indices);
431  if (flen > 0)
432  {
433  hw_if_index = lgm->free_tunnel_hw_if_indices[flen - 1];
434  _vec_len (lgm->free_tunnel_hw_if_indices) -= 1;
435 
436  hi = vnet_get_hw_interface (vnm, hw_if_index);
437 
438  /* rename interface */
439  new_name = format (0, "%U", dev_class->format_device_name, vni);
440 
441  vec_add1 (new_name, 0);
442  vnet_rename_interface (vnm, hw_if_index, (char *) new_name);
443  vec_free (new_name);
444 
445  /* clear old stats of freed interface before reuse */
450  hi->sw_if_index);
453  hi->sw_if_index);
456  hi->sw_if_index);
458  }
459  else
460  {
461  hw_if_index = vnet_register_interface (vnm, dev_class->index, vni,
462  lisp_gpe_hw_class.index, 0);
463  hi = vnet_get_hw_interface (vnm, hw_if_index);
464  }
465 
466  hash_set (tuns->hw_if_index_by_dp_table, dp_table, hw_if_index);
467 
468  /* set tunnel termination: post decap, packets are tagged as having been
469  * originated by lisp-gpe interface */
470  hash_set (tuns->sw_if_index_by_vni, vni, hi->sw_if_index);
471  hash_set (tuns->vni_by_sw_if_index, hi->sw_if_index, vni);
472 
473  return hi;
474 }
475 
476 static void
477 lisp_gpe_remove_iface (lisp_gpe_main_t * lgm, u32 hi_index, u32 dp_table,
478  tunnel_lookup_t * tuns)
479 {
480  vnet_main_t *vnm = lgm->vnet_main;
482  uword *vnip;
483 
484  hi = vnet_get_hw_interface (vnm, hi_index);
485 
486  /* disable interface */
487  vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 0 /* down */ );
488  vnet_hw_interface_set_flags (vnm, hi->hw_if_index, 0 /* down */ );
489  hash_unset (tuns->hw_if_index_by_dp_table, dp_table);
491 
492  /* clean tunnel termination and vni to sw_if_index binding */
493  vnip = hash_get (tuns->vni_by_sw_if_index, hi->sw_if_index);
494  if (0 == vnip)
495  {
496  clib_warning ("No vni associated to interface %d", hi->sw_if_index);
497  return;
498  }
499  hash_unset (tuns->sw_if_index_by_vni, vnip[0]);
501 }
502 
503 static void
505 {
506  fib_node_index_t fib_index;
507 
512  ip4_sw_interface_enable_disable (sw_if_index, 1);
513 
518  ip6_sw_interface_enable_disable (sw_if_index, 1);
519 }
520 
521 static void
523 {
524  fib_protocol_t proto;
525 
527  {
528  fib_prefix_t prefix = {
529  .fp_proto = proto,
530  };
531  u32 fib_index;
532 
533  fib_index = fib_table_find (prefix.fp_proto, table_id);
534  fib_table_entry_special_remove (fib_index, &prefix, FIB_SOURCE_LISP);
535  fib_table_unlock (fib_index, prefix.fp_proto, FIB_SOURCE_LISP);
536  }
537 }
538 
539 static void
541 {
542  fib_protocol_t proto;
543 
545  {
546  fib_prefix_t prefix = {
547  .fp_proto = proto,
548  };
549  u32 fib_index;
550 
551  /*
552  * Add a deafult route that results in a control plane punt DPO
553  */
554  fib_index = fib_table_find_or_create_and_lock (prefix.fp_proto, table_id,
559  (proto)));
560  }
561 }
562 
563 
564 /**
565  * @brief Add/del LISP-GPE L3 interface.
566  *
567  * Creates LISP-GPE interface, sets ingress arcs from lisp_gpeX_lookup,
568  * installs default routes that attract all traffic with no more specific
569  * routes to lgpe-ipx-lookup, set egress arcs to ipx-lookup, sets
570  * the interface in the right vrf and enables it.
571  *
572  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
573  * @param[in] a Parameters to create interface.
574  *
575  * @return number of vectors in frame.
576  */
577 u32
579  u8 with_default_routes)
580 {
581  vnet_main_t *vnm = lgm->vnet_main;
582  tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
584  uword *hip, *si;
585 
586  hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
587 
588  if (hip)
589  {
590  clib_warning ("vrf %d already mapped to a vni", table_id);
591  return ~0;
592  }
593 
594  si = hash_get (l3_ifaces->sw_if_index_by_vni, vni);
595 
596  if (si)
597  {
598  clib_warning ("Interface for vni %d already exists", vni);
599  }
600 
601  /* create lisp iface and populate tunnel tables */
602  hi = lisp_gpe_create_iface (lgm, vni, table_id,
603  &lisp_gpe_device_class, l3_ifaces);
604 
605  /* insert default routes that point to lisp-cp lookup */
606  lisp_gpe_iface_set_table (hi->sw_if_index, table_id);
607  if (with_default_routes)
609 
610  /* enable interface */
615 
616  return (hi->sw_if_index);
617 }
618 
619 void
621 {
622  vnet_main_t *vnm = lgm->vnet_main;
623  tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
625  uword *hip;
626 
627  hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
628 
629  if (hip == 0)
630  {
631  clib_warning ("The interface for vrf %d doesn't exist", table_id);
632  return;
633  }
634 
635  hi = vnet_get_hw_interface (vnm, hip[0]);
636 
637  lisp_gpe_remove_iface (lgm, hip[0], table_id, &lgm->l3_ifaces);
638 
639  /* unset default routes */
643 }
644 
645 /**
646  * @brief Add/del LISP-GPE L2 interface.
647  *
648  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
649  * bridge domain, sets egress arcs and enables it.
650  *
651  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
652  * @param[in] a Parameters to create interface.
653  *
654  * @return number of vectors in frame.
655  */
656 u32
658 {
659  vnet_main_t *vnm = lgm->vnet_main;
660  tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
662  uword *hip, *si;
663  u16 bd_index;
664 
665  if (bd_id > L2_BD_ID_MAX)
666  {
667  clib_warning ("bridge domain ID %d exceed 16M limit", bd_id);
668  return ~0;
669  }
670 
671  bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
672  hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
673 
674  if (hip)
675  {
676  clib_warning ("bridge domain %d already mapped to a vni", bd_id);
677  return ~0;
678  }
679 
680  si = hash_get (l2_ifaces->sw_if_index_by_vni, vni);
681  if (si)
682  {
683  clib_warning ("Interface for vni %d already exists", vni);
684  return ~0;
685  }
686 
687  /* create lisp iface and populate tunnel tables */
688  hi = lisp_gpe_create_iface (lgm, vni, bd_index,
689  &l2_lisp_gpe_device_class, &lgm->l2_ifaces);
690 
691  /* enable interface */
696 
698  hi->tx_node_index,
699  "l2-load-balance");
700 
701  /* we're ready. add iface to l2 bridge domain */
703  bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
704 
705  return (hi->sw_if_index);
706 }
707 
708 /**
709  * @brief Add/del LISP-GPE L2 interface.
710  *
711  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
712  * bridge domain, sets egress arcs and enables it.
713  *
714  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
715  * @param[in] a Parameters to create interface.
716  *
717  * @return number of vectors in frame.
718  */
719 void
721 {
722  tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
724 
725  u32 bd_index = bd_find_index (&bd_main, bd_id);
726  ASSERT (bd_index != ~0);
727  uword *hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
728 
729  if (hip == 0)
730  {
731  clib_warning ("The interface for bridge domain %d doesn't exist",
732  bd_id);
733  return;
734  }
735 
736  /* Remove interface from bridge .. by enabling L3 mode */
737  hi = vnet_get_hw_interface (lgm->vnet_main, hip[0]);
739  0, L2_BD_PORT_TYPE_NORMAL, 0, 0);
740  lisp_gpe_remove_iface (lgm, hip[0], bd_index, &lgm->l2_ifaces);
741 }
742 
743 /**
744  * @brief Add LISP-GPE NSH interface.
745  *
746  * Creates LISP-GPE interface, sets it in L3 mode.
747  *
748  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
749  * @param[in] a Parameters to create interface.
750  *
751  * @return sw_if_index.
752  */
753 u32
755 {
756  vnet_main_t *vnm = lgm->vnet_main;
757  tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
759  uword *hip, *si;
760 
761  hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
762 
763  if (hip)
764  {
765  clib_warning ("NSH interface 0 already exists");
766  return ~0;
767  }
768 
769  si = hash_get (nsh_ifaces->sw_if_index_by_vni, 0);
770  if (si)
771  {
772  clib_warning ("NSH interface already exists");
773  return ~0;
774  }
775 
776  /* create lisp iface and populate tunnel tables */
777  hi = lisp_gpe_create_iface (lgm, 0, 0,
778  &nsh_lisp_gpe_device_class, &lgm->nsh_ifaces);
779 
780  /* enable interface */
785 
786  return (hi->sw_if_index);
787 }
788 
789 /**
790  * @brief Del LISP-GPE NSH interface.
791  *
792  */
793 void
795 {
796  tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
797  uword *hip;
798 
799  hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
800 
801  if (hip == 0)
802  {
803  clib_warning ("The NSH 0 interface doesn't exist");
804  return;
805  }
806  lisp_gpe_remove_iface (lgm, hip[0], 0, &lgm->nsh_ifaces);
807 }
808 
809 static clib_error_t *
811  vlib_cli_command_t * cmd)
812 {
813  unformat_input_t _line_input, *line_input = &_line_input;
814  u8 is_add = 1;
815  u32 table_id, vni, bd_id;
816  u8 vni_is_set = 0, vrf_is_set = 0, bd_index_is_set = 0;
817  u8 nsh_iface = 0;
818  clib_error_t *error = NULL;
819 
821  {
822  return clib_error_return (0, "LISP is disabled");
823  }
824 
825  /* Get a line of input. */
826  if (!unformat_user (input, unformat_line_input, line_input))
827  return 0;
828 
829  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
830  {
831  if (unformat (line_input, "add"))
832  is_add = 1;
833  else if (unformat (line_input, "del"))
834  is_add = 0;
835  else if (unformat (line_input, "vrf %d", &table_id))
836  {
837  vrf_is_set = 1;
838  }
839  else if (unformat (line_input, "vni %d", &vni))
840  {
841  vni_is_set = 1;
842  }
843  else if (unformat (line_input, "bd %d", &bd_id))
844  {
845  bd_index_is_set = 1;
846  }
847  else if (unformat (line_input, "nsh"))
848  {
849  nsh_iface = 1;
850  }
851  else
852  {
853  error = clib_error_return (0, "parse error: '%U'",
854  format_unformat_error, line_input);
855  goto done;
856  }
857  }
858 
859  if (nsh_iface)
860  {
861  if (is_add)
862  {
864  {
865  error = clib_error_return (0, "NSH interface not created");
866  goto done;
867  }
868  }
869  else
870  {
872  }
873  goto done;
874  }
875 
876  if (vrf_is_set && bd_index_is_set)
877  {
878  error = clib_error_return
879  (0, "Cannot set both vrf and brdige domain index!");
880  goto done;
881  }
882 
883  if (!vni_is_set)
884  {
885  error = clib_error_return (0, "vni must be set!");
886  goto done;
887  }
888 
889  if (!vrf_is_set && !bd_index_is_set)
890  {
891  error =
892  clib_error_return (0, "vrf or bridge domain index must be set!");
893  goto done;
894  }
895 
896  if (bd_index_is_set)
897  {
898  if (is_add)
899  {
900  if (~0 == lisp_gpe_tenant_l2_iface_add_or_lock (vni, bd_id))
901  {
902  error = clib_error_return (0, "L2 interface not created");
903  goto done;
904  }
905  }
906  else
908  }
909  else
910  {
911  if (is_add)
912  {
913  if (~0 == lisp_gpe_tenant_l3_iface_add_or_lock (vni, table_id, 1
914  /* with_default_route */
915  ))
916  {
917  error = clib_error_return (0, "L3 interface not created");
918  goto done;
919  }
920  }
921  else
923  }
924 
925 done:
926  unformat_free (line_input);
927 
928  return error;
929 }
930 
931 /* *INDENT-OFF* */
932 VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command, static) = {
933  .path = "gpe iface",
934  .short_help = "gpe iface add/del vni <vni> vrf <vrf>",
936 };
937 /* *INDENT-ON* */
938 
939 /*
940  * fd.io coding-style-patch-verification: ON
941  *
942  * Local Variables:
943  * eval: (c-set-style "gnu")
944  * End:
945  */
void lisp_gpe_tenant_l2_iface_unlock(u32 vni)
Release the lock held on the tenant&#39;s L3 interface.
static uword nsh_lisp_gpe_interface_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
LISP-GPE interface TX for NSH overlays.
Definition: interface.c:343
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
u32 sw_if_index
Definition: ipsec_gre.api:37
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:212
#define is_v4_packet(_h)
Definition: interface.c:73
u32 * free_tunnel_hw_if_indices
Free vlib hw_if_indices.
Definition: lisp_gpe.h:132
vmrglw vmrglh hi
vlib_combined_counter_main_t lbm_to_counters
Definition: load_balance.h:46
#define hash_set(h, key, value)
Definition: hash.h:255
#define CLIB_UNUSED(x)
Definition: clib.h:82
struct ip_adjacency_t_::@46::@48 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
#define hash_unset(h, key)
Definition: hash.h:261
u32 lisp_gpe_add_l2_iface(lisp_gpe_main_t *lgm, u32 vni, u32 bd_id)
Add/del LISP-GPE L2 interface.
Definition: interface.c:657
const dpo_id_t * lisp_cp_dpo_get(dpo_proto_t proto)
Definition: lisp_cp_dpo.c:26
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:220
u8 vnet_lisp_gpe_enable_disable_status(void)
Check if LISP-GPE is enabled.
Definition: lisp_gpe.c:184
static u8 * format_l2_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:209
void lisp_gpe_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, adj_index_t ai)
The LISP-GPE interface registered function to update, i.e.
#define foreach_lisp_gpe_tx_next
Definition: interface.c:44
static u8 * format_nsh_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:403
static uword l2_arc_to_lb
The VLIB node arc/edge from the interface&#39;s TX node, to the L2 load-balanceing node.
Definition: interface.c:42
vnet_interface_main_t interface_main
Definition: vnet.h:56
void lisp_gpe_tenant_l3_iface_unlock(u32 vni)
Release the lock held on the tenant&#39;s L3 interface.
static uword vlib_node_add_named_next(vlib_main_t *vm, uword node, char *name)
Definition: node_funcs.h:1134
#define NULL
Definition: clib.h:58
IP unicast adjacency.
Definition: adj.h:221
u32 vnet_lisp_gpe_add_nsh_iface(lisp_gpe_main_t *lgm)
Add LISP-GPE NSH interface.
Definition: interface.c:754
u8 src_address[6]
Definition: packet.h:56
LISP-GPE global state.
Definition: lisp_gpe.h:118
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 thread_index
Definition: main.h:197
static clib_error_t * lisp_gpe_add_del_iface_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: interface.c:810
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
LISP-GPE definitions.
static u8 * format_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:155
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
vnet_hw_interface_class_t lisp_gpe_hw_class
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:112
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
struct _vnet_device_class vnet_device_class_t
uword * vni_by_sw_if_index
Definition: lisp_gpe.h:90
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:366
unsigned char u8
Definition: types.h:56
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u8 * format_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:63
vlib_main_t * vlib_main
convenience
Definition: lisp_gpe.h:171
void lisp_gpe_del_l3_iface(lisp_gpe_main_t *lgm, u32 vni, u32 table_id)
Definition: interface.c:620
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:433
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a &#39;special&#39; entry from the FIB.
Definition: fib_table.c:407
#define MODE_L2_BRIDGE
Definition: l2_input.h:211
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:824
u8 dst_address[6]
Definition: packet.h:55
Aggregrate type for a prefix.
Definition: fib_types.h:203
#define clib_error_return(e, args...)
Definition: error.h:99
u32 lisp_gpe_add_l3_iface(lisp_gpe_main_t *lgm, u32 vni, u32 table_id, u8 with_default_routes)
Add/del LISP-GPE L3 interface.
Definition: interface.c:578
u8 * lisp_gpe_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
unsigned int u32
Definition: types.h:88
u32 lisp_gpe_tenant_l2_iface_add_or_lock(u32 vni, u32 bd_id)
Add/create and lock a new or find and lock the existing L2 interface for the tenant.
u32 fib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1064
u32 vnet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u32 hw_class_index, u32 hw_instance)
Definition: interface.c:740
u8 * format_lisp_gpe_header_with_length(u8 *s, va_list *args)
Definition: interface.c:171
Common utility functions for IPv4, IPv6 and L2 LISP-GPE adjacencys.
unformat_function_t unformat_line_input
Definition: format.h:282
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:168
void vnet_lisp_gpe_del_nsh_iface(lisp_gpe_main_t *lgm)
Del LISP-GPE NSH interface.
Definition: interface.c:794
#define hash_get(h, key)
Definition: hash.h:249
Definition: fib_entry.h:279
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread counters.
Definition: counter.h:285
void ip4_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip4_forward.c:525
u32 lisp_gpe_tenant_l3_iface_add_or_lock(u32 vni, u32 table_id, u8 with_default_route)
Add/create and lock a new or find and lock the existing L3 interface for the tenant.
u32 bd_id
Definition: gbp.api:269
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
static void lisp_gpe_tenant_add_default_routes(u32 table_id)
Definition: interface.c:540
#define PREDICT_FALSE(x)
Definition: clib.h:111
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:823
load_balance_main_t load_balance_main
The one instance of load-balance main.
Definition: load_balance.c:55
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:218
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:368
void fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
Definition: fib_table.c:1237
uword * sw_if_index_by_vni
lookup decap tunnel termination sw_if_index by vni and vice versa
Definition: lisp_gpe.h:87
clib_error_t * vnet_rename_interface(vnet_main_t *vnm, u32 hw_if_index, char *new_name)
Definition: interface.c:1384
VNET_HW_INTERFACE_CLASS(ethernet_hw_interface_class)
static void ip_udp_fixup_one(vlib_main_t *vm, vlib_buffer_t *b0, u8 is_ip4)
Definition: udp.h:283
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
u16 n_vectors
Definition: node.h:395
vlib_main_t * vm
Definition: buffer.c:312
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
tunnel_lookup_t l2_ifaces
Definition: lisp_gpe.h:146
vnet_main_t * vnet_main
Definition: lisp_gpe.h:172
#define clib_warning(format, args...)
Definition: error.h:59
void lisp_gpe_del_l2_iface(lisp_gpe_main_t *lgm, u32 vni, u32 bd_id)
Add/del LISP-GPE L2 interface.
Definition: interface.c:720
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:855
static void lisp_gpe_remove_iface(lisp_gpe_main_t *lgm, u32 hi_index, u32 dp_table, tunnel_lookup_t *tuns)
Definition: interface.c:477
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:465
LISP-GPE header.
lisp_gpe_main_t lisp_gpe_main
LISP-GPE global state.
Definition: lisp_gpe.c:30
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
fib_node_index_t fib_table_entry_special_dpo_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Add a &#39;special&#39; entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
Definition: fib_table.c:307
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:847
static void lisp_gpe_iface_set_table(u32 sw_if_index, u32 table_id)
Definition: interface.c:504
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:514
#define L2_BD_ID_MAX
Definition: l2_bd.h:116
static u32 bd_find_or_add_bd_index(bd_main_t *bdm, u32 bd_id)
Get or create a bridge domain.
Definition: l2_bd.h:194
#define ASSERT(truth)
ip6_main_t ip6_main
Definition: ip6_forward.c:2688
u8 is_add
Definition: ipsec_gre.api:36
uword * hw_if_index_by_dp_table
Lookup lisp-gpe interfaces by dp table (eg.
Definition: lisp_gpe.h:84
u32 set_int_l2_mode(vlib_main_t *vm, vnet_main_t *vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, l2_bd_port_type_t port_type, u32 shg, u32 xc_sw_if_index)
Set the subinterface to run in l2 or l3 mode.
Definition: l2_input.c:589
u32 fib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, fib_source_t src)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1123
u8 * format_nsh_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:320
static void vlib_zero_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Clear a simple counter Clears the set of per-thread u16 counters, and the u64 counter.
Definition: counter.h:139
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:237
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:57
static uword l2_lisp_gpe_interface_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
LISP-GPE interface TX (encap) function for L2 overlays.
Definition: interface.c:237
Definition: defs.h:47
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:184
union ip_adjacency_t_::@46 sub_type
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
tunnel_lookup_t l3_ifaces
Definition: lisp_gpe.h:138
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_interface_flags_t flags)
Definition: interface.c:504
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:274
u32 vni
Definition: vxlan_gbp.api:42
A collection of combined counters.
Definition: counter.h:188
typedef prefix
Definition: ip_types.api:35
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:70
#define vnet_buffer(b)
Definition: buffer.h:369
index_t lisp_l2_fib_lookup(lisp_gpe_main_t *lgm, u16 bd_index, u8 src_mac[6], u8 dst_mac[6])
Lookup L2 SD FIB entry.
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
static uword lisp_gpe_interface_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
LISP-GPE interface TX (encap) function.
Definition: interface.c:92
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:905
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, vnet_sw_interface_flags_t flags)
Definition: interface.c:513
LISP.
Definition: fib_entry.h:86
static u8 * format_l2_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:299
u32 bd_find_index(bd_main_t *bdm, u32 bd_id)
Get a bridge domain.
Definition: l2_bd.c:69
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:180
VNET_DEVICE_CLASS(ethernet_simulated_device_class)
bd_main_t bd_main
Definition: l2_bd.c:44
lisp_gpe_tx_next_t
Definition: interface.c:49
tunnel_lookup_t nsh_ifaces
Definition: lisp_gpe.h:156
u32 * fib_index_by_sw_if_index
Definition: ip6.h:194
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
const dpo_id_t * lisp_nsh_fib_lookup(lisp_gpe_main_t *lgm, u32 spi_si_net_order)
Lookup NSH SD FIB entry.
static vnet_hw_interface_t * lisp_gpe_create_iface(lisp_gpe_main_t *lgm, u32 vni, u32 dp_table, vnet_device_class_t *dev_class, tunnel_lookup_t *tuns)
Definition: interface.c:419
static void lisp_gpe_tenant_del_default_routes(u32 table_id)
Definition: interface.c:522
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:146
LISP-GPE definitions.
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
#define MODE_L3
Definition: l2_input.h:210