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