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/ip/format.h>
18 #include <vnet/ip/lookup.h>
19 #include <vnet/adj/adj.h>
20 #include <vnet/dpo/load_balance.h>
21 #include <vnet/dpo/drop_dpo.h>
23 #include <vnet/fib/fib_entry.h>
24 #include <vnet/fib/fib_walk.h>
25 #include <vnet/fib/fib_entry_src.h>
26 #include <vnet/fib/fib_entry_cover.h>
27 #include <vnet/fib/fib_table.h>
28 #include <vnet/fib/fib_internal.h>
29 #include <vnet/fib/fib_attached_export.h>
30 #include <vnet/fib/fib_path_ext.h>
31 #include <vnet/fib/fib_entry_delegate.h>
32 #include <vnet/fib/fib_entry_track.h>
35 * Array of strings/names for the FIB sources
37 static const char *fib_attribute_names[] = FIB_ENTRY_ATTRIBUTES;
38 static const char *fib_src_attribute_names[] = FIB_ENTRY_SRC_ATTRIBUTES;
41 * Pool for all fib_entries
43 static fib_entry_t *fib_entry_pool;
48 vlib_log_class_t fib_entry_logger;
51 fib_entry_get (fib_node_index_t index)
53 return (pool_elt_at_index(fib_entry_pool, index));
57 fib_entry_get_node (fib_node_index_t index)
59 return ((fib_node_t*)fib_entry_get(index));
63 fib_entry_get_index (const fib_entry_t * fib_entry)
65 return (fib_entry - fib_entry_pool);
69 fib_entry_get_proto (const fib_entry_t * fib_entry)
71 return (fib_entry->fe_prefix.fp_proto);
75 fib_entry_get_dpo_proto (const fib_entry_t * fib_entry)
77 return (fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto));
80 fib_forward_chain_type_t
81 fib_entry_get_default_chain_type (const fib_entry_t *fib_entry)
83 switch (fib_entry->fe_prefix.fp_proto)
85 case FIB_PROTOCOL_IP4:
86 return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
87 case FIB_PROTOCOL_IP6:
88 return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
89 case FIB_PROTOCOL_MPLS:
90 if (MPLS_EOS == fib_entry->fe_prefix.fp_eos)
91 return (FIB_FORW_CHAIN_TYPE_MPLS_EOS);
93 return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
96 return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
100 format_fib_entry_flags (u8 *s, va_list *args)
102 fib_entry_attribute_t attr;
103 fib_entry_flag_t flag = va_arg(*args, int);
105 FOR_EACH_FIB_ATTRIBUTE(attr) {
106 if ((1<<attr) & flag) {
107 s = format (s, "%s,", fib_attribute_names[attr]);
115 format_fib_entry_src_flags (u8 *s, va_list *args)
117 fib_entry_src_attribute_t sattr;
118 fib_entry_src_flag_t flag = va_arg(*args, int);
120 FOR_EACH_FIB_SRC_ATTRIBUTE(sattr) {
121 if ((1<<sattr) & flag) {
122 s = format (s, "%s,", fib_src_attribute_names[sattr]);
130 format_fib_entry (u8 * s, va_list * args)
132 fib_forward_chain_type_t fct;
133 fib_entry_t *fib_entry;
134 fib_entry_src_t *src;
135 fib_node_index_t fei;
139 fei = va_arg (*args, fib_node_index_t);
140 level = va_arg (*args, int);
141 fib_entry = fib_entry_get(fei);
143 s = format (s, "%U", format_fib_prefix, &fib_entry->fe_prefix);
145 if (level >= FIB_ENTRY_FORMAT_DETAIL)
147 s = format (s, " fib:%d", fib_entry->fe_fib_index);
148 s = format (s, " index:%d", fib_entry_get_index(fib_entry));
149 s = format (s, " locks:%d", fib_entry->fe_node.fn_locks);
151 FOR_EACH_SRC_ADDED(fib_entry, src, source,
153 s = format (s, "\n %U", format_fib_source, source);
154 s = format (s, " refs:%d", src->fes_ref_count);
155 if (FIB_ENTRY_FLAG_NONE != src->fes_entry_flags) {
156 s = format(s, " entry-flags:%U",
157 format_fib_entry_flags, src->fes_entry_flags);
159 if (FIB_ENTRY_SRC_FLAG_NONE != src->fes_flags) {
160 s = format(s, " src-flags:%U",
161 format_fib_entry_src_flags, src->fes_flags);
163 s = fib_entry_src_format(fib_entry, source, s);
164 s = format (s, "\n");
165 if (FIB_NODE_INDEX_INVALID != src->fes_pl)
167 s = fib_path_list_format(src->fes_pl, s);
169 s = format(s, "%U", format_fib_path_ext_list, &src->fes_path_exts);
172 s = format (s, "\n forwarding: ");
176 s = format (s, "\n");
179 fct = fib_entry_get_default_chain_type(fib_entry);
181 if (!dpo_id_is_valid(&fib_entry->fe_lb))
183 s = format (s, " UNRESOLVED\n");
188 s = format(s, " %U-chain\n %U",
189 format_fib_forw_chain_type, fct,
195 if (level >= FIB_ENTRY_FORMAT_DETAIL2)
199 s = format (s, " Delegates:\n");
200 vec_foreach(fedi, fib_entry->fe_delegates)
202 s = format(s, " %U\n", format_fib_entry_delegate, *fedi);
207 if (level >= FIB_ENTRY_FORMAT_DETAIL2)
209 s = format(s, " Children:");
210 s = fib_node_children_format(fib_entry->fe_node.fn_children, s);
217 fib_entry_from_fib_node (fib_node_t *node)
219 ASSERT(FIB_NODE_TYPE_ENTRY == node->fn_type);
220 return ((fib_entry_t*)node);
224 fib_entry_last_lock_gone (fib_node_t *node)
226 fib_entry_delegate_type_t fdt;
227 fib_entry_delegate_t *fed;
228 fib_entry_t *fib_entry;
230 fib_entry = fib_entry_from_fib_node(node);
232 ASSERT(!dpo_id_is_valid(&fib_entry->fe_lb));
234 FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
236 dpo_reset(&fed->fd_dpo);
237 fib_entry_delegate_remove(fib_entry, fdt);
240 FIB_ENTRY_DBG(fib_entry, "last-lock");
242 fib_node_deinit(&fib_entry->fe_node);
244 ASSERT(0 == vec_len(fib_entry->fe_delegates));
245 vec_free(fib_entry->fe_delegates);
246 vec_free(fib_entry->fe_srcs);
247 pool_put(fib_entry_pool, fib_entry);
250 static fib_entry_src_t*
251 fib_entry_get_best_src_i (const fib_entry_t *fib_entry)
253 fib_entry_src_t *bsrc;
256 * the enum of sources is deliberately arranged in priority order
258 if (0 == vec_len(fib_entry->fe_srcs))
264 bsrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
271 fib_entry_src_get_source (const fib_entry_src_t *esrc)
275 return (esrc->fes_src);
277 return (FIB_SOURCE_INVALID);
280 static fib_entry_flag_t
281 fib_entry_src_get_flags (const fib_entry_src_t *esrc)
285 return (esrc->fes_entry_flags);
287 return (FIB_ENTRY_FLAG_NONE);
291 fib_entry_get_flags (fib_node_index_t fib_entry_index)
293 return (fib_entry_get_flags_i(fib_entry_get(fib_entry_index)));
297 fib_entry_show_memory (void)
299 u32 n_srcs = 0, n_exts = 0;
300 fib_entry_src_t *esrc;
303 fib_show_memory_usage("Entry",
304 pool_elts(fib_entry_pool),
305 pool_len(fib_entry_pool),
306 sizeof(fib_entry_t));
308 pool_foreach (entry, fib_entry_pool)
310 n_srcs += vec_len(entry->fe_srcs);
311 vec_foreach(esrc, entry->fe_srcs)
313 n_exts += fib_path_ext_list_length(&esrc->fes_path_exts);
317 fib_show_memory_usage("Entry Source",
318 n_srcs, n_srcs, sizeof(fib_entry_src_t));
319 fib_show_memory_usage("Entry Path-Extensions",
321 sizeof(fib_path_ext_t));
325 * @brief Contribute the set of Adjacencies that this entry forwards with
326 * to build the uRPF list of its children
329 fib_entry_contribute_urpf (fib_node_index_t entry_index,
332 fib_entry_t *fib_entry;
334 fib_entry = fib_entry_get(entry_index);
336 return (fib_path_list_contribute_urpf(fib_entry->fe_parent, urpf));
340 * If the client is request a chain for multicast forwarding then swap
341 * the chain type to one that can provide such transport.
343 static fib_forward_chain_type_t
344 fib_entry_chain_type_mcast_to_ucast (fib_forward_chain_type_t fct)
348 case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
349 case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
351 * we can only transport IP multicast packets if there is an
354 fct = FIB_FORW_CHAIN_TYPE_MPLS_EOS;
356 case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
357 case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
358 case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
359 case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
360 case FIB_FORW_CHAIN_TYPE_ETHERNET:
361 case FIB_FORW_CHAIN_TYPE_NSH:
362 case FIB_FORW_CHAIN_TYPE_BIER:
370 * fib_entry_contribute_forwarding
372 * Get an lock the forwarding information (DPO) contributed by the FIB entry.
375 fib_entry_contribute_forwarding (fib_node_index_t fib_entry_index,
376 fib_forward_chain_type_t fct,
379 fib_entry_delegate_t *fed;
380 fib_entry_t *fib_entry;
382 fib_entry = fib_entry_get(fib_entry_index);
385 * mfib children ask for mcast chains. fix these to the appropriate ucast types.
387 fct = fib_entry_chain_type_mcast_to_ucast(fct);
389 if (fct == fib_entry_get_default_chain_type(fib_entry))
391 dpo_copy(dpo, &fib_entry->fe_lb);
395 fed = fib_entry_delegate_find(fib_entry,
396 fib_entry_chain_type_to_delegate_type(fct));
401 * use a temporary DPO lest the delegate realloc in the recursive
404 dpo_id_t tmp = DPO_INVALID;
407 * on-demand create eos/non-eos.
408 * There is no on-demand delete because:
409 * - memory versus complexity & reliability:
410 * leaving unrequired [n]eos LB arounds wastes memory, cleaning
411 * then up on the right trigger is more code. i favour the latter.
413 fib_entry_src_mk_lb(fib_entry,
414 fib_entry_get_best_source(fib_entry_index),
418 fed = fib_entry_delegate_find_or_add(
420 fib_entry_chain_type_to_delegate_type(fct));
422 dpo_copy(&fed->fd_dpo, &tmp);
426 dpo_copy(dpo, &fed->fd_dpo);
429 * use the drop DPO is nothing else is present
431 if (!dpo_id_is_valid(dpo))
433 dpo_copy(dpo, drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct)));
437 * don't allow the special index indicating replicate.vs.load-balance
438 * to escape to the clients
440 dpo->dpoi_index &= ~MPLS_IS_REPLICATE;
444 fib_entry_contribute_ip_forwarding (fib_node_index_t fib_entry_index)
446 fib_forward_chain_type_t fct;
447 fib_entry_t *fib_entry;
449 fib_entry = fib_entry_get(fib_entry_index);
450 fct = fib_entry_get_default_chain_type(fib_entry);
452 ASSERT((fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP4 ||
453 fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP6));
455 if (dpo_id_is_valid(&fib_entry->fe_lb))
457 return (&fib_entry->fe_lb);
460 return (drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct)));
464 fib_entry_get_adj (fib_node_index_t fib_entry_index)
468 dpo = fib_entry_contribute_ip_forwarding(fib_entry_index);
470 if (dpo_id_is_valid(dpo))
472 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
476 return (dpo->dpoi_index);
479 return (ADJ_INDEX_INVALID);
483 fib_entry_get_path_list (fib_node_index_t fib_entry_index)
485 fib_entry_t *fib_entry;
487 fib_entry = fib_entry_get(fib_entry_index);
489 return (fib_entry->fe_parent);
493 fib_entry_child_add (fib_node_index_t fib_entry_index,
494 fib_node_type_t child_type,
495 fib_node_index_t child_index)
497 return (fib_node_child_add(FIB_NODE_TYPE_ENTRY,
504 fib_entry_child_remove (fib_node_index_t fib_entry_index,
507 fib_node_child_remove(FIB_NODE_TYPE_ENTRY,
511 if (0 == fib_node_get_n_children(FIB_NODE_TYPE_ENTRY,
515 * if there are no children left then there is no reason to keep
516 * the non-default forwarding chains. those chains are built only
517 * because the children want them.
519 fib_entry_delegate_type_t fdt;
520 fib_entry_delegate_t *fed;
521 fib_entry_t *fib_entry;
523 fib_entry = fib_entry_get(fib_entry_index);
525 FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
527 dpo_reset(&fed->fd_dpo);
528 fib_entry_delegate_remove(fib_entry, fdt);
534 fib_entry_alloc (u32 fib_index,
535 const fib_prefix_t *prefix,
536 fib_node_index_t *fib_entry_index)
538 fib_entry_t *fib_entry;
540 u8 need_barrier_sync = 0;
541 vlib_main_t *vm = vlib_get_main();
542 ASSERT (vm->thread_index == 0);
544 pool_get_will_expand (fib_entry_pool, need_barrier_sync );
545 if (need_barrier_sync)
546 vlib_worker_thread_barrier_sync (vm);
548 pool_get(fib_entry_pool, fib_entry);
550 if (need_barrier_sync)
551 vlib_worker_thread_barrier_release (vm);
553 clib_memset(fib_entry, 0, sizeof(*fib_entry));
555 fib_node_init(&fib_entry->fe_node,
556 FIB_NODE_TYPE_ENTRY);
558 fib_entry->fe_fib_index = fib_index;
561 * the one time we need to update the const prefix is when
562 * the entry is first created
564 fep = (fib_prefix_t*)&(fib_entry->fe_prefix);
567 if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto)
570 if (MPLS_NON_EOS == fep->fp_eos)
572 fep->fp_payload_proto = DPO_PROTO_MPLS;
574 ASSERT(DPO_PROTO_NONE != fib_entry->fe_prefix.fp_payload_proto);
577 dpo_reset(&fib_entry->fe_lb);
579 *fib_entry_index = fib_entry_get_index(fib_entry);
585 fib_entry_post_flag_update_actions (fib_entry_t *fib_entry,
586 fib_entry_flag_t old_flags,
589 fib_node_index_t fei;
592 * save the index so we can recover from pool reallocs
594 fei = fib_entry_get_index(fib_entry);
597 * handle changes to attached export for import entries
599 int is_import = (FIB_ENTRY_FLAG_IMPORT & fib_entry_get_flags_i(fib_entry));
600 int was_import = (FIB_ENTRY_FLAG_IMPORT & old_flags);
602 if (!was_import && is_import)
605 * transition from not exported to exported
609 * there is an assumption here that the entry resolves via only
610 * one interface and that it is the cross VRF interface.
612 if (~0 == new_fib_index)
614 u32 sw_if_index = fib_path_list_get_resolving_interface(fib_entry->fe_parent);
615 new_fib_index = fib_table_get_index_for_sw_if_index(
616 fib_entry_get_proto(fib_entry),
619 fib_attached_export_import(fib_entry, new_fib_index);
621 else if (was_import && !is_import)
624 * transition from exported to not exported
626 fib_attached_export_purge(fib_entry);
628 else if (was_import && is_import && ~0 != new_fib_index)
631 * transition from export from one table to another
633 fib_attached_export_purge(fib_entry);
634 fib_attached_export_import(fib_entry, new_fib_index);
638 * no change. nothing to do.
642 * reload the entry address post possible pool realloc
644 fib_entry = fib_entry_get(fei);
647 * handle changes to attached export for export entries
649 int is_attached = (FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags_i(fib_entry));
650 int was_attached = (FIB_ENTRY_FLAG_ATTACHED & old_flags);
652 if (!was_attached && is_attached)
655 * transition to attached. time to export
665 fib_entry_post_install_actions (fib_entry_t *fib_entry,
667 fib_entry_flag_t old_flags)
669 fib_entry = fib_entry_post_flag_update_actions(fib_entry, old_flags, ~0);
670 fib_entry = fib_entry_src_action_installed(fib_entry, source);
676 fib_entry_create (u32 fib_index,
677 const fib_prefix_t *prefix,
679 fib_entry_flag_t flags,
680 const fib_route_path_t *paths)
682 fib_node_index_t fib_entry_index;
683 fib_entry_t *fib_entry;
685 ASSERT(0 < vec_len(paths));
687 fib_entry = fib_entry_alloc(fib_index, prefix, &fib_entry_index);
690 * since this is a new entry create, we don't need to check for winning
691 * sources - there is only one.
693 fib_entry = fib_entry_src_action_add(fib_entry, source, flags,
696 fib_entry_get_proto(fib_entry))));
697 fib_entry_src_action_path_swap(fib_entry,
702 * handle possible realloc's by refetching the pointer
704 fib_entry = fib_entry_get(fib_entry_index);
705 fib_entry_src_action_activate(fib_entry, source);
707 fib_entry = fib_entry_post_install_actions(fib_entry, source,
708 FIB_ENTRY_FLAG_NONE);
710 FIB_ENTRY_DBG(fib_entry, "create");
712 return (fib_entry_index);
716 fib_entry_create_special (u32 fib_index,
717 const fib_prefix_t *prefix,
719 fib_entry_flag_t flags,
722 fib_node_index_t fib_entry_index;
723 fib_entry_t *fib_entry;
726 * create and initialize the new enty
728 fib_entry = fib_entry_alloc(fib_index, prefix, &fib_entry_index);
731 * create the path-list
733 fib_entry = fib_entry_src_action_add(fib_entry, source, flags, dpo);
734 fib_entry_src_action_activate(fib_entry, source);
736 fib_entry = fib_entry_post_install_actions(fib_entry, source,
737 FIB_ENTRY_FLAG_NONE);
739 FIB_ENTRY_DBG(fib_entry, "create-special");
741 return (fib_entry_index);
745 fib_entry_post_update_actions (fib_entry_t *fib_entry,
747 fib_entry_flag_t old_flags)
750 * backwalk to children to inform then of the change to forwarding.
752 fib_node_back_walk_ctx_t bw_ctx = {
753 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_EVALUATE,
756 fib_walk_sync(FIB_NODE_TYPE_ENTRY, fib_entry_get_index(fib_entry), &bw_ctx);
759 * then inform any covered prefixes
761 fib_entry_cover_update_notify(fib_entry);
763 fib_entry_post_install_actions(fib_entry, source, old_flags);
767 fib_entry_recalculate_forwarding (fib_node_index_t fib_entry_index)
769 fib_source_t best_source;
770 fib_entry_t *fib_entry;
771 fib_entry_src_t *bsrc;
773 fib_entry = fib_entry_get(fib_entry_index);
775 bsrc = fib_entry_get_best_src_i(fib_entry);
776 best_source = fib_entry_src_get_source(bsrc);
778 fib_entry_src_action_reactivate(fib_entry, best_source);
782 fib_entry_source_change_w_flags (fib_entry_t *fib_entry,
783 fib_source_t old_source,
784 fib_entry_flag_t old_flags,
785 fib_source_t new_source)
787 switch (fib_source_cmp(new_source, old_source))
789 case FIB_SOURCE_CMP_BETTER:
791 * we have a new winning source.
793 fib_entry_src_action_deactivate(fib_entry, old_source);
794 fib_entry_src_action_activate(fib_entry, new_source);
797 case FIB_SOURCE_CMP_WORSE:
799 * the new source loses. Re-activate the winning sources
800 * in case it is an interposer and hence relied on the losing
801 * source's path-list.
803 fib_entry_src_action_reactivate(fib_entry, old_source);
806 case FIB_SOURCE_CMP_EQUAL:
808 * the new source is one this entry already has.
809 * But the path-list was updated, which will contribute new forwarding,
812 fib_entry_src_action_reactivate(fib_entry, new_source);
816 fib_entry_post_update_actions(fib_entry, new_source, old_flags);
820 fib_entry_source_change (fib_entry_t *fib_entry,
821 fib_source_t old_source,
822 fib_source_t new_source)
824 fib_entry_flag_t old_flags;
826 old_flags = fib_entry_get_flags_for_source(
827 fib_entry_get_index(fib_entry), old_source);
829 return (fib_entry_source_change_w_flags(fib_entry, old_source,
830 old_flags, new_source));
834 fib_entry_special_add (fib_node_index_t fib_entry_index,
836 fib_entry_flag_t flags,
839 fib_source_t best_source;
840 fib_entry_t *fib_entry;
842 fib_entry = fib_entry_get(fib_entry_index);
843 best_source = fib_entry_get_best_source(fib_entry_index);
845 fib_entry = fib_entry_src_action_add(fib_entry, source, flags, dpo);
846 fib_entry_source_change(fib_entry, best_source, source);
847 FIB_ENTRY_DBG(fib_entry, "special-add:%U", format_fib_source, source);
851 fib_entry_special_update (fib_node_index_t fib_entry_index,
853 fib_entry_flag_t flags,
856 fib_source_t best_source;
857 fib_entry_t *fib_entry;
859 fib_entry = fib_entry_get(fib_entry_index);
860 best_source = fib_entry_get_best_source(fib_entry_index);
862 fib_entry = fib_entry_src_action_update(fib_entry, source, flags, dpo);
863 fib_entry_source_change(fib_entry, best_source, source);
865 FIB_ENTRY_DBG(fib_entry, "special-updated:%U", format_fib_source, source);
870 fib_entry_path_add (fib_node_index_t fib_entry_index,
872 fib_entry_flag_t flags,
873 const fib_route_path_t *rpaths)
875 fib_source_t best_source;
876 fib_entry_t *fib_entry;
877 fib_entry_src_t *bsrc;
879 fib_entry = fib_entry_get(fib_entry_index);
880 ASSERT(NULL != fib_entry);
882 bsrc = fib_entry_get_best_src_i(fib_entry);
883 best_source = fib_entry_src_get_source(bsrc);
885 fib_entry = fib_entry_src_action_path_add(fib_entry, source, flags, rpaths);
887 fib_entry_source_change(fib_entry, best_source, source);
889 FIB_ENTRY_DBG(fib_entry, "path add:%U", format_fib_source, source);
892 static fib_entry_src_flag_t
893 fib_entry_src_burn_only_inherited (fib_entry_t *fib_entry)
895 fib_entry_src_t *src;
897 int has_only_inherited_sources = 1;
899 FOR_EACH_SRC_ADDED(fib_entry, src, source,
901 if (!(src->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
903 has_only_inherited_sources = 0;
907 if (has_only_inherited_sources)
909 FOR_EACH_SRC_ADDED(fib_entry, src, source,
911 fib_entry_src_action_remove(fib_entry, source);
913 return (FIB_ENTRY_SRC_FLAG_NONE);
917 return (FIB_ENTRY_SRC_FLAG_ADDED);
921 static fib_entry_src_flag_t
922 fib_entry_source_removed (fib_entry_t *fib_entry,
923 fib_entry_flag_t old_flags)
925 const fib_entry_src_t *bsrc;
926 fib_source_t best_source;
929 * if all that is left are inherited sources, then burn them
931 fib_entry_src_burn_only_inherited(fib_entry);
933 bsrc = fib_entry_get_best_src_i(fib_entry);
934 best_source = fib_entry_src_get_source(bsrc);
936 if (FIB_SOURCE_INVALID == best_source)
939 * no more sources left. this entry is toast.
941 fib_entry = fib_entry_post_flag_update_actions(fib_entry, old_flags, ~0);
942 fib_entry_src_action_uninstall(fib_entry);
944 return (FIB_ENTRY_SRC_FLAG_NONE);
948 fib_entry_src_action_activate(fib_entry, best_source);
951 fib_entry_post_update_actions(fib_entry, best_source, old_flags);
956 return (FIB_ENTRY_SRC_FLAG_ADDED);
960 * fib_entry_path_remove
962 * remove a path from the entry.
963 * return the fib_entry's index if it is still present, INVALID otherwise.
966 fib_entry_path_remove (fib_node_index_t fib_entry_index,
968 const fib_route_path_t *rpaths)
970 fib_entry_src_flag_t sflag;
971 fib_source_t best_source;
972 fib_entry_flag_t bflags;
973 fib_entry_t *fib_entry;
974 fib_entry_src_t *bsrc;
976 fib_entry = fib_entry_get(fib_entry_index);
977 ASSERT(NULL != fib_entry);
979 bsrc = fib_entry_get_best_src_i(fib_entry);
980 best_source = fib_entry_src_get_source(bsrc);
981 bflags = fib_entry_src_get_flags(bsrc);
983 sflag = fib_entry_src_action_path_remove(fib_entry, source, rpaths);
985 FIB_ENTRY_DBG(fib_entry, "path remove:%U", format_fib_source, source);
988 * if the path list for the source passed is invalid,
989 * then we need to create a new one. else we are updating
992 switch (fib_source_cmp(source, best_source))
994 case FIB_SOURCE_CMP_BETTER:
996 * Que! removing a path from a source that is better than the
997 * one this entry is using.
1001 case FIB_SOURCE_CMP_WORSE:
1003 * the source is not the best. no need to update forwarding
1005 if (FIB_ENTRY_SRC_FLAG_ADDED & sflag)
1008 * the source being removed still has paths
1010 return (FIB_ENTRY_SRC_FLAG_ADDED);
1015 * that was the last path from this source, check if those
1016 * that remain are non-inherited
1018 return (fib_entry_src_burn_only_inherited(fib_entry));
1021 case FIB_SOURCE_CMP_EQUAL:
1023 * removing a path from the path-list we were using.
1025 if (!(FIB_ENTRY_SRC_FLAG_ADDED & sflag))
1028 * the last path from the source was removed.
1029 * fallback to lower source
1031 return (fib_entry_source_removed(fib_entry, bflags));
1036 * re-install the new forwarding information
1038 fib_entry_src_action_reactivate(fib_entry, source);
1043 fib_entry_post_update_actions(fib_entry, source, bflags);
1046 * still have sources
1048 return (FIB_ENTRY_SRC_FLAG_ADDED);
1052 * fib_entry_special_remove
1054 * remove a special source from the entry.
1055 * return the fib_entry's index if it is still present, INVALID otherwise.
1057 fib_entry_src_flag_t
1058 fib_entry_special_remove (fib_node_index_t fib_entry_index,
1059 fib_source_t source)
1061 fib_entry_src_flag_t sflag;
1062 fib_source_t best_source;
1063 fib_entry_flag_t bflags;
1064 fib_entry_t *fib_entry;
1065 fib_entry_src_t *bsrc;
1067 fib_entry = fib_entry_get(fib_entry_index);
1068 ASSERT(NULL != fib_entry);
1070 bsrc = fib_entry_get_best_src_i(fib_entry);
1071 best_source = fib_entry_src_get_source(bsrc);
1072 bflags = fib_entry_src_get_flags(bsrc);
1074 FIB_ENTRY_DBG(fib_entry, "special remove:%U", format_fib_source, source);
1076 sflag = fib_entry_src_action_remove_or_update_inherit(fib_entry, source);
1079 * if the path list for the source passed is invalid,
1080 * then we need to create a new one. else we are updating
1083 switch (fib_source_cmp(source, best_source))
1085 case FIB_SOURCE_CMP_BETTER:
1087 * Que! removing a path from a source that is better than the
1088 * one this entry is using. This can only mean it is a source
1089 * this prefix does not have.
1091 return (FIB_ENTRY_SRC_FLAG_ADDED);
1093 case FIB_SOURCE_CMP_WORSE:
1095 * the source is not the best. no need to update forwarding
1097 if (FIB_ENTRY_SRC_FLAG_ADDED & sflag)
1100 * the source being removed still has paths
1102 return (FIB_ENTRY_SRC_FLAG_ADDED);
1107 * that was the last path from this source, check if those
1108 * that remain are non-inherited
1110 if (FIB_ENTRY_SRC_FLAG_NONE == fib_entry_src_burn_only_inherited(fib_entry))
1113 * no more sources left. this entry is toast.
1115 fib_entry = fib_entry_post_flag_update_actions(fib_entry, bflags, ~0);
1116 fib_entry_src_action_uninstall(fib_entry);
1117 return (FIB_ENTRY_SRC_FLAG_NONE);
1121 * reactivate the best source so the interposer gets restacked
1123 fib_entry_src_action_reactivate(fib_entry, best_source);
1125 return (FIB_ENTRY_SRC_FLAG_ADDED);
1129 case FIB_SOURCE_CMP_EQUAL:
1130 if (!(FIB_ENTRY_SRC_FLAG_ADDED & sflag))
1133 * the source was removed. use the next best.
1135 return (fib_entry_source_removed(fib_entry, bflags));
1140 * re-install the new forwarding information
1142 fib_entry_src_action_reactivate(fib_entry, source);
1147 fib_entry_post_update_actions(fib_entry, source, bflags);
1150 * still have sources
1152 return (FIB_ENTRY_SRC_FLAG_ADDED);
1158 * If the source on the cover is inheriting then push this source
1159 * down to the covered.
1162 fib_entry_inherit (fib_node_index_t cover,
1163 fib_node_index_t covered)
1165 fib_entry_src_inherit(fib_entry_get(cover),
1166 fib_entry_get(covered));
1172 * The source is withdrawing all the paths it provided
1174 fib_entry_src_flag_t
1175 fib_entry_delete (fib_node_index_t fib_entry_index,
1176 fib_source_t source)
1178 return (fib_entry_special_remove(fib_entry_index, source));
1184 * The source has provided a new set of paths that will replace the old.
1187 fib_entry_update (fib_node_index_t fib_entry_index,
1188 fib_source_t source,
1189 fib_entry_flag_t flags,
1190 const fib_route_path_t *paths)
1192 fib_source_t best_source;
1193 fib_entry_flag_t bflags;
1194 fib_entry_t *fib_entry;
1195 fib_entry_src_t *bsrc;
1197 fib_entry = fib_entry_get(fib_entry_index);
1198 ASSERT(NULL != fib_entry);
1200 bsrc = fib_entry_get_best_src_i(fib_entry);
1201 best_source = fib_entry_src_get_source(bsrc);
1202 bflags = fib_entry_get_flags_i(fib_entry);
1204 fib_entry = fib_entry_src_action_path_swap(fib_entry,
1209 fib_entry_source_change_w_flags(fib_entry, best_source, bflags, source);
1210 FIB_ENTRY_DBG(fib_entry, "update");
1215 * fib_entry_cover_changed
1217 * this entry is tracking its cover and that cover has changed.
1220 fib_entry_cover_changed (fib_node_index_t fib_entry_index)
1222 fib_entry_src_cover_res_t res = {
1224 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
1226 CLIB_UNUSED(fib_source_t source);
1227 fib_source_t best_source;
1228 fib_entry_flag_t bflags;
1229 fib_entry_t *fib_entry;
1230 fib_entry_src_t *esrc;
1233 bflags = FIB_ENTRY_FLAG_NONE;
1234 best_source = FIB_SOURCE_FIRST;
1235 fib_entry = fib_entry_get(fib_entry_index);
1237 fib_attached_export_cover_change(fib_entry);
1240 * propagate the notification to each of the added sources
1243 FOR_EACH_SRC_ADDED(fib_entry, esrc, source,
1248 * only the best source gets to set the back walk flags
1250 res = fib_entry_src_action_cover_change(fib_entry, esrc);
1251 bflags = fib_entry_src_get_flags(esrc);
1252 best_source = fib_entry_src_get_source(esrc);
1256 fib_entry_src_action_cover_change(fib_entry, esrc);
1263 fib_entry_src_action_reactivate(fib_entry,
1264 fib_entry_src_get_source(
1265 fib_entry_get_best_src_i(fib_entry)));
1266 fib_entry = fib_entry_post_install_actions(fib_entry,
1272 fib_entry_src_action_uninstall(fib_entry);
1275 if (FIB_NODE_BW_REASON_FLAG_NONE != res.bw_reason)
1278 * time for walkies fido.
1280 fib_node_back_walk_ctx_t bw_ctx = {
1281 .fnbw_reason = res.bw_reason,
1284 fib_walk_sync(FIB_NODE_TYPE_ENTRY, fib_entry_index, &bw_ctx);
1286 FIB_ENTRY_DBG(fib_entry, "cover-changed");
1290 * fib_entry_cover_updated
1292 * this entry is tracking its cover and that cover has been updated
1293 * (i.e. its forwarding information has changed).
1296 fib_entry_cover_updated (fib_node_index_t fib_entry_index)
1298 fib_entry_src_cover_res_t res = {
1300 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
1302 CLIB_UNUSED(fib_source_t source);
1303 fib_source_t best_source;
1304 fib_entry_flag_t bflags;
1305 fib_entry_t *fib_entry;
1306 fib_entry_src_t *esrc;
1309 bflags = FIB_ENTRY_FLAG_NONE;
1310 best_source = FIB_SOURCE_FIRST;
1311 fib_entry = fib_entry_get(fib_entry_index);
1313 fib_attached_export_cover_update(fib_entry);
1316 * propagate the notification to each of the added sources
1319 FOR_EACH_SRC_ADDED(fib_entry, esrc, source,
1324 * only the best source gets to set the install result
1326 res = fib_entry_src_action_cover_update(fib_entry, esrc);
1327 bflags = fib_entry_src_get_flags(esrc);
1328 best_source = fib_entry_src_get_source(esrc);
1333 * contirubting sources can set backwalk flags
1335 if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_CONTRIBUTING)
1337 fib_entry_src_cover_res_t tmp = {
1339 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
1342 tmp = fib_entry_src_action_cover_update(fib_entry, esrc);
1343 res.bw_reason |= tmp.bw_reason;
1347 fib_entry_src_action_cover_update(fib_entry, esrc);
1355 fib_entry_src_action_reactivate(fib_entry,
1356 fib_entry_src_get_source(
1357 fib_entry_get_best_src_i(fib_entry)));
1358 fib_entry = fib_entry_post_install_actions(fib_entry,
1364 fib_entry_src_action_uninstall(fib_entry);
1367 if (FIB_NODE_BW_REASON_FLAG_NONE != res.bw_reason)
1370 * time for walkies fido.
1372 fib_node_back_walk_ctx_t bw_ctx = {
1373 .fnbw_reason = res.bw_reason,
1376 fib_walk_sync(FIB_NODE_TYPE_ENTRY, fib_entry_index, &bw_ctx);
1378 FIB_ENTRY_DBG(fib_entry, "cover-updated");
1382 fib_entry_recursive_loop_detect (fib_node_index_t entry_index,
1383 fib_node_index_t **entry_indicies)
1385 fib_entry_t *fib_entry;
1386 int was_looped, is_looped;
1388 fib_entry = fib_entry_get(entry_index);
1390 if (FIB_NODE_INDEX_INVALID != fib_entry->fe_parent)
1392 fib_node_index_t *entries = *entry_indicies;
1394 vec_add1(entries, entry_index);
1395 was_looped = fib_path_list_is_looped(fib_entry->fe_parent);
1396 is_looped = fib_path_list_recursive_loop_detect(fib_entry->fe_parent,
1399 *entry_indicies = entries;
1401 if (!!was_looped != !!is_looped)
1404 * re-evaluate all the entry's forwarding
1405 * NOTE: this is an inplace modify
1407 fib_entry_delegate_type_t fdt;
1408 fib_entry_delegate_t *fed;
1410 FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
1412 fib_entry_src_mk_lb(fib_entry,
1413 fib_entry_get_best_source(entry_index),
1414 fib_entry_delegate_type_to_chain_type(fdt),
1422 * the entry is currently not linked to a path-list. this happens
1423 * when it is this entry that is re-linking path-lists and has thus
1433 * fib_entry_attached_cross_table
1435 * Return true if the route is attached via an interface that
1436 * is not in the same table as the route
1439 fib_entry_attached_cross_table (const fib_entry_t *fib_entry,
1442 const fib_prefix_t *pfx = &fib_entry->fe_prefix;
1444 switch (pfx->fp_proto)
1446 case FIB_PROTOCOL_MPLS:
1447 /* MPLS routes are never imported/exported */
1449 case FIB_PROTOCOL_IP6:
1450 /* Ignore link local addresses these also can't be imported/exported */
1451 if (ip6_address_is_link_local_unicast (&pfx->fp_addr.ip6))
1456 case FIB_PROTOCOL_IP4:
1460 return (fib_entry->fe_fib_index != fib_index);
1464 * fib_entry_back_walk_notify
1466 * A back walk has reach this entry.
1468 static fib_node_back_walk_rc_t
1469 fib_entry_back_walk_notify (fib_node_t *node,
1470 fib_node_back_walk_ctx_t *ctx)
1472 fib_source_t best_source;
1473 fib_entry_t *fib_entry;
1474 fib_entry_src_t *bsrc;
1476 fib_entry = fib_entry_from_fib_node(node);
1477 bsrc = fib_entry_get_best_src_i(fib_entry);
1478 best_source = fib_entry_src_get_source(bsrc);
1480 if (FIB_NODE_BW_REASON_FLAG_INTERFACE_BIND & ctx->fnbw_reason)
1482 fib_entry_flag_t bflags;
1484 bflags = fib_entry_src_get_flags(bsrc);
1486 fib_entry_src_action_reactivate(fib_entry, best_source);
1488 /* re-evaluate whether the prefix is cross table */
1489 if (fib_entry_attached_cross_table(
1490 fib_entry, ctx->interface_bind.fnbw_to_fib_index) &&
1491 !(bsrc->fes_entry_flags & FIB_ENTRY_FLAG_NO_ATTACHED_EXPORT))
1493 bsrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
1497 bsrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
1500 fib_entry = fib_entry_post_flag_update_actions(
1502 ctx->interface_bind.fnbw_to_fib_index);
1504 else if (FIB_NODE_BW_REASON_FLAG_EVALUATE & ctx->fnbw_reason ||
1505 FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE & ctx->fnbw_reason ||
1506 FIB_NODE_BW_REASON_FLAG_ADJ_DOWN & ctx->fnbw_reason ||
1507 FIB_NODE_BW_REASON_FLAG_INTERFACE_UP & ctx->fnbw_reason ||
1508 FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN & ctx->fnbw_reason ||
1509 FIB_NODE_BW_REASON_FLAG_INTERFACE_BIND & ctx->fnbw_reason ||
1510 FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE & ctx->fnbw_reason)
1512 fib_entry_src_action_reactivate(fib_entry, best_source);
1516 * all other walk types can be reclassifed to a re-evaluate to
1517 * all recursive dependents.
1518 * By reclassifying we ensure that should any of these walk types meet
1519 * they can be merged.
1521 ctx->fnbw_reason = FIB_NODE_BW_REASON_FLAG_EVALUATE;
1524 * ... and nothing is forced sync from now on.
1526 ctx->fnbw_flags &= ~FIB_NODE_BW_FLAG_FORCE_SYNC;
1528 FIB_ENTRY_DBG(fib_entry, "bw:%U",
1529 format_fib_node_bw_reason, ctx->fnbw_reason);
1532 * propagate the backwalk further if we haven't already reached the
1535 fib_walk_sync(FIB_NODE_TYPE_ENTRY,
1536 fib_entry_get_index(fib_entry),
1539 return (FIB_NODE_BACK_WALK_CONTINUE);
1543 * The FIB path-list's graph node virtual function table
1545 static const fib_node_vft_t fib_entry_vft = {
1546 .fnv_get = fib_entry_get_node,
1547 .fnv_last_lock = fib_entry_last_lock_gone,
1548 .fnv_back_walk = fib_entry_back_walk_notify,
1549 .fnv_mem_show = fib_entry_show_memory,
1553 fib_entry_get_resolving_interface (fib_node_index_t entry_index)
1555 fib_entry_t *fib_entry;
1557 fib_entry = fib_entry_get(entry_index);
1559 return (fib_path_list_get_resolving_interface(fib_entry->fe_parent));
1563 fib_entry_get_any_resolving_interface (fib_node_index_t entry_index)
1565 const fib_entry_src_t *src;
1566 fib_entry_t *fib_entry;
1567 fib_source_t source;
1570 fib_entry = fib_entry_get(entry_index);
1572 FOR_EACH_SRC_ADDED(fib_entry, src, source,
1574 sw_if_index = fib_entry_get_resolving_interface_for_source (entry_index,
1577 if (~0 != sw_if_index)
1580 return (sw_if_index);
1584 fib_entry_get_best_source (fib_node_index_t entry_index)
1586 fib_entry_t *fib_entry;
1587 fib_entry_src_t *bsrc;
1589 fib_entry = fib_entry_get(entry_index);
1591 bsrc = fib_entry_get_best_src_i(fib_entry);
1592 return (fib_entry_src_get_source(bsrc));
1596 * Return !0 is the entry represents a host prefix
1599 fib_entry_is_host (fib_node_index_t fib_entry_index)
1601 return (fib_prefix_is_host(fib_entry_get_prefix(fib_entry_index)));
1605 * Return !0 is the entry is resolved, i.e. will return a valid forwarding
1609 fib_entry_is_resolved (fib_node_index_t fib_entry_index)
1611 fib_entry_delegate_t *fed;
1612 fib_entry_t *fib_entry;
1614 fib_entry = fib_entry_get(fib_entry_index);
1616 fed = fib_entry_delegate_find(fib_entry, FIB_ENTRY_DELEGATE_BFD);
1621 * no BFD tracking - consider it resolved.
1628 * defer to the state of the BFD tracking
1630 return (FIB_BFD_STATE_UP == fed->fd_bfd_state);
1635 fib_entry_set_flow_hash_config (fib_node_index_t fib_entry_index,
1636 flow_hash_config_t hash_config)
1638 fib_entry_t *fib_entry;
1640 fib_entry = fib_entry_get(fib_entry_index);
1643 * pass the hash-config on to the load-balance object where it is cached.
1644 * we can ignore LBs in the delegate chains, since they will not be of the
1645 * correct protocol type (i.e. they are not IP)
1646 * There's no way, nor need, to change the hash config for MPLS.
1648 if (dpo_id_is_valid(&fib_entry->fe_lb))
1652 ASSERT(DPO_LOAD_BALANCE == fib_entry->fe_lb.dpoi_type);
1654 lb = load_balance_get(fib_entry->fe_lb.dpoi_index);
1657 * atomic update for packets in flight
1659 lb->lb_hash_config = hash_config;
1664 fib_entry_get_stats_index (fib_node_index_t fib_entry_index)
1666 fib_entry_t *fib_entry;
1668 fib_entry = fib_entry_get(fib_entry_index);
1670 return (fib_entry->fe_lb.dpoi_index);
1674 fib_ip4_address_compare (const ip4_address_t * a1,
1675 const ip4_address_t * a2)
1678 * IP addresses are unsigned ints. the return value here needs to be signed
1679 * a simple subtraction won't cut it.
1680 * If the addresses are the same, the sort order is undefined, so phoey.
1682 return ((clib_net_to_host_u32(a1->data_u32) >
1683 clib_net_to_host_u32(a2->data_u32) ) ?
1688 fib_ip6_address_compare (const ip6_address_t * a1,
1689 const ip6_address_t * a2)
1692 for (i = 0; i < ARRAY_LEN (a1->as_u16); i++)
1694 int cmp = (clib_net_to_host_u16 (a1->as_u16[i]) -
1695 clib_net_to_host_u16 (a2->as_u16[i]));
1703 fib_entry_cmp (fib_node_index_t fib_entry_index1,
1704 fib_node_index_t fib_entry_index2)
1706 fib_entry_t *fib_entry1, *fib_entry2;
1709 fib_entry1 = fib_entry_get(fib_entry_index1);
1710 fib_entry2 = fib_entry_get(fib_entry_index2);
1712 switch (fib_entry1->fe_prefix.fp_proto)
1714 case FIB_PROTOCOL_IP4:
1715 cmp = fib_ip4_address_compare(&fib_entry1->fe_prefix.fp_addr.ip4,
1716 &fib_entry2->fe_prefix.fp_addr.ip4);
1718 case FIB_PROTOCOL_IP6:
1719 cmp = fib_ip6_address_compare(&fib_entry1->fe_prefix.fp_addr.ip6,
1720 &fib_entry2->fe_prefix.fp_addr.ip6);
1722 case FIB_PROTOCOL_MPLS:
1723 cmp = (fib_entry1->fe_prefix.fp_label - fib_entry2->fe_prefix.fp_label);
1727 cmp = (fib_entry1->fe_prefix.fp_eos - fib_entry2->fe_prefix.fp_eos);
1733 cmp = (fib_entry1->fe_prefix.fp_len - fib_entry2->fe_prefix.fp_len);
1739 fib_entry_cmp_for_sort (void *i1, void *i2)
1741 fib_node_index_t *fib_entry_index1 = i1, *fib_entry_index2 = i2;
1743 return (fib_entry_cmp(*fib_entry_index1,
1744 *fib_entry_index2));
1748 fib_entry_lock (fib_node_index_t fib_entry_index)
1750 fib_entry_t *fib_entry;
1752 fib_entry = fib_entry_get(fib_entry_index);
1754 fib_node_lock(&fib_entry->fe_node);
1758 fib_entry_unlock (fib_node_index_t fib_entry_index)
1760 fib_entry_t *fib_entry;
1762 fib_entry = fib_entry_get(fib_entry_index);
1764 fib_node_unlock(&fib_entry->fe_node);
1768 fib_entry_module_init (void)
1770 fib_node_register_type(FIB_NODE_TYPE_ENTRY, &fib_entry_vft);
1771 fib_entry_logger = vlib_log_register_class("fib", "entry");
1773 fib_entry_track_module_init();
1777 fib_entry_encode (fib_node_index_t fib_entry_index)
1779 fib_path_ext_list_t *ext_list;
1780 fib_path_encode_ctx_t ctx = {
1783 fib_entry_t *fib_entry;
1784 fib_entry_src_t *bsrc;
1787 fib_entry = fib_entry_get(fib_entry_index);
1788 bsrc = fib_entry_get_best_src_i(fib_entry);
1792 ext_list = &bsrc->fes_path_exts;
1795 if (FIB_NODE_INDEX_INVALID != fib_entry->fe_parent)
1797 fib_path_list_walk_w_ext(fib_entry->fe_parent,
1803 return (ctx.rpaths);
1806 const fib_prefix_t *
1807 fib_entry_get_prefix (fib_node_index_t fib_entry_index)
1809 fib_entry_t *fib_entry;
1811 fib_entry = fib_entry_get(fib_entry_index);
1813 return (&fib_entry->fe_prefix);
1817 fib_entry_get_fib_index (fib_node_index_t fib_entry_index)
1819 fib_entry_t *fib_entry;
1821 fib_entry = fib_entry_get(fib_entry_index);
1823 return (fib_entry->fe_fib_index);
1827 fib_entry_pool_size (void)
1829 return (pool_elts(fib_entry_pool));
1834 fib_table_assert_empty (const fib_table_t *fib_table)
1836 fib_node_index_t *fei, *feis = NULL;
1837 fib_entry_t *fib_entry;
1839 pool_foreach (fib_entry, fib_entry_pool)
1841 if (fib_entry->fe_fib_index == fib_table->ft_index)
1842 vec_add1 (feis, fib_entry_get_index(fib_entry));
1847 vec_foreach (fei, feis)
1848 clib_error ("%U", format_fib_entry, *fei, FIB_ENTRY_FORMAT_DETAIL);
1855 static clib_error_t *
1856 show_fib_entry_command (vlib_main_t * vm,
1857 unformat_input_t * input,
1858 vlib_cli_command_t * cmd)
1860 fib_node_index_t fei;
1862 if (unformat (input, "%d", &fei))
1865 * show one in detail
1867 if (!pool_is_free_index(fib_entry_pool, fei))
1869 vlib_cli_output (vm, "%d@%U",
1871 format_fib_entry, fei,
1872 FIB_ENTRY_FORMAT_DETAIL2);
1876 vlib_cli_output (vm, "entry %d invalid", fei);
1884 vlib_cli_output (vm, "FIB Entries:");
1885 pool_foreach_index (fei, fib_entry_pool)
1887 vlib_cli_output (vm, "%d@%U",
1889 format_fib_entry, fei,
1890 FIB_ENTRY_FORMAT_BRIEF);
1897 VLIB_CLI_COMMAND (show_fib_entry, static) = {
1898 .path = "show fib entry",
1899 .function = show_fib_entry_command,
1900 .short_help = "show fib entry",