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_table.h>
17 : #include <vnet/fib/fib_entry.h>
18 : #include <vnet/fib/ip4_fib.h>
19 :
20 : /*
21 : * A table of prefixes to be added to tables and the sources for them
22 : */
23 : typedef struct ip4_fib_table_special_prefix_t_ {
24 : fib_prefix_t ift_prefix;
25 : fib_source_t ift_source;
26 : fib_entry_flag_t ift_flag;
27 : } ip4_fib_table_special_prefix_t;
28 :
29 : static const ip4_fib_table_special_prefix_t ip4_specials[] = {
30 : {
31 : /* 0.0.0.0/0*/
32 : .ift_prefix = {
33 : .fp_addr = {
34 : .ip4.data_u32 = 0,
35 : },
36 : .fp_len = 0,
37 : .fp_proto = FIB_PROTOCOL_IP4,
38 : },
39 : .ift_source = FIB_SOURCE_DEFAULT_ROUTE,
40 : .ift_flag = FIB_ENTRY_FLAG_DROP,
41 : },
42 : {
43 : /* 0.0.0.0/32*/
44 : .ift_prefix = {
45 : .fp_addr = {
46 : .ip4.data_u32 = 0,
47 : },
48 : .fp_len = 32,
49 : .fp_proto = FIB_PROTOCOL_IP4,
50 : },
51 : .ift_source = FIB_SOURCE_DEFAULT_ROUTE,
52 : .ift_flag = FIB_ENTRY_FLAG_DROP,
53 : },
54 : {
55 : /*
56 : * 240.0.0.0/4
57 : * drop class E
58 : */
59 : .ift_prefix = {
60 : .fp_addr = {
61 : .ip4.data_u32 = 0xf0000000,
62 : },
63 : .fp_len = 4,
64 : .fp_proto = FIB_PROTOCOL_IP4,
65 : },
66 : .ift_source = FIB_SOURCE_SPECIAL,
67 : .ift_flag = FIB_ENTRY_FLAG_DROP,
68 :
69 : },
70 : {
71 : /*
72 : * 224.0.0.0/4
73 : * drop all mcast
74 : */
75 : .ift_prefix = {
76 : .fp_addr = {
77 : .ip4.data_u32 = 0xe0000000,
78 : },
79 : .fp_len = 4,
80 : .fp_proto = FIB_PROTOCOL_IP4,
81 : },
82 : .ift_source = FIB_SOURCE_SPECIAL,
83 : .ift_flag = FIB_ENTRY_FLAG_DROP,
84 : },
85 : {
86 : /*
87 : * 255.255.255.255/32
88 : * drop, but we'll allow it to be usurped by the likes of DHCP
89 : */
90 : .ift_prefix = {
91 : .fp_addr = {
92 : .ip4.data_u32 = 0xffffffff,
93 : },
94 : .fp_len = 32,
95 : .fp_proto = FIB_PROTOCOL_IP4,
96 : },
97 : .ift_source = FIB_SOURCE_DEFAULT_ROUTE,
98 : .ift_flag = FIB_ENTRY_FLAG_DROP,
99 : }
100 : };
101 :
102 : void
103 859 : ip4_fib_hash_load_specials (u32 fib_index)
104 : {
105 : /*
106 : * add the special entries into the new FIB
107 : */
108 : int ii;
109 :
110 5154 : for (ii = 0; ii < ARRAY_LEN(ip4_specials); ii++)
111 : {
112 4295 : fib_prefix_t prefix = ip4_specials[ii].ift_prefix;
113 :
114 4295 : prefix.fp_addr.ip4.data_u32 =
115 4295 : clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
116 :
117 4295 : fib_table_entry_special_add(fib_index,
118 : &prefix,
119 4295 : ip4_specials[ii].ift_source,
120 4295 : ip4_specials[ii].ift_flag);
121 : }
122 859 : }
123 :
124 : void
125 265 : ip4_fib_hash_flush_specials (u32 fib_index)
126 : {
127 : int ii;
128 :
129 : /*
130 : * remove all the specials we added when the table was created.
131 : * In reverse order so the default route is last.
132 : */
133 1590 : for (ii = ARRAY_LEN(ip4_specials) - 1; ii >= 0; ii--)
134 : {
135 1325 : fib_prefix_t prefix = ip4_specials[ii].ift_prefix;
136 :
137 1325 : prefix.fp_addr.ip4.data_u32 =
138 1325 : clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
139 :
140 1325 : fib_table_entry_special_remove(fib_index,
141 : &prefix,
142 1325 : ip4_specials[ii].ift_source);
143 : }
144 265 : }
145 :
146 : static u32
147 859 : ip4_create_fib_with_table_id (u32 table_id,
148 : fib_source_t src)
149 : {
150 : fib_table_t *fib_table;
151 : ip4_fib_t *v4_fib;
152 :
153 859 : pool_get(ip4_main.fibs, fib_table);
154 859 : clib_memset(fib_table, 0, sizeof(*fib_table));
155 :
156 859 : pool_get_aligned(ip4_fibs, v4_fib, CLIB_CACHE_LINE_BYTES);
157 :
158 859 : fib_table->ft_proto = FIB_PROTOCOL_IP4;
159 859 : fib_table->ft_index = (v4_fib - ip4_fibs);
160 :
161 : /*
162 : * It is required that the index of the fib_table_t in its pool
163 : * is the same as the index of the ip4_fib_t in its pool, since the
164 : * rest of the code usues the 'fib_index' to mean either of these
165 : * objects, depending on the context.
166 : */
167 859 : ASSERT(fib_table->ft_index == fib_table - ip4_main.fibs);
168 :
169 859 : hash_set (ip4_main.fib_index_by_table_id, table_id, fib_table->ft_index);
170 :
171 859 : fib_table->ft_table_id =
172 859 : v4_fib->hash.table_id =
173 : table_id;
174 859 : fib_table->ft_flow_hash_config = IP_FLOW_HASH_DEFAULT;
175 :
176 859 : fib_table_lock(fib_table->ft_index, FIB_PROTOCOL_IP4, src);
177 :
178 859 : ip4_fib_table_init(v4_fib);
179 :
180 : /*
181 : * add the special entries into the new FIB
182 : */
183 859 : ip4_fib_hash_load_specials(fib_table - ip4_main.fibs);
184 :
185 859 : return (fib_table->ft_index);
186 : }
187 :
188 : void
189 265 : ip4_fib_table_destroy (u32 fib_index)
190 : {
191 265 : fib_table_t *fib_table = pool_elt_at_index(ip4_main.fibs, fib_index);
192 265 : ip4_fib_t *v4_fib = pool_elt_at_index(ip4_fibs, fib_table->ft_index);
193 : u32 *n_locks;
194 :
195 : /*
196 : * remove all the specials we added when the table was created.
197 : * In reverse order so the default route is last.
198 : */
199 265 : ip4_fib_hash_flush_specials(fib_table - ip4_main.fibs);
200 :
201 : /*
202 : * validate no more routes.
203 : */
204 : #if CLIB_DEBUG > 0
205 265 : if (0 != fib_table->ft_total_route_counts)
206 0 : fib_table_assert_empty(fib_table);
207 : #endif
208 :
209 5873 : vec_foreach(n_locks, fib_table->ft_src_route_counts)
210 : {
211 5608 : ASSERT(0 == *n_locks);
212 : }
213 :
214 265 : if (~0 != fib_table->ft_table_id)
215 : {
216 265 : hash_unset (ip4_main.fib_index_by_table_id, fib_table->ft_table_id);
217 : }
218 :
219 265 : vec_free (fib_table->ft_locks);
220 265 : vec_free(fib_table->ft_src_route_counts);
221 265 : ip4_fib_table_free(v4_fib);
222 :
223 265 : pool_put(ip4_fibs, v4_fib);
224 265 : pool_put(ip4_main.fibs, fib_table);
225 265 : }
226 :
227 :
228 : u32
229 1686 : ip4_fib_table_find_or_create_and_lock (u32 table_id,
230 : fib_source_t src)
231 : {
232 : u32 index;
233 :
234 1686 : index = ip4_fib_index_from_table_id(table_id);
235 1686 : if (~0 == index)
236 859 : return ip4_create_fib_with_table_id(table_id, src);
237 :
238 827 : fib_table_lock(index, FIB_PROTOCOL_IP4, src);
239 :
240 827 : return (index);
241 : }
242 :
243 : u32
244 0 : ip4_fib_table_create_and_lock (fib_source_t src)
245 : {
246 0 : return (ip4_create_fib_with_table_id(~0, src));
247 : }
248 :
249 : u32
250 130263 : ip4_fib_table_get_index_for_sw_if_index (u32 sw_if_index)
251 : {
252 130263 : if (sw_if_index >= vec_len(ip4_main.fib_index_by_sw_if_index))
253 : {
254 : /*
255 : * This is the case for interfaces that are not yet mapped to
256 : * a IP table
257 : */
258 0 : return (~0);
259 : }
260 130236 : return (ip4_main.fib_index_by_sw_if_index[sw_if_index]);
261 : }
262 :
263 :
264 : /**
265 : * Walk show context
266 : */
267 : typedef struct ip4_fib_show_walk_ctx_t_
268 : {
269 : fib_node_index_t *ifsw_indicies;
270 : } ip4_fib_show_walk_ctx_t;
271 :
272 : static fib_table_walk_rc_t
273 3392 : ip4_fib_show_walk_cb (fib_node_index_t fib_entry_index,
274 : void *arg)
275 : {
276 3392 : ip4_fib_show_walk_ctx_t *ctx = arg;
277 :
278 3392 : vec_add1(ctx->ifsw_indicies, fib_entry_index);
279 :
280 3392 : return (FIB_TABLE_WALK_CONTINUE);
281 : }
282 :
283 : static void
284 233 : ip4_fib_table_show_all (ip4_fib_t *fib,
285 : vlib_main_t * vm)
286 : {
287 233 : ip4_fib_show_walk_ctx_t ctx = {
288 : .ifsw_indicies = NULL,
289 : };
290 : fib_node_index_t *fib_entry_index;
291 :
292 233 : ip4_fib_table_walk(fib, ip4_fib_show_walk_cb, &ctx);
293 233 : vec_sort_with_function(ctx.ifsw_indicies,
294 : fib_entry_cmp_for_sort);
295 :
296 3625 : vec_foreach(fib_entry_index, ctx.ifsw_indicies)
297 : {
298 3392 : vlib_cli_output(vm, "%U",
299 : format_fib_entry,
300 : *fib_entry_index,
301 : FIB_ENTRY_FORMAT_BRIEF);
302 : }
303 :
304 233 : vec_free(ctx.ifsw_indicies);
305 233 : }
306 :
307 : static void
308 4 : ip4_fib_table_show_one (ip4_fib_t *fib,
309 : vlib_main_t * vm,
310 : ip4_address_t *address,
311 : u32 mask_len,
312 : int detail)
313 : {
314 4 : vlib_cli_output(vm, "%U",
315 : format_fib_entry,
316 : ip4_fib_table_lookup(fib, address, mask_len),
317 : (detail ?
318 : FIB_ENTRY_FORMAT_DETAIL2 :
319 : FIB_ENTRY_FORMAT_DETAIL));
320 4 : }
321 :
322 : u8 *
323 1 : format_ip4_fib_table_memory (u8 * s, va_list * args)
324 : {
325 1 : s = format(s, "%=30s %=6d\n",
326 : "IPv4 unicast",
327 1 : pool_elts(ip4_main.fibs));
328 1 : return (s);
329 : }
330 :
331 : static clib_error_t *
332 94 : ip4_show_fib (vlib_main_t * vm,
333 : unformat_input_t * input,
334 : vlib_cli_command_t * cmd)
335 : {
336 94 : ip4_main_t * im4 = &ip4_main;
337 : u64 total_mtrie_memory, total_hash_memory;
338 : int verbose, matching, mtrie, memory;
339 : ip4_address_t matching_address;
340 94 : u32 fib_index, matching_mask = 32;
341 94 : int i, table_id = -1, user_fib_index = ~0;
342 94 : int detail = 0;
343 :
344 94 : verbose = 1;
345 94 : matching = mtrie = memory = 0;
346 94 : total_hash_memory = total_mtrie_memory = 0;
347 :
348 99 : while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
349 : {
350 5 : if (unformat (input, "brief") || unformat (input, "summary")
351 5 : || unformat (input, "sum"))
352 0 : verbose = 0;
353 :
354 5 : else if (unformat (input, "detail") || unformat (input, "det"))
355 0 : detail = 1;
356 :
357 5 : else if (unformat (input, "mtrie"))
358 1 : mtrie = 1;
359 :
360 8 : else if (unformat (input, "mem") ||
361 4 : unformat (input, "memory"))
362 0 : memory = 1;
363 :
364 4 : else if (unformat (input, "%U/%d",
365 : unformat_ip4_address, &matching_address, &matching_mask))
366 0 : matching = 1;
367 :
368 4 : else if (unformat (input, "%U", unformat_ip4_address, &matching_address))
369 4 : matching = 1;
370 :
371 0 : else if (unformat (input, "table %d", &table_id))
372 : ;
373 0 : else if (unformat (input, "index %d", &user_fib_index))
374 : ;
375 : else
376 0 : break;
377 : }
378 :
379 332 : pool_foreach_index (fib_index, im4->fibs)
380 : {
381 238 : fib_table_t *fib_table = pool_elt_at_index(im4->fibs, fib_index);
382 238 : ip4_fib_t *fib = pool_elt_at_index(ip4_fibs, fib_table->ft_index);
383 : fib_source_t source;
384 238 : u8 *s = NULL;
385 :
386 238 : if (table_id >= 0 && table_id != (int)fib->hash.table_id)
387 1 : continue;
388 238 : if (user_fib_index != ~0 && user_fib_index != fib_index)
389 0 : continue;
390 :
391 238 : if (memory)
392 : {
393 : uword mtrie_size, hash_size;
394 :
395 :
396 0 : mtrie_size = ip4_mtrie_memory_usage(&fib->mtrie);
397 0 : hash_size = 0;
398 :
399 0 : for (i = 0; i < ARRAY_LEN (fib->hash.fib_entry_by_dst_address); i++)
400 : {
401 0 : uword * hash = fib->hash.fib_entry_by_dst_address[i];
402 0 : if (NULL != hash)
403 : {
404 0 : hash_size += hash_bytes(hash);
405 : }
406 : }
407 :
408 0 : if (verbose)
409 0 : vlib_cli_output (vm, "%U mtrie:%d hash:%d",
410 : format_fib_table_name, fib_index,
411 : FIB_PROTOCOL_IP4,
412 : mtrie_size,
413 : hash_size);
414 0 : total_mtrie_memory += mtrie_size;
415 0 : total_hash_memory += hash_size;
416 0 : continue;
417 : }
418 :
419 476 : s = format(s, "%U, fib_index:%d, flow hash:[%U] epoch:%d flags:%U locks:[",
420 : format_fib_table_name, fib_index,
421 : FIB_PROTOCOL_IP4,
422 : fib_index,
423 : format_ip_flow_hash_config,
424 : fib_table->ft_flow_hash_config,
425 : fib_table->ft_epoch,
426 238 : format_fib_table_flags, fib_table->ft_flags);
427 4611 : vec_foreach_index(source, fib_table->ft_locks)
428 : {
429 4373 : if (0 != fib_table->ft_locks[source])
430 : {
431 464 : s = format(s, "%U:%d, ",
432 : format_fib_source, source,
433 464 : fib_table->ft_locks[source]);
434 : }
435 : }
436 238 : s = format (s, "]");
437 238 : vlib_cli_output (vm, "%v", s);
438 238 : vec_free(s);
439 :
440 : /* Show summary? */
441 238 : if (mtrie)
442 : {
443 1 : vlib_cli_output (vm, "%U", format_ip4_mtrie, &fib->mtrie, verbose);
444 1 : continue;
445 : }
446 237 : if (! verbose)
447 : {
448 0 : vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
449 0 : for (i = 0; i < ARRAY_LEN (fib->hash.fib_entry_by_dst_address); i++)
450 : {
451 0 : uword * hash = fib->hash.fib_entry_by_dst_address[i];
452 0 : uword n_elts = hash_elts (hash);
453 0 : if (n_elts > 0)
454 0 : vlib_cli_output (vm, "%20d%16d", i, n_elts);
455 : }
456 0 : continue;
457 : }
458 :
459 237 : if (!matching)
460 : {
461 233 : ip4_fib_table_show_all(fib, vm);
462 : }
463 : else
464 : {
465 4 : ip4_fib_table_show_one(fib, vm, &matching_address,
466 : matching_mask, detail);
467 : }
468 : }
469 :
470 94 : if (memory)
471 : {
472 0 : vlib_cli_output (vm, "totals: mtrie:%ld hash:%ld all:%ld",
473 : total_mtrie_memory,
474 : total_hash_memory,
475 : total_mtrie_memory + total_hash_memory);
476 : }
477 94 : return 0;
478 : }
479 :
480 : /*?
481 : * This command displays the IPv4 FIB Tables (VRF Tables) and the route
482 : * entries for each table.
483 : *
484 : * @note This command will run for a long time when the FIB tables are
485 : * comprised of millions of entries. For those scenarios, consider displaying
486 : * a single table or summary mode.
487 : *
488 : * @cliexpar
489 : * Example of how to display all the IPv4 FIB tables:
490 : * @cliexstart{show ip fib}
491 : * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
492 : * 0.0.0.0/0
493 : * unicast-ip4-chain
494 : * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
495 : * [0] [@0]: dpo-drop ip6
496 : * 0.0.0.0/32
497 : * unicast-ip4-chain
498 : * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
499 : * [0] [@0]: dpo-drop ip6
500 : * 6.0.1.2/32
501 : * unicast-ip4-chain
502 : * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
503 : * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
504 : * 7.0.0.1/32
505 : * unicast-ip4-chain
506 : * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
507 : * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
508 : * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
509 : * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
510 : * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
511 : * 224.0.0.0/8
512 : * unicast-ip4-chain
513 : * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
514 : * [0] [@0]: dpo-drop ip6
515 : * 240.0.0.0/8
516 : * unicast-ip4-chain
517 : * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
518 : * [0] [@0]: dpo-drop ip6
519 : * 255.255.255.255/32
520 : * unicast-ip4-chain
521 : * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
522 : * [0] [@0]: dpo-drop ip6
523 : * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
524 : * 0.0.0.0/0
525 : * unicast-ip4-chain
526 : * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
527 : * [0] [@0]: dpo-drop ip6
528 : * 0.0.0.0/32
529 : * unicast-ip4-chain
530 : * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
531 : * [0] [@0]: dpo-drop ip6
532 : * 172.16.1.0/24
533 : * unicast-ip4-chain
534 : * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
535 : * [0] [@4]: ipv4-glean: af_packet0
536 : * 172.16.1.1/32
537 : * unicast-ip4-chain
538 : * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
539 : * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
540 : * 172.16.1.2/32
541 : * unicast-ip4-chain
542 : * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
543 : * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
544 : * 172.16.2.0/24
545 : * unicast-ip4-chain
546 : * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
547 : * [0] [@4]: ipv4-glean: af_packet1
548 : * 172.16.2.1/32
549 : * unicast-ip4-chain
550 : * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
551 : * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
552 : * 224.0.0.0/8
553 : * unicast-ip4-chain
554 : * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
555 : * [0] [@0]: dpo-drop ip6
556 : * 240.0.0.0/8
557 : * unicast-ip4-chain
558 : * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
559 : * [0] [@0]: dpo-drop ip6
560 : * 255.255.255.255/32
561 : * unicast-ip4-chain
562 : * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
563 : * [0] [@0]: dpo-drop ip6
564 : * @cliexend
565 : * Example of how to display a single IPv4 FIB table:
566 : * @cliexstart{show ip fib table 7}
567 : * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
568 : * 0.0.0.0/0
569 : * unicast-ip4-chain
570 : * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
571 : * [0] [@0]: dpo-drop ip6
572 : * 0.0.0.0/32
573 : * unicast-ip4-chain
574 : * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
575 : * [0] [@0]: dpo-drop ip6
576 : * 172.16.1.0/24
577 : * unicast-ip4-chain
578 : * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
579 : * [0] [@4]: ipv4-glean: af_packet0
580 : * 172.16.1.1/32
581 : * unicast-ip4-chain
582 : * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
583 : * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
584 : * 172.16.1.2/32
585 : * unicast-ip4-chain
586 : * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
587 : * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
588 : * 172.16.2.0/24
589 : * unicast-ip4-chain
590 : * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
591 : * [0] [@4]: ipv4-glean: af_packet1
592 : * 172.16.2.1/32
593 : * unicast-ip4-chain
594 : * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
595 : * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
596 : * 224.0.0.0/8
597 : * unicast-ip4-chain
598 : * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
599 : * [0] [@0]: dpo-drop ip6
600 : * 240.0.0.0/8
601 : * unicast-ip4-chain
602 : * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
603 : * [0] [@0]: dpo-drop ip6
604 : * 255.255.255.255/32
605 : * unicast-ip4-chain
606 : * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
607 : * [0] [@0]: dpo-drop ip6
608 : * @cliexend
609 : * Example of how to display a summary of all IPv4 FIB tables:
610 : * @cliexstart{show ip fib summary}
611 : * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
612 : * Prefix length Count
613 : * 0 1
614 : * 8 2
615 : * 32 4
616 : * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
617 : * Prefix length Count
618 : * 0 1
619 : * 8 2
620 : * 24 2
621 : * 32 4
622 : * @cliexend
623 : ?*/
624 : /* *INDENT-OFF* */
625 285289 : VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
626 : .path = "show ip fib",
627 : .short_help = "show ip fib [summary] [table <table-id>] [index <fib-id>] [<ip4-addr>[/<mask>]] [mtrie] [detail]",
628 : .function = ip4_show_fib,
629 : };
630 : /* *INDENT-ON* */
|
