/*
* 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];
/**
* Get the VFT for a given source. This is a combination of the source
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_vft[FIB_SOURCE_INTERPOSE]);
+ return (&fib_entry_src_bh_vft[FIB_SOURCE_BH_INTERPOSE]);
}
- return (&fib_entry_src_vft[esrc->fes_src]);
+ return (&fib_entry_src_bh_vft[bh]);
}
static void
}
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_vft[source].fesv_copy)
+ if (NULL == fib_entry_src_bh_vft[bh].fesv_copy)
{
- fib_entry_src_vft[source].fesv_copy = fib_entry_src_copy_default;
+ fib_entry_src_bh_vft[bh].fesv_copy = fib_entry_src_copy_default;
}
}
{
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));
}
static void
.fes_entry_flags = flags,
};
- FIB_ENTRY_SRC_VFT_INVOKE(&esrc, 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,
return (NULL);
}
-static fib_entry_src_t *
+fib_entry_src_t *
fib_entry_src_find (const fib_entry_t *fib_entry,
fib_source_t source)
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,
ASSERT(NULL != esrc);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_deinit, (esrc));
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deinit, (esrc));
fib_path_ext_list_flush(&esrc->fes_path_exts);
vec_del1(fib_entry->fe_srcs, index);
{
load_balance_path_t *next_hops;
const fib_entry_t *fib_entry;
- const fib_entry_src_t *esrc;
+ i32 start_source_index, end_source_index;
fib_forward_chain_type_t fct;
int n_recursive_constrained;
u16 preference;
* @brief Determine whether this FIB entry should use a load-balance MAP
* to support PIC edge fast convergence
*/
-load_balance_flags_t
-fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx)
+static load_balance_flags_t
+fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx,
+ const fib_entry_src_t *esrc)
{
/**
* We'll use a LB map if the path-list has multiple recursive paths.
* recursive paths implies BGP, and hence scale.
*/
if (ctx->n_recursive_constrained > 1 &&
- fib_path_list_is_popular(ctx->esrc->fes_pl))
+ fib_path_list_is_popular(esrc->fes_pl))
{
return (LOAD_BALANCE_FLAG_USES_MAP);
}
void *arg)
{
fib_entry_src_collect_forwarding_ctx_t *ctx;
+ const fib_entry_src_t *esrc;
fib_path_ext_t *path_ext;
u32 n_nhs;
ctx = arg;
n_nhs = vec_len(ctx->next_hops);
+ /*
+ * walk the paths and extension of the best non-interpose source
+ */
+ esrc = &ctx->fib_entry->fe_srcs[ctx->end_source_index];
+
/*
* if the path is not resolved, don't include it.
*/
/*
* get the matching path-extension for the path being visited.
*/
- path_ext = fib_path_ext_list_find_by_path_index(&ctx->esrc->fes_path_exts,
+ path_ext = fib_path_ext_list_find_by_path_index(&esrc->fes_path_exts,
path_index);
if (NULL != path_ext)
*/
const fib_entry_src_vft_t *vft;
- vft = fib_entry_src_get_vft(ctx->esrc);
+ /*
+ * roll up the sources that are interposes
+ */
+ i32 index;
- if (NULL != vft->fesv_contribute_interpose)
+ for (index = ctx->end_source_index;
+ index >= ctx->start_source_index;
+ index--)
{
const dpo_id_t *interposer;
- interposer = vft->fesv_contribute_interpose(ctx->esrc,
- ctx->fib_entry);
+ esrc = &ctx->fib_entry->fe_srcs[index];
+ vft = fib_entry_src_get_vft(esrc);
+
+ if (!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_CONTRIBUTING) ||
+ !(esrc->fes_entry_flags & FIB_ENTRY_FLAG_INTERPOSE))
+ continue;
+
+ ASSERT(vft->fesv_contribute_interpose);
+ interposer = vft->fesv_contribute_interpose(esrc, ctx->fib_entry);
if (NULL != interposer)
{
void
fib_entry_src_mk_lb (fib_entry_t *fib_entry,
- const fib_entry_src_t *esrc,
+ fib_source_t source,
fib_forward_chain_type_t fct,
dpo_id_t *dpo_lb)
{
+ const fib_entry_src_t *esrc;
dpo_proto_t lb_proto;
+ u32 start, end;
+
+ /*
+ * The source passed here is the 'best', i.e. the one the client
+ * wants. however, if it's an interpose then it does not contribute
+ * the forwarding, the next best source that is not an interpose does.
+ * So roll down the sources, to find the best non-interpose
+ */
+ vec_foreach_index (start, fib_entry->fe_srcs)
+ {
+ if (source == fib_entry->fe_srcs[start].fes_src)
+ break;
+ }
+ for (end = start; end < vec_len (fib_entry->fe_srcs); end++)
+ {
+ if (!(fib_entry->fe_srcs[end].fes_entry_flags &
+ FIB_ENTRY_FLAG_INTERPOSE) &&
+ (fib_entry->fe_srcs[end].fes_flags &
+ FIB_ENTRY_SRC_FLAG_CONTRIBUTING))
+ break;
+ }
+ if (end == vec_len(fib_entry->fe_srcs))
+ {
+ /* didn't find any contributing non-interpose sources */
+ end = start;
+ }
+
+ esrc = &fib_entry->fe_srcs[end];
/*
* If the entry has path extensions then we construct a load-balance
* Otherwise we use the load-balance of the path-list
*/
fib_entry_src_collect_forwarding_ctx_t ctx = {
- .esrc = esrc,
.fib_entry = fib_entry,
.next_hops = NULL,
.n_recursive_constrained = 0,
.fct = fct,
.preference = 0xffff,
+ .start_source_index = start,
+ .end_source_index = end,
};
/*
{
load_balance_multipath_update(dpo_lb,
ctx.next_hops,
- fib_entry_calc_lb_flags(&ctx));
+ fib_entry_calc_lb_flags(&ctx, esrc));
vec_free(ctx.next_hops);
/*
* tables
*/
fib_forward_chain_type_t fct;
- fib_entry_src_t *esrc;
int insert;
fct = fib_entry_get_default_chain_type(fib_entry);
- esrc = fib_entry_src_find(fib_entry, source);
/*
* Every entry has its own load-balance object. All changes to the entry's
*/
insert = !dpo_id_is_valid(&fib_entry->fe_lb);
- fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb);
+ fib_entry_src_mk_lb(fib_entry, source, fct, &fib_entry->fe_lb);
ASSERT(dpo_id_is_valid(&fib_entry->fe_lb));
FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb);
FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
{
- fib_entry_src_mk_lb(fib_entry, esrc,
+ fib_entry_src_mk_lb(fib_entry, source,
fib_entry_delegate_type_to_chain_type(fdt),
&fed->fd_dpo);
});
orig_src->fes_src,
orig_src->fes_entry_flags);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_copy,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_copy,
(orig_src, fib_entry, esrc));
fib_path_list_unlock(esrc->fes_pl);
ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_deactivate,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_deactivate,
(esrc, fib_entry));
esrc->fes_flags &= ~(FIB_ENTRY_SRC_FLAG_ACTIVE |
vec_foreach(esrc, fib_entry->fe_srcs)
{
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_fwd_update,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_fwd_update,
(esrc, 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);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_installed,
+ 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, flags);
if (flags != esrc->fes_entry_flags)
{
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_flags_change,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_flags_change,
(esrc, fib_entry, flags));
}
esrc->fes_entry_flags = flags;
return (fib_entry);
}
- /*
- * save variable so we can recover from a fib_entry realloc.
- */
- fib_entry_index = fib_entry_get_index(fib_entry);
-
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_add,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_add,
(esrc,
fib_entry,
flags,
fib_entry_get_dpo_proto(fib_entry),
dpo));
- fib_entry = fib_entry_get(fib_entry_index);
-
esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
fib_path_list_lock(esrc->fes_pl);
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, flags);
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);
-
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_add,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_add,
(esrc,
fib_entry,
flags,
fib_entry_get_dpo_proto(fib_entry),
dpo));
- fib_entry = fib_entry_get(fib_entry_index);
-
esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
fib_path_list_lock(esrc->fes_pl);
}
else if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_CONTRIBUTING)
{
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_deactivate,
+ 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;
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, 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));
*/
if (ip46_address_is_zero(&rpath->frp_addr) &&
(~0 != rpath->frp_sw_if_index) &&
- !(rpath->frp_flags & FIB_ROUTE_PATH_DVR) &&
+ !(rpath->frp_flags & (FIB_ROUTE_PATH_DVR | FIB_ROUTE_PATH_UDP_ENCAP)) &&
(fib_entry->fe_fib_index !=
fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry),
rpath->frp_sw_if_index)))
{
return (!0);
}
- else if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
+ else if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED ||
+ rpath->frp_flags & FIB_ROUTE_PATH_GLEAN)
{
return (!0);
}
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;
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);
if (NULL == esrc)
{
pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_path_add,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_add,
(esrc, fib_entry, pl_flags, rpaths));
- fib_entry = fib_entry_get(fib_entry_index);
fib_path_list_lock(esrc->fes_pl);
fib_path_list_unlock(old_path_list);
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;
fib_entry_src_t *esrc;
esrc = fib_entry_src_find(fib_entry, source);
- /*
- * save variable so we can recover from a fib_entry realloc.
- */
- fib_entry_index = fib_entry_get_index(fib_entry);
-
if (NULL == esrc)
{
const dpo_id_t *dpo;
{
if (flags != esrc->fes_entry_flags)
{
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_flags_change,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_flags_change,
(esrc, fib_entry, flags));
}
esrc->fes_entry_flags = flags;
fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_path_swap,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_swap,
(esrc, fib_entry,
pl_flags, rpaths));
- fib_entry = fib_entry_get(fib_entry_index);
-
fib_path_list_lock(esrc->fes_pl);
fib_path_list_unlock(old_path_list);
pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc);
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_path_remove,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_path_remove,
(esrc, pl_flags, rpaths));
/*
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
if (NULL != esrc)
{
- FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_set_data,
+ FIB_ENTRY_SRC_VFT_INVOKE(fib_entry, esrc, fesv_set_data,
(esrc, fib_entry, data));
}
}
fib_entry_src_rr_register();
fib_entry_src_interface_register();
fib_entry_src_interpose_register();
- fib_entry_src_default_route_register();
- fib_entry_src_special_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();
Code Review / vpp.git / blobdiff