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>
21 #include <vnet/fib/fib_entry_src.h>
22 #include <vnet/fib/fib_table.h>
23 #include <vnet/fib/fib_path_ext.h>
24 #include <vnet/fib/fib_urpf_list.h>
29 static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX];
32 fib_entry_get_proto (const fib_entry_t * fib_entry)
34 return (fib_entry->fe_prefix.fp_proto);
38 fib_entry_src_register (fib_source_t source,
39 const fib_entry_src_vft_t *vft)
41 fib_entry_src_vft[source] = *vft;
45 fib_entry_src_cmp_for_sort (void * v1,
48 fib_entry_src_t *esrc1 = v1, *esrc2 = v2;
50 return (esrc1->fes_src - esrc2->fes_src);
54 fib_entry_src_action_init (fib_entry_t *fib_entry,
58 fib_entry_src_t esrc = {
59 .fes_pl = FIB_NODE_INDEX_INVALID,
60 .fes_flags = FIB_ENTRY_SRC_FLAG_NONE,
64 if (NULL != fib_entry_src_vft[source].fesv_init)
66 fib_entry_src_vft[source].fesv_init(&esrc);
69 vec_add1(fib_entry->fe_srcs, esrc);
70 vec_sort_with_function(fib_entry->fe_srcs,
71 fib_entry_src_cmp_for_sort);
74 static fib_entry_src_t *
75 fib_entry_src_find (const fib_entry_t *fib_entry,
80 fib_entry_src_t *esrc;
84 vec_foreach(esrc, fib_entry->fe_srcs)
86 if (esrc->fes_src == source)
104 fib_entry_is_sourced (fib_node_index_t fib_entry_index,
107 fib_entry_t *fib_entry;
109 fib_entry = fib_entry_get(fib_entry_index);
111 return (NULL != fib_entry_src_find(fib_entry, source, NULL));
114 static fib_entry_src_t *
115 fib_entry_src_find_or_create (fib_entry_t *fib_entry,
119 fib_entry_src_t *esrc;
121 esrc = fib_entry_src_find(fib_entry, source, NULL);
125 fib_entry_src_action_init(fib_entry, source);
128 return (fib_entry_src_find(fib_entry, source, NULL));
132 fib_entry_src_action_deinit (fib_entry_t *fib_entry,
136 fib_entry_src_t *esrc;
139 esrc = fib_entry_src_find(fib_entry, source, &index);
141 ASSERT(NULL != esrc);
143 if (NULL != fib_entry_src_vft[source].fesv_deinit)
145 fib_entry_src_vft[source].fesv_deinit(esrc);
148 vec_free(esrc->fes_path_exts);
149 vec_del1(fib_entry->fe_srcs, index);
152 fib_entry_src_cover_res_t
153 fib_entry_src_action_cover_change (fib_entry_t *fib_entry,
156 if (NULL != fib_entry_src_vft[source].fesv_cover_change)
158 return (fib_entry_src_vft[source].fesv_cover_change(
159 fib_entry_src_find(fib_entry, source, NULL),
163 fib_entry_src_cover_res_t res = {
165 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
170 fib_entry_src_cover_res_t
171 fib_entry_src_action_cover_update (fib_entry_t *fib_entry,
174 if (NULL != fib_entry_src_vft[source].fesv_cover_update)
176 return (fib_entry_src_vft[source].fesv_cover_update(
177 fib_entry_src_find(fib_entry, source, NULL),
181 fib_entry_src_cover_res_t res = {
183 .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
188 typedef struct fib_entry_src_collect_forwarding_ctx_t_
190 load_balance_path_t * next_hops;
191 const fib_entry_t *fib_entry;
192 const fib_entry_src_t *esrc;
193 fib_forward_chain_type_t fct;
195 } fib_entry_src_collect_forwarding_ctx_t;
198 * @brief Determine whether this FIB entry should use a load-balance MAP
199 * to support PIC edge fast convergence
202 fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx)
205 * We'll use a LB map is the path-list has recursive paths.
206 * recursive paths implies BGP, and hence scale.
208 if (ctx->is_recursive)
210 return (LOAD_BALANCE_FLAG_USES_MAP);
212 return (LOAD_BALANCE_FLAG_NONE);
216 fib_entry_src_valid_out_label (mpls_label_t label)
218 return ((MPLS_LABEL_IS_REAL(label) ||
219 MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL == label ||
220 MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL == label ||
221 MPLS_IETF_IMPLICIT_NULL_LABEL == label));
225 * @brief Turn the chain type requested by the client into the one they
228 fib_forward_chain_type_t
229 fib_entry_chain_type_fixup (const fib_entry_t *entry,
230 fib_forward_chain_type_t fct)
232 ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct);
235 * The EOS chain is a tricky since one cannot know the adjacency
236 * to link to without knowing what the packets payload protocol
237 * will be once the label is popped.
239 fib_forward_chain_type_t dfct;
241 dfct = fib_entry_get_default_chain_type(entry);
243 if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
246 * If the entry being asked is a eos-MPLS label entry,
247 * then use the payload-protocol field, that we stashed there
248 * for just this purpose
250 return (fib_forw_chain_type_from_dpo_proto(
251 entry->fe_prefix.fp_payload_proto));
254 * else give them what this entry would be by default. i.e. if it's a v6
255 * entry, then the label its local labelled should be carrying v6 traffic.
256 * If it's a non-EOS label entry, then there are more labels and we want
263 fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
264 fib_node_index_t path_index,
267 fib_entry_src_collect_forwarding_ctx_t *ctx;
268 fib_path_ext_t *path_ext;
274 * if the path is not resolved, don't include it.
276 if (!fib_path_is_resolved(path_index))
281 if (fib_path_is_recursive(path_index))
283 ctx->is_recursive = 1;
287 * get the matching path-extension for the path being visited.
290 vec_foreach(path_ext, ctx->esrc->fes_path_exts)
292 if (path_ext->fpe_path_index == path_index)
300 fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0]))
303 * found a matching extension. stack it to obtain the forwarding
304 * info for this path.
306 ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fib_entry, ctx->fct, ctx->next_hops);
310 load_balance_path_t *nh;
313 * no extension => no out-going label for this path. that's OK
314 * in the case of an IP or EOS chain, but not for non-EOS
318 case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
319 case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
320 case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
321 case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
323 * EOS traffic with no label to stack, we need the IP Adj
325 vec_add2(ctx->next_hops, nh, 1);
327 nh->path_index = path_index;
328 nh->path_weight = fib_path_get_weight(path_index);
329 fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
332 case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
333 if (fib_path_is_exclusive(path_index) ||
334 fib_path_is_deag(path_index))
336 vec_add2(ctx->next_hops, nh, 1);
338 nh->path_index = path_index;
339 nh->path_weight = fib_path_get_weight(path_index);
340 fib_path_contribute_forwarding(path_index,
341 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
345 case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
348 * no label. we need a chain based on the payload. fixup.
350 vec_add2(ctx->next_hops, nh, 1);
352 nh->path_index = path_index;
353 nh->path_weight = fib_path_get_weight(path_index);
354 fib_path_contribute_forwarding(path_index,
355 fib_entry_chain_type_fixup(ctx->fib_entry,
361 case FIB_FORW_CHAIN_TYPE_ETHERNET:
362 case FIB_FORW_CHAIN_TYPE_NSH:
372 fib_entry_src_mk_lb (fib_entry_t *fib_entry,
373 const fib_entry_src_t *esrc,
374 fib_forward_chain_type_t fct,
377 dpo_proto_t lb_proto;
380 * If the entry has path extensions then we construct a load-balance
381 * by stacking the extensions on the forwarding chains of the paths.
382 * Otherwise we use the load-balance of the path-list
384 fib_entry_src_collect_forwarding_ctx_t ctx = {
386 .fib_entry = fib_entry,
393 * As an optimisation we allocate the vector of next-hops to be sized
394 * equal to the maximum nuber of paths we will need, which is also the
395 * most likely number we will need, since in most cases the paths are 'up'.
397 vec_validate(ctx.next_hops, fib_path_list_get_n_paths(esrc->fes_pl));
398 vec_reset_length(ctx.next_hops);
400 lb_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
402 fib_path_list_walk(esrc->fes_pl,
403 fib_entry_src_collect_forwarding,
406 if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_EXCLUSIVE)
409 * the client provided the DPO that the entry should link to.
410 * all entries must link to a LB, so if it is an LB already
411 * then we can use it.
413 if ((1 == vec_len(ctx.next_hops)) &&
414 (DPO_LOAD_BALANCE == ctx.next_hops[0].path_dpo.dpoi_type))
416 dpo_copy(dpo_lb, &ctx.next_hops[0].path_dpo);
417 dpo_reset(&ctx.next_hops[0].path_dpo);
422 if (!dpo_id_is_valid(dpo_lb))
427 flow_hash_config_t fhc;
429 fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index,
430 dpo_proto_to_fib(lb_proto));
434 load_balance_create(0, lb_proto, fhc));
437 load_balance_multipath_update(dpo_lb,
439 fib_entry_calc_lb_flags(&ctx));
440 vec_free(ctx.next_hops);
443 * if this entry is sourced by the uRPF-exempt source then we
444 * append the always present local0 interface (index 0) to the
445 * uRPF list so it is not empty. that way packets pass the loose check.
447 index_t ui = fib_path_list_get_urpf(esrc->fes_pl);
449 if ((fib_entry_is_sourced(fib_entry_get_index(fib_entry),
450 FIB_SOURCE_URPF_EXEMPT) ||
451 (esrc->fes_entry_flags & FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT))&&
452 (0 == fib_urpf_check_size(ui)))
455 * The uRPF list we get from the path-list is shared by all
456 * other users of the list, but the uRPF exemption applies
457 * only to this prefix. So we need our own list.
459 ui = fib_urpf_list_alloc_and_lock();
460 fib_urpf_list_append(ui, 0);
461 fib_urpf_list_bake(ui);
462 load_balance_set_urpf(dpo_lb->dpoi_index, ui);
463 fib_urpf_list_unlock(ui);
467 load_balance_set_urpf(dpo_lb->dpoi_index, ui);
469 load_balance_set_fib_entry_flags(dpo_lb->dpoi_index,
470 fib_entry_get_flags_i(fib_entry));
474 fib_entry_src_action_install (fib_entry_t *fib_entry,
478 * Install the forwarding chain for the given source into the forwarding
481 fib_forward_chain_type_t fct;
482 fib_entry_src_t *esrc;
485 fct = fib_entry_get_default_chain_type(fib_entry);
486 esrc = fib_entry_src_find(fib_entry, source, NULL);
489 * Every entry has its own load-balance object. All changes to the entry's
490 * forwarding result in an inplace modify of the load-balance. This means
491 * the load-balance object only needs to be added to the forwarding
492 * DB once, when it is created.
494 insert = !dpo_id_is_valid(&fib_entry->fe_lb);
496 fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb);
498 ASSERT(dpo_id_is_valid(&fib_entry->fe_lb));
499 FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb);
502 * insert the adj into the data-plane forwarding trie
506 fib_table_fwding_dpo_update(fib_entry->fe_fib_index,
507 &fib_entry->fe_prefix,
512 * if any of the other chain types are already created they will need
515 fib_entry_delegate_type_t fdt;
516 fib_entry_delegate_t *fed;
518 FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
520 fib_entry_src_mk_lb(fib_entry, esrc,
521 fib_entry_delegate_type_to_chain_type(fdt),
527 fib_entry_src_action_uninstall (fib_entry_t *fib_entry)
530 * uninstall the forwarding chain from the forwarding tables
532 FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
533 fib_entry->fe_adj_index);
535 if (dpo_id_is_valid(&fib_entry->fe_lb))
537 fib_table_fwding_dpo_remove(
538 fib_entry->fe_fib_index,
539 &fib_entry->fe_prefix,
542 dpo_reset(&fib_entry->fe_lb);
547 fib_entry_recursive_loop_detect_i (fib_node_index_t path_list_index)
549 fib_node_index_t *entries = NULL;
551 fib_path_list_recursive_loop_detect(path_list_index, &entries);
557 fib_entry_src_action_activate (fib_entry_t *fib_entry,
561 int houston_we_are_go_for_install;
562 fib_entry_src_t *esrc;
564 esrc = fib_entry_src_find(fib_entry, source, NULL);
566 ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
567 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
569 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ACTIVE;
571 if (NULL != fib_entry_src_vft[source].fesv_activate)
573 houston_we_are_go_for_install =
574 fib_entry_src_vft[source].fesv_activate(esrc, fib_entry);
579 * the source is not providing an activate function, we'll assume
580 * therefore it has no objection to installing the entry
582 houston_we_are_go_for_install = !0;
586 * link to the path-list provided by the source, and go check
587 * if that forms any loops in the graph.
589 fib_entry->fe_parent = esrc->fes_pl;
590 fib_entry->fe_sibling =
591 fib_path_list_child_add(fib_entry->fe_parent,
593 fib_entry_get_index(fib_entry));
595 fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
597 FIB_ENTRY_DBG(fib_entry, "activate: %d",
598 fib_entry->fe_parent);
600 if (0 != houston_we_are_go_for_install)
602 fib_entry_src_action_install(fib_entry, source);
606 fib_entry_src_action_uninstall(fib_entry);
611 fib_entry_src_action_deactivate (fib_entry_t *fib_entry,
615 fib_node_index_t path_list_index;
616 fib_entry_src_t *esrc;
618 esrc = fib_entry_src_find(fib_entry, source, NULL);
620 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
622 if (NULL != fib_entry_src_vft[source].fesv_deactivate)
624 fib_entry_src_vft[source].fesv_deactivate(esrc, fib_entry);
627 esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_ACTIVE;
629 FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
632 * un-link from an old path-list. Check for any loops this will clear
634 path_list_index = fib_entry->fe_parent;
635 fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
637 fib_entry_recursive_loop_detect_i(path_list_index);
640 * this will unlock the path-list, so it may be invalid thereafter.
642 fib_path_list_child_remove(path_list_index, fib_entry->fe_sibling);
643 fib_entry->fe_sibling = FIB_NODE_INDEX_INVALID;
647 fib_entry_src_action_fwd_update (const fib_entry_t *fib_entry,
650 fib_entry_src_t *esrc;
652 vec_foreach(esrc, fib_entry->fe_srcs)
654 if (NULL != fib_entry_src_vft[esrc->fes_src].fesv_fwd_update)
656 fib_entry_src_vft[esrc->fes_src].fesv_fwd_update(esrc,
664 fib_entry_src_action_reactivate (fib_entry_t *fib_entry,
667 fib_node_index_t path_list_index;
668 fib_entry_src_t *esrc;
670 esrc = fib_entry_src_find(fib_entry, source, NULL);
672 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
674 FIB_ENTRY_DBG(fib_entry, "reactivate: %d to %d",
675 fib_entry->fe_parent,
678 if (fib_entry->fe_parent != esrc->fes_pl)
681 * un-link from an old path-list. Check for any loops this will clear
683 path_list_index = fib_entry->fe_parent;
684 fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
687 * temporary lock so it doesn't get deleted when this entry is no
690 fib_path_list_lock(path_list_index);
693 * this entry is no longer a child. after unlinking check if any loops
696 fib_path_list_child_remove(path_list_index,
697 fib_entry->fe_sibling);
699 fib_entry_recursive_loop_detect_i(path_list_index);
702 * link to the path-list provided by the source, and go check
703 * if that forms any loops in the graph.
705 fib_entry->fe_parent = esrc->fes_pl;
706 fib_entry->fe_sibling =
707 fib_path_list_child_add(fib_entry->fe_parent,
709 fib_entry_get_index(fib_entry));
711 fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
712 fib_path_list_unlock(path_list_index);
714 fib_entry_src_action_install(fib_entry, source);
715 fib_entry_src_action_fwd_update(fib_entry, source);
719 fib_entry_src_action_installed (const fib_entry_t *fib_entry,
722 fib_entry_src_t *esrc;
724 esrc = fib_entry_src_find(fib_entry, source, NULL);
726 if (NULL != fib_entry_src_vft[source].fesv_installed)
728 fib_entry_src_vft[source].fesv_installed(esrc,
732 fib_entry_src_action_fwd_update(fib_entry, source);
736 * fib_entry_src_action_add
738 * Adding a source can result in a new fib_entry being created, which
739 * can inturn mean the pool is realloc'd and thus the entry passed as
740 * an argument it also realloc'd
741 * @return the original entry
744 fib_entry_src_action_add (fib_entry_t *fib_entry,
746 fib_entry_flag_t flags,
749 fib_node_index_t fib_entry_index;
750 fib_entry_src_t *esrc;
752 esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
754 esrc->fes_ref_count++;
756 if (1 != esrc->fes_ref_count)
759 * we only want to add the source on the 0->1 transition
764 esrc->fes_entry_flags = flags;
767 * save variable so we can recover from a fib_entry realloc.
769 fib_entry_index = fib_entry_get_index(fib_entry);
771 if (NULL != fib_entry_src_vft[source].fesv_add)
773 fib_entry_src_vft[source].fesv_add(esrc,
776 fib_entry_get_proto(fib_entry),
780 fib_entry = fib_entry_get(fib_entry_index);
782 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
784 fib_path_list_lock(esrc->fes_pl);
787 * the source owns a lock on the entry
789 fib_entry_lock(fib_entry_get_index(fib_entry));
795 * fib_entry_src_action_update
797 * Adding a source can result in a new fib_entry being created, which
798 * can inturn mean the pool is realloc'd and thus the entry passed as
799 * an argument it also realloc'd
800 * @return the original entry
803 fib_entry_src_action_update (fib_entry_t *fib_entry,
805 fib_entry_flag_t flags,
808 fib_node_index_t fib_entry_index, old_path_list_index;
809 fib_entry_src_t *esrc;
811 esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
814 return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
816 old_path_list_index = esrc->fes_pl;
817 esrc->fes_entry_flags = flags;
820 * save variable so we can recover from a fib_entry realloc.
822 fib_entry_index = fib_entry_get_index(fib_entry);
824 if (NULL != fib_entry_src_vft[source].fesv_add)
826 fib_entry_src_vft[source].fesv_add(esrc,
829 fib_entry_get_proto(fib_entry),
833 fib_entry = fib_entry_get(fib_entry_index);
835 esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
837 fib_path_list_lock(esrc->fes_pl);
838 fib_path_list_unlock(old_path_list_index);
845 fib_entry_src_action_remove (fib_entry_t *fib_entry,
849 fib_node_index_t old_path_list;
850 fib_entry_src_flag_t sflags;
851 fib_entry_src_t *esrc;
853 esrc = fib_entry_src_find(fib_entry, source, NULL);
856 return (FIB_ENTRY_SRC_FLAG_ACTIVE);
858 esrc->fes_ref_count--;
859 sflags = esrc->fes_flags;
861 if (0 != esrc->fes_ref_count)
864 * only remove the source on the 1->0 transisition
869 if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE)
871 fib_entry_src_action_deactivate(fib_entry, source);
874 old_path_list = esrc->fes_pl;
876 if (NULL != fib_entry_src_vft[source].fesv_remove)
878 fib_entry_src_vft[source].fesv_remove(esrc);
881 fib_path_list_unlock(old_path_list);
882 fib_entry_unlock(fib_entry_get_index(fib_entry));
884 sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED;
885 fib_entry_src_action_deinit(fib_entry, source);
891 fib_route_recurses_via_self (const fib_prefix_t *prefix,
892 const fib_route_path_t *rpath)
895 * not all zeros next hop &&
896 * is recursive path &&
897 * nexthop is same as the route's address
899 return ((!ip46_address_is_zero(&rpath->frp_addr)) &&
900 (~0 == rpath->frp_sw_if_index) &&
901 (0 == ip46_address_cmp(&rpath->frp_addr, &prefix->fp_addr)));
906 * fib_route_attached_cross_table
908 * Return true the the route is attached via an interface that
909 * is not in the same table as the route
912 fib_route_attached_cross_table (const fib_entry_t *fib_entry,
913 const fib_route_path_t *rpath)
916 * - All zeros next-hop
917 * - a valid interface
918 * - entry's fib index not equeal to interface's index
920 if (ip46_address_is_zero(&rpath->frp_addr) &&
921 (~0 != rpath->frp_sw_if_index) &&
922 (fib_entry->fe_fib_index !=
923 fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry),
924 rpath->frp_sw_if_index)))
932 * fib_route_attached_cross_table
934 * Return true the the route is attached via an interface that
935 * is not in the same table as the route
938 fib_path_is_attached (const fib_route_path_t *rpath)
941 * - All zeros next-hop
942 * - a valid interface
944 if (ip46_address_is_zero(&rpath->frp_addr) &&
945 (~0 != rpath->frp_sw_if_index))
952 fib_path_list_flags_t
953 fib_entry_src_flags_2_path_list_flags (fib_entry_flag_t eflags)
955 fib_path_list_flags_t plf = FIB_PATH_LIST_FLAG_NONE;
957 if (eflags & FIB_ENTRY_FLAG_DROP)
959 plf |= FIB_PATH_LIST_FLAG_DROP;
961 if (eflags & FIB_ENTRY_FLAG_LOCAL)
963 plf |= FIB_PATH_LIST_FLAG_LOCAL;
965 if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
967 plf |= FIB_PATH_LIST_FLAG_EXCLUSIVE;
974 fib_entry_flags_update (const fib_entry_t *fib_entry,
975 const fib_route_path_t *rpath,
976 fib_path_list_flags_t *pl_flags,
977 fib_entry_src_t *esrc)
980 * don't allow the addition of a recursive looped path for prefix
983 if (fib_route_recurses_via_self(&fib_entry->fe_prefix, rpath))
986 * force the install of a drop path-list.
987 * we want the entry to have some path-list, mainly so
988 * the dodgy path can be rmeoved when the source stops playing
991 *pl_flags |= FIB_PATH_LIST_FLAG_DROP;
995 *pl_flags &= ~FIB_PATH_LIST_FLAG_DROP;
998 if ((esrc->fes_src == FIB_SOURCE_API) ||
999 (esrc->fes_src == FIB_SOURCE_CLI))
1001 if (fib_path_is_attached(rpath))
1003 esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED;
1007 esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED;
1010 if (fib_route_attached_cross_table(fib_entry, rpath))
1012 esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
1016 esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
1021 * fib_entry_src_path_ext_add
1023 * append a path extension to the entry's list
1026 fib_entry_src_path_ext_append (fib_entry_src_t *esrc,
1027 const fib_route_path_t *rpath)
1029 if (NULL != rpath->frp_label_stack)
1031 fib_path_ext_t *path_ext;
1033 vec_add2(esrc->fes_path_exts, path_ext, 1);
1035 fib_path_ext_init(path_ext, esrc->fes_pl, rpath);
1040 * fib_entry_src_path_ext_insert
1042 * insert, sorted, a path extension to the entry's list.
1043 * It's not strictly necessary in sort the path extensions, since each
1044 * extension has the path index to which it resolves. However, by being
1045 * sorted the load-balance produced has a deterministic order, not an order
1046 * based on the sequence of extension additions. this is a considerable benefit.
1049 fib_entry_src_path_ext_insert (fib_entry_src_t *esrc,
1050 const fib_route_path_t *rpath)
1052 if (0 == vec_len(esrc->fes_path_exts))
1053 return (fib_entry_src_path_ext_append(esrc, rpath));
1055 if (NULL != rpath->frp_label_stack)
1057 fib_path_ext_t path_ext;
1060 fib_path_ext_init(&path_ext, esrc->fes_pl, rpath);
1062 while (i < vec_len(esrc->fes_path_exts) &&
1063 (fib_path_ext_cmp(&esrc->fes_path_exts[i], rpath) < 0))
1068 vec_insert_elts(esrc->fes_path_exts, &path_ext, 1, i);
1073 * fib_entry_src_action_add
1075 * Adding a source can result in a new fib_entry being created, which
1076 * can inturn mean the pool is realloc'd and thus the entry passed as
1077 * an argument it also realloc'd
1081 fib_entry_src_action_path_add (fib_entry_t *fib_entry,
1082 fib_source_t source,
1083 fib_entry_flag_t flags,
1084 const fib_route_path_t *rpath)
1086 fib_node_index_t old_path_list, fib_entry_index;
1087 fib_path_list_flags_t pl_flags;
1088 fib_path_ext_t *path_ext;
1089 fib_entry_src_t *esrc;
1092 * save variable so we can recover from a fib_entry realloc.
1094 fib_entry_index = fib_entry_get_index(fib_entry);
1096 esrc = fib_entry_src_find(fib_entry, source, NULL);
1100 fib_entry_src_action_add(fib_entry,
1105 fib_entry_get_proto(fib_entry))));
1106 esrc = fib_entry_src_find(fib_entry, source, NULL);
1110 * we are no doubt modifying a path-list. If the path-list
1111 * is shared, and hence not modifiable, then the index returned
1112 * will be for a different path-list. This FIB entry to needs
1113 * to maintain its lock appropriately.
1115 old_path_list = esrc->fes_pl;
1117 ASSERT(NULL != fib_entry_src_vft[source].fesv_path_add);
1119 pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1120 fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1122 fib_entry_src_vft[source].fesv_path_add(esrc, fib_entry, pl_flags, rpath);
1123 fib_entry = fib_entry_get(fib_entry_index);
1126 * re-resolve all the path-extensions with the new path-list
1128 vec_foreach(path_ext, esrc->fes_path_exts)
1130 fib_path_ext_resolve(path_ext, esrc->fes_pl);
1133 * if the path has a label we need to add a path extension
1135 fib_entry_src_path_ext_insert(esrc, rpath);
1137 fib_path_list_lock(esrc->fes_pl);
1138 fib_path_list_unlock(old_path_list);
1144 * fib_entry_src_action_swap
1146 * The source is providing new paths to replace the old ones.
1147 * Adding a source can result in a new fib_entry being created, which
1148 * can inturn mean the pool is realloc'd and thus the entry passed as
1149 * an argument it also realloc'd
1153 fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
1154 fib_source_t source,
1155 fib_entry_flag_t flags,
1156 const fib_route_path_t *rpaths)
1158 fib_node_index_t old_path_list, fib_entry_index;
1159 fib_path_list_flags_t pl_flags;
1160 const fib_route_path_t *rpath;
1161 fib_path_ext_t *path_ext;
1162 fib_entry_src_t *esrc;
1164 esrc = fib_entry_src_find(fib_entry, source, NULL);
1167 * save variable so we can recover from a fib_entry realloc.
1169 fib_entry_index = fib_entry_get_index(fib_entry);
1173 fib_entry = fib_entry_src_action_add(fib_entry,
1178 fib_entry_get_proto(fib_entry))));
1179 esrc = fib_entry_src_find(fib_entry, source, NULL);
1183 * swapping paths may create a new path-list (or may use an existing shared)
1184 * but we are certainly getting a different one. This FIB entry to needs
1185 * to maintain its lock appropriately.
1187 old_path_list = esrc->fes_pl;
1189 ASSERT(NULL != fib_entry_src_vft[source].fesv_path_swap);
1191 pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
1193 vec_foreach(rpath, rpaths)
1195 fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1198 fib_entry_src_vft[source].fesv_path_swap(esrc,
1203 vec_foreach(path_ext, esrc->fes_path_exts)
1205 vec_free(path_ext->fpe_label_stack);
1207 vec_free(esrc->fes_path_exts);
1209 vec_foreach(rpath, rpaths)
1211 fib_entry_src_path_ext_append(esrc, rpath);
1214 fib_entry = fib_entry_get(fib_entry_index);
1216 fib_path_list_lock(esrc->fes_pl);
1217 fib_path_list_unlock(old_path_list);
1222 fib_entry_src_flag_t
1223 fib_entry_src_action_path_remove (fib_entry_t *fib_entry,
1224 fib_source_t source,
1225 const fib_route_path_t *rpath)
1227 fib_path_list_flags_t pl_flags;
1228 fib_node_index_t old_path_list;
1229 fib_path_ext_t *path_ext;
1230 fib_entry_src_t *esrc;
1232 esrc = fib_entry_src_find(fib_entry, source, NULL);
1234 ASSERT(NULL != esrc);
1235 ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
1238 * we no doubt modifying a path-list. If the path-list
1239 * is shared, and hence not modifiable, then the index returned
1240 * will be for a different path-list. This FIB entry to needs
1241 * to maintain its lock appropriately.
1243 old_path_list = esrc->fes_pl;
1245 ASSERT(NULL != fib_entry_src_vft[source].fesv_path_remove);
1247 pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1248 fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1250 fib_entry_src_vft[source].fesv_path_remove(esrc, pl_flags, rpath);
1252 * find the matching path extension and remove it
1254 vec_foreach(path_ext, esrc->fes_path_exts)
1256 if (!fib_path_ext_cmp(path_ext, rpath))
1259 * delete the element moving the remaining elements down 1 position.
1260 * this preserves the sorted order.
1262 vec_free(path_ext->fpe_label_stack);
1263 vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
1268 * re-resolve all the path-extensions with the new path-list
1270 vec_foreach(path_ext, esrc->fes_path_exts)
1272 fib_path_ext_resolve(path_ext, esrc->fes_pl);
1276 * lock the new path-list, unlock the old if it had one
1278 fib_path_list_unlock(old_path_list);
1280 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) {
1281 fib_path_list_lock(esrc->fes_pl);
1282 return (FIB_ENTRY_SRC_FLAG_ADDED);
1287 * no more paths left from this source
1289 fib_entry_src_action_remove(fib_entry, source);
1290 return (FIB_ENTRY_SRC_FLAG_NONE);
1295 fib_entry_src_format (fib_entry_t *fib_entry,
1296 fib_source_t source,
1299 fib_entry_src_t *esrc;
1301 esrc = fib_entry_src_find(fib_entry, source, NULL);
1303 if (NULL != fib_entry_src_vft[source].fesv_format)
1305 return (fib_entry_src_vft[source].fesv_format(esrc, s));
1311 fib_entry_get_adj_for_source (fib_node_index_t fib_entry_index,
1312 fib_source_t source)
1314 fib_entry_t *fib_entry;
1315 fib_entry_src_t *esrc;
1317 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1318 return (ADJ_INDEX_INVALID);
1320 fib_entry = fib_entry_get(fib_entry_index);
1321 esrc = fib_entry_src_find(fib_entry, source, NULL);
1325 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1327 return (fib_path_list_get_adj(
1329 fib_entry_get_default_chain_type(fib_entry)));
1332 return (ADJ_INDEX_INVALID);
1336 fib_entry_get_dpo_for_source (fib_node_index_t fib_entry_index,
1337 fib_source_t source,
1340 fib_entry_t *fib_entry;
1341 fib_entry_src_t *esrc;
1343 if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1346 fib_entry = fib_entry_get(fib_entry_index);
1347 esrc = fib_entry_src_find(fib_entry, source, NULL);
1351 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1353 fib_path_list_contribute_forwarding(
1355 fib_entry_get_default_chain_type(fib_entry),
1358 return (dpo_id_is_valid(dpo));
1365 fib_entry_get_resolving_interface_for_source (fib_node_index_t entry_index,
1366 fib_source_t source)
1368 fib_entry_t *fib_entry;
1369 fib_entry_src_t *esrc;
1371 fib_entry = fib_entry_get(entry_index);
1373 esrc = fib_entry_src_find(fib_entry, source, NULL);
1377 if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1379 return (fib_path_list_get_resolving_interface(esrc->fes_pl));
1386 fib_entry_get_flags_for_source (fib_node_index_t entry_index,
1387 fib_source_t source)
1389 fib_entry_t *fib_entry;
1390 fib_entry_src_t *esrc;
1392 fib_entry = fib_entry_get(entry_index);
1394 esrc = fib_entry_src_find(fib_entry, source, NULL);
1398 return (esrc->fes_entry_flags);
1401 return (FIB_ENTRY_FLAG_NONE);
1405 fib_entry_get_flags_i (const fib_entry_t *fib_entry)
1407 fib_entry_flag_t flags;
1410 * the vector of sources is deliberately arranged in priority order
1412 if (0 == vec_len(fib_entry->fe_srcs))
1414 flags = FIB_ENTRY_FLAG_NONE;
1418 fib_entry_src_t *esrc;
1420 esrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
1421 flags = esrc->fes_entry_flags;
1428 fib_entry_set_source_data (fib_node_index_t fib_entry_index,
1429 fib_source_t source,
1432 fib_entry_t *fib_entry;
1433 fib_entry_src_t *esrc;
1435 fib_entry = fib_entry_get(fib_entry_index);
1436 esrc = fib_entry_src_find(fib_entry, source, NULL);
1439 NULL != fib_entry_src_vft[source].fesv_set_data)
1441 fib_entry_src_vft[source].fesv_set_data(esrc, fib_entry, data);
1446 fib_entry_get_source_data (fib_node_index_t fib_entry_index,
1447 fib_source_t source)
1449 fib_entry_t *fib_entry;
1450 fib_entry_src_t *esrc;
1452 fib_entry = fib_entry_get(fib_entry_index);
1453 esrc = fib_entry_src_find(fib_entry, source, NULL);
1456 NULL != fib_entry_src_vft[source].fesv_get_data)
1458 return (fib_entry_src_vft[source].fesv_get_data(esrc, fib_entry));
1464 fib_entry_src_module_init (void)
1466 fib_entry_src_rr_register();
1467 fib_entry_src_interface_register();
1468 fib_entry_src_default_route_register();
1469 fib_entry_src_special_register();
1470 fib_entry_src_api_register();
1471 fib_entry_src_adj_register();
1472 fib_entry_src_mpls_register();
1473 fib_entry_src_lisp_register();