FD.io VPP  v21.10.1-2-g0a485f517
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_inlines.h>
27 #include <vnet/ethernet/ethernet.h>
28 #include <lisp/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
94 {
95  u32 n_left_from, next_index, *from, *to_next;
97 
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  {
141  sizeof (*tr));
142  tr->tunnel_index = adj_index0;
143  }
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
239 {
240  u32 n_left_from, next_index, *from, *to_next;
244 
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 
281  b0));
282  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
283  {
285  sizeof (*tr));
286  tr->dpo_index = lbi0;
287  }
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
345 {
346  u32 n_left_from, next_index, *from, *to_next;
348 
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  {
389  sizeof (*tr));
390  tr->dpo_index = dpo0->dpoi_index;
391  }
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
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 */ );
490  vec_add1 (lgm->free_tunnel_hw_if_indices, hi->hw_if_index);
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]);
500  hash_unset (tuns->vni_by_sw_if_index, hi->sw_if_index);
501 }
502 
503 static void
505 {
506  fib_node_index_t fib_index;
507 
512 
517 }
518 
519 static void
521 {
523 
525  {
526  fib_prefix_t prefix = {
527  .fp_proto = proto,
528  };
529  u32 fib_index;
530 
531  fib_index = fib_table_find (prefix.fp_proto, table_id);
533  fib_table_unlock (fib_index, prefix.fp_proto, FIB_SOURCE_LISP);
534  }
535 }
536 
537 static void
539 {
541 
543  {
544  fib_prefix_t prefix = {
545  .fp_proto = proto,
546  };
547  u32 fib_index;
548 
549  /*
550  * Add a deafult route that results in a control plane punt DPO
551  */
552  fib_index = fib_table_find_or_create_and_lock (prefix.fp_proto, table_id,
557  (proto)));
558  }
559 }
560 
561 
562 /**
563  * @brief Add/del LISP-GPE L3 interface.
564  *
565  * Creates LISP-GPE interface, sets ingress arcs from lisp_gpeX_lookup,
566  * installs default routes that attract all traffic with no more specific
567  * routes to lgpe-ipx-lookup, set egress arcs to ipx-lookup, sets
568  * the interface in the right vrf and enables it.
569  *
570  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
571  * @param[in] a Parameters to create interface.
572  *
573  * @return number of vectors in frame.
574  */
575 u32
577  u8 with_default_routes)
578 {
579  vnet_main_t *vnm = lgm->vnet_main;
580  tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
582  uword *hip, *si;
583 
584  hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
585 
586  if (hip)
587  {
588  clib_warning ("vrf %d already mapped to a vni", table_id);
589  return ~0;
590  }
591 
592  si = hash_get (l3_ifaces->sw_if_index_by_vni, vni);
593 
594  if (si)
595  {
596  clib_warning ("Interface for vni %d already exists", vni);
597  }
598 
599  /* create lisp iface and populate tunnel tables */
601  &lisp_gpe_device_class, l3_ifaces);
602 
603  /* insert default routes that point to lisp-cp lookup */
604  lisp_gpe_iface_set_table (hi->sw_if_index, table_id);
605  if (with_default_routes)
607 
608  /* enable interface */
609  vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
611  vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
613 
614  return (hi->sw_if_index);
615 }
616 
617 void
619 {
620  vnet_main_t *vnm = lgm->vnet_main;
621  tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
623  uword *hip;
624 
625  hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
626 
627  if (hip == 0)
628  {
629  clib_warning ("The interface for vrf %d doesn't exist", table_id);
630  return;
631  }
632 
633  hi = vnet_get_hw_interface (vnm, hip[0]);
634 
635  lisp_gpe_remove_iface (lgm, hip[0], table_id, &lgm->l3_ifaces);
636 
637  /* unset default routes */
638  ip4_sw_interface_enable_disable (hi->sw_if_index, 0);
639  ip6_sw_interface_enable_disable (hi->sw_if_index, 0);
641 }
642 
643 /**
644  * @brief Add/del LISP-GPE L2 interface.
645  *
646  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
647  * bridge domain, sets egress arcs and enables it.
648  *
649  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
650  * @param[in] a Parameters to create interface.
651  *
652  * @return number of vectors in frame.
653  */
654 u32
656 {
657  vnet_main_t *vnm = lgm->vnet_main;
658  tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
660  uword *hip, *si;
661  u16 bd_index;
662 
663  if (bd_id > L2_BD_ID_MAX)
664  {
665  clib_warning ("bridge domain ID %d exceed 16M limit", bd_id);
666  return ~0;
667  }
668 
669  bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
670  hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
671 
672  if (hip)
673  {
674  clib_warning ("bridge domain %d already mapped to a vni", bd_id);
675  return ~0;
676  }
677 
678  si = hash_get (l2_ifaces->sw_if_index_by_vni, vni);
679  if (si)
680  {
681  clib_warning ("Interface for vni %d already exists", vni);
682  return ~0;
683  }
684 
685  /* create lisp iface and populate tunnel tables */
686  hi = lisp_gpe_create_iface (lgm, vni, bd_index,
687  &l2_lisp_gpe_device_class, &lgm->l2_ifaces);
688 
689  /* enable interface */
690  vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
692  vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
694 
696  hi->tx_node_index,
697  "l2-load-balance");
698 
699  /* we're ready. add iface to l2 bridge domain */
700  set_int_l2_mode (lgm->vlib_main, vnm, MODE_L2_BRIDGE, hi->sw_if_index,
701  bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
702 
703  return (hi->sw_if_index);
704 }
705 
706 /**
707  * @brief Add/del LISP-GPE L2 interface.
708  *
709  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
710  * bridge domain, sets egress arcs and enables it.
711  *
712  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
713  * @param[in] a Parameters to create interface.
714  *
715  * @return number of vectors in frame.
716  */
717 void
719 {
720  tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
722 
723  u32 bd_index = bd_find_index (&bd_main, bd_id);
724  ASSERT (bd_index != ~0);
725  uword *hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
726 
727  if (hip == 0)
728  {
729  clib_warning ("The interface for bridge domain %d doesn't exist",
730  bd_id);
731  return;
732  }
733 
734  /* Remove interface from bridge .. by enabling L3 mode */
735  hi = vnet_get_hw_interface (lgm->vnet_main, hip[0]);
736  set_int_l2_mode (lgm->vlib_main, lgm->vnet_main, MODE_L3, hi->sw_if_index,
737  0, L2_BD_PORT_TYPE_NORMAL, 0, 0);
738  lisp_gpe_remove_iface (lgm, hip[0], bd_index, &lgm->l2_ifaces);
739 }
740 
741 /**
742  * @brief Add LISP-GPE NSH interface.
743  *
744  * Creates LISP-GPE interface, sets it in L3 mode.
745  *
746  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
747  * @param[in] a Parameters to create interface.
748  *
749  * @return sw_if_index.
750  */
751 u32
753 {
754  vnet_main_t *vnm = lgm->vnet_main;
755  tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
757  uword *hip, *si;
758 
759  hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
760 
761  if (hip)
762  {
763  clib_warning ("NSH interface 0 already exists");
764  return ~0;
765  }
766 
767  si = hash_get (nsh_ifaces->sw_if_index_by_vni, 0);
768  if (si)
769  {
770  clib_warning ("NSH interface already exists");
771  return ~0;
772  }
773 
774  /* create lisp iface and populate tunnel tables */
775  hi = lisp_gpe_create_iface (lgm, 0, 0,
776  &nsh_lisp_gpe_device_class, &lgm->nsh_ifaces);
777 
778  /* enable interface */
779  vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
781  vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
783 
784  return (hi->sw_if_index);
785 }
786 
787 /**
788  * @brief Del LISP-GPE NSH interface.
789  *
790  */
791 void
793 {
794  tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
795  uword *hip;
796 
797  hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
798 
799  if (hip == 0)
800  {
801  clib_warning ("The NSH 0 interface doesn't exist");
802  return;
803  }
804  lisp_gpe_remove_iface (lgm, hip[0], 0, &lgm->nsh_ifaces);
805 }
806 
807 static clib_error_t *
809  vlib_cli_command_t * cmd)
810 {
811  unformat_input_t _line_input, *line_input = &_line_input;
812  u8 is_add = 1;
813  u32 table_id, vni, bd_id;
814  u8 vni_is_set = 0, vrf_is_set = 0, bd_index_is_set = 0;
815  u8 nsh_iface = 0;
816  clib_error_t *error = NULL;
817 
819  {
820  return clib_error_return (0, "LISP is disabled");
821  }
822 
823  /* Get a line of input. */
824  if (!unformat_user (input, unformat_line_input, line_input))
825  return 0;
826 
827  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
828  {
829  if (unformat (line_input, "add"))
830  is_add = 1;
831  else if (unformat (line_input, "del"))
832  is_add = 0;
833  else if (unformat (line_input, "vrf %d", &table_id))
834  {
835  vrf_is_set = 1;
836  }
837  else if (unformat (line_input, "vni %d", &vni))
838  {
839  vni_is_set = 1;
840  }
841  else if (unformat (line_input, "bd %d", &bd_id))
842  {
843  bd_index_is_set = 1;
844  }
845  else if (unformat (line_input, "nsh"))
846  {
847  nsh_iface = 1;
848  }
849  else
850  {
851  error = clib_error_return (0, "parse error: '%U'",
852  format_unformat_error, line_input);
853  goto done;
854  }
855  }
856 
857  if (nsh_iface)
858  {
859  if (is_add)
860  {
862  {
863  error = clib_error_return (0, "NSH interface not created");
864  goto done;
865  }
866  }
867  else
868  {
870  }
871  goto done;
872  }
873 
874  if (vrf_is_set && bd_index_is_set)
875  {
877  (0, "Cannot set both vrf and brdige domain index!");
878  goto done;
879  }
880 
881  if (!vni_is_set)
882  {
883  error = clib_error_return (0, "vni must be set!");
884  goto done;
885  }
886 
887  if (!vrf_is_set && !bd_index_is_set)
888  {
889  error =
890  clib_error_return (0, "vrf or bridge domain index must be set!");
891  goto done;
892  }
893 
894  if (bd_index_is_set)
895  {
896  if (is_add)
897  {
899  {
900  error = clib_error_return (0, "L2 interface not created");
901  goto done;
902  }
903  }
904  else
906  }
907  else
908  {
909  if (is_add)
910  {
912  /* with_default_route */
913  ))
914  {
915  error = clib_error_return (0, "L3 interface not created");
916  goto done;
917  }
918  }
919  else
921  }
922 
923 done:
924  unformat_free (line_input);
925 
926  return error;
927 }
928 
929 /* *INDENT-OFF* */
931  .path = "gpe iface",
932  .short_help = "gpe iface add/del vni <vni> vrf <vrf>",
934 };
935 /* *INDENT-ON* */
936 
937 /*
938  * fd.io coding-style-patch-verification: ON
939  *
940  * Local Variables:
941  * eval: (c-set-style "gnu")
942  * End:
943  */
lisp_gpe_add_del_iface_command_fn
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:808
dpo_id_t_::dpoi_next_node
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:186
lisp_gpe_create_iface
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
im
vnet_interface_main_t * im
Definition: interface_output.c:415
tunnel_lookup::vni_by_sw_if_index
uword * vni_by_sw_if_index
Definition: lisp_gpe.h:91
adj.h
vnet_sw_interface_set_flags
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:523
dpo_id_t_::dpoi_index
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:190
unformat_user
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
hash_set
#define hash_set(h, key, value)
Definition: hash.h:255
thread_index
u32 thread_index
Definition: nat44_ei_hairpinning.c:495
fib_table_entry_special_dpo_add
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 'special' entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
Definition: fib_table.c:324
format_lisp_gpe_header_with_length
u8 * format_lisp_gpe_header_with_length(u8 *s, va_list *args)
Definition: interface.c:171
vnet_device_class_t
struct _vnet_device_class vnet_device_class_t
lisp_gpe_interface_tx
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
VNET_DEVICE_CLASS
VNET_DEVICE_CLASS(ethernet_simulated_device_class)
lisp_gpe_update_adjacency
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.
Definition: lisp_gpe_adjacency.c:296
VNET_INTERFACE_COUNTER_TX
@ VNET_INTERFACE_COUNTER_TX
Definition: interface.h:919
next_index
nat44_ei_hairpin_src_next_t next_index
Definition: nat44_ei_hairpinning.c:412
FOR_EACH_FIB_IP_PROTOCOL
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:69
ip4_main
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1104
lisp_gpe_tenant_del_default_routes
static void lisp_gpe_tenant_del_default_routes(u32 table_id)
Definition: interface.c:520
vlib_get_buffer
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:111
lisp_l2_fib_lookup
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.
Definition: lisp_gpe_fwd_entry.c:644
ip4_sw_interface_enable_disable
void ip4_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip4_forward.c:602
unformat_line_input
unformat_function_t unformat_line_input
Definition: format.h:275
ethernet_header_t::dst_address
u8 dst_address[6]
Definition: packet.h:55
ethernet_header_t::src_address
u8 src_address[6]
Definition: packet.h:56
node
vlib_main_t vlib_node_runtime_t * node
Definition: nat44_ei.c:3047
vni
u32 vni
Definition: flow_types.api:160
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
lisp_gpe_tx_next_t
lisp_gpe_tx_next_t
Definition: interface.c:49
l2_lisp_gpe_tx_trace_t
Definition: interface.c:203
vlib_cli_command_t::path
char * path
Definition: cli.h:96
vnet_interface_main_t
Definition: interface.h:990
vnet_lisp_gpe_add_nsh_iface
u32 vnet_lisp_gpe_add_nsh_iface(lisp_gpe_main_t *lgm)
Add LISP-GPE NSH interface.
Definition: interface.c:752
lisp_gpe_tx_trace_t
Definition: interface.c:57
fib_table.h
u16
unsigned short u16
Definition: types.h:57
VNET_SW_INTERFACE_FLAG_ADMIN_UP
@ VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:844
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
lisp_gpe_hw_class
vnet_hw_interface_class_t lisp_gpe_hw_class
format_nsh_lisp_gpe_tx_trace
u8 * format_nsh_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:320
VNET_HW_INTERFACE_FLAG_LINK_UP
@ VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:509
lisp_gpe_tenant_add_default_routes
static void lisp_gpe_tenant_add_default_routes(u32 table_id)
Definition: interface.c:538
lisp_cp_dpo_get
const dpo_id_t * lisp_cp_dpo_get(dpo_proto_t proto)
Definition: lisp_cp_dpo.c:26
vnet_interface_main_t::sw_if_counters
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:1023
from_frame
vlib_main_t vlib_node_runtime_t vlib_frame_t * from_frame
Definition: esp_encrypt.c:1328
hi
vl_api_ip4_address_t hi
Definition: arp.api:37
FIB_ENTRY_FLAG_EXCLUSIVE
@ FIB_ENTRY_FLAG_EXCLUSIVE
Definition: fib_entry.h:116
unformat_input_t
struct _unformat_input_t unformat_input_t
lisp_gpe_del_l3_iface
void lisp_gpe_del_l3_iface(lisp_gpe_main_t *lgm, u32 vni, u32 table_id)
Definition: interface.c:618
lisp_gpe_add_l2_iface
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:655
vlib_frame_t
Definition: node.h:372
nsh_lisp_gpe_tx_trace_t
Definition: interface.c:314
vlib_buffer_length_in_chain
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:433
ethernet.h
h
h
Definition: flowhash_template.h:372
l2_arc_to_lb
static uword l2_arc_to_lb
The VLIB node arc/edge from the interface's TX node, to the L2 load-balanceing node.
Definition: interface.c:42
error
Definition: cJSON.c:88
lisp_gpe_main::nsh_ifaces
tunnel_lookup_t nsh_ifaces
Definition: lisp_gpe.h:157
hash_unset
#define hash_unset(h, key)
Definition: hash.h:261
lisp_gpe.h
LISP-GPE definitions.
MODE_L2_BRIDGE
#define MODE_L2_BRIDGE
Definition: l2_input.h:285
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
l2_lisp_gpe_tx_trace_t::dpo_index
u32 dpo_index
Definition: interface.c:205
ip4_main_t::fib_index_by_sw_if_index
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:120
fib_table_entry_special_remove
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a 'special' entry from the FIB.
Definition: fib_table.c:424
hash.h
format_lisp_gpe_name
static u8 * format_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:155
load_balance_main
load_balance_main_t load_balance_main
The one instance of load-balance main.
Definition: load_balance.c:59
lisp_gpe_main::l3_ifaces
tunnel_lookup_t l3_ifaces
Definition: lisp_gpe.h:139
format_l2_lisp_gpe_name
static u8 * format_l2_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:299
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
unformat_free
static void unformat_free(unformat_input_t *i)
Definition: format.h:155
error.h
bd_id
u32 bd_id
Definition: gbp.api:188
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
CLIB_UNUSED
#define CLIB_UNUSED(x)
Definition: clib.h:90
foreach_lisp_gpe_tx_next
#define foreach_lisp_gpe_tx_next
Definition: interface.c:44
vnet_buffer
#define vnet_buffer(b)
Definition: buffer.h:441
vnet_get_hw_interface
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface_funcs.h:44
fib_table_find_or_create_and_lock
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:1170
PREDICT_FALSE
#define PREDICT_FALSE(x)
Definition: clib.h:124
tunnel_lookup
Definition: lisp_gpe.h:82
hash_get
#define hash_get(h, key)
Definition: hash.h:249
vlib_frame_vector_args
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:301
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
fib_node_index_t
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
MODE_L3
#define MODE_L3
Definition: l2_input.h:284
foreach_lisp_gpe_flag_bit
@ foreach_lisp_gpe_flag_bit
Definition: lisp_gpe_packet.h:121
lisp_gpe_main::free_tunnel_hw_if_indices
u32 * free_tunnel_hw_if_indices
Free vlib hw_if_indices.
Definition: lisp_gpe.h:133
uword
u64 uword
Definition: types.h:112
vlib_zero_combined_counter
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:298
ethernet_header_t
Definition: packet.h:52
lisp_gpe_tenant.h
lisp_gpe_tenant_l2_iface_unlock
void lisp_gpe_tenant_l2_iface_unlock(u32 vni)
Release the lock held on the tenant's L3 interface.
Definition: lisp_gpe_tenant.c:215
vlib_main_t::thread_index
u32 thread_index
Definition: main.h:215
lisp_gpe_tenant_l3_iface_unlock
void lisp_gpe_tenant_l3_iface_unlock(u32 vni)
Release the lock held on the tenant's L3 interface.
Definition: lisp_gpe_tenant.c:139
lisp_gpe_main
lisp_gpe_main_t lisp_gpe_main
LISP-GPE global state.
Definition: lisp_gpe.c:30
dp_table
u32 dp_table
Definition: lisp_gpe.api:116
lisp_gpe_build_rewrite
u8 * lisp_gpe_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
Definition: lisp_gpe_adjacency.c:333
cm
vnet_feature_config_main_t * cm
Definition: nat44_ei_hairpinning.c:594
format_unformat_error
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
ip6_main_t::fib_index_by_sw_if_index
u32 * fib_index_by_sw_if_index
Definition: ip6.h:127
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
fib_protocol_t
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
bd_find_or_add_bd_index
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:202
udp_inlines.h
vnet_rename_interface
clib_error_t * vnet_rename_interface(vnet_main_t *vnm, u32 hw_if_index, char *new_name)
Definition: interface.c:1503
lisp_gpe_add_l3_iface
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:576
lisp_gpe_tx_trace_t::tunnel_index
u32 tunnel_index
Definition: interface.c:59
ip_adjacency_t_
IP unicast adjacency.
Definition: adj.h:235
VNET_INTERFACE_COUNTER_RX
@ VNET_INTERFACE_COUNTER_RX
Definition: interface.h:915
FIB_PROTOCOL_IP4
@ FIB_PROTOCOL_IP4
Definition: fib_types.h:36
LISP_AFI_MAC
@ LISP_AFI_MAC
Definition: lisp_types.h:187
vnet_interface_main_t::combined_sw_if_counters
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:1024
fib_proto_to_dpo
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:343
nsh_lisp_gpe_interface_tx
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
vnet_lisp_gpe_enable_disable_status
u8 vnet_lisp_gpe_enable_disable_status(void)
Check if LISP-GPE is enabled.
Definition: lisp_gpe.c:184
ip6_main
ip6_main_t ip6_main
Definition: ip6_forward.c:2785
add_del_lisp_gpe_iface_command
static vlib_cli_command_t add_del_lisp_gpe_iface_command
(constructor) VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command)
Definition: interface.c:930
set_int_l2_mode
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:256
l2_lisp_gpe_interface_tx
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
vnet_hw_interface_t
Definition: interface.h:638
vnet_main_t
Definition: vnet.h:76
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
ip_adjacency_t_::sub_type
union ip_adjacency_t_::@144 sub_type
vlib_validate_buffer_enqueue_x1
#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:224
VNET_HW_INTERFACE_CLASS
VNET_HW_INTERFACE_CLASS(ethernet_hw_interface_class)
load_balance_main_t_::lbm_to_counters
vlib_combined_counter_main_t lbm_to_counters
Definition: load_balance.h:46
vnet_interface_counter_unlock
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:1058
bd_find_index
u32 bd_find_index(bd_main_t *bdm, u32 bd_id)
Get a bridge domain.
Definition: l2_bd.c:70
L2_BD_PORT_TYPE_NORMAL
@ L2_BD_PORT_TYPE_NORMAL
Definition: l2_bd.h:28
lisp_gpe_main
LISP-GPE global state.
Definition: lisp_gpe.h:119
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
vlib_combined_counter_main_t
A collection of combined counters.
Definition: counter.h:203
vlib_zero_simple_counter
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:154
vlib_put_next_frame
vlib_put_next_frame(vm, node, next_index, 0)
ip.h
u32
unsigned int u32
Definition: types.h:88
lisp_gpe_header_t
LISP-GPE header.
Definition: lisp_gpe_packet.h:100
table_id
u32 table_id
Definition: wireguard.api:102
FIB_PROTOCOL_IP6
@ FIB_PROTOCOL_IP6
Definition: fib_types.h:37
si
vnet_sw_interface_t * si
Definition: interface_output.c:418
ip_udp_fixup_one
static void ip_udp_fixup_one(vlib_main_t *vm, vlib_buffer_t *b0, u8 is_ip4)
Definition: udp_inlines.h:46
vlib_node_add_named_next
static uword vlib_node_add_named_next(vlib_main_t *vm, uword node, char *name)
Definition: node_funcs.h:1189
ip6_sw_interface_enable_disable
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:240
LISP_GPE_TX_N_NEXT
@ LISP_GPE_TX_N_NEXT
Definition: interface.c:54
lisp_gpe_del_l2_iface
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:718
ip4_fib.h
ip6_fib.h
vlib_main_t
Definition: main.h:102
format_lisp_gpe_tx_trace
u8 * format_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:63
L2_BD_ID_MAX
#define L2_BD_ID_MAX
Definition: l2_bd.h:122
bd_main
bd_main_t bd_main
Definition: l2_bd.c:44
vlib_node_t
Definition: node.h:247
lisp_gpe_main::vlib_main
vlib_main_t * vlib_main
convenience
Definition: lisp_gpe.h:172
lisp_gpe_remove_iface
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
vlib_add_trace
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace.c:628
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
lisp_gpe_adjacency.h
Common utility functions for IPv4, IPv6 and L2 LISP-GPE adjacencys.
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
vnet_hw_interface_set_flags
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:513
vlib_buffer_get_current
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:257
lisp_nsh_fib_lookup
const dpo_id_t * lisp_nsh_fib_lookup(lisp_gpe_main_t *lgm, u32 spi_si_net_order)
Lookup NSH SD FIB entry.
Definition: lisp_gpe_fwd_entry.c:914
lisp_gpe_tenant_l3_iface_add_or_lock
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.
Definition: lisp_gpe_tenant.c:110
lisp_cp_dpo.h
LISP_AFI_LCAF
@ LISP_AFI_LCAF
Definition: lisp_types.h:186
fib_table_unlock
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:1342
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
lisp_gpe_tenant_l2_iface_add_or_lock
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.
Definition: lisp_gpe_tenant.c:182
dpo_id_t_
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:172
lisp_gpe_fwd_entry.h
LISP-GPE definitions.
tunnel_lookup::sw_if_index_by_vni
uword * sw_if_index_by_vni
lookup decap tunnel termination sw_if_index by vni and vice versa
Definition: lisp_gpe.h:88
FIB_SOURCE_LISP
@ FIB_SOURCE_LISP
LISP.
Definition: fib_source.h:83
vnet.h
vlib_node_runtime_t
Definition: node.h:454
is_v4_packet
#define is_v4_packet(_h)
Definition: interface.c:73
nsh_lisp_gpe_tx_trace_t::dpo_index
u32 dpo_index
Definition: interface.c:316
proto
vl_api_ip_proto_t proto
Definition: acl_types.api:51
vlib_cli_command_t
Definition: cli.h:92
from
from
Definition: nat44_ei_hairpinning.c:415
fib_table_find
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:1111
sw_if_index
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
format_nsh_lisp_gpe_name
static u8 * format_nsh_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:403
vlib_get_next_frame
#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:395
VLIB_TX
@ VLIB_TX
Definition: defs.h:47
vnet_interface_counter_lock
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:1051
adj_get
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:470
n_left_from
n_left_from
Definition: nat44_ei_hairpinning.c:416
lisp_gpe_main::vnet_main
vnet_main_t * vnet_main
Definition: lisp_gpe.h:173
lisp_gpe_main::l2_ifaces
tunnel_lookup_t l2_ifaces
Definition: lisp_gpe.h:147
tunnel_lookup::hw_if_index_by_dp_table
uword * hw_if_index_by_dp_table
Lookup lisp-gpe interfaces by dp table (eg.
Definition: lisp_gpe.h:85
fib_prefix_t_
Aggregate type for a prefix.
Definition: fib_types.h:202
format_l2_lisp_gpe_tx_trace
static u8 * format_l2_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:209
VNET_INTERFACE_COUNTER_DROP
@ VNET_INTERFACE_COUNTER_DROP
Definition: interface.h:904
vnet_register_interface
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:812
vnet_main_t::interface_main
vnet_interface_main_t interface_main
Definition: vnet.h:81
vlib_increment_combined_counter
vlib_increment_combined_counter(ccm, ti, sw_if_index, n_buffers, n_bytes)
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
prefix
vl_api_prefix_t prefix
Definition: ip.api:175
vlib_buffer_t::flags
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,...
Definition: buffer.h:133
vnet_lisp_gpe_del_nsh_iface
void vnet_lisp_gpe_del_nsh_iface(lisp_gpe_main_t *lgm)
Del LISP-GPE NSH interface.
Definition: interface.c:792
vlib_buffer_t
VLIB buffer representation.
Definition: buffer.h:111
ip_adjacency_t_::midchain
struct ip_adjacency_t_::@144::@146 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
lisp_gpe_iface_set_table
static void lisp_gpe_iface_set_table(u32 sw_if_index, u32 table_id)
Definition: interface.c:504