FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
fib_path.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 <vlib/vlib.h>
17 #include <vnet/vnet.h>
18 #include <vnet/ip/format.h>
19 #include <vnet/ip/ip.h>
20 #include <vnet/dpo/drop_dpo.h>
21 #include <vnet/dpo/receive_dpo.h>
23 #include <vnet/dpo/lookup_dpo.h>
26 #include <vnet/dpo/dvr_dpo.h>
27 #include <vnet/dpo/ip_null_dpo.h>
28 #include <vnet/dpo/classify_dpo.h>
29 #include <vnet/dpo/pw_cw.h>
30 
31 #include <vnet/adj/adj.h>
32 #include <vnet/adj/adj_mcast.h>
33 
34 #include <vnet/fib/fib_path.h>
35 #include <vnet/fib/fib_node.h>
36 #include <vnet/fib/fib_table.h>
37 #include <vnet/fib/fib_entry.h>
38 #include <vnet/fib/fib_path_list.h>
39 #include <vnet/fib/fib_internal.h>
40 #include <vnet/fib/fib_urpf_list.h>
41 #include <vnet/fib/mpls_fib.h>
42 #include <vnet/fib/fib_path_ext.h>
43 #include <vnet/udp/udp_encap.h>
44 #include <vnet/bier/bier_fmask.h>
45 #include <vnet/bier/bier_table.h>
46 #include <vnet/bier/bier_imp.h>
48 
49 /**
50  * Enurmeration of path types
51  */
52 typedef enum fib_path_type_t_ {
53  /**
54  * Marker. Add new types after this one.
55  */
57  /**
58  * Attached-nexthop. An interface and a nexthop are known.
59  */
61  /**
62  * attached. Only the interface is known.
63  */
65  /**
66  * recursive. Only the next-hop is known.
67  */
69  /**
70  * special. nothing is known. so we drop.
71  */
73  /**
74  * exclusive. user provided adj.
75  */
77  /**
78  * deag. Link to a lookup adj in the next table
79  */
81  /**
82  * interface receive.
83  */
85  /**
86  * Path resolves via a UDP encap object.
87  */
89  /**
90  * receive. it's for-us.
91  */
93  /**
94  * bier-imp. it's via a BIER imposition.
95  */
97  /**
98  * bier-fmask. it's via a BIER ECMP-table.
99  */
101  /**
102  * bier-fmask. it's via a BIER f-mask.
103  */
105  /**
106  * via a DVR.
107  */
109  /**
110  * Marker. Add new types before this one, then update it.
111  */
113 } __attribute__ ((packed)) fib_path_type_t;
114 
115 /**
116  * The maximum number of path_types
117  */
118 #define FIB_PATH_TYPE_MAX (FIB_PATH_TYPE_LAST + 1)
119 
120 #define FIB_PATH_TYPES { \
121  [FIB_PATH_TYPE_ATTACHED_NEXT_HOP] = "attached-nexthop", \
122  [FIB_PATH_TYPE_ATTACHED] = "attached", \
123  [FIB_PATH_TYPE_RECURSIVE] = "recursive", \
124  [FIB_PATH_TYPE_SPECIAL] = "special", \
125  [FIB_PATH_TYPE_EXCLUSIVE] = "exclusive", \
126  [FIB_PATH_TYPE_DEAG] = "deag", \
127  [FIB_PATH_TYPE_INTF_RX] = "intf-rx", \
128  [FIB_PATH_TYPE_UDP_ENCAP] = "udp-encap", \
129  [FIB_PATH_TYPE_RECEIVE] = "receive", \
130  [FIB_PATH_TYPE_BIER_IMP] = "bier-imp", \
131  [FIB_PATH_TYPE_BIER_TABLE] = "bier-table", \
132  [FIB_PATH_TYPE_BIER_FMASK] = "bier-fmask", \
133  [FIB_PATH_TYPE_DVR] = "dvr", \
134 }
135 
136 #define FOR_EACH_FIB_PATH_TYPE(_item) \
137  for (_item = FIB_PATH_TYPE_FIRST; \
138  _item <= FIB_PATH_TYPE_LAST; \
139  _item++)
140 
141 /**
142  * Enurmeration of path operational (i.e. derived) attributes
143  */
145  /**
146  * Marker. Add new types after this one.
147  */
149  /**
150  * The path forms part of a recursive loop.
151  */
153  /**
154  * The path is resolved
155  */
157  /**
158  * The path is attached, despite what the next-hop may say.
159  */
161  /**
162  * The path has become a permanent drop.
163  */
165  /**
166  * Marker. Add new types before this one, then update it.
167  */
169 } __attribute__ ((packed)) fib_path_oper_attribute_t;
170 
171 /**
172  * The maximum number of path operational attributes
173  */
174 #define FIB_PATH_OPER_ATTRIBUTE_MAX (FIB_PATH_OPER_ATTRIBUTE_LAST + 1)
175 
176 #define FIB_PATH_OPER_ATTRIBUTES { \
177  [FIB_PATH_OPER_ATTRIBUTE_RECURSIVE_LOOP] = "recursive-loop", \
178  [FIB_PATH_OPER_ATTRIBUTE_RESOLVED] = "resolved", \
179  [FIB_PATH_OPER_ATTRIBUTE_DROP] = "drop", \
180 }
181 
182 #define FOR_EACH_FIB_PATH_OPER_ATTRIBUTE(_item) \
183  for (_item = FIB_PATH_OPER_ATTRIBUTE_FIRST; \
184  _item <= FIB_PATH_OPER_ATTRIBUTE_LAST; \
185  _item++)
186 
187 /**
188  * Path flags from the attributes
189  */
196 } __attribute__ ((packed)) fib_path_oper_flags_t;
197 
198 /**
199  * A FIB path
200  */
201 typedef struct fib_path_t_ {
202  /**
203  * A path is a node in the FIB graph.
204  */
206 
207  /**
208  * The index of the path-list to which this path belongs
209  */
211 
212  /**
213  * This marks the start of the memory area used to hash
214  * the path
215  */
216  STRUCT_MARK(path_hash_start);
217 
218  /**
219  * Configuration Flags
220  */
222 
223  /**
224  * The type of the path. This is the selector for the union
225  */
226  fib_path_type_t fp_type;
227 
228  /**
229  * The protocol of the next-hop, i.e. the address family of the
230  * next-hop's address. We can't derive this from the address itself
231  * since the address can be all zeros
232  */
234 
235  /**
236  * UCMP [unnormalised] weigth
237  */
239 
240  /**
241  * A path preference. 0 is the best.
242  * Only paths of the best preference, that are 'up', are considered
243  * for forwarding.
244  */
246 
247  /**
248  * per-type union of the data required to resolve the path
249  */
250  union {
251  struct {
252  /**
253  * The next-hop
254  */
255  ip46_address_t fp_nh;
256  /**
257  * The interface
258  */
261  struct {
262  /**
263  * The interface
264  */
266  } attached;
267  struct {
268  union
269  {
270  /**
271  * The next-hop
272  */
273  ip46_address_t fp_ip;
274  struct {
275  /**
276  * The local label to resolve through.
277  */
279  /**
280  * The EOS bit of the resolving label
281  */
283  };
284  } fp_nh;
285  union {
286  /**
287  * The FIB table index in which to find the next-hop.
288  */
290  /**
291  * The BIER FIB the fmask is in
292  */
294  };
295  } recursive;
296  struct {
297  /**
298  * BIER FMask ID
299  */
301  } bier_fmask;
302  struct {
303  /**
304  * The BIER table's ID
305  */
307  } bier_table;
308  struct {
309  /**
310  * The BIER imposition object
311  * this is part of the path's key, since the index_t
312  * of an imposition object is the object's key.
313  */
315  } bier_imp;
316  struct {
317  /**
318  * The FIB index in which to perfom the next lookup
319  */
321  /**
322  * The RPF-ID to tag the packets with
323  */
325  } deag;
326  struct {
327  } special;
328  struct {
329  /**
330  * The user provided 'exclusive' DPO
331  */
333  } exclusive;
334  struct {
335  /**
336  * The interface on which the local address is configured
337  */
339  /**
340  * The next-hop
341  */
342  ip46_address_t fp_addr;
343  } receive;
344  struct {
345  /**
346  * The interface on which the packets will be input.
347  */
349  } intf_rx;
350  struct {
351  /**
352  * The UDP Encap object this path resolves through
353  */
355  } udp_encap;
356  struct {
357  /**
358  * The UDP Encap object this path resolves through
359  */
361  } classify;
362  struct {
363  /**
364  * The interface
365  */
367  } dvr;
368  };
369  STRUCT_MARK(path_hash_end);
370 
371  /**
372  * Memebers in this last section represent information that is
373  * dervied during resolution. It should not be copied to new paths
374  * nor compared.
375  */
376 
377  /**
378  * Operational Flags
379  */
381 
382  union {
383  /**
384  * the resolving via fib. not part of the union, since it it not part
385  * of the path's hash.
386  */
388  /**
389  * the resolving bier-table
390  */
392  /**
393  * the resolving bier-fmask
394  */
396  };
397 
398  /**
399  * The Data-path objects through which this path resolves for IP.
400  */
402 
403  /**
404  * the index of this path in the parent's child list.
405  */
407 } fib_path_t;
408 
409 /*
410  * Array of strings/names for the path types and attributes
411  */
412 static const char *fib_path_type_names[] = FIB_PATH_TYPES;
413 static const char *fib_path_oper_attribute_names[] = FIB_PATH_OPER_ATTRIBUTES;
414 static const char *fib_path_cfg_attribute_names[] = FIB_PATH_CFG_ATTRIBUTES;
415 
416 /*
417  * The memory pool from which we allocate all the paths
418  */
420 
421 /**
422  * the logger
423  */
425 
426 /*
427  * Debug macro
428  */
429 #define FIB_PATH_DBG(_p, _fmt, _args...) \
430 { \
431  vlib_log_debug (fib_path_logger, \
432  "[%U]: " _fmt, \
433  format_fib_path, fib_path_get_index(_p), 0, \
434  FIB_PATH_FORMAT_FLAGS_ONE_LINE, \
435  ##_args); \
436 }
437 
438 static fib_path_t *
440 {
441  return (pool_elt_at_index(fib_path_pool, index));
442 }
443 
444 static fib_node_index_t
446 {
447  return (path - fib_path_pool);
448 }
449 
450 static fib_node_t *
452 {
453  return ((fib_node_t*)fib_path_get(index));
454 }
455 
456 static fib_path_t*
458 {
460  return ((fib_path_t*)node);
461 }
462 
463 u8 *
464 format_fib_path (u8 * s, va_list * args)
465 {
466  fib_node_index_t path_index = va_arg (*args, fib_node_index_t);
467  u32 indent = va_arg (*args, u32);
469  vnet_main_t * vnm = vnet_get_main();
470  fib_path_oper_attribute_t oattr;
472  fib_path_t *path;
473  const char *eol;
474 
475  if (flags & FIB_PATH_FORMAT_FLAGS_ONE_LINE)
476  {
477  eol = "";
478  }
479  else
480  {
481  eol = "\n";
482  }
483 
484  path = fib_path_get(path_index);
485 
486  s = format (s, "%Upath:[%d] ", format_white_space, indent,
487  fib_path_get_index(path));
488  s = format (s, "pl-index:%d ", path->fp_pl_index);
489  s = format (s, "%U ", format_dpo_proto, path->fp_nh_proto);
490  s = format (s, "weight=%d ", path->fp_weight);
491  s = format (s, "pref=%d ", path->fp_preference);
492  s = format (s, "%s: ", fib_path_type_names[path->fp_type]);
493  if (FIB_PATH_OPER_FLAG_NONE != path->fp_oper_flags) {
494  s = format(s, " oper-flags:");
496  if ((1<<oattr) & path->fp_oper_flags) {
497  s = format (s, "%s,", fib_path_oper_attribute_names[oattr]);
498  }
499  }
500  }
501  if (FIB_PATH_CFG_FLAG_NONE != path->fp_cfg_flags) {
502  s = format(s, " cfg-flags:");
504  if ((1<<cattr) & path->fp_cfg_flags) {
505  s = format (s, "%s,", fib_path_cfg_attribute_names[cattr]);
506  }
507  }
508  }
509  if (!(flags & FIB_PATH_FORMAT_FLAGS_ONE_LINE))
510  s = format(s, "\n%U", format_white_space, indent+2);
511 
512  switch (path->fp_type)
513  {
515  s = format (s, "%U", format_ip46_address,
516  &path->attached_next_hop.fp_nh,
517  IP46_TYPE_ANY);
519  {
520  s = format (s, " if_index:%d", path->attached_next_hop.fp_interface);
521  }
522  else
523  {
524  s = format (s, " %U",
526  vnm,
528  vnm,
529  path->attached_next_hop.fp_interface));
531  path->attached_next_hop.fp_interface))
532  {
533  s = format (s, " (p2p)");
534  }
535  }
536  if (!dpo_id_is_valid(&path->fp_dpo))
537  {
538  s = format(s, "%s%Uunresolved", eol, format_white_space, indent+2);
539  }
540  else
541  {
542  s = format(s, "%s%U%U", eol,
543  format_white_space, indent,
545  &path->fp_dpo, 13);
546  }
547  break;
550  {
551  s = format (s, "if_index:%d", path->attached_next_hop.fp_interface);
552  }
553  else
554  {
555  s = format (s, " %U",
557  vnm,
559  vnm,
560  path->attached.fp_interface));
561  }
562  break;
564  if (DPO_PROTO_MPLS == path->fp_nh_proto)
565  {
566  s = format (s, "via %U %U",
568  path->recursive.fp_nh.fp_local_label,
570  path->recursive.fp_nh.fp_eos);
571  }
572  else
573  {
574  s = format (s, "via %U",
576  &path->recursive.fp_nh.fp_ip,
577  IP46_TYPE_ANY);
578  }
579  s = format (s, " in fib:%d",
580  path->recursive.fp_tbl_id,
581  path->fp_via_fib);
582  s = format (s, " via-fib:%d", path->fp_via_fib);
583  s = format (s, " via-dpo:[%U:%d]",
585  path->fp_dpo.dpoi_index);
586 
587  break;
589  s = format (s, "UDP-encap ID:%d", path->udp_encap.fp_udp_encap_id);
590  break;
592  s = format (s, "via bier-table:[%U}",
594  &path->bier_table.fp_bier_tbl);
595  s = format (s, " via-dpo:[%U:%d]",
597  path->fp_dpo.dpoi_index);
598  break;
600  s = format (s, "via-fmask:%d", path->bier_fmask.fp_bier_fmask);
601  s = format (s, " via-dpo:[%U:%d]",
603  path->fp_dpo.dpoi_index);
604  break;
606  s = format (s, "via %U", format_bier_imp,
607  path->bier_imp.fp_bier_imp, 0, BIER_SHOW_BRIEF);
608  break;
609  case FIB_PATH_TYPE_DVR:
610  s = format (s, " %U",
612  vnm,
614  vnm,
615  path->dvr.fp_interface));
616  break;
617  case FIB_PATH_TYPE_DEAG:
618  s = format (s, " %sfib-index:%d",
619  (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ? "m" : ""),
620  path->deag.fp_tbl_id);
621  break;
626  if (dpo_id_is_valid(&path->fp_dpo))
627  {
628  s = format(s, "%U", format_dpo_id,
629  &path->fp_dpo, indent+2);
630  }
631  break;
632  }
633  return (s);
634 }
635 
636 /*
637  * fib_path_last_lock_gone
638  *
639  * We don't share paths, we share path lists, so the [un]lock functions
640  * are no-ops
641  */
642 static void
644 {
645  ASSERT(0);
646 }
647 
648 static fib_path_t*
650  vnet_link_t link,
651  dpo_id_t *dpo)
652 {
653  fib_node_index_t fib_path_index;
654  fib_protocol_t nh_proto;
655  adj_index_t ai;
656 
657  fib_path_index = fib_path_get_index(path);
658  nh_proto = dpo_proto_to_fib(path->fp_nh_proto);
659 
661  path->attached_next_hop.fp_interface))
662  {
663  /*
664  * if the interface is p2p then the adj for the specific
665  * neighbour on that link will never exist. on p2p links
666  * the subnet address (the attached route) links to the
667  * auto-adj (see below), we want that adj here too.
668  */
669  ai = adj_nbr_add_or_lock(nh_proto, link, &zero_addr,
670  path->attached_next_hop.fp_interface);
671  }
672  else
673  {
674  ai = adj_nbr_add_or_lock(nh_proto, link,
675  &path->attached_next_hop.fp_nh,
676  path->attached_next_hop.fp_interface);
677  }
678 
680  adj_unlock(ai);
681 
682  return (fib_path_get(fib_path_index));
683 }
684 
685 static void
687 {
688  /*
689  * resolve directly via the adjacency discribed by the
690  * interface and next-hop
691  */
694  &path->fp_dpo);
695 
696  ASSERT(dpo_is_adj(&path->fp_dpo));
697 
698  /*
699  * become a child of the adjacency so we receive updates
700  * when its rewrite changes
701  */
704  fib_path_get_index(path));
705 
707  path->attached_next_hop.fp_interface) ||
708  !adj_is_up(path->fp_dpo.dpoi_index))
709  {
711  }
712 }
713 
714 static void
716  vnet_link_t link,
717  dpo_id_t *dpo)
718 {
719  fib_protocol_t nh_proto;
720 
721  nh_proto = dpo_proto_to_fib(path->fp_nh_proto);
722 
724  path->attached.fp_interface))
725  {
726  /*
727  * point-2-point interfaces do not require a glean, since
728  * there is nothing to ARP. Install a rewrite/nbr adj instead
729  */
730  adj_index_t ai;
731 
732  ai = adj_nbr_add_or_lock(nh_proto, link, &zero_addr,
733  path->attached.fp_interface);
734 
736  adj_unlock(ai);
737  }
739  path->attached.fp_interface))
740  {
741  dpo_copy(dpo, drop_dpo_get(path->fp_nh_proto));
742  }
743  else
744  {
745  adj_index_t ai;
746 
747  ai = adj_glean_add_or_lock(nh_proto, link,
748  path->attached.fp_interface,
749  NULL);
751  adj_unlock(ai);
752  }
753 }
754 
755 /*
756  * create of update the paths recursive adj
757  */
758 static void
761  dpo_id_t *dpo)
762 {
763  dpo_id_t via_dpo = DPO_INVALID;
764 
765  /*
766  * get the DPO to resolve through from the via-entry
767  */
769  fct,
770  &via_dpo);
771 
772 
773  /*
774  * hope for the best - clear if restrictions apply.
775  */
777 
778  /*
779  * Validate any recursion constraints and over-ride the via
780  * adj if not met
781  */
783  {
785  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
786  }
788  {
789  /*
790  * the via FIB must be a host route.
791  * note the via FIB just added will always be a host route
792  * since it is an RR source added host route. So what we need to
793  * check is whether the route has other sources. If it does then
794  * some other source has added it as a host route. If it doesn't
795  * then it was added only here and inherits forwarding from a cover.
796  * the cover is not a host route.
797  * The RR source is the lowest priority source, so we check if it
798  * is the best. if it is there are no other sources.
799  */
801  {
803  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
804 
805  /*
806  * PIC edge trigger. let the load-balance maps know
807  */
809  }
810  }
812  {
813  /*
814  * RR source entries inherit the flags from the cover, so
815  * we can check the via directly
816  */
818  {
820  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
821 
822  /*
823  * PIC edge trigger. let the load-balance maps know
824  */
826  }
827  }
828  /*
829  * check for over-riding factors on the FIB entry itself
830  */
831  if (!fib_entry_is_resolved(path->fp_via_fib))
832  {
834  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
835 
836  /*
837  * PIC edge trigger. let the load-balance maps know
838  */
840  }
841 
842  /*
843  * If this path is contributing a drop, then it's not resolved
844  */
845  if (dpo_is_drop(&via_dpo) || load_balance_is_drop(&via_dpo))
846  {
848  }
849 
850  /*
851  * update the path's contributed DPO
852  */
853  dpo_copy(dpo, &via_dpo);
854 
855  FIB_PATH_DBG(path, "recursive update:");
856 
857  dpo_reset(&via_dpo);
858 }
859 
860 /*
861  * re-evaulate the forwarding state for a via fmask path
862  */
863 static void
865  dpo_id_t *dpo)
866 {
867  bier_fmask_contribute_forwarding(path->bier_fmask.fp_bier_fmask, dpo);
868 
869  /*
870  * if we are stakcing on the drop, then the path is not resolved
871  */
872  if (dpo_is_drop(dpo))
873  {
875  }
876  else
877  {
879  }
880 }
881 
882 /*
883  * fib_path_is_permanent_drop
884  *
885  * Return !0 if the path is configured to permanently drop,
886  * despite other attributes.
887  */
888 static int
890 {
891  return ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DROP) ||
893 }
894 
895 /*
896  * fib_path_unresolve
897  *
898  * Remove our dependency on the resolution target
899  */
900 static void
902 {
903  /*
904  * the forced drop path does not need unresolving
905  */
906  if (fib_path_is_permanent_drop(path))
907  {
908  return;
909  }
910 
911  switch (path->fp_type)
912  {
914  if (FIB_NODE_INDEX_INVALID != path->fp_via_fib)
915  {
917  path->fp_sibling);
920  FIB_SOURCE_RR);
921  fib_table_unlock(path->recursive.fp_tbl_id,
923  FIB_SOURCE_RR);
925  }
926  break;
929  path->fp_sibling);
930  break;
933  break;
936  break;
939  if (dpo_is_adj(&path->fp_dpo))
941  path->fp_sibling);
942  break;
945  break;
947  dpo_reset(&path->exclusive.fp_ex_dpo);
948  break;
952  case FIB_PATH_TYPE_DEAG:
953  case FIB_PATH_TYPE_DVR:
954  /*
955  * these hold only the path's DPO, which is reset below.
956  */
957  break;
958  }
959 
960  /*
961  * release the adj we were holding and pick up the
962  * drop just in case.
963  */
964  dpo_reset(&path->fp_dpo);
966 
967  return;
968 }
969 
972 {
973  if (DPO_PROTO_MPLS == path->fp_nh_proto)
974  {
975  if (FIB_PATH_TYPE_RECURSIVE == path->fp_type &&
976  MPLS_EOS == path->recursive.fp_nh.fp_eos)
977  {
979  }
980  else
981  {
983  }
984  }
985  else
986  {
988  }
989 }
990 
991 /*
992  * fib_path_back_walk_notify
993  *
994  * A back walk has reach this path.
995  */
999 {
1000  fib_path_t *path;
1001 
1002  path = fib_path_from_fib_node(node);
1003 
1004  FIB_PATH_DBG(path, "bw:%U",
1006 
1007  switch (path->fp_type)
1008  {
1011  {
1012  /*
1013  * modify the recursive adjacency to use the new forwarding
1014  * of the via-fib.
1015  * this update is visible to packets in flight in the DP.
1016  */
1018  path,
1019  fib_path_to_chain_type(path),
1020  &path->fp_dpo);
1021  }
1024  {
1025  /*
1026  * ADJ updates (complete<->incomplete) do not need to propagate to
1027  * recursive entries.
1028  * The only reason its needed as far back as here, is that the adj
1029  * and the incomplete adj are a different DPO type, so the LBs need
1030  * to re-stack.
1031  * If this walk was quashed in the fib_entry, then any non-fib_path
1032  * children (like tunnels that collapse out the LB when they stack)
1033  * would not see the update.
1034  */
1035  return (FIB_NODE_BACK_WALK_CONTINUE);
1036  }
1037  break;
1040  {
1041  /*
1042  * update to use the BIER fmask's new forwading
1043  */
1044  fib_path_bier_fmask_update(path, &path->fp_dpo);
1045  }
1048  {
1049  /*
1050  * ADJ updates (complete<->incomplete) do not need to propagate to
1051  * recursive entries.
1052  * The only reason its needed as far back as here, is that the adj
1053  * and the incomplete adj are a different DPO type, so the LBs need
1054  * to re-stack.
1055  * If this walk was quashed in the fib_entry, then any non-fib_path
1056  * children (like tunnels that collapse out the LB when they stack)
1057  * would not see the update.
1058  */
1059  return (FIB_NODE_BACK_WALK_CONTINUE);
1060  }
1061  break;
1063  /*
1064 FIXME comment
1065  * ADJ_UPDATE backwalk pass silently through here and up to
1066  * the path-list when the multipath adj collapse occurs.
1067  * The reason we do this is that the assumtption is that VPP
1068  * runs in an environment where the Control-Plane is remote
1069  * and hence reacts slowly to link up down. In order to remove
1070  * this down link from the ECMP set quickly, we back-walk.
1071  * VPP also has dedicated CPUs, so we are not stealing resources
1072  * from the CP to do so.
1073  */
1075  {
1077  {
1078  /*
1079  * alreday resolved. no need to walk back again
1080  */
1081  return (FIB_NODE_BACK_WALK_CONTINUE);
1082  }
1084  }
1086  {
1088  {
1089  /*
1090  * alreday unresolved. no need to walk back again
1091  */
1092  return (FIB_NODE_BACK_WALK_CONTINUE);
1093  }
1095  }
1097  {
1098  /*
1099  * The interface this path resolves through has been deleted.
1100  * This will leave the path in a permanent drop state. The route
1101  * needs to be removed and readded (and hence the path-list deleted)
1102  * before it can forward again.
1103  */
1104  fib_path_unresolve(path);
1106  }
1108  {
1109  /*
1110  * restack the DPO to pick up the correct DPO sub-type
1111  */
1112  uword if_is_up;
1113 
1114  if_is_up = vnet_sw_interface_is_up(
1115  vnet_get_main(),
1116  path->attached_next_hop.fp_interface);
1117 
1119  path,
1121  &path->fp_dpo);
1122 
1124  if (if_is_up && adj_is_up(path->fp_dpo.dpoi_index))
1125  {
1127  }
1128 
1129  if (!if_is_up)
1130  {
1131  /*
1132  * If the interface is not up there is no reason to walk
1133  * back to children. if we did they would only evalute
1134  * that this path is unresolved and hence it would
1135  * not contribute the adjacency - so it would be wasted
1136  * CPU time.
1137  */
1138  return (FIB_NODE_BACK_WALK_CONTINUE);
1139  }
1140  }
1142  {
1144  {
1145  /*
1146  * alreday unresolved. no need to walk back again
1147  */
1148  return (FIB_NODE_BACK_WALK_CONTINUE);
1149  }
1150  /*
1151  * the adj has gone down. the path is no longer resolved.
1152  */
1154  }
1155  break;
1157  case FIB_PATH_TYPE_DVR:
1158  /*
1159  * FIXME; this could schedule a lower priority walk, since attached
1160  * routes are not usually in ECMP configurations so the backwalk to
1161  * the FIB entry does not need to be high priority
1162  */
1164  {
1166  }
1168  {
1170  }
1172  {
1173  fib_path_unresolve(path);
1175  }
1176  break;
1178  {
1179  dpo_id_t via_dpo = DPO_INVALID;
1180 
1181  /*
1182  * hope for the best - clear if restrictions apply.
1183  */
1185 
1186  udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
1187  path->fp_nh_proto,
1188  &via_dpo);
1189  /*
1190  * If this path is contributing a drop, then it's not resolved
1191  */
1192  if (dpo_is_drop(&via_dpo) || load_balance_is_drop(&via_dpo))
1193  {
1195  }
1196 
1197  /*
1198  * update the path's contributed DPO
1199  */
1200  dpo_copy(&path->fp_dpo, &via_dpo);
1201  dpo_reset(&via_dpo);
1202  break;
1203  }
1204  case FIB_PATH_TYPE_INTF_RX:
1205  ASSERT(0);
1206  case FIB_PATH_TYPE_DEAG:
1207  /*
1208  * FIXME When VRF delete is allowed this will need a poke.
1209  */
1210  case FIB_PATH_TYPE_SPECIAL:
1211  case FIB_PATH_TYPE_RECEIVE:
1215  /*
1216  * these path types have no parents. so to be
1217  * walked from one is unexpected.
1218  */
1219  ASSERT(0);
1220  break;
1221  }
1222 
1223  /*
1224  * propagate the backwalk further to the path-list
1225  */
1227 
1228  return (FIB_NODE_BACK_WALK_CONTINUE);
1229 }
1230 
1231 static void
1233 {
1234  fib_show_memory_usage("Path",
1235  pool_elts(fib_path_pool),
1236  pool_len(fib_path_pool),
1237  sizeof(fib_path_t));
1238 }
1239 
1240 /*
1241  * The FIB path's graph node virtual function table
1242  */
1243 static const fib_node_vft_t fib_path_vft = {
1245  .fnv_last_lock = fib_path_last_lock_gone,
1246  .fnv_back_walk = fib_path_back_walk_notify,
1247  .fnv_mem_show = fib_path_memory_show,
1248 };
1249 
1250 static fib_path_cfg_flags_t
1252 {
1254 
1255  if (rpath->frp_flags & FIB_ROUTE_PATH_POP_PW_CW)
1256  cfg_flags |= FIB_PATH_CFG_FLAG_POP_PW_CW;
1258  cfg_flags |= FIB_PATH_CFG_FLAG_RESOLVE_HOST;
1261  if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL)
1262  cfg_flags |= FIB_PATH_CFG_FLAG_LOCAL;
1263  if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
1264  cfg_flags |= FIB_PATH_CFG_FLAG_ATTACHED;
1265  if (rpath->frp_flags & FIB_ROUTE_PATH_INTF_RX)
1266  cfg_flags |= FIB_PATH_CFG_FLAG_INTF_RX;
1267  if (rpath->frp_flags & FIB_ROUTE_PATH_RPF_ID)
1268  cfg_flags |= FIB_PATH_CFG_FLAG_RPF_ID;
1269  if (rpath->frp_flags & FIB_ROUTE_PATH_EXCLUSIVE)
1270  cfg_flags |= FIB_PATH_CFG_FLAG_EXCLUSIVE;
1271  if (rpath->frp_flags & FIB_ROUTE_PATH_DROP)
1272  cfg_flags |= FIB_PATH_CFG_FLAG_DROP;
1274  cfg_flags |= FIB_PATH_CFG_FLAG_DEAG_SRC;
1276  cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_UNREACH;
1278  cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_PROHIBIT;
1279 
1280  return (cfg_flags);
1281 }
1282 
1283 /*
1284  * fib_path_create
1285  *
1286  * Create and initialise a new path object.
1287  * return the index of the path.
1288  */
1291  const fib_route_path_t *rpath)
1292 {
1293  fib_path_t *path;
1294 
1295  pool_get(fib_path_pool, path);
1296  clib_memset(path, 0, sizeof(*path));
1297 
1298  fib_node_init(&path->fp_node,
1300 
1301  dpo_reset(&path->fp_dpo);
1302  path->fp_pl_index = pl_index;
1303  path->fp_nh_proto = rpath->frp_proto;
1305  path->fp_weight = rpath->frp_weight;
1306  if (0 == path->fp_weight)
1307  {
1308  /*
1309  * a weight of 0 is a meaningless value. We could either reject it, and thus force
1310  * clients to always use 1, or we can accept it and fixup approrpiately.
1311  */
1312  path->fp_weight = 1;
1313  }
1314  path->fp_preference = rpath->frp_preference;
1316 
1317  /*
1318  * deduce the path's tpye from the parementers and save what is needed.
1319  */
1321  {
1323  path->receive.fp_interface = rpath->frp_sw_if_index;
1324  path->receive.fp_addr = rpath->frp_addr;
1325  }
1326  else if (rpath->frp_flags & FIB_ROUTE_PATH_UDP_ENCAP)
1327  {
1329  path->udp_encap.fp_udp_encap_id = rpath->frp_udp_encap_id;
1330  }
1331  else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_INTF_RX)
1332  {
1334  path->intf_rx.fp_interface = rpath->frp_sw_if_index;
1335  }
1336  else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID)
1337  {
1338  path->fp_type = FIB_PATH_TYPE_DEAG;
1339  path->deag.fp_tbl_id = rpath->frp_fib_index;
1340  path->deag.fp_rpf_id = rpath->frp_rpf_id;
1341  }
1342  else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_FMASK)
1343  {
1345  path->bier_fmask.fp_bier_fmask = rpath->frp_bier_fmask;
1346  }
1347  else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_IMP)
1348  {
1350  path->bier_imp.fp_bier_imp = rpath->frp_bier_imp;
1351  }
1352  else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_TABLE)
1353  {
1355  path->bier_table.fp_bier_tbl = rpath->frp_bier_tbl;
1356  }
1357  else if (rpath->frp_flags & FIB_ROUTE_PATH_DEAG)
1358  {
1359  path->fp_type = FIB_PATH_TYPE_DEAG;
1360  path->deag.fp_tbl_id = rpath->frp_fib_index;
1361  }
1362  else if (rpath->frp_flags & FIB_ROUTE_PATH_DVR)
1363  {
1364  path->fp_type = FIB_PATH_TYPE_DVR;
1365  path->dvr.fp_interface = rpath->frp_sw_if_index;
1366  }
1367  else if (rpath->frp_flags & FIB_ROUTE_PATH_EXCLUSIVE)
1368  {
1370  dpo_copy(&path->exclusive.fp_ex_dpo, &rpath->dpo);
1371  }
1372  else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT) ||
1374  {
1376  }
1377  else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY))
1378  {
1380  path->classify.fp_classify_table_id = rpath->frp_classify_table_id;
1381  }
1382  else if (~0 != rpath->frp_sw_if_index)
1383  {
1384  if (ip46_address_is_zero(&rpath->frp_addr))
1385  {
1387  path->attached.fp_interface = rpath->frp_sw_if_index;
1388  }
1389  else
1390  {
1392  path->attached_next_hop.fp_interface = rpath->frp_sw_if_index;
1393  path->attached_next_hop.fp_nh = rpath->frp_addr;
1394  }
1395  }
1396  else
1397  {
1398  if (ip46_address_is_zero(&rpath->frp_addr))
1399  {
1400  if (~0 == rpath->frp_fib_index)
1401  {
1403  }
1404  else
1405  {
1406  path->fp_type = FIB_PATH_TYPE_DEAG;
1407  path->deag.fp_tbl_id = rpath->frp_fib_index;
1408  path->deag.fp_rpf_id = ~0;
1409  }
1410  }
1411  else
1412  {
1414  if (DPO_PROTO_MPLS == path->fp_nh_proto)
1415  {
1416  path->recursive.fp_nh.fp_local_label = rpath->frp_local_label;
1417  path->recursive.fp_nh.fp_eos = rpath->frp_eos;
1418  }
1419  else
1420  {
1421  path->recursive.fp_nh.fp_ip = rpath->frp_addr;
1422  }
1423  path->recursive.fp_tbl_id = rpath->frp_fib_index;
1424  }
1425  }
1426 
1427  FIB_PATH_DBG(path, "create");
1428 
1429  return (fib_path_get_index(path));
1430 }
1431 
1432 /*
1433  * fib_path_create_special
1434  *
1435  * Create and initialise a new path object.
1436  * return the index of the path.
1437  */
1440  dpo_proto_t nh_proto,
1442  const dpo_id_t *dpo)
1443 {
1444  fib_path_t *path;
1445 
1446  pool_get(fib_path_pool, path);
1447  clib_memset(path, 0, sizeof(*path));
1448 
1449  fib_node_init(&path->fp_node,
1451  dpo_reset(&path->fp_dpo);
1452 
1453  path->fp_pl_index = pl_index;
1454  path->fp_weight = 1;
1455  path->fp_preference = 0;
1456  path->fp_nh_proto = nh_proto;
1458  path->fp_cfg_flags = flags;
1459 
1460  if (FIB_PATH_CFG_FLAG_DROP & flags)
1461  {
1463  }
1464  else if (FIB_PATH_CFG_FLAG_LOCAL & flags)
1465  {
1467  path->attached.fp_interface = FIB_NODE_INDEX_INVALID;
1468  }
1469  else
1470  {
1472  ASSERT(NULL != dpo);
1473  dpo_copy(&path->exclusive.fp_ex_dpo, dpo);
1474  }
1475 
1476  return (fib_path_get_index(path));
1477 }
1478 
1479 /*
1480  * fib_path_copy
1481  *
1482  * Copy a path. return index of new path.
1483  */
1486  fib_node_index_t path_list_index)
1487 {
1488  fib_path_t *path, *orig_path;
1489 
1490  pool_get(fib_path_pool, path);
1491 
1492  orig_path = fib_path_get(path_index);
1493  ASSERT(NULL != orig_path);
1494 
1495  clib_memcpy(path, orig_path, sizeof(*path));
1496 
1497  FIB_PATH_DBG(path, "create-copy:%d", path_index);
1498 
1499  /*
1500  * reset the dynamic section
1501  */
1504  path->fp_pl_index = path_list_index;
1506  clib_memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
1507  dpo_reset(&path->fp_dpo);
1508 
1509  return (fib_path_get_index(path));
1510 }
1511 
1512 /*
1513  * fib_path_destroy
1514  *
1515  * destroy a path that is no longer required
1516  */
1517 void
1519 {
1520  fib_path_t *path;
1521 
1522  path = fib_path_get(path_index);
1523 
1524  ASSERT(NULL != path);
1525  FIB_PATH_DBG(path, "destroy");
1526 
1527  fib_path_unresolve(path);
1528 
1529  fib_node_deinit(&path->fp_node);
1530  pool_put(fib_path_pool, path);
1531 }
1532 
1533 /*
1534  * fib_path_destroy
1535  *
1536  * destroy a path that is no longer required
1537  */
1538 uword
1540 {
1541  fib_path_t *path;
1542 
1543  path = fib_path_get(path_index);
1544 
1545  return (hash_memory(STRUCT_MARK_PTR(path, path_hash_start),
1546  (STRUCT_OFFSET_OF(fib_path_t, path_hash_end) -
1547  STRUCT_OFFSET_OF(fib_path_t, path_hash_start)),
1548  0));
1549 }
1550 
1551 /*
1552  * fib_path_cmp_i
1553  *
1554  * Compare two paths for equivalence.
1555  */
1556 static int
1558  const fib_path_t *path2)
1559 {
1560  int res;
1561 
1562  res = 1;
1563 
1564  /*
1565  * paths of different types and protocol are not equal.
1566  * different weights and/or preference only are the same path.
1567  */
1568  if (path1->fp_type != path2->fp_type)
1569  {
1570  res = (path1->fp_type - path2->fp_type);
1571  }
1572  else if (path1->fp_nh_proto != path2->fp_nh_proto)
1573  {
1574  res = (path1->fp_nh_proto - path2->fp_nh_proto);
1575  }
1576  else
1577  {
1578  /*
1579  * both paths are of the same type.
1580  * consider each type and its attributes in turn.
1581  */
1582  switch (path1->fp_type)
1583  {
1585  res = ip46_address_cmp(&path1->attached_next_hop.fp_nh,
1586  &path2->attached_next_hop.fp_nh);
1587  if (0 == res) {
1588  res = (path1->attached_next_hop.fp_interface -
1589  path2->attached_next_hop.fp_interface);
1590  }
1591  break;
1593  res = (path1->attached.fp_interface -
1594  path2->attached.fp_interface);
1595  break;
1597  res = ip46_address_cmp(&path1->recursive.fp_nh.fp_ip,
1598  &path2->recursive.fp_nh.fp_ip);
1599 
1600  if (0 == res)
1601  {
1602  res = (path1->recursive.fp_tbl_id - path2->recursive.fp_tbl_id);
1603  }
1604  break;
1606  res = (path1->bier_fmask.fp_bier_fmask -
1607  path2->bier_fmask.fp_bier_fmask);
1608  break;
1610  res = (path1->bier_imp.fp_bier_imp -
1611  path2->bier_imp.fp_bier_imp);
1612  break;
1614  res = bier_table_id_cmp(&path1->bier_table.fp_bier_tbl,
1615  &path2->bier_table.fp_bier_tbl);
1616  break;
1617  case FIB_PATH_TYPE_DEAG:
1618  res = (path1->deag.fp_tbl_id - path2->deag.fp_tbl_id);
1619  if (0 == res)
1620  {
1621  res = (path1->deag.fp_rpf_id - path2->deag.fp_rpf_id);
1622  }
1623  break;
1624  case FIB_PATH_TYPE_INTF_RX:
1625  res = (path1->intf_rx.fp_interface - path2->intf_rx.fp_interface);
1626  break;
1628  res = (path1->udp_encap.fp_udp_encap_id - path2->udp_encap.fp_udp_encap_id);
1629  break;
1630  case FIB_PATH_TYPE_DVR:
1631  res = (path1->dvr.fp_interface - path2->dvr.fp_interface);
1632  break;
1634  res = dpo_cmp(&path1->exclusive.fp_ex_dpo, &path2->exclusive.fp_ex_dpo);
1635  break;
1636  case FIB_PATH_TYPE_SPECIAL:
1637  case FIB_PATH_TYPE_RECEIVE:
1638  res = 0;
1639  break;
1640  }
1641  }
1642  return (res);
1643 }
1644 
1645 /*
1646  * fib_path_cmp_for_sort
1647  *
1648  * Compare two paths for equivalence. Used during path sorting.
1649  * As usual 0 means equal.
1650  */
1651 int
1653  void * v2)
1654 {
1655  fib_node_index_t *pi1 = v1, *pi2 = v2;
1656  fib_path_t *path1, *path2;
1657 
1658  path1 = fib_path_get(*pi1);
1659  path2 = fib_path_get(*pi2);
1660 
1661  /*
1662  * when sorting paths we want the highest preference paths
1663  * first, so that the choices set built is in prefernce order
1664  */
1665  if (path1->fp_preference != path2->fp_preference)
1666  {
1667  return (path1->fp_preference - path2->fp_preference);
1668  }
1669 
1670  return (fib_path_cmp_i(path1, path2));
1671 }
1672 
1673 /*
1674  * fib_path_cmp
1675  *
1676  * Compare two paths for equivalence.
1677  */
1678 int
1680  fib_node_index_t pi2)
1681 {
1682  fib_path_t *path1, *path2;
1683 
1684  path1 = fib_path_get(pi1);
1685  path2 = fib_path_get(pi2);
1686 
1687  return (fib_path_cmp_i(path1, path2));
1688 }
1689 
1690 int
1692  const fib_route_path_t *rpath)
1693 {
1694  fib_path_t *path;
1695  int res;
1696 
1697  path = fib_path_get(path_index);
1698 
1699  res = 1;
1700 
1701  if (path->fp_weight != rpath->frp_weight)
1702  {
1703  res = (path->fp_weight - rpath->frp_weight);
1704  }
1705  else
1706  {
1707  /*
1708  * both paths are of the same type.
1709  * consider each type and its attributes in turn.
1710  */
1711  switch (path->fp_type)
1712  {
1714  res = ip46_address_cmp(&path->attached_next_hop.fp_nh,
1715  &rpath->frp_addr);
1716  if (0 == res)
1717  {
1718  res = (path->attached_next_hop.fp_interface -
1719  rpath->frp_sw_if_index);
1720  }
1721  break;
1723  res = (path->attached.fp_interface - rpath->frp_sw_if_index);
1724  break;
1726  if (DPO_PROTO_MPLS == path->fp_nh_proto)
1727  {
1728  res = path->recursive.fp_nh.fp_local_label - rpath->frp_local_label;
1729 
1730  if (res == 0)
1731  {
1732  res = path->recursive.fp_nh.fp_eos - rpath->frp_eos;
1733  }
1734  }
1735  else
1736  {
1737  res = ip46_address_cmp(&path->recursive.fp_nh.fp_ip,
1738  &rpath->frp_addr);
1739  }
1740 
1741  if (0 == res)
1742  {
1743  res = (path->recursive.fp_tbl_id - rpath->frp_fib_index);
1744  }
1745  break;
1747  res = (path->bier_fmask.fp_bier_fmask - rpath->frp_bier_fmask);
1748  break;
1750  res = (path->bier_imp.fp_bier_imp - rpath->frp_bier_imp);
1751  break;
1753  res = bier_table_id_cmp(&path->bier_table.fp_bier_tbl,
1754  &rpath->frp_bier_tbl);
1755  break;
1756  case FIB_PATH_TYPE_INTF_RX:
1757  res = (path->intf_rx.fp_interface - rpath->frp_sw_if_index);
1758  break;
1760  res = (path->udp_encap.fp_udp_encap_id - rpath->frp_udp_encap_id);
1761  break;
1762  case FIB_PATH_TYPE_DEAG:
1763  res = (path->deag.fp_tbl_id - rpath->frp_fib_index);
1764  if (0 == res)
1765  {
1766  res = (path->deag.fp_rpf_id - rpath->frp_rpf_id);
1767  }
1768  break;
1769  case FIB_PATH_TYPE_DVR:
1770  res = (path->dvr.fp_interface - rpath->frp_sw_if_index);
1771  break;
1773  res = dpo_cmp(&path->exclusive.fp_ex_dpo, &rpath->dpo);
1774  break;
1775  case FIB_PATH_TYPE_RECEIVE:
1776  if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL)
1777  {
1778  res = 0;
1779  }
1780  else
1781  {
1782  res = 1;
1783  }
1784  break;
1785  case FIB_PATH_TYPE_SPECIAL:
1786  res = 0;
1787  break;
1788  }
1789  }
1790  return (res);
1791 }
1792 
1793 /*
1794  * fib_path_recursive_loop_detect
1795  *
1796  * A forward walk of the FIB object graph to detect for a cycle/loop. This
1797  * walk is initiated when an entry is linking to a new path list or from an old.
1798  * The entry vector passed contains all the FIB entrys that are children of this
1799  * path (it is all the entries encountered on the walk so far). If this vector
1800  * contains the entry this path resolve via, then a loop is about to form.
1801  * The loop must be allowed to form, since we need the dependencies in place
1802  * so that we can track when the loop breaks.
1803  * However, we MUST not produce a loop in the forwarding graph (else packets
1804  * would loop around the switch path until the loop breaks), so we mark recursive
1805  * paths as looped so that they do not contribute forwarding information.
1806  * By marking the path as looped, an etry such as;
1807  * X/Y
1808  * via a.a.a.a (looped)
1809  * via b.b.b.b (not looped)
1810  * can still forward using the info provided by b.b.b.b only
1811  */
1812 int
1814  fib_node_index_t **entry_indicies)
1815 {
1816  fib_path_t *path;
1817 
1818  path = fib_path_get(path_index);
1819 
1820  /*
1821  * the forced drop path is never looped, cos it is never resolved.
1822  */
1823  if (fib_path_is_permanent_drop(path))
1824  {
1825  return (0);
1826  }
1827 
1828  switch (path->fp_type)
1829  {
1831  {
1832  fib_node_index_t *entry_index, *entries;
1833  int looped = 0;
1834  entries = *entry_indicies;
1835 
1836  vec_foreach(entry_index, entries) {
1837  if (*entry_index == path->fp_via_fib)
1838  {
1839  /*
1840  * the entry that is about to link to this path-list (or
1841  * one of this path-list's children) is the same entry that
1842  * this recursive path resolves through. this is a cycle.
1843  * abort the walk.
1844  */
1845  looped = 1;
1846  break;
1847  }
1848  }
1849 
1850  if (looped)
1851  {
1852  FIB_PATH_DBG(path, "recursive loop formed");
1854 
1855  dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1856  }
1857  else
1858  {
1859  /*
1860  * no loop here yet. keep forward walking the graph.
1861  */
1862  if (fib_entry_recursive_loop_detect(path->fp_via_fib, entry_indicies))
1863  {
1864  FIB_PATH_DBG(path, "recursive loop formed");
1866  }
1867  else
1868  {
1869  FIB_PATH_DBG(path, "recursive loop cleared");
1871  }
1872  }
1873  break;
1874  }
1878  entry_indicies))
1879  {
1880  FIB_PATH_DBG(path, "recursive loop formed");
1882  }
1883  else
1884  {
1885  FIB_PATH_DBG(path, "recursive loop cleared");
1887  }
1888  break;
1889  case FIB_PATH_TYPE_SPECIAL:
1890  case FIB_PATH_TYPE_DEAG:
1891  case FIB_PATH_TYPE_DVR:
1892  case FIB_PATH_TYPE_RECEIVE:
1893  case FIB_PATH_TYPE_INTF_RX:
1899  /*
1900  * these path types cannot be part of a loop, since they are the leaves
1901  * of the graph.
1902  */
1903  break;
1904  }
1905 
1906  return (fib_path_is_looped(path_index));
1907 }
1908 
1909 int
1911 {
1912  fib_path_t *path;
1913 
1914  path = fib_path_get(path_index);
1915 
1916  /*
1917  * hope for the best.
1918  */
1920 
1921  /*
1922  * the forced drop path resolves via the drop adj
1923  */
1924  if (fib_path_is_permanent_drop(path))
1925  {
1926  dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1928  return (fib_path_is_resolved(path_index));
1929  }
1930 
1931  switch (path->fp_type)
1932  {
1935  break;
1937  {
1938  dpo_id_t tmp = DPO_INVALID;
1939 
1940  /*
1941  * path->attached.fp_interface
1942  */
1944  path->attached.fp_interface))
1945  {
1947  }
1950  &tmp);
1951 
1952  /*
1953  * re-fetch after possible mem realloc
1954  */
1955  path = fib_path_get(path_index);
1956  dpo_copy(&path->fp_dpo, &tmp);
1957 
1958  /*
1959  * become a child of the adjacency so we receive updates
1960  * when the interface state changes
1961  */
1962  if (dpo_is_adj(&path->fp_dpo))
1963  {
1964  path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
1966  fib_path_get_index(path));
1967  }
1968  dpo_reset(&tmp);
1969  break;
1970  }
1972  {
1973  /*
1974  * Create a RR source entry in the table for the address
1975  * that this path recurses through.
1976  * This resolve action is recursive, hence we may create
1977  * more paths in the process. more creates mean maybe realloc
1978  * of this path.
1979  */
1980  fib_node_index_t fei;
1981  fib_prefix_t pfx;
1982 
1984 
1985  if (DPO_PROTO_MPLS == path->fp_nh_proto)
1986  {
1987  fib_prefix_from_mpls_label(path->recursive.fp_nh.fp_local_label,
1988  path->recursive.fp_nh.fp_eos,
1989  &pfx);
1990  }
1991  else
1992  {
1993  fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx);
1994  }
1995 
1996  fib_table_lock(path->recursive.fp_tbl_id,
1998  FIB_SOURCE_RR);
1999  fei = fib_table_entry_special_add(path->recursive.fp_tbl_id,
2000  &pfx,
2001  FIB_SOURCE_RR,
2003 
2004  path = fib_path_get(path_index);
2005  path->fp_via_fib = fei;
2006 
2007  /*
2008  * become a dependent child of the entry so the path is
2009  * informed when the forwarding for the entry changes.
2010  */
2013  fib_path_get_index(path));
2014 
2015  /*
2016  * create and configure the IP DPO
2017  */
2019  path,
2020  fib_path_to_chain_type(path),
2021  &path->fp_dpo);
2022 
2023  break;
2024  }
2026  {
2027  /*
2028  * become a dependent child of the entry so the path is
2029  * informed when the forwarding for the entry changes.
2030  */
2031  path->fp_sibling = bier_fmask_child_add(path->bier_fmask.fp_bier_fmask,
2033  fib_path_get_index(path));
2034 
2035  path->fp_via_bier_fmask = path->bier_fmask.fp_bier_fmask;
2036  fib_path_bier_fmask_update(path, &path->fp_dpo);
2037 
2038  break;
2039  }
2041  bier_imp_lock(path->bier_imp.fp_bier_imp);
2042  bier_imp_contribute_forwarding(path->bier_imp.fp_bier_imp,
2043  DPO_PROTO_IP4,
2044  &path->fp_dpo);
2045  break;
2047  {
2048  /*
2049  * Find/create the BIER table to link to
2050  */
2052 
2053  path->fp_via_bier_tbl =
2054  bier_table_ecmp_create_and_lock(&path->bier_table.fp_bier_tbl);
2055 
2057  &path->fp_dpo);
2058  break;
2059  }
2060  case FIB_PATH_TYPE_SPECIAL:
2062  {
2065  &path->fp_dpo);
2066  }
2068  {
2071  &path->fp_dpo);
2072  }
2073  else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY)
2074  {
2075  dpo_set (&path->fp_dpo, DPO_CLASSIFY,
2076  path->fp_nh_proto,
2078  path->classify.fp_classify_table_id));
2079  }
2080  else
2081  {
2082  /*
2083  * Resolve via the drop
2084  */
2085  dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
2086  }
2087  break;
2088  case FIB_PATH_TYPE_DEAG:
2089  {
2090  if (DPO_PROTO_BIER == path->fp_nh_proto)
2091  {
2093  &path->fp_dpo);
2094  }
2095  else
2096  {
2097  /*
2098  * Resolve via a lookup DPO.
2099  * FIXME. control plane should add routes with a table ID
2100  */
2101  lookup_input_t input;
2102  lookup_cast_t cast;
2103 
2104  cast = (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ?
2106  LOOKUP_UNICAST);
2107  input = (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DEAG_SRC ?
2110 
2111  lookup_dpo_add_or_lock_w_fib_index(path->deag.fp_tbl_id,
2112  path->fp_nh_proto,
2113  cast,
2114  input,
2116  &path->fp_dpo);
2117  }
2118  break;
2119  }
2120  case FIB_PATH_TYPE_DVR:
2121  dvr_dpo_add_or_lock(path->attached.fp_interface,
2122  path->fp_nh_proto,
2123  &path->fp_dpo);
2124  break;
2125  case FIB_PATH_TYPE_RECEIVE:
2126  /*
2127  * Resolve via a receive DPO.
2128  */
2130  path->receive.fp_interface,
2131  &path->receive.fp_addr,
2132  &path->fp_dpo);
2133  break;
2135  udp_encap_lock(path->udp_encap.fp_udp_encap_id);
2136  udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
2137  path->fp_nh_proto,
2138  &path->fp_dpo);
2139  break;
2140  case FIB_PATH_TYPE_INTF_RX: {
2141  /*
2142  * Resolve via a receive DPO.
2143  */
2145  path->intf_rx.fp_interface,
2146  &path->fp_dpo);
2147  break;
2148  }
2150  /*
2151  * Resolve via the user provided DPO
2152  */
2153  dpo_copy(&path->fp_dpo, &path->exclusive.fp_ex_dpo);
2154  break;
2155  }
2156 
2157  return (fib_path_is_resolved(path_index));
2158 }
2159 
2160 u32
2162 {
2163  fib_path_t *path;
2164 
2165  path = fib_path_get(path_index);
2166 
2167  switch (path->fp_type)
2168  {
2170  return (path->attached_next_hop.fp_interface);
2172  return (path->attached.fp_interface);
2173  case FIB_PATH_TYPE_RECEIVE:
2174  return (path->receive.fp_interface);
2176  if (fib_path_is_resolved(path_index))
2177  {
2179  }
2180  break;
2181  case FIB_PATH_TYPE_DVR:
2182  return (path->dvr.fp_interface);
2183  case FIB_PATH_TYPE_INTF_RX:
2185  case FIB_PATH_TYPE_SPECIAL:
2186  case FIB_PATH_TYPE_DEAG:
2191  break;
2192  }
2193  return (dpo_get_urpf(&path->fp_dpo));
2194 }
2195 
2196 index_t
2198 {
2199  fib_path_t *path;
2200 
2201  path = fib_path_get(path_index);
2202 
2203  switch (path->fp_type)
2204  {
2207  case FIB_PATH_TYPE_RECEIVE:
2208  case FIB_PATH_TYPE_INTF_RX:
2209  case FIB_PATH_TYPE_SPECIAL:
2210  case FIB_PATH_TYPE_DEAG:
2211  case FIB_PATH_TYPE_DVR:
2213  break;
2215  return (path->udp_encap.fp_udp_encap_id);
2217  return (path->fp_via_fib);
2219  return (path->bier_fmask.fp_bier_fmask);
2221  return (path->fp_via_bier_tbl);
2223  return (path->bier_imp.fp_bier_imp);
2224  }
2225  return (~0);
2226 }
2227 
2230 {
2231  fib_path_t *path;
2232 
2233  path = fib_path_get(path_index);
2234 
2235  if (dpo_is_adj(&path->fp_dpo))
2236  {
2237  return (path->fp_dpo.dpoi_index);
2238  }
2239  return (ADJ_INDEX_INVALID);
2240 }
2241 
2242 u16
2244 {
2245  fib_path_t *path;
2246 
2247  path = fib_path_get(path_index);
2248 
2249  ASSERT(path);
2250 
2251  return (path->fp_weight);
2252 }
2253 
2254 u16
2256 {
2257  fib_path_t *path;
2258 
2259  path = fib_path_get(path_index);
2260 
2261  ASSERT(path);
2262 
2263  return (path->fp_preference);
2264 }
2265 
2266 u32
2268 {
2269  fib_path_t *path;
2270 
2271  path = fib_path_get(path_index);
2272 
2273  ASSERT(path);
2274 
2276  {
2277  return (path->deag.fp_rpf_id);
2278  }
2279 
2280  return (~0);
2281 }
2282 
2283 /**
2284  * @brief Contribute the path's adjacency to the list passed.
2285  * By calling this function over all paths, recursively, a child
2286  * can construct its full set of forwarding adjacencies, and hence its
2287  * uRPF list.
2288  */
2289 void
2291  index_t urpf)
2292 {
2293  fib_path_t *path;
2294 
2295  path = fib_path_get(path_index);
2296 
2297  /*
2298  * resolved and unresolved paths contribute to the RPF list.
2299  */
2300  switch (path->fp_type)
2301  {
2303  fib_urpf_list_append(urpf, path->attached_next_hop.fp_interface);
2304  break;
2305 
2307  fib_urpf_list_append(urpf, path->attached.fp_interface);
2308  break;
2309 
2311  if (FIB_NODE_INDEX_INVALID != path->fp_via_fib &&
2312  !fib_path_is_looped(path_index))
2313  {
2314  /*
2315  * there's unresolved due to constraints, and there's unresolved
2316  * due to ain't got no via. can't do nowt w'out via.
2317  */
2319  }
2320  break;
2321 
2323  case FIB_PATH_TYPE_SPECIAL:
2324  {
2325  /*
2326  * these path types may link to an adj, if that's what
2327  * the clinet gave
2328  */
2329  u32 rpf_sw_if_index;
2330 
2331  rpf_sw_if_index = dpo_get_urpf(&path->fp_dpo);
2332 
2333  if (~0 != rpf_sw_if_index)
2334  {
2335  fib_urpf_list_append(urpf, rpf_sw_if_index);
2336  }
2337  break;
2338  }
2339  case FIB_PATH_TYPE_DVR:
2340  fib_urpf_list_append(urpf, path->dvr.fp_interface);
2341  break;
2342  case FIB_PATH_TYPE_DEAG:
2343  case FIB_PATH_TYPE_RECEIVE:
2344  case FIB_PATH_TYPE_INTF_RX:
2349  /*
2350  * these path types don't link to an adj
2351  */
2352  break;
2353  }
2354 }
2355 
2356 void
2358  dpo_proto_t payload_proto,
2360  dpo_id_t *dpo)
2361 {
2362  fib_path_t *path;
2363 
2364  path = fib_path_get(path_index);
2365 
2366  ASSERT(path);
2367 
2368  switch (path->fp_type)
2369  {
2371  {
2372  dpo_id_t tmp = DPO_INVALID;
2373 
2374  dpo_copy(&tmp, dpo);
2375 
2376  mpls_disp_dpo_create(payload_proto, ~0, mode, &tmp, dpo);
2377  dpo_reset(&tmp);
2378  break;
2379  }
2380  case FIB_PATH_TYPE_DEAG:
2381  {
2382  dpo_id_t tmp = DPO_INVALID;
2383 
2384  dpo_copy(&tmp, dpo);
2385 
2386  mpls_disp_dpo_create(payload_proto,
2387  path->deag.fp_rpf_id,
2388  mode, &tmp, dpo);
2389  dpo_reset(&tmp);
2390  break;
2391  }
2392  case FIB_PATH_TYPE_RECEIVE:
2395  case FIB_PATH_TYPE_INTF_RX:
2398  case FIB_PATH_TYPE_SPECIAL:
2402  case FIB_PATH_TYPE_DVR:
2403  break;
2404  }
2405 
2407  {
2408  dpo_id_t tmp = DPO_INVALID;
2409 
2410  dpo_copy(&tmp, dpo);
2411 
2412  pw_cw_dpo_create(&tmp, dpo);
2413  dpo_reset(&tmp);
2414  }
2415 }
2416 
2417 void
2420  dpo_id_t *dpo)
2421 {
2422  fib_path_t *path;
2423 
2424  path = fib_path_get(path_index);
2425 
2426  ASSERT(path);
2428 
2429  /*
2430  * The DPO stored in the path was created when the path was resolved.
2431  * This then represents the path's 'native' protocol; IP.
2432  * For all others will need to go find something else.
2433  */
2434  if (fib_path_to_chain_type(path) == fct)
2435  {
2436  dpo_copy(dpo, &path->fp_dpo);
2437  }
2438  else
2439  {
2440  switch (path->fp_type)
2441  {
2443  switch (fct)
2444  {
2454  path,
2456  dpo);
2457  break;
2459  break;
2460  }
2461  break;
2463  switch (fct)
2464  {
2472  fib_path_recursive_adj_update(path, fct, dpo);
2473  break;
2476  ASSERT(0);
2477  break;
2478  }
2479  break;
2481  switch (fct)
2482  {
2485  break;
2494  ASSERT(0);
2495  break;
2496  }
2497  break;
2499  switch (fct)
2500  {
2502  fib_path_bier_fmask_update(path, dpo);
2503  break;
2512  ASSERT(0);
2513  break;
2514  }
2515  break;
2517  bier_imp_contribute_forwarding(path->bier_imp.fp_bier_imp,
2519  dpo);
2520  break;
2521  case FIB_PATH_TYPE_DEAG:
2522  switch (fct)
2523  {
2530  dpo);
2531  break;
2537  dpo_copy(dpo, &path->fp_dpo);
2538  break;
2540  break;
2543  ASSERT(0);
2544  break;
2545  }
2546  break;
2548  dpo_copy(dpo, &path->exclusive.fp_ex_dpo);
2549  break;
2551  switch (fct)
2552  {
2562  dpo);
2563  break;
2566  {
2567  adj_index_t ai;
2568 
2569  /*
2570  * Create the adj needed for sending IP multicast traffic
2571  */
2573  path->attached.fp_interface))
2574  {
2575  /*
2576  * point-2-point interfaces do not require a glean, since
2577  * there is nothing to ARP. Install a rewrite/nbr adj instead
2578  */
2581  &zero_addr,
2582  path->attached.fp_interface);
2583  }
2584  else
2585  {
2588  path->attached.fp_interface);
2589  }
2590  dpo_set(dpo, DPO_ADJACENCY,
2592  ai);
2593  adj_unlock(ai);
2594  }
2595  break;
2596  }
2597  break;
2598  case FIB_PATH_TYPE_INTF_RX:
2599  /*
2600  * Create the adj needed for sending IP multicast traffic
2601  */
2603  path->attached.fp_interface,
2604  dpo);
2605  break;
2607  udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
2608  path->fp_nh_proto,
2609  dpo);
2610  break;
2611  case FIB_PATH_TYPE_RECEIVE:
2612  case FIB_PATH_TYPE_SPECIAL:
2613  case FIB_PATH_TYPE_DVR:
2614  dpo_copy(dpo, &path->fp_dpo);
2615  break;
2616  }
2617  }
2618 }
2619 
2623  load_balance_path_t *hash_key)
2624 {
2625  load_balance_path_t *mnh;
2626  fib_path_t *path;
2627 
2628  path = fib_path_get(path_index);
2629 
2630  ASSERT(path);
2631 
2632  vec_add2(hash_key, mnh, 1);
2633 
2634  mnh->path_weight = path->fp_weight;
2635  mnh->path_index = path_index;
2636 
2637  if (fib_path_is_resolved(path_index))
2638  {
2639  fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo);
2640  }
2641  else
2642  {
2643  dpo_copy(&mnh->path_dpo,
2645  }
2646  return (hash_key);
2647 }
2648 
2649 int
2651 {
2652  fib_path_t *path;
2653 
2654  path = fib_path_get(path_index);
2655 
2656  return ((FIB_PATH_TYPE_RECURSIVE == path->fp_type) &&
2659 }
2660 
2661 int
2663 {
2664  fib_path_t *path;
2665 
2666  path = fib_path_get(path_index);
2667 
2668  return (FIB_PATH_TYPE_EXCLUSIVE == path->fp_type);
2669 }
2670 
2671 int
2673 {
2674  fib_path_t *path;
2675 
2676  path = fib_path_get(path_index);
2677 
2678  return (FIB_PATH_TYPE_DEAG == path->fp_type);
2679 }
2680 
2681 int
2683 {
2684  fib_path_t *path;
2685 
2686  path = fib_path_get(path_index);
2687 
2688  return (dpo_id_is_valid(&path->fp_dpo) &&
2690  !fib_path_is_looped(path_index) &&
2692 }
2693 
2694 int
2696 {
2697  fib_path_t *path;
2698 
2699  path = fib_path_get(path_index);
2700 
2702 }
2703 
2706  fib_node_index_t path_index,
2707  const fib_path_ext_t *path_ext,
2708  void *args)
2709 {
2710  fib_path_encode_ctx_t *ctx = args;
2711  fib_route_path_t *rpath;
2712  fib_path_t *path;
2713 
2714  path = fib_path_get(path_index);
2715  if (!path)
2716  return (FIB_PATH_LIST_WALK_CONTINUE);
2717 
2718  vec_add2(ctx->rpaths, rpath, 1);
2719  rpath->frp_weight = path->fp_weight;
2720  rpath->frp_preference = path->fp_preference;
2721  rpath->frp_proto = path->fp_nh_proto;
2722  rpath->frp_sw_if_index = ~0;
2723  rpath->frp_fib_index = 0;
2724 
2725  switch (path->fp_type)
2726  {
2727  case FIB_PATH_TYPE_RECEIVE:
2728  rpath->frp_addr = path->receive.fp_addr;
2729  rpath->frp_sw_if_index = path->receive.fp_interface;
2730  rpath->frp_flags |= FIB_ROUTE_PATH_LOCAL;
2731  break;
2733  rpath->frp_sw_if_index = path->attached.fp_interface;
2734  break;
2736  rpath->frp_sw_if_index = path->attached_next_hop.fp_interface;
2737  rpath->frp_addr = path->attached_next_hop.fp_nh;
2738  break;
2740  rpath->frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
2741  break;
2742  case FIB_PATH_TYPE_SPECIAL:
2743  break;
2744  case FIB_PATH_TYPE_DEAG:
2745  rpath->frp_fib_index = path->deag.fp_tbl_id;
2747  {
2748  rpath->frp_flags |= FIB_ROUTE_PATH_RPF_ID;
2749  }
2750  break;
2752  rpath->frp_addr = path->recursive.fp_nh.fp_ip;
2753  rpath->frp_fib_index = path->recursive.fp_tbl_id;
2754  break;
2755  case FIB_PATH_TYPE_DVR:
2756  rpath->frp_sw_if_index = path->dvr.fp_interface;
2757  rpath->frp_flags |= FIB_ROUTE_PATH_DVR;
2758  break;
2760  rpath->frp_udp_encap_id = path->udp_encap.fp_udp_encap_id;
2762  break;
2763  case FIB_PATH_TYPE_INTF_RX:
2764  rpath->frp_sw_if_index = path->receive.fp_interface;
2766  break;
2769  default:
2770  break;
2771  }
2772 
2773  if (path_ext && path_ext->fpe_type == FIB_PATH_EXT_MPLS)
2774  {
2775  rpath->frp_label_stack = path_ext->fpe_path.frp_label_stack;
2776  }
2777 
2779  rpath->frp_flags |= FIB_ROUTE_PATH_DROP;
2784 
2785  return (FIB_PATH_LIST_WALK_CONTINUE);
2786 }
2787 
2790 {
2791  fib_path_t *path;
2792 
2793  path = fib_path_get(path_index);
2794 
2795  return (path->fp_nh_proto);
2796 }
2797 
2798 void
2800 {
2801  fib_node_register_type (FIB_NODE_TYPE_PATH, &fib_path_vft);
2802  fib_path_logger = vlib_log_register_class ("fib", "path");
2803 }
2804 
2805 static clib_error_t *
2807  unformat_input_t * input,
2808  vlib_cli_command_t * cmd)
2809 {
2810  fib_node_index_t pi;
2811  fib_path_t *path;
2812 
2813  if (unformat (input, "%d", &pi))
2814  {
2815  /*
2816  * show one in detail
2817  */
2818  if (!pool_is_free_index(fib_path_pool, pi))
2819  {
2820  path = fib_path_get(pi);
2821  u8 *s = format(NULL, "%U", format_fib_path, pi, 1,
2823  s = format(s, "\n children:");
2825  vlib_cli_output (vm, "%s", s);
2826  vec_free(s);
2827  }
2828  else
2829  {
2830  vlib_cli_output (vm, "path %d invalid", pi);
2831  }
2832  }
2833  else
2834  {
2835  vlib_cli_output (vm, "FIB Paths");
2836  pool_foreach_index (pi, fib_path_pool,
2837  ({
2838  vlib_cli_output (vm, "%U", format_fib_path, pi, 0,
2840  }));
2841  }
2842 
2843  return (NULL);
2844 }
2845 
2846 VLIB_CLI_COMMAND (show_fib_path, static) = {
2847  .path = "show fib paths",
2848  .function = show_fib_path_command,
2849  .short_help = "show fib paths",
2850 };
vlib_log_class_t vlib_log_register_class(char *class, char *subclass)
Definition: log.c:176
int fib_path_is_resolved(fib_node_index_t path_index)
Definition: fib_path.c:2682
static uword vnet_sw_interface_is_up(vnet_main_t *vnm, u32 sw_if_index)
Contribute an object that is to be used to forward BIER packets.
Definition: fib_types.h:122
int fib_path_resolve(fib_node_index_t path_index)
Definition: fib_path.c:1910
void ip_null_dpo_add_and_lock(dpo_proto_t proto, ip_null_dpo_action_t action, dpo_id_t *dpo)
Definition: ip_null_dpo.c:78
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:137
ip46_address_t frp_addr
The next-hop address.
Definition: fib_types.h:501
fib_path_ext_type_t fpe_type
The type of path extension.
Definition: fib_path_ext.h:126
A path that resolves via a DVR DPO.
Definition: fib_types.h:387
void mpls_disp_dpo_create(dpo_proto_t payload_proto, fib_rpf_id_t rpf_id, fib_mpls_lsp_mode_t mode, const dpo_id_t *parent, dpo_id_t *dpo)
Create an MPLS label object.
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:113
void receive_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, const ip46_address_t *nh_addr, dpo_id_t *dpo)
Definition: receive_dpo.c:62
void pw_cw_dpo_create(const dpo_id_t *parent, dpo_id_t *dpo)
Create an PW CW pop.
Definition: pw_cw.c:43
static fib_path_t * fib_path_from_fib_node(fib_node_t *node)
Definition: fib_path.c:457
void bier_imp_contribute_forwarding(index_t bii, dpo_proto_t proto, dpo_id_t *dpo)
Definition: bier_imp.c:174
uword fib_path_hash(fib_node_index_t path_index)
Definition: fib_path.c:1539
fib_node_index_t path_index
The index of the FIB path.
Definition: load_balance.h:71
void fib_path_contribute_forwarding(fib_node_index_t path_index, fib_forward_chain_type_t fct, dpo_id_t *dpo)
Definition: fib_path.c:2418
enum fib_path_format_flags_t_ fib_format_path_flags_t
index_t fp_bier_fmask
BIER FMask ID.
Definition: fib_path.c:300
void lookup_dpo_add_or_lock_w_table_id(u32 table_id, dpo_proto_t proto, lookup_cast_t cast, lookup_input_t input, lookup_table_t table_config, dpo_id_t *dpo)
Definition: lookup_dpo.c:159
mpls_eos_bit_t frp_eos
EOS bit for the resolving label.
Definition: fib_types.h:512
fib_path_oper_attribute_t_
Enurmeration of path operational (i.e.
Definition: fib_path.c:144
u32 fp_classify_table_id
The UDP Encap object this path resolves through.
Definition: fib_path.c:360
int fib_entry_is_resolved(fib_node_index_t fib_entry_index)
Return !0 is the entry is resolved, i.e.
Definition: fib_entry.c:1493
index_t fib_path_get_resolving_index(fib_node_index_t path_index)
Definition: fib_path.c:2197
void fib_path_contribute_urpf(fib_node_index_t path_index, index_t urpf)
Contribute the path&#39;s adjacency to the list passed.
Definition: fib_path.c:2290
A representation of a path as described by a route producer.
Definition: fib_types.h:485
u8 * format_dpo_type(u8 *s, va_list *args)
format a DPO type
Definition: dpo.c:138
dpo_id_t path_dpo
ID of the Data-path object.
Definition: load_balance.h:66
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
Definition: dpo.c:278
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
u8 * format_bier_table_id(u8 *s, va_list *ap)
Format a BIER table ID.
Definition: bier_types.c:193
#define FIB_PATH_OPER_ATTRIBUTES
Definition: fib_path.c:176
#define STRUCT_MARK_PTR(v, f)
Definition: clib.h:71
int fib_path_cmp(fib_node_index_t pi1, fib_node_index_t pi2)
Definition: fib_path.c:1679
A Drop path - resolve the path on the drop DPO.
Definition: fib_types.h:346
void bier_fmask_contribute_forwarding(index_t bfmi, dpo_id_t *dpo)
Definition: bier_fmask.c:120
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:185
index_t fp_bier_imp
The BIER imposition object this is part of the path&#39;s key, since the index_t of an imposition object ...
Definition: fib_path.c:314
u32 fib_entry_child_add(fib_node_index_t fib_entry_index, fib_node_type_t child_type, fib_node_index_t child_index)
Definition: fib_entry.c:555
static int dpo_id_is_valid(const dpo_id_t *dpoi)
Return true if the DPO object is valid, i.e.
Definition: dpo.h:209
struct fib_path_t_::@216::@229 receive
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
A path that resolves via a BIER impostion object.
Definition: fib_types.h:379
An MPLS extension that maintains the path&#39;s outgoing labels,.
Definition: fib_path_ext.h:31
void fib_path_module_init(void)
Definition: fib_path.c:2799
int fib_path_is_exclusive(fib_node_index_t path_index)
Definition: fib_path.c:2662
void bier_imp_lock(index_t bii)
Definition: bier_imp.c:48
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
void fib_entry_contribute_forwarding(fib_node_index_t fib_entry_index, fib_forward_chain_type_t fct, dpo_id_t *dpo)
Definition: fib_entry.c:437
static void fib_path_bier_fmask_update(fib_path_t *path, dpo_id_t *dpo)
Definition: fib_path.c:864
index_t frp_bier_imp
A path via a BIER imposition object.
Definition: fib_types.h:518
void bier_table_ecmp_unlock(index_t bti)
Definition: bier_table.c:462
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:26
dpo_proto_t fib_forw_chain_type_to_dpo_proto(fib_forward_chain_type_t fct)
Convert from a chain type to the DPO proto it will install.
Definition: fib_types.c:433
void load_balance_map_path_state_change(fib_node_index_t path_index)
the state of a path has changed (it has no doubt gone down).
void fib_entry_child_remove(fib_node_index_t fib_entry_index, u32 sibling_index)
Definition: fib_entry.c:566
fib_node_index_t fp_tbl_id
The FIB table index in which to find the next-hop.
Definition: fib_path.c:289
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:262
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
enum fib_path_type_t_ fib_path_type_t
Enurmeration of path types.
u32 dpo_get_urpf(const dpo_id_t *dpo)
Get a uRPF interface for the DPO.
Definition: dpo.c:382
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:561
A path that resolves via a BIER [ECMP] Table.
Definition: fib_types.h:375
The path is resolved.
Definition: fib_path.c:156
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:109
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:65
void fib_node_deinit(fib_node_t *node)
Definition: fib_node.c:197
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
const fib_prefix_t * fib_entry_get_prefix(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1691
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
dpo_proto_t frp_proto
The protocol of the address below.
Definition: fib_types.h:490
vl_api_fib_path_t path
Definition: mfib_types.api:34
bier_table_id_t frp_bier_tbl
A path that resolves via a BIER Table.
Definition: fib_types.h:560
A path that result in received traffic being recieved/recirculated so that it appears to have arrived...
Definition: fib_types.h:355
dpo_id_t fp_ex_dpo
The user provided &#39;exclusive&#39; DPO.
Definition: fib_path.c:332
int fib_path_is_looped(fib_node_index_t path_index)
Definition: fib_path.c:2695
Definition: fib_entry.h:114
The ID of a table.
Definition: bier_types.h:394
void adj_child_remove(adj_index_t adj_index, u32 sibling_index)
Remove a child dependent.
Definition: adj.c:360
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:237
The path has become a permanent drop.
Definition: fib_path.c:164
int fib_path_cmp_for_sort(void *v1, void *v2)
Definition: fib_path.c:1652
unsigned char u8
Definition: types.h:56
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
ip46_address_t fp_ip
The next-hop.
Definition: fib_path.c:273
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
load_balance_path_t * fib_path_append_nh_for_multipath_hash(fib_node_index_t path_index, fib_forward_chain_type_t fct, load_balance_path_t *hash_key)
Definition: fib_path.c:2621
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
#define clib_memcpy(d, s, n)
Definition: string.h:180
int vnet_sw_interface_is_nbma(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1249
const dpo_id_t * drop_dpo_get(dpo_proto_t proto)
Definition: drop_dpo.c:25
fib_rpf_id_t frp_rpf_id
The RPF-ID.
Definition: fib_types.h:530
A local path with a RPF-ID => multicast traffic.
Definition: fib_types.h:359
#define FIB_PATH_TYPES
Definition: fib_path.c:120
u32 vlib_log_class_t
Definition: vlib.h:51
fib_path_type_t fp_type
The type of the path.
Definition: fib_path.c:226
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:525
dpo_proto_t vnet_link_to_dpo_proto(vnet_link_t linkt)
Definition: dpo.c:96
mpls_eos_bit_t fp_eos
The EOS bit of the resolving label.
Definition: fib_path.c:282
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a &#39;special&#39; entry from the FIB.
Definition: fib_table.c:424
struct fib_path_t_::@216::@222 recursive
static int ip46_address_cmp(const ip46_address_t *ip46_1, const ip46_address_t *ip46_2)
Definition: ip46_address.h:80
void bier_table_contribute_forwarding(index_t bti, dpo_id_t *dpo)
Definition: bier_table.c:728
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
Recursion constraint of via a host prefix.
Definition: fib_types.h:330
Recursive resolution source.
Definition: fib_source.h:119
fib_node_index_t fib_path_copy(fib_node_index_t path_index, fib_node_index_t path_list_index)
Definition: fib_path.c:1485
u8 * format_bier_imp(u8 *s, va_list *args)
Definition: bier_imp.c:137
void bier_fmask_child_remove(fib_node_index_t bfmi, u32 sibling_index)
Definition: bier_fmask.c:152
Aggregate type for a prefix.
Definition: fib_types.h:203
fib_path_cfg_flags_t fp_cfg_flags
Configuration Flags.
Definition: fib_path.c:221
void fib_entry_contribute_urpf(fib_node_index_t entry_index, index_t urpf)
Contribute the set of Adjacencies that this entry forwards with to build the uRPF list of its childre...
Definition: fib_entry.c:391
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
fib_node_t fp_node
A path is a node in the FIB graph.
Definition: fib_path.c:205
interface receive.
Definition: fib_path.c:84
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:324
A path via a UDP encap object.
Definition: fib_types.h:367
dpo_id_t fp_dpo
The Data-path objects through which this path resolves for IP.
Definition: fib_path.c:401
unsigned int u32
Definition: types.h:88
#define FIB_PATH_CFG_ATTRIBUTES
Definition: fib_path.h:113
Contribute an object that is to be used to forward Ethernet packets.
Definition: fib_types.h:141
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
fib_protocol_t dpo_proto_to_fib(dpo_proto_t dpo_proto)
Definition: fib_types.c:276
struct fib_path_t_::@216::@221 attached
int load_balance_is_drop(const dpo_id_t *dpo)
Definition: load_balance.c:272
u16 fib_path_get_weight(fib_node_index_t path_index)
Definition: fib_path.c:2243
enum lookup_cast_t_ lookup_cast_t
Switch to use the packet&#39;s source or destination address for lookup.
void fib_urpf_list_append(index_t ui, u32 sw_if_index)
Append another interface to the list.
struct fib_path_t_::@216::@220 attached_next_hop
vl_api_gre_tunnel_mode_t mode
Definition: gre.api:55
static void fib_path_attached_next_hop_set(fib_path_t *path)
Definition: fib_path.c:686
fib_node_index_t fib_path_create_special(fib_node_index_t pl_index, dpo_proto_t nh_proto, fib_path_cfg_flags_t flags, const dpo_id_t *dpo)
Definition: fib_path.c:1439
Definition: fib_entry.h:112
fib_rpf_id_t fp_rpf_id
The RPF-ID to tag the packets with.
Definition: fib_path.c:324
void bier_disp_table_contribute_forwarding(index_t bdti, dpo_id_t *dpo)
index_t frp_bier_fmask
Resolving via a BIER Fmask.
Definition: fib_types.h:575
u8 * format_fib_path(u8 *s, va_list *args)
Definition: fib_path.c:464
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
u32 fp_sibling
the index of this path in the parent&#39;s child list.
Definition: fib_path.c:406
Contribute an object that is to be used to forward end-of-stack MPLS packets.
Definition: fib_types.h:129
fib_node_bw_reason_flag_t fnbw_reason
The reason/trigger for the backwalk.
Definition: fib_node.h:212
format_function_t format_mpls_eos_bit
Definition: mpls.h:69
format_function_t format_vnet_sw_interface_name
#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
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
int adj_is_up(adj_index_t ai)
Return true if the adjacency is &#39;UP&#39;, i.e.
Definition: adj.c:502
u8 * format_fib_node_bw_reason(u8 *s, va_list *args)
Definition: fib_walk.c:973
dpo_proto_t fp_nh_proto
The protocol of the next-hop, i.e.
Definition: fib_path.c:233
struct fib_path_t_ fib_path_t
A FIB path.
index_t classify_dpo_create(dpo_proto_t proto, u32 classify_table_index)
Definition: classify_dpo.c:43
dpo_type_t dpoi_type
the type
Definition: dpo.h:174
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1234
static u8 ip46_address_is_zero(const ip46_address_t *ip46)
Definition: ip46_address.h:87
long ctx[MAX_CONNS]
Definition: main.c:144
struct fib_path_t_::@216::@226 deag
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
STRUCT_MARK(path_hash_start)
This marks the start of the memory area used to hash the path.
adj_index_t fib_path_get_adj(fib_node_index_t path_index)
Definition: fib_path.c:2229
enum fib_mpls_lsp_mode_t_ fib_mpls_lsp_mode_t
MPLS LSP mode - only valid at the head and tail.
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:287
index_t fp_via_bier_tbl
the resolving bier-table
Definition: fib_path.c:391
fib_mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:546
Recursion constraint of via an attahced prefix.
Definition: fib_types.h:334
void lookup_dpo_add_or_lock_w_fib_index(fib_node_index_t fib_index, dpo_proto_t proto, lookup_cast_t cast, lookup_input_t input, lookup_table_t table_config, dpo_id_t *dpo)
Definition: lookup_dpo.c:133
void fib_path_stack_mpls_disp(fib_node_index_t path_index, dpo_proto_t payload_proto, fib_mpls_lsp_mode_t mode, dpo_id_t *dpo)
Definition: fib_path.c:2357
fib_node_type_t fn_type
The node&#39;s type.
Definition: fib_node.h:299
enum fib_path_cfg_attribute_t_ fib_path_cfg_attribute_t
Given a route of the form; q.r.s.t/Y via <interface> <next-hop>
An node in the FIB graph.
Definition: fib_node.h:295
dpo_id_t dpo
Exclusive DPO.
Definition: fib_types.h:550
void fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
Definition: fib_table.c:1291
static fib_path_t * fib_path_pool
Definition: fib_path.c:419
vlib_main_t * vm
Definition: in2out_ed.c:1810
Pop a Psuedo Wire Control Word.
Definition: fib_types.h:396
static fib_path_t * fib_path_get(fib_node_index_t index)
Definition: fib_path.c:439
ip46_address_t fp_nh
The next-hop.
Definition: fib_path.c:255
void dvr_dpo_add_or_lock(u32 sw_if_index, dpo_proto_t dproto, dpo_id_t *dpo)
Definition: dvr_dpo.c:91
format_function_t format_ip46_address
Definition: ip46_address.h:50
u32 fib_entry_get_resolving_interface(fib_node_index_t entry_index)
Definition: fib_entry.c:1458
fib_path_oper_flags_t_
Path flags from the attributes.
Definition: fib_path.c:190
fib_node_index_t fib_table_entry_special_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags)
Add a &#39;special&#39; entry to the FIB.
Definition: fib_table.c:405
#define FOR_EACH_FIB_PATH_OPER_ATTRIBUTE(_item)
Definition: fib_path.c:182
#define MPLS_FIB_DEFAULT_TABLE_ID
Definition: mpls_fib.h:28
The path forms part of a recursive loop.
Definition: fib_path.c:152
vnet_link_t fib_forw_chain_type_to_link_type(fib_forward_chain_type_t fct)
Convert from a chain type to the adjacency&#39;s link type.
Definition: fib_types.c:382
fib_node_list_t fn_children
Vector of nodes that depend upon/use/share this node.
Definition: fib_node.h:309
u32 frp_classify_table_id
Classify table ID.
Definition: fib_types.h:570
u32 flags
Definition: vhost_user.h:141
struct fib_path_t_::@216::@228 exclusive
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:200
int bier_table_id_cmp(const bier_table_id_t *btid1, const bier_table_id_t *btid2)
Compare to BIER table IDs for equality.
Definition: bier_types.c:112
via a DVR.
Definition: fib_path.c:108
void udp_encap_lock(index_t uei)
Definition: udp_encap.c:149
Contribute an object that is to be used to forward NSH packets.
Definition: fib_types.h:147
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
u32 fp_udp_encap_id
The UDP Encap object this path resolves through.
Definition: fib_path.c:354
static void fib_path_last_lock_gone(fib_node_t *node)
Definition: fib_path.c:643
static fib_node_index_t fib_path_get_index(fib_path_t *path)
Definition: fib_path.c:445
A FIB path.
Definition: fib_path.c:201
int fib_entry_recursive_loop_detect(fib_node_index_t entry_index, fib_node_index_t **entry_indicies)
Definition: fib_entry.c:1407
fib_node_get_t fnv_get
Definition: fib_node.h:283
enum fib_path_oper_flags_t_ fib_path_oper_flags_t
Path flags from the attributes.
index_t fp_via_bier_fmask
the resolving bier-fmask
Definition: fib_path.c:395
u32 fib_path_get_rpf_id(fib_node_index_t path_index)
Definition: fib_path.c:2267
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
struct fib_path_t_::@216::@232 classify
void interface_rx_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, dpo_id_t *dpo)
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:284
Don&#39;t resolve the path, use the DPO the client provides.
Definition: fib_types.h:350
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
void fib_prefix_from_ip46_addr(const ip46_address_t *addr, fib_prefix_t *pfx)
Host prefix from ip.
Definition: fib_types.c:81
static void fib_path_memory_show(void)
Definition: fib_path.c:1232
The path is attached, despite what the next-hop may say.
Definition: fib_path.c:160
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
Definition: dpo.c:186
void fib_prefix_from_mpls_label(mpls_label_t label, mpls_eos_bit_t eos, fib_prefix_t *prf)
Definition: fib_types.c:95
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1810
static fib_node_back_walk_rc_t fib_path_back_walk_notify(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Definition: fib_path.c:997
Path resolves via a UDP encap object.
Definition: fib_path.c:88
enum lookup_input_t_ lookup_input_t
Switch to use the packet&#39;s source or destination address for lookup.
void fib_table_lock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Release a reference counting lock on the table.
Definition: fib_table.c:1310
Context passed between object during a back walk.
Definition: fib_node.h:208
u32 fib_rpf_id_t
An RPF-ID is numerical value that is used RPF validate.
Definition: fib_types.h:406
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:152
struct fib_path_t_::@216::@233 dvr
u32 fp_pl_index
The index of the path-list to which this path belongs.
Definition: fib_path.c:210
static void fib_path_recursive_adj_update(fib_path_t *path, fib_forward_chain_type_t fct, dpo_id_t *dpo)
Definition: fib_path.c:759
#define ASSERT(truth)
int fib_path_is_deag(fib_node_index_t path_index)
Definition: fib_path.c:2672
vnet_link_t dpo_proto_to_link(dpo_proto_t dp)
format a DPO protocol
Definition: dpo.c:118
fib_node_index_t fp_via_fib
the resolving via fib.
Definition: fib_path.c:387
static int fib_path_is_permanent_drop(fib_path_t *path)
Definition: fib_path.c:889
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
index_t bier_table_ecmp_create_and_lock(const bier_table_id_t *btid)
Definition: bier_table.c:456
ip46_address_t fp_addr
The next-hop.
Definition: fib_path.c:342
static fib_forward_chain_type_t fib_path_to_chain_type(const fib_path_t *path)
Definition: fib_path.c:971
u8 frp_preference
A path preference.
Definition: fib_types.h:591
bier_table_id_t fp_bier_tbl
The BIER table&#39;s ID.
Definition: fib_path.c:306
uword hash_memory(void *p, word n_bytes, uword state)
Definition: hash.c:275
Path encode context to use when walking a path-list to encode paths.
Definition: fib_path.h:213
A deag path using the packet&#39;s source not destination address.
Definition: fib_types.h:363
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
fib_route_path_flags_t frp_flags
flags on the path
Definition: fib_types.h:595
static void fib_path_attached_get_adj(fib_path_t *path, vnet_link_t link, dpo_id_t *dpo)
Definition: fib_path.c:715
u32 fp_interface
The interface.
Definition: fib_path.c:259
static clib_error_t * show_fib_path_command(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: fib_path.c:2806
vlib_log_class_t fib_path_logger
the logger
Definition: fib_path.c:424
int dpo_cmp(const dpo_id_t *dpo1, const dpo_id_t *dpo2)
Compare two Data-path objects.
Definition: dpo.c:249
struct fib_path_t_::@216::@224 bier_table
A path that resolves via a BIER F-Mask.
Definition: fib_types.h:371
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:148
A path that resolves via another table.
Definition: fib_types.h:383
u32 entries
struct fib_path_t_::@216::@223 bier_fmask
format_function_t format_mpls_unicast_label
Definition: mpls.h:71
static void fib_path_unresolve(fib_path_t *path)
Definition: fib_path.c:901
fib_route_path_t * rpaths
Definition: fib_path.h:215
mpls_label_t frp_local_label
The MPLS local Label to reursively resolve through.
Definition: fib_types.h:508
dpo_proto_t fib_path_get_proto(fib_node_index_t path_index)
Definition: fib_path.c:2789
fib_path_oper_flags_t fp_oper_flags
Memebers in this last section represent information that is dervied during resolution.
Definition: fib_path.c:380
int fib_path_is_recursive_constrained(fib_node_index_t path_index)
Definition: fib_path.c:2650
void fib_path_list_back_walk(fib_node_index_t path_list_index, fib_node_back_walk_ctx_t *ctx)
Attached-nexthop.
Definition: fib_path.c:60
enum fib_path_list_walk_rc_t_ fib_path_list_walk_rc_t
return code to control pat-hlist walk
u32 fib_path_get_resolving_interface(fib_node_index_t path_index)
Definition: fib_path.c:2161
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
A for-us/local path.
Definition: fib_types.h:338
u32 path_weight
weight for the path.
Definition: load_balance.h:76
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:343
u16 fib_path_get_preference(fib_node_index_t path_index)
Definition: fib_path.c:2255
u64 uword
Definition: types.h:112
struct fib_path_t_::@216::@231 udp_encap
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:197
#define FIB_PATH_DBG(_p, _fmt, _args...)
Definition: fib_path.c:429
adj_index_t adj_glean_add_or_lock(fib_protocol_t proto, vnet_link_t linkt, u32 sw_if_index, const ip46_address_t *nh_addr)
Glean Adjacency.
Definition: adj_glean.c:50
fib_node_index_t fib_path_create(fib_node_index_t pl_index, const fib_route_path_t *rpath)
Definition: fib_path.c:1290
u8 fp_weight
UCMP [unnormalised] weigth.
Definition: fib_path.c:238
One path from an [EU]CMP set that the client wants to add to a load-balance object.
Definition: load_balance.h:62
enum fib_path_cfg_flags_t_ fib_path_cfg_flags_t
Path config flags from the attributes.
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:178
int fib_path_recursive_loop_detect(fib_node_index_t path_index, fib_node_index_t **entry_indicies)
Definition: fib_path.c:1813
A FIB graph nodes virtual function table.
Definition: fib_node.h:282
struct fib_path_t_::@216::@230 intf_rx
static fib_path_cfg_flags_t fib_path_route_flags_to_cfg_flags(const fib_route_path_t *rpath)
Definition: fib_path.c:1251
int dpo_is_drop(const dpo_id_t *dpo)
The Drop DPO will drop all packets, no questions asked.
Definition: drop_dpo.c:33
adj_index_t adj_mcast_add_or_lock(fib_protocol_t proto, vnet_link_t link_type, u32 sw_if_index)
Mcast Adjacency.
Definition: adj_mcast.c:51
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:218
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:232
mpls_label_t fp_local_label
The local label to resolve through.
Definition: fib_path.c:278
#define vec_foreach(var, vec)
Vector iterator.
A path extension is a per-entry addition to the forwarding information when packets are sent for that...
Definition: fib_path_ext.h:98
fib_path_type_t_
Enurmeration of path types.
Definition: fib_path.c:52
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:118
Attached path.
Definition: fib_types.h:342
void udp_encap_unlock(index_t uei)
Definition: udp_encap.c:162
struct fib_path_t_::@216::@225 bier_imp
#define pool_foreach_index(i, v, body)
Iterate pool by index.
Definition: pool.h:543
u8 * fib_node_children_format(fib_node_list_t list, u8 *s)
Definition: fib_node.c:176
u8 fp_preference
A path preference.
Definition: fib_path.c:245
u8 frp_weight
[un]equal cost path weight
Definition: fib_types.h:585
static fib_path_t * fib_path_attached_next_hop_get_adj(fib_path_t *path, vnet_link_t link, dpo_id_t *dpo)
Definition: fib_path.c:649
fib_source_t fib_entry_get_best_source(fib_node_index_t entry_index)
Definition: fib_entry.c:1468
u32 frp_udp_encap_id
UDP encap ID.
Definition: fib_types.h:565
enum fib_path_oper_attribute_t_ fib_path_oper_attribute_t
Enurmeration of path operational (i.e.
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:133
struct fib_path_t_::@216::@227 special
u32 bier_fmask_child_add(fib_node_index_t bfmi, fib_node_type_t child_type, fib_node_index_t child_index)
Definition: bier_fmask.c:141
void bier_imp_unlock(index_t bii)
Definition: bier_imp.c:110
u32 frp_fib_index
The FIB index to lookup the nexthop Only valid for recursive paths.
Definition: fib_types.h:537
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
fib_forward_chain_type_t fib_forw_chain_type_from_dpo_proto(dpo_proto_t proto)
Convert from a payload-protocol to a chain type.
Definition: fib_types.c:344
void fib_path_destroy(fib_node_index_t path_index)
Definition: fib_path.c:1518
#define FOR_EACH_FIB_PATH_CFG_ATTRIBUTE(_item)
Definition: fib_path.h:129
static int fib_path_cmp_i(const fib_path_t *path1, const fib_path_t *path2)
Definition: fib_path.c:1557
const ip46_address_t zero_addr
Definition: lookup.c:307
int fib_path_cmp_w_route_path(fib_node_index_t path_index, const fib_route_path_t *rpath)
Definition: fib_path.c:1691
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
fib_route_path_t fpe_path
A description of the path that is being extended.
Definition: fib_path_ext.h:105
fib_path_list_walk_rc_t fib_path_encode(fib_node_index_t path_list_index, fib_node_index_t path_index, const fib_path_ext_t *path_ext, void *args)
Definition: fib_path.c:2705
void udp_encap_contribute_forwarding(index_t uei, dpo_proto_t proto, dpo_id_t *dpo)
Definition: udp_encap.c:131
static fib_node_t * fib_path_get_node(fib_node_index_t index)
Definition: fib_path.c:451
enum mpls_eos_bit_t_ mpls_eos_bit_t
index_t fp_bier_fib
The BIER FIB the fmask is in.
Definition: fib_path.c:293
fib_entry_flag_t fib_entry_get_flags(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:291
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128