#include <vnet/dpo/load_balance.h>
#include <vnet/dpo/mpls_label_dpo.h>
#include <vnet/dpo/drop_dpo.h>
+#include <vnet/dpo/replicate_dpo.h>
#include <vnet/fib/fib_entry_src.h>
#include <vnet/fib/fib_table.h>
#include <vnet/fib/fib_path_ext.h>
#include <vnet/fib/fib_urpf_list.h>
+#include <vnet/fib/fib_entry_delegate.h>
/*
* per-source type vft
*/
-static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX];
+static fib_entry_src_vft_t fib_entry_src_bh_vft[FIB_SOURCE_BH_MAX];
-static fib_protocol_t
-fib_entry_get_proto (const fib_entry_t * fib_entry)
+/**
+ * Get the VFT for a given source. This is a combination of the source
+ * enum and the interposer flags
+ */
+const fib_entry_src_vft_t*
+fib_entry_src_get_vft (const fib_entry_src_t *esrc)
+{
+ fib_source_behaviour_t bh;
+
+ bh = fib_source_get_behaviour(esrc->fes_src);
+
+ if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_INTERPOSE)
+ {
+ return (&fib_entry_src_bh_vft[FIB_SOURCE_BH_INTERPOSE]);
+ }
+
+ return (&fib_entry_src_bh_vft[bh]);
+}
+
+static void
+fib_entry_src_copy_default (const fib_entry_src_t *orig_src,
+ const fib_entry_t *fib_entry,
+ fib_entry_src_t *copy_src)
{
- return (fib_entry->fe_prefix.fp_proto);
+ clib_memcpy(©_src->u, &orig_src->u, sizeof(copy_src->u));
}
void
-fib_entry_src_register (fib_source_t source,
- const fib_entry_src_vft_t *vft)
+fib_entry_src_behaviour_register (fib_source_behaviour_t bh,
+ const fib_entry_src_vft_t *vft)
{
- fib_entry_src_vft[source] = *vft;
+ fib_entry_src_bh_vft[bh] = *vft;
+
+ if (NULL == fib_entry_src_bh_vft[bh].fesv_copy)
+ {
+ fib_entry_src_bh_vft[bh].fesv_copy = fib_entry_src_copy_default;
+ }
}
static int
{
fib_entry_src_t *esrc1 = v1, *esrc2 = v2;
- return (esrc1->fes_src - esrc2->fes_src);
+ return (fib_source_get_prio(esrc1->fes_src) -
+ fib_source_get_prio(esrc2->fes_src));
}
-void
+static void
fib_entry_src_action_init (fib_entry_t *fib_entry,
- fib_source_t source)
-
+ fib_source_t source,
+ fib_entry_flag_t flags)
{
fib_entry_src_t esrc = {
.fes_pl = FIB_NODE_INDEX_INVALID,
.fes_flags = FIB_ENTRY_SRC_FLAG_NONE,
.fes_src = source,
+ .fes_entry_flags = flags,
};
- if (NULL != fib_entry_src_vft[source].fesv_init)
- {
- fib_entry_src_vft[source].fesv_init(&esrc);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, &esrc, fesv_init, (&esrc));
vec_add1(fib_entry->fe_srcs, esrc);
vec_sort_with_function(fib_entry->fe_srcs,
}
static fib_entry_src_t *
-fib_entry_src_find (const fib_entry_t *fib_entry,
- fib_source_t source,
- u32 *index)
+fib_entry_src_find_i (const fib_entry_t *fib_entry,
+ fib_source_t source,
+ u32 *index)
{
fib_entry_src_t *esrc;
return (NULL);
}
+static fib_entry_src_t *
+fib_entry_src_find (const fib_entry_t *fib_entry,
+ fib_source_t source)
+
+{
+ return (fib_entry_src_find_i(fib_entry, source, NULL));
+}
+
int
fib_entry_is_sourced (fib_node_index_t fib_entry_index,
fib_source_t source)
fib_entry = fib_entry_get(fib_entry_index);
- return (NULL != fib_entry_src_find(fib_entry, source, NULL));
+ return (NULL != fib_entry_src_find(fib_entry, source));
+}
+
+int
+fib_entry_is_marked (fib_node_index_t fib_entry_index,
+ fib_source_t source)
+{
+ fib_entry_t *fib_entry;
+ fib_entry_src_t *esrc;
+
+ fib_entry = fib_entry_get(fib_entry_index);
+
+ esrc = fib_entry_src_find(fib_entry, source);
+
+ if (NULL == esrc)
+ {
+ return (0);
+ }
+ else
+ {
+ return (!!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_STALE));
+ }
+}
+
+void
+fib_entry_mark (fib_node_index_t fib_entry_index,
+ fib_source_t source)
+{
+ fib_entry_t *fib_entry;
+ fib_entry_src_t *esrc;
+
+ fib_entry = fib_entry_get(fib_entry_index);
+
+ esrc = fib_entry_src_find(fib_entry, source);
+
+ if (NULL != esrc)
+ {
+ esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_STALE;
+ }
}
static fib_entry_src_t *
fib_entry_src_find_or_create (fib_entry_t *fib_entry,
fib_source_t source,
- u32 *index)
+ fib_entry_flag_t flags)
{
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL == esrc)
{
- fib_entry_src_action_init(fib_entry, source);
+ fib_entry_src_action_init(fib_entry, source, flags);
}
- return (fib_entry_src_find(fib_entry, source, NULL));
+ return (fib_entry_src_find(fib_entry, source));
}
-void
+static void
fib_entry_src_action_deinit (fib_entry_t *fib_entry,
fib_source_t source)
fib_entry_src_t *esrc;
u32 index = ~0;
- esrc = fib_entry_src_find(fib_entry, source, &index);
+ esrc = fib_entry_src_find_i(fib_entry, source, &index);
ASSERT(NULL != esrc);
- if (NULL != fib_entry_src_vft[source].fesv_deinit)
- {
- fib_entry_src_vft[source].fesv_deinit(esrc);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deinit, (esrc));
- vec_free(esrc->fes_path_exts);
+ fib_path_ext_list_flush(&esrc->fes_path_exts);
vec_del1(fib_entry->fe_srcs, index);
+ vec_sort_with_function(fib_entry->fe_srcs,
+ fib_entry_src_cmp_for_sort);
}
fib_entry_src_cover_res_t
fib_entry_src_action_cover_change (fib_entry_t *fib_entry,
- fib_source_t source)
+ fib_entry_src_t *esrc)
{
- if (NULL != fib_entry_src_vft[source].fesv_cover_change)
- {
- return (fib_entry_src_vft[source].fesv_cover_change(
- fib_entry_src_find(fib_entry, source, NULL),
- fib_entry));
- }
+ FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_cover_change,
+ (esrc, fib_entry));
fib_entry_src_cover_res_t res = {
.install = !0,
fib_entry_src_cover_res_t
fib_entry_src_action_cover_update (fib_entry_t *fib_entry,
- fib_source_t source)
+ fib_entry_src_t *esrc)
{
- if (NULL != fib_entry_src_vft[source].fesv_cover_update)
- {
- return (fib_entry_src_vft[source].fesv_cover_update(
- fib_entry_src_find(fib_entry, source, NULL),
- fib_entry));
- }
+ FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_cover_update,
+ (esrc, fib_entry));
fib_entry_src_cover_res_t res = {
.install = !0,
typedef struct fib_entry_src_collect_forwarding_ctx_t_
{
- load_balance_path_t * next_hops;
+ load_balance_path_t *next_hops;
const fib_entry_t *fib_entry;
const fib_entry_src_t *esrc;
fib_forward_chain_type_t fct;
- int is_recursive;
+ int n_recursive_constrained;
+ u16 preference;
} fib_entry_src_collect_forwarding_ctx_t;
/**
fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx)
{
/**
- * We'll use a LB map is the path-list has recursive paths.
+ * We'll use a LB map if the path-list has multiple recursive paths.
* recursive paths implies BGP, and hence scale.
*/
- if (ctx->is_recursive)
+ if (ctx->n_recursive_constrained > 1 &&
+ fib_path_list_is_popular(ctx->esrc->fes_pl))
{
return (LOAD_BALANCE_FLAG_USES_MAP);
}
fib_entry_src_valid_out_label (mpls_label_t label)
{
return ((MPLS_LABEL_IS_REAL(label) ||
+ MPLS_LABEL_POP == label ||
MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL == label ||
MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL == label ||
MPLS_IETF_IMPLICIT_NULL_LABEL == label));
fib_entry_chain_type_fixup (const fib_entry_t *entry,
fib_forward_chain_type_t fct)
{
- ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS == fct);
-
/*
* The EOS chain is a tricky since one cannot know the adjacency
* to link to without knowing what the packets payload protocol
*/
fib_forward_chain_type_t dfct;
+ if (FIB_FORW_CHAIN_TYPE_MPLS_EOS != fct)
+ {
+ return (fct);
+ }
+
dfct = fib_entry_get_default_chain_type(entry);
if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct)
return (dfct);
}
-static int
+static dpo_proto_t
+fib_prefix_get_payload_proto (const fib_prefix_t *pfx)
+{
+ switch (pfx->fp_proto)
+ {
+ case FIB_PROTOCOL_IP4:
+ return (DPO_PROTO_IP4);
+ case FIB_PROTOCOL_IP6:
+ return (DPO_PROTO_IP6);
+ case FIB_PROTOCOL_MPLS:
+ return (pfx->fp_payload_proto);
+ }
+
+ ASSERT(0);
+ return (DPO_PROTO_IP4);
+}
+
+static void
+fib_entry_src_get_path_forwarding (fib_node_index_t path_index,
+ fib_entry_src_collect_forwarding_ctx_t *ctx)
+{
+ load_balance_path_t *nh;
+
+ /*
+ * no extension => no out-going label for this path. that's OK
+ * in the case of an IP or EOS chain, but not for non-EOS
+ */
+ switch (ctx->fct)
+ {
+ case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
+ case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
+ case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
+ case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
+ case FIB_FORW_CHAIN_TYPE_BIER:
+ /*
+ * EOS traffic with no label to stack, we need the IP Adj
+ */
+ vec_add2(ctx->next_hops, nh, 1);
+
+ nh->path_index = path_index;
+ nh->path_weight = fib_path_get_weight(path_index);
+ fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
+
+ break;
+ case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
+ if (fib_path_is_exclusive(path_index) ||
+ fib_path_is_deag(path_index))
+ {
+ vec_add2(ctx->next_hops, nh, 1);
+
+ nh->path_index = path_index;
+ nh->path_weight = fib_path_get_weight(path_index);
+ fib_path_contribute_forwarding(path_index,
+ FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
+ &nh->path_dpo);
+ }
+ break;
+ case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
+ {
+ /*
+ * no label. we need a chain based on the payload. fixup.
+ */
+ vec_add2(ctx->next_hops, nh, 1);
+
+ nh->path_index = path_index;
+ nh->path_weight = fib_path_get_weight(path_index);
+ fib_path_contribute_forwarding(path_index,
+ fib_entry_chain_type_fixup(ctx->fib_entry,
+ ctx->fct),
+ &nh->path_dpo);
+ fib_path_stack_mpls_disp(path_index,
+ fib_prefix_get_payload_proto(&ctx->fib_entry->fe_prefix),
+ FIB_MPLS_LSP_MODE_PIPE,
+ &nh->path_dpo);
+
+ break;
+ }
+ case FIB_FORW_CHAIN_TYPE_ETHERNET:
+ case FIB_FORW_CHAIN_TYPE_NSH:
+ ASSERT(0);
+ break;
+ }
+}
+
+static fib_path_list_walk_rc_t
fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
fib_node_index_t path_index,
void *arg)
{
fib_entry_src_collect_forwarding_ctx_t *ctx;
fib_path_ext_t *path_ext;
+ u32 n_nhs;
ctx = arg;
+ n_nhs = vec_len(ctx->next_hops);
/*
* if the path is not resolved, don't include it.
*/
if (!fib_path_is_resolved(path_index))
{
- return (!0);
+ return (FIB_PATH_LIST_WALK_CONTINUE);
}
- if (fib_path_is_recursive(path_index))
+ if (fib_path_is_recursive_constrained(path_index))
{
- ctx->is_recursive = 1;
+ ctx->n_recursive_constrained += 1;
+ }
+ if (0xffff == ctx->preference)
+ {
+ /*
+ * not set a preference yet, so the first path we encounter
+ * sets the preference we are collecting.
+ */
+ ctx->preference = fib_path_get_preference(path_index);
+ }
+ else if (ctx->preference != fib_path_get_preference(path_index))
+ {
+ /*
+ * this path does not belong to the same preference as the
+ * previous paths encountered. we are done now.
+ */
+ return (FIB_PATH_LIST_WALK_STOP);
}
/*
* get the matching path-extension for the path being visited.
*/
- vec_foreach(path_ext, ctx->esrc->fes_path_exts)
+ path_ext = fib_path_ext_list_find_by_path_index(&ctx->esrc->fes_path_exts,
+ path_index);
+
+ if (NULL != path_ext)
{
- if (path_ext->fpe_path_index == path_index)
+ switch (path_ext->fpe_type)
+ {
+ case FIB_PATH_EXT_MPLS:
+ if (fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0].fml_value))
+ {
+ /*
+ * found a matching extension. stack it to obtain the forwarding
+ * info for this path.
+ */
+ ctx->next_hops =
+ fib_path_ext_stack(path_ext,
+ ctx->fct,
+ fib_entry_chain_type_fixup(ctx->fib_entry,
+ ctx->fct),
+ ctx->next_hops);
+ }
+ else
+ {
+ fib_entry_src_get_path_forwarding(path_index, ctx);
+ }
break;
- }
-
- if (NULL != path_ext &&
- path_ext->fpe_path_index == path_index &&
- fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0]))
- {
- /*
- * found a matching extension. stack it to obtain the forwarding
- * info for this path.
- */
- ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fib_entry, ctx->fct, ctx->next_hops);
+ case FIB_PATH_EXT_ADJ:
+ if (FIB_PATH_EXT_ADJ_FLAG_REFINES_COVER & path_ext->fpe_adj_flags)
+ {
+ fib_entry_src_get_path_forwarding(path_index, ctx);
+ }
+ /*
+ * else
+ * the path does not refine the cover, meaning that
+ * the adjacency does/does not match the sub-net on the link.
+ * So this path does not contribute forwarding.
+ */
+ break;
+ }
}
else
{
- load_balance_path_t *nh;
+ fib_entry_src_get_path_forwarding(path_index, ctx);
+ }
+ /*
+ * a this point 'ctx' has the DPO the path contributed, plus
+ * any labels from path extensions.
+ * check if there are any interpose sources that want to contribute
+ */
+ if (n_nhs < vec_len(ctx->next_hops))
+ {
/*
- * no extension => no out-going label for this path. that's OK
- * in the case of an IP or EOS chain, but not for non-EOS
+ * the path contributed a new choice.
*/
- switch (ctx->fct)
- {
- case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
- case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
- case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
- case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
- /*
- * EOS traffic with no label to stack, we need the IP Adj
- */
- vec_add2(ctx->next_hops, nh, 1);
+ const fib_entry_src_vft_t *vft;
- nh->path_index = path_index;
- nh->path_weight = fib_path_get_weight(path_index);
- fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
-
- break;
- case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
- if (fib_path_is_exclusive(path_index) ||
- fib_path_is_deag(path_index))
- {
- vec_add2(ctx->next_hops, nh, 1);
+ vft = fib_entry_src_get_vft(ctx->esrc);
- nh->path_index = path_index;
- nh->path_weight = fib_path_get_weight(path_index);
- fib_path_contribute_forwarding(path_index,
- FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
- &nh->path_dpo);
- }
- break;
- case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
+ if (NULL != vft->fesv_contribute_interpose)
{
- /*
- * no label. we need a chain based on the payload. fixup.
- */
- vec_add2(ctx->next_hops, nh, 1);
+ const dpo_id_t *interposer;
- nh->path_index = path_index;
- nh->path_weight = fib_path_get_weight(path_index);
- fib_path_contribute_forwarding(path_index,
- fib_entry_chain_type_fixup(ctx->fib_entry,
- ctx->fct),
- &nh->path_dpo);
+ interposer = vft->fesv_contribute_interpose(ctx->esrc,
+ ctx->fib_entry);
- break;
- }
- case FIB_FORW_CHAIN_TYPE_ETHERNET:
- case FIB_FORW_CHAIN_TYPE_NSH:
- ASSERT(0);
- break;
+ if (NULL != interposer)
+ {
+ dpo_id_t clone = DPO_INVALID;
+
+ dpo_mk_interpose(interposer,
+ &ctx->next_hops[n_nhs].path_dpo,
+ &clone);
+
+ dpo_copy(&ctx->next_hops[n_nhs].path_dpo, &clone);
+ dpo_reset(&clone);
+ }
}
}
- return (!0);
+ return (FIB_PATH_LIST_WALK_CONTINUE);
}
void
.esrc = esrc,
.fib_entry = fib_entry,
.next_hops = NULL,
- .is_recursive = 0,
+ .n_recursive_constrained = 0,
.fct = fct,
+ .preference = 0xffff,
};
/*
* As an optimisation we allocate the vector of next-hops to be sized
- * equal to the maximum nuber of paths we will need, which is also the
+ * equal to the maximum number of paths we will need, which is also the
* most likely number we will need, since in most cases the paths are 'up'.
*/
vec_validate(ctx.next_hops, fib_path_list_get_n_paths(esrc->fes_pl));
vec_reset_length(ctx.next_hops);
- lb_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
+ lb_proto = fib_forw_chain_type_to_dpo_proto(fct);
fib_path_list_walk(esrc->fes_pl,
fib_entry_src_collect_forwarding,
/*
* first time create
*/
- flow_hash_config_t fhc;
+ if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_MULTICAST)
+ {
+ dpo_set(dpo_lb,
+ DPO_REPLICATE,
+ lb_proto,
+ MPLS_IS_REPLICATE | replicate_create(0, lb_proto));
+ }
+ else
+ {
+ fib_protocol_t flow_hash_proto;
+ flow_hash_config_t fhc;
- fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index,
- dpo_proto_to_fib(lb_proto));
- dpo_set(dpo_lb,
- DPO_LOAD_BALANCE,
- lb_proto,
- load_balance_create(0, lb_proto, fhc));
+ /*
+ * if the protocol for the LB we are building does not match that
+ * of the fib_entry (i.e. we are build the [n]EOS LB for an IPv[46]
+ * then the fib_index is not an index that relates to the table
+ * type we need. So get the default flow-hash config instead.
+ */
+ flow_hash_proto = dpo_proto_to_fib(lb_proto);
+ if (fib_entry->fe_prefix.fp_proto != flow_hash_proto)
+ {
+ fhc = fib_table_get_default_flow_hash_config(flow_hash_proto);
+ }
+ else
+ {
+ fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index,
+ flow_hash_proto);
+ }
+
+ dpo_set(dpo_lb,
+ DPO_LOAD_BALANCE,
+ lb_proto,
+ load_balance_create(0, lb_proto, fhc));
+ }
}
- load_balance_multipath_update(dpo_lb,
- ctx.next_hops,
- fib_entry_calc_lb_flags(&ctx));
- vec_free(ctx.next_hops);
-
- /*
- * if this entry is sourced by the uRPF-exempt source then we
- * append the always present local0 interface (index 0) to the
- * uRPF list so it is not empty. that way packets pass the loose check.
- */
- index_t ui = fib_path_list_get_urpf(esrc->fes_pl);
-
- if (fib_entry_is_sourced(fib_entry_get_index(fib_entry),
- FIB_SOURCE_URPF_EXEMPT) &&
- (0 == fib_urpf_check_size(ui)))
+ if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_MULTICAST)
{
- /*
- * The uRPF list we get from the path-list is shared by all
- * other users of the list, but the uRPF exemption applies
- * only to this prefix. So we need our own list.
- */
- ui = fib_urpf_list_alloc_and_lock();
- fib_urpf_list_append(ui, 0);
- fib_urpf_list_bake(ui);
- load_balance_set_urpf(dpo_lb->dpoi_index, ui);
- fib_urpf_list_unlock(ui);
+ /*
+ * MPLS multicast
+ */
+ replicate_multipath_update(dpo_lb, ctx.next_hops);
}
else
{
- load_balance_set_urpf(dpo_lb->dpoi_index, ui);
+ load_balance_multipath_update(dpo_lb,
+ ctx.next_hops,
+ fib_entry_calc_lb_flags(&ctx));
+ vec_free(ctx.next_hops);
+
+ /*
+ * if this entry is sourced by the uRPF-exempt source then we
+ * append the always present local0 interface (index 0) to the
+ * uRPF list so it is not empty. that way packets pass the loose check.
+ */
+ index_t ui = fib_path_list_get_urpf(esrc->fes_pl);
+
+ if ((fib_entry_is_sourced(fib_entry_get_index(fib_entry),
+ FIB_SOURCE_URPF_EXEMPT) ||
+ (esrc->fes_entry_flags & FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT))&&
+ (0 == fib_urpf_check_size(ui)))
+ {
+ /*
+ * The uRPF list we get from the path-list is shared by all
+ * other users of the list, but the uRPF exemption applies
+ * only to this prefix. So we need our own list.
+ */
+ ui = fib_urpf_list_alloc_and_lock();
+ fib_urpf_list_append(ui, 0);
+ fib_urpf_list_bake(ui);
+ load_balance_set_urpf(dpo_lb->dpoi_index, ui);
+ fib_urpf_list_unlock(ui);
+ }
+ else
+ {
+ load_balance_set_urpf(dpo_lb->dpoi_index, ui);
+ }
+ load_balance_set_fib_entry_flags(dpo_lb->dpoi_index,
+ fib_entry_get_flags_i(fib_entry));
}
- load_balance_set_fib_entry_flags(dpo_lb->dpoi_index,
- fib_entry_get_flags_i(fib_entry));
}
void
int insert;
fct = fib_entry_get_default_chain_type(fib_entry);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
/*
* Every entry has its own load-balance object. All changes to the entry's
/*
* uninstall the forwarding chain from the forwarding tables
*/
- FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
- fib_entry->fe_adj_index);
+ FIB_ENTRY_DBG(fib_entry, "uninstall");
+
+ if (dpo_id_is_valid(&fib_entry->fe_lb))
+ {
+ fib_table_fwding_dpo_remove(
+ fib_entry->fe_fib_index,
+ &fib_entry->fe_prefix,
+ &fib_entry->fe_lb);
+
+ dpo_reset(&fib_entry->fe_lb);
+ }
+}
+
+static void
+fib_entry_recursive_loop_detect_i (fib_node_index_t path_list_index)
+{
+ fib_node_index_t *entries = NULL;
+
+ fib_path_list_recursive_loop_detect(path_list_index, &entries);
+
+ vec_free(entries);
+}
+
+/*
+ * fib_entry_src_action_copy
+ *
+ * copy a source data from another entry to this one
+ */
+static fib_entry_t *
+fib_entry_src_action_copy (fib_entry_t *fib_entry,
+ const fib_entry_src_t *orig_src)
+{
+ fib_entry_src_t *esrc;
+
+ esrc = fib_entry_src_find_or_create(fib_entry,
+ orig_src->fes_src,
+ orig_src->fes_entry_flags);
+
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_copy,
+ (orig_src, fib_entry, esrc));
+
+ fib_path_list_unlock(esrc->fes_pl);
+
+ /*
+ * copy over all the data ...
+ */
+ esrc->fes_flags = orig_src->fes_flags;
+ esrc->fes_pl = orig_src->fes_pl;
+
+ /*
+ * ... then update
+ */
+ esrc->fes_ref_count = 1;
+ esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_INHERITED;
+ esrc->fes_flags &= ~(FIB_ENTRY_SRC_FLAG_ACTIVE |
+ FIB_ENTRY_SRC_FLAG_CONTRIBUTING);
+ esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_COVERED_INHERIT;
+
+ /*
+ * the source owns a lock on the entry
+ */
+ fib_path_list_lock(esrc->fes_pl);
+ fib_entry_lock(fib_entry_get_index(fib_entry));
+
+ return (fib_entry);
+}
+
+/*
+ * fib_entry_src_action_update
+ *
+ * copy a source data from another entry to this one
+ */
+static fib_entry_src_t *
+fib_entry_src_action_update_from_cover (fib_entry_t *fib_entry,
+ const fib_entry_src_t *orig_src)
+{
+ fib_entry_src_t *esrc;
+
+ esrc = fib_entry_src_find_or_create(fib_entry,
+ orig_src->fes_src,
+ orig_src->fes_entry_flags);
+
+ /*
+ * the source owns a lock on the entry
+ */
+ fib_path_list_unlock(esrc->fes_pl);
+ esrc->fes_pl = orig_src->fes_pl;
+ fib_path_list_lock(esrc->fes_pl);
+
+ return (esrc);
+}
+
+static fib_table_walk_rc_t
+fib_entry_src_covered_inherit_add_i (fib_entry_t *fib_entry,
+ const fib_entry_src_t *cover_src)
+{
+ fib_entry_src_t *esrc;
+
+ esrc = fib_entry_src_find(fib_entry, cover_src->fes_src);
+
+ if (cover_src == esrc)
+ {
+ return (FIB_TABLE_WALK_CONTINUE);
+ }
+
+ if (NULL != esrc)
+ {
+ /*
+ * the covered entry already has this source.
+ */
+ if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT)
+ {
+ /*
+ * the covered source is itself a COVERED_INHERIT, i.e.
+ * it also pushes this source down the sub-tree.
+ * We consider this more specific covered to be the owner
+ * of the sub-tree from this point down.
+ */
+ return (FIB_TABLE_WALK_SUB_TREE_STOP);
+ }
+ if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED)
+ {
+ /*
+ * The covered's source data has been inherited, presumably
+ * from this cover, i.e. this is a modify.
+ */
+ esrc = fib_entry_src_action_update_from_cover(fib_entry, cover_src);
+ fib_entry_source_change(fib_entry, esrc->fes_src, esrc->fes_src);
+ }
+ else
+ {
+ /*
+ * The covered's source was not inherited and it is also
+ * not inheriting. Nevertheless, it still owns the sub-tree from
+ * this point down.
+ */
+ return (FIB_TABLE_WALK_SUB_TREE_STOP);
+ }
+ }
+ else
+ {
+ /*
+ * The covered does not have this source - add it.
+ */
+ fib_source_t best_source;
+
+ best_source = fib_entry_get_best_source(
+ fib_entry_get_index(fib_entry));
+
+ fib_entry_src_action_copy(fib_entry, cover_src);
+ fib_entry_source_change(fib_entry, best_source, cover_src->fes_src);
+
+ }
+ return (FIB_TABLE_WALK_CONTINUE);
+}
+
+static fib_table_walk_rc_t
+fib_entry_src_covered_inherit_walk_add (fib_node_index_t fei,
+ void *ctx)
+{
+ return (fib_entry_src_covered_inherit_add_i(fib_entry_get(fei), ctx));
+}
+
+static fib_table_walk_rc_t
+fib_entry_src_covered_inherit_walk_remove (fib_node_index_t fei,
+ void *ctx)
+{
+ fib_entry_src_t *cover_src, *esrc;
+ fib_entry_t *fib_entry;
+
+ fib_entry = fib_entry_get(fei);
+
+ cover_src = ctx;
+ esrc = fib_entry_src_find(fib_entry, cover_src->fes_src);
+
+ if (cover_src == esrc)
+ {
+ return (FIB_TABLE_WALK_CONTINUE);
+ }
+
+ if (NULL != esrc)
+ {
+ /*
+ * the covered entry already has this source.
+ */
+ if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT)
+ {
+ /*
+ * the covered source is itself a COVERED_INHERIT, i.e.
+ * it also pushes this source down the sub-tree.
+ * We consider this more specific covered to be the owner
+ * of the sub-tree from this point down.
+ */
+ return (FIB_TABLE_WALK_SUB_TREE_STOP);
+ }
+ if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED)
+ {
+ /*
+ * The covered's source data has been inherited, presumably
+ * from this cover
+ */
+ fib_entry_src_flag_t remaining;
+
+ remaining = fib_entry_special_remove(fei, cover_src->fes_src);
+
+ ASSERT(FIB_ENTRY_SRC_FLAG_ADDED == remaining);
+ }
+ else
+ {
+ /*
+ * The covered's source was not inherited and it is also
+ * not inheriting. Nevertheless, it still owns the sub-tree from
+ * this point down.
+ */
+ return (FIB_TABLE_WALK_SUB_TREE_STOP);
+ }
+ }
+ else
+ {
+ /*
+ * The covered does not have this source - that's an error,
+ * since it should have inherited, but there is nothing we can do
+ * about it now.
+ */
+ }
+ return (FIB_TABLE_WALK_CONTINUE);
+}
+
+void
+fib_entry_src_inherit (const fib_entry_t *cover,
+ fib_entry_t *covered)
+{
+ CLIB_UNUSED(fib_source_t source);
+ const fib_entry_src_t *src;
+
+ FOR_EACH_SRC_ADDED(cover, src, source,
+ ({
+ if ((src->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) ||
+ (src->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
+ {
+ fib_entry_src_covered_inherit_add_i(covered, src);
+ }
+ }))
+}
+
+static void
+fib_entry_src_covered_inherit_add (fib_entry_t *fib_entry,
+ fib_source_t source)
+
+{
+ fib_entry_src_t *esrc;
+
+ esrc = fib_entry_src_find(fib_entry, source);
- if (dpo_id_is_valid(&fib_entry->fe_lb))
- {
- fib_table_fwding_dpo_remove(
- fib_entry->fe_fib_index,
- &fib_entry->fe_prefix,
- &fib_entry->fe_lb);
+ ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
- dpo_reset(&fib_entry->fe_lb);
+ if ((esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) ||
+ (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
+ {
+ fib_table_sub_tree_walk(fib_entry->fe_fib_index,
+ fib_entry->fe_prefix.fp_proto,
+ &fib_entry->fe_prefix,
+ fib_entry_src_covered_inherit_walk_add,
+ esrc);
}
}
static void
-fib_entry_recursive_loop_detect_i (fib_node_index_t path_list_index)
-{
- fib_node_index_t *entries = NULL;
+fib_entry_src_covered_inherit_remove (fib_entry_t *fib_entry,
+ fib_entry_src_t *esrc)
- fib_path_list_recursive_loop_detect(path_list_index, &entries);
+{
+ ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
- vec_free(entries);
+ if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT)
+ {
+ fib_table_sub_tree_walk(fib_entry->fe_fib_index,
+ fib_entry->fe_prefix.fp_proto,
+ &fib_entry->fe_prefix,
+ fib_entry_src_covered_inherit_walk_remove,
+ esrc);
+ }
}
void
{
int houston_we_are_go_for_install;
+ const fib_entry_src_vft_t *vft;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
- esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ACTIVE;
+ esrc->fes_flags |= (FIB_ENTRY_SRC_FLAG_ACTIVE |
+ FIB_ENTRY_SRC_FLAG_CONTRIBUTING);
+ vft = fib_entry_src_get_vft(esrc);
- if (NULL != fib_entry_src_vft[source].fesv_activate)
+ if (NULL != vft->fesv_activate)
{
- houston_we_are_go_for_install =
- fib_entry_src_vft[source].fesv_activate(esrc, fib_entry);
+ houston_we_are_go_for_install = vft->fesv_activate(esrc, fib_entry);
}
else
{
FIB_ENTRY_DBG(fib_entry, "activate: %d",
fib_entry->fe_parent);
+ /*
+ * If this source should push its state to covered prefixs, do that now.
+ */
+ fib_entry_src_covered_inherit_add(fib_entry, source);
+
if (0 != houston_we_are_go_for_install)
{
fib_entry_src_action_install(fib_entry, source);
fib_node_index_t path_list_index;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
- if (NULL != fib_entry_src_vft[source].fesv_deactivate)
- {
- fib_entry_src_vft[source].fesv_deactivate(esrc, fib_entry);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deactivate,
+ (esrc, fib_entry));
- esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_ACTIVE;
+ esrc->fes_flags &= ~(FIB_ENTRY_SRC_FLAG_ACTIVE |
+ FIB_ENTRY_SRC_FLAG_CONTRIBUTING);
FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
+ /*
+ * If this source should pull its state from covered prefixs, do that now.
+ * If this source also has the INHERITED flag set then it has a cover
+ * that wants to push down forwarding. We only want the covereds to see
+ * one update.
+ */
+ fib_entry_src_covered_inherit_remove(fib_entry, esrc);
+
/*
* un-link from an old path-list. Check for any loops this will clear
*/
vec_foreach(esrc, fib_entry->fe_srcs)
{
- if (NULL != fib_entry_src_vft[esrc->fes_src].fesv_fwd_update)
- {
- fib_entry_src_vft[esrc->fes_src].fesv_fwd_update(esrc,
- fib_entry,
- source);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_fwd_update,
+ (esrc, fib_entry, source));
}
}
fib_source_t source)
{
fib_node_index_t path_list_index;
+ const fib_entry_src_vft_t *vft;
fib_entry_src_t *esrc;
+ int remain_installed;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
fib_entry->fe_parent,
esrc->fes_pl);
+ /*
+ * call the source to reactive and get the go/no-go to remain installed
+ */
+ vft = fib_entry_src_get_vft(esrc);
+
+ if (NULL != vft->fesv_reactivate)
+ {
+ remain_installed = vft->fesv_reactivate(esrc, fib_entry);
+ }
+ else
+ {
+ remain_installed = 1;
+ }
+
if (fib_entry->fe_parent != esrc->fes_pl)
{
/*
fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
fib_path_list_unlock(path_list_index);
+
+ /*
+ * If this source should push its state to covered prefixs, do that now.
+ */
+ fib_entry_src_covered_inherit_add(fib_entry, source);
+ }
+
+ if (!remain_installed)
+ {
+ fib_entry_src_action_uninstall(fib_entry);
+ }
+ else
+ {
+ fib_entry_src_action_install(fib_entry, source);
}
- fib_entry_src_action_install(fib_entry, source);
fib_entry_src_action_fwd_update(fib_entry, source);
}
-void
-fib_entry_src_action_installed (const fib_entry_t *fib_entry,
+fib_entry_t *
+fib_entry_src_action_installed (fib_entry_t *fib_entry,
fib_source_t source)
{
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
- if (NULL != fib_entry_src_vft[source].fesv_installed)
- {
- fib_entry_src_vft[source].fesv_installed(esrc,
- fib_entry);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_installed,
+ (esrc, fib_entry));
fib_entry_src_action_fwd_update(fib_entry, source);
+
+ return (fib_entry);
}
/*
fib_entry_flag_t flags,
const dpo_id_t *dpo)
{
- fib_node_index_t fib_entry_index;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
+ esrc = fib_entry_src_find_or_create(fib_entry, source, flags);
+ ASSERT(esrc->fes_ref_count < 255);
esrc->fes_ref_count++;
+ if (flags != esrc->fes_entry_flags)
+ {
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_flags_change,
+ (esrc, fib_entry, flags));
+ }
+ esrc->fes_entry_flags = flags;
+
if (1 != esrc->fes_ref_count)
{
/*
return (fib_entry);
}
- esrc->fes_entry_flags = flags;
-
- /*
- * save variable so we can recover from a fib_entry realloc.
- */
- fib_entry_index = fib_entry_get_index(fib_entry);
-
- if (NULL != fib_entry_src_vft[source].fesv_add)
- {
- fib_entry_src_vft[source].fesv_add(esrc,
- fib_entry,
- flags,
- fib_entry_get_proto(fib_entry),
- dpo);
- }
-
- fib_entry = fib_entry_get(fib_entry_index);
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_add,
+ (esrc,
+ fib_entry,
+ flags,
+ fib_entry_get_dpo_proto(fib_entry),
+ dpo));
esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
fib_entry_flag_t flags,
const dpo_id_t *dpo)
{
- fib_node_index_t fib_entry_index, old_path_list_index;
+ fib_node_index_t old_path_list_index;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
+ esrc = fib_entry_src_find_or_create(fib_entry, source, flags);
if (NULL == esrc)
+ {
return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
+ }
old_path_list_index = esrc->fes_pl;
esrc->fes_entry_flags = flags;
- /*
- * save variable so we can recover from a fib_entry realloc.
- */
- fib_entry_index = fib_entry_get_index(fib_entry);
-
- if (NULL != fib_entry_src_vft[source].fesv_add)
- {
- fib_entry_src_vft[source].fesv_add(esrc,
- fib_entry,
- flags,
- fib_entry_get_proto(fib_entry),
- dpo);
- }
-
- fib_entry = fib_entry_get(fib_entry_index);
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_add,
+ (esrc,
+ fib_entry,
+ flags,
+ fib_entry_get_dpo_proto(fib_entry),
+ dpo));
esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
return (fib_entry);
}
+fib_entry_src_flag_t
+fib_entry_src_action_remove_or_update_inherit (fib_entry_t *fib_entry,
+ fib_source_t source)
+{
+ fib_entry_src_t *esrc;
+
+ esrc = fib_entry_src_find(fib_entry, source);
+
+ if (NULL == esrc)
+ return (FIB_ENTRY_SRC_FLAG_ACTIVE);
+
+ if ((esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) &&
+ (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED))
+ {
+ fib_entry_src_t *cover_src;
+ fib_node_index_t coveri;
+ fib_entry_t *cover;
+
+ /*
+ * this source was pushing inherited state, but so is its
+ * cover. Now that this source is going away, we need to
+ * pull the covers forwarding and use it to update the covereds.
+ * Go grab the path-list from the cover, rather than start a walk from
+ * the cover, so we don't recursively update this entry.
+ */
+ coveri = fib_table_get_less_specific(fib_entry->fe_fib_index,
+ &fib_entry->fe_prefix);
+
+ /*
+ * only the default route has itself as its own cover, but the
+ * default route cannot have inherited from something else.
+ */
+ ASSERT(coveri != fib_entry_get_index(fib_entry));
+
+ cover = fib_entry_get(coveri);
+ cover_src = fib_entry_src_find(cover, source);
+
+ ASSERT(NULL != cover_src);
+
+ esrc = fib_entry_src_action_update_from_cover(fib_entry, cover_src);
+ esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_COVERED_INHERIT;
+
+ /*
+ * Now push the new state from the cover down to the covereds
+ */
+ fib_entry_src_covered_inherit_add(fib_entry, source);
+
+ return (esrc->fes_flags);
+ }
+ else
+ {
+ return (fib_entry_src_action_remove(fib_entry, source));
+ }
+}
fib_entry_src_flag_t
fib_entry_src_action_remove (fib_entry_t *fib_entry,
fib_entry_src_flag_t sflags;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL == esrc)
return (FIB_ENTRY_SRC_FLAG_ACTIVE);
if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE)
{
- fib_entry_src_action_deactivate(fib_entry, source);
+ fib_entry_src_action_deactivate(fib_entry, source);
+ }
+ else if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_CONTRIBUTING)
+ {
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deactivate,
+ (esrc, fib_entry));
+ esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_CONTRIBUTING;
}
old_path_list = esrc->fes_pl;
- if (NULL != fib_entry_src_vft[source].fesv_remove)
- {
- fib_entry_src_vft[source].fesv_remove(esrc);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_remove, (esrc));
fib_path_list_unlock(old_path_list);
fib_entry_unlock(fib_entry_get_index(fib_entry));
return (sflags);
}
-static inline int
-fib_route_recurses_via_self (const fib_prefix_t *prefix,
- const fib_route_path_t *rpath)
-{
- /*
- * not all zeros next hop &&
- * is recursive path &&
- * nexthop is same as the route's address
- */
- return ((!ip46_address_is_zero(&rpath->frp_addr)) &&
- (~0 == rpath->frp_sw_if_index) &&
- (0 == ip46_address_cmp(&rpath->frp_addr, &prefix->fp_addr)));
-
-}
-
/*
* fib_route_attached_cross_table
*
*/
if (ip46_address_is_zero(&rpath->frp_addr) &&
(~0 != rpath->frp_sw_if_index) &&
+ !(rpath->frp_flags & FIB_ROUTE_PATH_DVR) &&
(fib_entry->fe_fib_index !=
fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry),
rpath->frp_sw_if_index)))
}
/*
- * fib_route_attached_cross_table
- *
- * Return true the the route is attached via an interface that
- * is not in the same table as the route
+ * Return true if the path is attached
*/
static inline int
fib_path_is_attached (const fib_route_path_t *rpath)
{
+ /*
+ * DVR paths are not attached, since we are not playing the
+ * L3 game with these
+ */
+ if (rpath->frp_flags & FIB_ROUTE_PATH_DVR)
+ {
+ return (0);
+ }
+
/*
* - All zeros next-hop
* - a valid interface
{
return (!0);
}
+ else if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
+ {
+ return (!0);
+ }
return (0);
}
{
plf |= FIB_PATH_LIST_FLAG_DROP;
}
- if (eflags & FIB_ENTRY_FLAG_LOCAL)
- {
- plf |= FIB_PATH_LIST_FLAG_LOCAL;
- }
if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
{
plf |= FIB_PATH_LIST_FLAG_EXCLUSIVE;
}
+ if (eflags & FIB_ENTRY_FLAG_LOCAL)
+ {
+ plf |= FIB_PATH_LIST_FLAG_LOCAL;
+ }
return (plf);
}
static void
fib_entry_flags_update (const fib_entry_t *fib_entry,
- const fib_route_path_t *rpath,
+ const fib_route_path_t *rpaths,
fib_path_list_flags_t *pl_flags,
fib_entry_src_t *esrc)
{
- /*
- * don't allow the addition of a recursive looped path for prefix
- * via itself.
- */
- if (fib_route_recurses_via_self(&fib_entry->fe_prefix, rpath))
- {
- /*
- * force the install of a drop path-list.
- * we want the entry to have some path-list, mainly so
- * the dodgy path can be rmeoved when the source stops playing
- * silly buggers.
- */
- *pl_flags |= FIB_PATH_LIST_FLAG_DROP;
- }
- else
- {
- *pl_flags &= ~FIB_PATH_LIST_FLAG_DROP;
- }
-
- if ((esrc->fes_src == FIB_SOURCE_API) ||
- (esrc->fes_src == FIB_SOURCE_CLI))
- {
- if (fib_path_is_attached(rpath))
- {
- esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED;
- }
- else
- {
- esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED;
- }
- }
- if (fib_route_attached_cross_table(fib_entry, rpath))
- {
- esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
- }
- else
- {
- esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
- }
-}
-
-/*
- * fib_entry_src_path_ext_add
- *
- * append a path extension to the entry's list
- */
-static void
-fib_entry_src_path_ext_append (fib_entry_src_t *esrc,
- const fib_route_path_t *rpath)
-{
- if (NULL != rpath->frp_label_stack)
- {
- fib_path_ext_t *path_ext;
-
- vec_add2(esrc->fes_path_exts, path_ext, 1);
-
- fib_path_ext_init(path_ext, esrc->fes_pl, rpath);
- }
-}
-
-/*
- * fib_entry_src_path_ext_insert
- *
- * insert, sorted, a path extension to the entry's list.
- * It's not strictly necessary in sort the path extensions, since each
- * extension has the path index to which it resolves. However, by being
- * sorted the load-balance produced has a deterministic order, not an order
- * based on the sequence of extension additions. this is a considerable benefit.
- */
-static void
-fib_entry_src_path_ext_insert (fib_entry_src_t *esrc,
- const fib_route_path_t *rpath)
-{
- if (0 == vec_len(esrc->fes_path_exts))
- return (fib_entry_src_path_ext_append(esrc, rpath));
+ const fib_route_path_t *rpath;
- if (NULL != rpath->frp_label_stack)
+ vec_foreach(rpath, rpaths)
{
- fib_path_ext_t path_ext;
- int i = 0;
-
- fib_path_ext_init(&path_ext, esrc->fes_pl, rpath);
-
- while (i < vec_len(esrc->fes_path_exts) &&
- (fib_path_ext_cmp(&esrc->fes_path_exts[i], rpath) < 0))
- {
- i++;
- }
-
- vec_insert_elts(esrc->fes_path_exts, &path_ext, 1, i);
+ if ((esrc->fes_src == FIB_SOURCE_API) ||
+ (esrc->fes_src == FIB_SOURCE_CLI))
+ {
+ if (fib_path_is_attached(rpath))
+ {
+ esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED;
+ }
+ else
+ {
+ esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED;
+ }
+ if (rpath->frp_flags & FIB_ROUTE_PATH_DEAG)
+ {
+ esrc->fes_entry_flags |= FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT;
+ }
+ }
+ if (fib_route_attached_cross_table(fib_entry, rpath) &&
+ !(esrc->fes_entry_flags & FIB_ENTRY_FLAG_NO_ATTACHED_EXPORT))
+ {
+ esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
+ }
+ else
+ {
+ esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
+ }
}
}
fib_entry_src_action_path_add (fib_entry_t *fib_entry,
fib_source_t source,
fib_entry_flag_t flags,
- const fib_route_path_t *rpath)
+ const fib_route_path_t *rpaths)
{
- fib_node_index_t old_path_list, fib_entry_index;
+ fib_node_index_t old_path_list;
fib_path_list_flags_t pl_flags;
- fib_path_ext_t *path_ext;
fib_entry_src_t *esrc;
- /*
- * save variable so we can recover from a fib_entry realloc.
- */
- fib_entry_index = fib_entry_get_index(fib_entry);
-
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL == esrc)
{
+ const dpo_id_t *dpo;
+
+ if (flags == FIB_ENTRY_FLAG_EXCLUSIVE) {
+ dpo = &rpaths->dpo;
+ } else {
+ dpo = drop_dpo_get(fib_entry_get_dpo_proto(fib_entry));
+ }
+
fib_entry =
fib_entry_src_action_add(fib_entry,
source,
flags,
- drop_dpo_get(
- fib_proto_to_dpo(
- fib_entry_get_proto(fib_entry))));
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ dpo);
+ esrc = fib_entry_src_find(fib_entry, source);
}
/*
*/
old_path_list = esrc->fes_pl;
- ASSERT(NULL != fib_entry_src_vft[source].fesv_path_add);
+ ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_add));
pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
- fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
+ fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
- fib_entry_src_vft[source].fesv_path_add(esrc, fib_entry, pl_flags, rpath);
- fib_entry = fib_entry_get(fib_entry_index);
-
- /*
- * re-resolve all the path-extensions with the new path-list
- */
- vec_foreach(path_ext, esrc->fes_path_exts)
- {
- fib_path_ext_resolve(path_ext, esrc->fes_pl);
- }
- /*
- * if the path has a label we need to add a path extension
- */
- fib_entry_src_path_ext_insert(esrc, rpath);
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_add,
+ (esrc, fib_entry, pl_flags, rpaths));
fib_path_list_lock(esrc->fes_pl);
fib_path_list_unlock(old_path_list);
fib_entry_t*
fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
fib_source_t source,
- fib_entry_flag_t flags,
+ fib_entry_flag_t flags,
const fib_route_path_t *rpaths)
{
- fib_node_index_t old_path_list, fib_entry_index;
+ fib_node_index_t old_path_list;
fib_path_list_flags_t pl_flags;
- const fib_route_path_t *rpath;
- fib_path_ext_t *path_ext;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
-
- /*
- * save variable so we can recover from a fib_entry realloc.
- */
- fib_entry_index = fib_entry_get_index(fib_entry);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL == esrc)
{
- fib_entry = fib_entry_src_action_add(fib_entry,
+ const dpo_id_t *dpo;
+
+ if (flags == FIB_ENTRY_FLAG_EXCLUSIVE) {
+ dpo = &rpaths->dpo;
+ } else {
+ dpo = drop_dpo_get(fib_entry_get_dpo_proto(fib_entry));
+ }
+
+ fib_entry = fib_entry_src_action_add(fib_entry,
source,
flags,
- drop_dpo_get(
- fib_proto_to_dpo(
- fib_entry_get_proto(fib_entry))));
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ dpo);
+ esrc = fib_entry_src_find(fib_entry, source);
+ }
+ else
+ {
+ if (flags != esrc->fes_entry_flags)
+ {
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_flags_change,
+ (esrc, fib_entry, flags));
+ }
+ esrc->fes_entry_flags = flags;
}
/*
*/
old_path_list = esrc->fes_pl;
- ASSERT(NULL != fib_entry_src_vft[source].fesv_path_swap);
+ ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_swap));
pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
- vec_foreach(rpath, rpaths)
- {
- fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
- }
-
- fib_entry_src_vft[source].fesv_path_swap(esrc,
- fib_entry,
- pl_flags,
- rpaths);
-
- vec_foreach(path_ext, esrc->fes_path_exts)
- {
- vec_free(path_ext->fpe_label_stack);
- }
- vec_free(esrc->fes_path_exts);
-
- vec_foreach(rpath, rpaths)
- {
- fib_entry_src_path_ext_append(esrc, rpath);
- }
+ fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
- fib_entry = fib_entry_get(fib_entry_index);
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_swap,
+ (esrc, fib_entry,
+ pl_flags, rpaths));
fib_path_list_lock(esrc->fes_pl);
fib_path_list_unlock(old_path_list);
fib_entry_src_flag_t
fib_entry_src_action_path_remove (fib_entry_t *fib_entry,
fib_source_t source,
- const fib_route_path_t *rpath)
+ const fib_route_path_t *rpaths)
{
fib_path_list_flags_t pl_flags;
fib_node_index_t old_path_list;
- fib_path_ext_t *path_ext;
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
ASSERT(NULL != esrc);
ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
*/
old_path_list = esrc->fes_pl;
- ASSERT(NULL != fib_entry_src_vft[source].fesv_path_remove);
+ ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_remove));
pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
- fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
+ fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
- fib_entry_src_vft[source].fesv_path_remove(esrc, pl_flags, rpath);
- /*
- * find the matching path extension and remove it
- */
- vec_foreach(path_ext, esrc->fes_path_exts)
- {
- if (!fib_path_ext_cmp(path_ext, rpath))
- {
- /*
- * delete the element moving the remaining elements down 1 position.
- * this preserves the sorted order.
- */
- vec_free(path_ext->fpe_label_stack);
- vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
- break;
- }
- }
- /*
- * re-resolve all the path-extensions with the new path-list
- */
- vec_foreach(path_ext, esrc->fes_path_exts)
- {
- fib_path_ext_resolve(path_ext, esrc->fes_pl);
- }
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_remove,
+ (esrc, pl_flags, rpaths));
/*
* lock the new path-list, unlock the old if it had one
/*
* no more paths left from this source
*/
- fib_entry_src_action_remove(fib_entry, source);
+ fib_entry_src_action_remove_or_update_inherit(fib_entry, source);
return (FIB_ENTRY_SRC_FLAG_NONE);
}
}
{
fib_entry_src_t *esrc;
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
+
+ FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_format, (esrc, s));
- if (NULL != fib_entry_src_vft[source].fesv_format)
- {
- return (fib_entry_src_vft[source].fesv_format(esrc, s));
- }
return (s);
}
return (ADJ_INDEX_INVALID);
fib_entry = fib_entry_get(fib_entry_index);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL != esrc)
{
return (0);
fib_entry = fib_entry_get(fib_entry_index);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL != esrc)
{
fib_path_list_contribute_forwarding(
esrc->fes_pl,
fib_entry_get_default_chain_type(fib_entry),
+ FIB_PATH_LIST_FWD_FLAG_NONE,
dpo);
return (dpo_id_is_valid(dpo));
fib_entry = fib_entry_get(entry_index);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL != esrc)
{
fib_entry = fib_entry_get(entry_index);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
if (NULL != esrc)
{
return (FIB_ENTRY_FLAG_NONE);
}
+fib_source_t
+fib_entry_get_source_i (const fib_entry_t *fib_entry)
+{
+ /* the vector of sources is deliberately arranged in priority order */
+ if (0 == vec_len(fib_entry->fe_srcs))
+ return (FIB_SOURCE_INVALID);
+ return (vec_elt(fib_entry->fe_srcs, 0).fes_src);
+}
+
fib_entry_flag_t
fib_entry_get_flags_i (const fib_entry_t *fib_entry)
{
- fib_entry_flag_t flags;
-
- /*
- * the vector of sources is deliberately arranged in priority order
- */
+ /* the vector of sources is deliberately arranged in priority order */
if (0 == vec_len(fib_entry->fe_srcs))
- {
- flags = FIB_ENTRY_FLAG_NONE;
- }
- else
- {
- fib_entry_src_t *esrc;
-
- esrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
- flags = esrc->fes_entry_flags;
- }
-
- return (flags);
+ return (FIB_ENTRY_FLAG_NONE);
+ return (vec_elt(fib_entry->fe_srcs, 0).fes_entry_flags);
}
void
fib_entry_src_t *esrc;
fib_entry = fib_entry_get(fib_entry_index);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
- if (NULL != esrc &&
- NULL != fib_entry_src_vft[source].fesv_set_data)
+ if (NULL != esrc)
{
- fib_entry_src_vft[source].fesv_set_data(esrc, fib_entry, data);
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_set_data,
+ (esrc, fib_entry, data));
}
}
fib_entry_src_t *esrc;
fib_entry = fib_entry_get(fib_entry_index);
- esrc = fib_entry_src_find(fib_entry, source, NULL);
+ esrc = fib_entry_src_find(fib_entry, source);
- if (NULL != esrc &&
- NULL != fib_entry_src_vft[source].fesv_get_data)
+ if (NULL != esrc)
{
- return (fib_entry_src_vft[source].fesv_get_data(esrc, fib_entry));
+ FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_get_data,
+ (esrc, fib_entry));
}
return (NULL);
}
{
fib_entry_src_rr_register();
fib_entry_src_interface_register();
- fib_entry_src_default_route_register();
- fib_entry_src_special_register();
+ fib_entry_src_interpose_register();
+ fib_entry_src_drop_register();
+ fib_entry_src_simple_register();
fib_entry_src_api_register();
fib_entry_src_adj_register();
fib_entry_src_mpls_register();