FD.io VPP  v17.04.2-2-ga8f93f8
Vector Packet Processing
interface.c
Go to the documentation of this file.
1 /*
2  * gre_interface.c: gre interfaces
3  *
4  * Copyright (c) 2012 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vnet/vnet.h>
19 #include <vnet/pg/pg.h>
20 #include <vnet/gre/gre.h>
21 #include <vnet/ip/format.h>
22 #include <vnet/fib/ip4_fib.h>
23 #include <vnet/adj/adj_midchain.h>
24 #include <vnet/adj/adj_nbr.h>
25 #include <vnet/mpls/mpls.h>
26 
28 
29 static inline u64
31  const ip4_address_t *dst,
32  u32 out_fib_index)
33 {
34  // FIXME. the fib index should be part of the key
35  return ((u64)src->as_u32 << 32 | (u64)dst->as_u32);
36 }
37 
38 static u8 *
39 format_gre_tunnel_type (u8 * s, va_list * args)
40 {
41  gre_tunnel_type_t type = va_arg (*args, gre_tunnel_type_t);
42 
43  return (format(s, "%s", gre_tunnel_type_names[type]));
44 }
45 
46 static u8 *
47 format_gre_tunnel (u8 * s, va_list * args)
48 {
49  gre_tunnel_t * t = va_arg (*args, gre_tunnel_t *);
50  gre_main_t * gm = &gre_main;
51 
52  s = format (s,
53  "[%d] %U (src) %U (dst) payload %U outer_fib_index %d",
54  t - gm->tunnels,
58  t->outer_fib_index);
59 
60  return s;
61 }
62 
63 static gre_tunnel_t *
65  const ip4_address_t *dst,
66  u32 out_fib_index)
67 {
68  gre_main_t * gm = &gre_main;
69  uword * p;
70  u64 key;
71 
72  key = gre_mk_key(src, dst, out_fib_index);
73 
74  p = hash_get (gm->tunnel_by_key, key);
75 
76  if (NULL == p)
77  return (NULL);
78 
79  return (pool_elt_at_index (gm->tunnels, p[0]));
80 }
81 
82 static void
84 {
85  gre_main_t * gm = &gre_main;
86  u64 key;
87 
88  key = gre_mk_key(&t->tunnel_src, &t->tunnel_dst, t->outer_fib_index);
89  hash_set (gm->tunnel_by_key, key, t - gm->tunnels);
90 }
91 
92 static void
94 {
95  gre_main_t * gm = &gre_main;
96  u64 key;
97 
98  key = gre_mk_key(&t->tunnel_src, &t->tunnel_dst, t->outer_fib_index);
99  hash_unset (gm->tunnel_by_key, key);
100 }
101 
102 static gre_tunnel_t *
104 {
105 #if (CLIB_DEBUG > 0)
107 #endif
108  return ((gre_tunnel_t*) (((char*)node) -
110 }
111 
112 /**
113  * gre_tunnel_stack
114  *
115  * 'stack' (resolve the recursion for) the tunnel's midchain adjacency
116  */
117 void
119 {
120  gre_main_t * gm = &gre_main;
121  ip_adjacency_t *adj;
122  gre_tunnel_t *gt;
123  u32 sw_if_index;
124 
125  adj = adj_get(ai);
126  sw_if_index = adj->rewrite_header.sw_if_index;
127 
128  if ((vec_len(gm->tunnel_index_by_sw_if_index) < sw_if_index) ||
129  (~0 == gm->tunnel_index_by_sw_if_index[sw_if_index]))
130  return;
131 
132  gt = pool_elt_at_index(gm->tunnels,
133  gm->tunnel_index_by_sw_if_index[sw_if_index]);
134 
135  /*
136  * find the adjacency that is contributed by the FIB entry
137  * that this tunnel resovles via, and use it as the next adj
138  * in the midchain
139  */
141  gt->hw_if_index) &
143  {
145  ai,
147  }
148  else
149  {
151  }
152 }
153 
154 /**
155  * @brief Call back when restacking all adjacencies on a GRE interface
156  */
157 static adj_walk_rc_t
159  void *ctx)
160 {
161  gre_tunnel_stack(ai);
162 
163  return (ADJ_WALK_RC_CONTINUE);
164 }
165 
166 static void
168 {
169  fib_protocol_t proto;
170 
171  /*
172  * walk all the adjacencies on th GRE interface and restack them
173  */
175  {
177  proto,
179  NULL);
180  }
181 }
182 
183 /**
184  * Function definition to backwalk a FIB node
185  */
189 {
191 
193 }
194 
195 /**
196  * Function definition to get a FIB node from its index
197  */
198 static fib_node_t*
200 {
201  gre_tunnel_t * gt;
202  gre_main_t * gm;
203 
204  gm = &gre_main;
205  gt = pool_elt_at_index(gm->tunnels, index);
206 
207  return (&gt->node);
208 }
209 
210 /**
211  * Function definition to inform the FIB node that its last lock has gone.
212  */
213 static void
215 {
216  /*
217  * The MPLS GRE tunnel is a root of the graph. As such
218  * it never has children and thus is never locked.
219  */
220  ASSERT(0);
221 }
222 
223 /*
224  * Virtual function table registered by MPLS GRE tunnels
225  * for participation in the FIB object graph.
226  */
227 const static fib_node_vft_t gre_vft = {
229  .fnv_last_lock = gre_tunnel_last_lock_gone,
230  .fnv_back_walk = gre_tunnel_back_walk,
231 };
232 
233 static int
235  u32 * sw_if_indexp)
236 {
237  gre_main_t * gm = &gre_main;
238  vnet_main_t * vnm = gm->vnet_main;
239  ip4_main_t * im = &ip4_main;
240  gre_tunnel_t * t;
242  u32 hw_if_index, sw_if_index;
243  u32 outer_fib_index;
244  u8 address[6];
245  clib_error_t *error;
246 
247  outer_fib_index = ip4_fib_index_from_table_id(a->outer_fib_id);
248 
249  if (~0 == outer_fib_index)
250  return VNET_API_ERROR_NO_SUCH_FIB;
251 
252  t = gre_tunnel_db_find(&a->src, &a->dst, a->outer_fib_id);
253 
254  if (NULL != t)
255  return VNET_API_ERROR_INVALID_VALUE;
256 
258  memset (t, 0, sizeof (*t));
260 
261  if (a->teb)
263  else
265 
266  if (vec_len (gm->free_gre_tunnel_hw_if_indices[t->type]) > 0) {
268 
269  hw_if_index = gm->free_gre_tunnel_hw_if_indices[t->type]
271  _vec_len (gm->free_gre_tunnel_hw_if_indices[t->type]) -= 1;
272 
273  hi = vnet_get_hw_interface (vnm, hw_if_index);
274  hi->dev_instance = t - gm->tunnels;
275  hi->hw_instance = hi->dev_instance;
276 
277  /* clear old stats of freed tunnel before reuse */
278  sw_if_index = hi->sw_if_index;
285  (&im->sw_if_counters[VNET_INTERFACE_COUNTER_DROP], sw_if_index);
287  if (GRE_TUNNEL_TYPE_TEB == t->type)
288  {
290  hi->tx_node_index,
291  "adj-l2-midchain");
292  }
293  } else {
294  if (GRE_TUNNEL_TYPE_TEB == t->type)
295  {
296  /* Default MAC address (d00b:eed0:0000 + sw_if_index) */
297  memset (address, 0, sizeof (address));
298  address[0] = 0xd0;
299  address[1] = 0x0b;
300  address[2] = 0xee;
301  address[3] = 0xd0;
302  address[4] = t - gm->tunnels;
303 
304  error = ethernet_register_interface(vnm,
305  gre_device_teb_class.index,
306  t - gm->tunnels, address,
307  &hw_if_index,
308  0);
309 
310  if (error)
311  {
312  clib_error_report (error);
313  return VNET_API_ERROR_INVALID_REGISTRATION;
314  }
315  hi = vnet_get_hw_interface (vnm, hw_if_index);
316 
318  hi->tx_node_index,
319  "adj-l2-midchain");
320  } else {
321  hw_if_index = vnet_register_interface(vnm,
322  gre_device_class.index,
323  t - gm->tunnels,
325  t - gm->tunnels);
326  }
327  hi = vnet_get_hw_interface (vnm, hw_if_index);
328  sw_if_index = hi->sw_if_index;
329  }
330 
331  t->hw_if_index = hw_if_index;
332  t->outer_fib_index = outer_fib_index;
333  t->sw_if_index = sw_if_index;
335 
337  gm->tunnel_index_by_sw_if_index[sw_if_index] = t - gm->tunnels;
338 
339  vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
340 
341  hi->min_packet_bytes = 64 + sizeof (gre_header_t) + sizeof (ip4_header_t);
343  /* preamble */ 8 + /* inter frame gap */ 12;
344 
345  /* Standard default gre MTU. */
347 
348  clib_memcpy (&t->tunnel_src, &a->src, sizeof (t->tunnel_src));
349  clib_memcpy (&t->tunnel_dst, &a->dst, sizeof (t->tunnel_dst));
350 
352 
353  /*
354  * source the FIB entry for the tunnel's destination
355  * and become a child thereof. The tunnel will then get poked
356  * when the forwarding for the entry updates, and the tunnel can
357  * re-stack accordingly
358  */
359  const fib_prefix_t tun_dst_pfx = {
360  .fp_len = 32,
361  .fp_proto = FIB_PROTOCOL_IP4,
362  .fp_addr = {
363  .ip4 = t->tunnel_dst,
364  }
365  };
366 
367  t->fib_entry_index =
368  fib_table_entry_special_add(outer_fib_index,
369  &tun_dst_pfx,
372  t->sibling_index =
375  t - gm->tunnels);
376 
377  clib_memcpy (&t->tunnel_src, &a->src, sizeof (t->tunnel_src));
378  clib_memcpy (&t->tunnel_dst, &a->dst, sizeof (t->tunnel_dst));
379 
380  if (GRE_TUNNEL_TYPE_TEB == t->type)
381  {
384  &zero_addr,
385  sw_if_index);
387  }
388 
389  if (sw_if_indexp)
390  *sw_if_indexp = sw_if_index;
391 
392  return 0;
393 }
394 
395 static int
397  u32 * sw_if_indexp)
398 {
399  gre_main_t * gm = &gre_main;
400  vnet_main_t * vnm = gm->vnet_main;
401  gre_tunnel_t * t;
402  u32 sw_if_index;
403 
404  t = gre_tunnel_db_find(&a->src, &a->dst, a->outer_fib_id);
405 
406  if (NULL == t)
407  return VNET_API_ERROR_NO_SUCH_ENTRY;
408 
409  sw_if_index = t->sw_if_index;
410  vnet_sw_interface_set_flags (vnm, sw_if_index, 0 /* down */);
411  /* make sure tunnel is removed from l2 bd or xconnect */
412  set_int_l2_mode(gm->vlib_main, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0);
414  gm->tunnel_index_by_sw_if_index[sw_if_index] = ~0;
415 
416  if (GRE_TUNNEL_TYPE_TEB == t->type)
418 
421 
423  t->sibling_index);
425  FIB_SOURCE_RR);
426 
428  fib_node_deinit(&t->node);
429  pool_put (gm->tunnels, t);
430 
431  if (sw_if_indexp)
432  *sw_if_indexp = sw_if_index;
433 
434  return 0;
435 }
436 
437 int
439  u32 * sw_if_indexp)
440 {
441  if (a->is_add)
442  return (vnet_gre_tunnel_add(a, sw_if_indexp));
443  else
444  return (vnet_gre_tunnel_delete(a, sw_if_indexp));
445 }
446 
447 clib_error_t *
449 {
450  gre_main_t * gm = &gre_main;
452  gre_tunnel_t *t;
453  u32 ti;
454 
455  hi = vnet_get_hw_interface (vnm, hw_if_index);
456 
457  if (NULL == gm->tunnel_index_by_sw_if_index ||
459  return (NULL);
460 
462 
463  if (~0 == ti)
464  /* not one of ours */
465  return (NULL);
466 
467  t = pool_elt_at_index(gm->tunnels, ti);
468 
471  else
472  vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */);
473 
475 
476  return /* no error */ 0;
477 }
478 
479 static clib_error_t *
481  unformat_input_t * input,
482  vlib_cli_command_t * cmd)
483 {
484  unformat_input_t _line_input, * line_input = &_line_input;
485  vnet_gre_add_del_tunnel_args_t _a, * a = &_a;
486  ip4_address_t src, dst;
487  u32 outer_fib_id = 0;
488  u8 teb = 0;
489  int rv;
490  u32 num_m_args = 0;
491  u8 is_add = 1;
492  u32 sw_if_index;
493  clib_error_t *error = NULL;
494 
495  /* Get a line of input. */
496  if (! unformat_user (input, unformat_line_input, line_input))
497  return 0;
498 
499  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
500  if (unformat (line_input, "del"))
501  is_add = 0;
502  else if (unformat (line_input, "src %U", unformat_ip4_address, &src))
503  num_m_args++;
504  else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst))
505  num_m_args++;
506  else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
507  ;
508  else if (unformat (line_input, "teb"))
509  teb = 1;
510  else
511  {
512  error = clib_error_return (0, "unknown input `%U'",
513  format_unformat_error, line_input);
514  goto done;
515  }
516  }
517 
518  if (num_m_args < 2)
519  {
520  error = clib_error_return (0, "mandatory argument(s) missing");
521  goto done;
522  }
523 
524  if (memcmp (&src, &dst, sizeof(src)) == 0)
525  {
526  error = clib_error_return (0, "src and dst are identical");
527  goto done;
528  }
529 
530  memset (a, 0, sizeof (*a));
531  a->outer_fib_id = outer_fib_id;
532  a->teb = teb;
533  clib_memcpy(&a->src, &src, sizeof(src));
534  clib_memcpy(&a->dst, &dst, sizeof(dst));
535 
536  if (is_add)
537  rv = vnet_gre_tunnel_add(a, &sw_if_index);
538  else
539  rv = vnet_gre_tunnel_delete(a, &sw_if_index);
540 
541  switch(rv)
542  {
543  case 0:
544  vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), sw_if_index);
545  break;
546  case VNET_API_ERROR_INVALID_VALUE:
547  error = clib_error_return (0, "GRE tunnel already exists...");
548  goto done;
549  case VNET_API_ERROR_NO_SUCH_FIB:
550  error = clib_error_return (0, "outer fib ID %d doesn't exist\n",
551  outer_fib_id);
552  goto done;
553  default:
554  error = clib_error_return (0, "vnet_gre_add_del_tunnel returned %d", rv);
555  goto done;
556  }
557 
558 done:
559  unformat_free (line_input);
560 
561  return error;
562 }
563 
564 VLIB_CLI_COMMAND (create_gre_tunnel_command, static) = {
565  .path = "create gre tunnel",
566  .short_help = "create gre tunnel src <addr> dst <addr> "
567  "[outer-fib-id <fib>] [teb] [del]",
568  .function = create_gre_tunnel_command_fn,
569 };
570 
571 static clib_error_t *
573  unformat_input_t * input,
574  vlib_cli_command_t * cmd)
575 {
576  gre_main_t * gm = &gre_main;
577  gre_tunnel_t * t;
578  u32 ti = ~0;
579 
580  if (pool_elts (gm->tunnels) == 0)
581  vlib_cli_output (vm, "No GRE tunnels configured...");
582 
584  {
585  if (unformat (input, "%d", &ti))
586  ;
587  else
588  break;
589  }
590 
591  if (~0 == ti)
592  {
593  pool_foreach (t, gm->tunnels,
594  ({
595  vlib_cli_output (vm, "%U", format_gre_tunnel, t);
596  }));
597  }
598  else
599  {
600  t = pool_elt_at_index(gm->tunnels, ti);
601 
602  vlib_cli_output (vm, "%U", format_gre_tunnel, t);
603  }
604 
605  return 0;
606 }
607 
608 VLIB_CLI_COMMAND (show_gre_tunnel_command, static) = {
609  .path = "show gre tunnel",
610  .function = show_gre_tunnel_command_fn,
611 };
612 
613 /* force inclusion from application's main.c */
615 {
617 
618  return 0;
619 }
vnet_main_t * vnet_main
Definition: gre.h:168
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
void gre_tunnel_stack(adj_index_t ai)
gre_tunnel_stack
Definition: interface.c:118
static void gre_tunnel_db_add(const gre_tunnel_t *t)
Definition: interface.c:83
vmrglw vmrglh hi
Recursive resolution source.
Definition: fib_entry.h:109
#define hash_set(h, key, value)
Definition: hash.h:254
GRE related global data.
Definition: gre.h:130
fib_node_index_t fib_entry_index
The FIB entry sourced by the tunnel for its destination prefix.
Definition: gre.h:106
u32 hw_if_index
Definition: gre.h:99
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:530
#define hash_unset(h, key)
Definition: hash.h:260
a
Definition: bitmap.h:516
static u8 * format_gre_tunnel(u8 *s, va_list *args)
Definition: interface.c:47
static int vnet_gre_tunnel_add(vnet_gre_add_del_tunnel_args_t *a, u32 *sw_if_indexp)
Definition: interface.c:234
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
vnet_interface_main_t interface_main
Definition: vnet.h:57
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:183
uword * tunnel_by_key
Hash mapping src/dst addr pair to tunnel.
Definition: gre.h:148
u32 fib_entry_child_add(fib_node_index_t fib_entry_index, fib_node_type_t child_type, fib_node_index_t child_index)
Definition: fib_entry.c:472
static uword vlib_node_add_named_next(vlib_main_t *vm, uword node, char *name)
Definition: node_funcs.h:1077
static void gre_tunnel_restack(gre_tunnel_t *gt)
Definition: interface.c:167
#define NULL
Definition: clib.h:55
IP unicast adjacency.
Definition: lookup.h:193
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:432
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 outer_fib_index
The FIB in which the src.dst address are present.
Definition: gre.h:98
void fib_entry_child_remove(fib_node_index_t fib_entry_index, u32 sibling_index)
Definition: fib_entry.c:483
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
static adj_walk_rc_t gre_adj_walk_cb(adj_index_t ai, void *ctx)
Call back when restacking all adjacencies on a GRE interface.
Definition: interface.c:158
static gre_tunnel_t * gre_tunnel_db_find(const ip4_address_t *src, const ip4_address_t *dst, u32 out_fib_index)
Definition: interface.c:64
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:982
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:62
void fib_node_deinit(fib_node_t *node)
Definition: fib_node.c:198
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:120
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:379
format_function_t format_vnet_sw_if_index_name
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u32 * tunnel_index_by_sw_if_index
Mapping from sw_if_index to tunnel index.
Definition: gre.h:160
void fib_node_register_type(fib_node_type_t type, const fib_node_vft_t *vft)
fib_node_register_type
Definition: fib_node.c:58
ip4_address_t tunnel_dst
The tunnel&#39;s destination/remote address.
Definition: gre.h:94
u32 sibling_index
The tunnel is a child of the FIB entry for its desintion.
Definition: gre.h:114
L3 GRE (i.e.
Definition: gre.h:64
format_function_t format_ip4_address
Definition: format.h:79
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:128
u32 sw_if_index
Definition: gre.h:100
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:376
unformat_function_t unformat_ip4_address
Definition: format.h:76
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:626
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
clib_error_t * gre_interface_init(vlib_main_t *vm)
Definition: interface.c:614
Aggregrate type for a prefix.
Definition: fib_types.h:160
#define clib_error_return(e, args...)
Definition: error.h:111
unsigned long u64
Definition: types.h:89
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:215
enum gre_tunnel_tyoe_t_ gre_tunnel_type_t
The GRE tunnel type.
static fib_node_t * gre_tunnel_fib_node_get(fib_node_index_t index)
Function definition to get a FIB node from its index.
Definition: interface.c:199
adj_index_t l2_adj_index
an L2 tunnel always rquires an L2 midchain.
Definition: gre.h:124
u16 fp_len
The mask length.
Definition: fib_types.h:164
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:681
#define GRE_TUNNEL_TYPE_NAMES
Definition: gre.h:71
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:523
Definition: fib_entry.h:227
unformat_function_t unformat_line_input
Definition: format.h:281
static clib_error_t * create_gre_tunnel_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: interface.c:480
#define hash_get(h, key)
Definition: hash.h:248
#define ADJ_INDEX_INVALID
Invalid ADJ index - used when no adj is known likewise blazoned capitals INVALID speak volumes where ...
Definition: adj_types.h:36
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:397
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
A representation of a GRE tunnel.
Definition: gre.h:81
static uword vnet_hw_interface_get_flags(vnet_main_t *vnm, u32 hw_if_index)
u32 * free_gre_tunnel_hw_if_indices[GRE_TUNNEL_N_TYPES]
Free vlib hw_if_indices.
Definition: gre.h:155
static void gre_tunnel_db_remove(const gre_tunnel_t *t)
Definition: interface.c:93
struct _unformat_input_t unformat_input_t
static gre_tunnel_t * gre_tunnel_from_fib_node(fib_node_t *node)
Definition: interface.c:103
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:241
void gre_update_adj(vnet_main_t *vnm, u32 sw_if_index, adj_index_t ai)
Definition: gre.c:239
vnet_device_class_t gre_device_teb_class
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:625
fib_node_type_t fn_type
The node&#39;s type.
Definition: fib_node.h:282
An node in the FIB graph.
Definition: fib_node.h:277
static u64 gre_mk_key(const ip4_address_t *src, const ip4_address_t *dst, u32 out_fib_index)
Definition: interface.c:30
clib_error_t * gre_interface_admin_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:448
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:169
static clib_error_t * show_gre_tunnel_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: interface.c:572
fib_node_index_t fib_table_entry_special_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags)
Add a &#39;special&#39; entry to the FIB.
Definition: fib_table.c:369
gre_tunnel_type_t type
Definition: gre.h:101
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
vlib_main_t * vm
Definition: buffer.c:276
void fib_table_entry_delete_index(fib_node_index_t fib_entry_index, fib_source_t source)
Delete a FIB entry.
Definition: fib_table.c:821
fib_node_get_t fnv_get
Definition: fib_node.h:265
#define clib_memcpy(a, b, c)
Definition: string.h:69
ip4_address_t tunnel_src
The tunnel&#39;s source/local address.
Definition: gre.h:90
static void vnet_interface_counter_unlock(vnet_interface_main_t *im)
Definition: interface.h:651
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
static u32 ip4_fib_index_from_table_id(u32 table_id)
Definition: ip4_fib.h:110
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
void adj_nbr_walk(u32 sw_if_index, fib_protocol_t adj_nh_proto, adj_walk_cb_t cb, void *ctx)
Walk the neighbour Adjacencies on a given interface.
Definition: adj_nbr.c:569
Context passed between object during a back walk.
Definition: fib_node.h:190
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
static u8 * format_gre_tunnel_type(u8 *s, va_list *args)
Definition: interface.c:39
static void vnet_interface_counter_lock(vnet_interface_main_t *im)
Definition: interface.h:643
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:536
u32 max_l3_packet_bytes[VLIB_N_RX_TX]
Definition: interface.h:451
#define ASSERT(truth)
static fib_node_back_walk_rc_t gre_tunnel_back_walk(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Function definition to backwalk a FIB node.
Definition: interface.c:187
void adj_nbr_midchain_stack(adj_index_t adj_index, const dpo_id_t *next)
adj_nbr_midchain_stack
Definition: adj_midchain.c:483
unsigned int u32
Definition: types.h:88
clib_error_t * ethernet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, u8 *address, u32 *hw_if_index_return, ethernet_flag_change_function_t flag_change)
Definition: interface.c:246
gre_tunnel_t * tunnels
pool of tunnel instances
Definition: gre.h:134
IPv4 main type.
Definition: ip4.h:107
#define clib_error_report(e)
Definition: error.h:125
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
void adj_nbr_midchain_unstack(adj_index_t adj_index)
adj_nbr_midchain_unstack
Definition: adj_midchain.c:460
vnet_hw_interface_class_t gre_hw_interface_class
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u64 uword
Definition: types.h:112
u32 l2_tx_arc
on a L2 tunnel this is the VLIB arc from the L2-tx to the l2-midchain
Definition: gre.h:119
fib_node_t node
Linkage into the FIB object graph.
Definition: gre.h:85
Definition: defs.h:47
vnet_device_class_t gre_device_class
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
Transparent Ethernet Bridging - the tunnel is in L2 mode.
Definition: gre.h:68
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:62
A FIB graph nodes virtual function table.
Definition: fib_node.h:264
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1117
adj_index_t adj_nbr_add_or_lock(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Neighbour Adjacency sub-type.
Definition: adj_nbr.c:216
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:538
vlib_main_t * vlib_main
Definition: gre.h:167
u32 per_packet_overhead_bytes
Definition: interface.h:448
u32 flags
Definition: vhost-user.h:78
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:485
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:577
int vnet_gre_add_del_tunnel(vnet_gre_add_del_tunnel_args_t *a, u32 *sw_if_indexp)
Definition: interface.c:438
gre_main_t gre_main
Definition: gre.c:22
static int vnet_gre_tunnel_delete(vnet_gre_add_del_tunnel_args_t *a, u32 *sw_if_indexp)
Definition: interface.c:396
static const char * gre_tunnel_type_names[]
Definition: interface.c:27
const ip46_address_t zero_addr
Definition: lookup.c:354
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:971
Definition: defs.h:46
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
#define MODE_L3
Definition: l2_input.h:181
static void gre_tunnel_last_lock_gone(fib_node_t *node)
Function definition to inform the FIB node that its last lock has gone.
Definition: interface.c:214
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:109