FD.io VPP  v21.01
Vector Packet Processing
adj.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 #include <vnet/adj/adj.h>
17 #include <vnet/adj/adj_internal.h>
18 #include <vnet/adj/adj_glean.h>
19 #include <vnet/adj/adj_midchain.h>
20 #include <vnet/adj/adj_mcast.h>
21 #include <vnet/adj/adj_delegate.h>
22 #include <vnet/fib/fib_node_list.h>
23 
24 /* Adjacency packet/byte counters indexed by adjacency index. */
25 vlib_combined_counter_main_t adjacency_counters = {
26  .name = "adjacency",
27  .stat_segment_name = "/net/adjacency",
28 };
29 
30 /*
31  * the single adj pool
32  */
34 
35 /**
36  * @brief Global Config for enabling per-adjacency counters.
37  * By default these are disabled.
38  */
40 
41 const ip46_address_t ADJ_BCAST_ADDR = {
42  .ip6 = {
43  .as_u64[0] = 0xffffffffffffffff,
44  .as_u64[1] = 0xffffffffffffffff,
45  },
46 };
47 
48 /**
49  * Adj flag names
50  */
51 static const char *adj_attr_names[] = ADJ_ATTR_NAMES;
52 
53 always_inline void
55 {
56  if (CLIB_DEBUG > 0)
57  {
58  clib_memset (adj, 0xfe, sizeof (adj[0]));
59  }
60 }
61 
64 {
65  ip_adjacency_t *adj;
66  u8 need_barrier_sync = 0;
67  vlib_main_t *vm;
68  vm = vlib_get_main();
69 
70  ASSERT (vm->thread_index == 0);
71 
72  pool_get_aligned_will_expand (adj_pool, need_barrier_sync,
74  /* If the adj_pool will expand, stop the parade. */
75  if (need_barrier_sync)
77 
79 
80  adj_poison(adj);
81 
82  /* Validate adjacency counters. */
83  if (need_barrier_sync == 0)
84  {
85  /* If the adj counter pool will expand, stop the parade */
87  (&adjacency_counters, adj_get_index (adj));
88  if (need_barrier_sync)
90  }
91  vlib_validate_combined_counter(&adjacency_counters,
92  adj_get_index(adj));
93 
94  /* Make sure certain fields are always initialized. */
95  vlib_zero_combined_counter(&adjacency_counters,
96  adj_get_index(adj));
97  fib_node_init(&adj->ia_node,
99 
100  adj->ia_nh_proto = proto;
101  adj->ia_flags = 0;
102  adj->ia_cfg_index = 0;
103  adj->rewrite_header.sw_if_index = ~0;
104  adj->rewrite_header.flags = 0;
105  adj->lookup_next_index = 0;
106  adj->ia_delegates = NULL;
107 
108  /* lest it become a midchain in the future */
109  clib_memset(&adj->sub_type.midchain.next_dpo, 0,
110  sizeof(adj->sub_type.midchain.next_dpo));
111 
112  if (need_barrier_sync)
114 
115  return (adj);
116 }
117 
118 static int
120 {
121  if (ADJ_INDEX_INVALID == adj_index)
122  return (!0);
123 
124  return (0);
125 }
126 
127 u8*
128 format_adj_flags (u8 * s, va_list * args)
129 {
130  adj_flags_t af;
131  adj_attr_t at;
132 
133  af = va_arg (*args, int);
134 
135  if (ADJ_FLAG_NONE == af)
136  {
137  return (format(s, "None"));
138  }
140  {
141  if (af & (1 << at))
142  {
143  s = format(s, "%s ", adj_attr_names[at]);
144  }
145  }
146  return (s);
147 }
148 
149 /**
150  * @brief Pretty print helper function for formatting specific adjacencies.
151  * @param s - input string to format
152  * @param args - other args passed to format function such as:
153  * - vnet_main_t
154  * - ip_lookup_main_t
155  * - adj_index
156  */
157 u8 *
158 format_ip_adjacency (u8 * s, va_list * args)
159 {
161  ip_adjacency_t * adj;
162  u32 adj_index;
163 
164  adj_index = va_arg (*args, u32);
165  fiaf = va_arg (*args, format_ip_adjacency_flags_t);
166 
167  if (!adj_is_valid(adj_index))
168  return format(s, "<invalid adjacency>");
169 
170  adj = adj_get(adj_index);
171 
172  switch (adj->lookup_next_index)
173  {
176  s = format (s, "%U", format_adj_nbr, adj_index, 0);
177  break;
178  case IP_LOOKUP_NEXT_ARP:
179  s = format (s, "%U", format_adj_nbr_incomplete, adj_index, 0);
180  break;
182  s = format (s, "%U", format_adj_glean, adj_index, 0);
183  break;
185  s = format (s, "%U", format_adj_midchain, adj_index, 2);
186  break;
188  s = format (s, "%U", format_adj_mcast, adj_index, 0);
189  break;
191  s = format (s, "%U", format_adj_mcast_midchain, adj_index, 0);
192  break;
193  case IP_LOOKUP_NEXT_DROP:
194  case IP_LOOKUP_NEXT_PUNT:
197  case IP_LOOKUP_N_NEXT:
198  break;
199  }
200 
201  if (fiaf & FORMAT_IP_ADJACENCY_DETAIL)
202  {
203  vlib_counter_t counts;
204 
205  vlib_get_combined_counter(&adjacency_counters, adj_index, &counts);
206  s = format (s, "\n flags:%U", format_adj_flags, adj->ia_flags);
207  s = format (s, "\n counts:[%Ld:%Ld]", counts.packets, counts.bytes);
208  s = format (s, "\n locks:%d", adj->ia_node.fn_locks);
209  s = format(s, "\n delegates:");
210  s = adj_delegate_format(s, adj);
211 
212  s = format(s, "\n children:");
214  {
215  s = format(s, "\n ");
217  }
218  }
219 
220  return s;
221 }
222 
223 int
225  fib_node_index_t **entry_indicies)
226 {
227  ip_adjacency_t * adj;
228 
229  adj = adj_get(ai);
230 
231  switch (adj->lookup_next_index)
232  {
234  case IP_LOOKUP_NEXT_ARP:
238  case IP_LOOKUP_NEXT_DROP:
239  case IP_LOOKUP_NEXT_PUNT:
242  case IP_LOOKUP_N_NEXT:
243  /*
244  * these adjacency types are terminal graph nodes, so there's no
245  * possibility of a loop down here.
246  */
247  break;
250  return (adj_ndr_midchain_recursive_loop_detect(ai, entry_indicies));
251  }
252 
253  return (0);
254 }
255 
256 /*
257  * adj_last_lock_gone
258  *
259  * last lock/reference to the adj has gone, we no longer need it.
260  */
261 static void
263 {
265 
267  ADJ_DBG(adj, "last-lock-gone");
268 
270 
272 
273  switch (adj->lookup_next_index)
274  {
277  /* FALL THROUGH */
278  case IP_LOOKUP_NEXT_ARP:
281  /*
282  * complete and incomplete nbr adjs
283  */
285  adj->ia_nh_proto,
286  adj->ia_link,
287  &adj->sub_type.nbr.next_hop,
288  adj->rewrite_header.sw_if_index);
289  break;
291  adj_glean_remove(adj);
292  break;
295  /* FALL THROUGH */
298  adj->rewrite_header.sw_if_index);
299  break;
300  case IP_LOOKUP_NEXT_DROP:
301  case IP_LOOKUP_NEXT_PUNT:
304  case IP_LOOKUP_N_NEXT:
305  /*
306  * type not stored in any DB from which we need to remove it
307  */
308  break;
309  }
310 
312 
313  fib_node_deinit(&adj->ia_node);
314  ASSERT(0 == vec_len(adj->ia_delegates));
315  vec_free(adj->ia_delegates);
316  pool_put(adj_pool, adj);
317 }
318 
319 u32
321 {
322  ip_adjacency_t *adj;
323 
324  adj = adj_get(dpo->dpoi_index);
325 
326  return (adj->rewrite_header.sw_if_index);
327 }
328 
329 void
331 {
332  ip_adjacency_t *adj;
333 
334  if (adj_index_is_special(adj_index))
335  {
336  return;
337  }
338 
339  adj = adj_get(adj_index);
340  ASSERT(adj);
341 
342  ADJ_DBG(adj, "lock");
343  fib_node_lock(&adj->ia_node);
344 }
345 
346 void
348 {
349  ip_adjacency_t *adj;
350 
351  if (adj_index_is_special(adj_index))
352  {
353  return;
354  }
355 
356  adj = adj_get(adj_index);
357  ASSERT(adj);
358 
359  ADJ_DBG(adj, "unlock");
360  ASSERT(adj);
361 
362  fib_node_unlock(&adj->ia_node);
363 }
364 
365 u32
367  fib_node_type_t child_type,
368  fib_node_index_t child_index)
369 {
370  ASSERT(ADJ_INDEX_INVALID != adj_index);
371  if (adj_index_is_special(adj_index))
372  {
373  return (~0);
374  }
375 
377  adj_index,
378  child_type,
379  child_index));
380 }
381 
382 void
384  u32 sibling_index)
385 {
386  if (adj_index_is_special(adj_index))
387  {
388  return;
389  }
390 
392  adj_index,
393  sibling_index);
394 }
395 
396 /*
397  * Context for the walk to update the cached feature flags.
398  */
399 typedef struct adj_feature_update_t_
400 {
404 
405 static adj_walk_rc_t
407  void *arg)
408 {
410  ip_adjacency_t *adj;
411 
412  adj = adj_get(ai);
413 
414  /*
415  * this ugly mess matches the feature arc that is changing with affected
416  * adjacencies
417  */
419  (VNET_LINK_IP6 == adj->ia_link)) ||
421  (VNET_LINK_IP4 == adj->ia_link)) ||
423  (VNET_LINK_MPLS == adj->ia_link)))
424  {
427 
428  cm = &fm->feature_config_mains[ctx->arc];
429 
430  if (ctx->enable)
431  adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
432  else
433  adj->rewrite_header.flags &= ~VNET_REWRITE_HAS_FEATURES;
434 
436  adj->rewrite_header.sw_if_index);
437  }
438  return (ADJ_WALK_RC_CONTINUE);
439 }
440 
441 static void
443  u8 arc_index,
444  u8 is_enable,
445  void *data)
446 {
447  /*
448  * Walk all the adjacencies on the interface to update the cached
449  * 'has-features' flag
450  */
452  .arc = arc_index,
453  .enable = is_enable,
454  };
455  adj_walk (sw_if_index, adj_feature_update_walk_cb, &ctx);
456 }
457 
458 static adj_walk_rc_t
460  void *arg)
461 {
462  ip_adjacency_t *adj;
463 
464  adj = adj_get(ai);
465 
467  &adj->rewrite_header);
468 
469  return (ADJ_WALK_RC_CONTINUE);
470 }
471 
472 static clib_error_t *
474 {
475  adj_walk (sw_if_index, adj_mtu_update_walk_cb, NULL);
476 
477  return (NULL);
478 }
479 
481 
482 /**
483  * @brief Walk the Adjacencies on a given interface
484  */
485 void
487  adj_walk_cb_t cb,
488  void *ctx)
489 {
490  /*
491  * walk all the neighbor adjacencies
492  */
494 
496  {
497  adj_nbr_walk(sw_if_index, proto, cb, ctx);
498  adj_mcast_walk(sw_if_index, proto, cb, ctx);
499  }
500 }
501 
502 /**
503  * @brief Return the link type of the adjacency
504  */
507 {
508  const ip_adjacency_t *adj;
509 
510  adj = adj_get(ai);
511 
512  return (adj->ia_link);
513 }
514 
515 /**
516  * @brief Return the sw interface index of the adjacency.
517  */
518 u32
520 {
521  const ip_adjacency_t *adj;
522 
523  adj = adj_get(ai);
524 
525  return (adj->rewrite_header.sw_if_index);
526 }
527 
528 /**
529  * @brief Return true if the adjacency is 'UP', i.e. can be used for forwarding
530  * 0 is down, !0 is up.
531  */
532 int
534 {
535  return (adj_bfd_is_up(ai));
536 }
537 
538 /**
539  * @brief Return the rewrite string of the adjacency
540  */
541 const u8*
543 {
545  ip_adjacency_t *adj;
546 
547  adj = adj_get(ai);
548  rw = &adj->rewrite_header;
549 
550  ASSERT (rw->data_bytes != 0xfefe);
551 
552  return (rw->data - rw->data_bytes);
553 }
554 
555 static fib_node_t *
557 {
558  ip_adjacency_t *adj;
559 
560  adj = adj_get(index);
561 
562  return (&adj->ia_node);
563 }
564 
565 #define ADJ_FROM_NODE(_node) \
566  ((ip_adjacency_t*)((char*)_node - STRUCT_OFFSET_OF(ip_adjacency_t, ia_node)))
567 
568 static void
570 {
572 }
573 
577 {
578  ip_adjacency_t *adj;
579 
580  adj = ADJ_FROM_NODE(node);
581 
582  switch (adj->lookup_next_index)
583  {
586  break;
587  case IP_LOOKUP_NEXT_ARP:
593  case IP_LOOKUP_NEXT_DROP:
594  case IP_LOOKUP_NEXT_PUNT:
597  case IP_LOOKUP_N_NEXT:
598  /*
599  * Que pasa. yo soj en el final!
600  */
601  ASSERT(0);
602  break;
603  }
604 
606 }
607 
608 /*
609  * Adjacency's graph node virtual function table
610  */
611 static const fib_node_vft_t adj_vft = {
613  .fnv_last_lock = adj_node_last_lock_gone,
614  .fnv_back_walk = adj_back_walk_notify,
615 };
616 
617 static clib_error_t *
619 {
621 
626 
628 
629  return (NULL);
630 }
631 
633 
634 static clib_error_t *
636  unformat_input_t * input,
637  vlib_cli_command_t * cmd)
638 {
640  u32 sw_if_index = ~0;
641  int summary = 0;
642 
644  {
645  if (unformat (input, "%d", &ai))
646  ;
647  else if (unformat (input, "summary") || unformat (input, "sum"))
648  summary = 1;
649  else if (unformat (input, "%U",
651  &sw_if_index))
652  ;
653  else
654  break;
655  }
656 
657  if (summary)
658  {
659  vlib_cli_output (vm, "Number of adjacencies: %d", pool_elts(adj_pool));
660  vlib_cli_output (vm, "Per-adjacency counters: %s",
662  "enabled":
663  "disabled"));
664  }
665  else
666  {
667  if (ADJ_INDEX_INVALID != ai)
668  {
669  if (pool_is_free_index(adj_pool, ai))
670  {
671  vlib_cli_output (vm, "adjacency %d invalid", ai);
672  return 0;
673  }
674 
675  vlib_cli_output (vm, "[@%d] %U",
676  ai,
679  }
680  else
681  {
682  /* *INDENT-OFF* */
683  pool_foreach_index (ai, adj_pool)
684  {
685  if (~0 != sw_if_index &&
686  sw_if_index != adj_get_sw_if_index(ai))
687  {
688  }
689  else
690  {
691  vlib_cli_output (vm, "[@%d] %U",
692  ai,
695  }
696  }
697  /* *INDENT-ON* */
698  }
699  }
700  return 0;
701 }
702 
703 /*?
704  * Show all adjacencies.
705  * @cliexpar
706  * @cliexstart{sh adj}
707  * [@0]
708  * [@1] glean: loop0
709  * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
710  * [@3] mpls via 1.0.0.2 loop0: MPLS: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
711  * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
712  * [@5] mpls via 1.0.0.3 loop0: MPLS: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
713  * @cliexend
714  ?*/
715 VLIB_CLI_COMMAND (adj_show_command, static) = {
716  .path = "show adj",
717  .short_help = "show adj [<adj_index>] [interface] [summary]",
718  .function = adj_show,
719 };
720 
721 /**
722  * @brief CLI invoked function to enable/disable per-adj counters
723  */
724 static clib_error_t *
726  unformat_input_t * input,
727  vlib_cli_command_t * cmd)
728 {
729  clib_error_t *error = NULL;
730  int enable = ~0;
731 
733  {
734  if (unformat (input, "enable"))
735  enable = 1;
736  else if (unformat (input, "disable"))
737  enable = 0;
738  else
739  break;
740  }
741 
742  if (enable != ~0)
743  {
744  /* user requested something sensible */
746  }
747  else
748  {
749  error = clib_error_return (0, "specify 'enable' or 'disable'");
750  }
751 
752  return (error);
753 }
754 
755 /*?
756  * Enable/disable per-adjacency counters. This is optional because it comes
757  * with a non-negligible performance cost.
758  ?*/
759 VLIB_CLI_COMMAND (adj_cli_counters_set_command, static) = {
760  .path = "adjacency counters",
761  .short_help = "adjacency counters [enable|disable]",
762  .function = adj_cli_counters_set,
763 };
void vnet_feature_register(vnet_feature_update_cb_t cb, void *data)
Definition: feature.c:29
void adj_delegate_adj_deleted(ip_adjacency_t *adj)
Definition: adj_delegate.c:142
adj_flags_t ia_flags
Flags on the adjacency 1-bytes.
Definition: adj.h:356
ip_adjacency_t * adj_pool
The global adjacency pool.
Definition: adj.c:33
#define pool_foreach_index(i, v)
Definition: pool.h:569
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:108
enum adj_attr_t_ adj_attr_t
Flags on an IP adjacency.
u8 * format_adj_mcast_midchain(u8 *s, va_list *ap)
Definition: adj_mcast.c:354
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105
u8 * format_adj_nbr(u8 *s, va_list *ap)
Format a neigbour (REWRITE) adjacency.
Definition: adj_nbr.c:1015
static int adj_index_is_special(adj_index_t adj_index)
Definition: adj.c:119
void adj_lock(adj_index_t adj_index)
Take a reference counting lock on the adjacency.
Definition: adj.c:330
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:185
const u8 * adj_get_rewrite(adj_index_t ai)
Return the rewrite string of the adjacency.
Definition: adj.c:542
int vlib_validate_combined_counter_will_expand(vlib_combined_counter_main_t *cm, u32 index)
Definition: counter.c:124
Multicast Adjacency.
Definition: adj.h:82
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:506
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
Broadcast Adjacency.
Definition: adj.h:85
IP unicast adjacency.
Definition: adj.h:235
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
u32 thread_index
Definition: main.h:250
#define pool_get_aligned_will_expand(P, YESNO, A)
See if pool_get will expand the pool or not.
Definition: pool.h:257
This packet is to be rewritten and forwarded to the next processing node.
Definition: adj.h:73
Combined counter to hold both packets and byte differences.
Definition: counter_types.h:26
void fib_node_deinit(fib_node_t *node)
Definition: fib_node.c:197
ip_lookup_main_t lookup_main
Definition: ip4.h:109
struct ip_adjacency_t_::@161::@163 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
vlib_main_t * vm
Definition: in2out_ed.c:1578
unformat_function_t unformat_vnet_sw_interface
u8 * format_adj_nbr_incomplete(u8 *s, va_list *ap)
Format aa incomplete neigbour (ARP) adjacency.
Definition: adj_nbr.c:996
void adj_child_remove(adj_index_t adj_index, u32 sibling_index)
Remove a child dependent.
Definition: adj.c:383
u32 adj_dpo_get_urpf(const dpo_id_t *dpo)
Definition: adj.c:320
unsigned char u8
Definition: types.h:56
#define ADJ_ATTR_NAMES
Definition: adj.h:196
u8 data[128]
Definition: ipsec_types.api:90
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u32 fib_node_child_add(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_type_t type, fib_node_index_t index)
Definition: fib_node.c:98
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:205
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:343
#define fm
Adjacency to punt this packet.
Definition: adj.h:55
u8 output_feature_arc_index
Definition: lookup.h:145
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:467
struct ip_adjacency_t_::@161::@162 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
description fragment has unexpected format
Definition: map.api:433
void adj_mcast_walk(u32 sw_if_index, fib_protocol_t proto, adj_walk_cb_t cb, void *ctx)
Walk the multicast Adjacencies on a given interface.
Definition: adj_mcast.c:316
#define clib_error_return(e, args...)
Definition: error.h:99
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:347
int adj_bfd_is_up(adj_index_t ai)
Definition: adj_bfd.c:239
unsigned int u32
Definition: types.h:88
static clib_error_t * adj_cli_counters_set(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
CLI invoked function to enable/disable per-adj counters.
Definition: adj.c:725
void adj_nbr_remove(adj_index_t ai, fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Definition: adj_nbr.c:85
u8 output_feature_arc_index
Definition: mpls.h:57
#define ADJ_DBG(_e, _fmt, _args...)
big switch to turn on Adjacency debugging
Definition: adj_internal.h:42
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:170
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
Definition: cJSON.c:84
#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
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:304
int adj_is_up(adj_index_t ai)
Return true if the adjacency is &#39;UP&#39;, i.e.
Definition: adj.c:533
counter_t packets
packet counter
Definition: counter_types.h:28
u32 adj_get_sw_if_index(adj_index_t ai)
Return the sw interface index of the adjacency.
Definition: adj.c:519
vl_api_ip_proto_t proto
Definition: acl_types.api:51
void fib_node_lock(fib_node_t *node)
Definition: fib_node.c:203
long ctx[MAX_CONNS]
Definition: main.c:144
void adj_midchain_module_init(void)
Module initialisation.
Definition: adj_midchain.c:777
int adj_ndr_midchain_recursive_loop_detect(adj_index_t ai, fib_node_index_t **entry_indicies)
descend the FIB graph looking for loops
Definition: adj_midchain.c:659
static adj_index_t adj_get_index(const ip_adjacency_t *adj)
Get a pointer to an adjacency object from its index.
Definition: adj_internal.h:101
struct _unformat_input_t unformat_input_t
#define ADJ_FROM_NODE(_node)
Definition: adj.c:565
void adj_glean_remove(ip_adjacency_t *adj)
Definition: adj_glean.c:297
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:301
void adj_midchain_delegate_restack(adj_index_t ai)
restack a midchain delegate
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
Definition: adj.h:68
#define always_inline
Definition: ipsec.h:28
ip6_main_t ip6_main
Definition: ip6_forward.c:2785
int adj_per_adj_counters
Global Config for enabling per-adjacency counters.
Definition: adj.c:39
static fib_node_back_walk_rc_t adj_back_walk_notify(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Definition: adj.c:575
An node in the FIB graph.
Definition: fib_node.h:295
void adj_nbr_module_init(void)
Module initialisation.
Definition: adj_nbr.c:1125
void fib_node_unlock(fib_node_t *node)
Definition: fib_node.c:209
fib_node_t ia_node
Linkage into the FIB node graph.
Definition: adj.h:243
void adj_mcast_remove(fib_protocol_t proto, u32 sw_if_index)
Definition: adj_mcast.c:180
u8 * format_adj_flags(u8 *s, va_list *args)
Format adjacency flags.
Definition: adj.c:128
void adj_glean_module_init(void)
Module initialisation.
Definition: adj_glean.c:498
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:245
static clib_error_t * adj_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: adj.c:635
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
Definition: adj.h:63
Adjacency to drop this packet.
Definition: adj.h:53
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
fib_node_list_t fn_children
Vector of nodes that depend upon/use/share this node.
Definition: fib_node.h:309
mpls_main_t mpls_main
Definition: mpls.c:25
int adj_recursive_loop_detect(adj_index_t ai, fib_node_index_t **entry_indicies)
descend the FIB graph looking for loops
Definition: adj.c:224
static void vlib_get_combined_counter(const vlib_combined_counter_main_t *cm, u32 index, vlib_counter_t *result)
Get the value of a combined counter, never called in the speed path Scrapes the entire set of per-thr...
Definition: counter.h:278
static void adj_last_lock_gone(ip_adjacency_t *adj)
Definition: adj.c:262
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
Multicast Midchain Adjacency.
Definition: adj.h:89
fib_node_get_t fnv_get
Definition: fib_node.h:283
u8 * format_adj_glean(u8 *s, va_list *ap)
Format/display a glean adjacency.
Definition: adj_glean.c:419
static clib_error_t * adj_mtu_update(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: adj.c:473
void adj_mcast_module_init(void)
Module initialisation.
Definition: adj_mcast.c:477
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
static adj_walk_rc_t adj_mtu_update_walk_cb(adj_index_t ai, void *arg)
Definition: adj.c:459
adj_walk_rc_t(* adj_walk_cb_t)(adj_index_t ai, void *ctx)
Call back function when walking adjacencies.
Definition: adj_types.h:50
static void adj_poison(ip_adjacency_t *adj)
Definition: adj.c:54
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:298
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
u8 * format_adj_mcast(u8 *s, va_list *ap)
Format/display a mcast adjacency.
Definition: adj_mcast.c:331
void adj_nbr_walk(u32 sw_if_index, fib_protocol_t adj_nh_proto, adj_walk_cb_t cb, void *ctx)
Walk all adjacencies on a link for a given next-hop protocol.
Definition: adj_nbr.c:571
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1578
Context passed between object during a back walk.
Definition: fib_node.h:208
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
void adj_walk(u32 sw_if_index, adj_walk_cb_t cb, void *ctx)
Walk the Adjacencies on a given interface.
Definition: adj.c:486
u8 * format_adj_midchain(u8 *s, va_list *ap)
Format a midchain adjacency.
Definition: adj_midchain.c:686
This packets follow a mid-chain adjacency.
Definition: adj.h:76
static const char * adj_attr_names[]
Adj flag names.
Definition: adj.c:51
u32 fib_node_list_get_size(fib_node_list_t list)
#define ASSERT(truth)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:696
static fib_node_t * adj_get_node(fib_node_index_t index)
Definition: adj.c:556
ip_lookup_main_t lookup_main
Definition: ip6.h:112
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
u32 ia_cfg_index
feature [arc] config index
Definition: adj.h:247
void fib_node_child_remove(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_index_t sibling_index)
Definition: fib_node.c:123
#define FOR_EACH_ADJ_ATTR(_attr)
Definition: adj.h:205
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
enum adj_flags_t_ adj_flags_t
Flags on an IP adjacency.
#define vec_elt(v, i)
Get vector value at index i.
union ip_adjacency_t_::@161 sub_type
u8 * adj_delegate_format(u8 *s, ip_adjacency_t *adj)
Definition: adj_delegate.c:172
counter_t bytes
byte counter
Definition: counter_types.h:29
This packets needs to go to ICMP error.
Definition: adj.h:79
This packet is for one of our own IP addresses.
Definition: adj.h:58
fib_protocol_t ia_nh_proto
The protocol of the neighbor/peer.
Definition: adj.h:350
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:188
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:337
u32 fn_locks
Number of dependents on this node.
Definition: fib_node.h:315
u32 adj_child_add(adj_index_t adj_index, fib_node_type_t child_type, fib_node_index_t child_index)
Add a child dependent to an adjacency.
Definition: adj.c:366
u8 * format_ip_adjacency(u8 *s, va_list *args)
Pretty print helper function for formatting specific adjacencies.
Definition: adj.c:158
ip_adjacency_t * adj_alloc(fib_protocol_t proto)
Definition: adj.c:63
char * name
The counter collection&#39;s name.
Definition: counter.h:212
u32 index
Definition: flow_types.api:221
A collection of combined counters.
Definition: counter.h:207
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:69
static int adj_is_valid(adj_index_t adj_index)
Definition: adj.h:473
static void adj_node_last_lock_gone(fib_node_t *node)
Definition: adj.c:569
A FIB graph nodes virtual function table.
Definition: fib_node.h:282
enum fib_node_type_t_ fib_node_type_t
The types of nodes in a FIB graph.
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1561
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1105
void adj_midchain_teardown(ip_adjacency_t *adj)
adj_midchain_setup
Definition: adj_midchain.c:359
static clib_error_t * adj_module_init(vlib_main_t *vm)
Definition: adj.c:618
vnet_feature_config_main_t * feature_config_mains
feature config main objects
Definition: feature.h:100
u8 * fib_node_children_format(fib_node_list_t list, u8 *s)
Definition: fib_node.c:176
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
struct adj_feature_update_t_ adj_feature_update_ctx_t
This adjacency/interface has output features configured.
Definition: rewrite.h:57
VNET_SW_INTERFACE_MTU_CHANGE_FUNCTION(adj_mtu_update)
void vnet_rewrite_update_mtu(vnet_main_t *vnm, vnet_link_t linkt, vnet_rewrite_header_t *rw)
Definition: rewrite.c:92
vnet_feature_main_t feature_main
Definition: feature.c:18
static void adj_feature_update(u32 sw_if_index, u8 arc_index, u8 is_enable, void *data)
Definition: adj.c:442
static adj_walk_rc_t adj_feature_update_walk_cb(adj_index_t ai, void *arg)
Definition: adj.c:406
const ip46_address_t ADJ_BCAST_ADDR
The special broadcast address (to construct a broadcast adjacency.
Definition: adj.c:41
static int adj_are_counters_enabled(void)
Get the global configuration option for enabling per-adj counters.
Definition: adj.h:482
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
struct adj_delegate_t_ * ia_delegates
A sorted vector of delegates.
Definition: adj.h:325
enum format_ip_adjacency_flags_t_ format_ip_adjacency_flags_t
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127