Line data Source code
1 : /*
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:
6 : *
7 : * http://www.apache.org/licenses/LICENSE-2.0
8 : *
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.
14 : */
15 :
16 : #include <vnet/fib/fib_entry_delegate.h>
17 : #include <vnet/fib/fib_entry.h>
18 : #include <vnet/fib/fib_attached_export.h>
19 :
20 : static fib_entry_delegate_t *fib_entry_delegate_pool;
21 :
22 : fib_entry_delegate_t *
23 161126 : fib_entry_delegate_get (index_t fedi)
24 : {
25 161126 : return (pool_elt_at_index(fib_entry_delegate_pool, fedi));
26 : }
27 :
28 : fib_node_index_t
29 13194 : fib_entry_delegate_get_index (const fib_entry_delegate_t *fed)
30 : {
31 13194 : return (fed - fib_entry_delegate_pool);
32 : }
33 :
34 : static fib_entry_delegate_t *
35 1181750 : fib_entry_delegate_find_i (const fib_entry_t *fib_entry,
36 : fib_entry_delegate_type_t type,
37 : u32 *index)
38 : {
39 : fib_entry_delegate_t *delegate;
40 : index_t *fedi;
41 : int ii;
42 :
43 1181750 : ii = 0;
44 1268570 : vec_foreach(fedi, fib_entry->fe_delegates)
45 : {
46 149637 : delegate = fib_entry_delegate_get(*fedi);
47 :
48 149637 : if (delegate->fd_type == type)
49 : {
50 62820 : if (NULL != index)
51 11539 : *index = ii;
52 :
53 62820 : return (delegate);
54 : }
55 : else
56 : {
57 86817 : ii++;
58 : }
59 : }
60 :
61 1118930 : return (NULL);
62 : }
63 :
64 : fib_entry_delegate_t *
65 1170210 : fib_entry_delegate_find (const fib_entry_t *fib_entry,
66 : fib_entry_delegate_type_t type)
67 : {
68 1170210 : return (fib_entry_delegate_find_i(fib_entry, type, NULL));
69 : }
70 :
71 : void
72 11539 : fib_entry_delegate_remove (fib_entry_t *fib_entry,
73 : fib_entry_delegate_type_t type)
74 : {
75 : fib_entry_delegate_t *fed;
76 11539 : u32 index = ~0;
77 :
78 11539 : fed = fib_entry_delegate_find_i(fib_entry, type, &index);
79 :
80 11539 : ASSERT(NULL != fed);
81 :
82 11539 : vec_del1(fib_entry->fe_delegates, index);
83 :
84 11539 : pool_put(fib_entry_delegate_pool, fed);
85 11539 : }
86 :
87 : static int
88 152 : fib_entry_delegate_cmp_for_sort (void * v1,
89 : void * v2)
90 : {
91 : fib_entry_delegate_t *delegate1, *delegate2;
92 152 : index_t *fedi1 = v1, *fedi2 = v2;
93 :
94 152 : delegate1 = fib_entry_delegate_get(*fedi1);
95 152 : delegate2 = fib_entry_delegate_get(*fedi2);
96 :
97 152 : return (delegate1->fd_type - delegate2->fd_type);
98 : }
99 :
100 : static void
101 11979 : fib_entry_delegate_init (fib_entry_t *fib_entry,
102 : fib_entry_delegate_type_t type)
103 :
104 : {
105 : fib_entry_delegate_t *delegate;
106 :
107 11979 : pool_get_zero(fib_entry_delegate_pool, delegate);
108 :
109 11979 : delegate->fd_entry_index = fib_entry_get_index(fib_entry);
110 11979 : delegate->fd_type = type;
111 :
112 11979 : vec_add1(fib_entry->fe_delegates, delegate - fib_entry_delegate_pool);
113 11979 : vec_sort_with_function(fib_entry->fe_delegates,
114 : fib_entry_delegate_cmp_for_sort);
115 11979 : }
116 :
117 : fib_entry_delegate_t *
118 11979 : fib_entry_delegate_find_or_add (fib_entry_t *fib_entry,
119 : fib_entry_delegate_type_t fdt)
120 : {
121 : fib_entry_delegate_t *delegate;
122 :
123 11979 : delegate = fib_entry_delegate_find(fib_entry, fdt);
124 :
125 11979 : if (NULL == delegate)
126 : {
127 11979 : fib_entry_delegate_init(fib_entry, fdt);
128 : }
129 :
130 11979 : return (fib_entry_delegate_find(fib_entry, fdt));
131 : }
132 :
133 : fib_entry_delegate_type_t
134 2912 : fib_entry_chain_type_to_delegate_type (fib_forward_chain_type_t fct)
135 : {
136 2912 : switch (fct)
137 : {
138 21 : case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
139 21 : return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4);
140 8 : case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
141 8 : return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6);
142 1609 : case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
143 1609 : return (FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS);
144 1274 : case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
145 1274 : return (FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS);
146 0 : case FIB_FORW_CHAIN_TYPE_ETHERNET:
147 0 : return (FIB_ENTRY_DELEGATE_CHAIN_ETHERNET);
148 0 : case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
149 : case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
150 : case FIB_FORW_CHAIN_TYPE_BIER:
151 0 : break;
152 0 : case FIB_FORW_CHAIN_TYPE_NSH:
153 0 : return (FIB_ENTRY_DELEGATE_CHAIN_NSH);
154 : }
155 0 : ASSERT(0);
156 0 : return (FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4);
157 : }
158 :
159 : fib_forward_chain_type_t
160 2094 : fib_entry_delegate_type_to_chain_type (fib_entry_delegate_type_t fdt)
161 : {
162 2094 : switch (fdt)
163 : {
164 4 : case FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4:
165 4 : return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
166 0 : case FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6:
167 0 : return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
168 997 : case FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS:
169 997 : return (FIB_FORW_CHAIN_TYPE_MPLS_EOS);
170 1093 : case FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS:
171 1093 : return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
172 0 : case FIB_ENTRY_DELEGATE_CHAIN_ETHERNET:
173 0 : return (FIB_FORW_CHAIN_TYPE_ETHERNET);
174 0 : case FIB_ENTRY_DELEGATE_CHAIN_NSH:
175 0 : return (FIB_FORW_CHAIN_TYPE_NSH);
176 0 : case FIB_ENTRY_DELEGATE_COVERED:
177 : case FIB_ENTRY_DELEGATE_ATTACHED_IMPORT:
178 : case FIB_ENTRY_DELEGATE_ATTACHED_EXPORT:
179 : case FIB_ENTRY_DELEGATE_BFD:
180 : case FIB_ENTRY_DELEGATE_TRACK:
181 0 : break;
182 : }
183 0 : ASSERT(0);
184 0 : return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
185 : }
186 :
187 : /**
188 : * typedef for printing a delegate
189 : */
190 : typedef u8 * (*fib_entry_delegate_format_t)(const fib_entry_delegate_t *fed,
191 : u8 *s);
192 :
193 : /**
194 : * Print a delegate that represents a forwarding chain
195 : */
196 : static u8 *
197 0 : fib_entry_delegate_fmt_fwd_chain (const fib_entry_delegate_t *fed,
198 : u8 *s)
199 : {
200 0 : s = format(s, "%U-chain\n %U",
201 : format_fib_forw_chain_type,
202 0 : fib_entry_delegate_type_to_chain_type(fed->fd_type),
203 : format_dpo_id, &fed->fd_dpo, 2);
204 :
205 0 : return (s);
206 : }
207 :
208 : /**
209 : * Print a delegate that represents cover tracking
210 : */
211 : static u8 *
212 0 : fib_entry_delegate_fmt_covered (const fib_entry_delegate_t *fed,
213 : u8 *s)
214 : {
215 0 : s = format(s, "covered:[");
216 0 : s = fib_node_children_format(fed->fd_list, s);
217 0 : s = format(s, "]");
218 :
219 0 : return (s);
220 : }
221 :
222 : /**
223 : * Print a delegate that represents attached-import tracking
224 : */
225 : static u8 *
226 0 : fib_entry_delegate_fmt_import (const fib_entry_delegate_t *fed,
227 : u8 *s)
228 : {
229 0 : s = format(s, "import:");
230 0 : s = fib_ae_import_format(fed->fd_index, s);
231 :
232 0 : return (s);
233 : }
234 :
235 : /**
236 : * Print a delegate that represents attached-export tracking
237 : */
238 : static u8 *
239 0 : fib_entry_delegate_fmt_export (const fib_entry_delegate_t *fed,
240 : u8 *s)
241 : {
242 0 : s = format(s, "export:");
243 0 : s = fib_ae_export_format(fed->fd_index, s);
244 :
245 0 : return (s);
246 : }
247 :
248 : /**
249 : * Print a delegate that represents BFD tracking
250 : */
251 : static u8 *
252 0 : fib_entry_delegate_fmt_bfd (const fib_entry_delegate_t *fed,
253 : u8 *s)
254 : {
255 0 : s = format(s, "BFD:%d", fed->fd_bfd_state);
256 :
257 0 : return (s);
258 : }
259 :
260 : /**
261 : * Print a delegate that represents tracking
262 : */
263 : static u8 *
264 0 : fib_entry_delegate_fmt_track (const fib_entry_delegate_t *fed,
265 : u8 *s)
266 : {
267 0 : u32 indent = format_get_indent (s);
268 :
269 0 : s = format(s, "track: sibling:%d", fed->fd_track.fedt_sibling);
270 :
271 0 : s = format(s, "\n%UChildren:", format_white_space, indent);
272 0 : s = fib_node_children_format(fed->fd_track.fedt_node.fn_children, s);
273 :
274 0 : return (s);
275 : }
276 :
277 : /**
278 : * A delegate type to formatter map
279 : */
280 : static fib_entry_delegate_format_t fed_formatters[] =
281 : {
282 : [FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP4] = fib_entry_delegate_fmt_fwd_chain,
283 : [FIB_ENTRY_DELEGATE_CHAIN_UNICAST_IP6] = fib_entry_delegate_fmt_fwd_chain,
284 : [FIB_ENTRY_DELEGATE_CHAIN_MPLS_EOS] = fib_entry_delegate_fmt_fwd_chain,
285 : [FIB_ENTRY_DELEGATE_CHAIN_MPLS_NON_EOS] = fib_entry_delegate_fmt_fwd_chain,
286 : [FIB_ENTRY_DELEGATE_CHAIN_ETHERNET] = fib_entry_delegate_fmt_fwd_chain,
287 : [FIB_ENTRY_DELEGATE_CHAIN_NSH] = fib_entry_delegate_fmt_fwd_chain,
288 : [FIB_ENTRY_DELEGATE_COVERED] = fib_entry_delegate_fmt_covered,
289 : [FIB_ENTRY_DELEGATE_ATTACHED_IMPORT] = fib_entry_delegate_fmt_import,
290 : [FIB_ENTRY_DELEGATE_ATTACHED_EXPORT] = fib_entry_delegate_fmt_export,
291 : [FIB_ENTRY_DELEGATE_BFD] = fib_entry_delegate_fmt_bfd,
292 : [FIB_ENTRY_DELEGATE_TRACK] = fib_entry_delegate_fmt_track,
293 : };
294 :
295 : u8 *
296 0 : format_fib_entry_delegate (u8 * s, va_list * args)
297 : {
298 : fib_entry_delegate_t *fed;
299 : index_t fedi;
300 :
301 0 : fedi = va_arg (*args, index_t);
302 0 : fed = fib_entry_delegate_get(fedi);
303 :
304 0 : return (fed_formatters[fed->fd_type](fed, s));
305 : }
306 :
307 : static clib_error_t *
308 1 : show_fib_entry_delegate_command (vlib_main_t * vm,
309 : unformat_input_t * input,
310 : vlib_cli_command_t * cmd)
311 : {
312 : fib_node_index_t fedi;
313 :
314 1 : if (unformat (input, "%d", &fedi))
315 : {
316 : /*
317 : * show one in detail
318 : */
319 0 : if (!pool_is_free_index(fib_entry_delegate_pool, fedi))
320 : {
321 0 : vlib_cli_output (vm, "%d@%U",
322 : fedi,
323 : format_fib_entry_delegate, fedi);
324 : }
325 : else
326 : {
327 0 : vlib_cli_output (vm, "entry %d invalid", fedi);
328 : }
329 : }
330 : else
331 : {
332 : /*
333 : * show all
334 : */
335 1 : vlib_cli_output (vm, "FIB Entry Delegates:");
336 1 : pool_foreach_index (fedi, fib_entry_delegate_pool)
337 : {
338 0 : vlib_cli_output (vm, "%d@%U",
339 : fedi,
340 : format_fib_entry_delegate, fedi);
341 : }
342 : }
343 :
344 1 : return (NULL);
345 : }
346 :
347 285289 : VLIB_CLI_COMMAND (show_fib_entry, static) = {
348 : .path = "show fib entry-delegate",
349 : .function = show_fib_entry_delegate_command,
350 : .short_help = "show fib entry delegate",
351 : };
|
