FD.io VPP  v18.07-rc0-415-g6c78436
Vector Packet Processing
lisp_gpe_adjacency.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  * @file
17  * @brief Common utility functions for IPv4, IPv6 and L2 LISP-GPE adjacencys.
18  *
19  */
20 
21 #include <vnet/dpo/load_balance.h>
22 #include <vnet/lisp-cp/control.h>
27 #include <vnet/fib/fib_entry.h>
28 #include <vnet/adj/adj_midchain.h>
29 #include <vppinfra/bihash_24_8.h>
31 
32 /**
33  * Memory pool of all adjacencies
34  */
36 
37 /**
38  * Hash table of all adjacencies. key:{nh, itf}
39  * We never have an all zeros address since the interfaces are multi-access,
40  * therefore there is no ambiguity between a v4 and v6 next-hop, so we don't
41  * need to add the protocol to the key.
42  */
43 static
44 BVT (clib_bihash)
46 
47 #define LISP_ADJ_SET_KEY(_key, _itf, _nh) \
48 { \
49  _key.key[0] = (_nh)->ip.v6.as_u64[0]; \
50  _key.key[1] = (_nh)->ip.v6.as_u64[1]; \
51  _key.key[2] = (_itf); \
52 }
53 
54  static index_t lisp_adj_find (const ip_address_t * addr, u32 sw_if_index)
55 {
56  BVT (clib_bihash_kv) kv;
57 
58  LISP_ADJ_SET_KEY (kv, sw_if_index, addr);
59 
60  if (BV (clib_bihash_search) (&lisp_adj_db, &kv, &kv) < 0)
61  {
62  return (INDEX_INVALID);
63  }
64  else
65  {
66  return (kv.value);
67  }
68 }
69 
70 static void
71 lisp_adj_insert (const ip_address_t * addr, u32 sw_if_index, index_t ai)
72 {
73  BVT (clib_bihash_kv) kv;
74 
75  LISP_ADJ_SET_KEY (kv, sw_if_index, addr);
76  kv.value = ai;
77 
78  BV (clib_bihash_add_del) (&lisp_adj_db, &kv, 1);
79 }
80 
81 static void
82 lisp_adj_remove (const ip_address_t * addr, u32 sw_if_index)
83 {
84  BVT (clib_bihash_kv) kv;
85 
86  LISP_ADJ_SET_KEY (kv, sw_if_index, addr);
87 
88  BV (clib_bihash_add_del) (&lisp_adj_db, &kv, 0);
89 }
90 
91 static lisp_gpe_adjacency_t *
93 {
94  return (pool_elt_at_index (lisp_adj_pool, lai));
95 }
96 
99 {
100  switch (ip_addr_version (&ladj->remote_rloc))
101  {
102  case IP4:
104  case IP6:
106  default:
107  ASSERT (0);
108  break;
109  }
111 }
112 
113 static void
114 ip46_address_to_ip_address (const ip46_address_t * a, ip_address_t * b)
115 {
116  if (ip46_address_is_ip4 (a))
117  {
118  memset (b, 0, sizeof (*b));
119  ip_address_set (b, &a->ip4, IP4);
120  }
121  else
122  {
123  ip_address_set (b, &a->ip6, IP6);
124  }
125 }
126 
127 /**
128  * @brief Stack the tunnel's midchain on the IP forwarding chain of the via
129  */
130 static void
132 {
133  const lisp_gpe_tunnel_t *lgt;
134  dpo_id_t tmp = DPO_INVALID;
135 
136  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
139  &tmp);
140 
141  if (DPO_LOAD_BALANCE == tmp.dpoi_type)
142  {
143  /*
144  * post LISP rewrite we will load-balance. However, the LISP encap
145  * is always the same for this adjacency/tunnel and hence the IP/UDP src,dst
146  * hash is always the same result too. So we do that hash now and
147  * stack on the choice.
148  * If the choice is an incomplete adj then we will need a poke when
149  * it becomes complete. This happens since the adj update walk propagates
150  * as far a recursive paths.
151  */
152  const dpo_id_t *choice;
153  load_balance_t *lb;
154  int hash;
155 
156  lb = load_balance_get (tmp.dpoi_index);
157 
158  if (IP4 == ip_addr_version (&ladj->remote_rloc))
159  {
161  lb->lb_hash_config);
162  }
163  else
164  {
166  lb->lb_hash_config);
167  }
168 
169  choice =
171  dpo_copy (&tmp, choice);
172  }
173 
174  adj_nbr_midchain_stack (ai, &tmp);
175  dpo_reset (&tmp);
176 }
177 
178 /**
179  * @brief Call back when restacking all adjacencies on a GRE interface
180  */
181 static adj_walk_rc_t
183 {
184  lisp_gpe_adjacency_t *ladj = ctx;
185 
186  lisp_gpe_adj_stack_one (ladj, ai);
187 
188  return (ADJ_WALK_RC_CONTINUE);
189 }
190 
191 static void
193 {
194  fib_protocol_t nh_proto;
195  ip46_address_t nh;
196 
197  ip_address_to_46 (&ladj->remote_rloc, &nh, &nh_proto);
198 
199  /*
200  * walk all the adjacencies on th lisp interface and restack them
201  */
203  nh_proto, &nh, lisp_gpe_adj_walk_cb, ladj);
204 }
205 
208 {
209  switch (linkt)
210  {
211  case VNET_LINK_IP4:
212  return (LISP_GPE_NEXT_PROTO_IP4);
213  case VNET_LINK_IP6:
214  return (LISP_GPE_NEXT_PROTO_IP6);
215  case VNET_LINK_ETHERNET:
217  case VNET_LINK_NSH:
218  return (LISP_GPE_NEXT_PROTO_NSH);
219  default:
220  ASSERT (0);
221  }
222  return (LISP_GPE_NEXT_PROTO_IP4);
223 }
224 
225 #define is_v4_packet(_h) ((*(u8*) _h) & 0xF0) == 0x40
226 
227 static lisp_afi_e
229 {
230  switch (link)
231  {
232  case VNET_LINK_IP4:
233  return LISP_AFI_IP;
234  case VNET_LINK_IP6:
235  return LISP_AFI_IP6;
236  case VNET_LINK_ETHERNET:
237  return LISP_AFI_MAC;
238  default:
239  return LISP_AFI_NO_ADDR;
240  }
241 }
242 
243 static void
245  vlib_buffer_t * b)
246 {
248  lisp_gpe_adjacency_t *ladj;
249  ip_address_t rloc;
250  index_t lai;
251  u32 si, di;
252  gid_address_t src, dst;
253  uword *feip;
254 
255  ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
256  si = vnet_buffer (b)->sw_if_index[VLIB_TX];
257  lai = lisp_adj_find (&rloc, si);
258  ASSERT (INDEX_INVALID != lai);
259 
260  ladj = pool_elt_at_index (lisp_adj_pool, lai);
261 
262  u8 *lisp_data = (u8 *) vlib_buffer_get_current (b);
263 
264  /* skip IP header */
265  if (is_v4_packet (lisp_data))
266  lisp_data += sizeof (ip4_header_t);
267  else
268  lisp_data += sizeof (ip6_header_t);
269 
270  /* skip UDP header */
271  lisp_data += sizeof (udp_header_t);
272  // TODO: skip TCP?
273 
274  /* skip LISP GPE header */
275  lisp_data += sizeof (lisp_gpe_header_t);
276 
277  i16 saved_current_data = b->current_data;
278  b->current_data = lisp_data - b->data;
279 
281  get_src_and_dst_eids_from_buffer (lcm, b, &src, &dst, afi);
282  b->current_data = saved_current_data;
283  di = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid, &dst, &src);
284  if (PREDICT_FALSE (~0 == di))
285  {
286  clib_warning ("dst mapping not found (%U, %U)", format_gid_address,
287  &src, format_gid_address, &dst);
288  return;
289  }
290 
291  feip = hash_get (lcm->fwd_entry_by_mapping_index, di);
292  if (PREDICT_FALSE (!feip))
293  return;
294 
296  memset (&key, 0, sizeof (key));
297  key.fwd_entry_index = feip[0];
298  key.tunnel_index = ladj->tunnel_index;
299 
300  uword *p = hash_get_mem (lgm->lisp_stats_index_by_key, &key);
301  ASSERT (p);
302 
303  /* compute payload length starting after GPE */
304  u32 bytes = b->current_length - (lisp_data - b->data - b->current_data);
306  p[0], 1, bytes);
307 }
308 
309 static void
311  ip_adjacency_t * adj, vlib_buffer_t * b, const void *data)
312 {
314 
315  if (lcm->flags & LISP_FLAG_STATS_ENABLED)
316  lisp_gpe_increment_stats_counters (lcm, adj, b);
317 
318  /* Fixup the checksum and len fields in the LISP tunnel encap
319  * that was applied at the midchain node */
321 }
322 
323 /**
324  * @brief The LISP-GPE interface registered function to update, i.e.
325  * provide an rewrite string for, an adjacency.
326  */
327 void
329 {
330  const lisp_gpe_tunnel_t *lgt;
331  lisp_gpe_adjacency_t *ladj;
332  ip_adjacency_t *adj;
333  ip_address_t rloc;
334  vnet_link_t linkt;
335  index_t lai;
336 
337  adj = adj_get (ai);
338  ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
339 
340  /*
341  * find an existing or create a new adj
342  */
343  lai = lisp_adj_find (&rloc, sw_if_index);
344 
345  ASSERT (INDEX_INVALID != lai);
346 
347  ladj = pool_elt_at_index (lisp_adj_pool, lai);
348  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
349  linkt = adj_get_link_type (ai);
351  (ai, lisp_gpe_fixup,
352  NULL,
353  (VNET_LINK_ETHERNET == linkt ?
355  ADJ_FLAG_NONE),
358  (linkt)));
359 
360  lisp_gpe_adj_stack_one (ladj, ai);
361 }
362 
363 u8 *
365  u32 sw_if_index,
366  vnet_link_t link_type, const void *dst_address)
367 {
368  ASSERT (0);
369  return (NULL);
370 }
371 
372 index_t
374  u32 overlay_table_id, u32 vni)
375 {
376  const lisp_gpe_sub_interface_t *l3s;
377  const lisp_gpe_tunnel_t *lgt;
378  lisp_gpe_adjacency_t *ladj;
379  index_t lai, l3si;
380 
381  /*
382  * first find the L3 sub-interface that corresponds to the loacl-rloc and vni
383  */
385  overlay_table_id,
386  vni);
387  l3s = lisp_gpe_sub_interface_get (l3si);
388 
389  /*
390  * find an existing or create a new adj
391  */
392  lai = lisp_adj_find (&pair->rmt_loc, l3s->sw_if_index);
393 
394  if (INDEX_INVALID == lai)
395  {
396 
397  pool_get (lisp_adj_pool, ladj);
398  memset (ladj, 0, sizeof (*ladj));
399  lai = (ladj - lisp_adj_pool);
400 
401  ip_address_copy (&ladj->remote_rloc, &pair->rmt_loc);
402  ladj->vni = vni;
403  /* transfer the lock to the adj */
404  ladj->lisp_l3_sub_index = l3si;
405  ladj->sw_if_index = l3s->sw_if_index;
406 
407  /* if vni is non-default */
408  if (ladj->vni)
409  ladj->flags = LISP_GPE_FLAGS_I;
410 
411  /* work in lisp-gpe not legacy mode */
412  ladj->flags |= LISP_GPE_FLAGS_P;
413 
414  /*
415  * find the tunnel that will provide the underlying transport
416  * and hence the rewrite.
417  * The RLOC FIB index is default table - always.
418  */
420 
421  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
422 
423  /*
424  * become of child of the RLOC FIB entry so we are updated when
425  * its reachability changes, allowing us to re-stack the midcahins
426  */
429  lai);
430 
431  lisp_adj_insert (&ladj->remote_rloc, ladj->sw_if_index, lai);
432  }
433  else
434  {
435  /* unlock the interface from the find. */
437  ladj = lisp_gpe_adjacency_get_i (lai);
438  }
439 
440  ladj->locks++;
441 
442  return (lai);
443 }
444 
445 /**
446  * @brief Get a pointer to a tunnel from a pointer to a FIB node
447  */
448 static lisp_gpe_adjacency_t *
450 {
451  return ((lisp_gpe_adjacency_t *)
452  ((char *) node -
454 }
455 
456 static void
458 {
459  const lisp_gpe_tunnel_t *lgt;
460 
461  /*
462  * no children so we are not counting locks. no-op.
463  * at least not counting
464  */
465  lisp_adj_remove (&ladj->remote_rloc, ladj->sw_if_index);
466 
467  /*
468  * unlock the resources this adj holds
469  */
470  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
471 
473 
476 
477  pool_put (lisp_adj_pool, ladj);
478 }
479 
480 void
482 {
483  lisp_gpe_adjacency_t *ladj;
484 
485  ladj = lisp_gpe_adjacency_get_i (lai);
486 
487  ladj->locks--;
488 
489  if (0 == ladj->locks)
490  {
492  }
493 }
494 
495 const lisp_gpe_adjacency_t *
497 {
498  return (lisp_gpe_adjacency_get_i (lai));
499 }
500 
501 
502 /**
503  * @brief LISP GPE tunnel back walk
504  *
505  * The FIB entry through which this tunnel resolves has been updated.
506  * re-stack the midchain on the new forwarding.
507  */
511 {
513 
515 }
516 
517 static fib_node_t *
519 {
520  lisp_gpe_adjacency_t *ladj;
521 
522  ladj = pool_elt_at_index (lisp_adj_pool, index);
523  return (&ladj->fib_node);
524 }
525 
526 static void
528 {
530 }
531 
532 const static fib_node_vft_t lisp_gpe_tuennel_vft = {
534  .fnv_back_walk = lisp_gpe_adjacency_back_walk,
535  .fnv_last_lock = lisp_gpe_adjacency_last_fib_lock_gone,
536 };
537 
538 u8 *
539 format_lisp_gpe_adjacency (u8 * s, va_list * args)
540 {
541  lisp_gpe_adjacency_t *ladj = va_arg (*args, lisp_gpe_adjacency_t *);
543  va_arg (*args, lisp_gpe_adjacency_format_flags_t);
544 
546  {
547  s =
548  format (s, "index %d locks:%d\n", ladj - lisp_adj_pool, ladj->locks);
549  }
550 
551  s = format (s, " vni: %d,", ladj->vni);
552  s = format (s, " remote-RLOC: %U,", format_ip_address, &ladj->remote_rloc);
553 
554  if (flags & LISP_GPE_ADJ_FORMAT_FLAG_DETAIL)
555  {
556  s = format (s, " %U\n",
559  s = format (s, " %U\n",
562  }
563  else
564  {
565  s = format (s, " LISP L3 sub-interface index: %d,",
566  ladj->lisp_l3_sub_index);
567  s = format (s, " LISP tunnel index: %d", ladj->tunnel_index);
568  }
569 
570 
571  return (s);
572 }
573 
574 static clib_error_t *
576  unformat_input_t * input, vlib_cli_command_t * cmd)
577 {
578  lisp_gpe_adjacency_t *ladj;
579  index_t index;
580 
581  if (pool_elts (lisp_adj_pool) == 0)
582  vlib_cli_output (vm, "No lisp-gpe Adjacencies");
583 
584  if (unformat (input, "%d", &index))
585  {
586  ladj = lisp_gpe_adjacency_get_i (index);
589  }
590  else
591  {
592  /* *INDENT-OFF* */
593  pool_foreach (ladj, lisp_adj_pool,
594  ({
595  vlib_cli_output (vm, "[%d] %U\n",
596  ladj - lisp_adj_pool,
599  }));
600  /* *INDENT-ON* */
601  }
602 
603  return 0;
604 }
605 
606 /* *INDENT-OFF* */
607 VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) =
608 {
609  .path = "show gpe adjacency",
610  .function = lisp_gpe_adjacency_show,
611 };
612 /* *INDENT-ON* */
613 
614 #define LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (256)
615 #define LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (1<<20)
616 
617 static clib_error_t *
619 {
621  "Adjacency Neighbour table",
624 
625  fib_node_register_type (FIB_NODE_TYPE_LISP_ADJ, &lisp_gpe_tuennel_vft);
626  return (NULL);
627 }
628 
630 /*
631  * fd.io coding-style-patch-verification: ON
632  *
633  * Local Variables:
634  * eval: (c-set-style "gnu")
635  * End:
636  */
const lisp_gpe_tunnel_t * lisp_gpe_tunnel_get(index_t lgti)
static lisp_gpe_adjacency_t * lisp_gpe_adjacency_get_i(index_t lai)
void adj_nbr_walk_nh(u32 sw_if_index, fib_protocol_t adj_nh_proto, const ip46_address_t *nh, adj_walk_cb_t cb, void *ctx)
Walk adjacencies on a link with a given next-hop.
Definition: adj_nbr.c:647
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:103
enum lisp_gpe_adjacency_format_flags_t_ lisp_gpe_adjacency_format_flags_t
Flags for displaying the adjacency.
a
Definition: bitmap.h:537
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:213
#define LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE
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.
u32 locks
The number of locks/reference counts on the adjacency.
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
const u8 * adj_get_rewrite(adj_index_t ai)
Return the rewrite string of the adjacency.
Definition: adj.c:424
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
LISP-GPE global state.
Definition: lisp_gpe.h:118
index_t lisp_gpe_tunnel_find_or_create_and_lock(const locator_pair_t *pair, u32 rloc_fib_index)
void fib_entry_child_remove(fib_node_index_t fib_entry_index, u32 sibling_index)
Definition: fib_entry.c:538
static clib_error_t * lisp_gpe_adj_module_init(vlib_main_t *vm)
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:261
static void lisp_gpe_adjacency_last_lock_gone(lisp_gpe_adjacency_t *ladj)
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
struct ip_adjacency_t_::@43::@44 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
u8 * format_lisp_gpe_tunnel(u8 *s, va_list *args)
Format LISP-GPE tunnel.
lisp_gpe_fwd_entry_key_t * key
The Entry&#39;s key: {lEID,rEID,vni}.
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:99
static index_t lisp_adj_find(const ip_address_t *addr, u32 sw_if_index)
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:62
static fib_node_t * lisp_gpe_adjacency_get_fib_node(fib_node_index_t index)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
void ip_address_copy(ip_address_t *dst, const ip_address_t *src)
Definition: lisp_types.c:886
void ip_address_set(ip_address_t *dst, const void *src, u8 version)
Definition: lisp_types.c:908
u8 * format_lisp_gpe_sub_interface(u8 *s, va_list *ap)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:227
static fib_node_back_walk_rc_t lisp_gpe_adjacency_back_walk(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
LISP GPE tunnel back walk.
unsigned char u8
Definition: types.h:56
static clib_error_t * lisp_gpe_adjacency_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
union ip_adjacency_t_::@43 sub_type
void fib_node_register_type(fib_node_type_t type, const fib_node_vft_t *vft)
fib_node_register_type
Definition: fib_node.c:60
vnet_link_t ia_link
link/ether-type 1 bytes
Definition: adj.h:196
static lisp_gpe_next_protocol_e lisp_gpe_adj_proto_from_vnet_link_type(vnet_link_t linkt)
u32 fib_entry_child_index
This adjacency is a child of the FIB entry to reach the RLOC.
static lisp_gpe_main_t * vnet_lisp_gpe_get_main()
Definition: lisp_gpe.h:183
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
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:104
fib_node_index_t fib_entry_index
the FIB entry through which the remote rloc is reachable s
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:440
int clib_bihash_add_del(clib_bihash *h, clib_bihash_kv *add_v, int is_add)
Add or delete a (key,value) pair from a bi-hash table.
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
u32 fwd_entry_index
Definition: lisp_gpe.h:95
fib_node_t fib_node
The LISP adj is a part of the FIB control plane graph.
u16 lb_n_buckets_minus_1
number of buckets in the load-balance - 1.
Definition: load_balance.h:99
static BVT(clib_bihash)
Definition: adj_nbr.c:26
vlib_combined_counter_main_t counters
Definition: lisp_gpe.h:164
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
static void lisp_gpe_adj_stack(lisp_gpe_adjacency_t *ladj)
void lisp_gpe_tunnel_unlock(index_t lgti)
void di(unformat_input_t *i)
Definition: unformat.c:163
void lisp_gpe_adjacency_unlock(index_t lai)
u32 * fwd_entry_by_mapping_index
Definition: control.h:196
static void lisp_gpe_increment_stats_counters(lisp_cp_main_t *lcm, ip_adjacency_t *adj, vlib_buffer_t *b)
const lisp_gpe_sub_interface_t * lisp_gpe_sub_interface_get(index_t l3si)
u32 sw_if_index
The SW if index assigned to this sub-interface.
u8 * lisp_gpe_build_rewrite(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t link_type, const void *dst_address)
unsigned int u32
Definition: types.h:88
static lisp_cp_main_t * vnet_lisp_cp_get_main()
Definition: control.h:301
#define ip_addr_version(_a)
Definition: lisp_types.h:56
Common utility functions for IPv4, IPv6 and L2 LISP-GPE adjacencys.
LISP sub-interfaces.
static void ip46_address_to_ip_address(const ip46_address_t *a, ip_address_t *b)
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_get(h, key)
Definition: hash.h:249
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:461
Common utility functions for IPv4, IPv6 and L2 LISP-GPE tunnels.
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:108
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
struct _unformat_input_t unformat_input_t
load-balancing over a choice of [un]equal cost paths
Definition: dpo.h:102
static lisp_adj_db
Hash table of all adjacencies.
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:273
The FIB DPO provieds;.
Definition: load_balance.h:84
#define PREDICT_FALSE(x)
Definition: clib.h:105
u32 sw_if_index
The SW IF index of the sub-interface this adjacency uses.
u8 * format_gid_address(u8 *s, va_list *args)
Definition: lisp_types.c:265
const lisp_gpe_adjacency_t * lisp_gpe_adjacency_get(index_t lai)
#define LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS
ip_address_t lcl_loc
Definition: lisp_types.h:386
#define is_v4_packet(_h)
An node in the FIB graph.
Definition: fib_node.h:286
void clib_bihash_init(clib_bihash *h, char *name, u32 nbuckets, uword memory_size)
initialize a bounded index extensible hash table
static void lisp_gpe_adjacency_last_fib_lock_gone(fib_node_t *node)
lisp_afi_e
Definition: lisp_types.h:239
void ip_address_to_46(const ip_address_t *addr, ip46_address_t *a, fib_protocol_t *proto)
Definition: lisp_types.c:915
#define ip46_address_is_ip4(ip46)
Definition: ip6_packet.h:81
index_t lisp_gpe_adjacency_find_or_create_and_lock(const locator_pair_t *pair, u32 overlay_table_id, u32 vni)
static void ip_udp_fixup_one(vlib_main_t *vm, vlib_buffer_t *b0, u8 is_ip4)
Definition: udp.h:272
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:221
vlib_main_t * vm
Definition: buffer.c:294
#define LISP_ADJ_SET_KEY(_key, _itf, _nh)
#define clib_warning(format, args...)
Definition: error.h:59
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:274
Packets TX through the midchain do not increment the interface counters.
Definition: adj.h:166
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
LISP-GPE header.
void lisp_gpe_sub_interface_unlock(index_t l3si)
Context passed between object during a back walk.
Definition: fib_node.h:199
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
struct _gid_address_t gid_address_t
#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
u8 * format_ip_address(u8 *s, va_list *args)
Definition: lisp_types.c:144
long ctx[MAX_CONNS]
Definition: main.c:126
static lisp_afi_e lisp_afi_from_vnet_link_type(vnet_link_t link)
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
gid_dictionary_t mapping_index_by_gid
Definition: control.h:168
u32 gid_dictionary_sd_lookup(gid_dictionary_t *db, gid_address_t *dst, gid_address_t *src)
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
static adj_walk_rc_t lisp_gpe_adj_walk_cb(adj_index_t ai, void *ctx)
Call back when restacking all adjacencies on a GRE interface.
Definition: defs.h:47
A LISP GPE Adjacency.
dpo_id_t choice
The DPO used for forwarding.
index_t lisp_gpe_sub_interface_find_or_create_and_lock(const ip_address_t *lrloc, u32 overlay_table_id, u32 vni)
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:184
A LISP L3 sub-interface.
u32 tunnel_index
The index of the LISP GPE tunnel that provides the transport in the underlay.
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
static void lisp_gpe_fixup(vlib_main_t *vm, ip_adjacency_t *adj, vlib_buffer_t *b, const void *data)
u64 uword
Definition: types.h:112
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:195
u8 * lisp_gpe_tunnel_build_rewrite(const lisp_gpe_tunnel_t *lgt, const lisp_gpe_adjacency_t *ladj, lisp_gpe_next_protocol_e payload_proto)
Compute IP-UDP-GPE sub-tunnel encap/rewrite header.
fib_forward_chain_type_t lisp_gpe_adj_get_fib_chain_type(const lisp_gpe_adjacency_t *ladj)
Definition: lisp_types.h:37
#define hash_get_mem(h, key)
Definition: hash.h:269
static void lisp_adj_remove(const ip_address_t *addr, u32 sw_if_index)
A FIB graph nodes virtual function table.
Definition: fib_node.h:273
u8 * format_lisp_gpe_adjacency(u8 *s, va_list *args)
#define vnet_buffer(b)
Definition: buffer.h:360
static lisp_gpe_adjacency_t * lisp_adj_pool
Memory pool of all adjacencies.
void get_src_and_dst_eids_from_buffer(lisp_cp_main_t *lcm, vlib_buffer_t *b, gid_address_t *src, gid_address_t *dst, u16 type)
Definition: control.c:3269
ip_address_t rmt_loc
Definition: lisp_types.h:387
u8 data[0]
Packet data.
Definition: buffer.h:172
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:231
static lisp_gpe_adjacency_t * lisp_gpe_adjacency_from_fib_node(const fib_node_t *node)
Get a pointer to a tunnel from a pointer to a FIB node.
u32 lisp_l3_sub_index
The index of the LISP L3 subinterface.
vhost_vring_addr_t addr
Definition: vhost-user.h:83
uword * lisp_stats_index_by_key
Definition: lisp_gpe.h:163
lisp_gpe_next_protocol_e
u32 flags
Definition: vhost-user.h:77
Definition: lisp_types.h:38
fib_node_t node
This object joins the FIB control plane graph to receive updates to for changes to the graph...
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:681
u8 flags
LISP header fields in HOST byte order.
ip_address_t remote_rloc
remote RLOC.
A LISP GPE Tunnel.
static void lisp_adj_insert(const ip_address_t *addr, u32 sw_if_index, index_t ai)
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static void lisp_gpe_adj_stack_one(lisp_gpe_adjacency_t *ladj, adj_index_t ai)
Stack the tunnel&#39;s midchain on the IP forwarding chain of the via.
signed short i16
Definition: types.h:46
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128