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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <vlib/vlib.h>
17 #include <vnet/dpo/drop_dpo.h>
19 #include <vnet/fib/fib_table.h>
20 #include <vnet/fib/fib_entry_cover.h>
21 #include <vnet/fib/fib_internal.h>
22 #include <vnet/fib/ip4_fib.h>
23 #include <vnet/fib/ip6_fib.h>
24 #include <vnet/fib/mpls_fib.h>
27 fib_table_get (fib_node_index_t index,
32 case FIB_PROTOCOL_IP4:
33 return (pool_elt_at_index(ip4_main.fibs, index));
34 case FIB_PROTOCOL_IP6:
35 return (pool_elt_at_index(ip6_main.fibs, index));
36 case FIB_PROTOCOL_MPLS:
37 return (pool_elt_at_index(mpls_main.fibs, index));
43 static inline fib_node_index_t
44 fib_table_lookup_i (fib_table_t *fib_table,
45 const fib_prefix_t *prefix)
47 switch (prefix->fp_proto)
49 case FIB_PROTOCOL_IP4:
50 return (ip4_fib_table_lookup(&fib_table->v4,
53 case FIB_PROTOCOL_IP6:
54 return (ip6_fib_table_lookup(fib_table->ft_index,
57 case FIB_PROTOCOL_MPLS:
58 return (mpls_fib_table_lookup(&fib_table->mpls,
62 return (FIB_NODE_INDEX_INVALID);
66 fib_table_lookup (u32 fib_index,
67 const fib_prefix_t *prefix)
69 return (fib_table_lookup_i(fib_table_get(fib_index, prefix->fp_proto), prefix));
72 static inline fib_node_index_t
73 fib_table_lookup_exact_match_i (const fib_table_t *fib_table,
74 const fib_prefix_t *prefix)
76 switch (prefix->fp_proto)
78 case FIB_PROTOCOL_IP4:
79 return (ip4_fib_table_lookup_exact_match(&fib_table->v4,
82 case FIB_PROTOCOL_IP6:
83 return (ip6_fib_table_lookup_exact_match(fib_table->ft_index,
86 case FIB_PROTOCOL_MPLS:
87 return (mpls_fib_table_lookup(&fib_table->mpls,
91 return (FIB_NODE_INDEX_INVALID);
95 fib_table_lookup_exact_match (u32 fib_index,
96 const fib_prefix_t *prefix)
98 return (fib_table_lookup_exact_match_i(fib_table_get(fib_index,
103 static fib_node_index_t
104 fib_table_get_less_specific_i (fib_table_t *fib_table,
105 const fib_prefix_t *prefix)
111 if (FIB_PROTOCOL_MPLS == pfx.fp_proto)
113 return (FIB_NODE_INDEX_INVALID);
117 * in the absence of a tree structure for the table that allows for an O(1)
118 * parent get, a cheeky way to find the cover is to LPM for the prefix with
120 * there should always be a cover, though it may be the default route. the
121 * default route's cover is the default route.
123 if (pfx.fp_len != 0) {
127 return (fib_table_lookup_i(fib_table, &pfx));
131 fib_table_get_less_specific (u32 fib_index,
132 const fib_prefix_t *prefix)
134 return (fib_table_get_less_specific_i(fib_table_get(fib_index,
140 fib_table_entry_remove (fib_table_t *fib_table,
141 const fib_prefix_t *prefix,
142 fib_node_index_t fib_entry_index)
144 vlib_smp_unsafe_warning();
146 fib_table->ft_total_route_counts--;
148 switch (prefix->fp_proto)
150 case FIB_PROTOCOL_IP4:
151 ip4_fib_table_entry_remove(&fib_table->v4,
152 &prefix->fp_addr.ip4,
155 case FIB_PROTOCOL_IP6:
156 ip6_fib_table_entry_remove(fib_table->ft_index,
157 &prefix->fp_addr.ip6,
160 case FIB_PROTOCOL_MPLS:
161 mpls_fib_table_entry_remove(&fib_table->mpls,
167 fib_entry_unlock(fib_entry_index);
171 fib_table_post_insert_actions (fib_table_t *fib_table,
172 const fib_prefix_t *prefix,
173 fib_node_index_t fib_entry_index)
175 fib_node_index_t fib_entry_cover_index;
178 * no cover relationships in the MPLS FIB
180 if (FIB_PROTOCOL_MPLS == prefix->fp_proto)
184 * find and inform the covering entry that a new more specific
185 * has been inserted beneath it
187 fib_entry_cover_index = fib_table_get_less_specific_i(fib_table, prefix);
189 * the indicies are the same when the default route is first added
191 if (fib_entry_cover_index != fib_entry_index)
193 fib_entry_cover_change_notify(fib_entry_cover_index,
199 fib_table_entry_insert (fib_table_t *fib_table,
200 const fib_prefix_t *prefix,
201 fib_node_index_t fib_entry_index)
203 vlib_smp_unsafe_warning();
205 fib_entry_lock(fib_entry_index);
206 fib_table->ft_total_route_counts++;
208 switch (prefix->fp_proto)
210 case FIB_PROTOCOL_IP4:
211 ip4_fib_table_entry_insert(&fib_table->v4,
212 &prefix->fp_addr.ip4,
216 case FIB_PROTOCOL_IP6:
217 ip6_fib_table_entry_insert(fib_table->ft_index,
218 &prefix->fp_addr.ip6,
222 case FIB_PROTOCOL_MPLS:
223 mpls_fib_table_entry_insert(&fib_table->mpls,
230 fib_table_post_insert_actions(fib_table, prefix, fib_entry_index);
234 fib_table_fwding_dpo_update (u32 fib_index,
235 const fib_prefix_t *prefix,
238 vlib_smp_unsafe_warning();
240 switch (prefix->fp_proto)
242 case FIB_PROTOCOL_IP4:
243 return (ip4_fib_table_fwding_dpo_update(ip4_fib_get(fib_index),
244 &prefix->fp_addr.ip4,
247 case FIB_PROTOCOL_IP6:
248 return (ip6_fib_table_fwding_dpo_update(fib_index,
249 &prefix->fp_addr.ip6,
252 case FIB_PROTOCOL_MPLS:
253 return (mpls_fib_forwarding_table_update(mpls_fib_get(fib_index),
261 fib_table_fwding_dpo_remove (u32 fib_index,
262 const fib_prefix_t *prefix,
265 vlib_smp_unsafe_warning();
267 switch (prefix->fp_proto)
269 case FIB_PROTOCOL_IP4:
270 return (ip4_fib_table_fwding_dpo_remove(ip4_fib_get(fib_index),
271 &prefix->fp_addr.ip4,
274 case FIB_PROTOCOL_IP6:
275 return (ip6_fib_table_fwding_dpo_remove(fib_index,
276 &prefix->fp_addr.ip6,
279 case FIB_PROTOCOL_MPLS:
280 return (mpls_fib_forwarding_table_reset(mpls_fib_get(fib_index),
288 fib_table_entry_special_dpo_add (u32 fib_index,
289 const fib_prefix_t *prefix,
291 fib_entry_flag_t flags,
294 fib_node_index_t fib_entry_index;
295 fib_table_t *fib_table;
297 fib_table = fib_table_get(fib_index, prefix->fp_proto);
298 fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
300 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
302 fib_entry_index = fib_entry_create_special(fib_index, prefix,
306 fib_table_entry_insert(fib_table, prefix, fib_entry_index);
307 fib_table->ft_src_route_counts[source]++;
313 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
314 fib_entry_special_add(fib_entry_index, source, flags, dpo);
316 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
318 fib_table->ft_src_route_counts[source]++;
323 return (fib_entry_index);
327 fib_table_entry_special_dpo_update (u32 fib_index,
328 const fib_prefix_t *prefix,
330 fib_entry_flag_t flags,
333 fib_node_index_t fib_entry_index;
334 fib_table_t *fib_table;
336 fib_table = fib_table_get(fib_index, prefix->fp_proto);
337 fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
339 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
341 fib_entry_index = fib_entry_create_special(fib_index, prefix,
345 fib_table_entry_insert(fib_table, prefix, fib_entry_index);
346 fib_table->ft_src_route_counts[source]++;
352 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
355 fib_entry_special_update(fib_entry_index, source, flags, dpo);
357 fib_entry_special_add(fib_entry_index, source, flags, dpo);
359 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
361 fib_table->ft_src_route_counts[source]++;
365 return (fib_entry_index);
369 fib_table_entry_special_add (u32 fib_index,
370 const fib_prefix_t *prefix,
372 fib_entry_flag_t flags,
373 adj_index_t adj_index)
375 fib_node_index_t fib_entry_index;
376 dpo_id_t tmp_dpo = DPO_INVALID;
378 if (ADJ_INDEX_INVALID != adj_index)
387 dpo_copy(&tmp_dpo, drop_dpo_get(fib_proto_to_dpo(prefix->fp_proto)));
390 fib_entry_index = fib_table_entry_special_dpo_add(fib_index, prefix, source,
393 dpo_unlock(&tmp_dpo);
395 return (fib_entry_index);
399 fib_table_entry_special_remove (u32 fib_index,
400 const fib_prefix_t *prefix,
405 * yes => remove source
406 * 2 - is it still sourced?
409 fib_node_index_t fib_entry_index;
410 fib_table_t *fib_table;
412 fib_table = fib_table_get(fib_index, prefix->fp_proto);
413 fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
415 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
418 * removing an etry that does not exist. i'll allow it.
423 fib_entry_src_flag_t src_flag;
427 * don't nobody go nowhere
429 fib_entry_lock(fib_entry_index);
430 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
432 src_flag = fib_entry_special_remove(fib_entry_index, source);
434 if (!(FIB_ENTRY_SRC_FLAG_ADDED & src_flag))
437 * last source gone. remove from the table
439 fib_table_entry_remove(fib_table, prefix, fib_entry_index);
442 * now the entry is no longer in the table, we can
443 * inform the entries that it covers to re-calculate their cover
445 fib_entry_cover_change_notify(fib_entry_index,
446 FIB_NODE_INDEX_INVALID);
450 * still has sources, leave it be.
452 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
454 fib_table->ft_src_route_counts[source]--;
457 fib_entry_unlock(fib_entry_index);
462 * fib_table_route_path_fixup
464 * Convert attached hosts to attached next-hops.
466 * This special case is required because an attached path will link to a
467 * glean, and the FIB entry will have the interface or API/CLI source. When
468 * the ARP/ND process is completes then that source (which will provide a
469 * complete adjacency) will be lower priority and so the FIB entry will
470 * remain linked to a glean and traffic will never reach the hosts. For
471 * an ATTAHCED_HOST path we can link the path directly to the [incomplete]
475 fib_table_route_path_fixup (const fib_prefix_t *prefix,
476 fib_route_path_t *path)
478 if (fib_prefix_is_host(prefix) &&
479 ip46_address_is_zero(&path->frp_addr) &&
480 path->frp_sw_if_index != ~0)
482 path->frp_addr = prefix->fp_addr;
483 path->frp_flags |= FIB_ROUTE_PATH_ATTACHED;
488 fib_table_entry_path_add (u32 fib_index,
489 const fib_prefix_t *prefix,
491 fib_entry_flag_t flags,
492 fib_protocol_t next_hop_proto,
493 const ip46_address_t *next_hop,
494 u32 next_hop_sw_if_index,
495 u32 next_hop_fib_index,
497 mpls_label_t *next_hop_labels,
498 fib_route_path_flags_t path_flags)
500 fib_route_path_t path = {
501 .frp_proto = next_hop_proto,
502 .frp_addr = (NULL == next_hop? zero_addr : *next_hop),
503 .frp_sw_if_index = next_hop_sw_if_index,
504 .frp_fib_index = next_hop_fib_index,
505 .frp_weight = next_hop_weight,
506 .frp_flags = path_flags,
507 .frp_label_stack = next_hop_labels,
509 fib_node_index_t fib_entry_index;
510 fib_route_path_t *paths = NULL;
512 vec_add1(paths, path);
514 fib_entry_index = fib_table_entry_path_add2(fib_index, prefix,
515 source, flags, paths);
518 return (fib_entry_index);
522 fib_table_entry_path_add2 (u32 fib_index,
523 const fib_prefix_t *prefix,
525 fib_entry_flag_t flags,
526 fib_route_path_t *rpath)
528 fib_node_index_t fib_entry_index;
529 fib_table_t *fib_table;
532 fib_table = fib_table_get(fib_index, prefix->fp_proto);
533 fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
535 for (ii = 0; ii < vec_len(rpath); ii++)
537 fib_table_route_path_fixup(prefix, &rpath[ii]);
540 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
542 fib_entry_index = fib_entry_create(fib_index, prefix,
546 fib_table_entry_insert(fib_table, prefix, fib_entry_index);
547 fib_table->ft_src_route_counts[source]++;
553 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
554 fib_entry_path_add(fib_entry_index, source, flags, rpath);;
556 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
558 fib_table->ft_src_route_counts[source]++;
562 return (fib_entry_index);
566 fib_table_entry_path_remove2 (u32 fib_index,
567 const fib_prefix_t *prefix,
569 fib_route_path_t *rpath)
573 * yes => remove source
574 * 2 - is it still sourced?
577 fib_node_index_t fib_entry_index;
578 fib_table_t *fib_table;
581 fib_table = fib_table_get(fib_index, prefix->fp_proto);
582 fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
584 for (ii = 0; ii < vec_len(rpath); ii++)
586 fib_table_route_path_fixup(prefix, &rpath[ii]);
589 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
592 * removing an etry that does not exist. i'll allow it.
597 fib_entry_src_flag_t src_flag;
601 * don't nobody go nowhere
603 fib_entry_lock(fib_entry_index);
604 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
606 src_flag = fib_entry_path_remove(fib_entry_index, source, rpath);
608 if (!(FIB_ENTRY_SRC_FLAG_ADDED & src_flag))
611 * last source gone. remove from the table
613 fib_table_entry_remove(fib_table, prefix, fib_entry_index);
616 * now the entry is no longer in the table, we can
617 * inform the entries that it covers to re-calculate their cover
619 fib_entry_cover_change_notify(fib_entry_index,
620 FIB_NODE_INDEX_INVALID);
624 * still has sources, leave it be.
626 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
628 fib_table->ft_src_route_counts[source]--;
631 fib_entry_unlock(fib_entry_index);
636 fib_table_entry_path_remove (u32 fib_index,
637 const fib_prefix_t *prefix,
639 fib_protocol_t next_hop_proto,
640 const ip46_address_t *next_hop,
641 u32 next_hop_sw_if_index,
642 u32 next_hop_fib_index,
644 fib_route_path_flags_t path_flags)
648 * yes => remove source
649 * 2 - is it still sourced?
652 fib_route_path_t path = {
653 .frp_proto = next_hop_proto,
654 .frp_addr = (NULL == next_hop? zero_addr : *next_hop),
655 .frp_sw_if_index = next_hop_sw_if_index,
656 .frp_fib_index = next_hop_fib_index,
657 .frp_weight = next_hop_weight,
658 .frp_flags = path_flags,
660 fib_route_path_t *paths = NULL;
662 fib_table_route_path_fixup(prefix, &path);
663 vec_add1(paths, path);
665 fib_table_entry_path_remove2(fib_index, prefix, source, paths);
671 fib_route_path_cmp_for_sort (void * v1,
674 return (fib_route_path_cmp(v1, v2));
678 fib_table_entry_update (u32 fib_index,
679 const fib_prefix_t *prefix,
681 fib_entry_flag_t flags,
682 fib_route_path_t *paths)
684 fib_node_index_t fib_entry_index;
685 fib_table_t *fib_table;
688 fib_table = fib_table_get(fib_index, prefix->fp_proto);
689 fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix);
691 for (ii = 0; ii < vec_len(paths); ii++)
693 fib_table_route_path_fixup(prefix, &paths[ii]);
696 * sort the paths provided by the control plane. this means
697 * the paths and the extension on the entry will be sorted.
699 vec_sort_with_function(paths, fib_route_path_cmp_for_sort);
701 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
703 fib_entry_index = fib_entry_create(fib_index, prefix,
707 fib_table_entry_insert(fib_table, prefix, fib_entry_index);
708 fib_table->ft_src_route_counts[source]++;
714 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
715 fib_entry_update(fib_entry_index, source, flags, paths);
717 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
719 fib_table->ft_src_route_counts[source]++;
723 return (fib_entry_index);
727 fib_table_entry_update_one_path (u32 fib_index,
728 const fib_prefix_t *prefix,
730 fib_entry_flag_t flags,
731 fib_protocol_t next_hop_proto,
732 const ip46_address_t *next_hop,
733 u32 next_hop_sw_if_index,
734 u32 next_hop_fib_index,
736 mpls_label_t *next_hop_labels,
737 fib_route_path_flags_t path_flags)
739 fib_node_index_t fib_entry_index;
740 fib_route_path_t path = {
741 .frp_proto = next_hop_proto,
742 .frp_addr = (NULL == next_hop? zero_addr : *next_hop),
743 .frp_sw_if_index = next_hop_sw_if_index,
744 .frp_fib_index = next_hop_fib_index,
745 .frp_weight = next_hop_weight,
746 .frp_flags = path_flags,
747 .frp_label_stack = next_hop_labels,
749 fib_route_path_t *paths = NULL;
751 fib_table_route_path_fixup(prefix, &path);
752 vec_add1(paths, path);
755 fib_table_entry_update(fib_index, prefix, source, flags, paths);
759 return (fib_entry_index);
763 fib_table_entry_delete_i (u32 fib_index,
764 fib_node_index_t fib_entry_index,
765 const fib_prefix_t *prefix,
768 fib_entry_src_flag_t src_flag;
769 fib_table_t *fib_table;
772 fib_table = fib_table_get(fib_index, prefix->fp_proto);
773 was_sourced = fib_entry_is_sourced(fib_entry_index, source);
776 * don't nobody go nowhere
778 fib_entry_lock(fib_entry_index);
780 src_flag = fib_entry_delete(fib_entry_index, source);
782 if (!(FIB_ENTRY_SRC_FLAG_ADDED & src_flag))
785 * last source gone. remove from the table
787 fib_table_entry_remove(fib_table, prefix, fib_entry_index);
790 * now the entry is no longer in the table, we can
791 * inform the entries that it covers to re-calculate their cover
793 fib_entry_cover_change_notify(fib_entry_index,
794 FIB_NODE_INDEX_INVALID);
798 * still has sources, leave it be.
800 if (was_sourced != fib_entry_is_sourced(fib_entry_index, source))
802 fib_table->ft_src_route_counts[source]--;
805 fib_entry_unlock(fib_entry_index);
809 fib_table_entry_delete (u32 fib_index,
810 const fib_prefix_t *prefix,
813 fib_node_index_t fib_entry_index;
815 fib_entry_index = fib_table_lookup_exact_match(fib_index, prefix);
817 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
820 * removing an etry that does not exist.
821 * i'll allow it, but i won't like it.
823 clib_warning("%U not in FIB", format_fib_prefix, prefix);
827 fib_table_entry_delete_i(fib_index, fib_entry_index, prefix, source);
832 fib_table_entry_delete_index (fib_node_index_t fib_entry_index,
837 fib_entry_get_prefix(fib_entry_index, &prefix);
839 fib_table_entry_delete_i(fib_entry_get_fib_index(fib_entry_index),
840 fib_entry_index, &prefix, source);
844 fib_table_entry_local_label_add (u32 fib_index,
845 const fib_prefix_t *prefix,
848 fib_node_index_t fib_entry_index;
850 fib_entry_index = fib_table_lookup_exact_match(fib_index, prefix);
852 if (FIB_NODE_INDEX_INVALID == fib_entry_index ||
853 !fib_entry_is_sourced(fib_entry_index, FIB_SOURCE_MPLS))
856 * only source the prefix once. this allows the label change
859 fib_entry_index = fib_table_entry_special_dpo_add(fib_index, prefix,
865 fib_entry_set_source_data(fib_entry_index, FIB_SOURCE_MPLS, &label);
867 return (fib_entry_index);
871 fib_table_entry_local_label_remove (u32 fib_index,
872 const fib_prefix_t *prefix,
875 fib_node_index_t fib_entry_index;
879 fib_entry_index = fib_table_lookup_exact_match(fib_index, prefix);
881 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
884 data = fib_entry_get_source_data(fib_entry_index, FIB_SOURCE_MPLS);
889 pl = *(mpls_label_t*)data;
894 pl = MPLS_LABEL_INVALID;
896 fib_entry_set_source_data(fib_entry_index, FIB_SOURCE_MPLS, &pl);
897 fib_table_entry_special_remove(fib_index,
903 fib_table_get_index_for_sw_if_index (fib_protocol_t proto,
908 case FIB_PROTOCOL_IP4:
909 return (ip4_fib_table_get_index_for_sw_if_index(sw_if_index));
910 case FIB_PROTOCOL_IP6:
911 return (ip6_fib_table_get_index_for_sw_if_index(sw_if_index));
912 case FIB_PROTOCOL_MPLS:
913 return (mpls_fib_table_get_index_for_sw_if_index(sw_if_index));
919 fib_table_get_flow_hash_config (u32 fib_index,
920 fib_protocol_t proto)
924 case FIB_PROTOCOL_IP4:
925 return (ip4_fib_table_get_flow_hash_config(fib_index));
926 case FIB_PROTOCOL_IP6:
927 return (ip6_fib_table_get_flow_hash_config(fib_index));
928 case FIB_PROTOCOL_MPLS:
929 return (mpls_fib_table_get_flow_hash_config(fib_index));
936 fib_table_get_table_id_for_sw_if_index (fib_protocol_t proto,
939 fib_table_t *fib_table;
941 fib_table = fib_table_get(fib_table_get_index_for_sw_if_index(
945 return ((NULL != fib_table ? fib_table->ft_table_id : ~0));
949 fib_table_find (fib_protocol_t proto,
954 case FIB_PROTOCOL_IP4:
955 return (ip4_fib_index_from_table_id(table_id));
956 case FIB_PROTOCOL_IP6:
957 return (ip6_fib_index_from_table_id(table_id));
958 case FIB_PROTOCOL_MPLS:
959 return (mpls_fib_index_from_table_id(table_id));
965 fib_table_find_or_create_and_lock (fib_protocol_t proto,
968 fib_table_t *fib_table;
973 case FIB_PROTOCOL_IP4:
974 fi = ip4_fib_table_find_or_create_and_lock(table_id);
976 case FIB_PROTOCOL_IP6:
977 fi = ip6_fib_table_find_or_create_and_lock(table_id);
979 case FIB_PROTOCOL_MPLS:
980 fi = mpls_fib_table_find_or_create_and_lock(table_id);
986 fib_table = fib_table_get(fi, proto);
988 fib_table->ft_desc = format(NULL, "%U-VRF:%d",
989 format_fib_protocol, proto,
996 fib_table_create_and_lock (fib_protocol_t proto,
997 const char *const fmt,
1000 fib_table_t *fib_table;
1001 fib_node_index_t fi;
1008 case FIB_PROTOCOL_IP4:
1009 fi = ip4_fib_table_create_and_lock();
1011 case FIB_PROTOCOL_IP6:
1012 fi = ip6_fib_table_create_and_lock();
1014 case FIB_PROTOCOL_MPLS:
1015 fi = mpls_fib_table_create_and_lock();
1021 fib_table = fib_table_get(fi, proto);
1023 fib_table->ft_desc = va_format(fib_table->ft_desc, fmt, &ap);
1030 fib_table_destroy (fib_table_t *fib_table)
1032 vec_free(fib_table->ft_desc);
1034 switch (fib_table->ft_proto)
1036 case FIB_PROTOCOL_IP4:
1037 ip4_fib_table_destroy(&fib_table->v4);
1039 case FIB_PROTOCOL_IP6:
1040 ip6_fib_table_destroy(fib_table->ft_index);
1042 case FIB_PROTOCOL_MPLS:
1043 mpls_fib_table_destroy(&fib_table->mpls);
1049 fib_table_walk (u32 fib_index,
1050 fib_protocol_t proto,
1051 fib_table_walk_fn_t fn,
1056 case FIB_PROTOCOL_IP4:
1057 ip4_fib_table_walk(ip4_fib_get(fib_index), fn, ctx);
1059 case FIB_PROTOCOL_IP6:
1060 ip6_fib_table_walk(fib_index, fn, ctx);
1062 case FIB_PROTOCOL_MPLS:
1063 mpls_fib_table_walk(mpls_fib_get(fib_index), fn, ctx);
1069 fib_table_unlock (u32 fib_index,
1070 fib_protocol_t proto)
1072 fib_table_t *fib_table;
1074 fib_table = fib_table_get(fib_index, proto);
1075 fib_table->ft_locks--;
1077 if (0 == fib_table->ft_locks)
1079 fib_table_destroy(fib_table);
1083 fib_table_lock (u32 fib_index,
1084 fib_protocol_t proto)
1086 fib_table_t *fib_table;
1088 fib_table = fib_table_get(fib_index, proto);
1089 fib_table->ft_locks++;
1093 fib_table_get_num_entries (u32 fib_index,
1094 fib_protocol_t proto,
1095 fib_source_t source)
1097 fib_table_t *fib_table;
1099 fib_table = fib_table_get(fib_index, proto);
1101 return (fib_table->ft_src_route_counts[source]);
1105 format_fib_table_name (u8* s, va_list ap)
1107 fib_node_index_t fib_index = va_arg(ap, fib_node_index_t);
1108 fib_protocol_t proto = va_arg(ap, int); // int promotion
1109 fib_table_t *fib_table;
1111 fib_table = fib_table_get(fib_index, proto);
1113 s = format(s, "%v", fib_table->ft_desc);
1119 * @brief Table flush context. Store the indicies of matching FIB entries
1120 * that need to be removed.
1122 typedef struct fib_table_flush_ctx_t_
1125 * The list of entries to flush
1127 fib_node_index_t *ftf_entries;
1130 * The source we are flushing
1132 fib_source_t ftf_source;
1133 } fib_table_flush_ctx_t;
1136 fib_table_flush_cb (fib_node_index_t fib_entry_index,
1139 fib_table_flush_ctx_t *ctx = arg;
1141 if (fib_entry_is_sourced(fib_entry_index, ctx->ftf_source))
1143 vec_add1(ctx->ftf_entries, fib_entry_index);
1150 fib_table_flush (u32 fib_index,
1151 fib_protocol_t proto,
1152 fib_source_t source)
1154 fib_node_index_t *fib_entry_index;
1155 fib_table_flush_ctx_t ctx = {
1156 .ftf_entries = NULL,
1157 .ftf_source = source,
1160 fib_table_walk(fib_index, proto,
1164 vec_foreach(fib_entry_index, ctx.ftf_entries)
1166 fib_table_entry_delete_index(*fib_entry_index, source);
1169 vec_free(ctx.ftf_entries);