FD.io VPP  v16.12-rc0-308-g931be3a
Vector Packet Processing
fib_entry_src.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <vnet/adj/adj.h>
17 #include <vnet/dpo/load_balance.h>
19 #include <vnet/dpo/drop_dpo.h>
20 
21 #include <vnet/fib/fib_entry_src.h>
22 #include <vnet/fib/fib_table.h>
23 #include <vnet/fib/fib_path_ext.h>
24 #include <vnet/fib/fib_urpf_list.h>
25 
26 /*
27  * per-source type vft
28  */
29 static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX];
30 
31 static fib_protocol_t
32 fib_entry_get_proto (const fib_entry_t * fib_entry)
33 {
34  return (fib_entry->fe_prefix.fp_proto);
35 }
36 
37 void
39  const fib_entry_src_vft_t *vft)
40 {
41  fib_entry_src_vft[source] = *vft;
42 }
43 
44 static int
46  void * v2)
47 {
48  fib_entry_src_t *esrc1 = v1, *esrc2 = v2;
49 
50  return (esrc1->fes_src - esrc2->fes_src);
51 }
52 
53 void
55  fib_source_t source)
56 
57 {
58  fib_entry_src_t esrc = {
60  .fes_flags = FIB_ENTRY_SRC_FLAG_NONE,
61  .fes_src = source,
62  };
63 
64  if (NULL != fib_entry_src_vft[source].fesv_init)
65  {
66  fib_entry_src_vft[source].fesv_init(&esrc);
67  }
68 
69  vec_add1(fib_entry->fe_srcs, esrc);
72 }
73 
74 static fib_entry_src_t *
75 fib_entry_src_find (const fib_entry_t *fib_entry,
76  fib_source_t source,
77  u32 *index)
78 
79 {
80  fib_entry_src_t *esrc;
81  int ii;
82 
83  ii = 0;
84  vec_foreach(esrc, fib_entry->fe_srcs)
85  {
86  if (esrc->fes_src == source)
87  {
88  if (NULL != index)
89  {
90  *index = ii;
91  }
92  return (esrc);
93  }
94  else
95  {
96  ii++;
97  }
98  }
99 
100  return (NULL);
101 }
102 
103 int
105  fib_source_t source)
106 {
107  fib_entry_t *fib_entry;
108 
109  fib_entry = fib_entry_get(fib_entry_index);
110 
111  return (NULL != fib_entry_src_find(fib_entry, source, NULL));
112 }
113 
114 static fib_entry_src_t *
116  fib_source_t source,
117  u32 *index)
118 {
119  fib_entry_src_t *esrc;
120 
121  esrc = fib_entry_src_find(fib_entry, source, NULL);
122 
123  if (NULL == esrc)
124  {
125  fib_entry_src_action_init(fib_entry, source);
126  }
127 
128  return (fib_entry_src_find(fib_entry, source, NULL));
129 }
130 
131 void
133  fib_source_t source)
134 
135 {
136  fib_entry_src_t *esrc;
137  u32 index = ~0;
138 
139  esrc = fib_entry_src_find(fib_entry, source, &index);
140 
141  ASSERT(NULL != esrc);
142 
143  if (NULL != fib_entry_src_vft[source].fesv_deinit)
144  {
145  fib_entry_src_vft[source].fesv_deinit(esrc);
146  }
147 
148  vec_free(esrc->fes_path_exts);
149  vec_del1(fib_entry->fe_srcs, index);
150 }
151 
154  fib_source_t source)
155 {
156  if (NULL != fib_entry_src_vft[source].fesv_cover_change)
157  {
158  return (fib_entry_src_vft[source].fesv_cover_change(
159  fib_entry_src_find(fib_entry, source, NULL),
160  fib_entry));
161  }
162 
164  .install = !0,
165  .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
166  };
167  return (res);
168 }
169 
172  fib_source_t source)
173 {
174  if (NULL != fib_entry_src_vft[source].fesv_cover_update)
175  {
176  return (fib_entry_src_vft[source].fesv_cover_update(
177  fib_entry_src_find(fib_entry, source, NULL),
178  fib_entry));
179  }
180 
182  .install = !0,
183  .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
184  };
185  return (res);
186 }
187 
189 {
196 
197 /**
198  * @brief Determine whether this FIB entry should use a load-balance MAP
199  * to support PIC edge fast convergence
200  */
203 {
204  /**
205  * We'll use a LB map is the path-list has recursive paths.
206  * recursive paths implies BGP, and hence scale.
207  */
208  if (ctx->is_recursive)
209  {
211  }
212  return (LOAD_BALANCE_FLAG_NONE);
213 }
214 
215 static int
217 {
218  return ((MPLS_LABEL_IS_REAL(label) ||
222 }
223 
224 static int
226  fib_node_index_t path_index,
227  void *arg)
228 {
230  fib_path_ext_t *path_ext;
231 
232  ctx = arg;
233 
234  /*
235  * if the path is not resolved, don't include it.
236  */
237  if (!fib_path_is_resolved(path_index))
238  {
239  return (!0);
240  }
241 
242  if (fib_path_is_recursive(path_index))
243  {
244  ctx->is_recursive = 1;
245  }
246 
247  /*
248  * get the matching path-extension for the path being visited.
249  */
250  vec_foreach(path_ext, ctx->esrc->fes_path_exts)
251  {
252  if (path_ext->fpe_path_index == path_index)
253  break;
254  }
255 
256  if (NULL != path_ext &&
257  path_ext->fpe_path_index == path_index &&
258  fib_entry_src_valid_out_label(path_ext->fpe_label))
259  {
260  /*
261  * found a matching extension. stack it to obtain the forwarding
262  * info for this path.
263  */
264  ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fct, ctx->next_hops);
265  }
266  else
267  {
269 
270  /*
271  * no extension => no out-going label for this path. that's OK
272  * in the case of an IP or EOS chain, but not for non-EOS
273  */
274  switch (ctx->fct)
275  {
278  /*
279  * EOS traffic with no label to stack, we need the IP Adj
280  */
281  vec_add2(ctx->next_hops, nh, 1);
282 
283  nh->path_index = path_index;
284  nh->path_weight = fib_path_get_weight(path_index);
285  fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
286 
287  break;
289  if (fib_path_is_exclusive(path_index) ||
290  fib_path_is_deag(path_index))
291  {
292  vec_add2(ctx->next_hops, nh, 1);
293 
294  nh->path_index = path_index;
295  nh->path_weight = fib_path_get_weight(path_index);
298  &nh->path_dpo);
299  }
300  break;
303  ASSERT(0);
304  break;
305  }
306  }
307 
308  return (!0);
309 }
310 
311 void
313  const fib_entry_src_t *esrc,
315  dpo_id_t *dpo_lb)
316 {
317  dpo_proto_t lb_proto;
318 
319  /*
320  * If the entry has path extensions then we construct a load-balance
321  * by stacking the extensions on the forwarding chains of the paths.
322  * Otherwise we use the load-balance of the path-list
323  */
325  .esrc = esrc,
326  .fib_entry = fib_entry,
327  .next_hops = NULL,
328  .is_recursive = 0,
329  .fct = fct,
330  };
331 
332  lb_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
333 
336  &ctx);
337 
339  {
340  /*
341  * the client provided the DPO that the entry should link to.
342  * all entries must link to a LB, so if it is an LB already
343  * then we can use it.
344  */
345  if ((1 == vec_len(ctx.next_hops)) &&
347  {
348  dpo_copy(dpo_lb, &ctx.next_hops[0].path_dpo);
349  dpo_reset(&ctx.next_hops[0].path_dpo);
350  return;
351  }
352  }
353 
354  if (!dpo_id_is_valid(dpo_lb))
355  {
356  /*
357  * first time create
358  */
359  flow_hash_config_t fhc;
360 
362  dpo_proto_to_fib(lb_proto));
363  dpo_set(dpo_lb,
365  lb_proto,
366  load_balance_create(0, lb_proto, fhc));
367  }
368 
370  ctx.next_hops,
372  vec_free(ctx.next_hops);
373 
374  /*
375  * if this entry is sourced by the uRPF-exempt source then we
376  * append the always present local0 interface (index 0) to the
377  * uRPF list so it is not empty. that way packets pass the loose check.
378  */
380 
383  (0 == fib_urpf_check_size(ui)))
384  {
385  /*
386  * The uRPF list we get from the path-list is shared by all
387  * other users of the list, but the uRPF exemption applies
388  * only to this prefix. So we need our own list.
389  */
391  fib_urpf_list_append(ui, 0);
392  fib_urpf_list_bake(ui);
393  load_balance_set_urpf(dpo_lb->dpoi_index, ui);
395  }
396  else
397  {
398  load_balance_set_urpf(dpo_lb->dpoi_index, ui);
399  }
400 }
401 
402 void
404  fib_source_t source)
405 {
406  /*
407  * Install the forwarding chain for the given source into the forwarding
408  * tables
409  */
412  int insert;
413 
414  fct = fib_entry_get_default_chain_type(fib_entry);
415  esrc = fib_entry_src_find(fib_entry, source, NULL);
416 
417  /*
418  * Every entry has its own load-balance object. All changes to the entry's
419  * forwarding result in an inplace modify of the load-balance. This means
420  * the load-balance object only needs to be added to the forwarding
421  * DB once, when it is created.
422  */
423  insert = !dpo_id_is_valid(&fib_entry->fe_lb[fct]);
424 
425  fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb[fct]);
426 
427  ASSERT(dpo_id_is_valid(&fib_entry->fe_lb[fct]));
428  FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb[fct]);
429 
430  /*
431  * insert the adj into the data-plane forwarding trie
432  */
433  if (insert)
434  {
436  &fib_entry->fe_prefix,
437  &fib_entry->fe_lb[fct]);
438  }
439 
440  if (FIB_FORW_CHAIN_TYPE_UNICAST_IP4 == fct ||
442  {
445  fct++)
446  {
447  /*
448  * if any of the other chain types are already created they will need
449  * updating too
450  */
451  if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
452  {
453  fib_entry_src_mk_lb(fib_entry,
454  esrc,
455  fct,
456  &fib_entry->fe_lb[fct]);
457  }
458  }
459  }
460 }
461 
462 void
464 {
466 
467  fct = fib_entry_get_default_chain_type(fib_entry);
468  /*
469  * uninstall the forwarding chain from the forwarding tables
470  */
471  FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
472  fib_entry->fe_adj_index);
473 
474  if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
475  {
477  fib_entry->fe_fib_index,
478  &fib_entry->fe_prefix,
479  &fib_entry->fe_lb[fct]);
480 
481  dpo_reset(&fib_entry->fe_lb[fct]);
482  }
483 }
484 
485 static void
487 {
488  fib_node_index_t *entries = NULL;
489 
490  fib_path_list_recursive_loop_detect(path_list_index, &entries);
491 
492  vec_free(entries);
493 }
494 
495 void
497  fib_source_t source)
498 
499 {
500  int houston_we_are_go_for_install;
502 
503  esrc = fib_entry_src_find(fib_entry, source, NULL);
504 
507 
509 
510  if (NULL != fib_entry_src_vft[source].fesv_activate)
511  {
512  houston_we_are_go_for_install =
513  fib_entry_src_vft[source].fesv_activate(esrc, fib_entry);
514  }
515  else
516  {
517  /*
518  * the source is not providing an activate function, we'll assume
519  * therefore it has no objection to installing the entry
520  */
521  houston_we_are_go_for_install = !0;
522  }
523 
524  /*
525  * link to the path-list provided by the source, and go check
526  * if that forms any loops in the graph.
527  */
528  fib_entry->fe_parent = esrc->fes_pl;
529  fib_entry->fe_sibling =
532  fib_entry_get_index(fib_entry));
533 
535 
536  FIB_ENTRY_DBG(fib_entry, "activate: %d",
537  fib_entry->fe_parent);
538 
539  if (0 != houston_we_are_go_for_install)
540  {
541  fib_entry_src_action_install(fib_entry, source);
542  }
543  else
544  {
546  }
547 }
548 
549 void
551  fib_source_t source)
552 
553 {
554  fib_node_index_t path_list_index;
556 
557  esrc = fib_entry_src_find(fib_entry, source, NULL);
558 
560 
561  if (NULL != fib_entry_src_vft[source].fesv_deactivate)
562  {
563  fib_entry_src_vft[source].fesv_deactivate(esrc, fib_entry);
564  }
565 
567 
568  FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
569 
570  /*
571  * un-link from an old path-list. Check for any loops this will clear
572  */
573  path_list_index = fib_entry->fe_parent;
574  fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
575 
576  fib_entry_recursive_loop_detect_i(path_list_index);
577 
578  /*
579  * this will unlock the path-list, so it may be invalid thereafter.
580  */
581  fib_path_list_child_remove(path_list_index, fib_entry->fe_sibling);
582  fib_entry->fe_sibling = FIB_NODE_INDEX_INVALID;
583 }
584 
585 static void
587  fib_source_t source)
588 {
590 
591  vec_foreach(esrc, fib_entry->fe_srcs)
592  {
593  if (NULL != fib_entry_src_vft[esrc->fes_src].fesv_fwd_update)
594  {
595  fib_entry_src_vft[esrc->fes_src].fesv_fwd_update(esrc,
596  fib_entry,
597  source);
598  }
599  }
600 }
601 
602 void
604  fib_source_t source)
605 {
606  fib_node_index_t path_list_index;
608 
609  esrc = fib_entry_src_find(fib_entry, source, NULL);
610 
612 
613  FIB_ENTRY_DBG(fib_entry, "reactivate: %d to %d",
614  fib_entry->fe_parent,
615  esrc->fes_pl);
616 
617  if (fib_entry->fe_parent != esrc->fes_pl)
618  {
619  /*
620  * un-link from an old path-list. Check for any loops this will clear
621  */
622  path_list_index = fib_entry->fe_parent;
623  fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
624 
625  /*
626  * temporary lock so it doesn't get deleted when this entry is no
627  * longer a child.
628  */
629  fib_path_list_lock(path_list_index);
630 
631  /*
632  * this entry is no longer a child. after unlinking check if any loops
633  * were broken
634  */
635  fib_path_list_child_remove(path_list_index,
636  fib_entry->fe_sibling);
637 
638  fib_entry_recursive_loop_detect_i(path_list_index);
639 
640  /*
641  * link to the path-list provided by the source, and go check
642  * if that forms any loops in the graph.
643  */
644  fib_entry->fe_parent = esrc->fes_pl;
645  fib_entry->fe_sibling =
648  fib_entry_get_index(fib_entry));
649 
651  fib_path_list_unlock(path_list_index);
652  }
653  fib_entry_src_action_install(fib_entry, source);
654  fib_entry_src_action_fwd_update(fib_entry, source);
655 }
656 
657 void
659  fib_source_t source)
660 {
662 
663  esrc = fib_entry_src_find(fib_entry, source, NULL);
664 
665  if (NULL != fib_entry_src_vft[source].fesv_installed)
666  {
667  fib_entry_src_vft[source].fesv_installed(esrc,
668  fib_entry);
669  }
670 
671  fib_entry_src_action_fwd_update(fib_entry, source);
672 }
673 
674 /*
675  * fib_entry_src_action_add
676  *
677  * Adding a source can result in a new fib_entry being created, which
678  * can inturn mean the pool is realloc'd and thus the entry passed as
679  * an argument it also realloc'd
680  * @return the original entry
681  */
682 fib_entry_t *
684  fib_source_t source,
686  const dpo_id_t *dpo)
687 {
688  fib_node_index_t fib_entry_index;
690 
691  esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
692 
693  esrc->fes_ref_count++;
694 
695  if (1 != esrc->fes_ref_count)
696  {
697  /*
698  * we only want to add the source on the 0->1 transition
699  */
700  return (fib_entry);
701  }
702 
703  esrc->fes_entry_flags = flags;
704 
705  /*
706  * save variable so we can recover from a fib_entry realloc.
707  */
708  fib_entry_index = fib_entry_get_index(fib_entry);
709 
710  if (NULL != fib_entry_src_vft[source].fesv_add)
711  {
712  fib_entry_src_vft[source].fesv_add(esrc,
713  fib_entry,
714  flags,
715  fib_entry_get_proto(fib_entry),
716  dpo);
717  }
718 
719  fib_entry = fib_entry_get(fib_entry_index);
720 
722 
723  fib_path_list_lock(esrc->fes_pl);
724 
725  /*
726  * the source owns a lock on the entry
727  */
729 
730  return (fib_entry);
731 }
732 
733 /*
734  * fib_entry_src_action_update
735  *
736  * Adding a source can result in a new fib_entry being created, which
737  * can inturn mean the pool is realloc'd and thus the entry passed as
738  * an argument it also realloc'd
739  * @return the original entry
740  */
741 fib_entry_t *
743  fib_source_t source,
745  const dpo_id_t *dpo)
746 {
747  fib_node_index_t fib_entry_index, old_path_list_index;
749 
750  esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
751 
752  if (NULL == esrc)
753  return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
754 
755  old_path_list_index = esrc->fes_pl;
756  esrc->fes_entry_flags = flags;
757 
758  /*
759  * save variable so we can recover from a fib_entry realloc.
760  */
761  fib_entry_index = fib_entry_get_index(fib_entry);
762 
763  if (NULL != fib_entry_src_vft[source].fesv_add)
764  {
765  fib_entry_src_vft[source].fesv_add(esrc,
766  fib_entry,
767  flags,
768  fib_entry_get_proto(fib_entry),
769  dpo);
770  }
771 
772  fib_entry = fib_entry_get(fib_entry_index);
773 
775 
776  fib_path_list_lock(esrc->fes_pl);
777  fib_path_list_unlock(old_path_list_index);
778 
779  return (fib_entry);
780 }
781 
782 
785  fib_source_t source)
786 
787 {
788  fib_node_index_t old_path_list;
789  fib_entry_src_flag_t sflags;
791 
792  esrc = fib_entry_src_find(fib_entry, source, NULL);
793 
794  if (NULL == esrc)
795  return (FIB_ENTRY_SRC_FLAG_ACTIVE);
796 
797  esrc->fes_ref_count--;
798  sflags = esrc->fes_flags;
799 
800  if (0 != esrc->fes_ref_count)
801  {
802  /*
803  * only remove the source on the 1->0 transisition
804  */
805  return (sflags);
806  }
807 
809  {
810  fib_entry_src_action_deactivate(fib_entry, source);
811  }
812 
813  old_path_list = esrc->fes_pl;
814 
815  if (NULL != fib_entry_src_vft[source].fesv_remove)
816  {
817  fib_entry_src_vft[source].fesv_remove(esrc);
818  }
819 
820  fib_path_list_unlock(old_path_list);
822 
823  sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED;
824  fib_entry_src_action_deinit(fib_entry, source);
825 
826  return (sflags);
827 }
828 
829 static inline int
831  const fib_route_path_t *rpath)
832 {
833  /*
834  * not all zeros next hop &&
835  * is recursive path &&
836  * nexthop is same as the route's address
837  */
838  return ((!ip46_address_is_zero(&rpath->frp_addr)) &&
839  (~0 == rpath->frp_sw_if_index) &&
840  (0 == ip46_address_cmp(&rpath->frp_addr, &prefix->fp_addr)));
841 
842 }
843 
844 /*
845  * fib_route_attached_cross_table
846  *
847  * Return true the the route is attached via an interface that
848  * is not in the same table as the route
849  */
850 static inline int
852  const fib_route_path_t *rpath)
853 {
854  /*
855  * - All zeros next-hop
856  * - a valid interface
857  * - entry's fib index not equeal to interface's index
858  */
859  if (ip46_address_is_zero(&rpath->frp_addr) &&
860  (~0 != rpath->frp_sw_if_index) &&
861  (fib_entry->fe_fib_index !=
863  rpath->frp_sw_if_index)))
864  {
865  return (!0);
866  }
867  return (0);
868 }
869 
870 /*
871  * fib_route_attached_cross_table
872  *
873  * Return true the the route is attached via an interface that
874  * is not in the same table as the route
875  */
876 static inline int
878 {
879  /*
880  * - All zeros next-hop
881  * - a valid interface
882  */
883  if (ip46_address_is_zero(&rpath->frp_addr) &&
884  (~0 != rpath->frp_sw_if_index))
885  {
886  return (!0);
887  }
888  return (0);
889 }
890 
893 {
895 
896  if (eflags & FIB_ENTRY_FLAG_DROP)
897  {
899  }
900  if (eflags & FIB_ENTRY_FLAG_LOCAL)
901  {
903  }
904  if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
905  {
907  }
908 
909  return (plf);
910 }
911 
912 static void
914  const fib_route_path_t *rpath,
915  fib_path_list_flags_t *pl_flags,
917 {
918  /*
919  * don't allow the addition of a recursive looped path for prefix
920  * via itself.
921  */
922  if (fib_route_recurses_via_self(&fib_entry->fe_prefix, rpath))
923  {
924  /*
925  * force the install of a drop path-list.
926  * we want the entry to have some path-list, mainly so
927  * the dodgy path can be rmeoved when the source stops playing
928  * silly buggers.
929  */
930  *pl_flags |= FIB_PATH_LIST_FLAG_DROP;
931  }
932  else
933  {
934  *pl_flags &= ~FIB_PATH_LIST_FLAG_DROP;
935  }
936 
937  if ((esrc->fes_src == FIB_SOURCE_API) ||
938  (esrc->fes_src == FIB_SOURCE_CLI))
939  {
940  if (fib_path_is_attached(rpath))
941  {
943  }
944  else
945  {
947  }
948  }
949  if (fib_route_attached_cross_table(fib_entry, rpath))
950  {
952  }
953  else
954  {
956  }
957 }
958 
959 /*
960  * fib_entry_src_path_ext_add
961  *
962  * append a path extension to the entry's list
963  */
964 static void
966  const fib_route_path_t *rpath)
967 {
968  if (MPLS_LABEL_INVALID != rpath->frp_label)
969  {
970  fib_path_ext_t *path_ext;
971 
972  vec_add2(esrc->fes_path_exts, path_ext, 1);
973 
974  fib_path_ext_init(path_ext, esrc->fes_pl, rpath);
975  }
976 }
977 
978 /*
979  * fib_entry_src_path_ext_insert
980  *
981  * insert, sorted, a path extension to the entry's list.
982  * It's not strictly necessary in sort the path extensions, since each
983  * extension has the path index to which it resolves. However, by being
984  * sorted the load-balance produced has a deterministic order, not an order
985  * based on the sequence of extension additions. this is a considerable benefit.
986  */
987 static void
989  const fib_route_path_t *rpath)
990 {
991  if (0 == vec_len(esrc->fes_path_exts))
992  return (fib_entry_src_path_ext_append(esrc, rpath));
993 
994  if (MPLS_LABEL_INVALID != rpath->frp_label)
995  {
996  fib_path_ext_t path_ext;
997  int i = 0;
998 
999  fib_path_ext_init(&path_ext, esrc->fes_pl, rpath);
1000 
1001  while (i < vec_len(esrc->fes_path_exts) &&
1002  (fib_path_ext_cmp(&esrc->fes_path_exts[i], rpath) < 0))
1003  {
1004  i++;
1005  }
1006 
1007  vec_insert_elts(esrc->fes_path_exts, &path_ext, 1, i);
1008  }
1009 }
1010 
1011 /*
1012  * fib_entry_src_action_add
1013  *
1014  * Adding a source can result in a new fib_entry being created, which
1015  * can inturn mean the pool is realloc'd and thus the entry passed as
1016  * an argument it also realloc'd
1017  * @return the entry
1018  */
1019 fib_entry_t*
1021  fib_source_t source,
1023  const fib_route_path_t *rpath)
1024 {
1025  fib_node_index_t old_path_list, fib_entry_index;
1026  fib_path_list_flags_t pl_flags;
1027  fib_path_ext_t *path_ext;
1029 
1030  /*
1031  * save variable so we can recover from a fib_entry realloc.
1032  */
1033  fib_entry_index = fib_entry_get_index(fib_entry);
1034 
1035  esrc = fib_entry_src_find(fib_entry, source, NULL);
1036  if (NULL == esrc)
1037  {
1038  fib_entry =
1039  fib_entry_src_action_add(fib_entry,
1040  source,
1041  flags,
1042  drop_dpo_get(
1044  fib_entry_get_proto(fib_entry))));
1045  esrc = fib_entry_src_find(fib_entry, source, NULL);
1046  }
1047 
1048  /*
1049  * we are no doubt modifying a path-list. If the path-list
1050  * is shared, and hence not modifiable, then the index returned
1051  * will be for a different path-list. This FIB entry to needs
1052  * to maintain its lock appropriately.
1053  */
1054  old_path_list = esrc->fes_pl;
1055 
1056  ASSERT(NULL != fib_entry_src_vft[source].fesv_path_add);
1057 
1059  fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1060 
1061  fib_entry_src_vft[source].fesv_path_add(esrc, fib_entry, pl_flags, rpath);
1062  fib_entry = fib_entry_get(fib_entry_index);
1063 
1064  /*
1065  * re-resolve all the path-extensions with the new path-list
1066  */
1067  vec_foreach(path_ext, esrc->fes_path_exts)
1068  {
1069  fib_path_ext_resolve(path_ext, esrc->fes_pl);
1070  }
1071  /*
1072  * if the path has a label we need to add a path extension
1073  */
1074  fib_entry_src_path_ext_insert(esrc, rpath);
1075 
1076  fib_path_list_lock(esrc->fes_pl);
1077  fib_path_list_unlock(old_path_list);
1078 
1079  return (fib_entry);
1080 }
1081 
1082 /*
1083  * fib_entry_src_action_swap
1084  *
1085  * The source is providing new paths to replace the old ones.
1086  * Adding a source can result in a new fib_entry being created, which
1087  * can inturn mean the pool is realloc'd and thus the entry passed as
1088  * an argument it also realloc'd
1089  * @return the entry
1090  */
1091 fib_entry_t*
1093  fib_source_t source,
1095  const fib_route_path_t *rpaths)
1096 {
1097  fib_node_index_t old_path_list, fib_entry_index;
1098  fib_path_list_flags_t pl_flags;
1099  const fib_route_path_t *rpath;
1101 
1102  esrc = fib_entry_src_find(fib_entry, source, NULL);
1103 
1104  /*
1105  * save variable so we can recover from a fib_entry realloc.
1106  */
1107  fib_entry_index = fib_entry_get_index(fib_entry);
1108 
1109  if (NULL == esrc)
1110  {
1111  fib_entry = fib_entry_src_action_add(fib_entry,
1112  source,
1113  flags,
1114  drop_dpo_get(
1116  fib_entry_get_proto(fib_entry))));
1117  esrc = fib_entry_src_find(fib_entry, source, NULL);
1118  }
1119 
1120  /*
1121  * swapping paths may create a new path-list (or may use an existing shared)
1122  * but we are certainly getting a different one. This FIB entry to needs
1123  * to maintain its lock appropriately.
1124  */
1125  old_path_list = esrc->fes_pl;
1126 
1127  ASSERT(NULL != fib_entry_src_vft[source].fesv_path_swap);
1128 
1129  pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
1130 
1131  vec_foreach(rpath, rpaths)
1132  {
1133  fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1134  }
1135 
1136  fib_entry_src_vft[source].fesv_path_swap(esrc,
1137  fib_entry,
1138  pl_flags,
1139  rpaths);
1140 
1141  vec_free(esrc->fes_path_exts);
1142  vec_foreach(rpath, rpaths)
1143  {
1144  fib_entry_src_path_ext_append(esrc, rpath);
1145  }
1146 
1147  fib_entry = fib_entry_get(fib_entry_index);
1148 
1149  fib_path_list_lock(esrc->fes_pl);
1150  fib_path_list_unlock(old_path_list);
1151 
1152  return (fib_entry);
1153 }
1154 
1157  fib_source_t source,
1158  const fib_route_path_t *rpath)
1159 {
1160  fib_path_list_flags_t pl_flags;
1161  fib_node_index_t old_path_list;
1162  fib_path_ext_t *path_ext;
1164 
1165  esrc = fib_entry_src_find(fib_entry, source, NULL);
1166 
1167  ASSERT(NULL != esrc);
1169 
1170  /*
1171  * we no doubt modifying a path-list. If the path-list
1172  * is shared, and hence not modifiable, then the index returned
1173  * will be for a different path-list. This FIB entry to needs
1174  * to maintain its lock appropriately.
1175  */
1176  old_path_list = esrc->fes_pl;
1177 
1178  ASSERT(NULL != fib_entry_src_vft[source].fesv_path_remove);
1179 
1181  fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1182 
1183  fib_entry_src_vft[source].fesv_path_remove(esrc, pl_flags, rpath);
1184  /*
1185  * find the matching path extension and remove it
1186  */
1187  vec_foreach(path_ext, esrc->fes_path_exts)
1188  {
1189  if (!fib_path_ext_cmp(path_ext, rpath))
1190  {
1191  /*
1192  * delete the element moving the remaining elements down 1 position.
1193  * this preserves the sorted order.
1194  */
1195  vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
1196  break;
1197  }
1198  }
1199  /*
1200  * re-resolve all the path-extensions with the new path-list
1201  */
1202  vec_foreach(path_ext, esrc->fes_path_exts)
1203  {
1204  fib_path_ext_resolve(path_ext, esrc->fes_pl);
1205  }
1206 
1207  /*
1208  * lock the new path-list, unlock the old if it had one
1209  */
1210  fib_path_list_unlock(old_path_list);
1211 
1212  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) {
1213  fib_path_list_lock(esrc->fes_pl);
1214  return (FIB_ENTRY_SRC_FLAG_ADDED);
1215  }
1216  else
1217  {
1218  /*
1219  * no more paths left from this source
1220  */
1221  fib_entry_src_action_remove(fib_entry, source);
1222  return (FIB_ENTRY_SRC_FLAG_NONE);
1223  }
1224 }
1225 
1226 u8*
1228  fib_source_t source,
1229  u8* s)
1230 {
1232 
1233  esrc = fib_entry_src_find(fib_entry, source, NULL);
1234 
1235  if (NULL != fib_entry_src_vft[source].fesv_format)
1236  {
1237  return (fib_entry_src_vft[source].fesv_format(esrc, s));
1238  }
1239  return (s);
1240 }
1241 
1244  fib_source_t source)
1245 {
1248 
1249  if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1250  return (ADJ_INDEX_INVALID);
1251 
1252  fib_entry = fib_entry_get(fib_entry_index);
1253  esrc = fib_entry_src_find(fib_entry, source, NULL);
1254 
1255  if (NULL != esrc)
1256  {
1257  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1258  {
1259  return (fib_path_list_get_adj(
1260  esrc->fes_pl,
1261  fib_entry_get_default_chain_type(fib_entry)));
1262  }
1263  }
1264  return (ADJ_INDEX_INVALID);
1265 }
1266 
1267 const int
1269  fib_source_t source,
1270  dpo_id_t *dpo)
1271 {
1274 
1275  if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1276  return (0);
1277 
1278  fib_entry = fib_entry_get(fib_entry_index);
1279  esrc = fib_entry_src_find(fib_entry, source, NULL);
1280 
1281  if (NULL != esrc)
1282  {
1283  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1284  {
1286  esrc->fes_pl,
1288  dpo);
1289 
1290  return (dpo_id_is_valid(dpo));
1291  }
1292  }
1293  return (0);
1294 }
1295 
1296 u32
1298  fib_source_t source)
1299 {
1302 
1303  fib_entry = fib_entry_get(entry_index);
1304 
1305  esrc = fib_entry_src_find(fib_entry, source, NULL);
1306 
1307  if (NULL != esrc)
1308  {
1309  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1310  {
1312  }
1313  }
1314  return (~0);
1315 }
1316 
1319  fib_source_t source)
1320 {
1323 
1324  fib_entry = fib_entry_get(entry_index);
1325 
1326  esrc = fib_entry_src_find(fib_entry, source, NULL);
1327 
1328  if (NULL != esrc)
1329  {
1330  return (esrc->fes_entry_flags);
1331  }
1332 
1333  return (FIB_ENTRY_FLAG_NONE);
1334 }
1335 
1338 {
1340 
1341  /*
1342  * the vector of sources is deliberately arranged in priority order
1343  */
1344  if (0 == vec_len(fib_entry->fe_srcs))
1345  {
1346  flags = FIB_ENTRY_FLAG_NONE;
1347  }
1348  else
1349  {
1351 
1352  esrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
1353  flags = esrc->fes_entry_flags;
1354  }
1355 
1356  return (flags);
1357 }
1358 
1359 void
1361  fib_source_t source,
1362  const void *data)
1363 {
1366 
1367  fib_entry = fib_entry_get(fib_entry_index);
1368  esrc = fib_entry_src_find(fib_entry, source, NULL);
1369 
1370  if (NULL != esrc &&
1371  NULL != fib_entry_src_vft[source].fesv_set_data)
1372  {
1373  fib_entry_src_vft[source].fesv_set_data(esrc, fib_entry, data);
1374  }
1375 }
1376 
1377 const void*
1379  fib_source_t source)
1380 {
1383 
1384  fib_entry = fib_entry_get(fib_entry_index);
1385  esrc = fib_entry_src_find(fib_entry, source, NULL);
1386 
1387  if (NULL != esrc &&
1388  NULL != fib_entry_src_vft[source].fesv_get_data)
1389  {
1390  return (fib_entry_src_vft[source].fesv_get_data(esrc, fib_entry));
1391  }
1392  return (NULL);
1393 }
1394 
1395 void
1397 {
1406 }
static int fib_entry_src_cmp_for_sort(void *v1, void *v2)
Definition: fib_entry_src.c:45
fib_entry_src_cover_res_t fib_entry_src_action_cover_change(fib_entry_t *fib_entry, fib_source_t source)
int fib_path_is_resolved(fib_node_index_t path_index)
Definition: fib_path.c:1785
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:158
fib_entry_src_init_t fesv_init
#define FIB_ENTRY_DBG(_e, _fmt, _args...)
Debug macro.
Definition: fib_entry_src.h:42
ip46_address_t frp_addr
The next-hop address.
Definition: fib_types.h:295
void fib_table_fwding_dpo_remove(u32 fib_index, const fib_prefix_t *prefix, const dpo_id_t *dpo)
remove an entry in the FIB&#39;s forwarding table
Definition: fib_table.c:261
void fib_entry_unlock(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1460
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:89
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
An entry in a FIB table.
Definition: fib_entry.h:360
fib_node_index_t path_index
The index of the FIB path.
Definition: load_balance.h:70
static int fib_entry_src_valid_out_label(mpls_label_t label)
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:1626
int is_recursive
fib_entry_src_set_data_t fesv_set_data
struct fib_entry_src_collect_forwarding_ctx_t_ fib_entry_src_collect_forwarding_ctx_t
static int fib_urpf_check_size(index_t ui)
Data-Plane function to check the size of an uRPF list, (i.e.
void fib_path_list_child_remove(fib_node_index_t path_list_index, u32 si)
void fib_path_ext_resolve(fib_path_ext_t *path_ext, fib_node_index_t path_list_index)
Definition: fib_path_ext.c:66
fib_entry_flag_t fib_entry_get_flags_i(const fib_entry_t *fib_entry)
A representation of a path as described by a route producer.
Definition: fib_types.h:283
int fib_path_ext_cmp(fib_path_ext_t *path_ext, const fib_route_path_t *rpath)
Definition: fib_path_ext.c:42
dpo_id_t path_dpo
ID of the Data-path object.
Definition: load_balance.h:65
fib_forward_chain_type_t fct
static void fib_entry_src_action_fwd_update(const fib_entry_t *fib_entry, fib_source_t source)
adj_index_t fib_path_list_get_adj(fib_node_index_t path_list_index, fib_forward_chain_type_t type)
Virtual function table each FIB entry source will register.
u32 fib_path_list_get_resolving_interface(fib_node_index_t path_list_index)
Definition: fib_entry.h:256
static int dpo_id_is_valid(const dpo_id_t *dpoi)
Return true if the DPO object is valid, i.e.
Definition: dpo.h:170
static fib_entry_src_t * fib_entry_src_find_or_create(fib_entry_t *fib_entry, fib_source_t source, u32 *index)
#define NULL
Definition: clib.h:55
Information related to the source of a FIB entry.
Definition: fib_entry.h:269
u32 fib_table_get_index_for_sw_if_index(fib_protocol_t proto, u32 sw_if_index)
Get the index of the FIB bound to the interface.
Definition: fib_table.c:887
Definition: fib_entry.h:221
void load_balance_set_urpf(index_t lbi, index_t urpf)
Definition: load_balance.c:242
int fib_path_is_exclusive(fib_node_index_t path_index)
Definition: fib_path.c:1765
void fib_entry_src_action_deactivate(fib_entry_t *fib_entry, fib_source_t source)
load_balance_path_t * next_hops
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
#define MPLS_IETF_IMPLICIT_NULL_LABEL
Definition: mpls_types.h:16
From the CLI.
Definition: fib_entry.h:61
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:196
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:521
Result from a cover update/change.
Definition: fib_entry_src.h:87
void fib_path_list_walk(fib_node_index_t path_list_index, fib_path_list_walk_fn_t func, void *ctx)
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:85
u32 fe_fib_index
The index of the FIB table this entry is in.
Definition: fib_entry.h:372
uRPF bypass/exemption.
Definition: fib_entry.h:109
Definition: fib_entry.h:217
fib_entry_src_t * fe_srcs
Vector of source infos.
Definition: fib_entry.h:391
static void fib_entry_recursive_loop_detect_i(fib_node_index_t path_list_index)
void fib_entry_src_action_deinit(fib_entry_t *fib_entry, fib_source_t source)
u32 fib_path_list_child_add(fib_node_index_t path_list_index, fib_node_type_t child_type, fib_node_index_t child_index)
#define ip46_address_cmp(ip46_1, ip46_2)
Definition: ip6_packet.h:73
fib_node_index_t fe_parent
the path-list for which this entry is a child.
Definition: fib_entry.h:396
void fib_entry_src_mpls_register(void)
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
flow_hash_config_t fib_table_get_flow_hash_config(u32 fib_index, fib_protocol_t proto)
Get the flow hash configured used by the table.
Definition: fib_table.c:903
index_t load_balance_create(u32 n_buckets, dpo_proto_t lb_proto, flow_hash_config_t fhc)
Definition: load_balance.c:192
void fib_path_ext_init(fib_path_ext_t *path_ext, fib_node_index_t path_list_index, const fib_route_path_t *rpath)
Definition: fib_path_ext.c:79
const dpo_id_t * drop_dpo_get(dpo_proto_t proto)
Definition: drop_dpo.c:25
void fib_entry_src_adj_register(void)
u32 fe_sibling
index of this entry in the parent&#39;s child list.
Definition: fib_entry.h:402
fib_entry_flag_t fib_entry_get_flags_for_source(fib_node_index_t entry_index, fib_source_t source)
const int fib_entry_get_dpo_for_source(fib_node_index_t fib_entry_index, fib_source_t source, dpo_id_t *dpo)
u32 fib_entry_get_resolving_interface_for_source(fib_node_index_t entry_index, fib_source_t source)
void fib_entry_src_lisp_register(void)
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:300
fib_entry_src_flag_t fib_entry_src_action_path_remove(fib_entry_t *fib_entry, fib_source_t source, const fib_route_path_t *rpath)
fib_entry_t * fib_entry_src_action_path_add(fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const fib_route_path_t *rpath)
index_t fib_urpf_list_alloc_and_lock(void)
Definition: fib_urpf_list.c:47
void load_balance_multipath_update(const dpo_id_t *dpo, load_balance_path_t *raw_next_hops, load_balance_flags_t flags)
Definition: load_balance.c:456
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
Aggregrate type for a prefix.
Definition: fib_types.h:149
fib_entry_src_path_add_t fesv_path_add
fib_node_index_t fib_entry_get_index(const fib_entry_t *fib_entry)
Definition: fib_entry.c:56
Contribute an object that is to be used to forward Ethernet packets.
Definition: fib_types.h:107
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:238
void fib_entry_src_api_register(void)
void fib_urpf_list_append(index_t ui, u32 sw_if_index)
Append another interface to the list.
Definition: fib_urpf_list.c:92
static void fib_entry_src_path_ext_insert(fib_entry_src_t *esrc, const fib_route_path_t *rpath)
u16 install
Definition: fib_entry_src.h:88
Definition: fib_entry.h:215
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:138
Contribute an object that is to be used to forward end-of-stack MPLS packets.
Definition: fib_types.h:101
Definition: fib_entry.h:220
void fib_entry_src_mk_lb(fib_entry_t *fib_entry, const fib_entry_src_t *esrc, fib_forward_chain_type_t fct, dpo_id_t *dpo_lb)
void fib_entry_src_default_route_register(void)
Definition: fib_entry.h:219
#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
fib_entry_t * fib_entry_src_action_add(fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
struct fib_path_ext_t_ * fes_path_exts
A vector of path extensions.
Definition: fib_entry.h:273
static int fib_route_attached_cross_table(const fib_entry_t *fib_entry, const fib_route_path_t *rpath)
enum fib_source_t_ fib_source_t
The different sources that can create a route.
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:172
fib_entry_src_fwd_update_t fesv_fwd_update
fib_entry_src_deinit_t fesv_deinit
dpo_type_t dpoi_type
the type
Definition: dpo.h:142
load-balancing over a choice of [un]equal cost paths
Definition: dpo.h:102
#define MPLS_LABEL_IS_REAL(_lbl)
Definition: mpls_types.h:35
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:765
void fib_table_fwding_dpo_update(u32 fib_index, const fib_prefix_t *prefix, const dpo_id_t *dpo)
Add or update an entry in the FIB&#39;s forwarding table.
Definition: fib_table.c:234
void fib_path_list_lock(fib_node_index_t path_list_index)
static fib_entry_src_t * fib_entry_src_find(const fib_entry_t *fib_entry, fib_source_t source, u32 *index)
Definition: fib_entry_src.c:75
#define FIB_SOURCE_MAX
The maximum number of sources.
Definition: fib_entry.h:129
void fib_entry_src_action_init(fib_entry_t *fib_entry, fib_source_t source)
Definition: fib_entry_src.c:54
fib_prefix_t fe_prefix
The prefix of the route.
Definition: fib_entry.h:368
enum load_balance_flags_t_ load_balance_flags_t
Flags controlling load-balance creation and modification.
fib_entry_src_flag_t fib_entry_src_action_remove(fib_entry_t *fib_entry, fib_source_t source)
static void fib_entry_flags_update(const fib_entry_t *fib_entry, const fib_route_path_t *rpath, fib_path_list_flags_t *pl_flags, fib_entry_src_t *esrc)
int fib_path_is_recursive(fib_node_index_t path_index)
Definition: fib_path.c:1755
void fib_entry_src_action_installed(const fib_entry_t *fib_entry, fib_source_t source)
Definition: fib_entry.h:254
#define MPLS_LABEL_INVALID
Definition: mpls_types.h:33
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
void fib_entry_src_action_activate(fib_entry_t *fib_entry, fib_source_t source)
void fib_urpf_list_bake(index_t ui)
Convert the uRPF list from the itf set obtained during the walk to a unique list. ...
void fib_entry_src_rr_register(void)
#define MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL
Definition: mpls_types.h:13
fib_path_list_flags_t fib_entry_src_flags_2_path_list_flags(fib_entry_flag_t eflags)
fib_entry_src_remove_t fesv_remove
Definition: fib_entry.h:218
fib_entry_src_deactivate_t fesv_deactivate
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
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:134
void fib_path_list_unlock(fib_node_index_t path_list_index)
fib_entry_t * fib_entry_get(fib_node_index_t index)
Definition: fib_entry.c:44
void fib_entry_src_interface_register(void)
void fib_entry_lock(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1450
enum fib_entry_flag_t_ fib_entry_flag_t
int fib_path_list_recursive_loop_detect(fib_node_index_t path_list_index, fib_node_index_t **entry_indicies)
fib_entry_flag_t fes_entry_flags
Flags the source contributes to the entry.
Definition: fib_entry.h:298
static fib_protocol_t fib_entry_get_proto(const fib_entry_t *fib_entry)
Definition: fib_entry_src.c:32
static void fib_entry_src_path_ext_append(fib_entry_src_t *esrc, const fib_route_path_t *rpath)
fib_source_t fes_src
Which source this info block is for.
Definition: fib_entry.h:282
fib_entry_src_cover_res_t fib_entry_src_action_cover_update(fib_entry_t *fib_entry, fib_source_t source)
#define ASSERT(truth)
fib_entry_src_flag_t fes_flags
Flags on the source.
Definition: fib_entry.h:286
void fib_entry_src_special_register(void)
fib_entry_t * fib_entry_src_action_path_swap(fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const fib_route_path_t *rpaths)
unsigned int u32
Definition: types.h:88
int fib_path_is_deag(fib_node_index_t path_index)
Definition: fib_path.c:1775
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:745
#define vec_insert_elts(V, E, N, M)
Insert N vector elements starting at element M, insert given elements (no header, unspecified alignme...
Definition: vec.h:724
void fib_entry_src_module_init(void)
void fib_entry_src_register(fib_source_t source, const fib_entry_src_vft_t *vft)
Definition: fib_entry_src.c:38
mpls_label_t frp_label
The outgoing MPLS label.
Definition: fib_types.h:317
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
fib_entry_t * fib_entry_src_action_update(fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Definition: fib_entry.h:255
static int fib_entry_src_collect_forwarding(fib_node_index_t pl_index, fib_node_index_t path_index, void *arg)
void fib_path_list_contribute_forwarding(fib_node_index_t path_list_index, fib_forward_chain_type_t type, dpo_id_t *dpo)
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:202
From the control plane API.
Definition: fib_entry.h:57
enum fib_entry_src_flag_t_ fib_entry_src_flag_t
int fib_path_get_weight(fib_node_index_t path_index)
Definition: fib_path.c:1558
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
Definition: lookup.h:157
fib_entry_src_path_remove_t fesv_path_remove
int fib_entry_is_sourced(fib_node_index_t fib_entry_index, fib_source_t source)
fib_entry_src_path_swap_t fesv_path_swap
fib_node_index_t fes_pl
The path-list created by the source.
Definition: fib_entry.h:278
const fib_entry_src_t * esrc
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:154
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
dpo_id_t fe_lb[FIB_FORW_CHAIN_MPLS_NUM]
The load-balance used for forwarding.
Definition: fib_entry.h:385
unsigned char u8
Definition: types.h:56
u32 path_weight
weight for the path.
Definition: load_balance.h:75
fib_node_index_t fpe_path_index
The index of the path.
Definition: fib_path_ext.h:46
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:920
fib_entry_src_activate_t fesv_activate
load_balance_path_t * fib_path_ext_stack(fib_path_ext_t *path_ext, fib_forward_chain_type_t parent_fct, load_balance_path_t *nhs)
Definition: fib_path_ext.c:90
void fib_urpf_list_unlock(index_t ui)
Definition: fib_urpf_list.c:60
#define MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL
Definition: mpls_types.h:15
One path from an [EU]CMP set that the client wants to add to a load-balance object.
Definition: load_balance.h:61
u8 * fib_entry_src_format(fib_entry_t *fib_entry, fib_source_t source, u8 *s)
void fib_entry_set_source_data(fib_node_index_t fib_entry_index, fib_source_t source, const void *data)
fib_entry_src_add_t fesv_add
index_t fib_path_list_get_urpf(fib_node_index_t path_list_index)
Return the the child the RPF list pre-built for this path list.
void fib_entry_src_action_reactivate(fib_entry_t *fib_entry, fib_source_t source)
load_balance_flags_t fib_entry_calc_lb_flags(fib_entry_src_collect_forwarding_ctx_t *ctx)
Determine whether this FIB entry should use a load-balance MAP to support PIC edge fast convergence...
const fib_entry_t * fib_entry
static int fib_route_recurses_via_self(const fib_prefix_t *prefix, const fib_route_path_t *rpath)
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:171
#define vec_foreach(var, vec)
Vector iterator.
A path extension is a per-entry addition to the forwarigind information when packets are sent for tha...
Definition: fib_path_ext.h:32
adj_index_t fib_entry_get_adj_for_source(fib_node_index_t fib_entry_index, fib_source_t source)
u8 fes_ref_count
1 bytes ref count.
Definition: fib_entry.h:293
static int fib_path_is_attached(const fib_route_path_t *rpath)
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:94
const void * fib_entry_get_source_data(fib_node_index_t fib_entry_index, fib_source_t source)
enum fib_path_list_flags_t_ fib_path_list_flags_t
u32 flags
Definition: vhost-user.h:75
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:74
fib_forward_chain_type_t fib_entry_get_default_chain_type(const fib_entry_t *fib_entry)
Definition: fib_entry.c:109
void fib_entry_src_action_install(fib_entry_t *fib_entry, fib_source_t source)
fib_entry_src_installed_t fesv_installed
void fib_entry_src_action_uninstall(fib_entry_t *fib_entry)