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 <vnet/adj/adj.h>
17 #include <vnet/dpo/load_balance.h>
18 #include <vnet/dpo/mpls_label_dpo.h>
19 #include <vnet/dpo/drop_dpo.h>
20 #include <vnet/dpo/replicate_dpo.h>
22 #include <vnet/fib/fib_entry_src.h>
23 #include <vnet/fib/fib_table.h>
24 #include <vnet/fib/fib_path_ext.h>
25 #include <vnet/fib/fib_urpf_list.h>
26 #include <vnet/fib/fib_entry_delegate.h>
31 static fib_entry_src_vft_t fib_entry_src_bh_vft[FIB_SOURCE_BH_MAX];
34 * Get the VFT for a given source. This is a combination of the source
35 * enum and the interposer flags
37 const fib_entry_src_vft_t*
38 fib_entry_src_get_vft (const fib_entry_src_t *esrc)
40 fib_source_behaviour_t bh;
42 bh = fib_source_get_behaviour(esrc->fes_src);
44 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_INTERPOSE)
46 return (&fib_entry_src_bh_vft[FIB_SOURCE_BH_INTERPOSE]);
49 return (&fib_entry_src_bh_vft[bh]);
53 fib_entry_src_copy_default (const fib_entry_src_t *orig_src,
54 const fib_entry_t *fib_entry,
55 fib_entry_src_t *copy_src)
57 clib_memcpy(©_src->u, &orig_src->u, sizeof(copy_src->u));
61 fib_entry_src_behaviour_register (fib_source_behaviour_t bh,
62 const fib_entry_src_vft_t *vft)
64 fib_entry_src_bh_vft[bh] = *vft;
66 if (NULL == fib_entry_src_bh_vft[bh].fesv_copy)
68 fib_entry_src_bh_vft[bh].fesv_copy = fib_entry_src_copy_default;
73 fib_entry_src_cmp_for_sort (void * v1,
76 fib_entry_src_t *esrc1 = v1, *esrc2 = v2;
78 return (fib_source_get_prio(esrc1->fes_src) -
79 fib_source_get_prio(esrc2->fes_src));
83 fib_entry_src_action_init (fib_entry_t *fib_entry,
85 fib_entry_flag_t flags)
87 fib_entry_src_t esrc = {
88 .fes_pl = FIB_NODE_INDEX_INVALID,
89 .fes_flags = FIB_ENTRY_SRC_FLAG_NONE,
91 .fes_entry_flags = flags,
94 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, &esrc, fesv_init, (&esrc));
96 vec_add1(fib_entry->fe_srcs, esrc);
97 vec_sort_with_function(fib_entry->fe_srcs,
98 fib_entry_src_cmp_for_sort);
101 static fib_entry_src_t *
102 fib_entry_src_find_i (const fib_entry_t *fib_entry,
107 fib_entry_src_t *esrc;
111 vec_foreach(esrc, fib_entry->fe_srcs)
113 if (esrc->fes_src == source)
130 static fib_entry_src_t *
131 fib_entry_src_find (const fib_entry_t *fib_entry,
135 return (fib_entry_src_find_i(fib_entry, source, NULL));
139 fib_entry_is_sourced (fib_node_index_t fib_entry_index,
142 fib_entry_t *fib_entry;
144 fib_entry = fib_entry_get(fib_entry_index);
146 return (NULL != fib_entry_src_find(fib_entry, source));
150 fib_entry_is_marked (fib_node_index_t fib_entry_index,
153 fib_entry_t *fib_entry;
154 fib_entry_src_t *esrc;
156 fib_entry = fib_entry_get(fib_entry_index);
158 esrc = fib_entry_src_find(fib_entry, source);
166 return (!!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_STALE));
171 fib_entry_mark (fib_node_index_t fib_entry_index,
174 fib_entry_t *fib_entry;
175 fib_entry_src_t *esrc;
177 fib_entry = fib_entry_get(fib_entry_index);
179 esrc = fib_entry_src_find(fib_entry, source);
183 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_STALE;
187 static fib_entry_src_t *
188 fib_entry_src_find_or_create (fib_entry_t *fib_entry,
190 fib_entry_flag_t flags)
192 fib_entry_src_t *esrc;
194 esrc = fib_entry_src_find(fib_entry, source);
198 fib_entry_src_action_init(fib_entry, source, flags);
201 return (fib_entry_src_find(fib_entry, source));
205 fib_entry_src_action_deinit (fib_entry_t *fib_entry,
209 fib_entry_src_t *esrc;
212 esrc = fib_entry_src_find_i(fib_entry, source, &index);
214 ASSERT(NULL != esrc);
216 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deinit, (esrc));
218 fib_path_ext_list_flush(&esrc->fes_path_exts);
219 vec_del1(fib_entry->fe_srcs, index);
220 vec_sort_with_function(fib_entry->fe_srcs,
221 fib_entry_src_cmp_for_sort);
224 fib_entry_src_cover_res_t
225 fib_entry_src_action_cover_change (fib_entry_t *fib_entry,
226 fib_entry_src_t *esrc)
228 FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_cover_change,
231 fib_entry_src_cover_res_t res = {
233 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
238 fib_entry_src_cover_res_t
239 fib_entry_src_action_cover_update (fib_entry_t *fib_entry,
240 fib_entry_src_t *esrc)
242 FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_cover_update,
245 fib_entry_src_cover_res_t res = {
247 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
252 typedef struct fib_entry_src_collect_forwarding_ctx_t_
254 load_balance_path_t *next_hops;
255 const fib_entry_t *fib_entry;
256 const fib_entry_src_t *esrc;
257 fib_forward_chain_type_t fct;
258 int n_recursive_constrained;
260 } fib_entry_src_collect_forwarding_ctx_t;
263 * @brief Determine whether this FIB entry should use a load-balance MAP
264 * to support PIC edge fast convergence
267 fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx)
270 * We'll use a LB map if the path-list has multiple recursive paths.
271 * recursive paths implies BGP, and hence scale.
273 if (ctx->n_recursive_constrained > 1 &&
274 fib_path_list_is_popular(ctx->esrc->fes_pl))
276 return (LOAD_BALANCE_FLAG_USES_MAP);
278 return (LOAD_BALANCE_FLAG_NONE);
282 fib_entry_src_valid_out_label (mpls_label_t label)
284 return ((MPLS_LABEL_IS_REAL(label) ||
285 MPLS_LABEL_POP == label ||
286 MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL == label ||
287 MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL == label ||
288 MPLS_IETF_IMPLICIT_NULL_LABEL == label));
292 * @brief Turn the chain type requested by the client into the one they
295 fib_forward_chain_type_t
296 fib_entry_chain_type_fixup (const fib_entry_t *entry,
297 fib_forward_chain_type_t fct)
300 * The EOS chain is a tricky since one cannot know the adjacency
301 * to link to without knowing what the packets payload protocol
302 * will be once the label is popped.
304 fib_forward_chain_type_t dfct;
306 if (FIB_FORW_CHAIN_TYPE_MPLS_EOS != fct)
311 dfct = fib_entry_get_default_chain_type(entry);
313 if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
316 * If the entry being asked is a eos-MPLS label entry,
317 * then use the payload-protocol field, that we stashed there
318 * for just this purpose
320 return (fib_forw_chain_type_from_dpo_proto(
321 entry->fe_prefix.fp_payload_proto));
324 * else give them what this entry would be by default. i.e. if it's a v6
325 * entry, then the label its local labelled should be carrying v6 traffic.
326 * If it's a non-EOS label entry, then there are more labels and we want
333 fib_prefix_get_payload_proto (const fib_prefix_t *pfx)
335 switch (pfx->fp_proto)
337 case FIB_PROTOCOL_IP4:
338 return (DPO_PROTO_IP4);
339 case FIB_PROTOCOL_IP6:
340 return (DPO_PROTO_IP6);
341 case FIB_PROTOCOL_MPLS:
342 return (pfx->fp_payload_proto);
346 return (DPO_PROTO_IP4);
350 fib_entry_src_get_path_forwarding (fib_node_index_t path_index,
351 fib_entry_src_collect_forwarding_ctx_t *ctx)
353 load_balance_path_t *nh;
356 * no extension => no out-going label for this path. that's OK
357 * in the case of an IP or EOS chain, but not for non-EOS
361 case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
362 case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
363 case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
364 case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
365 case FIB_FORW_CHAIN_TYPE_BIER:
367 * EOS traffic with no label to stack, we need the IP Adj
369 vec_add2(ctx->next_hops, nh, 1);
371 nh->path_index = path_index;
372 nh->path_weight = fib_path_get_weight(path_index);
373 fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
376 case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
377 if (fib_path_is_exclusive(path_index) ||
378 fib_path_is_deag(path_index))
380 vec_add2(ctx->next_hops, nh, 1);
382 nh->path_index = path_index;
383 nh->path_weight = fib_path_get_weight(path_index);
384 fib_path_contribute_forwarding(path_index,
385 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
389 case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
392 * no label. we need a chain based on the payload. fixup.
394 vec_add2(ctx->next_hops, nh, 1);
396 nh->path_index = path_index;
397 nh->path_weight = fib_path_get_weight(path_index);
398 fib_path_contribute_forwarding(path_index,
399 fib_entry_chain_type_fixup(ctx->fib_entry,
402 fib_path_stack_mpls_disp(path_index,
403 fib_prefix_get_payload_proto(&ctx->fib_entry->fe_prefix),
404 FIB_MPLS_LSP_MODE_PIPE,
409 case FIB_FORW_CHAIN_TYPE_ETHERNET:
410 case FIB_FORW_CHAIN_TYPE_NSH:
416 static fib_path_list_walk_rc_t
417 fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
418 fib_node_index_t path_index,
421 fib_entry_src_collect_forwarding_ctx_t *ctx;
422 fib_path_ext_t *path_ext;
426 n_nhs = vec_len(ctx->next_hops);
429 * if the path is not resolved, don't include it.
431 if (!fib_path_is_resolved(path_index))
433 return (FIB_PATH_LIST_WALK_CONTINUE);
436 if (fib_path_is_recursive_constrained(path_index))
438 ctx->n_recursive_constrained += 1;
440 if (0xffff == ctx->preference)
443 * not set a preference yet, so the first path we encounter
444 * sets the preference we are collecting.
446 ctx->preference = fib_path_get_preference(path_index);
448 else if (ctx->preference != fib_path_get_preference(path_index))
451 * this path does not belong to the same preference as the
452 * previous paths encountered. we are done now.
454 return (FIB_PATH_LIST_WALK_STOP);
458 * get the matching path-extension for the path being visited.
460 path_ext = fib_path_ext_list_find_by_path_index(&ctx->esrc->fes_path_exts,
463 if (NULL != path_ext)
465 switch (path_ext->fpe_type)
467 case FIB_PATH_EXT_MPLS:
468 if (fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0].fml_value))
471 * found a matching extension. stack it to obtain the forwarding
472 * info for this path.
475 fib_path_ext_stack(path_ext,
477 fib_entry_chain_type_fixup(ctx->fib_entry,
483 fib_entry_src_get_path_forwarding(path_index, ctx);
486 case FIB_PATH_EXT_ADJ:
487 if (FIB_PATH_EXT_ADJ_FLAG_REFINES_COVER & path_ext->fpe_adj_flags)
489 fib_entry_src_get_path_forwarding(path_index, ctx);
493 * the path does not refine the cover, meaning that
494 * the adjacency does/does not match the sub-net on the link.
495 * So this path does not contribute forwarding.
502 fib_entry_src_get_path_forwarding(path_index, ctx);
506 * a this point 'ctx' has the DPO the path contributed, plus
507 * any labels from path extensions.
508 * check if there are any interpose sources that want to contribute
510 if (n_nhs < vec_len(ctx->next_hops))
513 * the path contributed a new choice.
515 const fib_entry_src_vft_t *vft;
517 vft = fib_entry_src_get_vft(ctx->esrc);
519 if (NULL != vft->fesv_contribute_interpose)
521 const dpo_id_t *interposer;
523 interposer = vft->fesv_contribute_interpose(ctx->esrc,
526 if (NULL != interposer)
528 dpo_id_t clone = DPO_INVALID;
530 dpo_mk_interpose(interposer,
531 &ctx->next_hops[n_nhs].path_dpo,
534 dpo_copy(&ctx->next_hops[n_nhs].path_dpo, &clone);
540 return (FIB_PATH_LIST_WALK_CONTINUE);
544 fib_entry_src_mk_lb (fib_entry_t *fib_entry,
545 const fib_entry_src_t *esrc,
546 fib_forward_chain_type_t fct,
549 dpo_proto_t lb_proto;
552 * If the entry has path extensions then we construct a load-balance
553 * by stacking the extensions on the forwarding chains of the paths.
554 * Otherwise we use the load-balance of the path-list
556 fib_entry_src_collect_forwarding_ctx_t ctx = {
558 .fib_entry = fib_entry,
560 .n_recursive_constrained = 0,
562 .preference = 0xffff,
566 * As an optimisation we allocate the vector of next-hops to be sized
567 * equal to the maximum number of paths we will need, which is also the
568 * most likely number we will need, since in most cases the paths are 'up'.
570 vec_validate(ctx.next_hops, fib_path_list_get_n_paths(esrc->fes_pl));
571 vec_reset_length(ctx.next_hops);
573 lb_proto = fib_forw_chain_type_to_dpo_proto(fct);
575 fib_path_list_walk(esrc->fes_pl,
576 fib_entry_src_collect_forwarding,
579 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_EXCLUSIVE)
582 * the client provided the DPO that the entry should link to.
583 * all entries must link to a LB, so if it is an LB already
584 * then we can use it.
586 if ((1 == vec_len(ctx.next_hops)) &&
587 (DPO_LOAD_BALANCE == ctx.next_hops[0].path_dpo.dpoi_type))
589 dpo_copy(dpo_lb, &ctx.next_hops[0].path_dpo);
590 dpo_reset(&ctx.next_hops[0].path_dpo);
595 if (!dpo_id_is_valid(dpo_lb))
600 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_MULTICAST)
605 MPLS_IS_REPLICATE | replicate_create(0, lb_proto));
609 fib_protocol_t flow_hash_proto;
610 flow_hash_config_t fhc;
613 * if the protocol for the LB we are building does not match that
614 * of the fib_entry (i.e. we are build the [n]EOS LB for an IPv[46]
615 * then the fib_index is not an index that relates to the table
616 * type we need. So get the default flow-hash config instead.
618 flow_hash_proto = dpo_proto_to_fib(lb_proto);
619 if (fib_entry->fe_prefix.fp_proto != flow_hash_proto)
621 fhc = fib_table_get_default_flow_hash_config(flow_hash_proto);
625 fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index,
632 load_balance_create(0, lb_proto, fhc));
636 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_MULTICAST)
641 replicate_multipath_update(dpo_lb, ctx.next_hops);
645 load_balance_multipath_update(dpo_lb,
647 fib_entry_calc_lb_flags(&ctx));
648 vec_free(ctx.next_hops);
651 * if this entry is sourced by the uRPF-exempt source then we
652 * append the always present local0 interface (index 0) to the
653 * uRPF list so it is not empty. that way packets pass the loose check.
655 index_t ui = fib_path_list_get_urpf(esrc->fes_pl);
657 if ((fib_entry_is_sourced(fib_entry_get_index(fib_entry),
658 FIB_SOURCE_URPF_EXEMPT) ||
659 (esrc->fes_entry_flags & FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT))&&
660 (0 == fib_urpf_check_size(ui)))
663 * The uRPF list we get from the path-list is shared by all
664 * other users of the list, but the uRPF exemption applies
665 * only to this prefix. So we need our own list.
667 ui = fib_urpf_list_alloc_and_lock();
668 fib_urpf_list_append(ui, 0);
669 fib_urpf_list_bake(ui);
670 load_balance_set_urpf(dpo_lb->dpoi_index, ui);
671 fib_urpf_list_unlock(ui);
675 load_balance_set_urpf(dpo_lb->dpoi_index, ui);
677 load_balance_set_fib_entry_flags(dpo_lb->dpoi_index,
678 fib_entry_get_flags_i(fib_entry));
683 fib_entry_src_action_install (fib_entry_t *fib_entry,
687 * Install the forwarding chain for the given source into the forwarding
690 fib_forward_chain_type_t fct;
691 fib_entry_src_t *esrc;
694 fct = fib_entry_get_default_chain_type(fib_entry);
695 esrc = fib_entry_src_find(fib_entry, source);
698 * Every entry has its own load-balance object. All changes to the entry's
699 * forwarding result in an inplace modify of the load-balance. This means
700 * the load-balance object only needs to be added to the forwarding
701 * DB once, when it is created.
703 insert = !dpo_id_is_valid(&fib_entry->fe_lb);
705 fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb);
707 ASSERT(dpo_id_is_valid(&fib_entry->fe_lb));
708 FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb);
711 * insert the adj into the data-plane forwarding trie
715 fib_table_fwding_dpo_update(fib_entry->fe_fib_index,
716 &fib_entry->fe_prefix,
721 * if any of the other chain types are already created they will need
724 fib_entry_delegate_type_t fdt;
725 fib_entry_delegate_t *fed;
727 FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
729 fib_entry_src_mk_lb(fib_entry, esrc,
730 fib_entry_delegate_type_to_chain_type(fdt),
736 fib_entry_src_action_uninstall (fib_entry_t *fib_entry)
739 * uninstall the forwarding chain from the forwarding tables
741 FIB_ENTRY_DBG(fib_entry, "uninstall");
743 if (dpo_id_is_valid(&fib_entry->fe_lb))
745 fib_table_fwding_dpo_remove(
746 fib_entry->fe_fib_index,
747 &fib_entry->fe_prefix,
750 dpo_reset(&fib_entry->fe_lb);
755 fib_entry_recursive_loop_detect_i (fib_node_index_t path_list_index)
757 fib_node_index_t *entries = NULL;
759 fib_path_list_recursive_loop_detect(path_list_index, &entries);
765 * fib_entry_src_action_copy
767 * copy a source data from another entry to this one
770 fib_entry_src_action_copy (fib_entry_t *fib_entry,
771 const fib_entry_src_t *orig_src)
773 fib_entry_src_t *esrc;
775 esrc = fib_entry_src_find_or_create(fib_entry,
777 orig_src->fes_entry_flags);
779 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_copy,
780 (orig_src, fib_entry, esrc));
782 fib_path_list_unlock(esrc->fes_pl);
785 * copy over all the data ...
787 esrc->fes_flags = orig_src->fes_flags;
788 esrc->fes_pl = orig_src->fes_pl;
793 esrc->fes_ref_count = 1;
794 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_INHERITED;
795 esrc->fes_flags &= ~(FIB_ENTRY_SRC_FLAG_ACTIVE |
796 FIB_ENTRY_SRC_FLAG_CONTRIBUTING);
797 esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_COVERED_INHERIT;
800 * the source owns a lock on the entry
802 fib_path_list_lock(esrc->fes_pl);
803 fib_entry_lock(fib_entry_get_index(fib_entry));
809 * fib_entry_src_action_update
811 * copy a source data from another entry to this one
813 static fib_entry_src_t *
814 fib_entry_src_action_update_from_cover (fib_entry_t *fib_entry,
815 const fib_entry_src_t *orig_src)
817 fib_entry_src_t *esrc;
819 esrc = fib_entry_src_find_or_create(fib_entry,
821 orig_src->fes_entry_flags);
824 * the source owns a lock on the entry
826 fib_path_list_unlock(esrc->fes_pl);
827 esrc->fes_pl = orig_src->fes_pl;
828 fib_path_list_lock(esrc->fes_pl);
833 static fib_table_walk_rc_t
834 fib_entry_src_covered_inherit_add_i (fib_entry_t *fib_entry,
835 const fib_entry_src_t *cover_src)
837 fib_entry_src_t *esrc;
839 esrc = fib_entry_src_find(fib_entry, cover_src->fes_src);
841 if (cover_src == esrc)
843 return (FIB_TABLE_WALK_CONTINUE);
849 * the covered entry already has this source.
851 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT)
854 * the covered source is itself a COVERED_INHERIT, i.e.
855 * it also pushes this source down the sub-tree.
856 * We consider this more specific covered to be the owner
857 * of the sub-tree from this point down.
859 return (FIB_TABLE_WALK_SUB_TREE_STOP);
861 if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED)
864 * The covered's source data has been inherited, presumably
865 * from this cover, i.e. this is a modify.
867 esrc = fib_entry_src_action_update_from_cover(fib_entry, cover_src);
868 fib_entry_source_change(fib_entry, esrc->fes_src, esrc->fes_src);
873 * The covered's source was not inherited and it is also
874 * not inheriting. Nevertheless, it still owns the sub-tree from
877 return (FIB_TABLE_WALK_SUB_TREE_STOP);
883 * The covered does not have this source - add it.
885 fib_source_t best_source;
887 best_source = fib_entry_get_best_source(
888 fib_entry_get_index(fib_entry));
890 fib_entry_src_action_copy(fib_entry, cover_src);
891 fib_entry_source_change(fib_entry, best_source, cover_src->fes_src);
894 return (FIB_TABLE_WALK_CONTINUE);
897 static fib_table_walk_rc_t
898 fib_entry_src_covered_inherit_walk_add (fib_node_index_t fei,
901 return (fib_entry_src_covered_inherit_add_i(fib_entry_get(fei), ctx));
904 static fib_table_walk_rc_t
905 fib_entry_src_covered_inherit_walk_remove (fib_node_index_t fei,
908 fib_entry_src_t *cover_src, *esrc;
909 fib_entry_t *fib_entry;
911 fib_entry = fib_entry_get(fei);
914 esrc = fib_entry_src_find(fib_entry, cover_src->fes_src);
916 if (cover_src == esrc)
918 return (FIB_TABLE_WALK_CONTINUE);
924 * the covered entry already has this source.
926 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT)
929 * the covered source is itself a COVERED_INHERIT, i.e.
930 * it also pushes this source down the sub-tree.
931 * We consider this more specific covered to be the owner
932 * of the sub-tree from this point down.
934 return (FIB_TABLE_WALK_SUB_TREE_STOP);
936 if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED)
939 * The covered's source data has been inherited, presumably
942 fib_entry_src_flag_t remaining;
944 remaining = fib_entry_special_remove(fei, cover_src->fes_src);
946 ASSERT(FIB_ENTRY_SRC_FLAG_ADDED == remaining);
951 * The covered's source was not inherited and it is also
952 * not inheriting. Nevertheless, it still owns the sub-tree from
955 return (FIB_TABLE_WALK_SUB_TREE_STOP);
961 * The covered does not have this source - that's an error,
962 * since it should have inherited, but there is nothing we can do
966 return (FIB_TABLE_WALK_CONTINUE);
970 fib_entry_src_inherit (const fib_entry_t *cover,
971 fib_entry_t *covered)
973 CLIB_UNUSED(fib_source_t source);
974 const fib_entry_src_t *src;
976 FOR_EACH_SRC_ADDED(cover, src, source,
978 if ((src->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) ||
979 (src->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
981 fib_entry_src_covered_inherit_add_i(covered, src);
987 fib_entry_src_covered_inherit_add (fib_entry_t *fib_entry,
991 fib_entry_src_t *esrc;
993 esrc = fib_entry_src_find(fib_entry, source);
995 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
997 if ((esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) ||
998 (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
1000 fib_table_sub_tree_walk(fib_entry->fe_fib_index,
1001 fib_entry->fe_prefix.fp_proto,
1002 &fib_entry->fe_prefix,
1003 fib_entry_src_covered_inherit_walk_add,
1009 fib_entry_src_covered_inherit_remove (fib_entry_t *fib_entry,
1010 fib_entry_src_t *esrc)
1013 ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
1015 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT)
1017 fib_table_sub_tree_walk(fib_entry->fe_fib_index,
1018 fib_entry->fe_prefix.fp_proto,
1019 &fib_entry->fe_prefix,
1020 fib_entry_src_covered_inherit_walk_remove,
1026 fib_entry_src_action_activate (fib_entry_t *fib_entry,
1027 fib_source_t source)
1030 int houston_we_are_go_for_install;
1031 const fib_entry_src_vft_t *vft;
1032 fib_entry_src_t *esrc;
1034 esrc = fib_entry_src_find(fib_entry, source);
1036 ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
1037 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
1039 esrc->fes_flags |= (FIB_ENTRY_SRC_FLAG_ACTIVE |
1040 FIB_ENTRY_SRC_FLAG_CONTRIBUTING);
1041 vft = fib_entry_src_get_vft(esrc);
1043 if (NULL != vft->fesv_activate)
1045 houston_we_are_go_for_install = vft->fesv_activate(esrc, fib_entry);
1050 * the source is not providing an activate function, we'll assume
1051 * therefore it has no objection to installing the entry
1053 houston_we_are_go_for_install = !0;
1057 * link to the path-list provided by the source, and go check
1058 * if that forms any loops in the graph.
1060 fib_entry->fe_parent = esrc->fes_pl;
1061 fib_entry->fe_sibling =
1062 fib_path_list_child_add(fib_entry->fe_parent,
1063 FIB_NODE_TYPE_ENTRY,
1064 fib_entry_get_index(fib_entry));
1066 fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
1068 FIB_ENTRY_DBG(fib_entry, "activate: %d",
1069 fib_entry->fe_parent);
1072 * If this source should push its state to covered prefixs, do that now.
1074 fib_entry_src_covered_inherit_add(fib_entry, source);
1076 if (0 != houston_we_are_go_for_install)
1078 fib_entry_src_action_install(fib_entry, source);
1082 fib_entry_src_action_uninstall(fib_entry);
1087 fib_entry_src_action_deactivate (fib_entry_t *fib_entry,
1088 fib_source_t source)
1091 fib_node_index_t path_list_index;
1092 fib_entry_src_t *esrc;
1094 esrc = fib_entry_src_find(fib_entry, source);
1096 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
1098 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deactivate,
1101 esrc->fes_flags &= ~(FIB_ENTRY_SRC_FLAG_ACTIVE |
1102 FIB_ENTRY_SRC_FLAG_CONTRIBUTING);
1104 FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
1107 * If this source should pull its state from covered prefixs, do that now.
1108 * If this source also has the INHERITED flag set then it has a cover
1109 * that wants to push down forwarding. We only want the covereds to see
1112 fib_entry_src_covered_inherit_remove(fib_entry, esrc);
1115 * un-link from an old path-list. Check for any loops this will clear
1117 path_list_index = fib_entry->fe_parent;
1118 fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
1120 fib_entry_recursive_loop_detect_i(path_list_index);
1123 * this will unlock the path-list, so it may be invalid thereafter.
1125 fib_path_list_child_remove(path_list_index, fib_entry->fe_sibling);
1126 fib_entry->fe_sibling = FIB_NODE_INDEX_INVALID;
1130 fib_entry_src_action_fwd_update (const fib_entry_t *fib_entry,
1131 fib_source_t source)
1133 fib_entry_src_t *esrc;
1135 vec_foreach(esrc, fib_entry->fe_srcs)
1137 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_fwd_update,
1138 (esrc, fib_entry, source));
1143 fib_entry_src_action_reactivate (fib_entry_t *fib_entry,
1144 fib_source_t source)
1146 fib_node_index_t path_list_index;
1147 const fib_entry_src_vft_t *vft;
1148 fib_entry_src_t *esrc;
1149 int remain_installed;
1151 esrc = fib_entry_src_find(fib_entry, source);
1153 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
1155 FIB_ENTRY_DBG(fib_entry, "reactivate: %d to %d",
1156 fib_entry->fe_parent,
1160 * call the source to reactive and get the go/no-go to remain installed
1162 vft = fib_entry_src_get_vft(esrc);
1164 if (NULL != vft->fesv_reactivate)
1166 remain_installed = vft->fesv_reactivate(esrc, fib_entry);
1170 remain_installed = 1;
1173 if (fib_entry->fe_parent != esrc->fes_pl)
1176 * un-link from an old path-list. Check for any loops this will clear
1178 path_list_index = fib_entry->fe_parent;
1179 fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
1182 * temporary lock so it doesn't get deleted when this entry is no
1185 fib_path_list_lock(path_list_index);
1188 * this entry is no longer a child. after unlinking check if any loops
1191 fib_path_list_child_remove(path_list_index,
1192 fib_entry->fe_sibling);
1194 fib_entry_recursive_loop_detect_i(path_list_index);
1197 * link to the path-list provided by the source, and go check
1198 * if that forms any loops in the graph.
1200 fib_entry->fe_parent = esrc->fes_pl;
1201 fib_entry->fe_sibling =
1202 fib_path_list_child_add(fib_entry->fe_parent,
1203 FIB_NODE_TYPE_ENTRY,
1204 fib_entry_get_index(fib_entry));
1206 fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
1207 fib_path_list_unlock(path_list_index);
1210 * If this source should push its state to covered prefixs, do that now.
1212 fib_entry_src_covered_inherit_add(fib_entry, source);
1215 if (!remain_installed)
1217 fib_entry_src_action_uninstall(fib_entry);
1221 fib_entry_src_action_install(fib_entry, source);
1223 fib_entry_src_action_fwd_update(fib_entry, source);
1227 fib_entry_src_action_installed (fib_entry_t *fib_entry,
1228 fib_source_t source)
1230 fib_entry_src_t *esrc;
1232 esrc = fib_entry_src_find(fib_entry, source);
1234 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_installed,
1237 fib_entry_src_action_fwd_update(fib_entry, source);
1243 * fib_entry_src_action_add
1245 * Adding a source can result in a new fib_entry being created, which
1246 * can inturn mean the pool is realloc'd and thus the entry passed as
1247 * an argument it also realloc'd
1248 * @return the original entry
1251 fib_entry_src_action_add (fib_entry_t *fib_entry,
1252 fib_source_t source,
1253 fib_entry_flag_t flags,
1254 const dpo_id_t *dpo)
1256 fib_entry_src_t *esrc;
1258 esrc = fib_entry_src_find_or_create(fib_entry, source, flags);
1260 ASSERT(esrc->fes_ref_count < 255);
1261 esrc->fes_ref_count++;
1263 if (flags != esrc->fes_entry_flags)
1265 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_flags_change,
1266 (esrc, fib_entry, flags));
1268 esrc->fes_entry_flags = flags;
1270 if (1 != esrc->fes_ref_count)
1273 * we only want to add the source on the 0->1 transition
1278 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_add,
1282 fib_entry_get_dpo_proto(fib_entry),
1285 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
1287 fib_path_list_lock(esrc->fes_pl);
1290 * the source owns a lock on the entry
1292 fib_entry_lock(fib_entry_get_index(fib_entry));
1298 * fib_entry_src_action_update
1300 * Adding a source can result in a new fib_entry being created, which
1301 * can inturn mean the pool is realloc'd and thus the entry passed as
1302 * an argument it also realloc'd
1303 * @return the original entry
1306 fib_entry_src_action_update (fib_entry_t *fib_entry,
1307 fib_source_t source,
1308 fib_entry_flag_t flags,
1309 const dpo_id_t *dpo)
1311 fib_node_index_t old_path_list_index;
1312 fib_entry_src_t *esrc;
1314 esrc = fib_entry_src_find_or_create(fib_entry, source, flags);
1318 return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
1321 old_path_list_index = esrc->fes_pl;
1322 esrc->fes_entry_flags = flags;
1324 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_add,
1328 fib_entry_get_dpo_proto(fib_entry),
1331 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
1333 fib_path_list_lock(esrc->fes_pl);
1334 fib_path_list_unlock(old_path_list_index);
1339 fib_entry_src_flag_t
1340 fib_entry_src_action_remove_or_update_inherit (fib_entry_t *fib_entry,
1341 fib_source_t source)
1343 fib_entry_src_t *esrc;
1345 esrc = fib_entry_src_find(fib_entry, source);
1348 return (FIB_ENTRY_SRC_FLAG_ACTIVE);
1350 if ((esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) &&
1351 (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
1353 fib_entry_src_t *cover_src;
1354 fib_node_index_t coveri;
1358 * this source was pushing inherited state, but so is its
1359 * cover. Now that this source is going away, we need to
1360 * pull the covers forwarding and use it to update the covereds.
1361 * Go grab the path-list from the cover, rather than start a walk from
1362 * the cover, so we don't recursively update this entry.
1364 coveri = fib_table_get_less_specific(fib_entry->fe_fib_index,
1365 &fib_entry->fe_prefix);
1368 * only the default route has itself as its own cover, but the
1369 * default route cannot have inherited from something else.
1371 ASSERT(coveri != fib_entry_get_index(fib_entry));
1373 cover = fib_entry_get(coveri);
1374 cover_src = fib_entry_src_find(cover, source);
1376 ASSERT(NULL != cover_src);
1378 esrc = fib_entry_src_action_update_from_cover(fib_entry, cover_src);
1379 esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_COVERED_INHERIT;
1382 * Now push the new state from the cover down to the covereds
1384 fib_entry_src_covered_inherit_add(fib_entry, source);
1386 return (esrc->fes_flags);
1390 return (fib_entry_src_action_remove(fib_entry, source));
1394 fib_entry_src_flag_t
1395 fib_entry_src_action_remove (fib_entry_t *fib_entry,
1396 fib_source_t source)
1399 fib_node_index_t old_path_list;
1400 fib_entry_src_flag_t sflags;
1401 fib_entry_src_t *esrc;
1403 esrc = fib_entry_src_find(fib_entry, source);
1406 return (FIB_ENTRY_SRC_FLAG_ACTIVE);
1408 esrc->fes_ref_count--;
1409 sflags = esrc->fes_flags;
1411 if (0 != esrc->fes_ref_count)
1414 * only remove the source on the 1->0 transisition
1419 if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE)
1421 fib_entry_src_action_deactivate(fib_entry, source);
1423 else if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_CONTRIBUTING)
1425 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deactivate,
1427 esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_CONTRIBUTING;
1430 old_path_list = esrc->fes_pl;
1432 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_remove, (esrc));
1434 fib_path_list_unlock(old_path_list);
1435 fib_entry_unlock(fib_entry_get_index(fib_entry));
1437 sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED;
1438 fib_entry_src_action_deinit(fib_entry, source);
1444 * fib_route_attached_cross_table
1446 * Return true the the route is attached via an interface that
1447 * is not in the same table as the route
1450 fib_route_attached_cross_table (const fib_entry_t *fib_entry,
1451 const fib_route_path_t *rpath)
1454 * - All zeros next-hop
1455 * - a valid interface
1456 * - entry's fib index not equeal to interface's index
1458 if (ip46_address_is_zero(&rpath->frp_addr) &&
1459 (~0 != rpath->frp_sw_if_index) &&
1460 !(rpath->frp_flags & FIB_ROUTE_PATH_DVR) &&
1461 (fib_entry->fe_fib_index !=
1462 fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry),
1463 rpath->frp_sw_if_index)))
1471 * Return true if the path is attached
1474 fib_path_is_attached (const fib_route_path_t *rpath)
1477 * DVR paths are not attached, since we are not playing the
1478 * L3 game with these
1480 if (rpath->frp_flags & FIB_ROUTE_PATH_DVR)
1486 * - All zeros next-hop
1487 * - a valid interface
1489 if (ip46_address_is_zero(&rpath->frp_addr) &&
1490 (~0 != rpath->frp_sw_if_index))
1494 else if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
1501 fib_path_list_flags_t
1502 fib_entry_src_flags_2_path_list_flags (fib_entry_flag_t eflags)
1504 fib_path_list_flags_t plf = FIB_PATH_LIST_FLAG_NONE;
1506 if (eflags & FIB_ENTRY_FLAG_DROP)
1508 plf |= FIB_PATH_LIST_FLAG_DROP;
1510 if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
1512 plf |= FIB_PATH_LIST_FLAG_EXCLUSIVE;
1514 if (eflags & FIB_ENTRY_FLAG_LOCAL)
1516 plf |= FIB_PATH_LIST_FLAG_LOCAL;
1523 fib_entry_flags_update (const fib_entry_t *fib_entry,
1524 const fib_route_path_t *rpaths,
1525 fib_path_list_flags_t *pl_flags,
1526 fib_entry_src_t *esrc)
1528 const fib_route_path_t *rpath;
1530 vec_foreach(rpath, rpaths)
1532 if ((esrc->fes_src == FIB_SOURCE_API) ||
1533 (esrc->fes_src == FIB_SOURCE_CLI))
1535 if (fib_path_is_attached(rpath))
1537 esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED;
1541 esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED;
1543 if (rpath->frp_flags & FIB_ROUTE_PATH_DEAG)
1545 esrc->fes_entry_flags |= FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT;
1548 if (fib_route_attached_cross_table(fib_entry, rpath) &&
1549 !(esrc->fes_entry_flags & FIB_ENTRY_FLAG_NO_ATTACHED_EXPORT))
1551 esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
1555 esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
1561 * fib_entry_src_action_add
1563 * Adding a source can result in a new fib_entry being created, which
1564 * can inturn mean the pool is realloc'd and thus the entry passed as
1565 * an argument it also realloc'd
1569 fib_entry_src_action_path_add (fib_entry_t *fib_entry,
1570 fib_source_t source,
1571 fib_entry_flag_t flags,
1572 const fib_route_path_t *rpaths)
1574 fib_node_index_t old_path_list;
1575 fib_path_list_flags_t pl_flags;
1576 fib_entry_src_t *esrc;
1578 esrc = fib_entry_src_find(fib_entry, source);
1581 const dpo_id_t *dpo;
1583 if (flags == FIB_ENTRY_FLAG_EXCLUSIVE) {
1586 dpo = drop_dpo_get(fib_entry_get_dpo_proto(fib_entry));
1590 fib_entry_src_action_add(fib_entry,
1594 esrc = fib_entry_src_find(fib_entry, source);
1598 * we are no doubt modifying a path-list. If the path-list
1599 * is shared, and hence not modifiable, then the index returned
1600 * will be for a different path-list. This FIB entry to needs
1601 * to maintain its lock appropriately.
1603 old_path_list = esrc->fes_pl;
1605 ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_add));
1607 pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1608 fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
1610 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_add,
1611 (esrc, fib_entry, pl_flags, rpaths));
1613 fib_path_list_lock(esrc->fes_pl);
1614 fib_path_list_unlock(old_path_list);
1620 * fib_entry_src_action_swap
1622 * The source is providing new paths to replace the old ones.
1623 * Adding a source can result in a new fib_entry being created, which
1624 * can inturn mean the pool is realloc'd and thus the entry passed as
1625 * an argument it also realloc'd
1629 fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
1630 fib_source_t source,
1631 fib_entry_flag_t flags,
1632 const fib_route_path_t *rpaths)
1634 fib_node_index_t old_path_list;
1635 fib_path_list_flags_t pl_flags;
1636 fib_entry_src_t *esrc;
1638 esrc = fib_entry_src_find(fib_entry, source);
1642 const dpo_id_t *dpo;
1644 if (flags == FIB_ENTRY_FLAG_EXCLUSIVE) {
1647 dpo = drop_dpo_get(fib_entry_get_dpo_proto(fib_entry));
1650 fib_entry = fib_entry_src_action_add(fib_entry,
1654 esrc = fib_entry_src_find(fib_entry, source);
1658 if (flags != esrc->fes_entry_flags)
1660 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_flags_change,
1661 (esrc, fib_entry, flags));
1663 esrc->fes_entry_flags = flags;
1667 * swapping paths may create a new path-list (or may use an existing shared)
1668 * but we are certainly getting a different one. This FIB entry to needs
1669 * to maintain its lock appropriately.
1671 old_path_list = esrc->fes_pl;
1673 ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_swap));
1675 pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
1677 fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
1679 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_swap,
1683 fib_path_list_lock(esrc->fes_pl);
1684 fib_path_list_unlock(old_path_list);
1689 fib_entry_src_flag_t
1690 fib_entry_src_action_path_remove (fib_entry_t *fib_entry,
1691 fib_source_t source,
1692 const fib_route_path_t *rpaths)
1694 fib_path_list_flags_t pl_flags;
1695 fib_node_index_t old_path_list;
1696 fib_entry_src_t *esrc;
1698 esrc = fib_entry_src_find(fib_entry, source);
1700 ASSERT(NULL != esrc);
1701 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
1704 * we no doubt modifying a path-list. If the path-list
1705 * is shared, and hence not modifiable, then the index returned
1706 * will be for a different path-list. This FIB entry to needs
1707 * to maintain its lock appropriately.
1709 old_path_list = esrc->fes_pl;
1711 ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_remove));
1713 pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1714 fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
1716 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_remove,
1717 (esrc, pl_flags, rpaths));
1720 * lock the new path-list, unlock the old if it had one
1722 fib_path_list_unlock(old_path_list);
1724 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) {
1725 fib_path_list_lock(esrc->fes_pl);
1726 return (FIB_ENTRY_SRC_FLAG_ADDED);
1731 * no more paths left from this source
1733 fib_entry_src_action_remove_or_update_inherit(fib_entry, source);
1734 return (FIB_ENTRY_SRC_FLAG_NONE);
1739 fib_entry_src_format (fib_entry_t *fib_entry,
1740 fib_source_t source,
1743 fib_entry_src_t *esrc;
1745 esrc = fib_entry_src_find(fib_entry, source);
1747 FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_format, (esrc, s));
1753 fib_entry_get_adj_for_source (fib_node_index_t fib_entry_index,
1754 fib_source_t source)
1756 fib_entry_t *fib_entry;
1757 fib_entry_src_t *esrc;
1759 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1760 return (ADJ_INDEX_INVALID);
1762 fib_entry = fib_entry_get(fib_entry_index);
1763 esrc = fib_entry_src_find(fib_entry, source);
1767 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1769 return (fib_path_list_get_adj(
1771 fib_entry_get_default_chain_type(fib_entry)));
1774 return (ADJ_INDEX_INVALID);
1778 fib_entry_get_dpo_for_source (fib_node_index_t fib_entry_index,
1779 fib_source_t source,
1782 fib_entry_t *fib_entry;
1783 fib_entry_src_t *esrc;
1785 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1788 fib_entry = fib_entry_get(fib_entry_index);
1789 esrc = fib_entry_src_find(fib_entry, source);
1793 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1795 fib_path_list_contribute_forwarding(
1797 fib_entry_get_default_chain_type(fib_entry),
1798 FIB_PATH_LIST_FWD_FLAG_NONE,
1801 return (dpo_id_is_valid(dpo));
1808 fib_entry_get_resolving_interface_for_source (fib_node_index_t entry_index,
1809 fib_source_t source)
1811 fib_entry_t *fib_entry;
1812 fib_entry_src_t *esrc;
1814 fib_entry = fib_entry_get(entry_index);
1816 esrc = fib_entry_src_find(fib_entry, source);
1820 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1822 return (fib_path_list_get_resolving_interface(esrc->fes_pl));
1829 fib_entry_get_flags_for_source (fib_node_index_t entry_index,
1830 fib_source_t source)
1832 fib_entry_t *fib_entry;
1833 fib_entry_src_t *esrc;
1835 fib_entry = fib_entry_get(entry_index);
1837 esrc = fib_entry_src_find(fib_entry, source);
1841 return (esrc->fes_entry_flags);
1844 return (FIB_ENTRY_FLAG_NONE);
1848 fib_entry_get_source_i (const fib_entry_t *fib_entry)
1850 /* the vector of sources is deliberately arranged in priority order */
1851 if (0 == vec_len(fib_entry->fe_srcs))
1852 return (FIB_SOURCE_INVALID);
1853 return (vec_elt(fib_entry->fe_srcs, 0).fes_src);
1857 fib_entry_get_flags_i (const fib_entry_t *fib_entry)
1859 /* the vector of sources is deliberately arranged in priority order */
1860 if (0 == vec_len(fib_entry->fe_srcs))
1861 return (FIB_ENTRY_FLAG_NONE);
1862 return (vec_elt(fib_entry->fe_srcs, 0).fes_entry_flags);
1866 fib_entry_set_source_data (fib_node_index_t fib_entry_index,
1867 fib_source_t source,
1870 fib_entry_t *fib_entry;
1871 fib_entry_src_t *esrc;
1873 fib_entry = fib_entry_get(fib_entry_index);
1874 esrc = fib_entry_src_find(fib_entry, source);
1878 FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_set_data,
1879 (esrc, fib_entry, data));
1884 fib_entry_get_source_data (fib_node_index_t fib_entry_index,
1885 fib_source_t source)
1887 fib_entry_t *fib_entry;
1888 fib_entry_src_t *esrc;
1890 fib_entry = fib_entry_get(fib_entry_index);
1891 esrc = fib_entry_src_find(fib_entry, source);
1895 FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_get_data,
1902 fib_entry_src_module_init (void)
1904 fib_entry_src_rr_register();
1905 fib_entry_src_interface_register();
1906 fib_entry_src_interpose_register();
1907 fib_entry_src_drop_register();
1908 fib_entry_src_simple_register();
1909 fib_entry_src_api_register();
1910 fib_entry_src_adj_register();
1911 fib_entry_src_mpls_register();
1912 fib_entry_src_lisp_register();