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 = 0,
 145         .frp_flags = FIB_ROUTE_PATH_LOCAL,
 146     };
 147
 148     pool_get_aligned(ip6_main.mfibs, mfib_table, CLIB_CACHE_LINE_BYTES);
 149     clib_memset(mfib_table, 0, sizeof(*mfib_table));
 150
 151     mfib_table->mft_proto = FIB_PROTOCOL_IP6;
 152     mfib_table->mft_index =
 153         mfib_table->v6.index =
 154             (mfib_table - ip6_main.mfibs);
 155
 156     hash_set (ip6_main.mfib_index_by_table_id,
 157               table_id,
 158               mfib_table->mft_index);
 159
 160     mfib_table->mft_table_id =
 161         mfib_table->v6.table_id =
 162             table_id;
 163
 164     mfib_table_lock(mfib_table->mft_index, FIB_PROTOCOL_IP6, src);
 165
 166     /*
 167      * add the special entries into the new FIB
 168      */
 169     mfib_table_entry_update(mfib_table->mft_index,
 170                             &all_zeros,
 171                             MFIB_SOURCE_DEFAULT_ROUTE,
 172                             MFIB_RPF_ID_NONE,
 173                             MFIB_ENTRY_FLAG_DROP);
 174
 175     /*
 176      * Add each of the specials
 177      */
 178     FOR_EACH_IP6_SPECIAL(&pfx,
 179     ({
 180         mfib_table_entry_path_update(mfib_table->mft_index,
 181                                      &pfx,
 182                                      MFIB_SOURCE_SPECIAL,
 183                                      &path_for_us,
 184                                      MFIB_ITF_FLAG_FORWARD);
 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 = 0,
 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 = 0,
 240     };
 241     mfib_prefix_t pfx = {
 242         .fp_proto = FIB_PROTOCOL_IP6,
 243     };
 244     u32 mfib_index;
 245
 246     vec_validate (ip6_main.mfib_index_by_sw_if_index, sw_if_index);
 247     mfib_index = ip6_mfib_table_get_index_for_sw_if_index(sw_if_index);
 248
 249     if (is_enable)
 250     {
 251         FOR_EACH_IP6_SPECIAL(&pfx,
 252         {
 253             mfib_table_entry_path_update(mfib_index,
 254                                          &pfx,
 255                                          MFIB_SOURCE_SPECIAL,
 256                                          &path,
 257                                          MFIB_ITF_FLAG_ACCEPT);
 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
 369         rv = clib_bihash_search_inline_2_40_8(&table->ip6_mhash, &key, &value);
 370         if (rv == 0)
 371             return value.value;
 372     }
 373
 374     return (FIB_NODE_INDEX_INVALID);
 375 }
 376
 377 /*
 378  * ip6_fib_table_lookup
 379  *
 380  * Longest prefix match
 381  */
 382 fib_node_index_t
 383 ip6_mfib_table_lookup (const ip6_mfib_t *mfib,
 384                        const ip6_address_t *src,
 385                        const ip6_address_t *grp,
 386                        u32 len)
 387 {
 388     ip6_mfib_table_instance_t *table;
 389     ip6_mfib_key_t key, value;
 390     int i, n, rv;
 391
 392     table = &ip6_main.ip6_mtable;
 393     n = vec_len (table->prefix_lengths_in_search_order);
 394
 395     /*
 396      * start search from a mask length same length or shorter.
 397      * we don't want matches longer than the mask passed
 398      */
 399     i = 0;
 400     while (i < n && table->prefix_lengths_in_search_order[i] > len)
 401     {
 402         i++;
 403     }
 404
 405     for (; i < n; i++)
 406     {
 407         len = table->prefix_lengths_in_search_order[i];
 408
 409         ASSERT(len >= 0 && len <= 256);
 410         IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
 411
 412         rv = clib_bihash_search_inline_2_40_8(&table->ip6_mhash, &key, &value);
 413         if (rv == 0)
 414             return value.value;
 415     }
 416
 417     return (FIB_NODE_INDEX_INVALID);
 418 }
 419
 420 static void
 421 compute_prefix_lengths_in_search_order (ip6_mfib_table_instance_t *table)
 422 {
 423     int i;
 424     vec_reset_length (table->prefix_lengths_in_search_order);
 425     /* Note: bitmap reversed so this is in fact a longest prefix match */
 426     clib_bitmap_foreach (i, table->non_empty_dst_address_length_bitmap,
 427     ({
 428         vec_add1(table->prefix_lengths_in_search_order, (256 - i));
 429     }));
 430 }
 431
 432 void
 433 ip6_mfib_table_entry_insert (ip6_mfib_t *mfib,
 434                              const ip6_address_t *grp,
 435                              const ip6_address_t *src,
 436                              u32 len,
 437                              fib_node_index_t mfib_entry_index)
 438 {
 439     ip6_mfib_table_instance_t *table;
 440     ip6_mfib_key_t key;
 441
 442     table = &ip6_main.ip6_mtable;
 443     IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
 444     key.value = mfib_entry_index;
 445
 446     clib_bihash_add_del_40_8(&table->ip6_mhash, &key, 1);
 447
 448     if (0 == table->dst_address_length_refcounts[len]++)
 449     {
 450         table->non_empty_dst_address_length_bitmap =
 451             clib_bitmap_set (table->non_empty_dst_address_length_bitmap,
 452                              256 - len, 1);
 453         compute_prefix_lengths_in_search_order (table);
 454     }
 455 }
 456
 457 void
 458 ip6_mfib_table_entry_remove (ip6_mfib_t *mfib,
 459                              const ip6_address_t *grp,
 460                              const ip6_address_t *src,
 461                              u32 len)
 462 {
 463     ip6_mfib_table_instance_t *table;
 464     ip6_mfib_key_t key;
 465
 466     IP6_MFIB_MK_KEY(mfib, grp, src, len, key);
 467
 468     table = &ip6_main.ip6_mtable;
 469     clib_bihash_add_del_40_8(&table->ip6_mhash, &key, 0);
 470
 471     ASSERT (table->dst_address_length_refcounts[len] > 0);
 472     if (--table->dst_address_length_refcounts[len] == 0)
 473     {
 474         table->non_empty_dst_address_length_bitmap =
 475             clib_bitmap_set (table->non_empty_dst_address_length_bitmap,
 476                              256 - len, 0);
 477         compute_prefix_lengths_in_search_order (table);
 478     }
 479 }
 480
 481 static clib_error_t *
 482 ip6_mfib_module_init (vlib_main_t * vm)
 483 {
 484     return (NULL);
 485 }
 486
 487 VLIB_INIT_FUNCTION(ip6_mfib_module_init);
 488
 489 u8 *
 490 format_ip6_mfib_table_memory (u8 * s, va_list * args)
 491 {
 492     s = format(s, "%=30s %=6d %=8s\n",
 493                "IPv6 multicast",
 494                pool_elts(ip6_main.mfibs), "???");
 495
 496     return (s);
 497 }
 498
 499 static void
 500 ip6_mfib_table_show_one (ip6_mfib_t *mfib,
 501                          vlib_main_t * vm,
 502                          ip6_address_t *src,
 503                          ip6_address_t *grp,
 504                          u32 mask_len)
 505 {
 506     vlib_cli_output(vm, "%U",
 507                     format_mfib_entry,
 508                     ip6_mfib_table_lookup(mfib, src, grp, mask_len),
 509                     MFIB_ENTRY_FORMAT_DETAIL);
 510 }
 511
 512 typedef struct ip6_mfib_show_ctx_t_ {
 513     fib_node_index_t *entries;
 514 } ip6_mfib_show_ctx_t;
 515
 516
 517 static int
 518 ip6_mfib_table_collect_entries (fib_node_index_t mfei, void *arg)
 519 {
 520     ip6_mfib_show_ctx_t *ctx = arg;
 521
 522     vec_add1(ctx->entries, mfei);
 523
 524     return (0);
 525 }
 526
 527 static void
 528 ip6_mfib_table_show_all (ip6_mfib_t *mfib,
 529                          vlib_main_t * vm)
 530 {
 531     fib_node_index_t *mfib_entry_index;
 532     ip6_mfib_show_ctx_t ctx = {
 533         .entries = NULL,
 534     };
 535
 536     ip6_mfib_table_walk(mfib,
 537                         ip6_mfib_table_collect_entries,
 538                         &ctx);
 539
 540     vec_sort_with_function(ctx.entries, mfib_entry_cmp_for_sort);
 541
 542     vec_foreach(mfib_entry_index, ctx.entries)
 543     {
 544         vlib_cli_output(vm, "%U",
 545                         format_mfib_entry,
 546                         *mfib_entry_index,
 547                         MFIB_ENTRY_FORMAT_BRIEF);
 548     }
 549
 550     vec_free(ctx.entries);
 551 }
 552
 553 /**
 554  * @brief Context when walking the IPv6 table. Since all VRFs are in the
 555  * same hash table, we need to filter only those we need as we walk
 556  */
 557 typedef struct ip6_mfib_walk_ctx_t_
 558 {
 559     u32 i6w_mfib_index;
 560     mfib_table_walk_fn_t i6w_fn;
 561     void *i6w_ctx;
 562 } ip6_mfib_walk_ctx_t;
 563
 564 static int
 565 ip6_mfib_walk_cb (clib_bihash_kv_40_8_t * kvp,
 566                  void *arg)
 567 {
 568     ip6_mfib_walk_ctx_t *ctx = arg;
 569
 570     if ((kvp->key[4] >> 32) == ctx->i6w_mfib_index)
 571     {
 572         return (ctx->i6w_fn(kvp->value, ctx->i6w_ctx));
 573     }
 574     return (FIB_TABLE_WALK_CONTINUE);
 575 }
 576
 577 void
 578 ip6_mfib_table_walk (ip6_mfib_t *mfib,
 579                      mfib_table_walk_fn_t fn,
 580                      void *arg)
 581 {
 582     ip6_mfib_walk_ctx_t ctx = {
 583         .i6w_mfib_index = mfib->index,
 584         .i6w_fn = fn,
 585         .i6w_ctx = arg,
 586     };
 587
 588     clib_bihash_foreach_key_value_pair_40_8(
 589         &ip6_main.ip6_mtable.ip6_mhash,
 590         ip6_mfib_walk_cb,
 591         &ctx);
 592 }
 593
 594 static clib_error_t *
 595 ip6_show_mfib (vlib_main_t * vm,
 596                unformat_input_t * input,
 597                vlib_cli_command_t * cmd)
 598 {
 599     ip6_main_t * im6 = &ip6_main;
 600     mfib_table_t *mfib_table;
 601     int verbose, matching;
 602     ip6_address_t grp, src = {{0}};
 603     u32 mask = 32;
 604     int table_id = -1, fib_index = ~0;
 605
 606     verbose = 1;
 607     matching = 0;
 608
 609     while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 610     {
 611         if (unformat (input, "brief") || unformat (input, "summary")
 612             || unformat (input, "sum"))
 613             verbose = 0;
 614
 615         else if (unformat (input, "%U %U",
 616                            unformat_ip6_address, &src,
 617                            unformat_ip6_address, &grp))
 618         {
 619             matching = 1;
 620             mask = 256;
 621         }
 622         else if (unformat (input, "%U/%d", unformat_ip6_address, &grp, &mask))
 623         {
 624             clib_memset(&src, 0, sizeof(src));
 625             matching = 1;
 626         }
 627         else if (unformat (input, "%U", unformat_ip6_address, &grp))
 628         {
 629             clib_memset(&src, 0, sizeof(src));
 630             matching = 1;
 631             mask = 128;
 632         }
 633         else if (unformat (input, "table %d", &table_id))
 634             ;
 635         else if (unformat (input, "index %d", &fib_index))
 636             ;
 637         else
 638             break;
 639     }
 640
 641     pool_foreach (mfib_table, im6->mfibs,
 642     ({
 643         ip6_mfib_t *mfib = &mfib_table->v6;
 644
 645         if (table_id >= 0 && table_id != (int)mfib->table_id)
 646             continue;
 647         if (fib_index != ~0 && fib_index != (int)mfib->index)
 648             continue;
 649
 650         vlib_cli_output (vm, "%U, fib_index %d",
 651                          format_mfib_table_name, mfib->index, FIB_PROTOCOL_IP6,
 652                          mfib->index);
 653
 654         /* Show summary? */
 655         if (! verbose)
 656         {
 657             /* vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count"); */
 658             /* for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++) */
 659             /* { */
 660             /*     uword * hash = mfib->fib_entry_by_dst_address[i]; */
 661             /*     uword n_elts = hash_elts (hash); */
 662             /*     if (n_elts > 0) */
 663             /*         vlib_cli_output (vm, "%20d%16d", i, n_elts); */
 664             /* } */
 665             continue;
 666         }
 667
 668         if (!matching)
 669         {
 670             ip6_mfib_table_show_all(mfib, vm);
 671         }
 672         else
 673         {
 674             ip6_mfib_table_show_one(mfib, vm, &src, &grp, mask);
 675         }
 676     }));
 677
 678     return 0;
 679 }
 680
 681 /*
 682  * This command displays the IPv6 MulticasrFIB Tables (VRF Tables) and
 683  * the route entries for each table.
 684  *
 685  * @note This command will run for a long time when the FIB tables are
 686  * comprised of millions of entries. For those senarios, consider displaying
 687  * a single table or summary mode.
 688  *
 689  * @cliexpar
 690  * Example of how to display all the IPv6 Multicast FIB tables:
 691  * @cliexstart{show ip fib}
 692  * ipv6-VRF:0, fib_index 0
 693  * (*, 0.0.0.0/0):  flags:D,
 694  *  Interfaces:
 695  *  multicast-ip6-chain
 696  *   [@1]: dpo-drop ip6
 697  * (*, 232.1.1.1/32):
 698  * Interfaces:
 699  *  test-eth1: Forward,
 700  *  test-eth2: Forward,
 701  *  test-eth0: Accept,
 702  * multicast-ip6-chain
 703  * [@2]: dpo-replicate: [index:1 buckets:2 to:[0:0]]
 704  *   [0] [@1]: ipv6-mcast: test-eth1: IP6: d0:d1:d2:d3:d4:01 -> 01:00:05:00:00:00
 705  *   [1] [@1]: ipv6-mcast: test-eth2: IP6: d0:d1:d2:d3:d4:02 -> 01:00:05:00:00:00
 706  *
 707  * @cliexend
 708  * Example of how to display a summary of all IPv6 FIB tables:
 709  * @cliexstart{show ip fib summary}
 710  * ipv6-VRF:0, fib_index 0, flow hash: src dst sport dport proto
 711  *     Prefix length         Count
 712  *                    0               1
 713  *                    8               2
 714  *                   32               4
 715  * ipv6-VRF:7, fib_index 1, flow hash: src dst sport dport proto
 716  *     Prefix length         Count
 717  *                    0               1
 718  *                    8               2
 719  *                   24               2
 720  *                   32               4
 721  * @cliexend
 722  */
 723 /* *INDENT-OFF* */
 724 VLIB_CLI_COMMAND (ip6_show_fib_command, static) = {
 725     .path = "show ip6 mfib",
 726     .short_help = "show ip mfib [summary] [table <table-id>] [index <fib-id>] [<grp-addr>[/<mask>]] [<grp-addr>] [<src-addr> <grp-addr>]",
 727     .function = ip6_show_mfib,
 728 };
 729 /* *INDENT-ON* */