2 * Copyright (c) 2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #include <vnet/fib/fib_node.h>
17 #include <vnet/fib/fib_node_list.h>
18 #include <vnet/fib/fib_table.h>
19 #include <vnet/mfib/mfib_table.h>
22 * The per-type vector of virtual function tables
24 static fib_node_vft_t *fn_vfts;
27 * The last registered new type
29 static fib_node_type_t last_new_type = FIB_NODE_TYPE_LAST;
34 static const char *fn_type_builtin_names[] = FIB_NODE_TYPES;
35 static const char **fn_type_names;
38 fib_node_type_get_name (fib_node_type_t type)
40 if ((type < vec_len(fn_type_names)) &&
41 (NULL != fn_type_names[type]))
43 return (fn_type_names[type]);
52 * fib_node_register_type
54 * Register the function table for a given type
57 fib_node_register_type_i (fib_node_type_t type,
59 const fib_node_vft_t *vft)
62 * assert that one only registration is made per-node type
64 if (vec_len(fn_vfts) > type)
65 ASSERT(NULL == fn_vfts[type].fnv_get);
68 * Assert that we are getting each of the required functions
70 ASSERT(NULL != vft->fnv_get);
71 ASSERT(NULL != vft->fnv_last_lock);
73 vec_validate(fn_vfts, type);
75 vec_validate(fn_type_names, type);
76 fn_type_names[type] = name;
80 * fib_node_register_type
82 * Register the function table for a given type
85 fib_node_register_type (fib_node_type_t type,
86 const fib_node_vft_t *vft)
88 fib_node_register_type_i(type, fn_type_builtin_names[type], vft);
92 fib_node_register_new_type (const char *name,
93 const fib_node_vft_t *vft)
95 fib_node_type_t new_type;
97 new_type = ++last_new_type;
99 fib_node_register_type_i(new_type, name, vft);
105 fib_node_format (fib_node_ptr_t *fnp, u8*s)
107 return (format(s, "{%s:%d}", fn_type_names[fnp->fnp_type], fnp->fnp_index));
111 fib_node_child_add (fib_node_type_t parent_type,
112 fib_node_index_t parent_index,
113 fib_node_type_t type,
114 fib_node_index_t index)
118 parent = fn_vfts[parent_type].fnv_get(parent_index);
121 * return the index of the sibling in the child list
123 fib_node_lock(parent);
125 if (FIB_NODE_INDEX_INVALID == parent->fn_children)
127 parent->fn_children = fib_node_list_create();
130 return (fib_node_list_push_front(parent->fn_children,
136 fib_node_child_remove (fib_node_type_t parent_type,
137 fib_node_index_t parent_index,
138 fib_node_index_t sibling_index)
142 parent = fn_vfts[parent_type].fnv_get(parent_index);
144 fib_node_list_remove(parent->fn_children, sibling_index);
146 if (0 == fib_node_list_get_size(parent->fn_children))
148 fib_node_list_destroy(&parent->fn_children);
151 fib_node_unlock(parent);
155 fib_node_get_n_children (fib_node_type_t parent_type,
156 fib_node_index_t parent_index)
160 parent = fn_vfts[parent_type].fnv_get(parent_index);
162 return (fib_node_list_get_size(parent->fn_children));
166 fib_node_back_walk_rc_t
167 fib_node_back_walk_one (fib_node_ptr_t *ptr,
168 fib_node_back_walk_ctx_t *ctx)
172 node = fn_vfts[ptr->fnp_type].fnv_get(ptr->fnp_index);
174 return (fn_vfts[ptr->fnp_type].fnv_back_walk(node, ctx));
178 fib_node_ptr_format_one_child (fib_node_ptr_t *ptr,
183 *s = fib_node_format(ptr, *s);
185 return (WALK_CONTINUE);
189 fib_node_children_format (fib_node_list_t list,
192 fib_node_list_walk(list, fib_node_ptr_format_one_child, (void*)&s);
198 fib_node_init (fib_node_t *node,
199 fib_node_type_t type)
202 * The node's type. used to retrieve the VFT.
204 node->fn_type = type;
206 node->fn_children = FIB_NODE_INDEX_INVALID;
210 fib_node_deinit (fib_node_t *node)
212 fib_node_list_destroy(&node->fn_children);
216 fib_node_lock (fib_node_t *node)
222 fib_node_unlock (fib_node_t *node)
226 if (0 == node->fn_locks)
228 fn_vfts[node->fn_type].fnv_last_lock(node);
233 fib_show_memory_usage (const char *name,
238 vlib_cli_output (vlib_get_main(), "%=30s %=5d %=8d/%=9d %d/%d ",
240 in_use_elts, allocd_elts,
241 in_use_elts*size_elt, allocd_elts*size_elt);
244 static clib_error_t *
245 fib_memory_show (vlib_main_t * vm,
246 unformat_input_t * input,
247 vlib_cli_command_t * cmd)
251 vlib_cli_output (vm, "FIB memory");
252 vlib_cli_output (vm, " Tables:");
253 vlib_cli_output (vm, "%=30s %=6s %=12s", "SAFI", "Number", "Bytes");
254 vlib_cli_output (vm, "%U", format_fib_table_memory);
255 vlib_cli_output (vm, "%U", format_mfib_table_memory);
256 vlib_cli_output (vm, " Nodes:");
257 vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s totals",
258 "Name","Size", "in-use", "allocated");
260 vec_foreach(vft, fn_vfts)
262 if (NULL != vft->fnv_mem_show)
266 fib_node_list_memory_show();
272 * The '<em>sh fib memory </em>' command displays the memory usage for each
276 * @cliexstart{show fib memory}
280 * IPv4 unicast 2 673066
281 * IPv6 unicast 2 1054608
283 * IPv4 multicast 2 2322
284 * IPv6 multicast 2 ???
286 * Name Size in-use /allocated totals
287 * Entry 96 20 / 20 1920/1920
288 * Entry Source 32 0 / 0 0/0
289 * Entry Path-Extensions 60 0 / 0 0/0
290 * multicast-Entry 192 12 / 12 2304/2304
291 * Path-list 40 28 / 28 1120/1120
292 * uRPF-list 16 20 / 20 320/320
293 * Path 72 28 / 28 2016/2016
294 * Node-list elements 20 28 / 28 560/560
295 * Node-list heads 8 30 / 30 240/240
298 VLIB_CLI_COMMAND (show_fib_memory, static) = {
299 .path = "show fib memory",
300 .function = fib_memory_show,
301 .short_help = "show fib memory",