X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ffib%2Ffib_table.c;h=e71e6c36bfb11878f8eb61d58b5c269647e64559;hb=e2fe09742;hp=6b6cc5cb99a31a443eb4b8b417ddf34213e77af2;hpb=da78f957e46c686434149d332a477d7ea055d76a;p=vpp.git diff --git a/src/vnet/fib/fib_table.c b/src/vnet/fib/fib_table.c index 6b6cc5cb99a..e71e6c36bfb 100644 --- a/src/vnet/fib/fib_table.c +++ b/src/vnet/fib/fib_table.c @@ -23,6 +23,8 @@ #include #include +const static char * fib_table_flags_strings[] = FIB_TABLE_ATTRIBUTES; + fib_table_t * fib_table_get (fib_node_index_t index, fib_protocol_t proto) @@ -181,8 +183,7 @@ fib_table_post_insert_actions (fib_table_t *fib_table, return; /* - * find and inform the covering entry that a new more specific - * has been inserted beneath it + * find the covering entry */ fib_entry_cover_index = fib_table_get_less_specific_i(fib_table, prefix); /* @@ -190,8 +191,26 @@ fib_table_post_insert_actions (fib_table_t *fib_table, */ if (fib_entry_cover_index != fib_entry_index) { - fib_entry_cover_change_notify(fib_entry_cover_index, - fib_entry_index); + /* + * push any inherting sources from the cover onto the covered + */ + fib_entry_inherit(fib_entry_cover_index, + fib_entry_index); + + /* + * inform the covering entry that a new more specific + * has been inserted beneath it. + * If the prefix that has been inserted is a host route + * then it is not possible that it will be the cover for any + * other entry, so we can elide the walk. This is particularly + * beneficial since there are often many host entries sharing the + * same cover (i.e. ADJ or RR sourced entries). + */ + if (!fib_entry_is_host(fib_entry_index)) + { + fib_entry_cover_change_notify(fib_entry_cover_index, + fib_entry_index); + } } } @@ -285,6 +304,21 @@ fib_table_fwding_dpo_remove (u32 fib_index, } } +static void +fib_table_source_count_inc (fib_table_t *fib_table, + fib_source_t source) +{ + vec_validate (fib_table->ft_src_route_counts, source); + fib_table->ft_src_route_counts[source]++; +} + +static void +fib_table_source_count_dec (fib_table_t *fib_table, + fib_source_t source) +{ + vec_validate (fib_table->ft_src_route_counts, source); + fib_table->ft_src_route_counts[source]--; +} fib_node_index_t fib_table_entry_special_dpo_add (u32 fib_index, @@ -306,7 +340,7 @@ fib_table_entry_special_dpo_add (u32 fib_index, dpo); fib_table_entry_insert(fib_table, prefix, fib_entry_index); - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } else { @@ -317,7 +351,7 @@ fib_table_entry_special_dpo_add (u32 fib_index, if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } } @@ -345,7 +379,7 @@ fib_table_entry_special_dpo_update (u32 fib_index, dpo); fib_table_entry_insert(fib_table, prefix, fib_entry_index); - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } else { @@ -360,7 +394,7 @@ fib_table_entry_special_dpo_update (u32 fib_index, if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } } @@ -442,7 +476,7 @@ fib_table_entry_special_remove (u32 fib_index, */ if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]--; + fib_table_source_count_dec(fib_table, source); } fib_entry_unlock(fib_entry_index); @@ -464,7 +498,7 @@ fib_table_entry_special_remove (u32 fib_index, */ static void fib_table_route_path_fixup (const fib_prefix_t *prefix, - fib_entry_flag_t eflags, + fib_entry_flag_t *eflags, fib_route_path_t *path) { /* @@ -476,28 +510,48 @@ fib_table_route_path_fixup (const fib_prefix_t *prefix, (~0 == path->frp_sw_if_index) && (0 == ip46_address_cmp(&path->frp_addr, &prefix->fp_addr))) { - /* Prefix recurses via itse;f */ + /* Prefix recurses via itself */ path->frp_flags |= FIB_ROUTE_PATH_DROP; } - if (fib_prefix_is_host(prefix) && + if (!(path->frp_flags & FIB_ROUTE_PATH_LOCAL) && + fib_prefix_is_host(prefix) && ip46_address_is_zero(&path->frp_addr) && - path->frp_sw_if_index != ~0) + path->frp_sw_if_index != ~0 && + path->frp_proto != DPO_PROTO_ETHERNET) { path->frp_addr = prefix->fp_addr; path->frp_flags |= FIB_ROUTE_PATH_ATTACHED; } - if (eflags & FIB_ENTRY_FLAG_DROP) + else if ((*eflags & FIB_ENTRY_FLAG_CONNECTED) && + !(*eflags & FIB_ENTRY_FLAG_LOCAL)) + { + if (ip46_address_is_zero(&path->frp_addr)) + { + path->frp_flags |= FIB_ROUTE_PATH_GLEAN; + fib_prefix_normalize(prefix, &path->frp_connected); + } + } + if (*eflags & FIB_ENTRY_FLAG_DROP) { path->frp_flags |= FIB_ROUTE_PATH_DROP; } - if (eflags & FIB_ENTRY_FLAG_LOCAL) + if (*eflags & FIB_ENTRY_FLAG_LOCAL) { path->frp_flags |= FIB_ROUTE_PATH_LOCAL; } - if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE) + if (*eflags & FIB_ENTRY_FLAG_EXCLUSIVE) { path->frp_flags |= FIB_ROUTE_PATH_EXCLUSIVE; } + if (path->frp_flags & FIB_ROUTE_PATH_LOCAL) + { + *eflags |= FIB_ENTRY_FLAG_LOCAL; + + if (path->frp_sw_if_index != ~0) + { + *eflags |= FIB_ENTRY_FLAG_CONNECTED; + } + } } fib_node_index_t @@ -510,7 +564,7 @@ fib_table_entry_path_add (u32 fib_index, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, - mpls_label_t *next_hop_labels, + fib_mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags) { fib_route_path_t path = { @@ -520,6 +574,7 @@ fib_table_entry_path_add (u32 fib_index, .frp_fib_index = next_hop_fib_index, .frp_weight = next_hop_weight, .frp_flags = path_flags, + .frp_rpf_id = INDEX_INVALID, .frp_label_stack = next_hop_labels, }; fib_node_index_t fib_entry_index; @@ -534,12 +589,19 @@ fib_table_entry_path_add (u32 fib_index, return (fib_entry_index); } +static int +fib_route_path_cmp_for_sort (void * v1, + void * v2) +{ + return (fib_route_path_cmp(v1, v2)); +} + fib_node_index_t fib_table_entry_path_add2 (u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, - fib_route_path_t *rpath) + fib_route_path_t *rpaths) { fib_node_index_t fib_entry_index; fib_table_t *fib_table; @@ -548,30 +610,35 @@ fib_table_entry_path_add2 (u32 fib_index, fib_table = fib_table_get(fib_index, prefix->fp_proto); fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix); - for (ii = 0; ii < vec_len(rpath); ii++) + for (ii = 0; ii < vec_len(rpaths); ii++) { - fib_table_route_path_fixup(prefix, flags, &rpath[ii]); + fib_table_route_path_fixup(prefix, &flags, &rpaths[ii]); } + /* + * sort the paths provided by the control plane. this means + * the paths and the extension on the entry will be sorted. + */ + vec_sort_with_function(rpaths, fib_route_path_cmp_for_sort); if (FIB_NODE_INDEX_INVALID == fib_entry_index) { fib_entry_index = fib_entry_create(fib_index, prefix, source, flags, - rpath); + rpaths); fib_table_entry_insert(fib_table, prefix, fib_entry_index); - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } else { int was_sourced; was_sourced = fib_entry_is_sourced(fib_entry_index, source); - fib_entry_path_add(fib_entry_index, source, flags, rpath);; + fib_entry_path_add(fib_entry_index, source, flags, rpaths);; if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } } @@ -582,7 +649,7 @@ void fib_table_entry_path_remove2 (u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, - fib_route_path_t *rpath) + fib_route_path_t *rpaths) { /* * 1 is it present @@ -591,8 +658,8 @@ fib_table_entry_path_remove2 (u32 fib_index, * no => cover walk */ fib_node_index_t fib_entry_index; + fib_route_path_t *rpath; fib_table_t *fib_table; - u32 ii; fib_table = fib_table_get(fib_index, prefix->fp_proto); fib_entry_index = fib_table_lookup_exact_match_i(fib_table, prefix); @@ -622,16 +689,16 @@ fib_table_entry_path_remove2 (u32 fib_index, */ fib_entry_lock(fib_entry_index); - for (ii = 0; ii < vec_len(rpath); ii++) + vec_foreach(rpath, rpaths) { - fib_table_route_path_fixup( - prefix, - fib_entry_get_flags_for_source(fib_entry_index, - source), - &rpath[ii]); + fib_entry_flag_t eflags; + + eflags = fib_entry_get_flags_for_source(fib_entry_index, + source); + fib_table_route_path_fixup(prefix, &eflags, rpath); } - src_flag = fib_entry_path_remove(fib_entry_index, source, rpath); + src_flag = fib_entry_path_remove(fib_entry_index, source, rpaths); if (!(FIB_ENTRY_SRC_FLAG_ADDED & src_flag)) { @@ -653,7 +720,7 @@ fib_table_entry_path_remove2 (u32 fib_index, */ if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]--; + fib_table_source_count_dec(fib_table, source); } fib_entry_unlock(fib_entry_index); @@ -694,13 +761,6 @@ fib_table_entry_path_remove (u32 fib_index, vec_free(paths); } -static int -fib_route_path_cmp_for_sort (void * v1, - void * v2) -{ - return (fib_route_path_cmp(v1, v2)); -} - fib_node_index_t fib_table_entry_update (u32 fib_index, const fib_prefix_t *prefix, @@ -717,7 +777,7 @@ fib_table_entry_update (u32 fib_index, for (ii = 0; ii < vec_len(paths); ii++) { - fib_table_route_path_fixup(prefix, flags, &paths[ii]); + fib_table_route_path_fixup(prefix, &flags, &paths[ii]); } /* * sort the paths provided by the control plane. this means @@ -732,7 +792,7 @@ fib_table_entry_update (u32 fib_index, paths); fib_table_entry_insert(fib_table, prefix, fib_entry_index); - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } else { @@ -743,7 +803,7 @@ fib_table_entry_update (u32 fib_index, if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]++; + fib_table_source_count_inc(fib_table, source); } } @@ -760,7 +820,7 @@ fib_table_entry_update_one_path (u32 fib_index, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, - mpls_label_t *next_hop_labels, + fib_mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags) { fib_node_index_t fib_entry_index; @@ -825,7 +885,7 @@ fib_table_entry_delete_i (u32 fib_index, */ if (was_sourced != fib_entry_is_sourced(fib_entry_index, source)) { - fib_table->ft_src_route_counts[source]--; + fib_table_source_count_dec(fib_table, source); } fib_entry_unlock(fib_entry_index); @@ -846,7 +906,8 @@ fib_table_entry_delete (u32 fib_index, * removing an etry that does not exist. * i'll allow it, but i won't like it. */ - clib_warning("%U not in FIB", format_fib_prefix, prefix); + if (0) + clib_warning("%U not in FIB", format_fib_prefix, prefix); } else { @@ -858,12 +919,20 @@ void fib_table_entry_delete_index (fib_node_index_t fib_entry_index, fib_source_t source) { - fib_prefix_t prefix; + const fib_prefix_t *prefix; - fib_entry_get_prefix(fib_entry_index, &prefix); + prefix = fib_entry_get_prefix(fib_entry_index); fib_table_entry_delete_i(fib_entry_get_fib_index(fib_entry_index), - fib_entry_index, &prefix, source); + fib_entry_index, prefix, source); +} + +u32 +fib_table_entry_get_stats_index (u32 fib_index, + const fib_prefix_t *prefix) +{ + return (fib_entry_get_stats_index( + fib_table_lookup_exact_match(fib_index, prefix))); } fib_node_index_t @@ -951,6 +1020,7 @@ fib_table_get_flow_hash_config (u32 fib_index, return (fib->ft_flow_hash_config); } + flow_hash_config_t fib_table_get_default_flow_hash_config (fib_protocol_t proto) { @@ -979,7 +1049,7 @@ typedef struct fib_table_set_flow_hash_config_ctx_t_ flow_hash_config_t hash_config; } fib_table_set_flow_hash_config_ctx_t; -static int +static fib_table_walk_rc_t fib_table_set_flow_hash_config_cb (fib_node_index_t fib_entry_index, void *arg) { @@ -987,7 +1057,7 @@ fib_table_set_flow_hash_config_cb (fib_node_index_t fib_entry_index, fib_entry_set_flow_hash_config(fib_entry_index, ctx->hash_config); - return (1); + return (FIB_TABLE_WALK_CONTINUE); } void @@ -1021,6 +1091,17 @@ fib_table_get_table_id_for_sw_if_index (fib_protocol_t proto, return ((NULL != fib_table ? fib_table->ft_table_id : ~0)); } +u32 +fib_table_get_table_id (u32 fib_index, + fib_protocol_t proto) +{ + fib_table_t *fib_table; + + fib_table = fib_table_get(fib_index, proto); + + return ((NULL != fib_table ? fib_table->ft_table_id : ~0)); +} + u32 fib_table_find (fib_protocol_t proto, u32 table_id) @@ -1037,9 +1118,11 @@ fib_table_find (fib_protocol_t proto, return (~0); } -u32 -fib_table_find_or_create_and_lock (fib_protocol_t proto, - u32 table_id) +static u32 +fib_table_find_or_create_and_lock_i (fib_protocol_t proto, + u32 table_id, + fib_source_t src, + const u8 *name) { fib_table_t *fib_table; fib_node_index_t fi; @@ -1047,13 +1130,13 @@ fib_table_find_or_create_and_lock (fib_protocol_t proto, switch (proto) { case FIB_PROTOCOL_IP4: - fi = ip4_fib_table_find_or_create_and_lock(table_id); + fi = ip4_fib_table_find_or_create_and_lock(table_id, src); break; case FIB_PROTOCOL_IP6: - fi = ip6_fib_table_find_or_create_and_lock(table_id); + fi = ip6_fib_table_find_or_create_and_lock(table_id, src); break; case FIB_PROTOCOL_MPLS: - fi = mpls_fib_table_find_or_create_and_lock(table_id); + fi = mpls_fib_table_find_or_create_and_lock(table_id, src); break; default: return (~0); @@ -1061,15 +1144,45 @@ fib_table_find_or_create_and_lock (fib_protocol_t proto, fib_table = fib_table_get(fi, proto); - fib_table->ft_desc = format(NULL, "%U-VRF:%d", - format_fib_protocol, proto, - table_id); + if (NULL == fib_table->ft_desc) + { + if (name && name[0]) + { + fib_table->ft_desc = format(NULL, "%s", name); + } + else + { + fib_table->ft_desc = format(NULL, "%U-VRF:%d", + format_fib_protocol, proto, + table_id); + } + } return (fi); } +u32 +fib_table_find_or_create_and_lock (fib_protocol_t proto, + u32 table_id, + fib_source_t src) +{ + return (fib_table_find_or_create_and_lock_i(proto, table_id, + src, NULL)); +} + +u32 +fib_table_find_or_create_and_lock_w_name (fib_protocol_t proto, + u32 table_id, + fib_source_t src, + const u8 *name) +{ + return (fib_table_find_or_create_and_lock_i(proto, table_id, + src, name)); +} + u32 fib_table_create_and_lock (fib_protocol_t proto, + fib_source_t src, const char *const fmt, ...) { @@ -1077,18 +1190,17 @@ fib_table_create_and_lock (fib_protocol_t proto, fib_node_index_t fi; va_list ap; - va_start(ap, fmt); switch (proto) { case FIB_PROTOCOL_IP4: - fi = ip4_fib_table_create_and_lock(); + fi = ip4_fib_table_create_and_lock(src); break; case FIB_PROTOCOL_IP6: - fi = ip6_fib_table_create_and_lock(); + fi = ip6_fib_table_create_and_lock(src, FIB_TABLE_FLAG_NONE, NULL); break; case FIB_PROTOCOL_MPLS: - fi = mpls_fib_table_create_and_lock(); + fi = mpls_fib_table_create_and_lock(src); break; default: return (~0); @@ -1096,6 +1208,8 @@ fib_table_create_and_lock (fib_protocol_t proto, fib_table = fib_table_get(fi, proto); + va_start(ap, fmt); + fib_table->ft_desc = va_format(fib_table->ft_desc, fmt, &ap); va_end(ap); @@ -1141,28 +1255,76 @@ fib_table_walk (u32 fib_index, } } +void +fib_table_sub_tree_walk (u32 fib_index, + fib_protocol_t proto, + const fib_prefix_t *root, + fib_table_walk_fn_t fn, + void *ctx) +{ + switch (proto) + { + case FIB_PROTOCOL_IP4: + ip4_fib_table_sub_tree_walk(ip4_fib_get(fib_index), root, fn, ctx); + break; + case FIB_PROTOCOL_IP6: + ip6_fib_table_sub_tree_walk(fib_index, root, fn, ctx); + break; + case FIB_PROTOCOL_MPLS: + break; + } +} + +static void +fib_table_lock_dec (fib_table_t *fib_table, + fib_source_t source) +{ + vec_validate(fib_table->ft_locks, source); + + fib_table->ft_locks[source]--; + fib_table->ft_total_locks--; +} + +static void +fib_table_lock_inc (fib_table_t *fib_table, + fib_source_t source) +{ + vec_validate(fib_table->ft_locks, source); + + ASSERT(fib_table->ft_total_locks < (0xffffffff - 1)); + fib_table->ft_locks[source]++; + fib_table->ft_total_locks++; +} + void fib_table_unlock (u32 fib_index, - fib_protocol_t proto) + fib_protocol_t proto, + fib_source_t source) { fib_table_t *fib_table; fib_table = fib_table_get(fib_index, proto); - fib_table->ft_locks--; + fib_table_lock_dec(fib_table, source); - if (0 == fib_table->ft_locks) + if (0 == fib_table->ft_total_locks) { + /* + * no more locak from any source - kill it + */ fib_table_destroy(fib_table); } } + void fib_table_lock (u32 fib_index, - fib_protocol_t proto) + fib_protocol_t proto, + fib_source_t source) { fib_table_t *fib_table; fib_table = fib_table_get(fib_index, proto); - fib_table->ft_locks++; + + fib_table_lock_inc(fib_table, source); } u32 @@ -1178,10 +1340,10 @@ fib_table_get_num_entries (u32 fib_index, } u8* -format_fib_table_name (u8* s, va_list ap) +format_fib_table_name (u8* s, va_list* ap) { - fib_node_index_t fib_index = va_arg(ap, fib_node_index_t); - fib_protocol_t proto = va_arg(ap, int); // int promotion + fib_node_index_t fib_index = va_arg(*ap, fib_node_index_t); + fib_protocol_t proto = va_arg(*ap, int); // int promotion fib_table_t *fib_table; fib_table = fib_table_get(fib_index, proto); @@ -1191,6 +1353,26 @@ format_fib_table_name (u8* s, va_list ap) return (s); } +u8* +format_fib_table_flags (u8 *s, va_list *args) +{ + fib_table_flags_t flags = va_arg(*args, int); + fib_table_attribute_t attr; + + if (!flags) + { + return format(s, "none"); + } + + FOR_EACH_FIB_TABLE_ATTRIBUTE(attr) { + if (1 << attr & flags) { + s = format(s, "%s", fib_table_flags_strings[attr]); + } + } + + return (s); +} + /** * @brief Table flush context. Store the indicies of matching FIB entries * that need to be removed. @@ -1208,7 +1390,7 @@ typedef struct fib_table_flush_ctx_t_ fib_source_t ftf_source; } fib_table_flush_ctx_t; -static int +static fib_table_walk_rc_t fib_table_flush_cb (fib_node_index_t fib_entry_index, void *arg) { @@ -1218,10 +1400,9 @@ fib_table_flush_cb (fib_node_index_t fib_entry_index, { vec_add1(ctx->ftf_entries, fib_entry_index); } - return (1); + return (FIB_TABLE_WALK_CONTINUE); } - void fib_table_flush (u32 fib_index, fib_protocol_t proto, @@ -1244,3 +1425,86 @@ fib_table_flush (u32 fib_index, vec_free(ctx.ftf_entries); } + +static fib_table_walk_rc_t +fib_table_mark_cb (fib_node_index_t fib_entry_index, + void *arg) +{ + fib_table_flush_ctx_t *ctx = arg; + + if (fib_entry_is_sourced(fib_entry_index, ctx->ftf_source)) + { + fib_entry_mark(fib_entry_index, ctx->ftf_source); + } + return (FIB_TABLE_WALK_CONTINUE); +} + +void +fib_table_mark (u32 fib_index, + fib_protocol_t proto, + fib_source_t source) +{ + fib_table_flush_ctx_t ctx = { + .ftf_source = source, + }; + fib_table_t *fib_table; + + fib_table = fib_table_get(fib_index, proto); + + fib_table->ft_epoch++; + fib_table->ft_flags |= FIB_TABLE_FLAG_RESYNC; + + fib_table_walk(fib_index, proto, + fib_table_mark_cb, + &ctx); +} + +static fib_table_walk_rc_t +fib_table_sweep_cb (fib_node_index_t fib_entry_index, + void *arg) +{ + fib_table_flush_ctx_t *ctx = arg; + + if (fib_entry_is_marked(fib_entry_index, ctx->ftf_source)) + { + vec_add1(ctx->ftf_entries, fib_entry_index); + } + return (FIB_TABLE_WALK_CONTINUE); +} + +void +fib_table_sweep (u32 fib_index, + fib_protocol_t proto, + fib_source_t source) +{ + fib_table_flush_ctx_t ctx = { + .ftf_source = source, + }; + fib_node_index_t *fib_entry_index; + fib_table_t *fib_table; + + fib_table = fib_table_get(fib_index, proto); + + fib_table->ft_flags &= ~FIB_TABLE_FLAG_RESYNC; + + fib_table_walk(fib_index, proto, + fib_table_sweep_cb, + &ctx); + + vec_foreach(fib_entry_index, ctx.ftf_entries) + { + fib_table_entry_delete_index(*fib_entry_index, source); + } + + vec_free(ctx.ftf_entries); +} + +u8 * +format_fib_table_memory (u8 *s, va_list *args) +{ + s = format(s, "%U", format_ip4_fib_table_memory); + s = format(s, "%U", format_ip6_fib_table_memory); + s = format(s, "%U", format_mpls_fib_table_memory); + + return (s); +}