FD.io VPP  v17.10-9-gd594711
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 {
313 
314  if (lcm->flags & LISP_FLAG_STATS_ENABLED)
315  lisp_gpe_increment_stats_counters (lcm, adj, b);
316 
317  /* Fixup the checksum and len fields in the LISP tunnel encap
318  * that was applied at the midchain node */
320 }
321 
322 /**
323  * @brief The LISP-GPE interface registered function to update, i.e.
324  * provide an rewrite string for, an adjacency.
325  */
326 void
328 {
329  const lisp_gpe_tunnel_t *lgt;
330  lisp_gpe_adjacency_t *ladj;
331  ip_adjacency_t *adj;
332  ip_address_t rloc;
333  vnet_link_t linkt;
334  index_t lai;
335 
336  adj = adj_get (ai);
337  ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
338 
339  /*
340  * find an existing or create a new adj
341  */
342  lai = lisp_adj_find (&rloc, sw_if_index);
343 
344  ASSERT (INDEX_INVALID != lai);
345 
346  ladj = pool_elt_at_index (lisp_adj_pool, lai);
347  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
348  linkt = adj_get_link_type (ai);
350  (ai, lisp_gpe_fixup,
351  (VNET_LINK_ETHERNET == linkt ?
353  ADJ_FLAG_NONE),
356  (linkt)));
357 
358  lisp_gpe_adj_stack_one (ladj, ai);
359 }
360 
361 u8 *
363  u32 sw_if_index,
364  vnet_link_t link_type, const void *dst_address)
365 {
366  ASSERT (0);
367  return (NULL);
368 }
369 
370 index_t
372  u32 overlay_table_id, u32 vni)
373 {
374  const lisp_gpe_sub_interface_t *l3s;
375  const lisp_gpe_tunnel_t *lgt;
376  lisp_gpe_adjacency_t *ladj;
377  index_t lai, l3si;
378 
379  /*
380  * first find the L3 sub-interface that corresponds to the loacl-rloc and vni
381  */
383  overlay_table_id,
384  vni);
385  l3s = lisp_gpe_sub_interface_get (l3si);
386 
387  /*
388  * find an existing or create a new adj
389  */
390  lai = lisp_adj_find (&pair->rmt_loc, l3s->sw_if_index);
391 
392  if (INDEX_INVALID == lai)
393  {
394 
395  pool_get (lisp_adj_pool, ladj);
396  memset (ladj, 0, sizeof (*ladj));
397  lai = (ladj - lisp_adj_pool);
398 
399  ip_address_copy (&ladj->remote_rloc, &pair->rmt_loc);
400  ladj->vni = vni;
401  /* transfer the lock to the adj */
402  ladj->lisp_l3_sub_index = l3si;
403  ladj->sw_if_index = l3s->sw_if_index;
404 
405  /* if vni is non-default */
406  if (ladj->vni)
407  ladj->flags = LISP_GPE_FLAGS_I;
408 
409  /* work in lisp-gpe not legacy mode */
410  ladj->flags |= LISP_GPE_FLAGS_P;
411 
412  /*
413  * find the tunnel that will provide the underlying transport
414  * and hence the rewrite.
415  * The RLOC FIB index is default table - always.
416  */
418 
419  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
420 
421  /*
422  * become of child of the RLOC FIB entry so we are updated when
423  * its reachability changes, allowing us to re-stack the midcahins
424  */
427  lai);
428 
429  lisp_adj_insert (&ladj->remote_rloc, ladj->sw_if_index, lai);
430  }
431  else
432  {
433  /* unlock the interface from the find. */
435  ladj = lisp_gpe_adjacency_get_i (lai);
436  }
437 
438  ladj->locks++;
439 
440  return (lai);
441 }
442 
443 /**
444  * @brief Get a pointer to a tunnel from a pointer to a FIB node
445  */
446 static lisp_gpe_adjacency_t *
448 {
449  return ((lisp_gpe_adjacency_t *)
450  ((char *) node -
452 }
453 
454 static void
456 {
457  const lisp_gpe_tunnel_t *lgt;
458 
459  /*
460  * no children so we are not counting locks. no-op.
461  * at least not counting
462  */
463  lisp_adj_remove (&ladj->remote_rloc, ladj->sw_if_index);
464 
465  /*
466  * unlock the resources this adj holds
467  */
468  lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
469 
471 
474 
475  pool_put (lisp_adj_pool, ladj);
476 }
477 
478 void
480 {
481  lisp_gpe_adjacency_t *ladj;
482 
483  ladj = lisp_gpe_adjacency_get_i (lai);
484 
485  ladj->locks--;
486 
487  if (0 == ladj->locks)
488  {
490  }
491 }
492 
493 const lisp_gpe_adjacency_t *
495 {
496  return (lisp_gpe_adjacency_get_i (lai));
497 }
498 
499 
500 /**
501  * @brief LISP GPE tunnel back walk
502  *
503  * The FIB entry through which this tunnel resolves has been updated.
504  * re-stack the midchain on the new forwarding.
505  */
509 {
511 
513 }
514 
515 static fib_node_t *
517 {
518  lisp_gpe_adjacency_t *ladj;
519 
520  ladj = pool_elt_at_index (lisp_adj_pool, index);
521  return (&ladj->fib_node);
522 }
523 
524 static void
526 {
528 }
529 
530 const static fib_node_vft_t lisp_gpe_tuennel_vft = {
532  .fnv_back_walk = lisp_gpe_adjacency_back_walk,
533  .fnv_last_lock = lisp_gpe_adjacency_last_fib_lock_gone,
534 };
535 
536 u8 *
537 format_lisp_gpe_adjacency (u8 * s, va_list * args)
538 {
539  lisp_gpe_adjacency_t *ladj = va_arg (*args, lisp_gpe_adjacency_t *);
541  va_arg (*args, lisp_gpe_adjacency_format_flags_t);
542 
544  {
545  s =
546  format (s, "index %d locks:%d\n", ladj - lisp_adj_pool, ladj->locks);
547  }
548 
549  s = format (s, " vni: %d,", ladj->vni);
550  s = format (s, " remote-RLOC: %U,", format_ip_address, &ladj->remote_rloc);
551 
552  if (flags & LISP_GPE_ADJ_FORMAT_FLAG_DETAIL)
553  {
554  s = format (s, " %U\n",
557  s = format (s, " %U\n",
560  }
561  else
562  {
563  s = format (s, " LISP L3 sub-interface index: %d,",
564  ladj->lisp_l3_sub_index);
565  s = format (s, " LISP tunnel index: %d", ladj->tunnel_index);
566  }
567 
568 
569  return (s);
570 }
571 
572 static clib_error_t *
574  unformat_input_t * input, vlib_cli_command_t * cmd)
575 {
576  lisp_gpe_adjacency_t *ladj;
577  index_t index;
578 
579  if (pool_elts (lisp_adj_pool) == 0)
580  vlib_cli_output (vm, "No lisp-gpe Adjacencies");
581 
582  if (unformat (input, "%d", &index))
583  {
584  ladj = lisp_gpe_adjacency_get_i (index);
587  }
588  else
589  {
590  /* *INDENT-OFF* */
591  pool_foreach (ladj, lisp_adj_pool,
592  ({
593  vlib_cli_output (vm, "[%d] %U\n",
594  ladj - lisp_adj_pool,
597  }));
598  /* *INDENT-ON* */
599  }
600 
601  return 0;
602 }
603 
604 /* *INDENT-OFF* */
605 VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) =
606 {
607  .path = "show gpe adjacency",
608  .function = lisp_gpe_adjacency_show,
609 };
610 /* *INDENT-ON* */
611 
612 #define LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (256)
613 #define LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (1<<20)
614 
615 static clib_error_t *
617 {
619  "Adjacency Neighbour table",
622 
623  fib_node_register_type (FIB_NODE_TYPE_LISP_ADJ, &lisp_gpe_tuennel_vft);
624  return (NULL);
625 }
626 
628 /*
629  * fd.io coding-style-patch-verification: ON
630  *
631  * Local Variables:
632  * eval: (c-set-style "gnu")
633  * End:
634  */
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:672
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:85
enum lisp_gpe_adjacency_format_flags_t_ lisp_gpe_adjacency_format_flags_t
Flags for displaying the adjacency.
a
Definition: bitmap.h:516
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:211
#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:504
const u8 * adj_get_rewrite(adj_index_t ai)
Return the rewrite string of the adjacency.
Definition: adj.c:408
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:355
#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:174
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:409
flow_hash_config_t lb_hash_config
the hash config to use when selecting a bucket.
Definition: load_balance.h:128
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:515
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:255
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
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:81
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
static void lisp_gpe_fixup(vlib_main_t *vm, ip_adjacency_t *adj, vlib_buffer_t *b)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:225
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.
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.
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
vnet_link_t ia_link
link/ether-type 1 bytes
Definition: adj.h:195
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.
void adj_nbr_midchain_update_rewrite(adj_index_t adj_index, adj_midchain_fixup_t fixup, adj_flags_t flags, u8 *rewrite)
adj_nbr_midchain_update_rewrite
Definition: adj_midchain.c:504
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:365
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:68
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:437
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:111
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:93
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:193
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)
static lisp_cp_main_t * vnet_lisp_cp_get_main()
Definition: control.h:300
#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:150
#define hash_get(h, key)
Definition: hash.h:248
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:458
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:72
struct ip_adjacency_t_::@38::@39 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
dpo_type_t dpoi_type
the type
Definition: dpo.h:154
static const dpo_id_t * load_balance_get_bucket_i(const load_balance_t *lb, u32 bucket)
Definition: load_balance.h:202
struct _unformat_input_t unformat_input_t
load-balancing over a choice of [un]equal cost paths
Definition: dpo.h:100
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:193
static u32 ip6_compute_flow_hash(const ip6_header_t *ip, flow_hash_config_t flow_hash_config)
Definition: ip6.h:404
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:270
The FIB DPO provieds;.
Definition: load_balance.h:84
#define PREDICT_FALSE(x)
Definition: clib.h:97
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:279
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
union ip_adjacency_t_::@38 sub_type
#define ip46_address_is_ip4(ip46)
Definition: ip6_packet.h:76
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:185
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:221
vlib_main_t * vm
Definition: buffer.c:283
#define LISP_ADJ_SET_KEY(_key, _itf, _nh)
#define clib_warning(format, args...)
Definition: error.h:59
fib_node_get_t fnv_get
Definition: fib_node.h:267
Packets TX through the midchain do not increment the interface counters.
Definition: adj.h:165
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
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:192
#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:565
unsigned int u32
Definition: types.h:88
u8 * format_ip_address(u8 *s, va_list *args)
Definition: lisp_types.c:144
int clib_bihash_search(clib_bihash *h, clib_bihash_kv *search_v, clib_bihash_kv *return_v)
Search a bi-hash table.
long ctx[MAX_CONNS]
Definition: main.c:95
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:193
gid_dictionary_t mapping_index_by_gid
Definition: control.h:165
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.
u64 uword
Definition: types.h:112
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:166
unsigned char u8
Definition: types.h:56
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
u8 * format_lisp_gpe_sub_interface(u8 *s, va_list ap)
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:177
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:268
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:266
u8 * format_lisp_gpe_adjacency(u8 *s, va_list *args)
short i16
Definition: types.h:46
#define vnet_buffer(b)
Definition: buffer.h:306
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:3143
ip_address_t rmt_loc
Definition: lisp_types.h:387
u8 data[0]
Packet data.
Definition: buffer.h:157
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:225
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:680
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.
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128