vnet/vnet/fib/fib_entry_src.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/adj/adj.h>
  17 #include <vnet/dpo/load_balance.h>
  18 #include <vnet/dpo/mpls_label_dpo.h>
  19 #include <vnet/dpo/drop_dpo.h>
  20
  21 #include <vnet/fib/fib_entry_src.h>
  22 #include <vnet/fib/fib_table.h>
  23 #include <vnet/fib/fib_path_ext.h>
  24 #include <vnet/fib/fib_urpf_list.h>
  25
  26 /*
  27  * per-source type vft
  28  */
  29 static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX];
  30
  31 static fib_protocol_t
  32 fib_entry_get_proto (const fib_entry_t * fib_entry)
  33 {
  34     return (fib_entry->fe_prefix.fp_proto);
  35 }
  36
  37 void
  38 fib_entry_src_register (fib_source_t source,
  39                         const fib_entry_src_vft_t *vft)
  40 {
  41     fib_entry_src_vft[source] = *vft;
  42 }
  43
  44 static int
  45 fib_entry_src_cmp_for_sort (void * v1,
  46                             void * v2)
  47 {
  48     fib_entry_src_t *esrc1 = v1, *esrc2 = v2;
  49
  50     return (esrc1->fes_src - esrc2->fes_src);
  51 }
  52
  53 void
  54 fib_entry_src_action_init (fib_entry_t *fib_entry,
  55                            fib_source_t source)
  56
  57 {
  58     fib_entry_src_t esrc = {
  59         .fes_pl = FIB_NODE_INDEX_INVALID,
  60         .fes_flags = FIB_ENTRY_SRC_FLAG_NONE,
  61         .fes_src = source,
  62     };
  63
  64     if (NULL != fib_entry_src_vft[source].fesv_init)
  65     {
  66         fib_entry_src_vft[source].fesv_init(&esrc);
  67     }
  68
  69     vec_add1(fib_entry->fe_srcs, esrc);
  70     vec_sort_with_function(fib_entry->fe_srcs,
  71                            fib_entry_src_cmp_for_sort);
  72 }
  73
  74 static fib_entry_src_t *
  75 fib_entry_src_find (const fib_entry_t *fib_entry,
  76                     fib_source_t source,
  77                     u32 *index)
  78
  79 {
  80     fib_entry_src_t *esrc;
  81     int ii;
  82
  83     ii = 0;
  84     vec_foreach(esrc, fib_entry->fe_srcs)
  85     {
  86         if (esrc->fes_src == source)
  87         {
  88             if (NULL != index)
  89             {
  90                 *index = ii;
  91             }
  92             return (esrc);
  93         }
  94         else
  95         {
  96             ii++;
  97         }
  98     }
  99
 100     return (NULL);
 101 }
 102
 103 int
 104 fib_entry_is_sourced (fib_node_index_t fib_entry_index,
 105                       fib_source_t source)
 106 {
 107     fib_entry_t *fib_entry;
 108
 109     fib_entry = fib_entry_get(fib_entry_index);
 110
 111     return (NULL != fib_entry_src_find(fib_entry, source, NULL));
 112 }
 113
 114 static fib_entry_src_t *
 115 fib_entry_src_find_or_create (fib_entry_t *fib_entry,
 116                               fib_source_t source,
 117                               u32 *index)
 118 {
 119     fib_entry_src_t *esrc;
 120
 121     esrc = fib_entry_src_find(fib_entry, source, NULL);
 122
 123     if (NULL == esrc)
 124     {
 125         fib_entry_src_action_init(fib_entry, source);
 126     }
 127
 128     return (fib_entry_src_find(fib_entry, source, NULL));
 129 }
 130
 131 void
 132 fib_entry_src_action_deinit (fib_entry_t *fib_entry,
 133                              fib_source_t source)
 134
 135 {
 136     fib_entry_src_t *esrc;
 137     u32 index = ~0;
 138
 139     esrc = fib_entry_src_find(fib_entry, source, &index);
 140
 141     ASSERT(NULL != esrc);
 142
 143     if (NULL != fib_entry_src_vft[source].fesv_deinit)
 144     {
 145         fib_entry_src_vft[source].fesv_deinit(esrc);
 146     }
 147
 148     vec_free(esrc->fes_path_exts);
 149     vec_del1(fib_entry->fe_srcs, index);
 150 }
 151
 152 fib_entry_src_cover_res_t
 153 fib_entry_src_action_cover_change (fib_entry_t *fib_entry,
 154                                    fib_source_t source)
 155 {
 156     if (NULL != fib_entry_src_vft[source].fesv_cover_change)
 157     {
 158         return (fib_entry_src_vft[source].fesv_cover_change(
 159                     fib_entry_src_find(fib_entry, source, NULL),
 160                     fib_entry));
 161     }
 162
 163     fib_entry_src_cover_res_t res = {
 164         .install = !0,
 165         .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
 166     };
 167     return (res);
 168 }
 169
 170 fib_entry_src_cover_res_t
 171 fib_entry_src_action_cover_update (fib_entry_t *fib_entry,
 172                                    fib_source_t source)
 173 {
 174     if (NULL != fib_entry_src_vft[source].fesv_cover_update)
 175     {
 176         return (fib_entry_src_vft[source].fesv_cover_update(
 177                     fib_entry_src_find(fib_entry, source, NULL),
 178                     fib_entry));
 179     }
 180
 181     fib_entry_src_cover_res_t res = {
 182         .install = !0,
 183         .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
 184     };
 185     return (res);
 186 }
 187
 188 typedef struct fib_entry_src_collect_forwarding_ctx_t_
 189 {
 190     load_balance_path_t * next_hops;
 191     const fib_entry_t *fib_entry;
 192     const fib_entry_src_t *esrc;
 193     fib_forward_chain_type_t fct;
 194     int is_recursive;
 195 } fib_entry_src_collect_forwarding_ctx_t;
 196
 197 /**
 198  * @brief Determine whether this FIB entry should use a load-balance MAP
 199  * to support PIC edge fast convergence
 200  */
 201 load_balance_flags_t
 202 fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx)
 203 {
 204     /**
 205      * We'll use a LB map is the path-list has recursive paths.
 206      * recursive paths implies BGP, and hence scale.
 207      */
 208     if (ctx->is_recursive)
 209     {
 210         return (LOAD_BALANCE_FLAG_USES_MAP);
 211     }
 212     return (LOAD_BALANCE_FLAG_NONE);
 213 }
 214
 215 static int
 216 fib_entry_src_valid_out_label (mpls_label_t label)
 217 {
 218     return ((MPLS_LABEL_IS_REAL(label) ||
 219              MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL == label ||
 220              MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL == label ||
 221              MPLS_IETF_IMPLICIT_NULL_LABEL == label));
 222 }
 223
 224 static int
 225 fib_entry_src_collect_forwarding (fib_node_index_t pl_index,
 226                                   fib_node_index_t path_index,
 227                                   void *arg)
 228 {
 229     fib_entry_src_collect_forwarding_ctx_t *ctx;
 230     fib_path_ext_t *path_ext;
 231
 232     ctx = arg;
 233
 234     /*
 235      * if the path is not resolved, don't include it.
 236      */
 237     if (!fib_path_is_resolved(path_index))
 238     {
 239         return (!0);
 240     }
 241
 242     if (fib_path_is_recursive(path_index))
 243     {
 244         ctx->is_recursive = 1;
 245     }
 246
 247     /*
 248      * get the matching path-extension for the path being visited.
 249      */
 250     vec_foreach(path_ext, ctx->esrc->fes_path_exts)
 251     {
 252         if (path_ext->fpe_path_index == path_index)
 253             break;
 254     }
 255
 256     if (NULL != path_ext &&
 257         path_ext->fpe_path_index == path_index &&
 258         fib_entry_src_valid_out_label(path_ext->fpe_label))
 259     {
 260         /*
 261          * found a matching extension. stack it to obtain the forwarding
 262          * info for this path.
 263          */
 264         ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fct, ctx->next_hops);
 265     }
 266     else
 267     {
 268         load_balance_path_t *nh;
 269
 270         /*
 271          * no extension => no out-going label for this path. that's OK
 272          * in the case of an IP or EOS chain, but not for non-EOS
 273          */
 274         switch (ctx->fct)
 275         {
 276         case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
 277         case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
 278             /*
 279              * EOS traffic with no label to stack, we need the IP Adj
 280              */
 281             vec_add2(ctx->next_hops, nh, 1);
 282
 283             nh->path_index = path_index;
 284             nh->path_weight = fib_path_get_weight(path_index);
 285             fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo);
 286
 287             break;
 288         case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
 289             if (fib_path_is_exclusive(path_index) ||
 290                 fib_path_is_deag(path_index))
 291             {
 292                 vec_add2(ctx->next_hops, nh, 1);
 293
 294                 nh->path_index = path_index;
 295                 nh->path_weight = fib_path_get_weight(path_index);
 296                 fib_path_contribute_forwarding(path_index,
 297                                                FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
 298                                                &nh->path_dpo);
 299             }
 300             break;
 301         case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
 302         case FIB_FORW_CHAIN_TYPE_ETHERNET:
 303             ASSERT(0);
 304             break;
 305         }
 306     }
 307
 308     return (!0);
 309 }
 310
 311 void
 312 fib_entry_src_mk_lb (fib_entry_t *fib_entry,
 313                      const fib_entry_src_t *esrc,
 314                      fib_forward_chain_type_t fct,
 315                      dpo_id_t *dpo_lb)
 316 {
 317     dpo_proto_t lb_proto;
 318
 319     /*
 320      * If the entry has path extensions then we construct a load-balance
 321      * by stacking the extensions on the forwarding chains of the paths.
 322      * Otherwise we use the load-balance of the path-list
 323      */
 324     fib_entry_src_collect_forwarding_ctx_t ctx = {
 325         .esrc = esrc,
 326         .fib_entry = fib_entry,
 327         .next_hops = NULL,
 328         .is_recursive = 0,
 329         .fct = fct,
 330     };
 331
 332     lb_proto = fib_proto_to_dpo(fib_entry->fe_prefix.fp_proto);
 333
 334     fib_path_list_walk(esrc->fes_pl,
 335                        fib_entry_src_collect_forwarding,
 336                        &ctx);
 337
 338     if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_EXCLUSIVE)
 339     {
 340         /*
 341          * the client provided the DPO that the entry should link to.
 342          * all entries must link to a LB, so if it is an LB already
 343          * then we can use it.
 344          */
 345         if ((1 == vec_len(ctx.next_hops)) &&
 346             (DPO_LOAD_BALANCE == ctx.next_hops[0].path_dpo.dpoi_type))
 347         {
 348             dpo_copy(dpo_lb, &ctx.next_hops[0].path_dpo);
 349             dpo_reset(&ctx.next_hops[0].path_dpo);
 350             return;
 351         }
 352     }
 353
 354     if (!dpo_id_is_valid(dpo_lb))
 355     {
 356         /*
 357          * first time create
 358          */
 359         flow_hash_config_t fhc;
 360
 361         fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index,
 362                                              dpo_proto_to_fib(lb_proto));
 363         dpo_set(dpo_lb,
 364                 DPO_LOAD_BALANCE,
 365                 lb_proto,
 366                 load_balance_create(0, lb_proto, fhc));
 367     }
 368
 369     load_balance_multipath_update(dpo_lb,
 370                                   ctx.next_hops,
 371                                   fib_entry_calc_lb_flags(&ctx));
 372     vec_free(ctx.next_hops);
 373
 374     /*
 375      * if this entry is sourced by the uRPF-exempt source then we
 376      * append the always present local0 interface (index 0) to the
 377      * uRPF list so it is not empty. that way packets pass the loose check.
 378      */
 379     index_t ui = fib_path_list_get_urpf(esrc->fes_pl);
 380
 381     if (fib_entry_is_sourced(fib_entry_get_index(fib_entry),
 382                              FIB_SOURCE_URPF_EXEMPT) &&
 383         (0 == fib_urpf_check_size(ui)))
 384     {
 385         /*
 386          * The uRPF list we get from the path-list is shared by all
 387          * other users of the list, but the uRPF exemption applies
 388          * only to this prefix. So we need our own list.
 389          */
 390         ui = fib_urpf_list_alloc_and_lock();
 391         fib_urpf_list_append(ui, 0);
 392         fib_urpf_list_bake(ui);
 393         load_balance_set_urpf(dpo_lb->dpoi_index, ui);
 394         fib_urpf_list_unlock(ui);
 395     }
 396     else
 397     {
 398         load_balance_set_urpf(dpo_lb->dpoi_index, ui);
 399     }
 400 }
 401
 402 void
 403 fib_entry_src_action_install (fib_entry_t *fib_entry,
 404                               fib_source_t source)
 405 {
 406     /*
 407      * Install the forwarding chain for the given source into the forwarding
 408      * tables
 409      */
 410     fib_forward_chain_type_t fct;
 411     fib_entry_src_t *esrc;
 412     int insert;
 413
 414     fct = fib_entry_get_default_chain_type(fib_entry);
 415     esrc = fib_entry_src_find(fib_entry, source, NULL);
 416
 417     /*
 418      * Every entry has its own load-balance object. All changes to the entry's
 419      * forwarding result in an inplace modify of the load-balance. This means
 420      * the load-balance object only needs to be added to the forwarding
 421      * DB once, when it is created.
 422      */
 423     insert = !dpo_id_is_valid(&fib_entry->fe_lb[fct]);
 424
 425     fib_entry_src_mk_lb(fib_entry, esrc, fct, &fib_entry->fe_lb[fct]);
 426
 427     ASSERT(dpo_id_is_valid(&fib_entry->fe_lb[fct]));
 428     FIB_ENTRY_DBG(fib_entry, "install: %d", fib_entry->fe_lb[fct]);
 429
 430     /*
 431      * insert the adj into the data-plane forwarding trie
 432      */
 433     if (insert)
 434     {
 435        fib_table_fwding_dpo_update(fib_entry->fe_fib_index,
 436                                    &fib_entry->fe_prefix,
 437                                    &fib_entry->fe_lb[fct]);
 438     }
 439
 440     if (FIB_FORW_CHAIN_TYPE_UNICAST_IP4 == fct ||
 441         FIB_FORW_CHAIN_TYPE_UNICAST_IP6 == fct)
 442     {
 443         for (fct = FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS;
 444              fct <= FIB_FORW_CHAIN_TYPE_MPLS_EOS;
 445              fct++)
 446         {
 447             /*
 448              * if any of the other chain types are already created they will need
 449              * updating too
 450              */
 451             if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
 452             {
 453                 fib_entry_src_mk_lb(fib_entry,
 454                                     esrc,
 455                                     fct,
 456                                     &fib_entry->fe_lb[fct]);
 457             }
 458         }
 459     }
 460 }
 461
 462 void
 463 fib_entry_src_action_uninstall (fib_entry_t *fib_entry)
 464 {
 465     fib_forward_chain_type_t fct;
 466
 467     fct = fib_entry_get_default_chain_type(fib_entry);
 468     /*
 469      * uninstall the forwarding chain from the forwarding tables
 470      */
 471     FIB_ENTRY_DBG(fib_entry, "uninstall: %d",
 472                   fib_entry->fe_adj_index);
 473
 474     if (dpo_id_is_valid(&fib_entry->fe_lb[fct]))
 475     {
 476         fib_table_fwding_dpo_remove(
 477             fib_entry->fe_fib_index,
 478             &fib_entry->fe_prefix,
 479             &fib_entry->fe_lb[fct]);
 480
 481         dpo_reset(&fib_entry->fe_lb[fct]);
 482     }
 483 }
 484
 485 static void
 486 fib_entry_recursive_loop_detect_i (fib_node_index_t path_list_index)
 487 {
 488     fib_node_index_t *entries = NULL;
 489
 490     fib_path_list_recursive_loop_detect(path_list_index, &entries);
 491
 492     vec_free(entries);
 493 }
 494
 495 void
 496 fib_entry_src_action_activate (fib_entry_t *fib_entry,
 497                                fib_source_t source)
 498
 499 {
 500     int houston_we_are_go_for_install;
 501     fib_entry_src_t *esrc;
 502
 503     esrc = fib_entry_src_find(fib_entry, source, NULL);
 504
 505     ASSERT(!(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE));
 506     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
 507
 508     esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ACTIVE;
 509
 510     if (NULL != fib_entry_src_vft[source].fesv_activate)
 511     {
 512         houston_we_are_go_for_install =
 513             fib_entry_src_vft[source].fesv_activate(esrc, fib_entry);
 514     }
 515     else
 516     {
 517         /*
 518          * the source is not providing an activate function, we'll assume
 519          * therefore it has no objection to installing the entry
 520          */
 521         houston_we_are_go_for_install = !0;
 522     }
 523
 524     /*
 525      * link to the path-list provided by the source, and go check
 526      * if that forms any loops in the graph.
 527      */
 528     fib_entry->fe_parent = esrc->fes_pl;
 529     fib_entry->fe_sibling =
 530         fib_path_list_child_add(fib_entry->fe_parent,
 531                                 FIB_NODE_TYPE_ENTRY,
 532                                 fib_entry_get_index(fib_entry));
 533
 534     fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
 535
 536     FIB_ENTRY_DBG(fib_entry, "activate: %d",
 537                   fib_entry->fe_parent);
 538
 539     if (0 != houston_we_are_go_for_install)
 540     {
 541         fib_entry_src_action_install(fib_entry, source);
 542     }
 543     else
 544     {
 545         fib_entry_src_action_uninstall(fib_entry);
 546     }
 547 }
 548
 549 void
 550 fib_entry_src_action_deactivate (fib_entry_t *fib_entry,
 551                                  fib_source_t source)
 552
 553 {
 554     fib_node_index_t path_list_index;
 555     fib_entry_src_t *esrc;
 556
 557     esrc = fib_entry_src_find(fib_entry, source, NULL);
 558
 559     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
 560
 561     if (NULL != fib_entry_src_vft[source].fesv_deactivate)
 562     {
 563         fib_entry_src_vft[source].fesv_deactivate(esrc, fib_entry);
 564     }
 565
 566     esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_ACTIVE;
 567
 568     FIB_ENTRY_DBG(fib_entry, "deactivate: %d", fib_entry->fe_parent);
 569
 570     /*
 571      * un-link from an old path-list. Check for any loops this will clear
 572      */
 573     path_list_index = fib_entry->fe_parent;
 574     fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
 575
 576     fib_entry_recursive_loop_detect_i(path_list_index);
 577
 578     /*
 579      * this will unlock the path-list, so it may be invalid thereafter.
 580      */
 581     fib_path_list_child_remove(path_list_index, fib_entry->fe_sibling);
 582     fib_entry->fe_sibling = FIB_NODE_INDEX_INVALID;
 583 }
 584
 585 static void
 586 fib_entry_src_action_fwd_update (const fib_entry_t *fib_entry,
 587                                  fib_source_t source)
 588 {
 589     fib_entry_src_t *esrc;
 590
 591     vec_foreach(esrc, fib_entry->fe_srcs)
 592     {
 593         if (NULL != fib_entry_src_vft[esrc->fes_src].fesv_fwd_update)
 594         {
 595             fib_entry_src_vft[esrc->fes_src].fesv_fwd_update(esrc,
 596                                                              fib_entry,
 597                                                              source);
 598         }
 599     }
 600 }
 601
 602 void
 603 fib_entry_src_action_reactivate (fib_entry_t *fib_entry,
 604                                  fib_source_t source)
 605 {
 606     fib_node_index_t path_list_index;
 607     fib_entry_src_t *esrc;
 608
 609     esrc = fib_entry_src_find(fib_entry, source, NULL);
 610
 611     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE);
 612
 613     FIB_ENTRY_DBG(fib_entry, "reactivate: %d to %d",
 614                   fib_entry->fe_parent,
 615                   esrc->fes_pl);
 616
 617     if (fib_entry->fe_parent != esrc->fes_pl)
 618     {
 619         /*
 620          * un-link from an old path-list. Check for any loops this will clear
 621          */
 622         path_list_index = fib_entry->fe_parent;
 623         fib_entry->fe_parent = FIB_NODE_INDEX_INVALID;
 624
 625         /*
 626          * temporary lock so it doesn't get deleted when this entry is no
 627          * longer a child.
 628          */
 629         fib_path_list_lock(path_list_index);
 630
 631         /*
 632          * this entry is no longer a child. after unlinking check if any loops
 633          * were broken
 634          */
 635         fib_path_list_child_remove(path_list_index,
 636                                    fib_entry->fe_sibling);
 637
 638         fib_entry_recursive_loop_detect_i(path_list_index);
 639
 640         /*
 641          * link to the path-list provided by the source, and go check
 642          * if that forms any loops in the graph.
 643          */
 644         fib_entry->fe_parent = esrc->fes_pl;
 645         fib_entry->fe_sibling =
 646             fib_path_list_child_add(fib_entry->fe_parent,
 647                                     FIB_NODE_TYPE_ENTRY,
 648                                     fib_entry_get_index(fib_entry));
 649
 650         fib_entry_recursive_loop_detect_i(fib_entry->fe_parent);
 651         fib_path_list_unlock(path_list_index);
 652     }
 653     fib_entry_src_action_install(fib_entry, source);
 654     fib_entry_src_action_fwd_update(fib_entry, source);
 655 }
 656
 657 void
 658 fib_entry_src_action_installed (const fib_entry_t *fib_entry,
 659                                 fib_source_t source)
 660 {
 661     fib_entry_src_t *esrc;
 662
 663     esrc = fib_entry_src_find(fib_entry, source, NULL);
 664
 665     if (NULL != fib_entry_src_vft[source].fesv_installed)
 666     {
 667         fib_entry_src_vft[source].fesv_installed(esrc,
 668                                                  fib_entry);
 669     }
 670
 671     fib_entry_src_action_fwd_update(fib_entry, source);
 672 }
 673
 674 /*
 675  * fib_entry_src_action_add
 676  *
 677  * Adding a source can result in a new fib_entry being created, which
 678  * can inturn mean the pool is realloc'd and thus the entry passed as
 679  * an argument it also realloc'd
 680  * @return the original entry
 681  */
 682 fib_entry_t *
 683 fib_entry_src_action_add (fib_entry_t *fib_entry,
 684                           fib_source_t source,
 685                           fib_entry_flag_t flags,
 686                           const dpo_id_t *dpo)
 687 {
 688     fib_node_index_t fib_entry_index;
 689     fib_entry_src_t *esrc;
 690
 691     esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
 692
 693     esrc->fes_ref_count++;
 694
 695     if (1 != esrc->fes_ref_count)
 696     {
 697         /*
 698          * we only want to add the source on the 0->1 transition
 699          */
 700         return (fib_entry);
 701     }
 702
 703     esrc->fes_entry_flags = flags;
 704
 705     /*
 706      * save variable so we can recover from a fib_entry realloc.
 707      */
 708     fib_entry_index = fib_entry_get_index(fib_entry);
 709
 710     if (NULL != fib_entry_src_vft[source].fesv_add)
 711     {
 712         fib_entry_src_vft[source].fesv_add(esrc,
 713                                            fib_entry,
 714                                            flags,
 715                                            fib_entry_get_proto(fib_entry),
 716                                            dpo);
 717     }
 718
 719     fib_entry = fib_entry_get(fib_entry_index);
 720
 721     esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
 722
 723     fib_path_list_lock(esrc->fes_pl);
 724
 725     /*
 726      * the source owns a lock on the entry
 727      */
 728     fib_entry_lock(fib_entry_get_index(fib_entry));
 729
 730     return (fib_entry);
 731 }
 732
 733 /*
 734  * fib_entry_src_action_update
 735  *
 736  * Adding a source can result in a new fib_entry being created, which
 737  * can inturn mean the pool is realloc'd and thus the entry passed as
 738  * an argument it also realloc'd
 739  * @return the original entry
 740  */
 741 fib_entry_t *
 742 fib_entry_src_action_update (fib_entry_t *fib_entry,
 743                              fib_source_t source,
 744                              fib_entry_flag_t flags,
 745                              const dpo_id_t *dpo)
 746 {
 747     fib_node_index_t fib_entry_index, old_path_list_index;
 748     fib_entry_src_t *esrc;
 749
 750     esrc = fib_entry_src_find_or_create(fib_entry, source, NULL);
 751
 752     if (NULL == esrc)
 753         return (fib_entry_src_action_add(fib_entry, source, flags, dpo));
 754
 755     old_path_list_index = esrc->fes_pl;
 756     esrc->fes_entry_flags = flags;
 757
 758     /*
 759      * save variable so we can recover from a fib_entry realloc.
 760      */
 761     fib_entry_index = fib_entry_get_index(fib_entry);
 762
 763     if (NULL != fib_entry_src_vft[source].fesv_add)
 764     {
 765         fib_entry_src_vft[source].fesv_add(esrc,
 766                                            fib_entry,
 767                                            flags,
 768                                            fib_entry_get_proto(fib_entry),
 769                                            dpo);
 770     }
 771
 772     fib_entry = fib_entry_get(fib_entry_index);
 773
 774     esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED;
 775
 776     fib_path_list_lock(esrc->fes_pl);
 777     fib_path_list_unlock(old_path_list_index);
 778
 779     return (fib_entry);
 780 }
 781
 782
 783 fib_entry_src_flag_t
 784 fib_entry_src_action_remove (fib_entry_t *fib_entry,
 785                              fib_source_t source)
 786
 787 {
 788     fib_node_index_t old_path_list;
 789     fib_entry_src_flag_t sflags;
 790     fib_entry_src_t *esrc;
 791
 792     esrc = fib_entry_src_find(fib_entry, source, NULL);
 793
 794     if (NULL == esrc)
 795         return (FIB_ENTRY_SRC_FLAG_ACTIVE);
 796
 797     esrc->fes_ref_count--;
 798     sflags = esrc->fes_flags;
 799
 800     if (0 != esrc->fes_ref_count)
 801     {
 802         /*
 803          * only remove the source on the 1->0 transisition
 804          */
 805         return (sflags);
 806     }
 807
 808     if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE)
 809     {
 810         fib_entry_src_action_deactivate(fib_entry, source);
 811     }
 812
 813     old_path_list = esrc->fes_pl;
 814
 815     if (NULL != fib_entry_src_vft[source].fesv_remove)
 816     {
 817         fib_entry_src_vft[source].fesv_remove(esrc);
 818     }
 819
 820     fib_path_list_unlock(old_path_list);
 821     fib_entry_unlock(fib_entry_get_index(fib_entry));
 822
 823     sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED;
 824     fib_entry_src_action_deinit(fib_entry, source);
 825
 826     return (sflags);
 827 }
 828
 829 static inline int
 830 fib_route_recurses_via_self (const fib_prefix_t *prefix,
 831                              const fib_route_path_t *rpath)
 832 {
 833     /*
 834      * not all zeros next hop &&
 835      * is recursive path &&
 836      * nexthop is same as the route's address
 837      */
 838     return ((!ip46_address_is_zero(&rpath->frp_addr)) &&
 839             (~0 == rpath->frp_sw_if_index) &&
 840             (0 == ip46_address_cmp(&rpath->frp_addr, &prefix->fp_addr)));
 841
 842 }
 843
 844 /*
 845  * fib_route_attached_cross_table
 846  *
 847  * Return true the the route is attached via an interface that
 848  * is not in the same table as the route
 849  */
 850 static inline int
 851 fib_route_attached_cross_table (const fib_entry_t *fib_entry,
 852                                 const fib_route_path_t *rpath)
 853 {
 854     /*
 855      * - All zeros next-hop
 856      * - a valid interface
 857      * - entry's fib index not equeal to interface's index
 858      */
 859     if (ip46_address_is_zero(&rpath->frp_addr) &&
 860         (~0 != rpath->frp_sw_if_index) &&
 861         (fib_entry->fe_fib_index !=
 862          fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry),
 863                                              rpath->frp_sw_if_index)))
 864     {
 865         return (!0);
 866     }
 867     return (0);
 868 }
 869
 870 /*
 871  * fib_route_attached_cross_table
 872  *
 873  * Return true the the route is attached via an interface that
 874  * is not in the same table as the route
 875  */
 876 static inline int
 877 fib_path_is_attached (const fib_route_path_t *rpath)
 878 {
 879     /*
 880      * - All zeros next-hop
 881      * - a valid interface
 882      */
 883     if (ip46_address_is_zero(&rpath->frp_addr) &&
 884         (~0 != rpath->frp_sw_if_index))
 885     {
 886         return (!0);
 887     }
 888     return (0);
 889 }
 890
 891 fib_path_list_flags_t
 892 fib_entry_src_flags_2_path_list_flags (fib_entry_flag_t eflags)
 893 {
 894     fib_path_list_flags_t plf = FIB_PATH_LIST_FLAG_NONE;
 895
 896     if (eflags & FIB_ENTRY_FLAG_DROP)
 897     {
 898         plf |= FIB_PATH_LIST_FLAG_DROP;
 899     }
 900     if (eflags & FIB_ENTRY_FLAG_LOCAL)
 901     {
 902         plf |= FIB_PATH_LIST_FLAG_LOCAL;
 903     }
 904     if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE)
 905     {
 906         plf |= FIB_PATH_LIST_FLAG_EXCLUSIVE;
 907     }
 908
 909     return (plf);
 910 }
 911
 912 static void
 913 fib_entry_flags_update (const fib_entry_t *fib_entry,
 914                         const fib_route_path_t *rpath,
 915                         fib_path_list_flags_t *pl_flags,
 916                         fib_entry_src_t *esrc)
 917 {
 918     /*
 919      * don't allow the addition of a recursive looped path for prefix
 920      * via itself.
 921      */
 922     if (fib_route_recurses_via_self(&fib_entry->fe_prefix, rpath))
 923     {
 924         /*
 925          * force the install of a drop path-list.
 926          * we want the entry to have some path-list, mainly so
 927          * the dodgy path can be rmeoved when the source stops playing
 928          * silly buggers.
 929          */
 930         *pl_flags |= FIB_PATH_LIST_FLAG_DROP;
 931     }
 932     else
 933     {
 934         *pl_flags &= ~FIB_PATH_LIST_FLAG_DROP;
 935     }
 936
 937     if ((esrc->fes_src == FIB_SOURCE_API) ||
 938         (esrc->fes_src == FIB_SOURCE_CLI))
 939     {
 940         if (fib_path_is_attached(rpath))
 941         {
 942             esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED;
 943         }
 944         else
 945         {
 946             esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED;
 947         }
 948     }
 949     if (fib_route_attached_cross_table(fib_entry, rpath))
 950     {
 951         esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT;
 952     }
 953     else
 954     {
 955         esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT;
 956     }
 957 }
 958
 959 /*
 960  * fib_entry_src_path_ext_add
 961  *
 962  * append a path extension to the entry's list
 963  */
 964 static void
 965 fib_entry_src_path_ext_append (fib_entry_src_t *esrc,
 966                                const fib_route_path_t *rpath)
 967 {
 968     if (MPLS_LABEL_INVALID != rpath->frp_label)
 969     {
 970         fib_path_ext_t *path_ext;
 971
 972         vec_add2(esrc->fes_path_exts, path_ext, 1);
 973
 974         fib_path_ext_init(path_ext, esrc->fes_pl, rpath);
 975     }
 976 }
 977
 978 /*
 979  * fib_entry_src_path_ext_insert
 980  *
 981  * insert, sorted, a path extension to the entry's list.
 982  * It's not strictly necessary in sort the path extensions, since each
 983  * extension has the path index to which it resolves. However, by being
 984  * sorted the load-balance produced has a deterministic order, not an order
 985  * based on the sequence of extension additions. this is a considerable benefit.
 986  */
 987 static void
 988 fib_entry_src_path_ext_insert (fib_entry_src_t *esrc,
 989                                const fib_route_path_t *rpath)
 990 {
 991     if (0 == vec_len(esrc->fes_path_exts))
 992         return (fib_entry_src_path_ext_append(esrc, rpath));
 993
 994     if (MPLS_LABEL_INVALID != rpath->frp_label)
 995     {
 996         fib_path_ext_t path_ext;
 997         int i = 0;
 998
 999         fib_path_ext_init(&path_ext, esrc->fes_pl, rpath);
1000
1001         while (i < vec_len(esrc->fes_path_exts) &&
1002                (fib_path_ext_cmp(&esrc->fes_path_exts[i], rpath) < 0))
1003         {
1004             i++;
1005         }
1006
1007         vec_insert_elts(esrc->fes_path_exts, &path_ext, 1, i);
1008     }
1009 }
1010
1011 /*
1012  * fib_entry_src_action_add
1013  *
1014  * Adding a source can result in a new fib_entry being created, which
1015  * can inturn mean the pool is realloc'd and thus the entry passed as
1016  * an argument it also realloc'd
1017  * @return the entry
1018  */
1019 fib_entry_t*
1020 fib_entry_src_action_path_add (fib_entry_t *fib_entry,
1021                                fib_source_t source,
1022                                fib_entry_flag_t flags,
1023                                const fib_route_path_t *rpath)
1024 {
1025     fib_node_index_t old_path_list, fib_entry_index;
1026     fib_path_list_flags_t pl_flags;
1027     fib_path_ext_t *path_ext;
1028     fib_entry_src_t *esrc;
1029
1030     /*
1031      * save variable so we can recover from a fib_entry realloc.
1032      */
1033     fib_entry_index = fib_entry_get_index(fib_entry);
1034
1035     esrc = fib_entry_src_find(fib_entry, source, NULL);
1036     if (NULL == esrc)
1037     {
1038         fib_entry =
1039             fib_entry_src_action_add(fib_entry,
1040                                      source,
1041                                      flags,
1042                                      drop_dpo_get(
1043                                          fib_proto_to_dpo(
1044                                              fib_entry_get_proto(fib_entry))));
1045         esrc = fib_entry_src_find(fib_entry, source, NULL);
1046     }
1047
1048     /*
1049      * we are no doubt modifying a path-list. If the path-list
1050      * is shared, and hence not modifiable, then the index returned
1051      * will be for a different path-list. This FIB entry to needs
1052      * to maintain its lock appropriately.
1053      */
1054     old_path_list = esrc->fes_pl;
1055
1056     ASSERT(NULL != fib_entry_src_vft[source].fesv_path_add);
1057
1058     pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1059     fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1060
1061     fib_entry_src_vft[source].fesv_path_add(esrc, fib_entry, pl_flags, rpath);
1062     fib_entry = fib_entry_get(fib_entry_index);
1063
1064     /*
1065      * re-resolve all the path-extensions with the new path-list
1066      */
1067     vec_foreach(path_ext, esrc->fes_path_exts)
1068     {
1069         fib_path_ext_resolve(path_ext, esrc->fes_pl);
1070     }
1071     /*
1072      * if the path has a label we need to add a path extension
1073      */
1074     fib_entry_src_path_ext_insert(esrc, rpath);
1075
1076     fib_path_list_lock(esrc->fes_pl);
1077     fib_path_list_unlock(old_path_list);
1078
1079     return (fib_entry);
1080 }
1081
1082 /*
1083  * fib_entry_src_action_swap
1084  *
1085  * The source is providing new paths to replace the old ones.
1086  * Adding a source can result in a new fib_entry being created, which
1087  * can inturn mean the pool is realloc'd and thus the entry passed as
1088  * an argument it also realloc'd
1089  * @return the entry
1090  */
1091 fib_entry_t*
1092 fib_entry_src_action_path_swap (fib_entry_t *fib_entry,
1093                                 fib_source_t source,
1094                                 fib_entry_flag_t flags,
1095                                 const fib_route_path_t *rpaths)
1096 {
1097     fib_node_index_t old_path_list, fib_entry_index;
1098     fib_path_list_flags_t pl_flags;
1099     const fib_route_path_t *rpath;
1100     fib_entry_src_t *esrc;
1101
1102     esrc = fib_entry_src_find(fib_entry, source, NULL);
1103
1104     /*
1105      * save variable so we can recover from a fib_entry realloc.
1106      */
1107     fib_entry_index = fib_entry_get_index(fib_entry);
1108
1109     if (NULL == esrc)
1110     {
1111         fib_entry = fib_entry_src_action_add(fib_entry,
1112                                              source,
1113                                              flags,
1114                                              drop_dpo_get(
1115                                                  fib_proto_to_dpo(
1116                                                      fib_entry_get_proto(fib_entry))));
1117         esrc = fib_entry_src_find(fib_entry, source, NULL);
1118     }
1119
1120     /*
1121      * swapping paths may create a new path-list (or may use an existing shared)
1122      * but we are certainly getting a different one. This FIB entry to needs
1123      * to maintain its lock appropriately.
1124      */
1125     old_path_list = esrc->fes_pl;
1126
1127     ASSERT(NULL != fib_entry_src_vft[source].fesv_path_swap);
1128
1129     pl_flags = fib_entry_src_flags_2_path_list_flags(flags);
1130
1131     vec_foreach(rpath, rpaths)
1132     {
1133         fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1134     }
1135
1136     fib_entry_src_vft[source].fesv_path_swap(esrc,
1137                                              fib_entry,
1138                                              pl_flags,
1139                                              rpaths);
1140
1141     vec_free(esrc->fes_path_exts);
1142     vec_foreach(rpath, rpaths)
1143     {
1144         fib_entry_src_path_ext_append(esrc, rpath);
1145     }
1146
1147     fib_entry = fib_entry_get(fib_entry_index);
1148
1149     fib_path_list_lock(esrc->fes_pl);
1150     fib_path_list_unlock(old_path_list);
1151
1152     return (fib_entry);
1153 }
1154
1155 fib_entry_src_flag_t
1156 fib_entry_src_action_path_remove (fib_entry_t *fib_entry,
1157                                   fib_source_t source,
1158                                   const fib_route_path_t *rpath)
1159 {
1160     fib_path_list_flags_t pl_flags;
1161     fib_node_index_t old_path_list;
1162     fib_path_ext_t *path_ext;
1163     fib_entry_src_t *esrc;
1164
1165     esrc = fib_entry_src_find(fib_entry, source, NULL);
1166
1167     ASSERT(NULL != esrc);
1168     ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED);
1169
1170     /*
1171      * we no doubt modifying a path-list. If the path-list
1172      * is shared, and hence not modifiable, then the index returned
1173      * will be for a different path-list. This FIB entry to needs
1174      * to maintain its lock appropriately.
1175      */
1176     old_path_list = esrc->fes_pl;
1177
1178     ASSERT(NULL != fib_entry_src_vft[source].fesv_path_remove);
1179
1180     pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry));
1181     fib_entry_flags_update(fib_entry, rpath, &pl_flags, esrc);
1182
1183     fib_entry_src_vft[source].fesv_path_remove(esrc, pl_flags, rpath);
1184     /*
1185      * find the matching path extension and remove it
1186      */
1187     vec_foreach(path_ext, esrc->fes_path_exts)
1188     {
1189         if (!fib_path_ext_cmp(path_ext, rpath))
1190         {
1191             /*
1192              * delete the element moving the remaining elements down 1 position.
1193              * this preserves the sorted order.
1194              */
1195             vec_delete(esrc->fes_path_exts, 1, (path_ext - esrc->fes_path_exts));
1196             break;
1197         }
1198     }
1199     /*
1200      * re-resolve all the path-extensions with the new path-list
1201      */
1202     vec_foreach(path_ext, esrc->fes_path_exts)
1203     {
1204         fib_path_ext_resolve(path_ext, esrc->fes_pl);
1205     }
1206
1207     /*
1208      * lock the new path-list, unlock the old if it had one
1209      */
1210     fib_path_list_unlock(old_path_list);
1211
1212     if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) {
1213         fib_path_list_lock(esrc->fes_pl);
1214         return (FIB_ENTRY_SRC_FLAG_ADDED);
1215     }
1216     else
1217     {
1218         /*
1219          * no more paths left from this source
1220          */
1221         fib_entry_src_action_remove(fib_entry, source);
1222         return (FIB_ENTRY_SRC_FLAG_NONE);
1223     }
1224 }
1225
1226 u8*
1227 fib_entry_src_format (fib_entry_t *fib_entry,
1228                       fib_source_t source,
1229                       u8* s)
1230 {
1231     fib_entry_src_t *esrc;
1232
1233     esrc = fib_entry_src_find(fib_entry, source, NULL);
1234
1235     if (NULL != fib_entry_src_vft[source].fesv_format)
1236     {
1237         return (fib_entry_src_vft[source].fesv_format(esrc, s));
1238     }
1239     return (s);
1240 }
1241
1242 adj_index_t
1243 fib_entry_get_adj_for_source (fib_node_index_t fib_entry_index,
1244                               fib_source_t source)
1245 {
1246     fib_entry_t *fib_entry;
1247     fib_entry_src_t *esrc;
1248
1249     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1250         return (ADJ_INDEX_INVALID);
1251
1252     fib_entry = fib_entry_get(fib_entry_index);
1253     esrc = fib_entry_src_find(fib_entry, source, NULL);
1254
1255     if (NULL != esrc)
1256     {
1257         if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1258         {
1259             return (fib_path_list_get_adj(
1260                         esrc->fes_pl,
1261                         fib_entry_get_default_chain_type(fib_entry)));
1262         }
1263     }
1264     return (ADJ_INDEX_INVALID);
1265 }
1266
1267 const int
1268 fib_entry_get_dpo_for_source (fib_node_index_t fib_entry_index,
1269                               fib_source_t source,
1270                               dpo_id_t *dpo)
1271 {
1272     fib_entry_t *fib_entry;
1273     fib_entry_src_t *esrc;
1274
1275     if (FIB_NODE_INDEX_INVALID == fib_entry_index)
1276         return (0);
1277
1278     fib_entry = fib_entry_get(fib_entry_index);
1279     esrc = fib_entry_src_find(fib_entry, source, NULL);
1280
1281     if (NULL != esrc)
1282     {
1283         if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1284         {
1285             fib_path_list_contribute_forwarding(
1286                 esrc->fes_pl,
1287                 fib_entry_get_default_chain_type(fib_entry),
1288                 dpo);
1289
1290             return (dpo_id_is_valid(dpo));
1291         }
1292     }
1293     return (0);
1294 }
1295
1296 u32
1297 fib_entry_get_resolving_interface_for_source (fib_node_index_t entry_index,
1298                                               fib_source_t source)
1299 {
1300     fib_entry_t *fib_entry;
1301     fib_entry_src_t *esrc;
1302
1303     fib_entry = fib_entry_get(entry_index);
1304
1305     esrc = fib_entry_src_find(fib_entry, source, NULL);
1306
1307     if (NULL != esrc)
1308     {
1309         if (FIB_NODE_INDEX_INVALID != esrc->fes_pl)
1310         {
1311             return (fib_path_list_get_resolving_interface(esrc->fes_pl));
1312         }
1313     }
1314     return (~0);
1315 }
1316
1317 fib_entry_flag_t
1318 fib_entry_get_flags_for_source (fib_node_index_t entry_index,
1319                                 fib_source_t source)
1320 {
1321     fib_entry_t *fib_entry;
1322     fib_entry_src_t *esrc;
1323
1324     fib_entry = fib_entry_get(entry_index);
1325
1326     esrc = fib_entry_src_find(fib_entry, source, NULL);
1327
1328     if (NULL != esrc)
1329     {
1330         return (esrc->fes_entry_flags);
1331     }
1332
1333     return (FIB_ENTRY_FLAG_NONE);
1334 }
1335
1336 fib_entry_flag_t
1337 fib_entry_get_flags_i (const fib_entry_t *fib_entry)
1338 {
1339     fib_entry_flag_t flags;
1340
1341     /*
1342      * the vector of sources is deliberately arranged in priority order
1343      */
1344     if (0 == vec_len(fib_entry->fe_srcs))
1345     {
1346         flags = FIB_ENTRY_FLAG_NONE;
1347     }
1348     else
1349     {
1350         fib_entry_src_t *esrc;
1351
1352         esrc = vec_elt_at_index(fib_entry->fe_srcs, 0);
1353         flags = esrc->fes_entry_flags;
1354     }
1355
1356     return (flags);
1357 }
1358
1359 void
1360 fib_entry_set_source_data (fib_node_index_t fib_entry_index,
1361                            fib_source_t source,
1362                            const void *data)
1363 {
1364     fib_entry_t *fib_entry;
1365     fib_entry_src_t *esrc;
1366
1367     fib_entry = fib_entry_get(fib_entry_index);
1368     esrc = fib_entry_src_find(fib_entry, source, NULL);
1369
1370     if (NULL != esrc &&
1371         NULL != fib_entry_src_vft[source].fesv_set_data)
1372     {
1373         fib_entry_src_vft[source].fesv_set_data(esrc, fib_entry, data);
1374     }
1375 }
1376
1377 const void*
1378 fib_entry_get_source_data (fib_node_index_t fib_entry_index,
1379                            fib_source_t source)
1380 {
1381     fib_entry_t *fib_entry;
1382     fib_entry_src_t *esrc;
1383
1384     fib_entry = fib_entry_get(fib_entry_index);
1385     esrc = fib_entry_src_find(fib_entry, source, NULL);
1386
1387     if (NULL != esrc &&
1388         NULL != fib_entry_src_vft[source].fesv_get_data)
1389     {
1390         return (fib_entry_src_vft[source].fesv_get_data(esrc, fib_entry));
1391     }
1392     return (NULL);
1393 }
1394
1395 void
1396 fib_entry_src_module_init (void)
1397 {
1398     fib_entry_src_rr_register();
1399     fib_entry_src_interface_register();
1400     fib_entry_src_default_route_register();
1401     fib_entry_src_special_register();
1402     fib_entry_src_api_register();
1403     fib_entry_src_adj_register();
1404     fib_entry_src_mpls_register();
1405     fib_entry_src_lisp_register();
1406 }