FD.io VPP  v18.07-rc0-415-g6c78436
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/drop_dpo.h>
28 
29 #include <vnet/adj/adj.h>
30 #include <vnet/adj/adj_mcast.h>
31 
32 #include <vnet/fib/fib_path.h>
33 #include <vnet/fib/fib_node.h>
34 #include <vnet/fib/fib_table.h>
35 #include <vnet/fib/fib_entry.h>
36 #include <vnet/fib/fib_path_list.h>
37 #include <vnet/fib/fib_internal.h>
38 #include <vnet/fib/fib_urpf_list.h>
39 #include <vnet/fib/mpls_fib.h>
40 #include <vnet/udp/udp_encap.h>
41 #include <vnet/bier/bier_fmask.h>
42 #include <vnet/bier/bier_table.h>
43 #include <vnet/bier/bier_imp.h>
45 
46 /**
47  * Enurmeration of path types
48  */
49 typedef enum fib_path_type_t_ {
50  /**
51  * Marker. Add new types after this one.
52  */
54  /**
55  * Attached-nexthop. An interface and a nexthop are known.
56  */
58  /**
59  * attached. Only the interface is known.
60  */
62  /**
63  * recursive. Only the next-hop is known.
64  */
66  /**
67  * special. nothing is known. so we drop.
68  */
70  /**
71  * exclusive. user provided adj.
72  */
74  /**
75  * deag. Link to a lookup adj in the next table
76  */
78  /**
79  * interface receive.
80  */
82  /**
83  * Path resolves via a UDP encap object.
84  */
86  /**
87  * receive. it's for-us.
88  */
90  /**
91  * bier-imp. it's via a BIER imposition.
92  */
94  /**
95  * bier-fmask. it's via a BIER ECMP-table.
96  */
98  /**
99  * bier-fmask. it's via a BIER f-mask.
100  */
102  /**
103  * via a DVR.
104  */
106  /**
107  * Marker. Add new types before this one, then update it.
108  */
110 } __attribute__ ((packed)) fib_path_type_t;
111 
112 /**
113  * The maximum number of path_types
114  */
115 #define FIB_PATH_TYPE_MAX (FIB_PATH_TYPE_LAST + 1)
116 
117 #define FIB_PATH_TYPES { \
118  [FIB_PATH_TYPE_ATTACHED_NEXT_HOP] = "attached-nexthop", \
119  [FIB_PATH_TYPE_ATTACHED] = "attached", \
120  [FIB_PATH_TYPE_RECURSIVE] = "recursive", \
121  [FIB_PATH_TYPE_SPECIAL] = "special", \
122  [FIB_PATH_TYPE_EXCLUSIVE] = "exclusive", \
123  [FIB_PATH_TYPE_DEAG] = "deag", \
124  [FIB_PATH_TYPE_INTF_RX] = "intf-rx", \
125  [FIB_PATH_TYPE_UDP_ENCAP] = "udp-encap", \
126  [FIB_PATH_TYPE_RECEIVE] = "receive", \
127  [FIB_PATH_TYPE_BIER_IMP] = "bier-imp", \
128  [FIB_PATH_TYPE_BIER_TABLE] = "bier-table", \
129  [FIB_PATH_TYPE_BIER_FMASK] = "bier-fmask", \
130  [FIB_PATH_TYPE_DVR] = "dvr", \
131 }
132 
133 #define FOR_EACH_FIB_PATH_TYPE(_item) \
134  for (_item = FIB_PATH_TYPE_FIRST; \
135  _item <= FIB_PATH_TYPE_LAST; \
136  _item++)
137 
138 /**
139  * Enurmeration of path operational (i.e. derived) attributes
140  */
142  /**
143  * Marker. Add new types after this one.
144  */
146  /**
147  * The path forms part of a recursive loop.
148  */
150  /**
151  * The path is resolved
152  */
154  /**
155  * The path is attached, despite what the next-hop may say.
156  */
158  /**
159  * The path has become a permanent drop.
160  */
162  /**
163  * Marker. Add new types before this one, then update it.
164  */
166 } __attribute__ ((packed)) fib_path_oper_attribute_t;
167 
168 /**
169  * The maximum number of path operational attributes
170  */
171 #define FIB_PATH_OPER_ATTRIBUTE_MAX (FIB_PATH_OPER_ATTRIBUTE_LAST + 1)
172 
173 #define FIB_PATH_OPER_ATTRIBUTES { \
174  [FIB_PATH_OPER_ATTRIBUTE_RECURSIVE_LOOP] = "recursive-loop", \
175  [FIB_PATH_OPER_ATTRIBUTE_RESOLVED] = "resolved", \
176  [FIB_PATH_OPER_ATTRIBUTE_DROP] = "drop", \
177 }
178 
179 #define FOR_EACH_FIB_PATH_OPER_ATTRIBUTE(_item) \
180  for (_item = FIB_PATH_OPER_ATTRIBUTE_FIRST; \
181  _item <= FIB_PATH_OPER_ATTRIBUTE_LAST; \
182  _item++)
183 
184 /**
185  * Path flags from the attributes
186  */
193 } __attribute__ ((packed)) fib_path_oper_flags_t;
194 
195 /**
196  * A FIB path
197  */
198 typedef struct fib_path_t_ {
199  /**
200  * A path is a node in the FIB graph.
201  */
203 
204  /**
205  * The index of the path-list to which this path belongs
206  */
208 
209  /**
210  * This marks the start of the memory area used to hash
211  * the path
212  */
213  STRUCT_MARK(path_hash_start);
214 
215  /**
216  * Configuration Flags
217  */
219 
220  /**
221  * The type of the path. This is the selector for the union
222  */
223  fib_path_type_t fp_type;
224 
225  /**
226  * The protocol of the next-hop, i.e. the address family of the
227  * next-hop's address. We can't derive this from the address itself
228  * since the address can be all zeros
229  */
231 
232  /**
233  * UCMP [unnormalised] weigth
234  */
236 
237  /**
238  * A path preference. 0 is the best.
239  * Only paths of the best preference, that are 'up', are considered
240  * for forwarding.
241  */
243 
244  /**
245  * per-type union of the data required to resolve the path
246  */
247  union {
248  struct {
249  /**
250  * The next-hop
251  */
252  ip46_address_t fp_nh;
253  /**
254  * The interface
255  */
257  } attached_next_hop;
258  struct {
259  /**
260  * The interface
261  */
262  u32 fp_interface;
263  } attached;
264  struct {
265  union
266  {
267  /**
268  * The next-hop
269  */
270  ip46_address_t fp_ip;
271  struct {
272  /**
273  * The local label to resolve through.
274  */
276  /**
277  * The EOS bit of the resolving label
278  */
280  };
281  } fp_nh;
282  union {
283  /**
284  * The FIB table index in which to find the next-hop.
285  */
287  /**
288  * The BIER FIB the fmask is in
289  */
291  };
292  } recursive;
293  struct {
294  /**
295  * BIER FMask ID
296  */
298  } bier_fmask;
299  struct {
300  /**
301  * The BIER table's ID
302  */
304  } bier_table;
305  struct {
306  /**
307  * The BIER imposition object
308  * this is part of the path's key, since the index_t
309  * of an imposition object is the object's key.
310  */
312  } bier_imp;
313  struct {
314  /**
315  * The FIB index in which to perfom the next lookup
316  */
317  fib_node_index_t fp_tbl_id;
318  /**
319  * The RPF-ID to tag the packets with
320  */
322  } deag;
323  struct {
324  } special;
325  struct {
326  /**
327  * The user provided 'exclusive' DPO
328  */
330  } exclusive;
331  struct {
332  /**
333  * The interface on which the local address is configured
334  */
335  u32 fp_interface;
336  /**
337  * The next-hop
338  */
339  ip46_address_t fp_addr;
340  } receive;
341  struct {
342  /**
343  * The interface on which the packets will be input.
344  */
345  u32 fp_interface;
346  } intf_rx;
347  struct {
348  /**
349  * The UDP Encap object this path resolves through
350  */
352  } udp_encap;
353  struct {
354  /**
355  * The interface
356  */
357  u32 fp_interface;
358  } dvr;
359  };
360  STRUCT_MARK(path_hash_end);
361 
362  /**
363  * Memebers in this last section represent information that is
364  * dervied during resolution. It should not be copied to new paths
365  * nor compared.
366  */
367 
368  /**
369  * Operational Flags
370  */
371  fib_path_oper_flags_t fp_oper_flags;
372 
373  union {
374  /**
375  * the resolving via fib. not part of the union, since it it not part
376  * of the path's hash.
377  */
379  /**
380  * the resolving bier-table
381  */
383  /**
384  * the resolving bier-fmask
385  */
387  };
388 
389  /**
390  * The Data-path objects through which this path resolves for IP.
391  */
393 
394  /**
395  * the index of this path in the parent's child list.
396  */
398 } fib_path_t;
399 
400 /*
401  * Array of strings/names for the path types and attributes
402  */
403 static const char *fib_path_type_names[] = FIB_PATH_TYPES;
404 static const char *fib_path_oper_attribute_names[] = FIB_PATH_OPER_ATTRIBUTES;
405 static const char *fib_path_cfg_attribute_names[] = FIB_PATH_CFG_ATTRIBUTES;
406 
407 /*
408  * The memory pool from which we allocate all the paths
409  */
411 
412 /*
413  * Debug macro
414  */
415 #ifdef FIB_DEBUG
416 #define FIB_PATH_DBG(_p, _fmt, _args...) \
417 { \
418  u8 *_tmp = NULL; \
419  _tmp = fib_path_format(fib_path_get_index(_p), _tmp); \
420  clib_warning("path:[%d:%U]:" _fmt, \
421  fib_path_get_index(_p), format_fib_path, _p, 0,\
422  ##_args); \
423  vec_free(_tmp); \
424 }
425 #else
426 #define FIB_PATH_DBG(_p, _fmt, _args...)
427 #endif
428 
429 static fib_path_t *
431 {
432  return (pool_elt_at_index(fib_path_pool, index));
433 }
434 
435 static fib_node_index_t
437 {
438  return (path - fib_path_pool);
439 }
440 
441 static fib_node_t *
443 {
444  return ((fib_node_t*)fib_path_get(index));
445 }
446 
447 static fib_path_t*
449 {
451  return ((fib_path_t*)node);
452 }
453 
454 u8 *
455 format_fib_path (u8 * s, va_list * args)
456 {
457  fib_node_index_t path_index = va_arg (*args, fib_node_index_t);
458  u32 indent = va_arg (*args, u32);
459  vnet_main_t * vnm = vnet_get_main();
460  fib_path_oper_attribute_t oattr;
462  fib_path_t *path;
463 
464  path = fib_path_get(path_index);
465 
466  s = format (s, "%Upath:[%d] ", format_white_space, indent,
467  fib_path_get_index(path));
468  s = format (s, "pl-index:%d ", path->fp_pl_index);
469  s = format (s, "%U ", format_dpo_proto, path->fp_nh_proto);
470  s = format (s, "weight=%d ", path->fp_weight);
471  s = format (s, "pref=%d ", path->fp_preference);
472  s = format (s, "%s: ", fib_path_type_names[path->fp_type]);
473  if (FIB_PATH_OPER_FLAG_NONE != path->fp_oper_flags) {
474  s = format(s, " oper-flags:");
476  if ((1<<oattr) & path->fp_oper_flags) {
477  s = format (s, "%s,", fib_path_oper_attribute_names[oattr]);
478  }
479  }
480  }
481  if (FIB_PATH_CFG_FLAG_NONE != path->fp_cfg_flags) {
482  s = format(s, " cfg-flags:");
484  if ((1<<cattr) & path->fp_cfg_flags) {
485  s = format (s, "%s,", fib_path_cfg_attribute_names[cattr]);
486  }
487  }
488  }
489  s = format(s, "\n%U", format_white_space, indent+2);
490 
491  switch (path->fp_type)
492  {
494  s = format (s, "%U", format_ip46_address,
495  &path->attached_next_hop.fp_nh,
496  IP46_TYPE_ANY);
498  {
499  s = format (s, " if_index:%d", path->attached_next_hop.fp_interface);
500  }
501  else
502  {
503  s = format (s, " %U",
505  vnm,
507  vnm,
508  path->attached_next_hop.fp_interface));
510  path->attached_next_hop.fp_interface))
511  {
512  s = format (s, " (p2p)");
513  }
514  }
515  if (!dpo_id_is_valid(&path->fp_dpo))
516  {
517  s = format(s, "\n%Uunresolved", format_white_space, indent+2);
518  }
519  else
520  {
521  s = format(s, "\n%U%U",
522  format_white_space, indent,
524  &path->fp_dpo, 13);
525  }
526  break;
529  {
530  s = format (s, "if_index:%d", path->attached_next_hop.fp_interface);
531  }
532  else
533  {
534  s = format (s, " %U",
536  vnm,
538  vnm,
539  path->attached.fp_interface));
540  }
541  break;
543  if (DPO_PROTO_MPLS == path->fp_nh_proto)
544  {
545  s = format (s, "via %U %U",
547  path->recursive.fp_nh.fp_local_label,
549  path->recursive.fp_nh.fp_eos);
550  }
551  else
552  {
553  s = format (s, "via %U",
555  &path->recursive.fp_nh.fp_ip,
556  IP46_TYPE_ANY);
557  }
558  s = format (s, " in fib:%d",
559  path->recursive.fp_tbl_id,
560  path->fp_via_fib);
561  s = format (s, " via-fib:%d", path->fp_via_fib);
562  s = format (s, " via-dpo:[%U:%d]",
564  path->fp_dpo.dpoi_index);
565 
566  break;
568  s = format (s, "UDP-encap ID:%d", path->udp_encap.fp_udp_encap_id);
569  break;
571  s = format (s, "via bier-table:[%U}",
573  &path->bier_table.fp_bier_tbl);
574  s = format (s, " via-dpo:[%U:%d]",
576  path->fp_dpo.dpoi_index);
577  break;
579  s = format (s, "via-fmask:%d", path->bier_fmask.fp_bier_fmask);
580  s = format (s, " via-dpo:[%U:%d]",
582  path->fp_dpo.dpoi_index);
583  break;
585  s = format (s, "via %U", format_bier_imp,
586  path->bier_imp.fp_bier_imp, 0, BIER_SHOW_BRIEF);
587  break;
588  case FIB_PATH_TYPE_DVR:
589  s = format (s, " %U",
591  vnm,
593  vnm,
594  path->dvr.fp_interface));
595  break;
599  case FIB_PATH_TYPE_DEAG:
601  if (dpo_id_is_valid(&path->fp_dpo))
602  {
603  s = format(s, "%U", format_dpo_id,
604  &path->fp_dpo, indent+2);
605  }
606  break;
607  }
608  return (s);
609 }
610 
611 u8 *
613 {
614  fib_path_t *path;
615 
616  path = fib_path_get(pi);
617  ASSERT(NULL != path);
618 
619  return (format (s, "%U", format_fib_path, path));
620 }
621 
622 /*
623  * fib_path_last_lock_gone
624  *
625  * We don't share paths, we share path lists, so the [un]lock functions
626  * are no-ops
627  */
628 static void
630 {
631  ASSERT(0);
632 }
633 
634 static const adj_index_t
636  vnet_link_t link)
637 {
639  path->attached_next_hop.fp_interface))
640  {
641  /*
642  * if the interface is p2p then the adj for the specific
643  * neighbour on that link will never exist. on p2p links
644  * the subnet address (the attached route) links to the
645  * auto-adj (see below), we want that adj here too.
646  */
648  link,
649  &zero_addr,
650  path->attached_next_hop.fp_interface));
651  }
652  else
653  {
655  link,
656  &path->attached_next_hop.fp_nh,
657  path->attached_next_hop.fp_interface));
658  }
659 }
660 
661 static void
663 {
664  /*
665  * resolve directly via the adjacnecy discribed by the
666  * interface and next-hop
667  */
668  dpo_set(&path->fp_dpo,
670  path->fp_nh_proto,
672  path,
674 
675  /*
676  * become a child of the adjacency so we receive updates
677  * when its rewrite changes
678  */
681  fib_path_get_index(path));
682 
684  path->attached_next_hop.fp_interface) ||
685  !adj_is_up(path->fp_dpo.dpoi_index))
686  {
688  }
689 }
690 
691 static const adj_index_t
693  vnet_link_t link)
694 {
696  path->attached.fp_interface))
697  {
698  /*
699  * point-2-point interfaces do not require a glean, since
700  * there is nothing to ARP. Install a rewrite/nbr adj instead
701  */
703  link,
704  &zero_addr,
705  path->attached.fp_interface));
706  }
707  else
708  {
710  link,
711  path->attached.fp_interface,
712  NULL));
713  }
714 }
715 
716 /*
717  * create of update the paths recursive adj
718  */
719 static void
722  dpo_id_t *dpo)
723 {
724  dpo_id_t via_dpo = DPO_INVALID;
725 
726  /*
727  * get the DPO to resolve through from the via-entry
728  */
730  fct,
731  &via_dpo);
732 
733 
734  /*
735  * hope for the best - clear if restrictions apply.
736  */
738 
739  /*
740  * Validate any recursion constraints and over-ride the via
741  * adj if not met
742  */
744  {
746  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
747  }
749  {
750  /*
751  * the via FIB must be a host route.
752  * note the via FIB just added will always be a host route
753  * since it is an RR source added host route. So what we need to
754  * check is whether the route has other sources. If it does then
755  * some other source has added it as a host route. If it doesn't
756  * then it was added only here and inherits forwarding from a cover.
757  * the cover is not a host route.
758  * The RR source is the lowest priority source, so we check if it
759  * is the best. if it is there are no other sources.
760  */
762  {
764  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
765 
766  /*
767  * PIC edge trigger. let the load-balance maps know
768  */
770  }
771  }
773  {
774  /*
775  * RR source entries inherit the flags from the cover, so
776  * we can check the via directly
777  */
779  {
781  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
782 
783  /*
784  * PIC edge trigger. let the load-balance maps know
785  */
787  }
788  }
789  /*
790  * check for over-riding factors on the FIB entry itself
791  */
792  if (!fib_entry_is_resolved(path->fp_via_fib))
793  {
795  dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
796 
797  /*
798  * PIC edge trigger. let the load-balance maps know
799  */
801  }
802 
803  /*
804  * If this path is contributing a drop, then it's not resolved
805  */
806  if (dpo_is_drop(&via_dpo) || load_balance_is_drop(&via_dpo))
807  {
809  }
810 
811  /*
812  * update the path's contributed DPO
813  */
814  dpo_copy(dpo, &via_dpo);
815 
816  FIB_PATH_DBG(path, "recursive update:");
817 
818  dpo_reset(&via_dpo);
819 }
820 
821 /*
822  * re-evaulate the forwarding state for a via fmask path
823  */
824 static void
826  dpo_id_t *dpo)
827 {
828  bier_fmask_contribute_forwarding(path->bier_fmask.fp_bier_fmask, dpo);
829 
830  /*
831  * if we are stakcing on the drop, then the path is not resolved
832  */
833  if (dpo_is_drop(dpo))
834  {
836  }
837  else
838  {
840  }
841 }
842 
843 /*
844  * fib_path_is_permanent_drop
845  *
846  * Return !0 if the path is configured to permanently drop,
847  * despite other attributes.
848  */
849 static int
851 {
852  return ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DROP) ||
854 }
855 
856 /*
857  * fib_path_unresolve
858  *
859  * Remove our dependency on the resolution target
860  */
861 static void
863 {
864  /*
865  * the forced drop path does not need unresolving
866  */
867  if (fib_path_is_permanent_drop(path))
868  {
869  return;
870  }
871 
872  switch (path->fp_type)
873  {
875  if (FIB_NODE_INDEX_INVALID != path->fp_via_fib)
876  {
877  fib_prefix_t pfx;
878 
879  fib_entry_get_prefix(path->fp_via_fib, &pfx);
881  path->fp_sibling);
883  &pfx,
884  FIB_SOURCE_RR);
886  }
887  break;
890  path->fp_sibling);
891  break;
894  break;
897  break;
900  path->fp_sibling);
902  break;
905  path->fp_sibling);
907  break;
910  break;
912  dpo_reset(&path->exclusive.fp_ex_dpo);
913  break;
917  case FIB_PATH_TYPE_DEAG:
918  case FIB_PATH_TYPE_DVR:
919  /*
920  * these hold only the path's DPO, which is reset below.
921  */
922  break;
923  }
924 
925  /*
926  * release the adj we were holding and pick up the
927  * drop just in case.
928  */
929  dpo_reset(&path->fp_dpo);
931 
932  return;
933 }
934 
937 {
938  if (DPO_PROTO_MPLS == path->fp_nh_proto)
939  {
940  if (FIB_PATH_TYPE_RECURSIVE == path->fp_type &&
941  MPLS_EOS == path->recursive.fp_nh.fp_eos)
942  {
944  }
945  else
946  {
948  }
949  }
950  else
951  {
953  }
954 }
955 
956 /*
957  * fib_path_back_walk_notify
958  *
959  * A back walk has reach this path.
960  */
964 {
965  fib_path_t *path;
966 
967  path = fib_path_from_fib_node(node);
968 
969  switch (path->fp_type)
970  {
973  {
974  /*
975  * modify the recursive adjacency to use the new forwarding
976  * of the via-fib.
977  * this update is visible to packets in flight in the DP.
978  */
980  path,
982  &path->fp_dpo);
983  }
986  {
987  /*
988  * ADJ updates (complete<->incomplete) do not need to propagate to
989  * recursive entries.
990  * The only reason its needed as far back as here, is that the adj
991  * and the incomplete adj are a different DPO type, so the LBs need
992  * to re-stack.
993  * If this walk was quashed in the fib_entry, then any non-fib_path
994  * children (like tunnels that collapse out the LB when they stack)
995  * would not see the update.
996  */
998  }
999  break;
1002  {
1003  /*
1004  * update to use the BIER fmask's new forwading
1005  */
1006  fib_path_bier_fmask_update(path, &path->fp_dpo);
1007  }
1010  {
1011  /*
1012  * ADJ updates (complete<->incomplete) do not need to propagate to
1013  * recursive entries.
1014  * The only reason its needed as far back as here, is that the adj
1015  * and the incomplete adj are a different DPO type, so the LBs need
1016  * to re-stack.
1017  * If this walk was quashed in the fib_entry, then any non-fib_path
1018  * children (like tunnels that collapse out the LB when they stack)
1019  * would not see the update.
1020  */
1021  return (FIB_NODE_BACK_WALK_CONTINUE);
1022  }
1023  break;
1025  /*
1026 FIXME comment
1027  * ADJ_UPDATE backwalk pass silently through here and up to
1028  * the path-list when the multipath adj collapse occurs.
1029  * The reason we do this is that the assumtption is that VPP
1030  * runs in an environment where the Control-Plane is remote
1031  * and hence reacts slowly to link up down. In order to remove
1032  * this down link from the ECMP set quickly, we back-walk.
1033  * VPP also has dedicated CPUs, so we are not stealing resources
1034  * from the CP to do so.
1035  */
1037  {
1039  {
1040  /*
1041  * alreday resolved. no need to walk back again
1042  */
1043  return (FIB_NODE_BACK_WALK_CONTINUE);
1044  }
1046  }
1048  {
1050  {
1051  /*
1052  * alreday unresolved. no need to walk back again
1053  */
1054  return (FIB_NODE_BACK_WALK_CONTINUE);
1055  }
1057  }
1059  {
1060  /*
1061  * The interface this path resolves through has been deleted.
1062  * This will leave the path in a permanent drop state. The route
1063  * needs to be removed and readded (and hence the path-list deleted)
1064  * before it can forward again.
1065  */
1066  fib_path_unresolve(path);
1068  }
1070  {
1071  /*
1072  * restack the DPO to pick up the correct DPO sub-type
1073  */
1074  uword if_is_up;
1075  adj_index_t ai;
1076 
1077  if_is_up = vnet_sw_interface_is_admin_up(
1078  vnet_get_main(),
1079  path->attached_next_hop.fp_interface);
1080 
1082  path,
1084 
1086  if (if_is_up && adj_is_up(ai))
1087  {
1089  }
1090 
1091  dpo_set(&path->fp_dpo, DPO_ADJACENCY, path->fp_nh_proto, ai);
1092  adj_unlock(ai);
1093 
1094  if (!if_is_up)
1095  {
1096  /*
1097  * If the interface is not up there is no reason to walk
1098  * back to children. if we did they would only evalute
1099  * that this path is unresolved and hence it would
1100  * not contribute the adjacency - so it would be wasted
1101  * CPU time.
1102  */
1103  return (FIB_NODE_BACK_WALK_CONTINUE);
1104  }
1105  }
1107  {
1109  {
1110  /*
1111  * alreday unresolved. no need to walk back again
1112  */
1113  return (FIB_NODE_BACK_WALK_CONTINUE);
1114  }
1115  /*
1116  * the adj has gone down. the path is no longer resolved.
1117  */
1119  }
1120  break;
1122  case FIB_PATH_TYPE_DVR:
1123  /*
1124  * FIXME; this could schedule a lower priority walk, since attached
1125  * routes are not usually in ECMP configurations so the backwalk to
1126  * the FIB entry does not need to be high priority
1127  */
1129  {
1131  }
1133  {
1135  }
1137  {
1138  fib_path_unresolve(path);
1140  }
1141  break;
1143  {
1144  dpo_id_t via_dpo = DPO_INVALID;
1145 
1146  /*
1147  * hope for the best - clear if restrictions apply.
1148  */
1150 
1151  udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
1152  path->fp_nh_proto,
1153  &via_dpo);
1154  /*
1155  * If this path is contributing a drop, then it's not resolved
1156  */
1157  if (dpo_is_drop(&via_dpo) || load_balance_is_drop(&via_dpo))
1158  {
1160  }
1161 
1162  /*
1163  * update the path's contributed DPO
1164  */
1165  dpo_copy(&path->fp_dpo, &via_dpo);
1166  dpo_reset(&via_dpo);
1167  break;
1168  }
1169  case FIB_PATH_TYPE_INTF_RX:
1170  ASSERT(0);
1171  case FIB_PATH_TYPE_DEAG:
1172  /*
1173  * FIXME When VRF delete is allowed this will need a poke.
1174  */
1175  case FIB_PATH_TYPE_SPECIAL:
1176  case FIB_PATH_TYPE_RECEIVE:
1180  /*
1181  * these path types have no parents. so to be
1182  * walked from one is unexpected.
1183  */
1184  ASSERT(0);
1185  break;
1186  }
1187 
1188  /*
1189  * propagate the backwalk further to the path-list
1190  */
1192 
1193  return (FIB_NODE_BACK_WALK_CONTINUE);
1194 }
1195 
1196 static void
1198 {
1199  fib_show_memory_usage("Path",
1200  pool_elts(fib_path_pool),
1201  pool_len(fib_path_pool),
1202  sizeof(fib_path_t));
1203 }
1204 
1205 /*
1206  * The FIB path's graph node virtual function table
1207  */
1208 static const fib_node_vft_t fib_path_vft = {
1210  .fnv_last_lock = fib_path_last_lock_gone,
1211  .fnv_back_walk = fib_path_back_walk_notify,
1212  .fnv_mem_show = fib_path_memory_show,
1213 };
1214 
1215 static fib_path_cfg_flags_t
1217 {
1219 
1221  cfg_flags |= FIB_PATH_CFG_FLAG_RESOLVE_HOST;
1224  if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL)
1225  cfg_flags |= FIB_PATH_CFG_FLAG_LOCAL;
1226  if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
1227  cfg_flags |= FIB_PATH_CFG_FLAG_ATTACHED;
1228  if (rpath->frp_flags & FIB_ROUTE_PATH_INTF_RX)
1229  cfg_flags |= FIB_PATH_CFG_FLAG_INTF_RX;
1230  if (rpath->frp_flags & FIB_ROUTE_PATH_RPF_ID)
1231  cfg_flags |= FIB_PATH_CFG_FLAG_RPF_ID;
1232  if (rpath->frp_flags & FIB_ROUTE_PATH_EXCLUSIVE)
1233  cfg_flags |= FIB_PATH_CFG_FLAG_EXCLUSIVE;
1234  if (rpath->frp_flags & FIB_ROUTE_PATH_DROP)
1235  cfg_flags |= FIB_PATH_CFG_FLAG_DROP;
1237  cfg_flags |= FIB_PATH_CFG_FLAG_DEAG_SRC;
1238 
1239  return (cfg_flags);
1240 }
1241 
1242 /*
1243  * fib_path_create
1244  *
1245  * Create and initialise a new path object.
1246  * return the index of the path.
1247  */
1250  const fib_route_path_t *rpath)
1251 {
1252  fib_path_t *path;
1253 
1254  pool_get(fib_path_pool, path);
1255  memset(path, 0, sizeof(*path));
1256 
1257  fib_node_init(&path->fp_node,
1259 
1260  dpo_reset(&path->fp_dpo);
1261  path->fp_pl_index = pl_index;
1262  path->fp_nh_proto = rpath->frp_proto;
1264  path->fp_weight = rpath->frp_weight;
1265  if (0 == path->fp_weight)
1266  {
1267  /*
1268  * a weight of 0 is a meaningless value. We could either reject it, and thus force
1269  * clients to always use 1, or we can accept it and fixup approrpiately.
1270  */
1271  path->fp_weight = 1;
1272  }
1273  path->fp_preference = rpath->frp_preference;
1275 
1276  /*
1277  * deduce the path's tpye from the parementers and save what is needed.
1278  */
1280  {
1282  path->receive.fp_interface = rpath->frp_sw_if_index;
1283  path->receive.fp_addr = rpath->frp_addr;
1284  }
1285  else if (rpath->frp_flags & FIB_ROUTE_PATH_UDP_ENCAP)
1286  {
1288  path->udp_encap.fp_udp_encap_id = rpath->frp_udp_encap_id;
1289  }
1290  else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_INTF_RX)
1291  {
1293  path->intf_rx.fp_interface = rpath->frp_sw_if_index;
1294  }
1295  else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID)
1296  {
1297  path->fp_type = FIB_PATH_TYPE_DEAG;
1298  path->deag.fp_tbl_id = rpath->frp_fib_index;
1299  path->deag.fp_rpf_id = rpath->frp_rpf_id;
1300  }
1301  else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_FMASK)
1302  {
1304  path->bier_fmask.fp_bier_fmask = rpath->frp_bier_fmask;
1305  }
1306  else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_IMP)
1307  {
1309  path->bier_imp.fp_bier_imp = rpath->frp_bier_imp;
1310  }
1311  else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_TABLE)
1312  {
1314  path->bier_table.fp_bier_tbl = rpath->frp_bier_tbl;
1315  }
1316  else if (rpath->frp_flags & FIB_ROUTE_PATH_DEAG)
1317  {
1318  path->fp_type = FIB_PATH_TYPE_DEAG;
1319  path->deag.fp_tbl_id = rpath->frp_fib_index;
1320  }
1321  else if (rpath->frp_flags & FIB_ROUTE_PATH_DVR)
1322  {
1323  path->fp_type = FIB_PATH_TYPE_DVR;
1324  path->dvr.fp_interface = rpath->frp_sw_if_index;
1325  }
1326  else if (~0 != rpath->frp_sw_if_index)
1327  {
1328  if (ip46_address_is_zero(&rpath->frp_addr))
1329  {
1331  path->attached.fp_interface = rpath->frp_sw_if_index;
1332  }
1333  else
1334  {
1336  path->attached_next_hop.fp_interface = rpath->frp_sw_if_index;
1337  path->attached_next_hop.fp_nh = rpath->frp_addr;
1338  }
1339  }
1340  else
1341  {
1342  if (ip46_address_is_zero(&rpath->frp_addr))
1343  {
1344  if (~0 == rpath->frp_fib_index)
1345  {
1347  }
1348  else
1349  {
1350  path->fp_type = FIB_PATH_TYPE_DEAG;
1351  path->deag.fp_tbl_id = rpath->frp_fib_index;
1352  path->deag.fp_rpf_id = ~0;
1353  }
1354  }
1355  else
1356  {
1358  if (DPO_PROTO_MPLS == path->fp_nh_proto)
1359  {
1360  path->recursive.fp_nh.fp_local_label = rpath->frp_local_label;
1361  path->recursive.fp_nh.fp_eos = rpath->frp_eos;
1362  }
1363  else
1364  {
1365  path->recursive.fp_nh.fp_ip = rpath->frp_addr;
1366  }
1367  path->recursive.fp_tbl_id = rpath->frp_fib_index;
1368  }
1369  }
1370 
1371  FIB_PATH_DBG(path, "create");
1372 
1373  return (fib_path_get_index(path));
1374 }
1375 
1376 /*
1377  * fib_path_create_special
1378  *
1379  * Create and initialise a new path object.
1380  * return the index of the path.
1381  */
1384  dpo_proto_t nh_proto,
1386  const dpo_id_t *dpo)
1387 {
1388  fib_path_t *path;
1389 
1390  pool_get(fib_path_pool, path);
1391  memset(path, 0, sizeof(*path));
1392 
1393  fib_node_init(&path->fp_node,
1395  dpo_reset(&path->fp_dpo);
1396 
1397  path->fp_pl_index = pl_index;
1398  path->fp_weight = 1;
1399  path->fp_preference = 0;
1400  path->fp_nh_proto = nh_proto;
1402  path->fp_cfg_flags = flags;
1403 
1404  if (FIB_PATH_CFG_FLAG_DROP & flags)
1405  {
1407  }
1408  else if (FIB_PATH_CFG_FLAG_LOCAL & flags)
1409  {
1411  path->attached.fp_interface = FIB_NODE_INDEX_INVALID;
1412  }
1413  else
1414  {
1416  ASSERT(NULL != dpo);
1417  dpo_copy(&path->exclusive.fp_ex_dpo, dpo);
1418  }
1419 
1420  return (fib_path_get_index(path));
1421 }
1422 
1423 /*
1424  * fib_path_copy
1425  *
1426  * Copy a path. return index of new path.
1427  */
1430  fib_node_index_t path_list_index)
1431 {
1432  fib_path_t *path, *orig_path;
1433 
1434  pool_get(fib_path_pool, path);
1435 
1436  orig_path = fib_path_get(path_index);
1437  ASSERT(NULL != orig_path);
1438 
1439  memcpy(path, orig_path, sizeof(*path));
1440 
1441  FIB_PATH_DBG(path, "create-copy:%d", path_index);
1442 
1443  /*
1444  * reset the dynamic section
1445  */
1448  path->fp_pl_index = path_list_index;
1450  memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
1451  dpo_reset(&path->fp_dpo);
1452 
1453  return (fib_path_get_index(path));
1454 }
1455 
1456 /*
1457  * fib_path_destroy
1458  *
1459  * destroy a path that is no longer required
1460  */
1461 void
1463 {
1464  fib_path_t *path;
1465 
1466  path = fib_path_get(path_index);
1467 
1468  ASSERT(NULL != path);
1469  FIB_PATH_DBG(path, "destroy");
1470 
1471  fib_path_unresolve(path);
1472 
1473  fib_node_deinit(&path->fp_node);
1474  pool_put(fib_path_pool, path);
1475 }
1476 
1477 /*
1478  * fib_path_destroy
1479  *
1480  * destroy a path that is no longer required
1481  */
1482 uword
1484 {
1485  fib_path_t *path;
1486 
1487  path = fib_path_get(path_index);
1488 
1489  return (hash_memory(STRUCT_MARK_PTR(path, path_hash_start),
1490  (STRUCT_OFFSET_OF(fib_path_t, path_hash_end) -
1491  STRUCT_OFFSET_OF(fib_path_t, path_hash_start)),
1492  0));
1493 }
1494 
1495 /*
1496  * fib_path_cmp_i
1497  *
1498  * Compare two paths for equivalence.
1499  */
1500 static int
1502  const fib_path_t *path2)
1503 {
1504  int res;
1505 
1506  res = 1;
1507 
1508  /*
1509  * paths of different types and protocol are not equal.
1510  * different weights and/or preference only are the same path.
1511  */
1512  if (path1->fp_type != path2->fp_type)
1513  {
1514  res = (path1->fp_type - path2->fp_type);
1515  }
1516  else if (path1->fp_nh_proto != path2->fp_nh_proto)
1517  {
1518  res = (path1->fp_nh_proto - path2->fp_nh_proto);
1519  }
1520  else
1521  {
1522  /*
1523  * both paths are of the same type.
1524  * consider each type and its attributes in turn.
1525  */
1526  switch (path1->fp_type)
1527  {
1529  res = ip46_address_cmp(&path1->attached_next_hop.fp_nh,
1530  &path2->attached_next_hop.fp_nh);
1531  if (0 == res) {
1532  res = (path1->attached_next_hop.fp_interface -
1533  path2->attached_next_hop.fp_interface);
1534  }
1535  break;
1537  res = (path1->attached.fp_interface -
1538  path2->attached.fp_interface);
1539  break;
1541  res = ip46_address_cmp(&path1->recursive.fp_nh,
1542  &path2->recursive.fp_nh);
1543 
1544  if (0 == res)
1545  {
1546  res = (path1->recursive.fp_tbl_id - path2->recursive.fp_tbl_id);
1547  }
1548  break;
1550  res = (path1->bier_fmask.fp_bier_fmask -
1551  path2->bier_fmask.fp_bier_fmask);
1552  break;
1554  res = (path1->bier_imp.fp_bier_imp -
1555  path2->bier_imp.fp_bier_imp);
1556  break;
1558  res = bier_table_id_cmp(&path1->bier_table.fp_bier_tbl,
1559  &path2->bier_table.fp_bier_tbl);
1560  break;
1561  case FIB_PATH_TYPE_DEAG:
1562  res = (path1->deag.fp_tbl_id - path2->deag.fp_tbl_id);
1563  if (0 == res)
1564  {
1565  res = (path1->deag.fp_rpf_id - path2->deag.fp_rpf_id);
1566  }
1567  break;
1568  case FIB_PATH_TYPE_INTF_RX:
1569  res = (path1->intf_rx.fp_interface - path2->intf_rx.fp_interface);
1570  break;
1572  res = (path1->udp_encap.fp_udp_encap_id - path2->udp_encap.fp_udp_encap_id);
1573  break;
1574  case FIB_PATH_TYPE_DVR:
1575  res = (path1->dvr.fp_interface - path2->dvr.fp_interface);
1576  break;
1577  case FIB_PATH_TYPE_SPECIAL:
1578  case FIB_PATH_TYPE_RECEIVE:
1580  res = 0;
1581  break;
1582  }
1583  }
1584  return (res);
1585 }
1586 
1587 /*
1588  * fib_path_cmp_for_sort
1589  *
1590  * Compare two paths for equivalence. Used during path sorting.
1591  * As usual 0 means equal.
1592  */
1593 int
1595  void * v2)
1596 {
1597  fib_node_index_t *pi1 = v1, *pi2 = v2;
1598  fib_path_t *path1, *path2;
1599 
1600  path1 = fib_path_get(*pi1);
1601  path2 = fib_path_get(*pi2);
1602 
1603  /*
1604  * when sorting paths we want the highest preference paths
1605  * first, so that the choices set built is in prefernce order
1606  */
1607  if (path1->fp_preference != path2->fp_preference)
1608  {
1609  return (path1->fp_preference - path2->fp_preference);
1610  }
1611 
1612  return (fib_path_cmp_i(path1, path2));
1613 }
1614 
1615 /*
1616  * fib_path_cmp
1617  *
1618  * Compare two paths for equivalence.
1619  */
1620 int
1622  fib_node_index_t pi2)
1623 {
1624  fib_path_t *path1, *path2;
1625 
1626  path1 = fib_path_get(pi1);
1627  path2 = fib_path_get(pi2);
1628 
1629  return (fib_path_cmp_i(path1, path2));
1630 }
1631 
1632 int
1634  const fib_route_path_t *rpath)
1635 {
1636  fib_path_t *path;
1637  int res;
1638 
1639  path = fib_path_get(path_index);
1640 
1641  res = 1;
1642 
1643  if (path->fp_weight != rpath->frp_weight)
1644  {
1645  res = (path->fp_weight - rpath->frp_weight);
1646  }
1647  else
1648  {
1649  /*
1650  * both paths are of the same type.
1651  * consider each type and its attributes in turn.
1652  */
1653  switch (path->fp_type)
1654  {
1656  res = ip46_address_cmp(&path->attached_next_hop.fp_nh,
1657  &rpath->frp_addr);
1658  if (0 == res)
1659  {
1660  res = (path->attached_next_hop.fp_interface -
1661  rpath->frp_sw_if_index);
1662  }
1663  break;
1665  res = (path->attached.fp_interface - rpath->frp_sw_if_index);
1666  break;
1668  if (DPO_PROTO_MPLS == path->fp_nh_proto)
1669  {
1670  res = path->recursive.fp_nh.fp_local_label - rpath->frp_local_label;
1671 
1672  if (res == 0)
1673  {
1674  res = path->recursive.fp_nh.fp_eos - rpath->frp_eos;
1675  }
1676  }
1677  else
1678  {
1679  res = ip46_address_cmp(&path->recursive.fp_nh.fp_ip,
1680  &rpath->frp_addr);
1681  }
1682 
1683  if (0 == res)
1684  {
1685  res = (path->recursive.fp_tbl_id - rpath->frp_fib_index);
1686  }
1687  break;
1689  res = (path->bier_fmask.fp_bier_fmask - rpath->frp_bier_fmask);
1690  break;
1692  res = (path->bier_imp.fp_bier_imp - rpath->frp_bier_imp);
1693  break;
1695  res = bier_table_id_cmp(&path->bier_table.fp_bier_tbl,
1696  &rpath->frp_bier_tbl);
1697  break;
1698  case FIB_PATH_TYPE_INTF_RX:
1699  res = (path->intf_rx.fp_interface - rpath->frp_sw_if_index);
1700  break;
1702  res = (path->udp_encap.fp_udp_encap_id - rpath->frp_udp_encap_id);
1703  break;
1704  case FIB_PATH_TYPE_DEAG:
1705  res = (path->deag.fp_tbl_id - rpath->frp_fib_index);
1706  if (0 == res)
1707  {
1708  res = (path->deag.fp_rpf_id - rpath->frp_rpf_id);
1709  }
1710  break;
1711  case FIB_PATH_TYPE_DVR:
1712  res = (path->dvr.fp_interface - rpath->frp_sw_if_index);
1713  break;
1714  case FIB_PATH_TYPE_SPECIAL:
1715  case FIB_PATH_TYPE_RECEIVE:
1717  res = 0;
1718  break;
1719  }
1720  }
1721  return (res);
1722 }
1723 
1724 /*
1725  * fib_path_recursive_loop_detect
1726  *
1727  * A forward walk of the FIB object graph to detect for a cycle/loop. This
1728  * walk is initiated when an entry is linking to a new path list or from an old.
1729  * The entry vector passed contains all the FIB entrys that are children of this
1730  * path (it is all the entries encountered on the walk so far). If this vector
1731  * contains the entry this path resolve via, then a loop is about to form.
1732  * The loop must be allowed to form, since we need the dependencies in place
1733  * so that we can track when the loop breaks.
1734  * However, we MUST not produce a loop in the forwarding graph (else packets
1735  * would loop around the switch path until the loop breaks), so we mark recursive
1736  * paths as looped so that they do not contribute forwarding information.
1737  * By marking the path as looped, an etry such as;
1738  * X/Y
1739  * via a.a.a.a (looped)
1740  * via b.b.b.b (not looped)
1741  * can still forward using the info provided by b.b.b.b only
1742  */
1743 int
1745  fib_node_index_t **entry_indicies)
1746 {
1747  fib_path_t *path;
1748 
1749  path = fib_path_get(path_index);
1750 
1751  /*
1752  * the forced drop path is never looped, cos it is never resolved.
1753  */
1754  if (fib_path_is_permanent_drop(path))
1755  {
1756  return (0);
1757  }
1758 
1759  switch (path->fp_type)
1760  {
1762  {
1763  fib_node_index_t *entry_index, *entries;
1764  int looped = 0;
1765  entries = *entry_indicies;
1766 
1767  vec_foreach(entry_index, entries) {
1768  if (*entry_index == path->fp_via_fib)
1769  {
1770  /*
1771  * the entry that is about to link to this path-list (or
1772  * one of this path-list's children) is the same entry that
1773  * this recursive path resolves through. this is a cycle.
1774  * abort the walk.
1775  */
1776  looped = 1;
1777  break;
1778  }
1779  }
1780 
1781  if (looped)
1782  {
1783  FIB_PATH_DBG(path, "recursive loop formed");
1785 
1786  dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1787  }
1788  else
1789  {
1790  /*
1791  * no loop here yet. keep forward walking the graph.
1792  */
1793  if (fib_entry_recursive_loop_detect(path->fp_via_fib, entry_indicies))
1794  {
1795  FIB_PATH_DBG(path, "recursive loop formed");
1797  }
1798  else
1799  {
1800  FIB_PATH_DBG(path, "recursive loop cleared");
1802  }
1803  }
1804  break;
1805  }
1808  case FIB_PATH_TYPE_SPECIAL:
1809  case FIB_PATH_TYPE_DEAG:
1810  case FIB_PATH_TYPE_DVR:
1811  case FIB_PATH_TYPE_RECEIVE:
1812  case FIB_PATH_TYPE_INTF_RX:
1818  /*
1819  * these path types cannot be part of a loop, since they are the leaves
1820  * of the graph.
1821  */
1822  break;
1823  }
1824 
1825  return (fib_path_is_looped(path_index));
1826 }
1827 
1828 int
1830 {
1831  fib_path_t *path;
1832 
1833  path = fib_path_get(path_index);
1834 
1835  /*
1836  * hope for the best.
1837  */
1839 
1840  /*
1841  * the forced drop path resolves via the drop adj
1842  */
1843  if (fib_path_is_permanent_drop(path))
1844  {
1845  dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1847  return (fib_path_is_resolved(path_index));
1848  }
1849 
1850  switch (path->fp_type)
1851  {
1854  break;
1856  /*
1857  * path->attached.fp_interface
1858  */
1860  path->attached.fp_interface))
1861  {
1863  }
1864  dpo_set(&path->fp_dpo,
1865  DPO_ADJACENCY,
1866  path->fp_nh_proto,
1868  dpo_proto_to_link(path->fp_nh_proto)));
1869 
1870  /*
1871  * become a child of the adjacency so we receive updates
1872  * when the interface state changes
1873  */
1874  path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
1876  fib_path_get_index(path));
1877  break;
1879  {
1880  /*
1881  * Create a RR source entry in the table for the address
1882  * that this path recurses through.
1883  * This resolve action is recursive, hence we may create
1884  * more paths in the process. more creates mean maybe realloc
1885  * of this path.
1886  */
1887  fib_node_index_t fei;
1888  fib_prefix_t pfx;
1889 
1891 
1892  if (DPO_PROTO_MPLS == path->fp_nh_proto)
1893  {
1894  fib_prefix_from_mpls_label(path->recursive.fp_nh.fp_local_label,
1895  path->recursive.fp_nh.fp_eos,
1896  &pfx);
1897  }
1898  else
1899  {
1900  fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx);
1901  }
1902 
1903  fei = fib_table_entry_special_add(path->recursive.fp_tbl_id,
1904  &pfx,
1905  FIB_SOURCE_RR,
1907 
1908  path = fib_path_get(path_index);
1909  path->fp_via_fib = fei;
1910 
1911  /*
1912  * become a dependent child of the entry so the path is
1913  * informed when the forwarding for the entry changes.
1914  */
1917  fib_path_get_index(path));
1918 
1919  /*
1920  * create and configure the IP DPO
1921  */
1923  path,
1924  fib_path_to_chain_type(path),
1925  &path->fp_dpo);
1926 
1927  break;
1928  }
1930  {
1931  /*
1932  * become a dependent child of the entry so the path is
1933  * informed when the forwarding for the entry changes.
1934  */
1935  path->fp_sibling = bier_fmask_child_add(path->bier_fmask.fp_bier_fmask,
1937  fib_path_get_index(path));
1938 
1939  path->fp_via_bier_fmask = path->bier_fmask.fp_bier_fmask;
1940  fib_path_bier_fmask_update(path, &path->fp_dpo);
1941 
1942  break;
1943  }
1945  bier_imp_lock(path->bier_imp.fp_bier_imp);
1946  bier_imp_contribute_forwarding(path->bier_imp.fp_bier_imp,
1947  DPO_PROTO_IP4,
1948  &path->fp_dpo);
1949  break;
1951  {
1952  /*
1953  * Find/create the BIER table to link to
1954  */
1956 
1957  path->fp_via_bier_tbl =
1958  bier_table_ecmp_create_and_lock(&path->bier_table.fp_bier_tbl);
1959 
1961  &path->fp_dpo);
1962  break;
1963  }
1964  case FIB_PATH_TYPE_SPECIAL:
1965  /*
1966  * Resolve via the drop
1967  */
1968  dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1969  break;
1970  case FIB_PATH_TYPE_DEAG:
1971  {
1972  if (DPO_PROTO_BIER == path->fp_nh_proto)
1973  {
1975  &path->fp_dpo);
1976  }
1977  else
1978  {
1979  /*
1980  * Resolve via a lookup DPO.
1981  * FIXME. control plane should add routes with a table ID
1982  */
1983  lookup_input_t input;
1984  lookup_cast_t cast;
1985 
1986  cast = (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ?
1988  LOOKUP_UNICAST);
1989  input = (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DEAG_SRC ?
1992 
1993  lookup_dpo_add_or_lock_w_fib_index(path->deag.fp_tbl_id,
1994  path->fp_nh_proto,
1995  cast,
1996  input,
1998  &path->fp_dpo);
1999  }
2000  break;
2001  }
2002  case FIB_PATH_TYPE_DVR:
2003  dvr_dpo_add_or_lock(path->attached.fp_interface,
2004  path->fp_nh_proto,
2005  &path->fp_dpo);
2006  break;
2007  case FIB_PATH_TYPE_RECEIVE:
2008  /*
2009  * Resolve via a receive DPO.
2010  */
2012  path->receive.fp_interface,
2013  &path->receive.fp_addr,
2014  &path->fp_dpo);
2015  break;
2017  udp_encap_lock(path->udp_encap.fp_udp_encap_id);
2018  udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
2019  path->fp_nh_proto,
2020  &path->fp_dpo);
2021  break;
2022  case FIB_PATH_TYPE_INTF_RX: {
2023  /*
2024  * Resolve via a receive DPO.
2025  */
2027  path->intf_rx.fp_interface,
2028  &path->fp_dpo);
2029  break;
2030  }
2032  /*
2033  * Resolve via the user provided DPO
2034  */
2035  dpo_copy(&path->fp_dpo, &path->exclusive.fp_ex_dpo);
2036  break;
2037  }
2038 
2039  return (fib_path_is_resolved(path_index));
2040 }
2041 
2042 u32
2044 {
2045  fib_path_t *path;
2046 
2047  path = fib_path_get(path_index);
2048 
2049  switch (path->fp_type)
2050  {
2052  return (path->attached_next_hop.fp_interface);
2054  return (path->attached.fp_interface);
2055  case FIB_PATH_TYPE_RECEIVE:
2056  return (path->receive.fp_interface);
2058  if (fib_path_is_resolved(path_index))
2059  {
2061  }
2062  break;
2063  case FIB_PATH_TYPE_DVR:
2064  return (path->dvr.fp_interface);
2065  case FIB_PATH_TYPE_INTF_RX:
2067  case FIB_PATH_TYPE_SPECIAL:
2068  case FIB_PATH_TYPE_DEAG:
2073  break;
2074  }
2075  return (dpo_get_urpf(&path->fp_dpo));
2076 }
2077 
2078 index_t
2080 {
2081  fib_path_t *path;
2082 
2083  path = fib_path_get(path_index);
2084 
2085  switch (path->fp_type)
2086  {
2089  case FIB_PATH_TYPE_RECEIVE:
2090  case FIB_PATH_TYPE_INTF_RX:
2091  case FIB_PATH_TYPE_SPECIAL:
2092  case FIB_PATH_TYPE_DEAG:
2093  case FIB_PATH_TYPE_DVR:
2095  break;
2097  return (path->udp_encap.fp_udp_encap_id);
2099  return (path->fp_via_fib);
2101  return (path->bier_fmask.fp_bier_fmask);
2103  return (path->fp_via_bier_tbl);
2105  return (path->bier_imp.fp_bier_imp);
2106  }
2107  return (~0);
2108 }
2109 
2112 {
2113  fib_path_t *path;
2114 
2115  path = fib_path_get(path_index);
2116 
2117  ASSERT(dpo_is_adj(&path->fp_dpo));
2118  if (dpo_is_adj(&path->fp_dpo))
2119  {
2120  return (path->fp_dpo.dpoi_index);
2121  }
2122  return (ADJ_INDEX_INVALID);
2123 }
2124 
2125 u16
2127 {
2128  fib_path_t *path;
2129 
2130  path = fib_path_get(path_index);
2131 
2132  ASSERT(path);
2133 
2134  return (path->fp_weight);
2135 }
2136 
2137 u16
2139 {
2140  fib_path_t *path;
2141 
2142  path = fib_path_get(path_index);
2143 
2144  ASSERT(path);
2145 
2146  return (path->fp_preference);
2147 }
2148 
2149 u32
2151 {
2152  fib_path_t *path;
2153 
2154  path = fib_path_get(path_index);
2155 
2156  ASSERT(path);
2157 
2159  {
2160  return (path->deag.fp_rpf_id);
2161  }
2162 
2163  return (~0);
2164 }
2165 
2166 /**
2167  * @brief Contribute the path's adjacency to the list passed.
2168  * By calling this function over all paths, recursively, a child
2169  * can construct its full set of forwarding adjacencies, and hence its
2170  * uRPF list.
2171  */
2172 void
2174  index_t urpf)
2175 {
2176  fib_path_t *path;
2177 
2178  path = fib_path_get(path_index);
2179 
2180  /*
2181  * resolved and unresolved paths contribute to the RPF list.
2182  */
2183  switch (path->fp_type)
2184  {
2186  fib_urpf_list_append(urpf, path->attached_next_hop.fp_interface);
2187  break;
2188 
2190  fib_urpf_list_append(urpf, path->attached.fp_interface);
2191  break;
2192 
2194  if (FIB_NODE_INDEX_INVALID != path->fp_via_fib &&
2195  !fib_path_is_looped(path_index))
2196  {
2197  /*
2198  * there's unresolved due to constraints, and there's unresolved
2199  * due to ain't got no via. can't do nowt w'out via.
2200  */
2202  }
2203  break;
2204 
2206  case FIB_PATH_TYPE_SPECIAL:
2207  {
2208  /*
2209  * these path types may link to an adj, if that's what
2210  * the clinet gave
2211  */
2212  u32 rpf_sw_if_index;
2213 
2214  rpf_sw_if_index = dpo_get_urpf(&path->fp_dpo);
2215 
2216  if (~0 != rpf_sw_if_index)
2217  {
2218  fib_urpf_list_append(urpf, rpf_sw_if_index);
2219  }
2220  break;
2221  }
2222  case FIB_PATH_TYPE_DVR:
2223  fib_urpf_list_append(urpf, path->dvr.fp_interface);
2224  break;
2225  case FIB_PATH_TYPE_DEAG:
2226  case FIB_PATH_TYPE_RECEIVE:
2227  case FIB_PATH_TYPE_INTF_RX:
2232  /*
2233  * these path types don't link to an adj
2234  */
2235  break;
2236  }
2237 }
2238 
2239 void
2241  dpo_proto_t payload_proto,
2242  fib_mpls_lsp_mode_t mode,
2243  dpo_id_t *dpo)
2244 {
2245  fib_path_t *path;
2246 
2247  path = fib_path_get(path_index);
2248 
2249  ASSERT(path);
2250 
2251  switch (path->fp_type)
2252  {
2254  {
2255  dpo_id_t tmp = DPO_INVALID;
2256 
2257  dpo_copy(&tmp, dpo);
2258 
2259  mpls_disp_dpo_create(payload_proto, ~0, mode, &tmp, dpo);
2260  dpo_reset(&tmp);
2261  break;
2262  }
2263  case FIB_PATH_TYPE_DEAG:
2264  {
2265  dpo_id_t tmp = DPO_INVALID;
2266 
2267  dpo_copy(&tmp, dpo);
2268 
2269  mpls_disp_dpo_create(payload_proto,
2270  path->deag.fp_rpf_id,
2271  mode, &tmp, dpo);
2272  dpo_reset(&tmp);
2273  break;
2274  }
2275  case FIB_PATH_TYPE_RECEIVE:
2278  case FIB_PATH_TYPE_INTF_RX:
2281  case FIB_PATH_TYPE_SPECIAL:
2285  case FIB_PATH_TYPE_DVR:
2286  break;
2287  }
2288 }
2289 
2290 void
2293  dpo_id_t *dpo)
2294 {
2295  fib_path_t *path;
2296 
2297  path = fib_path_get(path_index);
2298 
2299  ASSERT(path);
2301 
2302  FIB_PATH_DBG(path, "contribute");
2303 
2304  /*
2305  * The DPO stored in the path was created when the path was resolved.
2306  * This then represents the path's 'native' protocol; IP.
2307  * For all others will need to go find something else.
2308  */
2309  if (fib_path_to_chain_type(path) == fct)
2310  {
2311  dpo_copy(dpo, &path->fp_dpo);
2312  }
2313  else
2314  {
2315  switch (path->fp_type)
2316  {
2318  switch (fct)
2319  {
2328  {
2329  adj_index_t ai;
2330 
2331  /*
2332  * get a appropriate link type adj.
2333  */
2335  path,
2337  dpo_set(dpo, DPO_ADJACENCY,
2339  adj_unlock(ai);
2340 
2341  break;
2342  }
2344  break;
2345  }
2346  break;
2348  switch (fct)
2349  {
2357  fib_path_recursive_adj_update(path, fct, dpo);
2358  break;
2361  ASSERT(0);
2362  break;
2363  }
2364  break;
2366  switch (fct)
2367  {
2370  break;
2379  ASSERT(0);
2380  break;
2381  }
2382  break;
2384  switch (fct)
2385  {
2387  fib_path_bier_fmask_update(path, dpo);
2388  break;
2397  ASSERT(0);
2398  break;
2399  }
2400  break;
2402  bier_imp_contribute_forwarding(path->bier_imp.fp_bier_imp,
2404  dpo);
2405  break;
2406  case FIB_PATH_TYPE_DEAG:
2407  switch (fct)
2408  {
2415  dpo);
2416  break;
2420  dpo_copy(dpo, &path->fp_dpo);
2421  break;
2425  break;
2428  ASSERT(0);
2429  break;
2430  }
2431  break;
2433  dpo_copy(dpo, &path->exclusive.fp_ex_dpo);
2434  break;
2436  switch (fct)
2437  {
2445  {
2446  adj_index_t ai;
2447 
2448  /*
2449  * get a appropriate link type adj.
2450  */
2452  path,
2454  dpo_set(dpo, DPO_ADJACENCY,
2456  adj_unlock(ai);
2457  break;
2458  }
2461  {
2462  adj_index_t ai;
2463 
2464  /*
2465  * Create the adj needed for sending IP multicast traffic
2466  */
2469  path->attached.fp_interface);
2470  dpo_set(dpo, DPO_ADJACENCY,
2472  ai);
2473  adj_unlock(ai);
2474  }
2475  break;
2476  }
2477  break;
2478  case FIB_PATH_TYPE_INTF_RX:
2479  /*
2480  * Create the adj needed for sending IP multicast traffic
2481  */
2483  path->attached.fp_interface,
2484  dpo);
2485  break;
2487  udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
2488  path->fp_nh_proto,
2489  dpo);
2490  break;
2491  case FIB_PATH_TYPE_RECEIVE:
2492  case FIB_PATH_TYPE_SPECIAL:
2493  case FIB_PATH_TYPE_DVR:
2494  dpo_copy(dpo, &path->fp_dpo);
2495  break;
2496  }
2497  }
2498 }
2499 
2503  load_balance_path_t *hash_key)
2504 {
2505  load_balance_path_t *mnh;
2506  fib_path_t *path;
2507 
2508  path = fib_path_get(path_index);
2509 
2510  ASSERT(path);
2511 
2512  if (fib_path_is_resolved(path_index))
2513  {
2514  vec_add2(hash_key, mnh, 1);
2515 
2516  mnh->path_weight = path->fp_weight;
2517  mnh->path_index = path_index;
2518  fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo);
2519  }
2520 
2521  return (hash_key);
2522 }
2523 
2524 int
2526 {
2527  fib_path_t *path;
2528 
2529  path = fib_path_get(path_index);
2530 
2531  return ((FIB_PATH_TYPE_RECURSIVE == path->fp_type) &&
2534 }
2535 
2536 int
2538 {
2539  fib_path_t *path;
2540 
2541  path = fib_path_get(path_index);
2542 
2543  return (FIB_PATH_TYPE_EXCLUSIVE == path->fp_type);
2544 }
2545 
2546 int
2548 {
2549  fib_path_t *path;
2550 
2551  path = fib_path_get(path_index);
2552 
2553  return (FIB_PATH_TYPE_DEAG == path->fp_type);
2554 }
2555 
2556 int
2558 {
2559  fib_path_t *path;
2560 
2561  path = fib_path_get(path_index);
2562 
2563  return (dpo_id_is_valid(&path->fp_dpo) &&
2565  !fib_path_is_looped(path_index) &&
2567 }
2568 
2569 int
2571 {
2572  fib_path_t *path;
2573 
2574  path = fib_path_get(path_index);
2575 
2577 }
2578 
2581  fib_node_index_t path_index,
2582  void *ctx)
2583 {
2584  fib_route_path_encode_t **api_rpaths = ctx;
2585  fib_route_path_encode_t *api_rpath;
2586  fib_path_t *path;
2587 
2588  path = fib_path_get(path_index);
2589  if (!path)
2590  return (FIB_PATH_LIST_WALK_CONTINUE);
2591  vec_add2(*api_rpaths, api_rpath, 1);
2592  api_rpath->rpath.frp_weight = path->fp_weight;
2593  api_rpath->rpath.frp_preference = path->fp_preference;
2594  api_rpath->rpath.frp_proto = path->fp_nh_proto;
2595  api_rpath->rpath.frp_sw_if_index = ~0;
2596  api_rpath->dpo = path->fp_dpo;
2597 
2598  switch (path->fp_type)
2599  {
2600  case FIB_PATH_TYPE_RECEIVE:
2601  api_rpath->rpath.frp_addr = path->receive.fp_addr;
2602  api_rpath->rpath.frp_sw_if_index = path->receive.fp_interface;
2603  break;
2605  api_rpath->rpath.frp_sw_if_index = path->attached.fp_interface;
2606  break;
2608  api_rpath->rpath.frp_sw_if_index = path->attached_next_hop.fp_interface;
2609  api_rpath->rpath.frp_addr = path->attached_next_hop.fp_nh;
2610  break;
2612  api_rpath->rpath.frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
2613  break;
2614  case FIB_PATH_TYPE_SPECIAL:
2615  break;
2616  case FIB_PATH_TYPE_DEAG:
2617  api_rpath->rpath.frp_fib_index = path->deag.fp_tbl_id;
2618  break;
2620  api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip;
2621  break;
2622  case FIB_PATH_TYPE_DVR:
2623  api_rpath->rpath.frp_sw_if_index = path->dvr.fp_interface;
2624  api_rpath->rpath.frp_flags |= FIB_ROUTE_PATH_DVR;
2625  break;
2627  api_rpath->rpath.frp_udp_encap_id = path->udp_encap.fp_udp_encap_id;
2629  break;
2630  default:
2631  break;
2632  }
2633 
2634  return (FIB_PATH_LIST_WALK_CONTINUE);
2635 }
2636 
2639 {
2640  fib_path_t *path;
2641 
2642  path = fib_path_get(path_index);
2643 
2644  return (path->fp_nh_proto);
2645 }
2646 
2647 void
2649 {
2650  fib_node_register_type (FIB_NODE_TYPE_PATH, &fib_path_vft);
2651 }
2652 
2653 static clib_error_t *
2655  unformat_input_t * input,
2656  vlib_cli_command_t * cmd)
2657 {
2658  fib_node_index_t pi;
2659  fib_path_t *path;
2660 
2661  if (unformat (input, "%d", &pi))
2662  {
2663  /*
2664  * show one in detail
2665  */
2666  if (!pool_is_free_index(fib_path_pool, pi))
2667  {
2668  path = fib_path_get(pi);
2669  u8 *s = format(NULL, "%U", format_fib_path, pi, 1);
2670  s = format(s, "children:");
2672  vlib_cli_output (vm, "%s", s);
2673  vec_free(s);
2674  }
2675  else
2676  {
2677  vlib_cli_output (vm, "path %d invalid", pi);
2678  }
2679  }
2680  else
2681  {
2682  vlib_cli_output (vm, "FIB Paths");
2683  pool_foreach_index (pi, fib_path_pool,
2684  ({
2685  vlib_cli_output (vm, "%U", format_fib_path, pi, 0);
2686  }));
2687  }
2688 
2689  return (NULL);
2690 }
2691 
2692 VLIB_CLI_COMMAND (show_fib_path, static) = {
2693  .path = "show fib paths",
2694  .function = show_fib_path_command,
2695  .short_help = "show fib paths",
2696 };
int fib_path_is_resolved(fib_node_index_t path_index)
Definition: fib_path.c:2557
Contribute an object that is to be used to forward BIER packets.
Definition: fib_types.h:112
int fib_path_resolve(fib_node_index_t path_index)
Definition: fib_path.c:1829
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:127
ip46_address_t frp_addr
The next-hop address.
Definition: fib_types.h:471
Recursive resolution source.
Definition: fib_entry.h:121
A path that resolves via a DVR DPO.
Definition: fib_types.h:366
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:103
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:56
static fib_path_t * fib_path_from_fib_node(fib_node_t *node)
Definition: fib_path.c:448
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:1483
fib_node_index_t path_index
The index of the FIB path.
Definition: load_balance.h:71
A representation of a fib path for fib_path_encode to convey the information to the caller...
Definition: fib_types.h:564
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:2291
index_t fp_bier_fmask
BIER FMask ID.
Definition: fib_path.c:297
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:153
mpls_eos_bit_t frp_eos
EOS bit for the resolving label.
Definition: fib_types.h:482
fib_path_oper_attribute_t_
Enurmeration of path operational (i.e.
Definition: fib_path.c:141
int fib_entry_is_resolved(fib_node_index_t fib_entry_index)
Return !0 is the entry is reoslved, i.e.
Definition: fib_entry.c:1448
index_t fib_path_get_resolving_index(fib_node_index_t path_index)
Definition: fib_path.c:2079
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:2173
A representation of a path as described by a route producer.
Definition: fib_types.h:455
u8 * format_dpo_type(u8 *s, va_list *args)
format a DPO type
Definition: dpo.c:137
dpo_id_t path_dpo
ID of the Data-path object.
Definition: load_balance.h:66
struct fib_path_t_::@133::@147 intf_rx
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
Definition: dpo.c:277
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
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:173
#define STRUCT_MARK_PTR(v, f)
Definition: clib.h:68
int fib_path_cmp(fib_node_index_t pi1, fib_node_index_t pi2)
Definition: fib_path.c:1621
A Drop path - resolve the path on the drop DPO.
Definition: fib_types.h:325
void bier_fmask_contribute_forwarding(index_t bfmi, dpo_id_t *dpo)
Definition: bier_fmask.c:120
struct fib_path_t_::@133::@141 bier_table
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:311
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:527
static int dpo_id_is_valid(const dpo_id_t *dpoi)
Return true if the DPO object is valid, i.e.
Definition: dpo.h:207
void fib_entry_get_prefix(fib_node_index_t fib_entry_index, fib_prefix_t *pfx)
Definition: fib_entry.c:1616
#define NULL
Definition: clib.h:55
A path that resolves via a BIER impostion object.
Definition: fib_types.h:358
struct fib_path_t_::@133::@138 attached
void fib_path_module_init(void)
Definition: fib_path.c:2648
int fib_path_is_exclusive(fib_node_index_t path_index)
Definition: fib_path.c:2537
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:419
void udp_encap_lock(u32 id)
Definition: udp_encap.c:200
static void fib_path_bier_fmask_update(fib_path_t *path, dpo_id_t *dpo)
Definition: fib_path.c:825
index_t frp_bier_imp
A path via a BIER imposition object.
Definition: fib_types.h:522
void bier_table_ecmp_unlock(index_t bti)
Definition: bier_table.c:426
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
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:359
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:538
fib_node_index_t fp_tbl_id
The FIB table index in which to find the next-hop.
Definition: fib_path.c:286
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:261
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
u32 dpo_get_urpf(const dpo_id_t *dpo)
Get a uRPF interface for the DPO.
Definition: dpo.c:381
#define STRUCT_MARK(mark)
Definition: clib.h:67
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:562
struct fib_path_t_::@133::@149 dvr
A path that resolves via a BIER [ECMP] Table.
Definition: fib_types.h:354
The path is resolved.
Definition: fib_path.c:153
format_function_t format_ip46_address
Definition: format.h:61
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:99
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:62
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)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
dpo_proto_t frp_proto
The protocol of the address below.
Definition: fib_types.h:460
bier_table_id_t frp_bier_tbl
A path that resolves via a BIER Table.
Definition: fib_types.h:516
A path that result in received traffic being recieved/recirculated so that it appears to have arrived...
Definition: fib_types.h:334
dpo_id_t fp_ex_dpo
The user provided &#39;exclusive&#39; DPO.
Definition: fib_path.c:329
int fib_path_is_looped(fib_node_index_t path_index)
Definition: fib_path.c:2570
Definition: fib_entry.h:272
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:276
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:227
struct fib_path_t_::@133::@137 attached_next_hop
The path has become a permanent drop.
Definition: fib_path.c:161
int fib_path_cmp_for_sort(void *v1, void *v2)
Definition: fib_path.c:1594
#define ip46_address_cmp(ip46_1, ip46_2)
Definition: ip6_packet.h:85
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:270
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:2501
struct fib_path_t_::@133::@139 recursive
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
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:494
A local path with a RPF-ID => multicast traffic.
Definition: fib_types.h:338
#define FIB_PATH_TYPES
Definition: fib_path.c:117
fib_path_type_t fp_type
The type of the path.
Definition: fib_path.c:223
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:490
mpls_eos_bit_t fp_eos
The EOS bit of the resolving label.
Definition: fib_path.c:279
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:407
static const adj_index_t fib_path_attached_next_hop_get_adj(fib_path_t *path, vnet_link_t link)
Definition: fib_path.c:635
void bier_table_contribute_forwarding(index_t bti, dpo_id_t *dpo)
Definition: bier_table.c:628
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
Recursion constraint of via a host prefix.
Definition: fib_types.h:309
struct fib_path_t_::@133::@148 udp_encap
fib_node_index_t fib_path_copy(fib_node_index_t path_index, fib_node_index_t path_list_index)
Definition: fib_path.c:1429
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
Aggregrate type for a prefix.
Definition: fib_types.h:188
fib_path_cfg_flags_t fp_cfg_flags
Configuration Flags.
Definition: fib_path.c:218
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:373
struct fib_path_t_::@133::@146 receive
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:202
interface receive.
Definition: fib_path.c:81
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:240
A path via a UDP encap object.
Definition: fib_types.h:346
dpo_id_t fp_dpo
The Data-path objects through which this path resolves for IP.
Definition: fib_path.c:392
struct fib_path_t_::@133::@145 exclusive
unsigned int u32
Definition: types.h:88
#define FIB_PATH_CFG_ATTRIBUTES
Definition: fib_path.h:97
Contribute an object that is to be used to forward Ethernet packets.
Definition: fib_types.h:131
struct fib_path_t_::@133::@140 bier_fmask
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:252
int load_balance_is_drop(const dpo_id_t *dpo)
Definition: load_balance.c:227
u16 fib_path_get_weight(fib_node_index_t path_index)
Definition: fib_path.c:2126
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.
static void fib_path_attached_next_hop_set(fib_path_t *path)
Definition: fib_path.c:662
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:1383
Definition: fib_entry.h:270
fib_rpf_id_t fp_rpf_id
The RPF-ID to tag the packets with.
Definition: fib_path.c:321
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:532
u8 * format_fib_path(u8 *s, va_list *args)
Definition: fib_path.c:455
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:168
u32 fp_sibling
the index of this path in the parent&#39;s child list.
Definition: fib_path.c:397
Contribute an object that is to be used to forward end-of-stack MPLS packets.
Definition: fib_types.h:119
fib_node_bw_reason_flag_t fnbw_reason
The reason/trigger for the backwalk.
Definition: fib_node.h:203
format_function_t format_mpls_eos_bit
Definition: mpls.h:67
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:461
int adj_is_up(adj_index_t ai)
Return true if the adjacency is &#39;UP&#39;, i.e.
Definition: adj.c:415
dpo_proto_t fp_nh_proto
The protocol of the next-hop, i.e.
Definition: fib_path.c:230
struct fib_path_t_ fib_path_t
A FIB path.
dpo_type_t dpoi_type
the type
Definition: dpo.h:172
int vnet_sw_interface_is_p2p(vnet_main_t *vnm, u32 sw_if_index)
Definition: interface.c:1257
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
adj_index_t fib_path_get_adj(fib_node_index_t path_index)
Definition: fib_path.c:2111
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:273
index_t fp_via_bier_tbl
the resolving bier-table
Definition: fib_path.c:382
Recursion constraint of via an attahced prefix.
Definition: fib_types.h:313
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:127
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:2240
fib_node_type_t fn_type
The node&#39;s type.
Definition: fib_node.h:290
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:286
static fib_path_t * fib_path_pool
Definition: fib_path.c:410
static fib_path_t * fib_path_get(fib_node_index_t index)
Definition: fib_path.c:430
ip46_address_t fp_nh
The next-hop.
Definition: fib_path.c:252
void dvr_dpo_add_or_lock(u32 sw_if_index, dpo_proto_t dproto, dpo_id_t *dpo)
Definition: dvr_dpo.c:87
u32 fib_entry_get_resolving_interface(fib_node_index_t entry_index)
Definition: fib_entry.c:1409
fib_path_oper_flags_t_
Path flags from the attributes.
Definition: fib_path.c:187
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:388
#define FOR_EACH_FIB_PATH_OPER_ATTRIBUTE(_item)
Definition: fib_path.c:179
#define MPLS_FIB_DEFAULT_TABLE_ID
Definition: mpls_fib.h:28
The path forms part of a recursive loop.
Definition: fib_path.c:149
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:308
fib_node_list_t fn_children
Vector of nodes that depend upon/use/share this node.
Definition: fib_node.h:300
vlib_main_t * vm
Definition: buffer.c:294
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:105
u8 * fib_path_format(fib_node_index_t pi, u8 *s)
Definition: fib_path.c:612
Contribute an object that is to be used to forward NSH packets.
Definition: fib_types.h:137
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
u32 fp_udp_encap_id
The UDP Encap object this path resolves through.
Definition: fib_path.c:351
static void fib_path_last_lock_gone(fib_node_t *node)
Definition: fib_path.c:629
static fib_node_index_t fib_path_get_index(fib_path_t *path)
Definition: fib_path.c:436
A FIB path.
Definition: fib_path.c:198
int fib_entry_recursive_loop_detect(fib_node_index_t entry_index, fib_node_index_t **entry_indicies)
Definition: fib_entry.c:1358
fib_node_get_t fnv_get
Definition: fib_node.h:274
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:386
u32 fib_path_get_rpf_id(fib_node_index_t path_index)
Definition: fib_path.c:2150
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
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:270
Don&#39;t resolve the path, use the DPO the client provides.
Definition: fib_types.h:329
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:79
static void fib_path_memory_show(void)
Definition: fib_path.c:1197
The path is attached, despite what the next-hop may say.
Definition: fib_path.c:157
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:185
void fib_prefix_from_mpls_label(mpls_label_t label, mpls_eos_bit_t eos, fib_prefix_t *prf)
Big train switch; FIB debugs on or off.
Definition: fib_types.c:93
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:962
Path resolves via a UDP encap object.
Definition: fib_path.c:85
enum lookup_input_t_ lookup_input_t
Switch to use the packet&#39;s source or destination address for lookup.
Context passed between object during a back walk.
Definition: fib_node.h:199
u32 fib_rpf_id_t
An RPF-ID is numerical value that is used RPF validate.
Definition: fib_types.h:376
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
u32 fp_pl_index
The index of the path-list to which this path belongs.
Definition: fib_path.c:207
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:720
static const adj_index_t fib_path_attached_get_adj(fib_path_t *path, vnet_link_t link)
Definition: fib_path.c:692
#define ASSERT(truth)
int fib_path_is_deag(fib_node_index_t path_index)
Definition: fib_path.c:2547
vnet_link_t dpo_proto_to_link(dpo_proto_t dp)
format a DPO protocol
Definition: dpo.c:117
fib_node_index_t fp_via_fib
the resolving via fib.
Definition: fib_path.c:378
long ctx[MAX_CONNS]
Definition: main.c:126
static int fib_path_is_permanent_drop(fib_path_t *path)
Definition: fib_path.c:850
fib_path_list_walk_rc_t fib_path_encode(fib_node_index_t path_list_index, fib_node_index_t path_index, void *ctx)
Definition: fib_path.c:2580
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:420
ip46_address_t fp_addr
The next-hop.
Definition: fib_path.c:339
static fib_forward_chain_type_t fib_path_to_chain_type(const fib_path_t *path)
Definition: fib_path.c:936
u8 frp_preference
A path preference.
Definition: fib_types.h:543
bier_table_id_t fp_bier_tbl
The BIER table&#39;s ID.
Definition: fib_path.c:303
uword hash_memory(void *p, word n_bytes, uword state)
Definition: hash.c:224
A deag path using the packet&#39;s source not destination address.
Definition: fib_types.h:342
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:547
u32 fp_interface
The interface.
Definition: fib_path.c:256
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:2654
A path that resolves via a BIER F-Mask.
Definition: fib_types.h:350
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:147
A path that resolves via another table.
Definition: fib_types.h:362
u32 entries
static uword vnet_sw_interface_is_admin_up(vnet_main_t *vnm, u32 sw_if_index)
format_function_t format_mpls_unicast_label
Definition: mpls.h:69
static void fib_path_unresolve(fib_path_t *path)
Definition: fib_path.c:862
mpls_label_t frp_local_label
The MPLS local Label to reursively resolve through.
Definition: fib_types.h:478
dpo_proto_t fib_path_get_proto(fib_node_index_t path_index)
Definition: fib_path.c:2638
fib_path_oper_flags_t fp_oper_flags
Memebers in this last section represent information that is dervied during resolution.
Definition: fib_path.c:371
int fib_path_is_recursive_constrained(fib_node_index_t path_index)
Definition: fib_path.c:2525
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:57
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:2043
struct fib_path_t_::@133::@143 deag
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:184
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
A for-us/local path.
Definition: fib_types.h:317
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:259
u16 fib_path_get_preference(fib_node_index_t path_index)
Definition: fib_path.c:2138
u64 uword
Definition: types.h:112
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:195
#define FIB_PATH_DBG(_p, _fmt, _args...)
Definition: fib_path.c:426
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:1249
u8 fp_weight
UCMP [unnormalised] weigth.
Definition: fib_path.c:235
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.
struct fib_path_t_::@133::@142 bier_imp
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:177
int fib_path_recursive_loop_detect(fib_node_index_t path_index, fib_node_index_t **entry_indicies)
Definition: fib_path.c:1744
A FIB graph nodes virtual function table.
Definition: fib_node.h:273
static fib_path_cfg_flags_t fib_path_route_flags_to_cfg_flags(const fib_route_path_t *rpath)
Definition: fib_path.c:1216
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:214
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:231
mpls_label_t fp_local_label
The local label to resolve through.
Definition: fib_path.c:275
#define vec_foreach(var, vec)
Vector iterator.
fib_route_path_t rpath
Definition: fib_types.h:565
fib_path_type_t_
Enurmeration of path types.
Definition: fib_path.c:49
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:108
void udp_encap_unlock_w_index(index_t uei)
Definition: udp_encap.c:213
Attached path.
Definition: fib_types.h:321
#define pool_foreach_index(i, v, body)
Iterate pool by index.
Definition: pool.h:485
u32 flags
Definition: vhost-user.h:77
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:242
u8 frp_weight
[un]equal cost path weight
Definition: fib_types.h:537
fib_source_t fib_entry_get_best_source(fib_node_index_t entry_index)
Definition: fib_entry.c:1419
u32 frp_udp_encap_id
UDP encap ID.
Definition: fib_types.h:527
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:86
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:123
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:501
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:681
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:286
void fib_path_destroy(fib_node_index_t path_index)
Definition: fib_path.c:1462
#define FOR_EACH_FIB_PATH_CFG_ATTRIBUTE(_item)
Definition: fib_path.h:109
static int fib_path_cmp_i(const fib_path_t *path1, const fib_path_t *path2)
Definition: fib_path.c:1501
void udp_encap_contribute_forwarding(u32 id, dpo_proto_t proto, dpo_id_t *dpo)
Definition: udp_encap.c:166
const ip46_address_t zero_addr
Definition: lookup.c:318
int fib_path_cmp_w_route_path(fib_node_index_t path_index, const fib_route_path_t *rpath)
Definition: fib_path.c:1633
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static fib_node_t * fib_path_get_node(fib_node_index_t index)
Definition: fib_path.c:442
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:290
fib_entry_flag_t fib_entry_get_flags(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:276
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128