FD.io VPP  v19.04.4-rc0-5-ge88582fac
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 
68 
69  adj_poison(adj);
70 
71  /* Make sure certain fields are always initialized. */
72  /* Validate adjacency counters. */
73  vlib_validate_combined_counter(&adjacency_counters,
74  adj_get_index(adj));
75  vlib_zero_combined_counter(&adjacency_counters,
76  adj_get_index(adj));
77  fib_node_init(&adj->ia_node,
79 
80  adj->ia_nh_proto = proto;
81  adj->ia_flags = 0;
82  adj->rewrite_header.sw_if_index = ~0;
83  adj->rewrite_header.flags = 0;
84  adj->lookup_next_index = 0;
85  adj->ia_delegates = NULL;
86 
87  /* lest it become a midchain in the future */
88  clib_memset(&adj->sub_type.midchain.next_dpo, 0,
89  sizeof(adj->sub_type.midchain.next_dpo));
90 
91  return (adj);
92 }
93 
94 static int
96 {
97  if (ADJ_INDEX_INVALID == adj_index)
98  return (!0);
99 
100  return (0);
101 }
102 
103 u8*
104 format_adj_flags (u8 * s, va_list * args)
105 {
106  adj_flags_t af;
107  adj_attr_t at;
108 
109  af = va_arg (*args, int);
110 
111  if (ADJ_FLAG_NONE == af)
112  {
113  return (format(s, "None"));
114  }
116  {
117  if (af & (1 << at))
118  {
119  s = format(s, "%s ", adj_attr_names[at]);
120  }
121  }
122  return (s);
123 }
124 
125 /**
126  * @brief Pretty print helper function for formatting specific adjacencies.
127  * @param s - input string to format
128  * @param args - other args passed to format function such as:
129  * - vnet_main_t
130  * - ip_lookup_main_t
131  * - adj_index
132  */
133 u8 *
134 format_ip_adjacency (u8 * s, va_list * args)
135 {
137  ip_adjacency_t * adj;
138  u32 adj_index;
139 
140  adj_index = va_arg (*args, u32);
141  fiaf = va_arg (*args, format_ip_adjacency_flags_t);
142  adj = adj_get(adj_index);
143 
144  switch (adj->lookup_next_index)
145  {
148  s = format (s, "%U", format_adj_nbr, adj_index, 0);
149  break;
150  case IP_LOOKUP_NEXT_ARP:
151  s = format (s, "%U", format_adj_nbr_incomplete, adj_index, 0);
152  break;
154  s = format (s, "%U", format_adj_glean, adj_index, 0);
155  break;
157  s = format (s, "%U", format_adj_midchain, adj_index, 2);
158  break;
160  s = format (s, "%U", format_adj_mcast, adj_index, 0);
161  break;
163  s = format (s, "%U", format_adj_mcast_midchain, adj_index, 0);
164  break;
165  case IP_LOOKUP_NEXT_DROP:
166  case IP_LOOKUP_NEXT_PUNT:
169  case IP_LOOKUP_N_NEXT:
170  break;
171  }
172 
173  if (fiaf & FORMAT_IP_ADJACENCY_DETAIL)
174  {
175  vlib_counter_t counts;
176 
177  vlib_get_combined_counter(&adjacency_counters, adj_index, &counts);
178  s = format (s, "\n flags:%U", format_adj_flags, adj->ia_flags);
179  s = format (s, "\n counts:[%Ld:%Ld]", counts.packets, counts.bytes);
180  s = format (s, "\n locks:%d", adj->ia_node.fn_locks);
181  s = format(s, "\n delegates:\n ");
182  s = adj_delegate_format(s, adj);
183 
184  s = format(s, "\n children:");
186  {
187  s = format(s, "\n ");
189  }
190  }
191 
192  return s;
193 }
194 
195 int
197  fib_node_index_t **entry_indicies)
198 {
199  ip_adjacency_t * adj;
200 
201  adj = adj_get(ai);
202 
203  switch (adj->lookup_next_index)
204  {
206  case IP_LOOKUP_NEXT_ARP:
210  case IP_LOOKUP_NEXT_DROP:
211  case IP_LOOKUP_NEXT_PUNT:
214  case IP_LOOKUP_N_NEXT:
215  /*
216  * these adjacency types are terminal graph nodes, so there's no
217  * possibility of a loop down here.
218  */
219  break;
222  return (adj_ndr_midchain_recursive_loop_detect(ai, entry_indicies));
223  }
224 
225  return (0);
226 }
227 
228 /*
229  * adj_last_lock_gone
230  *
231  * last lock/reference to the adj has gone, we no longer need it.
232  */
233 static void
235 {
237 
239  ADJ_DBG(adj, "last-lock-gone");
240 
242 
244 
245  switch (adj->lookup_next_index)
246  {
248  dpo_reset(&adj->sub_type.midchain.next_dpo);
249  /* FALL THROUGH */
250  case IP_LOOKUP_NEXT_ARP:
253  /*
254  * complete and incomplete nbr adjs
255  */
257  adj->ia_nh_proto,
258  adj->ia_link,
259  &adj->sub_type.nbr.next_hop,
260  adj->rewrite_header.sw_if_index);
261  break;
264  adj->rewrite_header.sw_if_index);
265  break;
269  adj->rewrite_header.sw_if_index);
270  break;
271  case IP_LOOKUP_NEXT_DROP:
272  case IP_LOOKUP_NEXT_PUNT:
275  case IP_LOOKUP_N_NEXT:
276  /*
277  * type not stored in any DB from which we need to remove it
278  */
279  break;
280  }
281 
283 
284  fib_node_deinit(&adj->ia_node);
285  ASSERT(0 == vec_len(adj->ia_delegates));
286  vec_free(adj->ia_delegates);
287  pool_put(adj_pool, adj);
288 }
289 
290 u32
292 {
293  ip_adjacency_t *adj;
294 
295  adj = adj_get(dpo->dpoi_index);
296 
297  return (adj->rewrite_header.sw_if_index);
298 }
299 
300 void
302 {
303  ip_adjacency_t *adj;
304 
305  if (adj_index_is_special(adj_index))
306  {
307  return;
308  }
309 
310  adj = adj_get(adj_index);
311  ASSERT(adj);
312 
313  ADJ_DBG(adj, "lock");
314  fib_node_lock(&adj->ia_node);
315 }
316 
317 void
319 {
320  ip_adjacency_t *adj;
321 
322  if (adj_index_is_special(adj_index))
323  {
324  return;
325  }
326 
327  adj = adj_get(adj_index);
328  ASSERT(adj);
329 
330  ADJ_DBG(adj, "unlock");
331  ASSERT(adj);
332 
333  fib_node_unlock(&adj->ia_node);
334 }
335 
336 u32
338  fib_node_type_t child_type,
339  fib_node_index_t child_index)
340 {
341  ASSERT(ADJ_INDEX_INVALID != adj_index);
342  if (adj_index_is_special(adj_index))
343  {
344  return (~0);
345  }
346 
348  adj_index,
349  child_type,
350  child_index));
351 }
352 
353 void
355  u32 sibling_index)
356 {
357  if (adj_index_is_special(adj_index))
358  {
359  return;
360  }
361 
363  adj_index,
364  sibling_index);
365 }
366 
367 /*
368  * Context for the walk to update the cached feature flags.
369  */
370 typedef struct adj_feature_update_t_
371 {
375 
376 static adj_walk_rc_t
378  void *arg)
379 {
381  ip_adjacency_t *adj;
382 
383  adj = adj_get(ai);
384 
385  /*
386  * this ugly mess matches the feature arc that is changing with affected
387  * adjacencies
388  */
390  (VNET_LINK_IP6 == adj->ia_link)) ||
392  (VNET_LINK_IP4 == adj->ia_link)) ||
394  (VNET_LINK_MPLS == adj->ia_link)))
395  {
396  if (ctx->enable)
397  adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
398  else
399  adj->rewrite_header.flags &= ~VNET_REWRITE_HAS_FEATURES;
400  }
401  return (ADJ_WALK_RC_CONTINUE);
402 }
403 
404 void
406  u8 arc_index,
407  u8 is_enable)
408 {
409  /*
410  * Walk all the adjacencies on the interface to update the cached
411  * 'has-features' flag
412  */
414  .arc = arc_index,
415  .enable = is_enable,
416  };
417  adj_walk (sw_if_index, adj_feature_update_walk_cb, &ctx);
418 }
419 
420 static adj_walk_rc_t
422  void *arg)
423 {
424  ip_adjacency_t *adj;
425 
426  adj = adj_get(ai);
427 
429  &adj->rewrite_header);
430 
431  return (ADJ_WALK_RC_CONTINUE);
432 }
433 
434 static clib_error_t *
436 {
437  adj_walk (sw_if_index, adj_mtu_update_walk_cb, NULL);
438 
439  return (NULL);
440 }
441 
443 
444 /**
445  * @brief Walk the Adjacencies on a given interface
446  */
447 void
449  adj_walk_cb_t cb,
450  void *ctx)
451 {
452  /*
453  * walk all the neighbor adjacencies
454  */
455  fib_protocol_t proto;
456 
458  {
459  adj_nbr_walk(sw_if_index, proto, cb, ctx);
460  adj_mcast_walk(sw_if_index, proto, cb, ctx);
461  }
462 }
463 
464 /**
465  * @brief Return the link type of the adjacency
466  */
469 {
470  const ip_adjacency_t *adj;
471 
472  adj = adj_get(ai);
473 
474  return (adj->ia_link);
475 }
476 
477 /**
478  * @brief Return the sw interface index of the adjacency.
479  */
480 u32
482 {
483  const ip_adjacency_t *adj;
484 
485  adj = adj_get(ai);
486 
487  return (adj->rewrite_header.sw_if_index);
488 }
489 
490 /**
491  * @brief Return true if the adjacency is 'UP', i.e. can be used for forwarding
492  * 0 is down, !0 is up.
493  */
494 int
496 {
497  return (adj_bfd_is_up(ai));
498 }
499 
500 /**
501  * @brief Return the rewrite string of the adjacency
502  */
503 const u8*
505 {
506  vnet_rewrite_header_t *rw;
507  ip_adjacency_t *adj;
508 
509  adj = adj_get(ai);
510  rw = &adj->rewrite_header;
511 
512  ASSERT (rw->data_bytes != 0xfefe);
513 
514  return (rw->data - rw->data_bytes);
515 }
516 
517 static fib_node_t *
519 {
520  ip_adjacency_t *adj;
521 
522  adj = adj_get(index);
523 
524  return (&adj->ia_node);
525 }
526 
527 #define ADJ_FROM_NODE(_node) \
528  ((ip_adjacency_t*)((char*)_node - STRUCT_OFFSET_OF(ip_adjacency_t, ia_node)))
529 
530 static void
532 {
534 }
535 
539 {
540  ip_adjacency_t *adj;
541 
542  adj = ADJ_FROM_NODE(node);
543 
544  switch (adj->lookup_next_index)
545  {
548  break;
549  case IP_LOOKUP_NEXT_ARP:
555  case IP_LOOKUP_NEXT_DROP:
556  case IP_LOOKUP_NEXT_PUNT:
559  case IP_LOOKUP_N_NEXT:
560  /*
561  * Que pasa. yo soj en el final!
562  */
563  ASSERT(0);
564  break;
565  }
566 
568 }
569 
570 /*
571  * Adjacency's graph node virtual function table
572  */
573 static const fib_node_vft_t adj_vft = {
575  .fnv_last_lock = adj_node_last_lock_gone,
576  .fnv_back_walk = adj_back_walk_notify,
577 };
578 
579 static clib_error_t *
581 {
583 
588 
589  return (NULL);
590 }
591 
593 
594 static clib_error_t *
596  unformat_input_t * input,
597  vlib_cli_command_t * cmd)
598 {
600  u32 sw_if_index = ~0;
601  int summary = 0;
602 
604  {
605  if (unformat (input, "%d", &ai))
606  ;
607  else if (unformat (input, "sum"))
608  summary = 1;
609  else if (unformat (input, "summary"))
610  summary = 1;
611  else if (unformat (input, "%U",
613  &sw_if_index))
614  ;
615  else
616  break;
617  }
618 
619  if (summary)
620  {
621  vlib_cli_output (vm, "Number of adjacencies: %d", pool_elts(adj_pool));
622  vlib_cli_output (vm, "Per-adjacency counters: %s",
624  "enabled":
625  "disabled"));
626  }
627  else
628  {
629  if (ADJ_INDEX_INVALID != ai)
630  {
631  if (pool_is_free_index(adj_pool, ai))
632  {
633  vlib_cli_output (vm, "adjacency %d invalid", ai);
634  return 0;
635  }
636 
637  vlib_cli_output (vm, "[@%d] %U",
638  ai,
641  }
642  else
643  {
644  /* *INDENT-OFF* */
645  pool_foreach_index(ai, adj_pool,
646  ({
647  if (~0 != sw_if_index &&
648  sw_if_index != adj_get_sw_if_index(ai))
649  {
650  }
651  else
652  {
653  vlib_cli_output (vm, "[@%d] %U",
654  ai,
657  }
658  }));
659  /* *INDENT-ON* */
660  }
661  }
662  return 0;
663 }
664 
665 /*?
666  * Show all adjacencies.
667  * @cliexpar
668  * @cliexstart{sh adj}
669  * [@0]
670  * [@1] glean: loop0
671  * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
672  * [@3] mpls via 1.0.0.2 loop0: MPLS: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
673  * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
674  * [@5] mpls via 1.0.0.3 loop0: MPLS: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
675  * @cliexend
676  ?*/
677 VLIB_CLI_COMMAND (adj_show_command, static) = {
678  .path = "show adj",
679  .short_help = "show adj [<adj_index>] [interface] [summary]",
680  .function = adj_show,
681 };
682 
683 /**
684  * @brief CLI invoked function to enable/disable per-adj counters
685  */
686 static clib_error_t *
688  unformat_input_t * input,
689  vlib_cli_command_t * cmd)
690 {
691  clib_error_t *error = NULL;
692  int enable = ~0;
693 
695  {
696  if (unformat (input, "enable"))
697  enable = 1;
698  else if (unformat (input, "disable"))
699  enable = 0;
700  else
701  break;
702  }
703 
704  if (enable != ~0)
705  {
706  /* user requested something sensible */
708  }
709  else
710  {
711  error = clib_error_return (0, "specify 'enable' or 'disable'");
712  }
713 
714  return (error);
715 }
716 
717 /*?
718  * Enable/disable per-adjacency counters. This is optional because it comes
719  * with a non-negligible performance cost.
720  ?*/
721 VLIB_CLI_COMMAND (adj_cli_counters_set_command, static) = {
722  .path = "adjacency counters",
723  .short_help = "adjacency counters [enable|disable]",
724  .function = adj_cli_counters_set,
725 };
u32 sw_if_index
Definition: ipsec_gre.api:37
void adj_glean_remove(fib_protocol_t proto, u32 sw_if_index)
Definition: adj_glean.c:130
void adj_delegate_adj_deleted(ip_adjacency_t *adj)
Definition: adj_delegate.c:128
adj_flags_t ia_flags
Flags on the adjacency 1-bytes.
Definition: adj.h:255
u32 flags
Definition: vhost_user.h:115
ip_adjacency_t * adj_pool
The global adjacnecy pool.
Definition: adj.c:33
struct ip_adjacency_t_::@46::@48 midchain
IP_LOOKUP_NEXT_MIDCHAIN.
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:106
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:346
u8 * format_adj_nbr(u8 *s, va_list *ap)
Format a neigbour (REWRITE) adjacency.
Definition: adj_nbr.c:983
static int adj_index_is_special(adj_index_t adj_index)
Definition: adj.c:95
void adj_lock(adj_index_t adj_index)
Take a reference counting lock on the adjacency.
Definition: adj.c:301
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
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:504
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:468
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
Broadcasr Adjacency.
Definition: adj.h:85
IP unicast adjacency.
Definition: adj.h:221
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
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:98
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
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:964
void adj_child_remove(adj_index_t adj_index, u32 sibling_index)
Remove a child dependent.
Definition: adj.c:354
u32 adj_dpo_get_urpf(const dpo_id_t *dpo)
Definition: adj.c:291
unsigned char u8
Definition: types.h:56
#define ADJ_ATTR_NAMES
Definition: adj.h:186
struct ip_adjacency_t_::@46::@47 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
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:204
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:242
Adjacency to punt this packet.
Definition: adj.h:55
u8 output_feature_arc_index
Definition: lookup.h:140
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:433
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
#define always_inline
Definition: clib.h:98
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
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:313
#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:318
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:687
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:81
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:168
#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:285
int adj_is_up(adj_index_t ai)
Return true if the adjacency is &#39;UP&#39;, i.e.
Definition: adj.c:495
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:481
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
struct _unformat_input_t unformat_input_t
#define ADJ_FROM_NODE(_node)
Definition: adj.c:527
static adj_index_t adj_get_index(ip_adjacency_t *adj)
Get a pointer to an adjacency object from its index.
Definition: adj_internal.h:101
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
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
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:537
An node in the FIB graph.
Definition: fib_node.h:291
void adj_nbr_module_init(void)
Module initialisation.
Definition: adj_nbr.c:1093
void fib_node_unlock(fib_node_t *node)
Definition: fib_node.c:209
fib_node_t ia_node
Linkage into the FIB node grpah.
Definition: adj.h:229
void adj_mcast_remove(fib_protocol_t proto, u32 sw_if_index)
Definition: adj_mcast.c:177
u8 * format_adj_flags(u8 *s, va_list *args)
Format adjacency flags.
Definition: adj.c:104
void adj_glean_module_init(void)
Module initialisation.
Definition: adj_glean.c:322
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:230
static clib_error_t * adj_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: adj.c:595
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:305
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:196
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:259
vlib_main_t * vm
Definition: buffer.c:312
static void adj_last_lock_gone(ip_adjacency_t *adj)
Definition: adj.c:234
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
Multicast Midchain Adjacency.
Definition: adj.h:89
fib_node_get_t fnv_get
Definition: fib_node.h:279
u8 * format_adj_glean(u8 *s, va_list *ap)
Format/display a glean adjacency.
Definition: adj_glean.c:263
static clib_error_t * adj_mtu_update(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Definition: adj.c:435
void adj_mcast_module_init(void)
Module initialisation.
Definition: adj_mcast.c:469
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
static adj_walk_rc_t adj_mtu_update_walk_cb(adj_index_t ai, void *arg)
Definition: adj.c:421
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:283
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:328
void adj_nbr_walk(u32 sw_if_index, fib_protocol_t adj_nh_proto, adj_walk_cb_t cb, void *ctx)
Walk the neighbour Adjacencies on a given interface.
Definition: adj_nbr.c:574
Context passed between object during a back walk.
Definition: fib_node.h:204
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
void adj_walk(u32 sw_if_index, adj_walk_cb_t cb, void *ctx)
Walk the Adjacencies on a given interface.
Definition: adj.c:448
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)
static fib_node_t * adj_get_node(fib_node_index_t index)
Definition: adj.c:518
ip6_main_t ip6_main
Definition: ip6_forward.c:2688
ip_lookup_main_t lookup_main
Definition: ip6.h:179
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
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:193
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.
u8 * adj_delegate_format(u8 *s, ip_adjacency_t *adj)
Definition: adj_delegate.c:144
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:249
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:184
union ip_adjacency_t_::@46 sub_type
#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:236
u32 fn_locks
Number of dependents on this node.
Definition: fib_node.h:311
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:337
u8 * format_ip_adjacency(u8 *s, va_list *args)
Pretty print helper function for formatting specific adjacencies.
Definition: adj.c:134
ip_adjacency_t * adj_alloc(fib_protocol_t proto)
Definition: adj.c:63
char * name
The counter collection&#39;s name.
Definition: counter.h:193
A collection of combined counters.
Definition: counter.h:188
#define FOR_EACH_FIB_IP_PROTOCOL(_item)
Definition: fib_types.h:70
static void adj_node_last_lock_gone(fib_node_t *node)
Definition: adj.c:531
A FIB graph nodes virtual function table.
Definition: fib_node.h:278
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:1489
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:905
void adj_feature_update(u32 sw_if_index, u8 arc_index, u8 is_enable)
Notify the adjacency subsystem that the features settings for an interface have changed.
Definition: adj.c:405
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:231
static clib_error_t * adj_module_init(vlib_main_t *vm)
Definition: adj.c:580
#define pool_foreach_index(i, v, body)
Iterate pool by index.
Definition: pool.h:538
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
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:762
static adj_walk_rc_t adj_feature_update_walk_cb(adj_index_t ai, void *arg)
Definition: adj.c:377
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:442
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
struct adj_delegate_t_ * ia_delegates
more control plane members that do not fit on the first cacheline
Definition: adj.h:327
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:128