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/mfib/ip6_mfib.h>
17 :
18 : #include <vnet/mfib/mfib_table.h>
19 : #include <vnet/mfib/mfib_entry.h>
20 : #include <vnet/fib/ip6_fib.h>
21 :
22 : ip6_mfib_table_instance_t ip6_mfib_table;
23 :
24 : /**
25 : * Key and mask for radix
26 : */
27 : typedef clib_bihash_kv_40_8_t ip6_mfib_key_t;
28 :
29 : static const mfib_prefix_t all_zeros = {
30 : /* (*,*) */
31 : .fp_src_addr = {
32 : .ip6.as_u64 = {0, 0},
33 : },
34 : .fp_grp_addr = {
35 : .ip6.as_u64 = {0, 0},
36 : },
37 : .fp_len = 0,
38 : .fp_proto = FIB_PROTOCOL_IP6,
39 : };
40 :
41 : typedef enum ip6_mfib_special_type_t_ {
42 : IP6_MFIB_SPECIAL_TYPE_NONE,
43 : IP6_MFIB_SPECIAL_TYPE_SOLICITED,
44 : } ip6_mfib_special_type_t;
45 :
46 : typedef struct ip6_mfib_special_t_ {
47 : /**
48 : * @brief solicited or not
49 : */
50 : ip6_mfib_special_type_t ims_type;
51 :
52 : /**
53 : * @brief the Prefix length
54 : */
55 : u8 ims_len;
56 :
57 : /**
58 : * @brief The last byte of the mcast address
59 : */
60 : u8 ims_byte;
61 : /**
62 : * @brief The scope of the address
63 : */
64 : u8 ims_scope;
65 : } ip6_mfib_special_t;
66 :
67 : static const ip6_mfib_special_t ip6_mfib_specials[] =
68 : {
69 : {
70 : /*
71 : * Add ff02::1:ff00:0/104 via local route for all tables.
72 : * This is required for neighbor discovery to work.
73 : */
74 : .ims_type = IP6_MFIB_SPECIAL_TYPE_SOLICITED,
75 : .ims_len = 104,
76 : },
77 : {
78 : /*
79 : * all-routers multicast address
80 : */
81 : .ims_type = IP6_MFIB_SPECIAL_TYPE_NONE,
82 : .ims_scope = IP6_MULTICAST_SCOPE_link_local,
83 : .ims_byte = IP6_MULTICAST_GROUP_ID_all_routers,
84 : .ims_len = 128,
85 : },
86 : {
87 : /*
88 : * all-nodes multicast address
89 : */
90 : .ims_type = IP6_MFIB_SPECIAL_TYPE_NONE,
91 : .ims_scope = IP6_MULTICAST_SCOPE_link_local,
92 : .ims_byte = IP6_MULTICAST_GROUP_ID_all_hosts,
93 : .ims_len = 128,
94 : },
95 : {
96 : /*
97 : * Add all-mldv2 multicast address via local route for all tables
98 : */
99 : .ims_type = IP6_MFIB_SPECIAL_TYPE_NONE,
100 : .ims_len = 128,
101 : .ims_scope = IP6_MULTICAST_SCOPE_link_local,
102 : .ims_byte = IP6_MULTICAST_GROUP_ID_mldv2_routers,
103 : }
104 : };
105 :
106 : #define FOR_EACH_IP6_SPECIAL(_pfx, _body) \
107 : { \
108 : const ip6_mfib_special_t *_spec; \
109 : u8 _ii; \
110 : for (_ii = 0; \
111 : _ii < ARRAY_LEN(ip6_mfib_specials); \
112 : _ii++) \
113 : { \
114 : _spec = &ip6_mfib_specials[_ii]; \
115 : if (IP6_MFIB_SPECIAL_TYPE_SOLICITED == _spec->ims_type) \
116 : { \
117 : ip6_set_solicited_node_multicast_address( \
118 : &(_pfx)->fp_grp_addr.ip6, 0); \
119 : } \
120 : else \
121 : { \
122 : ip6_set_reserved_multicast_address ( \
123 : &(_pfx)->fp_grp_addr.ip6, \
124 : _spec->ims_scope, \
125 : _spec->ims_byte); \
126 : } \
127 : (_pfx)->fp_len = _spec->ims_len; \
128 : do { _body; } while (0); \
129 : } \
130 : }
131 :
132 :
133 : static u32
134 698 : ip6_create_mfib_with_table_id (u32 table_id,
135 : mfib_source_t src)
136 : {
137 : mfib_table_t *mfib_table;
138 698 : mfib_prefix_t pfx = {
139 : .fp_proto = FIB_PROTOCOL_IP6,
140 : };
141 698 : const fib_route_path_t path_for_us = {
142 : .frp_proto = DPO_PROTO_IP6,
143 : .frp_addr = zero_addr,
144 : .frp_sw_if_index = 0xffffffff,
145 : .frp_fib_index = ~0,
146 : .frp_weight = 1,
147 : .frp_flags = FIB_ROUTE_PATH_LOCAL,
148 : .frp_mitf_flags = MFIB_ITF_FLAG_FORWARD,
149 : };
150 :
151 698 : pool_get_aligned(ip6_main.mfibs, mfib_table, CLIB_CACHE_LINE_BYTES);
152 698 : clib_memset(mfib_table, 0, sizeof(*mfib_table));
153 :
154 698 : mfib_table->mft_proto = FIB_PROTOCOL_IP6;
155 698 : mfib_table->mft_index =
156 698 : mfib_table->v6.index =
157 698 : (mfib_table - ip6_main.mfibs);
158 :
159 698 : hash_set (ip6_main.mfib_index_by_table_id,
160 : table_id,
161 : mfib_table->mft_index);
162 :
163 698 : mfib_table->mft_table_id =
164 698 : mfib_table->v6.table_id =
165 : table_id;
166 :
167 698 : mfib_table_lock(mfib_table->mft_index, FIB_PROTOCOL_IP6, src);
168 :
169 : /*
170 : * add the special entries into the new FIB
171 : */
172 698 : mfib_table_entry_update(mfib_table->mft_index,
173 : &all_zeros,
174 : MFIB_SOURCE_DEFAULT_ROUTE,
175 : MFIB_RPF_ID_NONE,
176 : MFIB_ENTRY_FLAG_DROP);
177 :
178 : /*
179 : * Add each of the specials
180 : */
181 3490 : FOR_EACH_IP6_SPECIAL(&pfx,
182 : ({
183 : mfib_table_entry_path_update(mfib_table->mft_index,
184 : &pfx,
185 : MFIB_SOURCE_SPECIAL,
186 : MFIB_ENTRY_FLAG_NONE,
187 : &path_for_us);
188 : }));
189 :
190 698 : return (mfib_table->mft_index);
191 : }
192 :
193 : void
194 115 : ip6_mfib_table_destroy (ip6_mfib_t *mfib)
195 : {
196 115 : mfib_table_t *mfib_table = (mfib_table_t*)mfib;
197 : fib_node_index_t mfei;
198 115 : mfib_prefix_t pfx = {
199 : .fp_proto = FIB_PROTOCOL_IP6,
200 : };
201 115 : const fib_route_path_t path_for_us = {
202 : .frp_proto = DPO_PROTO_IP6,
203 : .frp_addr = zero_addr,
204 : .frp_sw_if_index = 0xffffffff,
205 : .frp_fib_index = ~0,
206 : .frp_weight = 1,
207 : .frp_flags = FIB_ROUTE_PATH_LOCAL,
208 : };
209 :
210 : /*
211 : * remove all the specials we added when the table was created.
212 : */
213 575 : FOR_EACH_IP6_SPECIAL(&pfx,
214 : {
215 : mfib_table_entry_path_remove(mfib_table->mft_index,
216 : &pfx,
217 : MFIB_SOURCE_SPECIAL,
218 : &path_for_us);
219 : });
220 :
221 115 : mfei = mfib_table_lookup_exact_match(mfib_table->mft_index, &all_zeros);
222 115 : mfib_table_entry_delete_index(mfei, MFIB_SOURCE_DEFAULT_ROUTE);
223 :
224 : /*
225 : * validate no more routes.
226 : */
227 115 : ASSERT(0 == mfib_table->mft_total_route_counts);
228 115 : ASSERT(~0 != mfib_table->mft_table_id);
229 :
230 115 : hash_unset (ip6_main.mfib_index_by_table_id, mfib_table->mft_table_id);
231 115 : pool_put(ip6_main.mfibs, mfib_table);
232 115 : }
233 :
234 : void
235 8305 : ip6_mfib_interface_enable_disable (u32 sw_if_index, int is_enable)
236 : {
237 8305 : const fib_route_path_t path = {
238 : .frp_proto = DPO_PROTO_IP6,
239 : .frp_addr = zero_addr,
240 : .frp_sw_if_index = sw_if_index,
241 : .frp_fib_index = ~0,
242 : .frp_weight = 1,
243 : .frp_mitf_flags = MFIB_ITF_FLAG_ACCEPT,
244 : };
245 8305 : mfib_prefix_t pfx = {
246 : .fp_proto = FIB_PROTOCOL_IP6,
247 : };
248 : u32 mfib_index;
249 :
250 8305 : mfib_index = ip6_mfib_table_get_index_for_sw_if_index(sw_if_index);
251 :
252 8305 : if (is_enable)
253 : {
254 10565 : FOR_EACH_IP6_SPECIAL(&pfx,
255 : {
256 : mfib_table_entry_path_update(mfib_index,
257 : &pfx,
258 : MFIB_SOURCE_SPECIAL,
259 : MFIB_ENTRY_FLAG_NONE,
260 : &path);
261 : });
262 : }
263 : else
264 : {
265 30960 : FOR_EACH_IP6_SPECIAL(&pfx,
266 : {
267 : mfib_table_entry_path_remove(mfib_index,
268 : &pfx,
269 : MFIB_SOURCE_SPECIAL,
270 : &path);
271 : });
272 : }
273 8305 : }
274 :
275 : u32
276 770 : ip6_mfib_table_find_or_create_and_lock (u32 table_id,
277 : mfib_source_t src)
278 : {
279 : u32 index;
280 :
281 770 : index = ip6_mfib_index_from_table_id(table_id);
282 770 : if (~0 == index)
283 698 : return ip6_create_mfib_with_table_id(table_id, src);
284 72 : mfib_table_lock(index, FIB_PROTOCOL_IP6, src);
285 :
286 72 : return (index);
287 : }
288 :
289 : u32
290 8313 : ip6_mfib_table_get_index_for_sw_if_index (u32 sw_if_index)
291 : {
292 8313 : if (sw_if_index >= vec_len(ip6_main.mfib_index_by_sw_if_index))
293 : {
294 : /*
295 : * This is the case for interfaces that are not yet mapped to
296 : * a IP table
297 : */
298 0 : return (~0);
299 : }
300 8313 : return (ip6_main.mfib_index_by_sw_if_index[sw_if_index]);
301 : }
302 :
303 : #define IPV6_MFIB_GRP_LEN(_len) \
304 : (_len > 128 ? 128 : _len)
305 :
306 : #define IP6_MFIB_MK_KEY(_mfib, _grp, _src, _len, _key) \
307 : { \
308 : _key.key[0] = (_grp->as_u64[0] & \
309 : ip6_main.fib_masks[IPV6_MFIB_GRP_LEN(_len)].as_u64[0]); \
310 : _key.key[1] = (_grp->as_u64[1] & \
311 : ip6_main.fib_masks[IPV6_MFIB_GRP_LEN(_len)].as_u64[1]); \
312 : if (_len == 256) { \
313 : _key.key[2] = _src->as_u64[0]; \
314 : _key.key[3] = _src->as_u64[1]; \
315 : } else { \
316 : _key.key[2] = 0; \
317 : _key.key[3] = 0; \
318 : } \
319 : _key.key[4] = _mfib->index; \
320 : _key.key[4] = (_key.key[4] << 32) | len; \
321 : }
322 :
323 : /*
324 : * ip6_fib_table_lookup_exact_match
325 : *
326 : * Exact match prefix lookup
327 : */
328 : fib_node_index_t
329 37828 : ip6_mfib_table_lookup_exact_match (const ip6_mfib_t *mfib,
330 : const ip6_address_t *grp,
331 : const ip6_address_t *src,
332 : u32 len)
333 : {
334 : ip6_mfib_key_t key, value;
335 : int rv;
336 :
337 37828 : IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
338 :
339 37828 : rv = clib_bihash_search_inline_2_40_8(&ip6_mfib_table.ip6_mhash,
340 : &key, &value);
341 37828 : if (rv == 0)
342 34112 : return value.value;
343 :
344 3716 : return (FIB_NODE_INDEX_INVALID);
345 : }
346 :
347 : /*
348 : * ip6_fib_table_lookup
349 : *
350 : * Longest prefix match for the forwarding plane (no mask given)
351 : */
352 : fib_node_index_t
353 4109 : ip6_mfib_table_fwd_lookup (const ip6_mfib_t *mfib,
354 : const ip6_address_t *src,
355 : const ip6_address_t *grp)
356 : {
357 : ip6_mfib_table_instance_t *table;
358 : ip6_mfib_key_t key, value;
359 : int i, n, len;
360 : int rv;
361 :
362 4109 : table = &ip6_mfib_table;
363 4109 : n = vec_len (table->prefix_lengths_in_search_order);
364 :
365 9469 : for (i = 0; i < n; i++)
366 : {
367 9469 : len = table->prefix_lengths_in_search_order[i];
368 :
369 9469 : ASSERT(len >= 0 && len <= 256);
370 9469 : IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
371 9469 : rv = clib_bihash_search_inline_2_40_8(&table->ip6_mhash, &key, &value);
372 9469 : if (rv == 0)
373 4109 : return value.value;
374 : }
375 :
376 0 : return (FIB_NODE_INDEX_INVALID);
377 : }
378 :
379 :
380 : fib_node_index_t
381 3712 : ip6_mfib_table_get_less_specific (const ip6_mfib_t *mfib,
382 : const ip6_address_t *src,
383 : const ip6_address_t *grp,
384 : u32 len)
385 : {
386 : u32 mask_len;
387 :
388 : /*
389 : * in the absence of a tree structure for the table that allows for an O(1)
390 : * parent get, a cheeky way to find the cover is to LPM for the prefix with
391 : * mask-1.
392 : * there should always be a cover, though it may be the default route. the
393 : * default route's cover is the default route.
394 : */
395 3712 : if (len == 256)
396 : {
397 : /* go from (S,G) to (*,G*) */
398 7 : mask_len = 128;
399 : }
400 3705 : else if (len != 0)
401 : {
402 3007 : mask_len = len - 1;
403 : }
404 : else
405 : {
406 698 : mask_len = len;
407 : }
408 :
409 3712 : return (ip6_mfib_table_lookup(mfib, src, grp, mask_len));
410 : }
411 :
412 : /*
413 : * ip6_fib_table_lookup
414 : *
415 : * Longest prefix match
416 : */
417 : fib_node_index_t
418 3717 : ip6_mfib_table_lookup (const ip6_mfib_t *mfib,
419 : const ip6_address_t *src,
420 : const ip6_address_t *grp,
421 : u32 len)
422 : {
423 : ip6_mfib_table_instance_t *table;
424 : ip6_mfib_key_t key, value;
425 : int i, n, rv;
426 :
427 3717 : table = &ip6_mfib_table;
428 3717 : n = vec_len (table->prefix_lengths_in_search_order);
429 :
430 : /*
431 : * start search from a mask length same length or shorter.
432 : * we don't want matches longer than the mask passed
433 : */
434 3717 : i = 0;
435 7155 : while (i < n && table->prefix_lengths_in_search_order[i] > len)
436 : {
437 3438 : i++;
438 : }
439 :
440 6034 : for (; i < n; i++)
441 : {
442 6034 : len = table->prefix_lengths_in_search_order[i];
443 :
444 6034 : ASSERT(len <= 256);
445 6034 : IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
446 :
447 6034 : rv = clib_bihash_search_inline_2_40_8(&table->ip6_mhash, &key, &value);
448 6034 : if (rv == 0)
449 3717 : return value.value;
450 : }
451 :
452 0 : return (FIB_NODE_INDEX_INVALID);
453 : }
454 :
455 : static void
456 1742 : compute_prefix_lengths_in_search_order (ip6_mfib_table_instance_t *table)
457 : {
458 : int i;
459 1742 : vec_reset_length (table->prefix_lengths_in_search_order);
460 : /* Note: bitmap reversed so this is in fact a longest prefix match */
461 5262 : clib_bitmap_foreach (i, table->non_empty_dst_address_length_bitmap)
462 : {
463 3520 : vec_add1(table->prefix_lengths_in_search_order, (256 - i));
464 : }
465 1742 : }
466 :
467 : void
468 3708 : ip6_mfib_table_entry_insert (ip6_mfib_t *mfib,
469 : const ip6_address_t *grp,
470 : const ip6_address_t *src,
471 : u32 len,
472 : fib_node_index_t mfib_entry_index)
473 : {
474 : ip6_mfib_table_instance_t *table;
475 : ip6_mfib_key_t key;
476 :
477 3708 : table = &ip6_mfib_table;
478 3708 : IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
479 3708 : key.value = mfib_entry_index;
480 :
481 3708 : clib_bihash_add_del_40_8(&table->ip6_mhash, &key, 1);
482 :
483 3708 : if (0 == table->dst_address_length_refcounts[len]++)
484 : {
485 1734 : table->non_empty_dst_address_length_bitmap =
486 1734 : clib_bitmap_set (table->non_empty_dst_address_length_bitmap,
487 1734 : 256 - len, 1);
488 1734 : compute_prefix_lengths_in_search_order (table);
489 : }
490 3708 : }
491 :
492 : void
493 791 : ip6_mfib_table_entry_remove (ip6_mfib_t *mfib,
494 : const ip6_address_t *grp,
495 : const ip6_address_t *src,
496 : u32 len)
497 : {
498 : ip6_mfib_table_instance_t *table;
499 : ip6_mfib_key_t key;
500 :
501 791 : IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
502 :
503 791 : table = &ip6_mfib_table;
504 791 : clib_bihash_add_del_40_8(&table->ip6_mhash, &key, 0);
505 :
506 791 : ASSERT (table->dst_address_length_refcounts[len] > 0);
507 791 : if (--table->dst_address_length_refcounts[len] == 0)
508 : {
509 8 : table->non_empty_dst_address_length_bitmap =
510 8 : clib_bitmap_set (table->non_empty_dst_address_length_bitmap,
511 8 : 256 - len, 0);
512 8 : compute_prefix_lengths_in_search_order (table);
513 : }
514 791 : }
515 :
516 : static clib_error_t *
517 575 : ip6_mfib_module_init (vlib_main_t * vm)
518 : {
519 575 : return (NULL);
520 : }
521 :
522 86399 : VLIB_INIT_FUNCTION(ip6_mfib_module_init);
523 :
524 : u8 *
525 1 : format_ip6_mfib_table_memory (u8 * s, va_list * args)
526 : {
527 : u64 bytes_inuse;
528 :
529 1 : bytes_inuse = alloc_arena_next(&(ip6_mfib_table.ip6_mhash));
530 :
531 1 : s = format(s, "%=30s %=6d %=12ld\n",
532 : "IPv6 multicast",
533 1 : pool_elts(ip6_main.mfibs),
534 : bytes_inuse);
535 :
536 1 : return (s);
537 : }
538 :
539 : static void
540 0 : ip6_mfib_table_show_one (ip6_mfib_t *mfib,
541 : vlib_main_t * vm,
542 : ip6_address_t *src,
543 : ip6_address_t *grp,
544 : u32 mask_len,
545 : u32 cover)
546 : {
547 0 : if (cover)
548 : {
549 0 : vlib_cli_output(vm, "%U",
550 : format_mfib_entry,
551 : ip6_mfib_table_get_less_specific(mfib, src, grp, mask_len),
552 : MFIB_ENTRY_FORMAT_DETAIL);
553 : }
554 : else
555 : {
556 0 : vlib_cli_output(vm, "%U",
557 : format_mfib_entry,
558 : ip6_mfib_table_lookup(mfib, src, grp, mask_len),
559 : MFIB_ENTRY_FORMAT_DETAIL);
560 : }
561 0 : }
562 :
563 : typedef struct ip6_mfib_show_ctx_t_ {
564 : fib_node_index_t *entries;
565 : } ip6_mfib_show_ctx_t;
566 :
567 :
568 : static walk_rc_t
569 0 : ip6_mfib_table_collect_entries (fib_node_index_t mfei, void *arg)
570 : {
571 0 : ip6_mfib_show_ctx_t *ctx = arg;
572 :
573 0 : vec_add1(ctx->entries, mfei);
574 :
575 0 : return (WALK_CONTINUE);
576 : }
577 :
578 : static void
579 0 : ip6_mfib_table_show_all (ip6_mfib_t *mfib,
580 : vlib_main_t * vm)
581 : {
582 : fib_node_index_t *mfib_entry_index;
583 0 : ip6_mfib_show_ctx_t ctx = {
584 : .entries = NULL,
585 : };
586 :
587 0 : ip6_mfib_table_walk(mfib,
588 : ip6_mfib_table_collect_entries,
589 : &ctx);
590 :
591 0 : vec_sort_with_function(ctx.entries, mfib_entry_cmp_for_sort);
592 :
593 0 : vec_foreach(mfib_entry_index, ctx.entries)
594 : {
595 0 : vlib_cli_output(vm, "%U",
596 : format_mfib_entry,
597 : *mfib_entry_index,
598 : MFIB_ENTRY_FORMAT_BRIEF);
599 : }
600 :
601 0 : vec_free(ctx.entries);
602 0 : }
603 :
604 : /**
605 : * @brief Context when walking the IPv6 table. Since all VRFs are in the
606 : * same hash table, we need to filter only those we need as we walk
607 : */
608 : typedef struct ip6_mfib_walk_ctx_t_
609 : {
610 : u32 i6w_mfib_index;
611 : mfib_table_walk_fn_t i6w_fn;
612 : void *i6w_ctx;
613 : } ip6_mfib_walk_ctx_t;
614 :
615 : static int
616 13384 : ip6_mfib_walk_cb (clib_bihash_kv_40_8_t * kvp,
617 : void *arg)
618 : {
619 13384 : ip6_mfib_walk_ctx_t *ctx = arg;
620 :
621 13384 : if ((kvp->key[4] >> 32) == ctx->i6w_mfib_index)
622 : {
623 3466 : ctx->i6w_fn(kvp->value, ctx->i6w_ctx);
624 : }
625 13384 : return (BIHASH_WALK_CONTINUE);
626 : }
627 :
628 : void
629 468 : ip6_mfib_table_walk (ip6_mfib_t *mfib,
630 : mfib_table_walk_fn_t fn,
631 : void *arg)
632 : {
633 468 : ip6_mfib_walk_ctx_t ctx = {
634 468 : .i6w_mfib_index = mfib->index,
635 : .i6w_fn = fn,
636 : .i6w_ctx = arg,
637 : };
638 :
639 468 : clib_bihash_foreach_key_value_pair_40_8(
640 : &ip6_mfib_table.ip6_mhash,
641 : ip6_mfib_walk_cb,
642 : &ctx);
643 468 : }
644 :
645 : static clib_error_t *
646 0 : ip6_show_mfib (vlib_main_t * vm,
647 : unformat_input_t * input,
648 : vlib_cli_command_t * cmd)
649 : {
650 0 : ip6_main_t * im6 = &ip6_main;
651 : mfib_table_t *mfib_table;
652 : int verbose, matching;
653 0 : ip6_address_t grp, src = {{0}};
654 0 : u32 mask = 128, cover;
655 0 : int table_id = -1, fib_index = ~0;
656 :
657 0 : verbose = 1;
658 0 : matching = 0;
659 0 : cover = 0;
660 :
661 0 : while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
662 : {
663 0 : if (unformat (input, "brief") || unformat (input, "summary")
664 0 : || unformat (input, "sum"))
665 0 : verbose = 0;
666 :
667 0 : else if (unformat (input, "%U %U",
668 : unformat_ip6_address, &src,
669 : unformat_ip6_address, &grp))
670 : {
671 0 : matching = 1;
672 0 : mask = 256;
673 : }
674 0 : else if (unformat (input, "%U/%d", unformat_ip6_address, &grp, &mask))
675 : {
676 0 : clib_memset(&src, 0, sizeof(src));
677 0 : matching = 1;
678 : }
679 0 : else if (unformat (input, "%U", unformat_ip6_address, &grp))
680 : {
681 0 : clib_memset(&src, 0, sizeof(src));
682 0 : matching = 1;
683 0 : mask = 128;
684 : }
685 0 : else if (unformat (input, "table %d", &table_id))
686 : ;
687 0 : else if (unformat (input, "index %d", &fib_index))
688 : ;
689 0 : else if (unformat (input, "cover"))
690 0 : cover = 1;
691 : else
692 0 : break;
693 : }
694 :
695 0 : pool_foreach (mfib_table, im6->mfibs)
696 : {
697 0 : ip6_mfib_t *mfib = &mfib_table->v6;
698 :
699 0 : if (table_id >= 0 && table_id != (int)mfib->table_id)
700 0 : continue;
701 0 : if (fib_index != ~0 && fib_index != (int)mfib->index)
702 0 : continue;
703 :
704 0 : vlib_cli_output (vm, "%U, fib_index %d",
705 : format_mfib_table_name, mfib->index, FIB_PROTOCOL_IP6,
706 : mfib->index);
707 :
708 : /* Show summary? */
709 0 : if (! verbose)
710 : {
711 : /* vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count"); */
712 : /* for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++) */
713 : /* { */
714 : /* uword * hash = mfib->fib_entry_by_dst_address[i]; */
715 : /* uword n_elts = hash_elts (hash); */
716 : /* if (n_elts > 0) */
717 : /* vlib_cli_output (vm, "%20d%16d", i, n_elts); */
718 : /* } */
719 0 : continue;
720 : }
721 :
722 0 : if (!matching)
723 : {
724 0 : ip6_mfib_table_show_all(mfib, vm);
725 : }
726 : else
727 : {
728 0 : ip6_mfib_table_show_one(mfib, vm, &src, &grp, mask, cover);
729 : }
730 : }
731 :
732 0 : return 0;
733 : }
734 :
735 : /* clang-format off */
736 : /*?
737 : * This command displays the IPv6 MulticasrFIB Tables (VRF Tables) and
738 : * the route entries for each table.
739 : *
740 : * @note This command will run for a long time when the FIB tables are
741 : * comprised of millions of entries. For those scenarios, consider displaying
742 : * a single table or summary mode.
743 : *
744 : * @cliexpar
745 : * Example of how to display all the IPv6 Multicast FIB tables:
746 : * @cliexstart{show ip fib}
747 : * ipv6-VRF:0, fib_index 0
748 : * (*, 0.0.0.0/0): flags:D,
749 : * Interfaces:
750 : * multicast-ip6-chain
751 : * [@1]: dpo-drop ip6
752 : * (*, 232.1.1.1/32):
753 : * Interfaces:
754 : * test-eth1: Forward,
755 : * test-eth2: Forward,
756 : * test-eth0: Accept,
757 : * multicast-ip6-chain
758 : * [@2]: dpo-replicate: [index:1 buckets:2 to:[0:0]]
759 : * [0] [@1]: ipv6-mcast: test-eth1: IP6: d0:d1:d2:d3:d4:01 -> 01:00:05:00:00:00
760 : * [1] [@1]: ipv6-mcast: test-eth2: IP6: d0:d1:d2:d3:d4:02 -> 01:00:05:00:00:00
761 : *
762 : * @cliexend
763 : * Example of how to display a summary of all IPv6 FIB tables:
764 : * @cliexstart{show ip fib summary}
765 : * ipv6-VRF:0, fib_index 0, flow hash: src dst sport dport proto
766 : * Prefix length Count
767 : * 0 1
768 : * 8 2
769 : * 32 4
770 : * ipv6-VRF:7, fib_index 1, flow hash: src dst sport dport proto
771 : * Prefix length Count
772 : * 0 1
773 : * 8 2
774 : * 24 2
775 : * 32 4
776 : * @cliexend
777 : ?*/
778 : /* clang-format on */
779 285289 : VLIB_CLI_COMMAND (ip6_show_fib_command, static) = {
780 : .path = "show ip6 mfib",
781 : .short_help = "show ip mfib [summary] [table <table-id>] [index <fib-id>] [<grp-addr>[/<mask>]] [<grp-addr>] [<src-addr> <grp-addr>]",
782 : .function = ip6_show_mfib,
783 : };
784 :
785 : static clib_error_t *
786 575 : ip6_mfib_init (vlib_main_t * vm)
787 : {
788 575 : clib_bihash_init_40_8 (&ip6_mfib_table.ip6_mhash,
789 : "ip6 mFIB table",
790 : IP6_MFIB_DEFAULT_HASH_NUM_BUCKETS,
791 : IP6_MFIB_DEFAULT_HASH_MEMORY_SIZE);
792 :
793 575 : return (NULL);
794 : }
795 :
796 16127 : VLIB_INIT_FUNCTION (ip6_mfib_init) =
797 : {
798 : .runs_before = VLIB_INITS("ip6_lookup_init"),
799 : };
|
