FD.io VPP  v17.04-9-g99c0734
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 /**
225  * @brief Turn the chain type requested by the client into the one they
226  * really wanted
227  */
231 {
233 
234  /*
235  * The EOS chain is a tricky since one cannot know the adjacency
236  * to link to without knowing what the packets payload protocol
237  * will be once the label is popped.
238  */
240 
241  dfct = fib_entry_get_default_chain_type(entry);
242 
243  if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
244  {
245  /*
246  * If the entry being asked is a eos-MPLS label entry,
247  * then use the payload-protocol field, that we stashed there
248  * for just this purpose
249  */
251  entry->fe_prefix.fp_payload_proto));
252  }
253  /*
254  * else give them what this entry would be by default. i.e. if it's a v6
255  * entry, then the label its local labelled should be carrying v6 traffic.
256  * If it's a non-EOS label entry, then there are more labels and we want
257  * a non-eos chain.
258  */
259  return (dfct);
260 }
261 
262 static int
264  fib_node_index_t path_index,
265  void *arg)
266 {
268  fib_path_ext_t *path_ext;
269  int have_path_ext;
270 
271  ctx = arg;
272 
273  /*
274  * if the path is not resolved, don't include it.
275  */
276  if (!fib_path_is_resolved(path_index))
277  {
278  return (!0);
279  }
280 
281  if (fib_path_is_recursive(path_index))
282  {
283  ctx->is_recursive = 1;
284  }
285 
286  /*
287  * get the matching path-extension for the path being visited.
288  */
289  have_path_ext = 0;
290  vec_foreach(path_ext, ctx->esrc->fes_path_exts)
291  {
292  if (path_ext->fpe_path_index == path_index)
293  {
294  have_path_ext = 1;
295  break;
296  }
297  }
298 
299  if (have_path_ext &&
300  fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0]))
301  {
302  /*
303  * found a matching extension. stack it to obtain the forwarding
304  * info for this path.
305  */
306  ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fib_entry, ctx->fct, ctx->next_hops);
307  }
308  else
309  {
311 
312  /*
313  * no extension => no out-going label for this path. that's OK
314  * in the case of an IP or EOS chain, but not for non-EOS
315  */
316  switch (ctx->fct)
317  {
322  /*
323  * EOS traffic with no label to stack, we need the IP Adj
324  */
325  vec_add2(ctx->next_hops, nh, 1);
326 
327  nh->path_index = path_index;
328  nh->path_weight = fib_path_get_weight(path_index);
329  fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
330 
331  break;
333  if (fib_path_is_exclusive(path_index) ||
334  fib_path_is_deag(path_index))
335  {
336  vec_add2(ctx->next_hops, nh, 1);
337 
338  nh->path_index = path_index;
339  nh->path_weight = fib_path_get_weight(path_index);
342  &nh->path_dpo);
343  }
344  break;
346  {
347  /*
348  * no label. we need a chain based on the payload. fixup.
349  */
350  vec_add2(ctx->next_hops, nh, 1);
351 
352  nh->path_index = path_index;
353  nh->path_weight = fib_path_get_weight(path_index);
356  ctx->fct),
357  &nh->path_dpo);
358 
359  break;
360  }
363  ASSERT(0);
364  break;
365  }
366  }
367 
368  return (!0);
369 }
370 
371 void
373  const fib_entry_src_t *esrc,
375  dpo_id_t *dpo_lb)
376 {
377  dpo_proto_t lb_proto;
378 
379  /*
380  * If the entry has path extensions then we construct a load-balance
381  * by stacking the extensions on the forwarding chains of the paths.
382  * Otherwise we use the load-balance of the path-list
383  */
385  .esrc = esrc,
386  .fib_entry = fib_entry,
387  .next_hops = NULL,
388  .is_recursive = 0,
389  .fct = fct,
390  };
391 
392  /*
393  * As an optimisation we allocate the vector of next-hops to be sized
394  * equal to the maximum nuber of paths we will need, which is also the
395  * most likely number we will need, since in most cases the paths are 'up'.
396  */
399 
400  lb_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
401 
404  &ctx);
405 
407  {
408  /*
409  * the client provided the DPO that the entry should link to.
410  * all entries must link to a LB, so if it is an LB already
411  * then we can use it.
412  */
413  if ((1 == vec_len(ctx.next_hops)) &&
415  {
416  dpo_copy(dpo_lb, &ctx.next_hops[0].path_dpo);
417  dpo_reset(&ctx.next_hops[0].path_dpo);
418  return;
419  }
420  }
421 
422  if (!dpo_id_is_valid(dpo_lb))
423  {
424  /*
425  * first time create
426  */
427  flow_hash_config_t fhc;
428 
430  dpo_proto_to_fib(lb_proto));
431  dpo_set(dpo_lb,
433  lb_proto,
434  load_balance_create(0, lb_proto, fhc));
435  }
436 
438  ctx.next_hops,
440  vec_free(ctx.next_hops);
441 
442  /*
443  * if this entry is sourced by the uRPF-exempt source then we
444  * append the always present local0 interface (index 0) to the
445  * uRPF list so it is not empty. that way packets pass the loose check.
446  */
448 
452  (0 == fib_urpf_check_size(ui)))
453  {
454  /*
455  * The uRPF list we get from the path-list is shared by all
456  * other users of the list, but the uRPF exemption applies
457  * only to this prefix. So we need our own list.
458  */
460  fib_urpf_list_append(ui, 0);
461  fib_urpf_list_bake(ui);
462  load_balance_set_urpf(dpo_lb->dpoi_index, ui);
464  }
465  else
466  {
467  load_balance_set_urpf(dpo_lb->dpoi_index, ui);
468  }
470  fib_entry_get_flags_i(fib_entry));
471 }
472 
473 void
475  fib_source_t source)
476 {
477  /*
478  * Install the forwarding chain for the given source into the forwarding
479  * tables
480  */
483  int insert;
484 
485  fct = fib_entry_get_default_chain_type(fib_entry);
486  esrc = fib_entry_src_find(fib_entry, source, NULL);
487 
488  /*
489  * Every entry has its own load-balance object. All changes to the entry's
490  * forwarding result in an inplace modify of the load-balance. This means
491  * the load-balance object only needs to be added to the forwarding
492  * DB once, when it is created.
493  */
494  insert = !dpo_id_is_valid(&fib_entry->fe_lb);
495 
496  fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb);
497 
498  ASSERT(dpo_id_is_valid(&fib_entry->fe_lb));
499  FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb);
500 
501  /*
502  * insert the adj into the data-plane forwarding trie
503  */
504  if (insert)
505  {
507  &fib_entry->fe_prefix,
508  &fib_entry->fe_lb);
509  }
510 
511  /*
512  * if any of the other chain types are already created they will need
513  * updating too
514  */
517 
518  FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
519  {
520  fib_entry_src_mk_lb(fib_entry, esrc,
522  &fed->fd_dpo);
523  });
524 }
525 
526 void
528 {
529  /*
530  * uninstall the forwarding chain from the forwarding tables
531  */
532  FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
533  fib_entry->fe_adj_index);
534 
535  if (dpo_id_is_valid(&fib_entry->fe_lb))
536  {
538  fib_entry->fe_fib_index,
539  &fib_entry->fe_prefix,
540  &fib_entry->fe_lb);
541 
542  dpo_reset(&fib_entry->fe_lb);
543  }
544 }
545 
546 static void
548 {
549  fib_node_index_t *entries = NULL;
550 
551  fib_path_list_recursive_loop_detect(path_list_index, &entries);
552 
553  vec_free(entries);
554 }
555 
556 void
558  fib_source_t source)
559 
560 {
561  int houston_we_are_go_for_install;
563 
564  esrc = fib_entry_src_find(fib_entry, source, NULL);
565 
568 
570 
571  if (NULL != fib_entry_src_vft[source].fesv_activate)
572  {
573  houston_we_are_go_for_install =
574  fib_entry_src_vft[source].fesv_activate(esrc, fib_entry);
575  }
576  else
577  {
578  /*
579  * the source is not providing an activate function, we'll assume
580  * therefore it has no objection to installing the entry
581  */
582  houston_we_are_go_for_install = !0;
583  }
584 
585  /*
586  * link to the path-list provided by the source, and go check
587  * if that forms any loops in the graph.
588  */
589  fib_entry->fe_parent = esrc->fes_pl;
590  fib_entry->fe_sibling =
593  fib_entry_get_index(fib_entry));
594 
596 
597  FIB_ENTRY_DBG(fib_entry, "activate: %d",
598  fib_entry->fe_parent);
599 
600  if (0 != houston_we_are_go_for_install)
601  {
602  fib_entry_src_action_install(fib_entry, source);
603  }
604  else
605  {
607  }
608 }
609 
610 void
612  fib_source_t source)
613 
614 {
615  fib_node_index_t path_list_index;
617 
618  esrc = fib_entry_src_find(fib_entry, source, NULL);
619 
621 
622  if (NULL != fib_entry_src_vft[source].fesv_deactivate)
623  {
624  fib_entry_src_vft[source].fesv_deactivate(esrc, fib_entry);
625  }
626 
628 
629  FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
630 
631  /*
632  * un-link from an old path-list. Check for any loops this will clear
633  */
634  path_list_index = fib_entry->fe_parent;
635  fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
636 
637  fib_entry_recursive_loop_detect_i(path_list_index);
638 
639  /*
640  * this will unlock the path-list, so it may be invalid thereafter.
641  */
642  fib_path_list_child_remove(path_list_index, fib_entry->fe_sibling);
643  fib_entry->fe_sibling = FIB_NODE_INDEX_INVALID;
644 }
645 
646 static void
648  fib_source_t source)
649 {
651 
652  vec_foreach(esrc, fib_entry->fe_srcs)
653  {
654  if (NULL != fib_entry_src_vft[esrc->fes_src].fesv_fwd_update)
655  {
656  fib_entry_src_vft[esrc->fes_src].fesv_fwd_update(esrc,
657  fib_entry,
658  source);
659  }
660  }
661 }
662 
663 void
665  fib_source_t source)
666 {
667  fib_node_index_t path_list_index;
669 
670  esrc = fib_entry_src_find(fib_entry, source, NULL);
671 
673 
674  FIB_ENTRY_DBG(fib_entry, "reactivate: %d to %d",
675  fib_entry->fe_parent,
676  esrc->fes_pl);
677 
678  if (fib_entry->fe_parent != esrc->fes_pl)
679  {
680  /*
681  * un-link from an old path-list. Check for any loops this will clear
682  */
683  path_list_index = fib_entry->fe_parent;
684  fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
685 
686  /*
687  * temporary lock so it doesn't get deleted when this entry is no
688  * longer a child.
689  */
690  fib_path_list_lock(path_list_index);
691 
692  /*
693  * this entry is no longer a child. after unlinking check if any loops
694  * were broken
695  */
696  fib_path_list_child_remove(path_list_index,
697  fib_entry->fe_sibling);
698 
699  fib_entry_recursive_loop_detect_i(path_list_index);
700 
701  /*
702  * link to the path-list provided by the source, and go check
703  * if that forms any loops in the graph.
704  */
705  fib_entry->fe_parent = esrc->fes_pl;
706  fib_entry->fe_sibling =
709  fib_entry_get_index(fib_entry));
710 
712  fib_path_list_unlock(path_list_index);
713  }
714  fib_entry_src_action_install(fib_entry, source);
715  fib_entry_src_action_fwd_update(fib_entry, source);
716 }
717 
718 void
720  fib_source_t source)
721 {
723 
724  esrc = fib_entry_src_find(fib_entry, source, NULL);
725 
726  if (NULL != fib_entry_src_vft[source].fesv_installed)
727  {
728  fib_entry_src_vft[source].fesv_installed(esrc,
729  fib_entry);
730  }
731 
732  fib_entry_src_action_fwd_update(fib_entry, source);
733 }
734 
735 /*
736  * fib_entry_src_action_add
737  *
738  * Adding a source can result in a new fib_entry being created, which
739  * can inturn mean the pool is realloc'd and thus the entry passed as
740  * an argument it also realloc'd
741  * @return the original entry
742  */
743 fib_entry_t *
745  fib_source_t source,
747  const dpo_id_t *dpo)
748 {
749  fib_node_index_t fib_entry_index;
751 
752  esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
753 
754  esrc->fes_ref_count++;
755 
756  if (1 != esrc->fes_ref_count)
757  {
758  /*
759  * we only want to add the source on the 0->1 transition
760  */
761  return (fib_entry);
762  }
763 
764  esrc->fes_entry_flags = flags;
765 
766  /*
767  * save variable so we can recover from a fib_entry realloc.
768  */
769  fib_entry_index = fib_entry_get_index(fib_entry);
770 
771  if (NULL != fib_entry_src_vft[source].fesv_add)
772  {
773  fib_entry_src_vft[source].fesv_add(esrc,
774  fib_entry,
775  flags,
776  fib_entry_get_proto(fib_entry),
777  dpo);
778  }
779 
780  fib_entry = fib_entry_get(fib_entry_index);
781 
783 
784  fib_path_list_lock(esrc->fes_pl);
785 
786  /*
787  * the source owns a lock on the entry
788  */
790 
791  return (fib_entry);
792 }
793 
794 /*
795  * fib_entry_src_action_update
796  *
797  * Adding a source can result in a new fib_entry being created, which
798  * can inturn mean the pool is realloc'd and thus the entry passed as
799  * an argument it also realloc'd
800  * @return the original entry
801  */
802 fib_entry_t *
804  fib_source_t source,
806  const dpo_id_t *dpo)
807 {
808  fib_node_index_t fib_entry_index, old_path_list_index;
810 
811  esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
812 
813  if (NULL == esrc)
814  return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
815 
816  old_path_list_index = esrc->fes_pl;
817  esrc->fes_entry_flags = flags;
818 
819  /*
820  * save variable so we can recover from a fib_entry realloc.
821  */
822  fib_entry_index = fib_entry_get_index(fib_entry);
823 
824  if (NULL != fib_entry_src_vft[source].fesv_add)
825  {
826  fib_entry_src_vft[source].fesv_add(esrc,
827  fib_entry,
828  flags,
829  fib_entry_get_proto(fib_entry),
830  dpo);
831  }
832 
833  fib_entry = fib_entry_get(fib_entry_index);
834 
836 
837  fib_path_list_lock(esrc->fes_pl);
838  fib_path_list_unlock(old_path_list_index);
839 
840  return (fib_entry);
841 }
842 
843 
846  fib_source_t source)
847 
848 {
849  fib_node_index_t old_path_list;
850  fib_entry_src_flag_t sflags;
852 
853  esrc = fib_entry_src_find(fib_entry, source, NULL);
854 
855  if (NULL == esrc)
856  return (FIB_ENTRY_SRC_FLAG_ACTIVE);
857 
858  esrc->fes_ref_count--;
859  sflags = esrc->fes_flags;
860 
861  if (0 != esrc->fes_ref_count)
862  {
863  /*
864  * only remove the source on the 1->0 transisition
865  */
866  return (sflags);
867  }
868 
870  {
871  fib_entry_src_action_deactivate(fib_entry, source);
872  }
873 
874  old_path_list = esrc->fes_pl;
875 
876  if (NULL != fib_entry_src_vft[source].fesv_remove)
877  {
878  fib_entry_src_vft[source].fesv_remove(esrc);
879  }
880 
881  fib_path_list_unlock(old_path_list);
883 
884  sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED;
885  fib_entry_src_action_deinit(fib_entry, source);
886 
887  return (sflags);
888 }
889 
890 static inline int
892  const fib_route_path_t *rpath)
893 {
894  /*
895  * not all zeros next hop &&
896  * is recursive path &&
897  * nexthop is same as the route's address
898  */
899  return ((!ip46_address_is_zero(&rpath->frp_addr)) &&
900  (~0 == rpath->frp_sw_if_index) &&
901  (0 == ip46_address_cmp(&rpath->frp_addr, &prefix->fp_addr)));
902 
903 }
904 
905 /*
906  * fib_route_attached_cross_table
907  *
908  * Return true the the route is attached via an interface that
909  * is not in the same table as the route
910  */
911 static inline int
913  const fib_route_path_t *rpath)
914 {
915  /*
916  * - All zeros next-hop
917  * - a valid interface
918  * - entry's fib index not equeal to interface's index
919  */
920  if (ip46_address_is_zero(&rpath->frp_addr) &&
921  (~0 != rpath->frp_sw_if_index) &&
922  (fib_entry->fe_fib_index !=
924  rpath->frp_sw_if_index)))
925  {
926  return (!0);
927  }
928  return (0);
929 }
930 
931 /*
932  * fib_route_attached_cross_table
933  *
934  * Return true the the route is attached via an interface that
935  * is not in the same table as the route
936  */
937 static inline int
939 {
940  /*
941  * - All zeros next-hop
942  * - a valid interface
943  */
944  if (ip46_address_is_zero(&rpath->frp_addr) &&
945  (~0 != rpath->frp_sw_if_index))
946  {
947  return (!0);
948  }
949  else if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
950  {
951  return (!0);
952  }
953  return (0);
954 }
955 
958 {
960 
961  if (eflags & FIB_ENTRY_FLAG_DROP)
962  {
964  }
965  if (eflags & FIB_ENTRY_FLAG_LOCAL)
966  {
968  }
969  if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
970  {
972  }
973 
974  return (plf);
975 }
976 
977 static void
979  const fib_route_path_t *rpath,
980  fib_path_list_flags_t *pl_flags,
982 {
983  /*
984  * don't allow the addition of a recursive looped path for prefix
985  * via itself.
986  */
987  if (fib_route_recurses_via_self(&fib_entry->fe_prefix, rpath))
988  {
989  /*
990  * force the install of a drop path-list.
991  * we want the entry to have some path-list, mainly so
992  * the dodgy path can be rmeoved when the source stops playing
993  * silly buggers.
994  */
995  *pl_flags |= FIB_PATH_LIST_FLAG_DROP;
996  }
997  else
998  {
999  *pl_flags &= ~FIB_PATH_LIST_FLAG_DROP;
1000  }
1001 
1002  if ((esrc->fes_src == FIB_SOURCE_API) ||
1003  (esrc->fes_src == FIB_SOURCE_CLI))
1004  {
1005  if (fib_path_is_attached(rpath))
1006  {
1008  }
1009  else
1010  {
1012  }
1013  }
1014  if (fib_route_attached_cross_table(fib_entry, rpath))
1015  {
1017  }
1018  else
1019  {
1021  }
1022 }
1023 
1024 /*
1025  * fib_entry_src_path_ext_add
1026  *
1027  * append a path extension to the entry's list
1028  */
1029 static void
1031  const fib_route_path_t *rpath)
1032 {
1033  if (NULL != rpath->frp_label_stack)
1034  {
1035  fib_path_ext_t *path_ext;
1036 
1037  vec_add2(esrc->fes_path_exts, path_ext, 1);
1038 
1039  fib_path_ext_init(path_ext, esrc->fes_pl, rpath);
1040  }
1041 }
1042 
1043 /*
1044  * fib_entry_src_path_ext_insert
1045  *
1046  * insert, sorted, a path extension to the entry's list.
1047  * It's not strictly necessary in sort the path extensions, since each
1048  * extension has the path index to which it resolves. However, by being
1049  * sorted the load-balance produced has a deterministic order, not an order
1050  * based on the sequence of extension additions. this is a considerable benefit.
1051  */
1052 static void
1054  const fib_route_path_t *rpath)
1055 {
1056  if (0 == vec_len(esrc->fes_path_exts))
1057  return (fib_entry_src_path_ext_append(esrc, rpath));
1058 
1059  if (NULL != rpath->frp_label_stack)
1060  {
1061  fib_path_ext_t path_ext;
1062  int i = 0;
1063 
1064  fib_path_ext_init(&path_ext, esrc->fes_pl, rpath);
1065 
1066  while (i < vec_len(esrc->fes_path_exts) &&
1067  (fib_path_ext_cmp(&esrc->fes_path_exts[i], rpath) < 0))
1068  {
1069  i++;
1070  }
1071 
1072  vec_insert_elts(esrc->fes_path_exts, &path_ext, 1, i);
1073  }
1074 }
1075 
1076 /*
1077  * fib_entry_src_action_add
1078  *
1079  * Adding a source can result in a new fib_entry being created, which
1080  * can inturn mean the pool is realloc'd and thus the entry passed as
1081  * an argument it also realloc'd
1082  * @return the entry
1083  */
1084 fib_entry_t*
1086  fib_source_t source,
1088  const fib_route_path_t *rpath)
1089 {
1090  fib_node_index_t old_path_list, fib_entry_index;
1091  fib_path_list_flags_t pl_flags;
1092  fib_path_ext_t *path_ext;
1094 
1095  /*
1096  * save variable so we can recover from a fib_entry realloc.
1097  */
1098  fib_entry_index = fib_entry_get_index(fib_entry);
1099 
1100  esrc = fib_entry_src_find(fib_entry, source, NULL);
1101  if (NULL == esrc)
1102  {
1103  fib_entry =
1104  fib_entry_src_action_add(fib_entry,
1105  source,
1106  flags,
1107  drop_dpo_get(
1109  fib_entry_get_proto(fib_entry))));
1110  esrc = fib_entry_src_find(fib_entry, source, NULL);
1111  }
1112 
1113  /*
1114  * we are no doubt modifying a path-list. If the path-list
1115  * is shared, and hence not modifiable, then the index returned
1116  * will be for a different path-list. This FIB entry to needs
1117  * to maintain its lock appropriately.
1118  */
1119  old_path_list = esrc->fes_pl;
1120 
1121  ASSERT(NULL != fib_entry_src_vft[source].fesv_path_add);
1122 
1124  fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1125 
1126  fib_entry_src_vft[source].fesv_path_add(esrc, fib_entry, pl_flags, rpath);
1127  fib_entry = fib_entry_get(fib_entry_index);
1128 
1129  /*
1130  * re-resolve all the path-extensions with the new path-list
1131  */
1132  vec_foreach(path_ext, esrc->fes_path_exts)
1133  {
1134  fib_path_ext_resolve(path_ext, esrc->fes_pl);
1135  }
1136  /*
1137  * if the path has a label we need to add a path extension
1138  */
1139  fib_entry_src_path_ext_insert(esrc, rpath);
1140 
1141  fib_path_list_lock(esrc->fes_pl);
1142  fib_path_list_unlock(old_path_list);
1143 
1144  return (fib_entry);
1145 }
1146 
1147 /*
1148  * fib_entry_src_action_swap
1149  *
1150  * The source is providing new paths to replace the old ones.
1151  * Adding a source can result in a new fib_entry being created, which
1152  * can inturn mean the pool is realloc'd and thus the entry passed as
1153  * an argument it also realloc'd
1154  * @return the entry
1155  */
1156 fib_entry_t*
1158  fib_source_t source,
1160  const fib_route_path_t *rpaths)
1161 {
1162  fib_node_index_t old_path_list, fib_entry_index;
1163  fib_path_list_flags_t pl_flags;
1164  const fib_route_path_t *rpath;
1165  fib_path_ext_t *path_ext;
1167 
1168  esrc = fib_entry_src_find(fib_entry, source, NULL);
1169 
1170  /*
1171  * save variable so we can recover from a fib_entry realloc.
1172  */
1173  fib_entry_index = fib_entry_get_index(fib_entry);
1174 
1175  if (NULL == esrc)
1176  {
1177  fib_entry = fib_entry_src_action_add(fib_entry,
1178  source,
1179  flags,
1180  drop_dpo_get(
1182  fib_entry_get_proto(fib_entry))));
1183  esrc = fib_entry_src_find(fib_entry, source, NULL);
1184  }
1185 
1186  /*
1187  * swapping paths may create a new path-list (or may use an existing shared)
1188  * but we are certainly getting a different one. This FIB entry to needs
1189  * to maintain its lock appropriately.
1190  */
1191  old_path_list = esrc->fes_pl;
1192 
1193  ASSERT(NULL != fib_entry_src_vft[source].fesv_path_swap);
1194 
1195  pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
1196 
1197  vec_foreach(rpath, rpaths)
1198  {
1199  fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1200  }
1201 
1202  fib_entry_src_vft[source].fesv_path_swap(esrc,
1203  fib_entry,
1204  pl_flags,
1205  rpaths);
1206 
1207  vec_foreach(path_ext, esrc->fes_path_exts)
1208  {
1209  vec_free(path_ext->fpe_label_stack);
1210  }
1211  vec_free(esrc->fes_path_exts);
1212 
1213  vec_foreach(rpath, rpaths)
1214  {
1215  fib_entry_src_path_ext_append(esrc, rpath);
1216  }
1217 
1218  fib_entry = fib_entry_get(fib_entry_index);
1219 
1220  fib_path_list_lock(esrc->fes_pl);
1221  fib_path_list_unlock(old_path_list);
1222 
1223  return (fib_entry);
1224 }
1225 
1228  fib_source_t source,
1229  const fib_route_path_t *rpath)
1230 {
1231  fib_path_list_flags_t pl_flags;
1232  fib_node_index_t old_path_list;
1233  fib_path_ext_t *path_ext;
1235 
1236  esrc = fib_entry_src_find(fib_entry, source, NULL);
1237 
1238  ASSERT(NULL != esrc);
1240 
1241  /*
1242  * we no doubt modifying a path-list. If the path-list
1243  * is shared, and hence not modifiable, then the index returned
1244  * will be for a different path-list. This FIB entry to needs
1245  * to maintain its lock appropriately.
1246  */
1247  old_path_list = esrc->fes_pl;
1248 
1249  ASSERT(NULL != fib_entry_src_vft[source].fesv_path_remove);
1250 
1252  fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1253 
1254  fib_entry_src_vft[source].fesv_path_remove(esrc, pl_flags, rpath);
1255  /*
1256  * find the matching path extension and remove it
1257  */
1258  vec_foreach(path_ext, esrc->fes_path_exts)
1259  {
1260  if (!fib_path_ext_cmp(path_ext, rpath))
1261  {
1262  /*
1263  * delete the element moving the remaining elements down 1 position.
1264  * this preserves the sorted order.
1265  */
1266  vec_free(path_ext->fpe_label_stack);
1267  vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
1268  break;
1269  }
1270  }
1271  /*
1272  * re-resolve all the path-extensions with the new path-list
1273  */
1274  vec_foreach(path_ext, esrc->fes_path_exts)
1275  {
1276  fib_path_ext_resolve(path_ext, esrc->fes_pl);
1277  }
1278 
1279  /*
1280  * lock the new path-list, unlock the old if it had one
1281  */
1282  fib_path_list_unlock(old_path_list);
1283 
1284  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) {
1285  fib_path_list_lock(esrc->fes_pl);
1286  return (FIB_ENTRY_SRC_FLAG_ADDED);
1287  }
1288  else
1289  {
1290  /*
1291  * no more paths left from this source
1292  */
1293  fib_entry_src_action_remove(fib_entry, source);
1294  return (FIB_ENTRY_SRC_FLAG_NONE);
1295  }
1296 }
1297 
1298 u8*
1300  fib_source_t source,
1301  u8* s)
1302 {
1304 
1305  esrc = fib_entry_src_find(fib_entry, source, NULL);
1306 
1307  if (NULL != fib_entry_src_vft[source].fesv_format)
1308  {
1309  return (fib_entry_src_vft[source].fesv_format(esrc, s));
1310  }
1311  return (s);
1312 }
1313 
1316  fib_source_t source)
1317 {
1320 
1321  if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1322  return (ADJ_INDEX_INVALID);
1323 
1324  fib_entry = fib_entry_get(fib_entry_index);
1325  esrc = fib_entry_src_find(fib_entry, source, NULL);
1326 
1327  if (NULL != esrc)
1328  {
1329  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1330  {
1331  return (fib_path_list_get_adj(
1332  esrc->fes_pl,
1333  fib_entry_get_default_chain_type(fib_entry)));
1334  }
1335  }
1336  return (ADJ_INDEX_INVALID);
1337 }
1338 
1339 const int
1341  fib_source_t source,
1342  dpo_id_t *dpo)
1343 {
1346 
1347  if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1348  return (0);
1349 
1350  fib_entry = fib_entry_get(fib_entry_index);
1351  esrc = fib_entry_src_find(fib_entry, source, NULL);
1352 
1353  if (NULL != esrc)
1354  {
1355  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1356  {
1358  esrc->fes_pl,
1360  dpo);
1361 
1362  return (dpo_id_is_valid(dpo));
1363  }
1364  }
1365  return (0);
1366 }
1367 
1368 u32
1370  fib_source_t source)
1371 {
1374 
1375  fib_entry = fib_entry_get(entry_index);
1376 
1377  esrc = fib_entry_src_find(fib_entry, source, NULL);
1378 
1379  if (NULL != esrc)
1380  {
1381  if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1382  {
1384  }
1385  }
1386  return (~0);
1387 }
1388 
1391  fib_source_t source)
1392 {
1395 
1396  fib_entry = fib_entry_get(entry_index);
1397 
1398  esrc = fib_entry_src_find(fib_entry, source, NULL);
1399 
1400  if (NULL != esrc)
1401  {
1402  return (esrc->fes_entry_flags);
1403  }
1404 
1405  return (FIB_ENTRY_FLAG_NONE);
1406 }
1407 
1410 {
1412 
1413  /*
1414  * the vector of sources is deliberately arranged in priority order
1415  */
1416  if (0 == vec_len(fib_entry->fe_srcs))
1417  {
1418  flags = FIB_ENTRY_FLAG_NONE;
1419  }
1420  else
1421  {
1423 
1424  esrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
1425  flags = esrc->fes_entry_flags;
1426  }
1427 
1428  return (flags);
1429 }
1430 
1431 void
1433  fib_source_t source,
1434  const void *data)
1435 {
1438 
1439  fib_entry = fib_entry_get(fib_entry_index);
1440  esrc = fib_entry_src_find(fib_entry, source, NULL);
1441 
1442  if (NULL != esrc &&
1443  NULL != fib_entry_src_vft[source].fesv_set_data)
1444  {
1445  fib_entry_src_vft[source].fesv_set_data(esrc, fib_entry, data);
1446  }
1447 }
1448 
1449 const void*
1451  fib_source_t source)
1452 {
1455 
1456  fib_entry = fib_entry_get(fib_entry_index);
1457  esrc = fib_entry_src_find(fib_entry, source, NULL);
1458 
1459  if (NULL != esrc &&
1460  NULL != fib_entry_src_vft[source].fesv_get_data)
1461  {
1462  return (fib_entry_src_vft[source].fesv_get_data(esrc, fib_entry));
1463  }
1464  return (NULL);
1465 }
1466 
1467 void
1469 {
1478 }
static int fib_entry_src_cmp_for_sort(void *v1, void *v2)
Definition: fib_entry_src.c:45
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
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:1932
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:169
fib_entry_src_init_t fesv_init
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:105
#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:322
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:1427
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:85
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
An entry in a FIB table.
Definition: fib_entry.h:373
fib_node_index_t path_index
The index of the FIB path.
Definition: load_balance.h:71
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:1742
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:71
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:308
int fib_path_ext_cmp(fib_path_ext_t *path_ext, const fib_route_path_t *rpath)
Definition: fib_path_ext.c:47
dpo_id_t path_dpo
ID of the Data-path object.
Definition: load_balance.h:66
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:269
static int dpo_id_is_valid(const dpo_id_t *dpoi)
Return true if the DPO object is valid, i.e.
Definition: dpo.h:185
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:282
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:892
Definition: fib_entry.h:233
void load_balance_set_urpf(index_t lbi, index_t urpf)
Definition: load_balance.c:253
int fib_path_is_exclusive(fib_node_index_t path_index)
Definition: fib_path.c:1912
void fib_entry_src_action_deactivate(fib_entry_t *fib_entry, fib_source_t source)
load_balance_path_t * next_hops
enum fib_entry_delegate_type_t_ fib_entry_delegate_type_t
Delegate types.
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:62
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:224
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:522
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:561
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:81
u32 fe_fib_index
The index of the FIB table this entry is in.
Definition: fib_entry.h:386
uRPF bypass/exemption.
Definition: fib_entry.h:114
Definition: fib_entry.h:229
fib_entry_src_t * fe_srcs
Vector of source infos.
Definition: fib_entry.h:405
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:80
dpo_id_t fd_dpo
Valid for the forwarding chain delegates.
fib_node_index_t fe_parent
the path-list for which this entry is a child.
Definition: fib_entry.h:410
void fib_entry_src_mpls_register(void)
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
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:908
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:84
const dpo_id_t * drop_dpo_get(dpo_proto_t proto)
Definition: drop_dpo.c:25
void fib_entry_src_adj_register(void)
dpo_proto_t fp_payload_proto
This protocol determines the payload protocol of packets that will be forwarded by this entry once th...
Definition: fib_types.h:193
u32 fe_sibling
index of this entry in the parent&#39;s child list.
Definition: fib_entry.h:416
Definition: fib_entry.h:234
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:334
mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:351
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:55
void fib_path_list_contribute_forwarding(fib_node_index_t path_list_index, fib_forward_chain_type_t fct, dpo_id_t *dpo)
#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:160
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
void load_balance_multipath_update(const dpo_id_t *dpo, const load_balance_path_t *raw_nhs, load_balance_flags_t flags)
Definition: load_balance.c:482
Contribute an object that is to be used to forward Ethernet packets.
Definition: fib_types.h:109
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:236
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.
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:227
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:146
Contribute an object that is to be used to forward end-of-stack MPLS packets.
Definition: fib_types.h:97
Definition: fib_entry.h:232
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:231
#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:286
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:183
fib_entry_src_fwd_update_t fesv_fwd_update
#define FOR_EACH_DELEGATE_CHAIN(_entry, _fdt, _fed, _body)
fib_entry_src_deinit_t fesv_deinit
dpo_type_t dpoi_type
the type
Definition: dpo.h:150
void load_balance_set_fib_entry_flags(index_t lbi, fib_entry_flag_t flags)
Definition: load_balance.c:242
load-balancing over a choice of [un]equal cost paths
Definition: dpo.h:104
#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:805
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:134
void fib_entry_src_action_init(fib_entry_t *fib_entry, fib_source_t source)
Definition: fib_entry_src.c:54
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:1902
void fib_entry_src_action_installed(const fib_entry_t *fib_entry, fib_source_t source)
Definition: fib_entry.h:267
Contribute an object that is to be used to forward NSH packets.
Definition: fib_types.h:115
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
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:230
fib_entry_src_deactivate_t fesv_deactivate
u32 fib_path_list_get_n_paths(fib_node_index_t path_list_index)
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
fib_forward_chain_type_t fib_entry_delegate_type_to_chain_type(fib_entry_delegate_type_t fdt)
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:157
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
enum fib_entry_flag_t_ fib_entry_flag_t
void fib_entry_src_interface_register(void)
void fib_entry_lock(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1417
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:311
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:295
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:299
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:1922
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:785
#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:764
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
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:347
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:268
static int fib_entry_src_collect_forwarding(fib_node_index_t pl_index, fib_node_index_t path_index, void *arg)
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:220
From the control plane API.
Definition: fib_entry.h:58
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:1666
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
Definition: lookup.h:165
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
dpo_id_t fe_lb
The load-balance used for forwarding.
Definition: fib_entry.h:399
load_balance_path_t * fib_path_ext_stack(fib_path_ext_t *path_ext, const fib_entry_t *entry, fib_forward_chain_type_t child_fct, load_balance_path_t *nhs)
Definition: fib_path_ext.c:105
fib_node_index_t fes_pl
The path-list created by the source.
Definition: fib_entry.h:291
const fib_entry_src_t * esrc
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:162
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
u32 path_weight
weight for the path.
Definition: load_balance.h:76
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:960
fib_entry_src_activate_t fesv_activate
void fib_urpf_list_unlock(index_t ui)
Definition: fib_urpf_list.c:68
#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:62
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.
fib_forward_chain_type_t fib_entry_chain_type_fixup(const fib_entry_t *entry, fib_forward_chain_type_t fct)
Turn the chain type requested by the client into the one they really wanted.
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:194
#define vec_foreach(var, vec)
Vector iterator.
A path extension is a per-entry addition to the forwarding information when packets are sent for that...
Definition: fib_path_ext.h: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:306
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:90
const void * fib_entry_get_source_data(fib_node_index_t fib_entry_index, fib_source_t source)
Attached path.
Definition: fib_types.h:288
enum fib_path_list_flags_t_ fib_path_list_flags_t
A Delagate is a means to implmenet the Delagation design pattern; the extension of an objects functio...
u32 flags
Definition: vhost-user.h:78
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:81
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:101
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:270
fib_forward_chain_type_t fib_entry_get_default_chain_type(const fib_entry_t *fib_entry)
Definition: fib_entry.c:68
void fib_entry_src_action_install(fib_entry_t *fib_entry, fib_source_t source)
fib_entry_src_installed_t fesv_installed
const fib_prefix_t fe_prefix
The prefix of the route.
Definition: fib_entry.h:382
void fib_entry_src_action_uninstall(fib_entry_t *fib_entry)