src/vnet/mfib/ip6_mfib.c

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