diff options
Diffstat (limited to 'vnet')
27 files changed, 333 insertions, 387 deletions
diff --git a/vnet/Makefile.am b/vnet/Makefile.am index 6aa4254f2af..1b7b96911f9 100644 --- a/vnet/Makefile.am +++ b/vnet/Makefile.am @@ -777,7 +777,6 @@ nobase_include_HEADERS += \ ######################################## libvnet_la_SOURCES += \ - vnet/adj/adj_alloc.c \ vnet/adj/adj_nbr.c \ vnet/adj/adj_rewrite.c \ vnet/adj/adj_glean.c \ diff --git a/vnet/vnet/adj/adj.c b/vnet/vnet/adj/adj.c index b552fdb2bbc..8f9d96efd60 100644 --- a/vnet/vnet/adj/adj.c +++ b/vnet/vnet/adj/adj.c @@ -14,7 +14,6 @@ */ #include <vnet/adj/adj.h> -#include <vnet/adj/adj_alloc.h> #include <vnet/adj/adj_internal.h> #include <vnet/adj/adj_glean.h> #include <vnet/adj/adj_midchain.h> @@ -30,16 +29,17 @@ static ip_adjacency_t *special_v4_miss_adj_with_index_zero; /* Adjacency packet/byte counters indexed by adjacency index. */ vlib_combined_counter_main_t adjacency_counters; +/* + * the single adj pool + */ +ip_adjacency_t *adj_pool; + always_inline void adj_poison (ip_adjacency_t * adj) { if (CLIB_DEBUG > 0) { - u32 save_handle = adj->heap_handle;; - memset (adj, 0xfe, sizeof (adj[0])); - - adj->heap_handle = save_handle; } } @@ -48,14 +48,14 @@ adj_alloc (fib_protocol_t proto) { ip_adjacency_t *adj; - adj = aa_alloc(); + pool_get(adj_pool, adj); adj_poison(adj); /* Make sure certain fields are always initialized. */ /* Validate adjacency counters. */ vlib_validate_combined_counter(&adjacency_counters, - adj->heap_handle); + adj_get_index(adj)); adj->rewrite_header.sw_if_index = ~0; adj->mcast_group_index = ~0; @@ -66,6 +66,9 @@ adj_alloc (fib_protocol_t proto) FIB_NODE_TYPE_ADJ); adj->ia_nh_proto = proto; + ip4_main.lookup_main.adjacency_heap = adj_pool; + ip6_main.lookup_main.adjacency_heap = adj_pool; + return (adj); } @@ -166,7 +169,7 @@ adj_last_lock_gone (ip_adjacency_t *adj) } fib_node_deinit(&adj->ia_node); - aa_free(adj); + pool_put(adj_pool, adj); } void @@ -181,7 +184,6 @@ adj_lock (adj_index_t adj_index) adj = adj_get(adj_index); ASSERT(adj); - ASSERT(adj->heap_handle!=0); ADJ_DBG(adj, "lock"); fib_node_lock(&adj->ia_node); @@ -199,11 +201,9 @@ adj_unlock (adj_index_t adj_index) adj = adj_get(adj_index); ASSERT(adj); - ASSERT(adj->heap_handle!=0); ADJ_DBG(adj, "unlock"); ASSERT(adj); - ASSERT(adj->heap_handle!=0); fib_node_unlock(&adj->ia_node); } @@ -291,7 +291,6 @@ adj_module_init (vlib_main_t * vm) /* * 4 special adjs for v4 and v6 resp. */ - aa_bootstrap(8); special_v4_miss_adj_with_index_zero = adj_alloc(FIB_PROTOCOL_IP4); return (NULL); @@ -311,33 +310,14 @@ ip_add_adjacency (ip_lookup_main_t * lm, u32 * adj_index_return) { ip_adjacency_t * adj; - u32 ai, i, handle; ASSERT(1==n_adj); - adj = aa_alloc (); - handle = ai = adj->heap_handle; + adj = adj_alloc(FIB_PROTOCOL_IP4); - /* Validate adjacency counters. */ - vlib_validate_combined_counter (&adjacency_counters, ai + n_adj - 1); - - for (i = 0; i < n_adj; i++) - { - /* Make sure certain fields are always initialized. */ - adj[i].rewrite_header.sw_if_index = ~0; - adj[i].mcast_group_index = ~0; - adj[i].saved_lookup_next_index = 0; - - if (copy_adj) - adj[i] = copy_adj[i]; - - adj[i].heap_handle = handle; - adj[i].n_adj = n_adj; - - /* Zero possibly stale counters for re-used adjacencies. */ - vlib_zero_combined_counter (&adjacency_counters, ai + i); - } + if (copy_adj) + *adj = *copy_adj; - *adj_index_return = ai; + *adj_index_return = adj_get_index(adj); return adj; } diff --git a/vnet/vnet/adj/adj.h b/vnet/vnet/adj/adj.h index 3a1236497e1..002dab359ab 100644 --- a/vnet/vnet/adj/adj.h +++ b/vnet/vnet/adj/adj.h @@ -77,9 +77,9 @@ extern void adj_child_remove(adj_index_t adj_index, /** * @brief - * The global adjacnecy heap. Exposed for fast/inline data-plane access + * The global adjacnecy pool. Exposed for fast/inline data-plane access */ -extern ip_adjacency_t *adj_heap; +extern ip_adjacency_t *adj_pool; /** * @brief @@ -94,7 +94,7 @@ extern vlib_combined_counter_main_t adjacency_counters; static inline ip_adjacency_t * adj_get (adj_index_t adj_index) { - return (vec_elt_at_index(adj_heap, adj_index)); + return (vec_elt_at_index(adj_pool, adj_index)); } #endif diff --git a/vnet/vnet/adj/adj_alloc.c b/vnet/vnet/adj/adj_alloc.c deleted file mode 100644 index 5cc8cf6ef04..00000000000 --- a/vnet/vnet/adj/adj_alloc.c +++ /dev/null @@ -1,236 +0,0 @@ -/* - * Copyright (c) 2016 Cisco and/or its affiliates. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include <vnet/adj/adj_alloc.h> -#include <vnet/ip/ip.h> - -/* - * the single adj heap - */ -ip_adjacency_t *adj_heap; - -/* - * any operation which could cause the adj vector to be reallocated - * must have a worker thread barrier - */ -static inline int will_reallocate (ip_adjacency_t * adjs, u32 n) -{ - uword aligned_header_bytes, new_data_bytes; - uword data_bytes; - aa_header_t * ah = aa_header (adjs); - - if (adjs == 0) - return 1; - - data_bytes = (vec_len (adjs) + n) * sizeof (*adjs); - - aligned_header_bytes = vec_header_bytes (aa_aligned_header_bytes); - - new_data_bytes = data_bytes + aligned_header_bytes; - - ASSERT (clib_mem_is_heap_object (_vec_find(ah))); - - if (PREDICT_TRUE(new_data_bytes <= clib_mem_size (_vec_find(ah)))) - return 0; - - return 1; -} - -ip_adjacency_t * -aa_alloc (void) -{ - vlib_main_t * vm = &vlib_global_main; - aa_header_t * ah = aa_header (adj_heap); - ip_adjacency_t * adj_block; - u32 freelist_length; - int need_barrier_sync = 0; - u32 n = 1; - - ASSERT(os_get_cpu_number() == 0); - ASSERT (clib_mem_is_heap_object (_vec_find(ah))); - - /* If we don't have a freelist of size N, fresh allocation is required */ - if (vec_len (ah->free_indices_by_size) <= n) - { - if (will_reallocate (adj_heap, n)) - { - need_barrier_sync = 1; - vlib_worker_thread_barrier_sync (vm); - } - /* Workers wont look at the freelists... */ - vec_validate (ah->free_indices_by_size, n); - vec_add2_ha (adj_heap, adj_block, n, aa_aligned_header_bytes, - CLIB_CACHE_LINE_BYTES); - if (need_barrier_sync) - vlib_worker_thread_barrier_release (vm); - goto out; - } - /* See if we have a free adj block to dole out */ - if ((freelist_length = vec_len(ah->free_indices_by_size[n]))) - { - u32 index = ah->free_indices_by_size[n][freelist_length-1]; - - adj_block = &adj_heap[index]; - _vec_len(ah->free_indices_by_size[n]) -= 1; - goto out; - } - /* Allocate a new block of size N */ - if (will_reallocate (adj_heap, n)) - { - need_barrier_sync = 1; - vlib_worker_thread_barrier_sync (vm); - } - vec_add2_ha (adj_heap, adj_block, n, aa_aligned_header_bytes, - CLIB_CACHE_LINE_BYTES); - - if (need_barrier_sync) - vlib_worker_thread_barrier_release (vm); - - out: - memset (adj_block, 0, n * (sizeof(*adj_block))); - adj_block->heap_handle = adj_block - adj_heap; - adj_block->n_adj = n; - - /* - * the adj heap may have realloc'd. recache. - */ - ip4_main.lookup_main.adjacency_heap = adj_heap; - ip6_main.lookup_main.adjacency_heap = adj_heap; - - return (adj_block); -} - -void aa_free (ip_adjacency_t * adj) -{ - aa_header_t * ah = aa_header (adj_heap); - - ASSERT (adj_heap && adj && (adj->heap_handle < vec_len (adj_heap))); - ASSERT (adj->heap_handle != 0); - - vec_add1 (ah->free_indices_by_size[adj->n_adj], adj->heap_handle); - adj->heap_handle = 0; -} - -void aa_bootstrap (u32 n) -{ - ip_adjacency_t * adj_block; - aa_header_t * ah; - int i; - - vec_add2_ha (adj_heap, adj_block, n, aa_aligned_header_bytes, - CLIB_CACHE_LINE_BYTES); - - memset (adj_block, 0, n * sizeof(*adj_block)); - ah = aa_header (adj_heap); - memset (ah, 0, sizeof (*ah)); - - vec_validate (ah->free_indices_by_size, 1); - - for (i = 0 ; i < vec_len (adj_heap); i++) - { - adj_block->n_adj = 1; - adj_block->heap_handle = ~0; - /* Euchre the allocator into returning 0, 1, 2, etc. */ - vec_add1 (ah->free_indices_by_size[1], n - (i+1)); - } - - ip4_main.lookup_main.adjacency_heap = adj_heap; - ip6_main.lookup_main.adjacency_heap = adj_heap; -} - -u8 * format_adjacency_alloc (u8 * s, va_list * args) -{ - vnet_main_t * vnm = va_arg (*args, vnet_main_t *); - int verbose = va_arg (*args, int); - ip_adjacency_t * adj; - u32 inuse = 0, freed = 0; - u32 on_freelist = 0; - int i, j; - aa_header_t * ah = aa_header (adj_heap); - - for (i = 0; i < vec_len (adj_heap); i += adj->n_adj) - { - adj = adj_heap + i; - if ((i == 0) || adj->heap_handle) - inuse += adj->n_adj; - else - freed += adj->n_adj; - } - - for (i = 1; i < vec_len(ah->free_indices_by_size); i++) - { - for (j = 0; j < vec_len(ah->free_indices_by_size[i]); j++) - { - adj = adj_heap + ah->free_indices_by_size[i][j]; - ASSERT(adj->heap_handle == 0); - on_freelist += adj->n_adj; - } - } - - s = format (s, "adj_heap: %d total, %d in use, %d free, %d on freelists\n", - vec_len(adj_heap), inuse, freed, on_freelist); - if (verbose) - { - for (i = 0; i < vec_len (adj_heap); i += adj->n_adj) - { - adj = adj_heap + i; - if ((i == 0) || adj->heap_handle) - { - if (adj->n_adj > 1) - s = format (s, "[%d-%d] ", i, i+adj->n_adj-1); - else - s = format (s, "[%d] ", i); - - for (j = 0; j < adj->n_adj; j++) - { - if (j > 0) - s = format (s, " "); - - s = format(s, "%U\n", format_ip_adjacency, - vnm, i+j, FORMAT_IP_ADJACENCY_NONE); - } - } - } - } - return s; -} - -static clib_error_t * -show_adjacency_alloc_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - int verbose = 0; - vnet_main_t *vnm = vnet_get_main(); - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "verbose")) - verbose = 1; - else - return clib_error_return (0, "unknown input `%U'", - format_unformat_error, input); - } - - vlib_cli_output (vm, "%U", format_adjacency_alloc, vnm, verbose); - - return 0; -} - -VLIB_CLI_COMMAND (show_adjacency_alloc_command, static) = { - .path = "show adjacency alloc", - .short_help = "show adjacency alloc", - .function = show_adjacency_alloc_command_fn, -}; diff --git a/vnet/vnet/adj/adj_alloc.h b/vnet/vnet/adj/adj_alloc.h deleted file mode 100644 index 7d1a3fb3133..00000000000 --- a/vnet/vnet/adj/adj_alloc.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2016 Cisco and/or its affiliates. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef __adj_alloc_h__ -#define __adj_alloc_h__ - -/** - * @brief - * Adjacency allocator: heap-like in that the code - * will dole out contiguous chunks of n items. In the interests of - * thread safety, we don't bother about coalescing free blocks of size r - * into free blocks of size s, where r < s. - * - * We include explicit references to worker thread barrier synchronization - * where necessary. - */ - -#include <vppinfra/vec.h> -#include <vlib/vlib.h> -#include <vnet/ip/lookup.h> - -typedef struct { - u32 ** free_indices_by_size; -} aa_header_t; - -#define aa_aligned_header_bytes \ - vec_aligned_header_bytes (sizeof (aa_header_t), sizeof (void *)) - -/* Pool header from user pointer */ -static inline aa_header_t * aa_header (void * v) -{ - return vec_aligned_header (v, sizeof (aa_header_t), sizeof (void *)); -} - -extern ip_adjacency_t *aa_alloc(void); -extern void aa_free (ip_adjacency_t * adj); -extern void aa_bootstrap (u32 n); - -format_function_t format_adj_allocation; - -#endif /* __adj_alloc_h__ */ diff --git a/vnet/vnet/adj/adj_glean.c b/vnet/vnet/adj/adj_glean.c index 6eb6718e216..f5d181018b6 100644 --- a/vnet/vnet/adj/adj_glean.c +++ b/vnet/vnet/adj/adj_glean.c @@ -14,7 +14,6 @@ */ #include <vnet/adj/adj.h> -#include <vnet/adj/adj_alloc.h> #include <vnet/adj/adj_internal.h> #include <vnet/fib/fib_walk.h> @@ -62,7 +61,7 @@ adj_glean_add_or_lock (fib_protocol_t proto, adj->lookup_next_index = IP_LOOKUP_NEXT_GLEAN; adj->ia_nh_proto = proto; - adj_gleans[proto][sw_if_index] = adj->heap_handle; + adj_gleans[proto][sw_if_index] = adj_get_index(adj); if (NULL != nh_addr) { @@ -84,9 +83,9 @@ adj_glean_add_or_lock (fib_protocol_t proto, adj = adj_get(adj_gleans[proto][sw_if_index]); } - adj_lock(adj->heap_handle); + adj_lock(adj_get_index(adj)); - return (adj->heap_handle); + return (adj_get_index(adj)); } void @@ -124,7 +123,7 @@ adj_glean_interface_state_change (vnet_main_t * vnm, FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN), }; - fib_walk_sync(FIB_NODE_TYPE_ADJ, adj->heap_handle, &bw_ctx); + fib_walk_sync(FIB_NODE_TYPE_ADJ, adj_get_index(adj), &bw_ctx); } return (NULL); @@ -173,7 +172,7 @@ adj_glean_interface_delete (vnet_main_t * vnm, .fnbw_reason = FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE, }; - fib_walk_sync(FIB_NODE_TYPE_ADJ, adj->heap_handle, &bw_ctx); + fib_walk_sync(FIB_NODE_TYPE_ADJ, adj_get_index(adj), &bw_ctx); } return (NULL); diff --git a/vnet/vnet/adj/adj_internal.h b/vnet/vnet/adj/adj_internal.h index f2d0ce0dbb2..25a477ad007 100644 --- a/vnet/vnet/adj/adj_internal.h +++ b/vnet/vnet/adj/adj_internal.h @@ -31,11 +31,11 @@ * Debug macro */ #ifdef ADJ_DEBUG -#define ADJ_DBG(_adj, _fmt, _args...) \ -{ \ - clib_warning("adj:[%d:%p]:" _fmt, \ - _adj->heap_handle, _adj, \ - ##_args); \ +#define ADJ_DBG(_adj, _fmt, _args...) \ +{ \ + clib_warning("adj:[%d:%p]:" _fmt, \ + _adj - adj_pool, _adj, \ + ##_args); \ } #else #define ADJ_DBG(_e, _fmt, _args...) @@ -90,6 +90,16 @@ adj_fib_proto_2_nd (fib_protocol_t fp) return (0); } +/** + * @brief + * Get a pointer to an adjacency object from its index + */ +static inline adj_index_t +adj_get_index (ip_adjacency_t *adj) +{ + return (adj - adj_pool); +} + extern ip_adjacency_t * adj_alloc(fib_protocol_t proto); extern void adj_nbr_remove(fib_protocol_t nh_proto, diff --git a/vnet/vnet/adj/adj_midchain.c b/vnet/vnet/adj/adj_midchain.c index 562a90d6e1d..c40d4e8bca5 100644 --- a/vnet/vnet/adj/adj_midchain.c +++ b/vnet/vnet/adj/adj_midchain.c @@ -405,7 +405,7 @@ adj_nbr_midchain_update_rewrite (adj_index_t adj_index, .fnbw_reason = FIB_NODE_BW_REASON_ADJ_UPDATE, }; - fib_walk_sync(FIB_NODE_TYPE_ADJ, adj->heap_handle, &bw_ctx); + fib_walk_sync(FIB_NODE_TYPE_ADJ, adj_get_index(adj), &bw_ctx); } /** diff --git a/vnet/vnet/adj/adj_nbr.c b/vnet/vnet/adj/adj_nbr.c index 0913cfd791c..23e40a6850c 100644 --- a/vnet/vnet/adj/adj_nbr.c +++ b/vnet/vnet/adj/adj_nbr.c @@ -275,7 +275,7 @@ adj_nbr_alloc (fib_protocol_t nh_proto, adj_nbr_insert(nh_proto, link_type, nh_addr, sw_if_index, - adj->heap_handle); + adj_get_index(adj)); /* * since we just added the ADJ we have no rewrite string for it, @@ -362,9 +362,9 @@ adj_nbr_add_or_lock (fib_protocol_t nh_proto, adj = adj_get(adj_index); } - adj_lock(adj->heap_handle); + adj_lock(adj_get_index(adj)); - return (adj->heap_handle); + return (adj_get_index(adj)); } adj_index_t @@ -389,10 +389,10 @@ adj_nbr_add_or_lock_w_rewrite (fib_protocol_t nh_proto, adj = adj_get(adj_index); } - adj_lock(adj->heap_handle); - adj_nbr_update_rewrite(adj->heap_handle, rewrite); + adj_lock(adj_get_index(adj)); + adj_nbr_update_rewrite(adj_get_index(adj), rewrite); - return (adj->heap_handle); + return (adj_get_index(adj)); } /** @@ -760,10 +760,20 @@ adj_dpo_unlock (dpo_id_t *dpo) adj_unlock(dpo->dpoi_index); } +static void +adj_mem_show (void) +{ + fib_show_memory_usage("Adjacency", + pool_elts(adj_pool), + pool_len(adj_pool), + sizeof(ip_adjacency_t)); +} + const static dpo_vft_t adj_nbr_dpo_vft = { .dv_lock = adj_dpo_lock, .dv_unlock = adj_dpo_unlock, .dv_format = format_adj_nbr, + .dv_mem_show = adj_mem_show, }; const static dpo_vft_t adj_nbr_incompl_dpo_vft = { .dv_lock = adj_dpo_lock, diff --git a/vnet/vnet/adj/adj_rewrite.c b/vnet/vnet/adj/adj_rewrite.c index db802e33665..eb93f6a4377 100644 --- a/vnet/vnet/adj/adj_rewrite.c +++ b/vnet/vnet/adj/adj_rewrite.c @@ -14,7 +14,6 @@ */ #include <vnet/adj/adj.h> -#include <vnet/adj/adj_alloc.h> #include <vnet/adj/adj_internal.h> /** @@ -46,7 +45,7 @@ adj_rewrite_add_and_lock (fib_protocol_t nh_proto, &adj->rewrite_header, sizeof (adj->rewrite_data)); - adj_lock(adj->heap_handle); + adj_lock(adj_get_index(adj)); - return (adj->heap_handle); + return (adj_get_index(adj)); } diff --git a/vnet/vnet/dpo/classify_dpo.c b/vnet/vnet/dpo/classify_dpo.c index 3b7b98f9da8..93f3f0ae275 100644 --- a/vnet/vnet/dpo/classify_dpo.c +++ b/vnet/vnet/dpo/classify_dpo.c @@ -90,10 +90,20 @@ classify_dpo_unlock (dpo_id_t *dpo) } } +static void +classify_dpo_mem_show (void) +{ + fib_show_memory_usage("Classify", + pool_elts(classify_dpo_pool), + pool_len(classify_dpo_pool), + sizeof(classify_dpo_t)); +} + const static dpo_vft_t cd_vft = { .dv_lock = classify_dpo_lock, .dv_unlock = classify_dpo_unlock, .dv_format = format_classify_dpo, + .dv_mem_show = classify_dpo_mem_show, }; const static char* const classify_ip4_nodes[] = diff --git a/vnet/vnet/dpo/dpo.c b/vnet/vnet/dpo/dpo.c index 5eff52b7b8a..9f09dff81d1 100644 --- a/vnet/vnet/dpo/dpo.c +++ b/vnet/vnet/dpo/dpo.c @@ -422,3 +422,47 @@ dpo_module_init (vlib_main_t * vm) } VLIB_INIT_FUNCTION(dpo_module_init); + +static clib_error_t * +dpo_memory_show (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + dpo_vft_t *vft; + + vlib_cli_output (vm, "DPO memory"); + vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s totals", + "Name","Size", "in-use", "allocated"); + + vec_foreach(vft, dpo_vfts) + { + if (NULL != vft->dv_mem_show) + vft->dv_mem_show(); + } + + return (NULL); +} + +/* *INDENT-OFF* */ +/*? + * The '<em>sh dpo memory </em>' command displays the memory usage for each + * data-plane object type. + * + * @cliexpar + * @cliexstart{show dpo memory} + * DPO memory + * Name Size in-use /allocated totals + * load-balance 64 12 / 12 768/768 + * Adjacency 256 1 / 1 256/256 + * Receive 24 5 / 5 120/120 + * Lookup 12 0 / 0 0/0 + * Classify 12 0 / 0 0/0 + * MPLS label 24 0 / 0 0/0 + * @cliexend +?*/ +VLIB_CLI_COMMAND (show_fib_memory, static) = { + .path = "show dpo memory", + .function = dpo_memory_show, + .short_help = "show dpo memory", +}; +/* *INDENT-ON* */ diff --git a/vnet/vnet/dpo/dpo.h b/vnet/vnet/dpo/dpo.h index 452a07e3104..7ba47569d8d 100644 --- a/vnet/vnet/dpo/dpo.h +++ b/vnet/vnet/dpo/dpo.h @@ -301,6 +301,11 @@ typedef void (*dpo_lock_fn_t)(dpo_id_t *dpo); typedef void (*dpo_unlock_fn_t)(dpo_id_t *dpo); /** + * @brief An memory usage show command + */ +typedef void (*dpo_mem_show_t)(void); + +/** * @brief A virtual function table regisitered for a DPO type */ typedef struct dpo_vft_t_ @@ -317,6 +322,10 @@ typedef struct dpo_vft_t_ * A format function */ format_function_t *dv_format; + /** + * A show memory usage function + */ + dpo_mem_show_t dv_mem_show; } dpo_vft_t; @@ -337,9 +346,9 @@ typedef struct dpo_vft_t_ * @param nodes * The string description of the per-protocol VLIB graph nodes. */ -void dpo_register(dpo_type_t type, - const dpo_vft_t *vft, - const char * const * const * nodes); +extern void dpo_register(dpo_type_t type, + const dpo_vft_t *vft, + const char * const * const * nodes); /** * @brief Create and register a new DPO type. @@ -355,7 +364,7 @@ void dpo_register(dpo_type_t type, * * @return The new dpo_type_t */ -dpo_type_t dpo_register_new_type(const dpo_vft_t *vft, - const char * const * const * nodes); +extern dpo_type_t dpo_register_new_type(const dpo_vft_t *vft, + const char * const * const * nodes); #endif diff --git a/vnet/vnet/dpo/load_balance.c b/vnet/vnet/dpo/load_balance.c index 1250694a9e3..093661d8578 100644 --- a/vnet/vnet/dpo/load_balance.c +++ b/vnet/vnet/dpo/load_balance.c @@ -19,7 +19,6 @@ #include <vnet/dpo/drop_dpo.h> #include <vppinfra/math.h> /* for fabs */ #include <vnet/adj/adj.h> -#include <vnet/adj/adj_alloc.h> #include <vnet/adj/adj_internal.h> /* @@ -671,10 +670,20 @@ load_balance_unlock (dpo_id_t *dpo) } } +static void +load_balance_mem_show (void) +{ + fib_show_memory_usage("load-balance", + pool_elts(load_balance_pool), + pool_len(load_balance_pool), + sizeof(load_balance_t)); +} + const static dpo_vft_t lb_vft = { .dv_lock = load_balance_lock, .dv_unlock = load_balance_unlock, .dv_format = format_load_balance_dpo, + .dv_mem_show = load_balance_mem_show, }; /** diff --git a/vnet/vnet/dpo/lookup_dpo.c b/vnet/vnet/dpo/lookup_dpo.c index 6e3f0792d07..f775417287c 100644 --- a/vnet/vnet/dpo/lookup_dpo.c +++ b/vnet/vnet/dpo/lookup_dpo.c @@ -734,11 +734,26 @@ VLIB_REGISTER_NODE (lookup_mpls_dst_itf_node) = { }; VLIB_NODE_FUNCTION_MULTIARCH (lookup_mpls_dst_itf_node, lookup_mpls_dst_itf) +static void +lookup_dpo_mem_show (void) +{ + fib_show_memory_usage("Lookup", + pool_elts(lookup_dpo_pool), + pool_len(lookup_dpo_pool), + sizeof(lookup_dpo_t)); +} + const static dpo_vft_t lkd_vft = { .dv_lock = lookup_dpo_lock, .dv_unlock = lookup_dpo_unlock, .dv_format = format_lookup_dpo, }; +const static dpo_vft_t lkd_vft_w_mem_show = { + .dv_lock = lookup_dpo_lock, + .dv_unlock = lookup_dpo_unlock, + .dv_format = format_lookup_dpo, + .dv_mem_show = lookup_dpo_mem_show, +}; const static char* const lookup_src_ip4_nodes[] = { @@ -805,7 +820,7 @@ const static char* const * const lookup_dst_from_interface_nodes[DPO_PROTO_NUM] void lookup_dpo_module_init (void) { - dpo_register(DPO_LOOKUP, &lkd_vft, NULL); + dpo_register(DPO_LOOKUP, &lkd_vft_w_mem_show, NULL); /* * There are various sorts of lookup; src or dst addr v4 /v6 etc. diff --git a/vnet/vnet/dpo/mpls_label_dpo.c b/vnet/vnet/dpo/mpls_label_dpo.c index 0ec840ecfbd..532d0447db6 100644 --- a/vnet/vnet/dpo/mpls_label_dpo.c +++ b/vnet/vnet/dpo/mpls_label_dpo.c @@ -227,10 +227,20 @@ VLIB_REGISTER_NODE (mpls_label_imposition_node) = { }; VLIB_NODE_FUNCTION_MULTIARCH (mpls_label_imposition_node, mpls_label_imposition) +static void +mpls_label_dpo_mem_show (void) +{ + fib_show_memory_usage("MPLS label", + pool_elts(mpls_label_dpo_pool), + pool_len(mpls_label_dpo_pool), + sizeof(mpls_label_dpo_t)); +} + const static dpo_vft_t mld_vft = { .dv_lock = mpls_label_dpo_lock, .dv_unlock = mpls_label_dpo_unlock, .dv_format = format_mpls_label_dpo, + .dv_mem_show = mpls_label_dpo_mem_show, }; const static char* const mpls_label_imp_ip4_nodes[] = diff --git a/vnet/vnet/dpo/receive_dpo.c b/vnet/vnet/dpo/receive_dpo.c index ee7d82b0980..ad78850daf3 100644 --- a/vnet/vnet/dpo/receive_dpo.c +++ b/vnet/vnet/dpo/receive_dpo.c @@ -117,10 +117,20 @@ format_receive_dpo (u8 *s, va_list *ap) } } +static void +receive_dpo_mem_show (void) +{ + fib_show_memory_usage("Receive", + pool_elts(receive_dpo_pool), + pool_len(receive_dpo_pool), + sizeof(receive_dpo_t)); +} + const static dpo_vft_t receive_vft = { .dv_lock = receive_dpo_lock, .dv_unlock = receive_dpo_unlock, .dv_format = format_receive_dpo, + .dv_mem_show = receive_dpo_mem_show, }; /** diff --git a/vnet/vnet/fib/fib_entry.c b/vnet/vnet/fib/fib_entry.c index a75d5c9cf8c..1821319dbf7 100644 --- a/vnet/vnet/fib/fib_entry.c +++ b/vnet/vnet/fib/fib_entry.c @@ -435,6 +435,34 @@ fib_entry_back_walk_notify (fib_node_t *node, return (FIB_NODE_BACK_WALK_CONTINUE); } +static void +fib_entry_show_memory (void) +{ + u32 n_srcs = 0, n_exts = 0; + fib_entry_src_t *esrc; + fib_entry_t *entry; + + fib_show_memory_usage("Entry", + pool_elts(fib_entry_pool), + pool_len(fib_entry_pool), + sizeof(fib_entry_t)); + + pool_foreach(entry, fib_entry_pool, + ({ + n_srcs += vec_len(entry->fe_srcs); + vec_foreach(esrc, entry->fe_srcs) + { + n_exts += vec_len(esrc->fes_path_exts); + } + })); + + fib_show_memory_usage("Entry Source", + n_srcs, n_srcs, sizeof(fib_entry_src_t)); + fib_show_memory_usage("Entry Path-Extensions", + n_exts, n_exts, + sizeof(fib_path_ext_t)); +} + /* * The FIB path-list's graph node virtual function table */ @@ -442,6 +470,7 @@ static const fib_node_vft_t fib_entry_vft = { .fnv_get = fib_entry_get_node, .fnv_last_lock = fib_entry_last_lock_gone, .fnv_back_walk = fib_entry_back_walk_notify, + .fnv_mem_show = fib_entry_show_memory, }; /* @@ -517,14 +546,6 @@ fib_entry_get_path_list (fib_node_index_t fib_entry_index) } u32 -fib_entry_get_fib_table_id(fib_node_index_t fib_entry_index) -{ - - - return (0); -} - -u32 fib_entry_child_add (fib_node_index_t fib_entry_index, fib_node_type_t child_type, fib_node_index_t child_index) diff --git a/vnet/vnet/fib/fib_entry.h b/vnet/vnet/fib/fib_entry.h index 1ed9d619515..1016bb21948 100644 --- a/vnet/vnet/fib/fib_entry.h +++ b/vnet/vnet/fib/fib_entry.h @@ -262,6 +262,11 @@ _Static_assert (sizeof(fib_entry_src_flag_t) <= 2, */ typedef struct fib_entry_src_t_ { /** + * A vector of path extensions + */ + struct fib_path_ext_t_ *fes_path_exts; + + /** * The path-list created by the source */ fib_node_index_t fes_pl; @@ -273,10 +278,6 @@ typedef struct fib_entry_src_t_ { * Flags on the source */ fib_entry_src_flag_t fes_flags; - /** - * Flags the source contributes to the entry - */ - fib_entry_flag_t fes_entry_flags; /** * 1 bytes ref count. This is not the number of users of the Entry @@ -286,9 +287,9 @@ typedef struct fib_entry_src_t_ { u8 fes_ref_count; /** - * A vector of path extensions + * Flags the source contributes to the entry */ - struct fib_path_ext_t_ *fes_path_exts; + fib_entry_flag_t fes_entry_flags; /** * Source specific info @@ -502,7 +503,6 @@ extern int fib_entry_is_sourced(fib_node_index_t fib_entry_index, fib_source_t source); extern fib_node_index_t fib_entry_get_path_list(fib_node_index_t fib_entry_index); -extern u32 fib_entry_get_fib_table_id(fib_node_index_t fib_entry_index); extern void fib_entry_module_init(void); diff --git a/vnet/vnet/fib/fib_node.c b/vnet/vnet/fib/fib_node.c index 8ac67d2ef92..5ecc9a7fb2f 100644 --- a/vnet/vnet/fib/fib_node.c +++ b/vnet/vnet/fib/fib_node.c @@ -205,3 +205,62 @@ fib_node_unlock (fib_node_t *node) node->fn_vft->fnv_last_lock(node); } } + +void +fib_show_memory_usage (const char *name, + u32 in_use_elts, + u32 allocd_elts, + size_t size_elt) +{ + vlib_cli_output (vlib_get_main(), "%=30s %=5d %=8d/%=9d %d/%d ", + name, size_elt, + in_use_elts, allocd_elts, + in_use_elts*size_elt, allocd_elts*size_elt); +} + +static clib_error_t * +fib_memory_show (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + fib_node_vft_t *vft; + + vlib_cli_output (vm, "FIB memory"); + vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s totals", + "Name","Size", "in-use", "allocated"); + + vec_foreach(vft, fn_vfts) + { + if (NULL != vft->fnv_mem_show) + vft->fnv_mem_show(); + } + + fib_node_list_memory_show(); + + return (NULL); +} + +/* *INDENT-OFF* */ +/*? + * The '<em>sh fib memory </em>' command displays the memory usage for each + * FIB object type. + * + * @cliexpar + * @cliexstart{show fib memory} + * FIB memory + * Name Size in-use /allocated totals + * Entry 120 11 / 11 1320/1320 + * Entry Source 32 11 / 11 352/352 + * Entry Path-Extensions 44 0 / 0 0/0 + * Path-list 40 11 / 11 440/440 + * Path 88 11 / 11 968/968 + * Node-list elements 20 11 / 11 220/220 + * Node-list heads 8 13 / 13 104/104 + * @cliexend +?*/ +VLIB_CLI_COMMAND (show_fib_memory, static) = { + .path = "show fib memory", + .function = fib_memory_show, + .short_help = "show fib memory", +}; +/* *INDENT-ON* */ diff --git a/vnet/vnet/fib/fib_node.h b/vnet/vnet/fib/fib_node.h index 6a54c6f565b..2f9a107ab8b 100644 --- a/vnet/vnet/fib/fib_node.h +++ b/vnet/vnet/fib/fib_node.h @@ -220,6 +220,12 @@ typedef struct fib_node_t_* (*fib_node_get_t)(fib_node_index_t index); typedef void (*fib_node_last_lock_gone_t)(struct fib_node_t_ *node); /** + * Function definition to display the amount of memory used by a type. + * Implementations should call fib_show_memory_usage() + */ +typedef void (*fib_node_memory_show_t)(void); + +/** * A FIB graph nodes virtual function table */ typedef struct fib_node_vft_t_ { @@ -227,6 +233,7 @@ typedef struct fib_node_vft_t_ { fib_node_last_lock_gone_t fnv_last_lock; fib_node_back_walk_t fnv_back_walk; format_function_t *fnv_format; + fib_node_memory_show_t fnv_mem_show; } fib_node_vft_t; /** @@ -284,6 +291,22 @@ extern void fib_node_register_type (fib_node_type_t ft, */ extern fib_node_type_t fib_node_register_new_type (const fib_node_vft_t *vft); +/** + * @brief Show the memory usage for a type + * + * This should be invoked by the type in response to the infra calling + * its registered memory show function + * + * @param name the name of the type + * @param in_use_elts The number of elements in use + * @param allocd_elts The number of allocated pool elemenets + * @param size_elt The size of one element + */ +extern void fib_show_memory_usage(const char *name, + u32 in_use_elts, + u32 allocd_elts, + size_t size_elt); + extern void fib_node_init(fib_node_t *node, fib_node_type_t ft); extern void fib_node_deinit(fib_node_t *node); diff --git a/vnet/vnet/fib/fib_node_list.c b/vnet/vnet/fib/fib_node_list.c index 1d2e75ecec2..ceb951b466b 100644 --- a/vnet/vnet/fib/fib_node_list.c +++ b/vnet/vnet/fib/fib_node_list.c @@ -26,12 +26,6 @@ typedef struct fib_node_list_elt_t_ { /** - * An opaque indentifier set by the FIB node owning this element - * that will allow the owner to identify which element it is. - */ - int fnle_owner_id; - - /** * The index of the list this element is in */ fib_node_list_t fnle_list; @@ -108,7 +102,6 @@ fib_node_list_elt_create (fib_node_list_head_t *head, pool_get(fib_node_list_elt_pool, elt); elt->fnle_list = fib_node_list_head_get_index(head); - elt->fnle_owner_id = id; elt->fnle_owner.fnp_type = type; elt->fnle_owner.fnp_index = index; @@ -126,8 +119,7 @@ fib_node_list_head_init (fib_node_list_head_t *head) } /** - * @brief Create a new node list. The expectation is that these are few in number - * so straight from the memory subsystem + * @brief Create a new node list. */ fib_node_list_t fib_node_list_create (void) @@ -383,3 +375,16 @@ fib_node_list_walk (fib_node_list_t list, fn(&elt->fnle_owner, args); } } + +void +fib_node_list_memory_show (void) +{ + fib_show_memory_usage("Node-list elements", + pool_elts(fib_node_list_elt_pool), + pool_len(fib_node_list_elt_pool), + sizeof(fib_node_list_elt_t)); + fib_show_memory_usage("Node-list heads", + pool_elts(fib_node_list_head_pool), + pool_len(fib_node_list_head_pool), + sizeof(fib_node_list_head_t)); +} diff --git a/vnet/vnet/fib/fib_node_list.h b/vnet/vnet/fib/fib_node_list.h index afee3c6152c..9567b9669e8 100644 --- a/vnet/vnet/fib/fib_node_list.h +++ b/vnet/vnet/fib/fib_node_list.h @@ -58,4 +58,7 @@ typedef int (*fib_node_list_walk_cb_t)(fib_node_ptr_t *owner, extern void fib_node_list_walk(fib_node_list_t head, fib_node_list_walk_cb_t fn, void *args); + +extern void fib_node_list_memory_show(void); + #endif diff --git a/vnet/vnet/fib/fib_path.c b/vnet/vnet/fib/fib_path.c index d5453fde256..03cc7be5d9c 100644 --- a/vnet/vnet/fib/fib_path.c +++ b/vnet/vnet/fib/fib_path.c @@ -848,6 +848,15 @@ FIXME comment return (FIB_NODE_BACK_WALK_CONTINUE); } +static void +fib_path_memory_show (void) +{ + fib_show_memory_usage("Path", + pool_elts(fib_path_pool), + pool_len(fib_path_pool), + sizeof(fib_path_t)); +} + /* * The FIB path's graph node virtual function table */ @@ -855,6 +864,7 @@ static const fib_node_vft_t fib_path_vft = { .fnv_get = fib_path_get_node, .fnv_last_lock = fib_path_last_lock_gone, .fnv_back_walk = fib_path_back_walk_notify, + .fnv_mem_show = fib_path_memory_show, }; static fib_path_cfg_flags_t diff --git a/vnet/vnet/fib/fib_path_list.c b/vnet/vnet/fib/fib_path_list.c index 3523d93a7bb..611fe9fb5ae 100644 --- a/vnet/vnet/fib/fib_path_list.c +++ b/vnet/vnet/fib/fib_path_list.c @@ -452,12 +452,25 @@ fib_path_list_back_walk_notify (fib_node_t *node, } /* + * Display the path-list memory usage + */ +static void +fib_path_list_memory_show (void) +{ + fib_show_memory_usage("Path-list", + pool_elts(fib_path_list_pool), + pool_len(fib_path_list_pool), + sizeof(fib_path_list_t)); +} + +/* * The FIB path-list's graph node virtual function table */ static const fib_node_vft_t fib_path_list_vft = { .fnv_get = fib_path_list_get_node, .fnv_last_lock = fib_path_list_last_lock_gone, .fnv_back_walk = fib_path_list_back_walk_notify, + .fnv_mem_show = fib_path_list_memory_show, }; static fib_path_list_t * diff --git a/vnet/vnet/ip/lookup.c b/vnet/vnet/ip/lookup.c index a695ef765a0..5cfdc23ea01 100644 --- a/vnet/vnet/ip/lookup.c +++ b/vnet/vnet/ip/lookup.c @@ -38,7 +38,7 @@ */ #include <vnet/ip/ip.h> -#include <vnet/adj/adj_alloc.h> +#include <vnet/adj/adj.h> #include <vnet/fib/fib_table.h> #include <vnet/fib/ip4_fib.h> #include <vnet/fib/ip6_fib.h> @@ -162,7 +162,7 @@ void ip_lookup_init (ip_lookup_main_t * lm, u32 is_ip6) ASSERT(STRUCT_OFFSET_OF(ip_adjacency_t, cacheline1) == CLIB_CACHE_LINE_BYTES); /* Preallocate three "special" adjacencies */ - lm->adjacency_heap = adj_heap; + lm->adjacency_heap = adj_pool; if (! lm->fib_result_n_bytes) lm->fib_result_n_bytes = sizeof (uword); @@ -345,6 +345,7 @@ vnet_ip_route_cmd (vlib_main_t * vm, is_del = 0; table_id = 0; count = 1; + memset(&pfx, 0, sizeof(pfx)); /* Get a line of input. */ if (! unformat_user (main_input, unformat_line_input, line_input)) @@ -353,7 +354,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { memset(&rpath, 0, sizeof(rpath)); - memset(&pfx, 0, sizeof(pfx)); if (unformat (line_input, "table %d", &table_id)) ; @@ -510,6 +510,7 @@ vnet_ip_route_cmd (vlib_main_t * vm, { rpath.frp_label = MPLS_LABEL_INVALID; rpath.frp_proto = pfx.fp_proto; + rpath.frp_sw_if_index = ~0; vec_add1(rpaths, rpath); } else if (vec_len (prefixs) > 0 && diff --git a/vnet/vnet/ip/lookup.h b/vnet/vnet/ip/lookup.h index a21e1810983..97f776cb09d 100644 --- a/vnet/vnet/ip/lookup.h +++ b/vnet/vnet/ip/lookup.h @@ -173,8 +173,6 @@ typedef void (*adj_midchain_fixup_t)(vlib_main_t * vm, */ typedef struct ip_adjacency_t_ { CLIB_CACHE_LINE_ALIGN_MARK(cacheline0); - /* Handle for this adjacency in adjacency heap. */ - u32 heap_handle; /** Number of adjecencies in block. Greater than 1 means multipath; otherwise equal to 1. */ @@ -399,8 +397,6 @@ ip_get_adjacency (ip_lookup_main_t * lm, adj = vec_elt_at_index (lm->adjacency_heap, adj_index); - ASSERT (adj->heap_handle != ~0); - return adj; } |