FD.io VPP  v17.07.01-10-g3be13f0
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 
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 
243  from = vlib_frame_vector_args (from_frame);
244  n_left_from = from_frame->n_vectors;
245 
246  next_index = node->cached_next_index;
247 
248  while (n_left_from > 0)
249  {
250  u32 n_left_to_next;
251 
252  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
253 
254  while (n_left_from > 0 && n_left_to_next > 0)
255  {
256  vlib_buffer_t *b0;
257  u32 bi0, lbi0;
258  ethernet_header_t *e0;
259 
260  bi0 = from[0];
261  to_next[0] = bi0;
262  from += 1;
263  to_next += 1;
264  n_left_from -= 1;
265  n_left_to_next -= 1;
266 
267  b0 = vlib_get_buffer (vm, bi0);
268  e0 = vlib_buffer_get_current (b0);
269 
270  vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_MAC;
271 
272  /* lookup dst + src mac */
273  lbi0 = lisp_l2_fib_lookup (lgm, vnet_buffer (b0)->l2.bd_index,
274  e0->src_address, e0->dst_address);
275  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = lbi0;
276 
277 
279  {
280  l2_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
281  sizeof (*tr));
282  tr->dpo_index = lbi0;
283  }
284  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
285  n_left_to_next, bi0, l2_arc_to_lb);
286  }
287 
288  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
289  }
290 
291  return from_frame->n_vectors;
292 }
293 
294 static u8 *
295 format_l2_lisp_gpe_name (u8 * s, va_list * args)
296 {
297  u32 dev_instance = va_arg (*args, u32);
298  return format (s, "l2_lisp_gpe%d", dev_instance);
299 }
300 
301 /* *INDENT-OFF* */
302 VNET_DEVICE_CLASS (l2_lisp_gpe_device_class,static) = {
303  .name = "L2_LISP_GPE",
304  .format_device_name = format_l2_lisp_gpe_name,
305  .format_tx_trace = format_l2_lisp_gpe_tx_trace,
306  .tx_function = l2_lisp_gpe_interface_tx,
307 };
308 /* *INDENT-ON* */
309 
310 typedef struct
311 {
314 
315 u8 *
316 format_nsh_lisp_gpe_tx_trace (u8 * s, va_list * args)
317 {
318  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
319  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
320  nsh_lisp_gpe_tx_trace_t *t = va_arg (*args, nsh_lisp_gpe_tx_trace_t *);
321 
322  s = format (s, "NSH-GPE-TX: tunnel %d", t->dpo_index);
323  return s;
324 }
325 
326 /**
327  * @brief LISP-GPE interface TX for NSH overlays.
328  * @node nsh_lisp_gpe_interface_tx
329  *
330  * The NSH LISP-GPE interface TX function.
331  *
332  * @param[in] vm vlib_main_t corresponding to the current thread.
333  * @param[in] node vlib_node_runtime_t data for this node.
334  * @param[in] frame vlib_frame_t whose contents should be dispatched.
335  *
336  * @return number of vectors in frame.
337  */
338 static uword
340  vlib_frame_t * from_frame)
341 {
342  u32 n_left_from, next_index, *from, *to_next;
344 
345  from = vlib_frame_vector_args (from_frame);
346  n_left_from = from_frame->n_vectors;
347 
348  next_index = node->cached_next_index;
349 
350  while (n_left_from > 0)
351  {
352  u32 n_left_to_next;
353 
354  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
355 
356  while (n_left_from > 0 && n_left_to_next > 0)
357  {
358  vlib_buffer_t *b0;
359  u32 bi0;
360  u32 *nsh0, next0;
361  const dpo_id_t *dpo0;
362 
363  bi0 = from[0];
364  to_next[0] = bi0;
365  from += 1;
366  to_next += 1;
367  n_left_from -= 1;
368  n_left_to_next -= 1;
369 
370  b0 = vlib_get_buffer (vm, bi0);
371  nsh0 = vlib_buffer_get_current (b0);
372 
373  vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_LCAF;
374 
375  /* lookup SPI + SI (second word of the NSH header).
376  * NB: Load balancing was done by the control plane */
377  dpo0 = lisp_nsh_fib_lookup (lgm, nsh0[1]);
378 
379  next0 = dpo0->dpoi_next_node;
380  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
381 
383  {
384  nsh_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
385  sizeof (*tr));
386  tr->dpo_index = dpo0->dpoi_index;
387  }
388  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
389  n_left_to_next, bi0, next0);
390  }
391 
392  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
393  }
394 
395  return from_frame->n_vectors;
396 }
397 
398 static u8 *
399 format_nsh_lisp_gpe_name (u8 * s, va_list * args)
400 {
401  u32 dev_instance = va_arg (*args, u32);
402  return format (s, "nsh_lisp_gpe%d", dev_instance);
403 }
404 
405 /* *INDENT-OFF* */
406 VNET_DEVICE_CLASS (nsh_lisp_gpe_device_class,static) = {
407  .name = "NSH_LISP_GPE",
408  .format_device_name = format_nsh_lisp_gpe_name,
409  .format_tx_trace = format_nsh_lisp_gpe_tx_trace,
410  .tx_function = nsh_lisp_gpe_interface_tx,
411 };
412 /* *INDENT-ON* */
413 
414 static vnet_hw_interface_t *
416  vnet_device_class_t * dev_class,
417  tunnel_lookup_t * tuns)
418 {
419  u32 flen;
420  u32 hw_if_index = ~0;
421  u8 *new_name;
423  vnet_main_t *vnm = lgm->vnet_main;
424 
425  /* create hw lisp_gpeX iface if needed, otherwise reuse existing */
426  flen = vec_len (lgm->free_tunnel_hw_if_indices);
427  if (flen > 0)
428  {
429  hw_if_index = lgm->free_tunnel_hw_if_indices[flen - 1];
430  _vec_len (lgm->free_tunnel_hw_if_indices) -= 1;
431 
432  hi = vnet_get_hw_interface (vnm, hw_if_index);
433 
434  /* rename interface */
435  new_name = format (0, "%U", dev_class->format_device_name, vni);
436 
437  vec_add1 (new_name, 0);
438  vnet_rename_interface (vnm, hw_if_index, (char *) new_name);
439  vec_free (new_name);
440 
441  /* clear old stats of freed interface before reuse */
446  hi->sw_if_index);
449  hi->sw_if_index);
452  hi->sw_if_index);
454  }
455  else
456  {
457  hw_if_index = vnet_register_interface (vnm, dev_class->index, vni,
458  lisp_gpe_hw_class.index, 0);
459  hi = vnet_get_hw_interface (vnm, hw_if_index);
460  }
461 
462  hash_set (tuns->hw_if_index_by_dp_table, dp_table, hw_if_index);
463 
464  /* set tunnel termination: post decap, packets are tagged as having been
465  * originated by lisp-gpe interface */
466  hash_set (tuns->sw_if_index_by_vni, vni, hi->sw_if_index);
467  hash_set (tuns->vni_by_sw_if_index, hi->sw_if_index, vni);
468 
469  return hi;
470 }
471 
472 static void
473 lisp_gpe_remove_iface (lisp_gpe_main_t * lgm, u32 hi_index, u32 dp_table,
474  tunnel_lookup_t * tuns)
475 {
476  vnet_main_t *vnm = lgm->vnet_main;
478  uword *vnip;
479 
480  hi = vnet_get_hw_interface (vnm, hi_index);
481 
482  /* disable interface */
483  vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 0 /* down */ );
484  vnet_hw_interface_set_flags (vnm, hi->hw_if_index, 0 /* down */ );
485  hash_unset (tuns->hw_if_index_by_dp_table, dp_table);
487 
488  /* clean tunnel termination and vni to sw_if_index binding */
489  vnip = hash_get (tuns->vni_by_sw_if_index, hi->sw_if_index);
490  if (0 == vnip)
491  {
492  clib_warning ("No vni associated to interface %d", hi->sw_if_index);
493  return;
494  }
495  hash_unset (tuns->sw_if_index_by_vni, vnip[0]);
497 }
498 
499 static void
500 lisp_gpe_iface_set_table (u32 sw_if_index, u32 table_id)
501 {
502  fib_node_index_t fib_index;
503 
504  fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id);
506  ip4_main.fib_index_by_sw_if_index[sw_if_index] = fib_index;
507  ip4_sw_interface_enable_disable (sw_if_index, 1);
508 
509  fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, table_id);
511  ip6_main.fib_index_by_sw_if_index[sw_if_index] = fib_index;
512  ip6_sw_interface_enable_disable (sw_if_index, 1);
513 }
514 
515 static void
517 {
518  fib_protocol_t proto;
519 
521  {
522  fib_prefix_t prefix = {
523  .fp_proto = proto,
524  };
525  u32 fib_index;
526 
527  fib_index = fib_table_find (prefix.fp_proto, table_id);
528  fib_table_entry_special_remove (fib_index, &prefix, FIB_SOURCE_LISP);
529  fib_table_unlock (fib_index, prefix.fp_proto);
530  }
531 }
532 
533 static void
535 {
536  fib_protocol_t proto;
537 
539  {
540  fib_prefix_t prefix = {
541  .fp_proto = proto,
542  };
543  u32 fib_index;
544 
545  /*
546  * Add a deafult route that results in a control plane punt DPO
547  */
548  fib_index = fib_table_find_or_create_and_lock (prefix.fp_proto, table_id);
552  (proto)));
553  }
554 }
555 
556 
557 /**
558  * @brief Add/del LISP-GPE L3 interface.
559  *
560  * Creates LISP-GPE interface, sets ingress arcs from lisp_gpeX_lookup,
561  * installs default routes that attract all traffic with no more specific
562  * routes to lgpe-ipx-lookup, set egress arcs to ipx-lookup, sets
563  * the interface in the right vrf and enables it.
564  *
565  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
566  * @param[in] a Parameters to create interface.
567  *
568  * @return number of vectors in frame.
569  */
570 u32
572 {
573  vnet_main_t *vnm = lgm->vnet_main;
574  tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
576  uword *hip, *si;
577 
578  hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
579 
580  if (hip)
581  {
582  clib_warning ("vrf %d already mapped to a vni", table_id);
583  return ~0;
584  }
585 
586  si = hash_get (l3_ifaces->sw_if_index_by_vni, vni);
587 
588  if (si)
589  {
590  clib_warning ("Interface for vni %d already exists", vni);
591  }
592 
593  /* create lisp iface and populate tunnel tables */
594  hi = lisp_gpe_create_iface (lgm, vni, table_id,
595  &lisp_gpe_device_class, l3_ifaces);
596 
597  /* insert default routes that point to lisp-cp lookup */
598  lisp_gpe_iface_set_table (hi->sw_if_index, table_id);
600 
601  /* enable interface */
606 
607  return (hi->sw_if_index);
608 }
609 
610 void
612 {
613  vnet_main_t *vnm = lgm->vnet_main;
614  tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
616  uword *hip;
617 
618  hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
619 
620  if (hip == 0)
621  {
622  clib_warning ("The interface for vrf %d doesn't exist", table_id);
623  return;
624  }
625 
626  hi = vnet_get_hw_interface (vnm, hip[0]);
627 
628  lisp_gpe_remove_iface (lgm, hip[0], table_id, &lgm->l3_ifaces);
629 
630  /* unset default routes */
634 }
635 
636 /**
637  * @brief Add/del LISP-GPE L2 interface.
638  *
639  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
640  * bridge domain, sets egress arcs and enables it.
641  *
642  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
643  * @param[in] a Parameters to create interface.
644  *
645  * @return number of vectors in frame.
646  */
647 u32
649 {
650  vnet_main_t *vnm = lgm->vnet_main;
651  tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
653  uword *hip, *si;
654  u16 bd_index;
655 
656  if (bd_id > L2_BD_ID_MAX)
657  {
658  clib_warning ("bridge domain ID %d exceed 16M limit", bd_id);
659  return ~0;
660  }
661 
662  bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
663  hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
664 
665  if (hip)
666  {
667  clib_warning ("bridge domain %d already mapped to a vni", bd_id);
668  return ~0;
669  }
670 
671  si = hash_get (l2_ifaces->sw_if_index_by_vni, vni);
672  if (si)
673  {
674  clib_warning ("Interface for vni %d already exists", vni);
675  return ~0;
676  }
677 
678  /* create lisp iface and populate tunnel tables */
679  hi = lisp_gpe_create_iface (lgm, vni, bd_index,
680  &l2_lisp_gpe_device_class, &lgm->l2_ifaces);
681 
682  /* enable interface */
687 
689  hi->tx_node_index,
690  "l2-load-balance");
691 
692  /* we're ready. add iface to l2 bridge domain */
694  bd_index, 0, 0, 0);
695 
696  return (hi->sw_if_index);
697 }
698 
699 /**
700  * @brief Add/del LISP-GPE L2 interface.
701  *
702  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
703  * bridge domain, sets egress arcs and enables it.
704  *
705  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
706  * @param[in] a Parameters to create interface.
707  *
708  * @return number of vectors in frame.
709  */
710 void
712 {
713  tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
715 
716  u32 bd_index = bd_find_index (&bd_main, bd_id);
717  ASSERT (bd_index != ~0);
718  uword *hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
719 
720  if (hip == 0)
721  {
722  clib_warning ("The interface for bridge domain %d doesn't exist",
723  bd_id);
724  return;
725  }
726 
727  /* Remove interface from bridge .. by enabling L3 mode */
728  hi = vnet_get_hw_interface (lgm->vnet_main, hip[0]);
730  0, 0, 0, 0);
731  lisp_gpe_remove_iface (lgm, hip[0], bd_index, &lgm->l2_ifaces);
732 }
733 
734 /**
735  * @brief Add LISP-GPE NSH interface.
736  *
737  * Creates LISP-GPE interface, sets it in L3 mode.
738  *
739  * @param[in] lgm Reference to @ref lisp_gpe_main_t.
740  * @param[in] a Parameters to create interface.
741  *
742  * @return sw_if_index.
743  */
744 u32
746 {
747  vnet_main_t *vnm = lgm->vnet_main;
748  tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
750  uword *hip, *si;
751 
752  hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
753 
754  if (hip)
755  {
756  clib_warning ("NSH interface 0 already exists");
757  return ~0;
758  }
759 
760  si = hash_get (nsh_ifaces->sw_if_index_by_vni, 0);
761  if (si)
762  {
763  clib_warning ("NSH interface already exists");
764  return ~0;
765  }
766 
767  /* create lisp iface and populate tunnel tables */
768  hi = lisp_gpe_create_iface (lgm, 0, 0,
769  &nsh_lisp_gpe_device_class, &lgm->nsh_ifaces);
770 
771  /* enable interface */
776 
777  return (hi->sw_if_index);
778 }
779 
780 /**
781  * @brief Del LISP-GPE NSH interface.
782  *
783  */
784 void
786 {
787  tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
788  uword *hip;
789 
790  hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
791 
792  if (hip == 0)
793  {
794  clib_warning ("The NSH 0 interface doesn't exist");
795  return;
796  }
797  lisp_gpe_remove_iface (lgm, hip[0], 0, &lgm->nsh_ifaces);
798 }
799 
800 static clib_error_t *
802  vlib_cli_command_t * cmd)
803 {
804  unformat_input_t _line_input, *line_input = &_line_input;
805  u8 is_add = 1;
806  u32 table_id, vni, bd_id;
807  u8 vni_is_set = 0, vrf_is_set = 0, bd_index_is_set = 0;
808  u8 nsh_iface = 0;
809  clib_error_t *error = NULL;
810 
812  {
813  return clib_error_return (0, "LISP is disabled");
814  }
815 
816  /* Get a line of input. */
817  if (!unformat_user (input, unformat_line_input, line_input))
818  return 0;
819 
820  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
821  {
822  if (unformat (line_input, "add"))
823  is_add = 1;
824  else if (unformat (line_input, "del"))
825  is_add = 0;
826  else if (unformat (line_input, "vrf %d", &table_id))
827  {
828  vrf_is_set = 1;
829  }
830  else if (unformat (line_input, "vni %d", &vni))
831  {
832  vni_is_set = 1;
833  }
834  else if (unformat (line_input, "bd %d", &bd_id))
835  {
836  bd_index_is_set = 1;
837  }
838  else if (unformat (line_input, "nsh"))
839  {
840  nsh_iface = 1;
841  }
842  else
843  {
844  error = clib_error_return (0, "parse error: '%U'",
845  format_unformat_error, line_input);
846  goto done;
847  }
848  }
849 
850  if (nsh_iface)
851  {
852  if (is_add)
853  {
855  {
856  error = clib_error_return (0, "NSH interface not created");
857  goto done;
858  }
859  }
860  else
861  {
863  }
864  goto done;
865  }
866 
867  if (vrf_is_set && bd_index_is_set)
868  {
869  error = clib_error_return
870  (0, "Cannot set both vrf and brdige domain index!");
871  goto done;
872  }
873 
874  if (!vni_is_set)
875  {
876  error = clib_error_return (0, "vni must be set!");
877  goto done;
878  }
879 
880  if (!vrf_is_set && !bd_index_is_set)
881  {
882  error =
883  clib_error_return (0, "vrf or bridge domain index must be set!");
884  goto done;
885  }
886 
887  if (bd_index_is_set)
888  {
889  if (is_add)
890  {
891  if (~0 == lisp_gpe_tenant_l2_iface_add_or_lock (vni, bd_id))
892  {
893  error = clib_error_return (0, "L2 interface not created");
894  goto done;
895  }
896  }
897  else
899  }
900  else
901  {
902  if (is_add)
903  {
904  if (~0 == lisp_gpe_tenant_l3_iface_add_or_lock (vni, table_id))
905  {
906  error = clib_error_return (0, "L3 interface not created");
907  goto done;
908  }
909  }
910  else
912  }
913 
914 done:
915  unformat_free (line_input);
916 
917  return error;
918 }
919 
920 /* *INDENT-OFF* */
921 VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command, static) = {
922  .path = "gpe iface",
923  .short_help = "gpe iface add/del vni <vni> vrf <vrf>",
925 };
926 /* *INDENT-ON* */
927 
928 /*
929  * fd.io coding-style-patch-verification: ON
930  *
931  * Local Variables:
932  * eval: (c-set-style "gnu")
933  * End:
934  */
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:339
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:169
#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
#define hash_set(h, key, value)
Definition: hash.h:254
#define CLIB_UNUSED(x)
Definition: clib.h:79
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:537
#define hash_unset(h, key)
Definition: hash.h:260
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:648
const dpo_id_t * lisp_cp_dpo_get(dpo_proto_t proto)
Definition: lisp_cp_dpo.c:26
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:399
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:1093
#define NULL
Definition: clib.h:55
IP unicast adjacency.
Definition: adj.h:174
u32 vnet_lisp_gpe_add_nsh_iface(lisp_gpe_main_t *lgm)
Add LISP-GPE NSH interface.
Definition: interface.c:745
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:459
u8 src_address[6]
Definition: packet.h:54
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)
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:801
#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:99
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
union ip_adjacency_t_::@37 sub_type
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:397
struct _vnet_device_class vnet_device_class_t
uword * vni_by_sw_if_index
Definition: lisp_gpe.h:90
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:611
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:365
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:390
#define MODE_L2_BRIDGE
Definition: l2_input.h:199
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:653
u8 dst_address[6]
Definition: packet.h:53
Aggregrate type for a prefix.
Definition: fib_types.h:160
#define clib_error_return(e, args...)
Definition: error.h:99
u8 * lisp_gpe_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
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:1025
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:688
u8 * format_lisp_gpe_header_with_length(u8 *s, va_list *args)
Definition: interface.c:171
u32 set_int_l2_mode(vlib_main_t *vm, vnet_main_t *vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, u32 bvi, u32 shg, u32 xc_sw_if_index)
Set the subinterface to run in l2 or l3 mode.
Definition: l2_input.c:517
Common utility functions for IPv4, IPv6 and L2 LISP-GPE adjacencys.
unformat_function_t unformat_line_input
Definition: format.h:281
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:152
void fib_table_unlock(u32 fib_index, fib_protocol_t proto)
Take a reference counting lock on the table.
Definition: fib_table.c:1145
void vnet_lisp_gpe_del_nsh_iface(lisp_gpe_main_t *lgm)
Del LISP-GPE NSH interface.
Definition: interface.c:785
#define hash_get(h, key)
Definition: hash.h:248
Definition: fib_entry.h:237
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:276
void ip4_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip4_forward.c:860
struct _unformat_input_t unformat_input_t
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:188
static void lisp_gpe_tenant_add_default_routes(u32 table_id)
Definition: interface.c:534
#define PREDICT_FALSE(x)
Definition: clib.h:97
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:652
struct ip_adjacency_t_::@37::@39 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
#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:216
#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:366
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:1296
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:185
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
u16 n_vectors
Definition: node.h:345
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
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
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:85
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:711
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:678
static void lisp_gpe_remove_iface(lisp_gpe_main_t *lgm, u32 hi_index, u32 dp_table, tunnel_lookup_t *tuns)
Definition: interface.c:473
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
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:154
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:290
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:670
static void lisp_gpe_iface_set_table(u32 sw_if_index, u32 table_id)
Definition: interface.c:500
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:460
#define L2_BD_ID_MAX
Definition: l2_bd.h:94
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:560
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:167
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
ip6_main_t ip6_main
Definition: ip6_forward.c:2926
uword * hw_if_index_by_dp_table
Lookup lisp-gpe interfaces by dp table (eg.
Definition: lisp_gpe.h:84
u32 fib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1041
u8 * format_nsh_lisp_gpe_tx_trace(u8 *s, va_list *args)
Definition: interface.c:316
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:123
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:211
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u64 uword
Definition: types.h:112
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:55
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
unsigned short u16
Definition: types.h:57
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:168
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
tunnel_lookup_t l3_ifaces
Definition: lisp_gpe.h:138
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:269
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:62
#define vnet_buffer(b)
Definition: buffer.h:304
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:1168
LISP.
Definition: fib_entry.h:70
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:545
static u8 * format_l2_lisp_gpe_name(u8 *s, va_list *args)
Definition: interface.c:295
u32 bd_find_index(bd_main_t *bdm, u32 bd_id)
Get a bridge domain.
Definition: l2_bd.c:67
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:164
VNET_DEVICE_CLASS(ethernet_simulated_device_class)
bd_main_t bd_main
Definition: l2_bd.c:44
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:74
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:163
u32 lisp_gpe_tenant_l3_iface_add_or_lock(u32 vni, u32 table_id)
Add/create and lock a new or find and lock the existing L3 interface for the tenant.
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
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:415
static void lisp_gpe_tenant_del_default_routes(u32 table_id)
Definition: interface.c:516
void ip6_sw_interface_enable_disable(u32 sw_if_index, u32 is_enable)
Definition: ip6_forward.c:421
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:169
#define MODE_L3
Definition: l2_input.h:198
u32 lisp_gpe_add_l3_iface(lisp_gpe_main_t *lgm, u32 vni, u32 table_id)
Add/del LISP-GPE L3 interface.
Definition: interface.c:571