FD.io VPP  v18.07.1-19-g511ce25
Vector Packet Processing
ipip.c
Go to the documentation of this file.
1 /*
2  * ipip.c: ipip
3  *
4  * Copyright (c) 2018 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 aipiped 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 <stddef.h>
19 #include <vnet/adj/adj_midchain.h>
20 #include <vnet/ipip/ipip.h>
21 #include <vnet/vnet.h>
22 #include <vnet/adj/adj_nbr.h>
23 #include <vnet/fib/ip4_fib.h>
24 #include <vnet/fib/ip6_fib.h>
25 #include <vnet/ip/format.h>
26 #include <vnet/ipip/ipip.h>
27 
29 
30 /* Packet trace structure */
31 typedef struct
32 {
35  ip46_address_t src;
36  ip46_address_t dst;
38 
39 u8 *
40 format_ipip_tx_trace (u8 * s, va_list * args)
41 {
42  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
43  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
44  ipip_tx_trace_t *t = va_arg (*args, ipip_tx_trace_t *);
45 
46  s =
47  format (s, "IPIP: tunnel %d len %d src %U dst %U", t->tunnel_id,
50  return s;
51 }
52 
53 static u8 *
54 ipip_build_rewrite (vnet_main_t * vnm, u32 sw_if_index,
55  vnet_link_t link_type, const void *dst_address)
56 {
57  ip4_header_t *ip4;
58  ip6_header_t *ip6;
59  u8 *rewrite = NULL;
61 
62  if (!t)
63  /* not one of ours */
64  return (0);
65 
66  switch (t->transport)
67  {
68  case IPIP_TRANSPORT_IP4:
69  vec_validate (rewrite, sizeof (*ip4) - 1);
70  ip4 = (ip4_header_t *) rewrite;
71  ip4->ip_version_and_header_length = 0x45;
72  ip4->ttl = 64;
73  /* fixup ip4 header length, protocol and checksum after-the-fact */
74  ip4->src_address.as_u32 = t->tunnel_src.ip4.as_u32;
75  ip4->dst_address.as_u32 = t->tunnel_dst.ip4.as_u32;
76  ip4->checksum = ip4_header_checksum (ip4);
77  if (t->tc_tos != 0xFF)
78  ip4->tos = t->tc_tos;
79  break;
80 
81  case IPIP_TRANSPORT_IP6:
82  vec_validate (rewrite, sizeof (*ip6) - 1);
83  ip6 = (ip6_header_t *) rewrite;
85  clib_host_to_net_u32 (6 << 28);
86  if (t->tc_tos != 0xFF)
88  ip6->hop_limit = 64;
89  /* fixup ip6 header length and protocol after-the-fact */
90  ip6->src_address.as_u64[0] = t->tunnel_src.ip6.as_u64[0];
91  ip6->src_address.as_u64[1] = t->tunnel_src.ip6.as_u64[1];
92  ip6->dst_address.as_u64[0] = t->tunnel_dst.ip6.as_u64[0];
93  ip6->dst_address.as_u64[1] = t->tunnel_dst.ip6.as_u64[1];
94  break;
95 
96  default:
97  /* pass through */
98  ;
99  }
100  return (rewrite);
101 }
102 
103 static void
105  const void *data)
106 {
107  ip4_header_t *ip4;
108  const ipip_tunnel_t *t = data;
109 
110  ip4 = vlib_buffer_get_current (b);
111  ip4->length = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b));
112  switch (adj->ia_link)
113  {
114  case VNET_LINK_IP6:
115  ip4->protocol = IP_PROTOCOL_IPV6;
116  if (t->tc_tos == 0xFF)
117  ip4->tos =
118  ip6_traffic_class_network_order ((const ip6_header_t *) (ip4 + 1));
119  break;
120 
121  case VNET_LINK_IP4:
122  ip4->protocol = IP_PROTOCOL_IP_IN_IP;
123  if (t->tc_tos == 0xFF)
124  ip4->tos = ((ip4_header_t *) (ip4 + 1))->tos;
125  break;
126 
127  default:
128  break;
129  }
130 
131  ip4->checksum = ip4_header_checksum (ip4);
132 }
133 
134 static void
136  const void *data)
137 {
138  ip6_header_t *ip6;
139  const ipip_tunnel_t *t = data;
140 
141  ip6 = vlib_buffer_get_current (b);
142  ip6->payload_length =
143  clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b) -
144  sizeof (*ip6));
145  switch (adj->ia_link)
146  {
147  case VNET_LINK_IP6:
148  ip6->protocol = IP_PROTOCOL_IPV6;
149  if (t->tc_tos == 0xFF)
151  ip6_traffic_class_network_order ((const ip6_header_t *) (ip6 + 1)));
152  break;
153 
154  case VNET_LINK_IP4:
155  ip6->protocol = IP_PROTOCOL_IP_IN_IP;
156  if (t->tc_tos == 0xFF)
158  ((ip4_header_t *) (ip6 +
159  1))->tos);
160  break;
161 
162  default:
163  break;
164  }
165 }
166 
167 static void
169 {
170  ip_adjacency_t *adj;
171  ipip_tunnel_t *t;
172  u32 sw_if_index;
173 
174  adj = adj_get (ai);
175  sw_if_index = adj->rewrite_header.sw_if_index;
176 
177  t = ipip_tunnel_db_find_by_sw_if_index (sw_if_index);
178  if (!t)
179  return;
180 
183  {
185  return;
186  }
187 
188  dpo_id_t tmp = DPO_INVALID;
189  fib_forward_chain_type_t fib_fwd =
190  t->transport ==
193 
194  fib_entry_contribute_forwarding (t->p2p.fib_entry_index, fib_fwd, &tmp);
195  if (DPO_LOAD_BALANCE == tmp.dpoi_type)
196  {
197  /*
198  * post IPIP rewrite we will load-balance. However, the IPIP encap
199  * is always the same for this adjacency/tunnel and hence the IP/IPIP
200  * src,dst hash is always the same result too. So we do that hash now and
201  * stack on the choice.
202  * If the choice is an incomplete adj then we will need a poke when
203  * it becomes complete. This happens since the adj update walk propagates
204  * as far a recursive paths.
205  */
206  const dpo_id_t *choice;
207  load_balance_t *lb;
208  int hash;
209 
210  lb = load_balance_get (tmp.dpoi_index);
211 
212  if (fib_fwd == FIB_FORW_CHAIN_TYPE_UNICAST_IP4)
214  lb->lb_hash_config);
215  else
217  lb->lb_hash_config);
218  choice =
220  dpo_copy (&tmp, choice);
221  }
222 
223  adj_nbr_midchain_stack (ai, &tmp);
224  dpo_reset (&tmp);
225 }
226 
227 static adj_walk_rc_t
229 {
230  ipip_tunnel_stack (ai);
231 
232  return (ADJ_WALK_RC_CONTINUE);
233 }
234 
235 static void
237 {
238  fib_protocol_t proto;
239 
240  /*
241  * walk all the adjacencies on th IPIP interface and restack them
242  */
244  {
246  }
247 }
248 
249 void
250 ipip_update_adj (vnet_main_t * vnm, u32 sw_if_index, adj_index_t ai)
251 {
252  ipip_tunnel_t *t;
254 
255  t = ipip_tunnel_db_find_by_sw_if_index (sw_if_index);
256  if (!t)
257  return;
258 
260 
263  adj_get_link_type (ai) ?
266  sw_if_index,
268  (ai),
269  NULL));
270  ipip_tunnel_stack (ai);
271 }
272 
273 static u8 *
274 format_ipip_tunnel_name (u8 * s, va_list * args)
275 {
276  u32 dev_instance = va_arg (*args, u32);
277  ipip_main_t *gm = &ipip_main;
278  ipip_tunnel_t *t;
279 
280  if (dev_instance >= vec_len (gm->tunnels))
281  return format (s, "<improperly-referenced>");
282 
283  t = pool_elt_at_index (gm->tunnels, dev_instance);
284  return format (s, "ipip%d", t->user_instance);
285 }
286 
287 static u8 *
288 format_ipip_device (u8 * s, va_list * args)
289 {
290  u32 dev_instance = va_arg (*args, u32);
291  CLIB_UNUSED (int verbose) = va_arg (*args, int);
292 
293  s = format (s, "IPIP tunnel: id %d\n", dev_instance);
294  return s;
295 }
296 
297 static clib_error_t *
299 {
301  ipip_tunnel_t *t;
302 
303  hi = vnet_get_hw_interface (vnm, hw_if_index);
304 
306  if (!t)
307  return 0;
308 
310  vnet_hw_interface_set_flags (vnm, hw_if_index,
312  else
313  vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */ );
314 
316 
317  return /* no error */ 0;
318 }
319 
320 /* *INDENT-OFF* */
321 VNET_DEVICE_CLASS(ipip_device_class) = {
322  .name = "IPIP tunnel device",
323  .format_device_name = format_ipip_tunnel_name,
324  .format_device = format_ipip_device,
325  .format_tx_trace = format_ipip_tx_trace,
326  .admin_up_down_function = ipip_interface_admin_up_down,
327 #ifdef SOON
328  .clear counter = 0;
329 #endif
330 };
331 
333  .name = "IPIP",
334  //.format_header = format_ipip_header_with_length,
335  //.unformat_header = unformat_ipip_header,
336  .build_rewrite = ipip_build_rewrite,
337  .update_adjacency = ipip_update_adj,
339 };
340 /* *INDENT-ON* */
341 
344 {
345  ipip_main_t *gm = &ipip_main;
346  uword *p;
347 
348  p = hash_get_mem (gm->tunnel_by_key, key);
349  if (!p)
350  return (NULL);
351  return (pool_elt_at_index (gm->tunnels, p[0]));
352 }
353 
356 {
357  ipip_main_t *gm = &ipip_main;
358  if (vec_len (gm->tunnel_index_by_sw_if_index) <= sw_if_index)
359  return NULL;
360  u32 ti = gm->tunnel_index_by_sw_if_index[sw_if_index];
361  if (ti == ~0)
362  return NULL;
363  return pool_elt_at_index (gm->tunnels, ti);
364 }
365 
366 void
368 {
369  ipip_main_t *gm = &ipip_main;
370 
371  t->key = clib_mem_alloc (sizeof (*t->key));
372  clib_memcpy (t->key, key, sizeof (*key));
374 }
375 
376 void
378 {
379  ipip_main_t *gm = &ipip_main;
380 
381  hash_unset_mem (gm->tunnel_by_key, t->key);
382  clib_mem_free (t->key);
383  t->key = NULL;
384 }
385 
386 static ipip_tunnel_t *
388 {
389  ipip_main_t *gm = &ipip_main;
390  ASSERT (gm->fib_node_type == node->fn_type);
391  return ((ipip_tunnel_t *) (((char *) node) -
392  offsetof (ipip_tunnel_t, p2p.node)));
393 }
394 
397 {
399 
401 }
402 
403 static fib_node_t *
405 {
406  ipip_tunnel_t *gt;
407  ipip_main_t *gm;
408 
409  gm = &ipip_main;
410  gt = pool_elt_at_index (gm->tunnels, index);
411 
412  return (&gt->p2p.node);
413 }
414 
415 static void
417 {
418  /*
419  * The MPLS IPIP tunnel is a root of the graph. As such
420  * it never has children and thus is never locked.
421  */
422  ASSERT (0);
423 }
424 
425 /*
426  * Virtual function table registered by IPIP tunnels
427  * for participation in the FIB object graph.
428  */
429 const static fib_node_vft_t ipip_vft = {
431  .fnv_last_lock = ipip_tunnel_last_lock_gone,
432  .fnv_back_walk = ipip_tunnel_back_walk,
433 };
434 
435 static void
437 {
438  ipip_main_t *gm = &ipip_main;
439  fib_prefix_t dst = {.fp_len = t->transport == IPIP_TRANSPORT_IP6 ? 128 : 32,
440  .fp_proto =
441  t->transport ==
443  .fp_addr = t->tunnel_dst
444  };
445 
446  t->p2p.fib_entry_index =
449  t->p2p.sibling_index =
450  fib_entry_child_add (t->p2p.fib_entry_index, gm->fib_node_type,
451  t->dev_instance);
452 }
453 
454 static void
456 {
457  fib_entry_child_remove (t->p2p.fib_entry_index, t->p2p.sibling_index);
458  fib_table_entry_delete_index (t->p2p.fib_entry_index, FIB_SOURCE_RR);
459  fib_node_deinit (&t->p2p.node);
460 }
461 
462 int
464  u32 instance, ip46_address_t * src, ip46_address_t * dst,
465  u32 fib_index, u8 tc_tos, u32 * sw_if_indexp)
466 {
467  ipip_main_t *gm = &ipip_main;
468  vnet_main_t *vnm = gm->vnet_main;
469  ip4_main_t *im4 = &ip4_main;
470  ip6_main_t *im6 = &ip6_main;
471  ipip_tunnel_t *t;
473  u32 hw_if_index, sw_if_index;
474  ipip_tunnel_key_t key = {.transport = transport,
475  .fib_index = fib_index,
476  .src = *src,
477  .dst = *dst
478  };
479  t = ipip_tunnel_db_find (&key);
480  if (t)
481  return VNET_API_ERROR_IF_ALREADY_EXISTS;
482 
484  memset (t, 0, sizeof (*t));
485 
486  /* Reconcile the real dev_instance and a possible requested instance */
487  u32 t_idx = t - gm->tunnels; /* tunnel index (or instance) */
488  u32 u_idx = instance; /* user specified instance */
489  if (u_idx == ~0)
490  u_idx = t_idx;
491  if (hash_get (gm->instance_used, u_idx))
492  {
493  pool_put (gm->tunnels, t);
494  return VNET_API_ERROR_INSTANCE_IN_USE;
495  }
496  hash_set (gm->instance_used, u_idx, 1);
497 
498  t->dev_instance = t_idx; /* actual */
499  t->user_instance = u_idx; /* name */
500  fib_node_init (&t->p2p.node, gm->fib_node_type);
501 
502  hw_if_index = vnet_register_interface (vnm, ipip_device_class.index, t_idx,
504  t_idx);
505 
506  hi = vnet_get_hw_interface (vnm, hw_if_index);
507  sw_if_index = hi->sw_if_index;
508 
509  t->hw_if_index = hw_if_index;
510  t->fib_index = fib_index;
511  t->sw_if_index = sw_if_index;
512  t->tc_tos = tc_tos;
513 
514  t->transport = transport;
516  gm->tunnel_index_by_sw_if_index[sw_if_index] = t_idx;
517 
518  if (t->transport == IPIP_TRANSPORT_IP4)
519  {
520  vec_validate (im4->fib_index_by_sw_if_index, sw_if_index);
521  hi->min_packet_bytes = 64 + sizeof (ip4_header_t);
522  }
523  else
524  {
525  vec_validate (im6->fib_index_by_sw_if_index, sw_if_index);
526  hi->min_packet_bytes = 64 + sizeof (ip6_header_t);
527  }
528 
529  /* Standard default ipip MTU. */
530  vnet_sw_interface_set_mtu (vnm, sw_if_index, 9000);
531 
532  t->tunnel_src = *src;
533  t->tunnel_dst = *dst;
534 
535  ipip_tunnel_db_add (t, &key);
536 
537  /*
538  * Source the FIB entry for the tunnel's destination and become a
539  * child thereof. The tunnel will then get poked when the forwarding
540  * for the entry updates, and the tunnel can re-stack accordingly
541  */
542  ipip_fib_add (t);
543  if (sw_if_indexp)
544  *sw_if_indexp = sw_if_index;
545 
547  {
548  ip6_register_protocol (IP_PROTOCOL_IP_IN_IP, ipip6_input_node.index);
549  ip6_register_protocol (IP_PROTOCOL_IPV6, ipip6_input_node.index);
550  gm->ip6_protocol_registered = true;
551  }
553  {
554  ip4_register_protocol (IP_PROTOCOL_IP_IN_IP, ipip4_input_node.index);
555  ip4_register_protocol (IP_PROTOCOL_IPV6, ipip4_input_node.index);
556  gm->ip4_protocol_registered = true;
557  }
558  return 0;
559 }
560 
561 int
562 ipip_del_tunnel (u32 sw_if_index)
563 {
564  ipip_main_t *gm = &ipip_main;
565  vnet_main_t *vnm = gm->vnet_main;
566  ipip_tunnel_t *t;
567 
568 
569  t = ipip_tunnel_db_find_by_sw_if_index (sw_if_index);
570  if (t == NULL)
571  return VNET_API_ERROR_NO_SUCH_ENTRY;
572 
573  vnet_sw_interface_set_flags (vnm, sw_if_index, 0 /* down */ );
574  gm->tunnel_index_by_sw_if_index[sw_if_index] = ~0;
576  ipip_fib_delete (t);
579  pool_put (gm->tunnels, t);
580 
581  return 0;
582 }
583 
584 static clib_error_t *
586 {
587  ipip_main_t *gm = &ipip_main;
588 
589  memset (gm, 0, sizeof (gm[0]));
590  gm->vlib_main = vm;
591  gm->vnet_main = vnet_get_main ();
592  gm->tunnel_by_key =
593  hash_create_mem (0, sizeof (ipip_tunnel_key_t), sizeof (uword));
594  gm->fib_node_type = fib_node_register_new_type (&ipip_vft);
595 
596  return 0;
597 }
598 
600 
601 /*
602  * fd.io coding-style-patch-verification: ON
603  *
604  * Local Variables:
605  * eval: (c-set-style "gnu")
606  * End:
607  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:437
vmrglw vmrglh hi
void ipip_tunnel_db_remove(ipip_tunnel_t *t)
Definition: ipip.c:377
Recursive resolution source.
Definition: fib_entry.h:125
struct ipip_tunnel_t::@229::@231 p2p
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:103
#define hash_set(h, key, value)
Definition: hash.h:255
#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:541
#define hash_unset(h, key)
Definition: hash.h:261
void ip6_register_protocol(u32 protocol, u32 node_index)
Definition: ip6_forward.c:1426
ip4_address_t src_address
Definition: ip4_packet.h:169
static fib_node_t * ipip_tunnel_fib_node_get(fib_node_index_t index)
Definition: ipip.c:404
fib_node_t node
Definition: ipip.h:90
A representation of a IPIP tunnel.
Definition: ipip.h:69
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
int ipip_add_tunnel(ipip_transport_t transport, u32 instance, ip46_address_t *src, ip46_address_t *dst, u32 fib_index, u8 tc_tos, u32 *sw_if_indexp)
Definition: ipip.c:463
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:185
ip46_address_t tunnel_src
Definition: ipip.h:77
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:527
static clib_error_t * ipip_interface_admin_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: ipip.c:298
u64 as_u64[2]
Definition: ip6_packet.h:51
u32 length
Definition: ipip.c:34
const u8 * adj_get_rewrite(adj_index_t ai)
Return the rewrite string of the adjacency.
Definition: adj.c:424
vnet_hw_interface_class_t ipip_hw_interface_class
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:388
#define NULL
Definition: clib.h:55
static u32 ip4_compute_flow_hash(const ip4_header_t *ip, flow_hash_config_t flow_hash_config)
Definition: ip4.h:287
IP unicast adjacency.
Definition: adj.h:175
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
void fib_entry_contribute_forwarding(fib_node_index_t fib_entry_index, fib_forward_chain_type_t fct, dpo_id_t *dpo)
Definition: fib_entry.c:419
flow_hash_config_t lb_hash_config
the hash config to use when selecting a bucket.
Definition: load_balance.h:134
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u8 tc_tos
Definition: ipip.h:84
void fib_entry_child_remove(fib_node_index_t fib_entry_index, u32 sibling_index)
Definition: fib_entry.c:538
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:261
static u8 * format_ipip_device(u8 *s, va_list *args)
Definition: ipip.c:288
format_function_t format_ip46_address
Definition: format.h:61
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:99
#define hash_set_mem(h, key, value)
Definition: hash.h:275
void fib_node_deinit(fib_node_t *node)
Definition: fib_node.c:197
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:111
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:458
void ip4_register_protocol(u32 protocol, u32 node_index)
Definition: ip4_forward.c:1584
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:250
u32 hw_if_index
Definition: ipip.h:80
ip6_address_t src_address
Definition: ip6_packet.h:347
bool ip4_protocol_registered
Definition: ipip.h:121
unsigned char u8
Definition: types.h:56
fib_node_type_t fib_node_register_new_type(const fib_node_vft_t *vft)
Create a new FIB node type and Register the function table for it.
Definition: fib_node.c:80
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
vnet_link_t ia_link
link/ether-type 1 bytes
Definition: adj.h:196
static void ipip_tunnel_last_lock_gone(fib_node_t *node)
Definition: ipip.c:416
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:370
static void ipip4_fixup(vlib_main_t *vm, ip_adjacency_t *adj, vlib_buffer_t *b, const void *data)
Definition: ipip.c:104
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
u32 user_instance
Definition: ipip.h:83
u16 lb_n_buckets_minus_1
number of buckets in the load-balance - 1.
Definition: load_balance.h:99
ip4_address_t dst_address
Definition: ip4_packet.h:169
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
static_always_inline void ip6_set_traffic_class_network_order(ip6_header_t *ip6, u8 dscp)
Definition: ip6_packet.h:364
static_always_inline u8 ip6_traffic_class_network_order(const ip6_header_t *ip6)
Definition: ip6_packet.h:357
static void ipip_tunnel_restack(ipip_tunnel_t *gt)
Definition: ipip.c:236
Aggregrate type for a prefix.
Definition: fib_types.h:193
u32 tunnel_id
Definition: ipip.c:33
u32 * tunnel_index_by_sw_if_index
Definition: ipip.h:111
unsigned int u32
Definition: types.h:88
ipip_transport_t transport
Definition: ipip.h:56
u16 fp_len
The mask length.
Definition: fib_types.h:197
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:758
Definition: fib_entry.h:275
ip46_address_t dst
Definition: ipip.c:36
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:168
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:661
#define hash_get(h, key)
Definition: hash.h:249
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
#define hash_unset_mem(h, key)
Definition: hash.h:291
void ipip_tunnel_db_add(ipip_tunnel_t *t, ipip_tunnel_key_t *key)
Definition: ipip.c:367
static void ipip_tunnel_stack(adj_index_t ai)
Definition: ipip.c:168
static u8 * ipip_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
Definition: ipip.c:54
static uword vnet_hw_interface_get_flags(vnet_main_t *vnm, u32 hw_if_index)
ipip_tunnel_t * ipip_tunnel_db_find(ipip_tunnel_key_t *key)
Definition: ipip.c:343
dpo_type_t dpoi_type
the type
Definition: dpo.h:172
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
Definition: load_balance.h:209
ipip_tunnel_t * ipip_tunnel_db_find_by_sw_if_index(u32 sw_if_index)
Definition: ipip.c:355
ipip_tunnel_t * tunnels
Definition: ipip.h:109
load-balancing over a choice of [un]equal cost paths
Definition: dpo.h:102
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:202
static u32 ip6_compute_flow_hash(const ip6_header_t *ip, flow_hash_config_t flow_hash_config)
Definition: ip6.h:430
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
The FIB DPO provieds;.
Definition: load_balance.h:84
fib_node_type_t fn_type
The node&#39;s type.
Definition: fib_node.h:291
An node in the FIB graph.
Definition: fib_node.h:287
u8 * format_ipip_tx_trace(u8 *s, va_list *args)
Definition: ipip.c:40
ipip_tunnel_key_t * key
Definition: ipip.h:76
static void ipip6_fixup(vlib_main_t *vm, ip_adjacency_t *adj, vlib_buffer_t *b, const void *data)
Definition: ipip.c:135
u32 flags
Definition: vhost_user.h:110
static adj_walk_rc_t ipip_adj_walk_cb(adj_index_t ai, void *ctx)
Definition: ipip.c:228
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:188
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:388
VNET_HW_INTERFACE_CLASS(ipip_hw_interface_class)
ipip_transport_t
IPIP Tunnel key.
Definition: ipip.h:46
ipip_main_t ipip_main
Definition: ipip.c:28
vlib_main_t * vm
Definition: buffer.c:294
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:877
static u8 * format_ipip_tunnel_name(u8 *s, va_list *args)
Definition: ipip.c:274
void adj_nbr_midchain_update_rewrite(adj_index_t adj_index, adj_midchain_fixup_t fixup, const void *fixup_data, adj_flags_t flags, u8 *rewrite)
adj_nbr_midchain_update_rewrite
Definition: adj_midchain.c:506
fib_node_get_t fnv_get
Definition: fib_node.h:275
#define clib_memcpy(a, b, c)
Definition: string.h:75
static void ipip_fib_add(ipip_tunnel_t *t)
Definition: ipip.c:436
Packets TX through the midchain do not increment the interface counters.
Definition: adj.h:166
vlib_node_registration_t ipip4_input_node
(constructor) VLIB_REGISTER_NODE (ipip4_input_node)
Definition: node.c:224
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
void(* adj_midchain_fixup_t)(vlib_main_t *vm, struct ip_adjacency_t_ *adj, vlib_buffer_t *b0, const void *data)
A function type for post-rewrite fixups on midchain adjacency.
Definition: adj.h:142
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:567
Context passed between object during a back walk.
Definition: fib_node.h:200
fib_node_type_t fib_node_type
Definition: ipip.h:112
u32 fib_index
Definition: ipip.h:79
#define VNET_SW_INTERFACE_FLAG_ADMIN_UP
Definition: interface.h:661
#define ASSERT(truth)
void adj_nbr_midchain_stack(adj_index_t adj_index, const dpo_id_t *next)
adj_nbr_midchain_stack
Definition: adj_midchain.c:570
static ipip_tunnel_t * ipip_tunnel_from_fib_node(fib_node_t *node)
Definition: ipip.c:387
ip6_main_t ip6_main
Definition: ip6_forward.c:2574
ipip_transport_t transport
Definition: ipip.h:75
long ctx[MAX_CONNS]
Definition: main.c:126
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
static load_balance_t * load_balance_get(index_t lbi)
Definition: load_balance.h:200
IPv4 main type.
Definition: ip4.h:95
static void ipip_fib_delete(ipip_tunnel_t *t)
Definition: ipip.c:455
static void clib_mem_free(void *p)
Definition: mem.h:179
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
uword * tunnel_by_key
Definition: ipip.h:110
void adj_nbr_midchain_unstack(adj_index_t adj_index)
adj_nbr_midchain_unstack
Definition: adj_midchain.c:548
ip46_address_t src
Definition: ipip.c:35
static void * clib_mem_alloc(uword size)
Definition: mem.h:112
void ipip_update_adj(vnet_main_t *vnm, u32 sw_if_index, adj_index_t ai)
Definition: ipip.c:250
u32 sw_if_index
Definition: ipip.h:81
void vnet_delete_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface.c:968
vlib_node_registration_t ipip6_input_node
(constructor) VLIB_REGISTER_NODE (ipip6_input_node)
Definition: node.c:241
u32 ip_version_traffic_class_and_flow_label
Definition: ip6_packet.h:334
u16 payload_length
Definition: ip6_packet.h:338
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:184
vnet_main_t * vnet_main
Definition: ipip.h:116
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
bool ip6_protocol_registered
Definition: ipip.h:122
u64 uword
Definition: types.h:112
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:195
static clib_error_t * ipip_init(vlib_main_t *vm)
Definition: ipip.c:585
a point 2 point interface
Definition: interface.h:345
void vnet_sw_interface_set_mtu(vnet_main_t *vnm, u32 sw_if_index, u32 mtu)
Definition: interface.c:676
int ipip_del_tunnel(u32 sw_if_index)
Definition: ipip.c:562
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:70
#define hash_get_mem(h, key)
Definition: hash.h:269
A FIB graph nodes virtual function table.
Definition: fib_node.h:274
u32 dev_instance
Definition: ipip.h:82
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:832
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:231
clib_error_t * vnet_sw_interface_set_flags(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: interface.c:549
u8 ip_version_and_header_length
Definition: ip4_packet.h:137
ip46_address_t tunnel_dst
Definition: ipip.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:486
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:62
vlib_main_t * vlib_main
Definition: ipip.h:115
u32 * fib_index_by_sw_if_index
Definition: ip6.h:176
static fib_node_back_walk_rc_t ipip_tunnel_back_walk(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Definition: ipip.c:396
static u16 ip4_header_checksum(ip4_header_t *i)
Definition: ip4_packet.h:246
uword * instance_used
Definition: ipip.h:119
VNET_DEVICE_CLASS(ipip_device_class)
ip6_address_t dst_address
Definition: ip6_packet.h:347