FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
adj_nbr.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_nbr.h>
17 #include <vnet/adj/adj_internal.h>
19 #include <vnet/fib/fib_walk.h>
20 
21 /*
22  * Vector Hash tables of neighbour (traditional) adjacencies
23  * Key: interface(for the vector index), address (and its proto),
24  * link-type/ether-type.
25  */
27 
28 typedef struct adj_nbr_key_t_
29 {
30  ip46_address_t ank_ip;
33 
34 #define ADJ_NBR_SET_KEY(_key, _lt, _nh) \
35 { \
36  ip46_address_copy(&(_key).ank_ip, (_nh)); \
37  _key.ank_linkt = (_lt); \
38 }
39 
40 #define ADJ_NBR_ITF_OK(_proto, _itf) \
41  (((_itf) < vec_len(adj_nbr_tables[_proto])) && \
42  (NULL != adj_nbr_tables[_proto][(_itf)]))
43 
44 #define ADJ_NBR_ASSERT_NH_PROTO(nh_proto, err) \
45  do { \
46  ASSERT (nh_proto < FIB_PROTOCOL_IP_MAX); \
47  const fib_protocol_t nh_proto__ = (nh_proto); \
48  if (nh_proto__ >= FIB_PROTOCOL_IP_MAX) \
49  { \
50  clib_warning ("BUG: protocol %d > %d\n", \
51  (int)nh_proto__, \
52  FIB_PROTOCOL_IP_MAX); \
53  return err; \
54  } \
55  } while (0)
56 
57 static void
59  vnet_link_t link_type,
60  const ip46_address_t *nh_addr,
62  adj_index_t adj_index)
63 {
64  adj_nbr_key_t kv;
65 
66  ADJ_NBR_ASSERT_NH_PROTO (nh_proto,);
67 
68  if (sw_if_index >= vec_len(adj_nbr_tables[nh_proto]))
69  {
70  vec_validate(adj_nbr_tables[nh_proto], sw_if_index);
71  }
72  if (NULL == adj_nbr_tables[nh_proto][sw_if_index])
73  {
74  adj_nbr_tables[nh_proto][sw_if_index] =
75  hash_create_mem(0, sizeof(adj_nbr_key_t), sizeof(adj_index_t));
76  }
77 
78  ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
79 
80  hash_set_mem_alloc (&adj_nbr_tables[nh_proto][sw_if_index],
81  &kv, adj_index);
82 }
83 
84 void
86  fib_protocol_t nh_proto,
87  vnet_link_t link_type,
88  const ip46_address_t *nh_addr,
90 {
91  adj_nbr_key_t kv;
92 
93  ADJ_NBR_ASSERT_NH_PROTO (nh_proto,);
94 
95  if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
96  return;
97 
98  ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
99 
100  hash_unset_mem_free(&adj_nbr_tables[nh_proto][sw_if_index], &kv);
101 
102  if (0 == hash_elts(adj_nbr_tables[nh_proto][sw_if_index]))
103  {
104  hash_free(adj_nbr_tables[nh_proto][sw_if_index]);
105  }
106 }
107 
110  vnet_link_t link_type,
111  const ip46_address_t *nh_addr,
113 {
114  adj_nbr_key_t kv;
115  uword *p;
116 
118 
119  ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
120 
121  if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
122  return (ADJ_INDEX_INVALID);
123 
124  p = hash_get_mem(adj_nbr_tables[nh_proto][sw_if_index], &kv);
125 
126  if (p)
127  {
128  return (p[0]);
129  }
130  return (ADJ_INDEX_INVALID);
131 }
132 
133 static inline u32
135 {
136  switch (proto) {
137  case FIB_PROTOCOL_IP4:
138  return (ip4_arp_node.index);
139  case FIB_PROTOCOL_IP6:
140  return (ip6_discover_neighbor_node.index);
141  case FIB_PROTOCOL_MPLS:
142  break;
143  }
144  ASSERT(0);
145  return (ip4_arp_node.index);
146 }
147 
148 /**
149  * @brief Check and set feature flags if o/p interface has any o/p features.
150  */
151 static void
153 {
154  ip_adjacency_t *adj;
156  i16 feature_count;
157  u8 arc_index;
159 
160  adj = adj_get(ai);
161 
162  switch (adj->ia_link)
163  {
164  case VNET_LINK_IP4:
166  break;
167  case VNET_LINK_IP6:
169  break;
170  case VNET_LINK_MPLS:
172  break;
173  default:
174  return;
175  }
176 
177  sw_if_index = adj->rewrite_header.sw_if_index;
178  if (vec_len(fm->feature_count_by_sw_if_index[arc_index]) > sw_if_index)
179  {
180  feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
181  if (feature_count > 0)
182  {
184 
185  adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
186  cm = &fm->feature_config_mains[arc_index];
187 
189  sw_if_index);
190  }
191  }
192  return;
193 }
194 
195 static ip_adjacency_t*
197  vnet_link_t link_type,
198  const ip46_address_t *nh_addr,
200 {
201  ip_adjacency_t *adj;
202 
203  adj = adj_alloc(nh_proto);
204 
205  adj_nbr_insert(nh_proto, link_type, nh_addr,
206  sw_if_index,
207  adj_get_index(adj));
208 
209  /*
210  * since we just added the ADJ we have no rewrite string for it,
211  * so its for ARP
212  */
214  adj->sub_type.nbr.next_hop = *nh_addr;
215  adj->ia_link = link_type;
216  adj->ia_nh_proto = nh_proto;
217  adj->rewrite_header.sw_if_index = sw_if_index;
219  &adj->rewrite_header);
220 
222  return (adj);
223 }
224 
225 /*
226  * adj_nbr_add_or_lock
227  *
228  * Add an adjacency for the neighbour requested.
229  *
230  * The key for an adj is:
231  * - the Next-hops protocol (i.e. v4 or v6)
232  * - the address of the next-hop
233  * - the interface the next-hop is reachable through
234  */
237  vnet_link_t link_type,
238  const ip46_address_t *nh_addr,
240 {
241  adj_index_t adj_index;
242 
243  adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
244 
245  if (ADJ_INDEX_INVALID == adj_index)
246  {
247  ip_adjacency_t *adj;
248  vnet_main_t *vnm;
249 
250  vnm = vnet_get_main();
251  adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
252  adj_index = adj_get_index(adj);
253  adj_lock(adj_index);
254 
255  if (ip46_address_is_equal(&ADJ_BCAST_ADDR, nh_addr))
256  {
258  }
259 
260  vnet_rewrite_init(vnm, sw_if_index, link_type,
261  adj_get_nd_node(nh_proto),
262  vnet_tx_node_index_for_sw_interface(vnm, sw_if_index),
263  &adj->rewrite_header);
264 
265  /*
266  * we need a rewrite where the destination IP address is converted
267  * to the appropriate link-layer address. This is interface specific.
268  * So ask the interface to do it.
269  */
270  vnet_update_adjacency_for_sw_interface(vnm, sw_if_index, adj_index);
271  }
272  else
273  {
274  adj_lock(adj_index);
275  }
276 
277  adj_delegate_adj_created(adj_get(adj_index));
278  return (adj_index);
279 }
280 
283  vnet_link_t link_type,
284  const ip46_address_t *nh_addr,
286  u8 *rewrite)
287 {
288  adj_index_t adj_index;
289 
290  adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
291 
292  if (ADJ_INDEX_INVALID == adj_index)
293  {
294  ip_adjacency_t *adj;
295 
296  adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
297  adj->rewrite_header.sw_if_index = sw_if_index;
298  adj_index = adj_get_index(adj);
299  }
300 
301  adj_lock(adj_index);
302  adj_nbr_update_rewrite(adj_index,
304  rewrite);
305 
306  adj_delegate_adj_created(adj_get(adj_index));
307 
308  return (adj_index);
309 }
310 
311 /**
312  * adj_nbr_update_rewrite
313  *
314  * Update the adjacency's rewrite string. A NULL string implies the
315  * rewrite is reset (i.e. when ARP/ND entry is gone).
316  * NB: the adj being updated may be handling traffic in the DP.
317  */
318 void
321  u8 *rewrite)
322 {
323  ip_adjacency_t *adj;
324 
325  ASSERT(ADJ_INDEX_INVALID != adj_index);
326 
327  adj = adj_get(adj_index);
328 
329  if (flags & ADJ_NBR_REWRITE_FLAG_COMPLETE)
330  {
331  /*
332  * update the adj's rewrite string and build the arc
333  * from the rewrite node to the interface's TX node
334  */
338  vnet_get_main(),
339  adj->rewrite_header.sw_if_index),
340  rewrite);
341  }
342  else
343  {
347  vnet_get_main(),
348  adj->rewrite_header.sw_if_index),
349  rewrite);
350  }
351 }
352 
353 /**
354  * adj_nbr_update_rewrite_internal
355  *
356  * Update the adjacency's rewrite string. A NULL string implies the
357  * rewrite is reset (i.e. when ARP/ND entry is gone).
358  * NB: the adj being updated may be handling traffic in the DP.
359  */
360 void
362  ip_lookup_next_t adj_next_index,
363  u32 this_node,
364  u32 next_node,
365  u8 *rewrite)
366 {
367  ip_adjacency_t *walk_adj;
368  adj_index_t walk_ai, ai;
369  vlib_main_t * vm;
370  u32 old_next;
371  int do_walk;
372 
373  vm = vlib_get_main();
374  old_next = adj->lookup_next_index;
375 
376  ai = walk_ai = adj_get_index(adj);
377  if (VNET_LINK_MPLS == adj->ia_link)
378  {
379  /*
380  * The link type MPLS has no children in the control plane graph, it only
381  * has children in the data-plane graph. The backwalk is up the former.
382  * So we need to walk from its IP cousin.
383  */
384  walk_ai = adj_nbr_find(adj->ia_nh_proto,
386  &adj->sub_type.nbr.next_hop,
387  adj->rewrite_header.sw_if_index);
388  }
389 
390  /*
391  * Don't call the walk re-entrantly
392  */
393  if (ADJ_INDEX_INVALID != walk_ai)
394  {
395  walk_adj = adj_get(walk_ai);
396  if (ADJ_FLAG_SYNC_WALK_ACTIVE & walk_adj->ia_flags)
397  {
398  do_walk = 0;
399  }
400  else
401  {
402  /*
403  * Prevent re-entrant walk of the same adj
404  */
405  walk_adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
406  do_walk = 1;
407  }
408  }
409  else
410  {
411  do_walk = 0;
412  }
413 
414  /*
415  * lock the adjacencies that are affected by updates this walk will provoke.
416  * Since the aim of the walk is to update children to link to a different
417  * DPO, this adj will no longer be in use and its lock count will drop to 0.
418  * We don't want it to be deleted as part of this endeavour.
419  */
420  adj_lock(ai);
421  adj_lock(walk_ai);
422 
423  /*
424  * Updating a rewrite string is not atomic;
425  * - the rewrite string is too long to write in one instruction
426  * - when swapping from incomplete to complete, we also need to update
427  * the VLIB graph next-index of the adj.
428  * ideally we would only want to suspend forwarding via this adj whilst we
429  * do this, but we do not have that level of granularity - it's suspend all
430  * worker threads or nothing.
431  * The other choices are:
432  * - to mark the adj down and back walk so child load-balances drop this adj
433  * from the set.
434  * - update the next_node index of this adj to point to error-drop
435  * both of which will mean for MAC change we will drop for this adj
436  * which is not acceptable. However, when the adj changes type (from
437  * complete to incomplete and vice-versa) the child DPOs, which have the
438  * VLIB graph next node index, will be sending packets to the wrong graph
439  * node. So from the options above, updating the next_node of the adj to
440  * be drop will work, but it relies on each graph node v4/v6/mpls, rewrite/
441  * arp/midchain always be valid w.r.t. a mis-match of adj type and node type
442  * (i.e. a rewrite adj in the arp node). This is not enforceable. Getting it
443  * wrong will lead to hard to find bugs since its a race condition. So we
444  * choose the more reliable method of updating the children to use the drop,
445  * then switching adj's type, then updating the children again. Did I mention
446  * that this doesn't happen often...
447  * So we need to distinguish between the two cases:
448  * 1 - mac change
449  * 2 - adj type change
450  */
451  if (do_walk &&
452  old_next != adj_next_index &&
453  ADJ_INDEX_INVALID != walk_ai)
454  {
455  /*
456  * the adj is changing type. we need to fix all children so that they
457  * stack momentarily on a drop, while the adj changes. If we don't do
458  * this the children will send packets to a VLIB graph node that does
459  * not correspond to the adj's type - and it goes downhill from there.
460  */
461  fib_node_back_walk_ctx_t bw_ctx = {
463  /*
464  * force this walk to be synchronous. if we don't and a node in the graph
465  * (a heavily shared path-list) chooses to back-ground the walk (make it
466  * async) then it will pause and we will do the adj update below, before
467  * all the children are updated. not good.
468  */
469  .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
470  };
471 
472  fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
473  /*
474  * fib_walk_sync may allocate a new adjacency and potentially cuase a
475  * realloc for adj_pool. When that happens, adj pointer is no longer
476  * valid here. We refresh the adj pointer accordingly.
477  */
478  adj = adj_get (ai);
479  }
480 
481  /*
482  * If we are just updating the MAC string of the adj (which we also can't
483  * do atomically), then we need to stop packets switching through the adj.
484  * We can't do that on a per-adj basis, so it's all the packets.
485  * If we are updating the type, and we walked back to the children above,
486  * then this barrier serves to flush the queues/frames.
487  */
489 
490  adj->lookup_next_index = adj_next_index;
491  adj->ia_node_index = this_node;
492 
493  if (NULL != rewrite)
494  {
495  /*
496  * new rewrite provided.
497  * fill in the adj's rewrite string, and build the VLIB graph arc.
498  */
499  vnet_rewrite_set_data_internal(&adj->rewrite_header,
500  sizeof(adj->rewrite_data),
501  rewrite,
502  vec_len(rewrite));
503  vec_free(rewrite);
504  }
505  else
506  {
507  vnet_rewrite_clear_data_internal(&adj->rewrite_header,
508  sizeof(adj->rewrite_data));
509  }
510  adj->rewrite_header.next_index = vlib_node_add_next(vlib_get_main(),
511  this_node,
512  next_node);
513 
514  /*
515  * done with the rewrite update - let the workers loose.
516  */
518 
519  if (do_walk &&
520  (old_next != adj->lookup_next_index) &&
521  (ADJ_INDEX_INVALID != walk_ai))
522  {
523  /*
524  * backwalk to the children so they can stack on the now updated
525  * adjacency
526  */
527  fib_node_back_walk_ctx_t bw_ctx = {
529  };
530 
531  fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
532  }
533  /*
534  * Prevent re-entrant walk of the same adj
535  */
536  if (do_walk)
537  {
538  walk_adj = adj_get(walk_ai);
539  walk_adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
540  }
541 
543  adj_unlock(ai);
544  adj_unlock(walk_ai);
545 }
546 
547 u32
549 {
551  u32 sw_if_index = 0;
552  u64 count = 0;
553 
554  for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
555  {
556  vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
557  {
558  if (NULL != adj_nbr_tables[proto][sw_if_index])
559  {
560  count += hash_elts(adj_nbr_tables[proto][sw_if_index]);
561  }
562  }
563  }
564  return (count);
565 }
566 
567 /**
568  * @brief Walk all adjacencies on a link for a given next-hop protocol
569  */
570 void
572  fib_protocol_t adj_nh_proto,
573  adj_walk_cb_t cb,
574  void *ctx)
575 {
576  adj_index_t ai, *ais, *aip;
578 
579  ADJ_NBR_ASSERT_NH_PROTO (adj_nh_proto,);
580 
581  if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
582  return;
583 
584  ais = NULL;
585 
586  /* elements may be removed from the table during the walk, so
587  * collect the set first then process them */
588  hash_foreach_mem (key, ai, adj_nbr_tables[adj_nh_proto][sw_if_index],
589  ({
590  vec_add1(ais, ai);
591  }));
592 
593  vec_foreach(aip, ais)
594  {
595  /* An adj may be deleted during the walk so check first */
596  if (!pool_is_free_index(adj_pool, *aip))
597  cb(*aip, ctx);
598  }
599  vec_free(ais);
600 }
601 
602 /**
603  * @brief Walk adjacencies on a link with a given v4 next-hop.
604  * that is visit the adjacencies with different link types.
605  */
606 void
608  const ip4_address_t *addr,
609  adj_walk_cb_t cb,
610  void *ctx)
611 {
612  if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP4, sw_if_index))
613  return;
614 
615  ip46_address_t nh = {
616  .ip4 = *addr,
617  };
618  vnet_link_t linkt;
619  adj_index_t ai;
620 
621  FOR_EACH_VNET_LINK(linkt)
622  {
623  ai = adj_nbr_find (FIB_PROTOCOL_IP4, linkt, &nh, sw_if_index);
624 
625  if (INDEX_INVALID != ai)
626  cb(ai, ctx);
627  }
628 }
629 
630 /**
631  * @brief Walk adjacencies on a link with a given v6 next-hop.
632  * that is visit the adjacencies with different link types.
633  */
634 void
636  const ip6_address_t *addr,
637  adj_walk_cb_t cb,
638  void *ctx)
639 {
640  if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP6, sw_if_index))
641  return;
642 
643  ip46_address_t nh = {
644  .ip6 = *addr,
645  };
646  vnet_link_t linkt;
647  adj_index_t ai;
648 
649  FOR_EACH_VNET_LINK(linkt)
650  {
651  ai = adj_nbr_find (FIB_PROTOCOL_IP6, linkt, &nh, sw_if_index);
652 
653  if (INDEX_INVALID != ai)
654  cb(ai, ctx);
655  }
656 }
657 
658 /**
659  * @brief Walk adjacencies on a link with a given next-hop.
660  * that is visit the adjacencies with different link types.
661  */
662 void
664  fib_protocol_t adj_nh_proto,
665  const ip46_address_t *nh,
666  adj_walk_cb_t cb,
667  void *ctx)
668 {
669  ADJ_NBR_ASSERT_NH_PROTO (adj_nh_proto,);
670 
671  if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
672  return;
673 
674  switch (adj_nh_proto)
675  {
676  case FIB_PROTOCOL_IP4:
677  adj_nbr_walk_nh4(sw_if_index, &nh->ip4, cb, ctx);
678  break;
679  case FIB_PROTOCOL_IP6:
680  adj_nbr_walk_nh6(sw_if_index, &nh->ip6, cb, ctx);
681  break;
682  case FIB_PROTOCOL_MPLS:
683  ASSERT(0);
684  break;
685  }
686 }
687 
688 /**
689  * Flags associated with the interface state walks
690  */
692 {
695 
696 /**
697  * Context for the state change walk of the DB
698  */
700 {
701  /**
702  * Flags on the interface
703  */
706 
707 static adj_walk_rc_t
709  void *arg)
710 {
711  /*
712  * Back walk the graph to inform the forwarding entries
713  * that this interface state has changed. Do this synchronously
714  * since this is the walk that provides convergence
715  */
717  fib_node_back_walk_ctx_t bw_ctx = {
718  .fnbw_reason = ((ctx->flags & ADJ_NBR_INTERFACE_UP) ?
721  /*
722  * the force sync applies only as far as the first fib_entry.
723  * And it's the fib_entry's we need to converge away from
724  * the adjacencies on the now down link
725  */
726  .fnbw_flags = (!(ctx->flags & ADJ_NBR_INTERFACE_UP) ?
729  };
730  ip_adjacency_t *adj;
731 
732  adj = adj_get(ai);
733 
735  fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
737 
738  return (ADJ_WALK_RC_CONTINUE);
739 }
740 
741 /**
742  * @brief Registered function for SW interface state changes
743  */
744 static clib_error_t *
747  u32 flags)
748 {
750 
751  /*
752  * walk each adj on the interface and trigger a walk from that adj
753  */
754  for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
755  {
757  .flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
759  0),
760  };
761 
762  adj_nbr_walk(sw_if_index, proto,
764  &ctx);
765  }
766 
767  return (NULL);
768 }
769 
773 
774 /**
775  * @brief Invoked on each SW interface of a HW interface when the
776  * HW interface state changes
777  */
778 static walk_rc_t
781  void *arg)
782 {
785 
786  /*
787  * walk each adj on the interface and trigger a walk from that adj
788  */
789  for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
790  {
791  adj_nbr_walk(sw_if_index, proto,
793  ctx);
794  }
795  return (WALK_CONTINUE);
796 }
797 
798 /**
799  * @brief Registered callback for HW interface state changes
800  */
801 static clib_error_t *
803  u32 hw_if_index,
804  u32 flags)
805 {
806  /*
807  * walk SW interface on the HW
808  */
810  .flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
812  0),
813  };
814 
815  vnet_hw_interface_walk_sw(vnm, hw_if_index,
817  &ctx);
818 
819  return (NULL);
820 }
821 
825 
826 static adj_walk_rc_t
828  void *arg)
829 {
830  /*
831  * Back walk the graph to inform the forwarding entries
832  * that this interface has been deleted.
833  */
834  fib_node_back_walk_ctx_t bw_ctx = {
836  };
837  ip_adjacency_t *adj;
838 
839  adj_lock(ai);
840 
841  adj = adj_get(ai);
842 
844  fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
846 
847  adj_unlock(ai);
848  return (ADJ_WALK_RC_CONTINUE);
849 }
850 
851 /**
852  * adj_nbr_interface_add_del
853  *
854  * Registered to receive interface Add and delete notifications
855  */
856 static clib_error_t *
859  u32 is_add)
860 {
862 
863  if (is_add)
864  {
865  /*
866  * not interested in interface additions. we will not back walk
867  * to resolve paths through newly added interfaces. Why? The control
868  * plane should have the brains to add interfaces first, then routes.
869  * So the case where there are paths with a interface that matches
870  * one just created is the case where the path resolved through an
871  * interface that was deleted, and still has not been removed. The
872  * new interface added, is NO GUARANTEE that the interface being
873  * added now, even though it may have the same sw_if_index, is the
874  * same interface that the path needs. So tough!
875  * If the control plane wants these routes to resolve it needs to
876  * remove and add them again.
877  */
878  return (NULL);
879  }
880 
881  for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
882  {
883  adj_nbr_walk(sw_if_index, proto,
885  NULL);
886  }
887 
888  return (NULL);
889 
890 }
891 
893 
894 
895 static adj_walk_rc_t
897  void *arg)
898 {
899  vlib_cli_output (arg, "[@%d] %U",
900  ai,
903 
904  return (ADJ_WALK_RC_CONTINUE);
905 }
906 
907 static clib_error_t *
909  unformat_input_t * input,
910  vlib_cli_command_t * cmd)
911 {
913  ip46_address_t nh = ip46_address_initializer;
914  u32 sw_if_index = ~0;
915 
917  {
918  if (unformat (input, "%U",
920  &sw_if_index))
921  ;
922  else if (unformat (input, "%U",
924  ;
925  else if (unformat (input, "%d", &ai))
926  ;
927  else
928  break;
929  }
930 
931  if (ADJ_INDEX_INVALID != ai)
932  {
933  vlib_cli_output (vm, "[@%d] %U",
934  ai,
937  }
938  else if (~0 != sw_if_index)
939  {
941 
942  if (ip46_address_is_zero(&nh))
943  {
944  for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
945  {
946  adj_nbr_walk(sw_if_index, proto,
948  vm);
949  }
950  }
951  else
952  {
953  proto = (ip46_address_is_ip4(&nh) ?
956  adj_nbr_walk_nh(sw_if_index, proto, &nh,
958  vm);
959  }
960  }
961  else
962  {
964 
965  for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
966  {
967  vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
968  {
969  adj_nbr_walk(sw_if_index, proto,
971  vm);
972  }
973  }
974  }
975 
976  return 0;
977 }
978 
979 /*?
980  * Show all neighbour adjacencies.
981  * @cliexpar
982  * @cliexstart{sh adj nbr}
983  * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
984  * [@3] mpls via 1.0.0.2 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
985  * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
986  * [@5] mpls via 1.0.0.3 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
987  * @cliexend
988  ?*/
989 VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
990  .path = "show adj nbr",
991  .short_help = "show adj nbr [<adj_index>] [interface]",
992  .function = adj_nbr_show,
993 };
994 
995 u8*
996 format_adj_nbr_incomplete (u8* s, va_list *ap)
997 {
998  index_t index = va_arg(*ap, index_t);
999  CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
1000  vnet_main_t * vnm = vnet_get_main();
1001  ip_adjacency_t * adj = adj_get(index);
1002 
1003  s = format (s, "arp-%U", format_vnet_link, adj->ia_link);
1004  s = format (s, ": via %U",
1005  format_ip46_address, &adj->sub_type.nbr.next_hop,
1007  s = format (s, " %U",
1009  vnm, adj->rewrite_header.sw_if_index);
1010 
1011  return (s);
1012 }
1013 
1014 u8*
1015 format_adj_nbr (u8* s, va_list *ap)
1016 {
1017  index_t index = va_arg(*ap, index_t);
1018  CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
1019  ip_adjacency_t * adj = adj_get(index);
1020 
1021  s = format (s, "%U", format_vnet_link, adj->ia_link);
1022  s = format (s, " via %U ",
1023  format_ip46_address, &adj->sub_type.nbr.next_hop,
1025  s = format (s, "%U",
1027  &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
1028 
1029  return (s);
1030 }
1031 
1032 static void
1034 {
1035  adj_lock(dpo->dpoi_index);
1036 }
1037 static void
1039 {
1040  adj_unlock(dpo->dpoi_index);
1041 }
1042 
1043 static void
1045 {
1046  fib_show_memory_usage("Adjacency",
1048  pool_len(adj_pool),
1049  sizeof(ip_adjacency_t));
1050 }
1051 
1052 const static dpo_vft_t adj_nbr_dpo_vft = {
1053  .dv_lock = adj_dpo_lock,
1054  .dv_unlock = adj_dpo_unlock,
1055  .dv_format = format_adj_nbr,
1056  .dv_mem_show = adj_mem_show,
1057  .dv_get_urpf = adj_dpo_get_urpf,
1058 };
1059 const static dpo_vft_t adj_nbr_incompl_dpo_vft = {
1060  .dv_lock = adj_dpo_lock,
1061  .dv_unlock = adj_dpo_unlock,
1062  .dv_format = format_adj_nbr_incomplete,
1063  .dv_get_urpf = adj_dpo_get_urpf,
1064 };
1065 
1066 /**
1067  * @brief The per-protocol VLIB graph nodes that are assigned to an adjacency
1068  * object.
1069  *
1070  * this means that these graph nodes are ones from which a nbr is the
1071  * parent object in the DPO-graph.
1072  */
1073 const static char* const nbr_ip4_nodes[] =
1074 {
1075  "ip4-rewrite",
1076  NULL,
1077 };
1078 const static char* const nbr_ip6_nodes[] =
1079 {
1080  "ip6-rewrite",
1081  NULL,
1082 };
1083 const static char* const nbr_mpls_nodes[] =
1084 {
1085  "mpls-output",
1086  NULL,
1087 };
1088 const static char* const nbr_ethernet_nodes[] =
1089 {
1090  "adj-l2-rewrite",
1091  NULL,
1092 };
1093 const static char* const * const nbr_nodes[DPO_PROTO_NUM] =
1094 {
1099 };
1100 
1101 const static char* const nbr_incomplete_ip4_nodes[] =
1102 {
1103  "ip4-arp",
1104  NULL,
1105 };
1106 const static char* const nbr_incomplete_ip6_nodes[] =
1107 {
1108  "ip6-discover-neighbor",
1109  NULL,
1110 };
1111 const static char* const nbr_incomplete_mpls_nodes[] =
1112 {
1113  "mpls-adj-incomplete",
1114  NULL,
1115 };
1116 
1117 const static char* const * const nbr_incomplete_nodes[DPO_PROTO_NUM] =
1118 {
1122 };
1123 
1124 void
1126 {
1128  &adj_nbr_dpo_vft,
1129  nbr_nodes);
1131  &adj_nbr_incompl_dpo_vft,
1133 }
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
u8 count
Definition: dhcp.api:208
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:406
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:663
static clib_error_t * adj_nbr_hw_interface_state_change(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Registered callback for HW interface state changes.
Definition: adj_nbr.c:802
#define vec_foreach_index(var, v)
Iterate over vector indices.
adj_flags_t ia_flags
Flags on the adjacency 1-bytes.
Definition: adj.h:348
ip_adjacency_t * adj_pool
The global adjacency pool.
Definition: adj.c:33
#define CLIB_UNUSED(x)
Definition: clib.h:87
A virtual function table regisitered for a DPO type.
Definition: dpo.h:401
enum adj_nbr_interface_flags_t_ adj_nbr_interface_flags_t
Flags associated with the interface state walks.
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:103
u8 * format_adj_nbr(u8 *s, va_list *ap)
Format a neigbour (REWRITE) adjacency.
Definition: adj_nbr.c:1015
void adj_lock(adj_index_t adj_index)
Take a reference counting lock on the adjacency.
Definition: adj.c:331
An indication that the rewrite is complete, i.e.
Definition: adj_nbr.h:98
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static const char *const nbr_ethernet_nodes[]
Definition: adj_nbr.c:1088
static uword ** adj_nbr_tables[FIB_PROTOCOL_IP_MAX]
Definition: adj_nbr.c:26
vl_api_fib_path_nh_t nh
Definition: fib_types.api:126
static const char *const nbr_incomplete_ip6_nodes[]
Definition: adj_nbr.c:1106
unsigned long u64
Definition: types.h:89
void adj_delegate_adj_created(ip_adjacency_t *adj)
Definition: adj_delegate.c:158
static adj_walk_rc_t adj_nbr_interface_state_change_one(adj_index_t ai, void *arg)
Definition: adj_nbr.c:708
void vnet_hw_interface_walk_sw(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_sw_interface_walk_t fn, void *ctx)
Walk the SW interfaces on a HW interface - this is the super interface and any sub-interfaces.
Definition: interface.c:1053
Broadcast Adjacency.
Definition: adj.h:85
IP unicast adjacency.
Definition: adj.h:227
Context for the state change walk of the DB.
Definition: adj_nbr.c:699
#define FIB_PROTOCOL_IP_MAX
Definition outside of enum so it does not need to be included in non-defaulted switch statements...
Definition: fib_types.h:58
This packet is to be rewritten and forwarded to the next processing node.
Definition: adj.h:73
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
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:592
ip_lookup_main_t lookup_main
Definition: ip4.h:108
void adj_nbr_walk_nh4(u32 sw_if_index, const ip4_address_t *addr, adj_walk_cb_t cb, void *ctx)
Walk adjacencies on a link with a given v4 next-hop.
Definition: adj_nbr.c:607
vlib_main_t * vm
Definition: in2out_ed.c:1582
u64 ank_linkt
Definition: adj_nbr.c:31
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:996
static const char *const nbr_incomplete_mpls_nodes[]
Definition: adj_nbr.c:1111
static u8 ip46_address_is_ip4(const ip46_address_t *ip46)
Definition: ip46_address.h:55
u32 adj_dpo_get_urpf(const dpo_id_t *dpo)
Definition: adj.c:321
vhost_vring_addr_t addr
Definition: vhost_user.h:111
adj_index_t adj_nbr_add_or_lock_w_rewrite(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index, u8 *rewrite)
Add (and lock) a new or lock an existing neighbour adjacency.
Definition: adj_nbr.c:282
format_function_t format_vnet_sw_if_index_name
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1173
unsigned char u8
Definition: types.h:56
ip_lookup_next_t
An adjacency is a representation of an attached L3 peer.
Definition: adj.h:50
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:205
vnet_link_t ia_link
link/ether-type 1 bytes
Definition: adj.h:335
#define fm
static void adj_nbr_insert(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index, adj_index_t adj_index)
Definition: adj_nbr.c:58
enum walk_rc_t_ walk_rc_t
Walk return code.
u8 output_feature_arc_index
Definition: lookup.h:169
static clib_error_t * adj_nbr_sw_interface_state_change(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
Registered function for SW interface state changes.
Definition: adj_nbr.c:745
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:459
vlib_node_registration_t ip6_discover_neighbor_node
(constructor) VLIB_REGISTER_NODE (ip6_discover_neighbor_node)
Definition: ip6_neighbor.c:278
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION_PRIO(adj_nbr_sw_interface_state_change, VNET_ITF_FUNC_PRIORITY_HIGH)
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:322
format_function_t format_ip_adjacency
Definition: format.h:58
void fib_walk_sync(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_back_walk_ctx_t *ctx)
Back walk all the children of a FIB node.
Definition: fib_walk.c:745
static void vnet_rewrite_clear_data_internal(vnet_rewrite_header_t *rw, int max_size)
Definition: rewrite.h:129
static const char *const nbr_incomplete_ip4_nodes[]
Definition: adj_nbr.c:1101
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
static walk_rc_t adj_nbr_hw_sw_interface_state_change(vnet_main_t *vnm, u32 sw_if_index, void *arg)
Invoked on each SW interface of a HW interface when the HW interface state changes.
Definition: adj_nbr.c:779
static clib_error_t * adj_nbr_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: adj_nbr.c:908
ip46_address_t ank_ip
Definition: adj_nbr.c:30
static const char *const nbr_mpls_nodes[]
Definition: adj_nbr.c:1083
static void adj_dpo_lock(dpo_id_t *dpo)
Definition: adj_nbr.c:1033
void fib_show_memory_usage(const char *name, u32 in_use_elts, u32 allocd_elts, size_t size_elt)
Show the memory usage for a type.
Definition: fib_node.c:220
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:348
void vnet_update_adjacency_for_sw_interface(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Definition: rewrite.c:179
unsigned int u32
Definition: types.h:88
static const char *const nbr_ip6_nodes[]
Definition: adj_nbr.c:1078
static void adj_nbr_evaluate_feature(adj_index_t ai)
Check and set feature flags if o/p interface has any o/p features.
Definition: adj_nbr.c:152
format_function_t format_vnet_rewrite
Definition: rewrite.h:263
u8 output_feature_arc_index
Definition: mpls.h:57
union ip_adjacency_t_::@149 sub_type
u32 adj_nbr_db_size(void)
Return the size of the adjacency database.
Definition: adj_nbr.c:548
vlib_node_registration_t ip4_arp_node
(constructor) VLIB_REGISTER_NODE (ip4_arp_node)
Definition: ip4_neighbor.c:261
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
fib_node_bw_reason_flag_t fnbw_reason
The reason/trigger for the backwalk.
Definition: fib_node.h:212
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:661
#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
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
vl_api_ip_proto_t proto
Definition: acl_types.api:50
vl_api_address_t nh_addr
Definition: lisp_gpe.api:222
static u8 ip46_address_is_zero(const ip46_address_t *ip46)
Definition: ip46_address.h:87
long ctx[MAX_CONNS]
Definition: main.c:144
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 hash_free(h)
Definition: hash.h:310
void adj_delegate_adj_modified(ip_adjacency_t *adj)
Definition: adj_delegate.c:128
static clib_error_t * adj_nbr_interface_add_del(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
adj_nbr_interface_add_del
Definition: adj_nbr.c:857
u32 ia_node_index
The VLIB node in which this adj is used to forward packets.
Definition: adj.h:322
ip6_main_t ip6_main
Definition: ip6_forward.c:2781
void adj_nbr_module_init(void)
Module initialisation.
Definition: adj_nbr.c:1125
#define hash_foreach_mem(key_var, value_var, h, body)
Definition: hash.h:461
static u8 ip46_address_is_equal(const ip46_address_t *ip46_1, const ip46_address_t *ip46_2)
Definition: ip46_address.h:93
format_function_t format_ip46_address
Definition: ip46_address.h:50
#define ADJ_NBR_SET_KEY(_key, _lt, _nh)
Definition: adj_nbr.c:34
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
Definition: adj.h:63
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
void vnet_rewrite_init(vnet_main_t *vnm, u32 sw_if_index, vnet_link_t linkt, u32 this_node, u32 next_node, vnet_rewrite_header_t *rw)
Definition: rewrite.c:80
mpls_main_t mpls_main
Definition: mpls.c:25
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
static adj_walk_rc_t adj_nbr_show_one(adj_index_t ai, void *arg)
Definition: adj_nbr.c:896
Force the walk to be synchronous.
Definition: fib_node.h:174
u32 vnet_tx_node_index_for_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
Definition: rewrite.c:73
static void vnet_rewrite_set_data_internal(vnet_rewrite_header_t *rw, int max_size, void *data, int data_bytes)
Definition: rewrite.h:139
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
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:299
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
static void adj_mem_show(void)
Definition: adj_nbr.c:1044
static ip_adjacency_t * adj_nbr_alloc(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Definition: adj_nbr.c:196
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
i16 ** feature_count_by_sw_if_index
feature reference counts by interface
Definition: feature.h:109
#define FOR_EACH_VNET_LINK(_link)
Definition: interface.h:362
Context passed between object during a back walk.
Definition: fib_node.h:208
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION_PRIO(adj_nbr_hw_interface_state_change, VNET_ITF_FUNC_PRIORITY_HIGH)
adj_nbr_interface_flags_t flags
Flags on the interface.
Definition: adj_nbr.c:704
#define ASSERT(truth)
static uword hash_elts(void *v)
Definition: hash.h:118
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:696
ip_lookup_main_t lookup_main
Definition: ip6.h:181
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
struct ip_adjacency_t_::@149::@150 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
#define ADJ_NBR_ASSERT_NH_PROTO(nh_proto, err)
Definition: adj_nbr.c:44
u32 ia_cfg_index
feature [arc] config index
Definition: adj.h:239
static void hash_unset_mem_free(uword **h, const void *key)
Definition: hash.h:295
struct adj_nbr_key_t_ adj_nbr_key_t
static const char *const nbr_ip4_nodes[]
The per-protocol VLIB graph nodes that are assigned to an adjacency object.
Definition: adj_nbr.c:1073
static const char *const *const nbr_nodes[DPO_PROTO_NUM]
Definition: adj_nbr.c:1093
static u32 adj_get_rewrite_node(vnet_link_t linkt)
Definition: adj_internal.h:46
static u32 adj_get_nd_node(fib_protocol_t proto)
Definition: adj_nbr.c:134
unformat_function_t unformat_ip46_address
Definition: format.h:63
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
#define vec_elt(v, i)
Get vector value at index i.
typedef key
Definition: ipsec_types.api:85
fib_protocol_t ia_nh_proto
The protocol of the neighbor/peer.
Definition: adj.h:342
static const char *const *const nbr_incomplete_nodes[DPO_PROTO_NUM]
Definition: adj_nbr.c:1117
#define DPO_PROTO_NUM
Definition: dpo.h:70
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
#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:329
void adj_nbr_update_rewrite_internal(ip_adjacency_t *adj, ip_lookup_next_t adj_next_index, u32 this_node, u32 next_node, u8 *rewrite)
adj_nbr_update_rewrite_internal
Definition: adj_nbr.c:361
enum adj_nbr_rewrite_flag_t_ adj_nbr_rewrite_flag_t
When adding a rewrite to an adjacency these are flags that apply to that rewrite. ...
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
u64 uword
Definition: types.h:112
ip_adjacency_t * adj_alloc(fib_protocol_t proto)
Definition: adj.c:63
u32 index
Definition: flow_types.api:221
static adj_walk_rc_t adj_nbr_interface_delete_one(adj_index_t ai, void *arg)
Definition: adj_nbr.c:827
#define hash_get_mem(h, key)
Definition: hash.h:269
adj_nbr_interface_flags_t_
Flags associated with the interface state walks.
Definition: adj_nbr.c:691
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1554
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1144
adj_index_t adj_nbr_add_or_lock(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Neighbour Adjacency sub-type.
Definition: adj_nbr.c:236
#define vec_foreach(var, vec)
Vector iterator.
vnet_link_t fib_proto_to_link(fib_protocol_t proto)
Convert from a protocol to a link type.
Definition: fib_types.c:358
u8 * format_vnet_link(u8 *s, va_list *ap)
Definition: fib_types.c:41
static void hash_set_mem_alloc(uword **h, const void *key, uword v)
Definition: hash.h:279
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_nbr_interface_add_del)
static void adj_dpo_unlock(dpo_id_t *dpo)
Definition: adj_nbr.c:1038
vnet_feature_config_main_t * feature_config_mains
feature config main objects
Definition: feature.h:100
#define ADJ_NBR_ITF_OK(_proto, _itf)
Definition: adj_nbr.c:40
This adjacency/interface has output features configured.
Definition: rewrite.h:57
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
void adj_nbr_update_rewrite(adj_index_t adj_index, adj_nbr_rewrite_flag_t flags, u8 *rewrite)
adj_nbr_update_rewrite
Definition: adj_nbr.c:319
const ip46_address_t ADJ_BCAST_ADDR
The special broadcast address (to construct a broadcast adjacency.
Definition: adj.c:41
struct adj_nbr_interface_state_change_ctx_t_ adj_nbr_interface_state_change_ctx_t
Context for the state change walk of the DB.
#define ip46_address_initializer
Definition: ip46_address.h:52
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:33
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:171
static ip46_type_t adj_proto_to_46(fib_protocol_t proto)
Definition: adj_internal.h:82
signed short i16
Definition: types.h:46
adj_index_t adj_nbr_find(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Lookup neighbor adjancency.
Definition: adj_nbr.c:109
void adj_nbr_walk_nh6(u32 sw_if_index, const ip6_address_t *addr, adj_walk_cb_t cb, void *ctx)
Walk adjacencies on a link with a given v6 next-hop.
Definition: adj_nbr.c:635
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128