*/
static fib_entry_t *fib_entry_pool;
+/**
+ * the logger
+ */
+vlib_log_class_t fib_entry_logger;
+
fib_entry_t *
fib_entry_get (fib_node_index_t index)
{
}
u8 *
-format_fib_entry (u8 * s, va_list * args)
+format_fib_entry_flags (u8 *s, va_list *args)
+{
+ fib_entry_attribute_t attr;
+ fib_entry_flag_t flag = va_arg(*args, int);
+
+ FOR_EACH_FIB_ATTRIBUTE(attr) {
+ if ((1<<attr) & flag) {
+ s = format (s, "%s,", fib_attribute_names[attr]);
+ }
+ }
+
+ return (s);
+}
+
+u8 *
+format_fib_entry_src_flags (u8 *s, va_list *args)
{
fib_entry_src_attribute_t sattr;
+ fib_entry_src_flag_t flag = va_arg(*args, int);
+
+ FOR_EACH_FIB_SRC_ATTRIBUTE(sattr) {
+ if ((1<<sattr) & flag) {
+ s = format (s, "%s,", fib_src_attribute_names[sattr]);
+ }
+ }
+
+ return (s);
+}
+
+u8 *
+format_fib_entry (u8 * s, va_list * args)
+{
fib_forward_chain_type_t fct;
- fib_entry_attribute_t attr;
fib_entry_t *fib_entry;
fib_entry_src_t *src;
fib_node_index_t fei;
FOR_EACH_SRC_ADDED(fib_entry, src, source,
({
s = format (s, "\n %U", format_fib_source, source);
- s = fib_entry_src_format(fib_entry, source, s);
s = format (s, " refs:%d", src->fes_ref_count);
if (FIB_ENTRY_FLAG_NONE != src->fes_entry_flags) {
- s = format(s, " entry-flags:");
- FOR_EACH_FIB_ATTRIBUTE(attr) {
- if ((1<<attr) & src->fes_entry_flags) {
- s = format (s, "%s,", fib_attribute_names[attr]);
- }
- }
+ s = format(s, " entry-flags:%U",
+ format_fib_entry_flags, src->fes_entry_flags);
}
if (FIB_ENTRY_SRC_FLAG_NONE != src->fes_flags) {
- s = format(s, " src-flags:");
- FOR_EACH_FIB_SRC_ATTRIBUTE(sattr) {
- if ((1<<sattr) & src->fes_flags) {
- s = format (s, "%s,", fib_src_attribute_names[sattr]);
- }
- }
+ s = format(s, " src-flags:%U",
+ format_fib_entry_src_flags, src->fes_flags);
}
+ s = fib_entry_src_format(fib_entry, source, s);
s = format (s, "\n");
if (FIB_NODE_INDEX_INVALID != src->fes_pl)
{
fib_entry = fib_entry_from_fib_node(node);
+ ASSERT(!dpo_id_is_valid(&fib_entry->fe_lb));
+
FOR_EACH_DELEGATE_CHAIN(fib_entry, fdt, fed,
{
dpo_reset(&fed->fd_dpo);
FIB_ENTRY_DBG(fib_entry, "last-lock");
fib_node_deinit(&fib_entry->fe_node);
- // FIXME -RR Backwalk
ASSERT(0 == vec_len(fib_entry->fe_delegates));
vec_free(fib_entry->fe_delegates);
*/
ctx->fnbw_flags &= ~FIB_NODE_BW_FLAG_FORCE_SYNC;
+ FIB_ENTRY_DBG(fib_entry, "bw:%U",
+ format_fib_node_bw_reason, ctx->fnbw_reason);
+
/*
* propagate the backwalk further if we haven't already reached the
* maximum depth.
dpo_copy(dpo, &fed->fd_dpo);
}
+ /*
+ * use the drop DPO is nothing else is present
+ */
+ if (!dpo_id_is_valid(dpo))
+ {
+ dpo_copy(dpo, drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct)));
+ }
+
/*
* don't allow the special index indicating replicate.vs.load-balance
* to escape to the clients
ASSERT((fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP4 ||
fct == FIB_FORW_CHAIN_TYPE_UNICAST_IP6));
- return (&fib_entry->fe_lb);
+ if (dpo_id_is_valid(&fib_entry->fe_lb))
+ {
+ return (&fib_entry->fe_lb);
+ }
+
+ return (drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct)));
}
adj_index_t
fib_prefix_t *fep;
pool_get(fib_entry_pool, fib_entry);
- memset(fib_entry, 0, sizeof(*fib_entry));
+ clib_memset(fib_entry, 0, sizeof(*fib_entry));
fib_node_init(&fib_entry->fe_node,
FIB_NODE_TYPE_ENTRY);
*fib_entry_index = fib_entry_get_index(fib_entry);
- FIB_ENTRY_DBG(fib_entry, "alloc");
-
return (fib_entry);
}
fib_entry_post_install_actions(fib_entry, source, FIB_ENTRY_FLAG_NONE);
+ FIB_ENTRY_DBG(fib_entry, "create");
+
return (fib_entry_index);
}
fib_entry_post_install_actions(fib_entry, source, FIB_ENTRY_FLAG_NONE);
+ FIB_ENTRY_DBG(fib_entry, "create-special");
+
return (fib_entry_index);
}
}
void
-fib_entry_source_change (fib_entry_t *fib_entry,
- fib_source_t old_source,
- fib_source_t new_source)
+fib_entry_recalculate_forwarding (fib_node_index_t fib_entry_index)
{
- fib_entry_flag_t old_flags;
+ fib_source_t best_source;
+ fib_entry_t *fib_entry;
+ fib_entry_src_t *bsrc;
- old_flags = fib_entry_get_flags_for_source(
- fib_entry_get_index(fib_entry), old_source);
+ fib_entry = fib_entry_get(fib_entry_index);
+
+ bsrc = fib_entry_get_best_src_i(fib_entry);
+ best_source = fib_entry_src_get_source(bsrc);
+ fib_entry_src_action_reactivate(fib_entry, best_source);
+}
+
+static void
+fib_entry_source_change_w_flags (fib_entry_t *fib_entry,
+ fib_source_t old_source,
+ fib_entry_flag_t old_flags,
+ fib_source_t new_source)
+{
if (new_source < old_source)
{
/*
}
else if (new_source > old_source)
{
- /*
- * the new source loses. nothing to do here.
- * the data from the source is saved in the path-list created
- */
- return;
+ /*
+ * the new source loses. Re-activate the winning sources
+ * in case it is an interposer and hence relied on the losing
+ * source's path-list.
+ */
+ fib_entry_src_action_reactivate(fib_entry, old_source);
+ return;
}
else
{
fib_entry_post_update_actions(fib_entry, new_source, old_flags);
}
+void
+fib_entry_source_change (fib_entry_t *fib_entry,
+ fib_source_t old_source,
+ fib_source_t new_source)
+{
+ fib_entry_flag_t old_flags;
+
+ old_flags = fib_entry_get_flags_for_source(
+ fib_entry_get_index(fib_entry), old_source);
+
+ return (fib_entry_source_change_w_flags(fib_entry, old_source,
+ old_flags, new_source));
+}
+
void
fib_entry_special_add (fib_node_index_t fib_entry_index,
fib_source_t source,
fib_entry = fib_entry_src_action_add(fib_entry, source, flags, dpo);
fib_entry_source_change(fib_entry, best_source, source);
+ FIB_ENTRY_DBG(fib_entry, "special-add:%U", format_fib_source, source);
}
void
fib_entry = fib_entry_src_action_update(fib_entry, source, flags, dpo);
fib_entry_source_change(fib_entry, best_source, source);
+
+ FIB_ENTRY_DBG(fib_entry, "special-updated:%U", format_fib_source, source);
}
const fib_route_path_t *rpath)
{
fib_source_t best_source;
- fib_entry_flag_t bflags;
fib_entry_t *fib_entry;
fib_entry_src_t *bsrc;
bsrc = fib_entry_get_best_src_i(fib_entry);
best_source = fib_entry_src_get_source(bsrc);
- bflags = fib_entry_src_get_flags(bsrc);
fib_entry = fib_entry_src_action_path_add(fib_entry, source, flags, rpath);
- /*
- * if the path list for the source passed is invalid,
- * then we need to create a new one. else we are updating
- * an existing.
- */
- if (source < best_source)
- {
- /*
- * we have a new winning source.
- */
- fib_entry_src_action_deactivate(fib_entry, best_source);
- fib_entry_src_action_activate(fib_entry, source);
- }
- else if (source > best_source)
- {
- /*
- * the new source loses. nothing to do here.
- * the data from the source is saved in the path-list created
- */
- return;
- }
- else
- {
- /*
- * the new source is one this entry already has.
- * But the path-list was updated, which will contribute new forwarding,
- * so install it.
- */
- fib_entry_src_action_reactivate(fib_entry, source);
- }
+ fib_entry_source_change(fib_entry, best_source, source);
- fib_entry_post_update_actions(fib_entry, source, bflags);
+ FIB_ENTRY_DBG(fib_entry, "path add:%U", format_fib_source, source);
}
static fib_entry_src_flag_t
bsrc = fib_entry_get_best_src_i(fib_entry);
best_source = fib_entry_src_get_source(bsrc);
- if (FIB_SOURCE_MAX == best_source) {
+ if (FIB_SOURCE_MAX == best_source)
+ {
/*
* no more sources left. this entry is toast.
*/
sflag = fib_entry_src_action_path_remove(fib_entry, source, rpath);
+ FIB_ENTRY_DBG(fib_entry, "path remove:%U", format_fib_source, source);
+
/*
* if the path list for the source passed is invalid,
* then we need to create a new one. else we are updating
sflag = fib_entry_src_action_remove_or_update_inherit(fib_entry, source);
+ FIB_ENTRY_DBG(fib_entry, "special remove:%U", format_fib_source, source);
+
/*
* if the path list for the source passed is invalid,
* then we need to create a new one. else we are updating
fib_entry_src_action_uninstall(fib_entry);
return (FIB_ENTRY_SRC_FLAG_NONE);
}
+
+ /*
+ * reactivate the best source so the interposer gets restacked
+ */
+ fib_entry_src_action_reactivate(fib_entry, best_source);
+
return (FIB_ENTRY_SRC_FLAG_ADDED);
}
}
bsrc = fib_entry_get_best_src_i(fib_entry);
best_source = fib_entry_src_get_source(bsrc);
- bflags = fib_entry_src_get_flags(bsrc);
+ bflags = fib_entry_get_flags_i(fib_entry);
- fib_entry_src_action_path_swap(fib_entry,
- source,
- flags,
- paths);
- /*
- * handle possible realloc's by refetching the pointer
- */
- fib_entry = fib_entry_get(fib_entry_index);
+ fib_entry = fib_entry_src_action_path_swap(fib_entry,
+ source,
+ flags,
+ paths);
- /*
- * if the path list for the source passed is invalid,
- * then we need to create a new one. else we are updating
- * an existing.
- */
- if (source < best_source)
- {
- /*
- * we have a new winning source.
- */
- fib_entry_src_action_deactivate(fib_entry, best_source);
- fib_entry_src_action_activate(fib_entry, source);
- }
- else if (source > best_source) {
- /*
- * the new source loses. nothing to do here.
- * the data from the source is saved in the path-list created
- */
- return;
- }
- else
- {
- /*
- * the new source is one this entry already has.
- * But the path-list was updated, which will contribute new forwarding,
- * so install it.
- */
- fib_entry_src_action_reactivate(fib_entry, source);
- }
-
- fib_entry_post_update_actions(fib_entry, source, bflags);
+ fib_entry_source_change_w_flags(fib_entry, best_source, bflags, source);
+ FIB_ENTRY_DBG(fib_entry, "update");
}
.install = !0,
.bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
};
- fib_source_t source, best_source;
+ CLIB_UNUSED(fib_source_t source);
+ fib_source_t best_source;
fib_entry_flag_t bflags;
fib_entry_t *fib_entry;
fib_entry_src_t *esrc;
/*
* only the best source gets to set the back walk flags
*/
- res = fib_entry_src_action_cover_change(fib_entry, source);
+ res = fib_entry_src_action_cover_change(fib_entry, esrc);
bflags = fib_entry_src_get_flags(esrc);
best_source = fib_entry_src_get_source(esrc);
}
else
{
- fib_entry_src_action_cover_change(fib_entry, source);
+ fib_entry_src_action_cover_change(fib_entry, esrc);
}
index++;
}));
fib_walk_sync(FIB_NODE_TYPE_ENTRY, fib_entry_index, &bw_ctx);
}
+ FIB_ENTRY_DBG(fib_entry, "cover-changed");
}
/*
.install = !0,
.bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
};
- fib_source_t source, best_source;
+ CLIB_UNUSED(fib_source_t source);
+ fib_source_t best_source;
fib_entry_flag_t bflags;
fib_entry_t *fib_entry;
fib_entry_src_t *esrc;
/*
* only the best source gets to set the back walk flags
*/
- res = fib_entry_src_action_cover_update(fib_entry, source);
+ res = fib_entry_src_action_cover_update(fib_entry, esrc);
bflags = fib_entry_src_get_flags(esrc);
best_source = fib_entry_src_get_source(esrc);
}
else
{
- fib_entry_src_action_cover_update(fib_entry, source);
+ fib_entry_src_action_cover_update(fib_entry, esrc);
}
index++;
}));
fib_walk_sync(FIB_NODE_TYPE_ENTRY, fib_entry_index, &bw_ctx);
}
+ FIB_ENTRY_DBG(fib_entry, "cover-updated");
}
int
return (fib_entry_src_get_source(bsrc));
}
+/**
+ * Return !0 is the entry represents a host prefix
+ */
+int
+fib_entry_is_host (fib_node_index_t fib_entry_index)
+{
+ return (fib_prefix_is_host(fib_entry_get_prefix(fib_entry_index)));
+}
+
/**
* Return !0 is the entry is reoslved, i.e. will return a valid forwarding
* chain
}
}
+u32
+fib_entry_get_stats_index (fib_node_index_t fib_entry_index)
+{
+ fib_entry_t *fib_entry;
+
+ fib_entry = fib_entry_get(fib_entry_index);
+
+ return (fib_entry->fe_lb.dpoi_index);
+}
+
static int
fib_ip4_address_compare (const ip4_address_t * a1,
const ip4_address_t * a2)
void
fib_entry_module_init (void)
{
- fib_node_register_type (FIB_NODE_TYPE_ENTRY, &fib_entry_vft);
+ fib_node_register_type(FIB_NODE_TYPE_ENTRY, &fib_entry_vft);
+ fib_entry_logger = vlib_log_register_class("fib", "entry");
}
void
}
}
-void
-fib_entry_get_prefix (fib_node_index_t fib_entry_index,
- fib_prefix_t *pfx)
+const fib_prefix_t *
+fib_entry_get_prefix (fib_node_index_t fib_entry_index)
{
fib_entry_t *fib_entry;
fib_entry = fib_entry_get(fib_entry_index);
- *pfx = fib_entry->fe_prefix;
+
+ return (&fib_entry->fe_prefix);
}
u32