src/vnet/fib/fib_path.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 <vlib/vlib.h>
  17 #include <vnet/vnet.h>
  18 #include <vnet/ip/format.h>
  19 #include <vnet/ip/ip.h>
  20 #include <vnet/dpo/drop_dpo.h>
  21 #include <vnet/dpo/receive_dpo.h>
  22 #include <vnet/dpo/load_balance_map.h>
  23 #include <vnet/dpo/lookup_dpo.h>
  24 #include <vnet/dpo/interface_rx_dpo.h>
  25 #include <vnet/dpo/mpls_disposition.h>
  26 #include <vnet/dpo/dvr_dpo.h>
  27 #include <vnet/dpo/drop_dpo.h>
  28
  29 #include <vnet/adj/adj.h>
  30 #include <vnet/adj/adj_mcast.h>
  31
  32 #include <vnet/fib/fib_path.h>
  33 #include <vnet/fib/fib_node.h>
  34 #include <vnet/fib/fib_table.h>
  35 #include <vnet/fib/fib_entry.h>
  36 #include <vnet/fib/fib_path_list.h>
  37 #include <vnet/fib/fib_internal.h>
  38 #include <vnet/fib/fib_urpf_list.h>
  39 #include <vnet/fib/mpls_fib.h>
  40 #include <vnet/udp/udp_encap.h>
  41 #include <vnet/bier/bier_fmask.h>
  42 #include <vnet/bier/bier_table.h>
  43 #include <vnet/bier/bier_imp.h>
  44 #include <vnet/bier/bier_disp_table.h>
  45
  46 /**
  47  * Enurmeration of path types
  48  */
  49 typedef enum fib_path_type_t_ {
  50     /**
  51      * Marker. Add new types after this one.
  52      */
  53     FIB_PATH_TYPE_FIRST = 0,
  54     /**
  55      * Attached-nexthop. An interface and a nexthop are known.
  56      */
  57     FIB_PATH_TYPE_ATTACHED_NEXT_HOP = FIB_PATH_TYPE_FIRST,
  58     /**
  59      * attached. Only the interface is known.
  60      */
  61     FIB_PATH_TYPE_ATTACHED,
  62     /**
  63      * recursive. Only the next-hop is known.
  64      */
  65     FIB_PATH_TYPE_RECURSIVE,
  66     /**
  67      * special. nothing is known. so we drop.
  68      */
  69     FIB_PATH_TYPE_SPECIAL,
  70     /**
  71      * exclusive. user provided adj.
  72      */
  73     FIB_PATH_TYPE_EXCLUSIVE,
  74     /**
  75      * deag. Link to a lookup adj in the next table
  76      */
  77     FIB_PATH_TYPE_DEAG,
  78     /**
  79      * interface receive.
  80      */
  81     FIB_PATH_TYPE_INTF_RX,
  82     /**
  83      * interface receive.
  84      */
  85     FIB_PATH_TYPE_UDP_ENCAP,
  86     /**
  87      * receive. it's for-us.
  88      */
  89     FIB_PATH_TYPE_RECEIVE,
  90     /**
  91      * bier-imp. it's via a BIER imposition.
  92      */
  93     FIB_PATH_TYPE_BIER_IMP,
  94     /**
  95      * bier-fmask. it's via a BIER ECMP-table.
  96      */
  97     FIB_PATH_TYPE_BIER_TABLE,
  98     /**
  99      * bier-fmask. it's via a BIER f-mask.
 100      */
 101     FIB_PATH_TYPE_BIER_FMASK,
 102     /**
 103      * via a DVR.
 104      */
 105     FIB_PATH_TYPE_DVR,
 106     /**
 107      * Marker. Add new types before this one, then update it.
 108      */
 109     FIB_PATH_TYPE_LAST = FIB_PATH_TYPE_BIER_FMASK,
 110 } __attribute__ ((packed)) fib_path_type_t;
 111
 112 /**
 113  * The maximum number of path_types
 114  */
 115 #define FIB_PATH_TYPE_MAX (FIB_PATH_TYPE_LAST + 1)
 116
 117 #define FIB_PATH_TYPES {                                        \
 118     [FIB_PATH_TYPE_ATTACHED_NEXT_HOP] = "attached-nexthop",     \
 119     [FIB_PATH_TYPE_ATTACHED]          = "attached",             \
 120     [FIB_PATH_TYPE_RECURSIVE]         = "recursive",            \
 121     [FIB_PATH_TYPE_SPECIAL]           = "special",              \
 122     [FIB_PATH_TYPE_EXCLUSIVE]         = "exclusive",            \
 123     [FIB_PATH_TYPE_DEAG]              = "deag",                 \
 124     [FIB_PATH_TYPE_INTF_RX]           = "intf-rx",              \
 125     [FIB_PATH_TYPE_UDP_ENCAP]         = "udp-encap",            \
 126     [FIB_PATH_TYPE_RECEIVE]           = "receive",              \
 127     [FIB_PATH_TYPE_BIER_IMP]          = "bier-imp",             \
 128     [FIB_PATH_TYPE_BIER_TABLE]        = "bier-table",           \
 129     [FIB_PATH_TYPE_BIER_FMASK]        = "bier-fmask",           \
 130     [FIB_PATH_TYPE_DVR]               = "dvr",                  \
 131 }
 132
 133 #define FOR_EACH_FIB_PATH_TYPE(_item)           \
 134     for (_item = FIB_PATH_TYPE_FIRST;           \
 135          _item <= FIB_PATH_TYPE_LAST;           \
 136          _item++)
 137
 138 /**
 139  * Enurmeration of path operational (i.e. derived) attributes
 140  */
 141 typedef enum fib_path_oper_attribute_t_ {
 142     /**
 143      * Marker. Add new types after this one.
 144      */
 145     FIB_PATH_OPER_ATTRIBUTE_FIRST = 0,
 146     /**
 147      * The path forms part of a recursive loop.
 148      */
 149     FIB_PATH_OPER_ATTRIBUTE_RECURSIVE_LOOP = FIB_PATH_OPER_ATTRIBUTE_FIRST,
 150     /**
 151      * The path is resolved
 152      */
 153     FIB_PATH_OPER_ATTRIBUTE_RESOLVED,
 154     /**
 155      * The path is attached, despite what the next-hop may say.
 156      */
 157     FIB_PATH_OPER_ATTRIBUTE_ATTACHED,
 158     /**
 159      * The path has become a permanent drop.
 160      */
 161     FIB_PATH_OPER_ATTRIBUTE_DROP,
 162     /**
 163      * Marker. Add new types before this one, then update it.
 164      */
 165     FIB_PATH_OPER_ATTRIBUTE_LAST = FIB_PATH_OPER_ATTRIBUTE_DROP,
 166 } __attribute__ ((packed)) fib_path_oper_attribute_t;
 167
 168 /**
 169  * The maximum number of path operational attributes
 170  */
 171 #define FIB_PATH_OPER_ATTRIBUTE_MAX (FIB_PATH_OPER_ATTRIBUTE_LAST + 1)
 172
 173 #define FIB_PATH_OPER_ATTRIBUTES {                                      \
 174     [FIB_PATH_OPER_ATTRIBUTE_RECURSIVE_LOOP] = "recursive-loop",        \
 175     [FIB_PATH_OPER_ATTRIBUTE_RESOLVED]       = "resolved",              \
 176     [FIB_PATH_OPER_ATTRIBUTE_DROP]           = "drop",                  \
 177 }
 178
 179 #define FOR_EACH_FIB_PATH_OPER_ATTRIBUTE(_item) \
 180     for (_item = FIB_PATH_OPER_ATTRIBUTE_FIRST; \
 181          _item <= FIB_PATH_OPER_ATTRIBUTE_LAST; \
 182          _item++)
 183
 184 /**
 185  * Path flags from the attributes
 186  */
 187 typedef enum fib_path_oper_flags_t_ {
 188     FIB_PATH_OPER_FLAG_NONE = 0,
 189     FIB_PATH_OPER_FLAG_RECURSIVE_LOOP = (1 << FIB_PATH_OPER_ATTRIBUTE_RECURSIVE_LOOP),
 190     FIB_PATH_OPER_FLAG_DROP = (1 << FIB_PATH_OPER_ATTRIBUTE_DROP),
 191     FIB_PATH_OPER_FLAG_RESOLVED = (1 << FIB_PATH_OPER_ATTRIBUTE_RESOLVED),
 192     FIB_PATH_OPER_FLAG_ATTACHED = (1 << FIB_PATH_OPER_ATTRIBUTE_ATTACHED),
 193 } __attribute__ ((packed)) fib_path_oper_flags_t;
 194
 195 /**
 196  * A FIB path
 197  */
 198 typedef struct fib_path_t_ {
 199     /**
 200      * A path is a node in the FIB graph.
 201      */
 202     fib_node_t fp_node;
 203
 204     /**
 205      * The index of the path-list to which this path belongs
 206      */
 207     u32 fp_pl_index;
 208
 209     /**
 210      * This marks the start of the memory area used to hash
 211      * the path
 212      */
 213     STRUCT_MARK(path_hash_start);
 214
 215     /**
 216      * Configuration Flags
 217      */
 218     fib_path_cfg_flags_t fp_cfg_flags;
 219
 220     /**
 221      * The type of the path. This is the selector for the union
 222      */
 223     fib_path_type_t fp_type;
 224
 225     /**
 226      * The protocol of the next-hop, i.e. the address family of the
 227      * next-hop's address. We can't derive this from the address itself
 228      * since the address can be all zeros
 229      */
 230     dpo_proto_t fp_nh_proto;
 231
 232     /**
 233      * UCMP [unnormalised] weigth
 234      */
 235     u8 fp_weight;
 236
 237     /**
 238      * A path preference. 0 is the best.
 239      * Only paths of the best preference, that are 'up', are considered
 240      * for forwarding.
 241      */
 242     u8 fp_preference;
 243
 244     /**
 245      * per-type union of the data required to resolve the path
 246      */
 247     union {
 248         struct {
 249             /**
 250              * The next-hop
 251              */
 252             ip46_address_t fp_nh;
 253             /**
 254              * The interface
 255              */
 256             u32 fp_interface;
 257         } attached_next_hop;
 258         struct {
 259             /**
 260              * The interface
 261              */
 262             u32 fp_interface;
 263         } attached;
 264         struct {
 265             union
 266             {
 267                 /**
 268                  * The next-hop
 269                  */
 270                 ip46_address_t fp_ip;
 271                 struct {
 272                     /**
 273                      * The local label to resolve through.
 274                      */
 275                     mpls_label_t fp_local_label;
 276                     /**
 277                      * The EOS bit of the resolving label
 278                      */
 279                     mpls_eos_bit_t fp_eos;
 280                 };
 281             } fp_nh;
 282             union {
 283                 /**
 284                  * The FIB table index in which to find the next-hop.
 285                  */
 286                 fib_node_index_t fp_tbl_id;
 287                 /**
 288                  * The BIER FIB the fmask is in
 289                  */
 290                 index_t fp_bier_fib;
 291             };
 292         } recursive;
 293         struct {
 294             /**
 295              * BIER FMask ID
 296              */
 297             index_t fp_bier_fmask;
 298         } bier_fmask;
 299         struct {
 300             /**
 301              * The BIER table's ID
 302              */
 303             bier_table_id_t fp_bier_tbl;
 304         } bier_table;
 305         struct {
 306             /**
 307              * The BIER imposition object
 308              * this is part of the path's key, since the index_t
 309              * of an imposition object is the object's key.
 310              */
 311             index_t fp_bier_imp;
 312         } bier_imp;
 313         struct {
 314             /**
 315              * The FIB index in which to perfom the next lookup
 316              */
 317             fib_node_index_t fp_tbl_id;
 318             /**
 319              * The RPF-ID to tag the packets with
 320              */
 321             fib_rpf_id_t fp_rpf_id;
 322         } deag;
 323         struct {
 324         } special;
 325         struct {
 326             /**
 327              * The user provided 'exclusive' DPO
 328              */
 329             dpo_id_t fp_ex_dpo;
 330         } exclusive;
 331         struct {
 332             /**
 333              * The interface on which the local address is configured
 334              */
 335             u32 fp_interface;
 336             /**
 337              * The next-hop
 338              */
 339             ip46_address_t fp_addr;
 340         } receive;
 341         struct {
 342             /**
 343              * The interface on which the packets will be input.
 344              */
 345             u32 fp_interface;
 346         } intf_rx;
 347         struct {
 348             /**
 349              * The UDP Encap object this path resolves through
 350              */
 351             u32 fp_udp_encap_id;
 352         } udp_encap;
 353         struct {
 354             /**
 355              * The interface
 356              */
 357             u32 fp_interface;
 358         } dvr;
 359     };
 360     STRUCT_MARK(path_hash_end);
 361
 362     /**
 363      * Memebers in this last section represent information that is
 364      * dervied during resolution. It should not be copied to new paths
 365      * nor compared.
 366      */
 367
 368     /**
 369      * Operational Flags
 370      */
 371     fib_path_oper_flags_t fp_oper_flags;
 372
 373     union {
 374         /**
 375          * the resolving via fib. not part of the union, since it it not part
 376          * of the path's hash.
 377          */
 378         fib_node_index_t fp_via_fib;
 379         /**
 380          * the resolving bier-table
 381          */
 382         index_t fp_via_bier_tbl;
 383         /**
 384          * the resolving bier-fmask
 385          */
 386         index_t fp_via_bier_fmask;
 387     };
 388
 389     /**
 390      * The Data-path objects through which this path resolves for IP.
 391      */
 392     dpo_id_t fp_dpo;
 393
 394     /**
 395      * the index of this path in the parent's child list.
 396      */
 397     u32 fp_sibling;
 398 } fib_path_t;
 399
 400 /*
 401  * Array of strings/names for the path types and attributes
 402  */
 403 static const char *fib_path_type_names[] = FIB_PATH_TYPES;
 404 static const char *fib_path_oper_attribute_names[] = FIB_PATH_OPER_ATTRIBUTES;
 405 static const char *fib_path_cfg_attribute_names[]  = FIB_PATH_CFG_ATTRIBUTES;
 406
 407 /*
 408  * The memory pool from which we allocate all the paths
 409  */
 410 static fib_path_t *fib_path_pool;
 411
 412 /*
 413  * Debug macro
 414  */
 415 #ifdef FIB_DEBUG
 416 #define FIB_PATH_DBG(_p, _fmt, _args...)                        \
 417 {                                                               \
 418     u8 *_tmp = NULL;                                            \
 419     _tmp = fib_path_format(fib_path_get_index(_p), _tmp);       \
 420     clib_warning("path:[%d:%U]:" _fmt,                          \
 421                  fib_path_get_index(_p), format_fib_path, _p, 0,\
 422                  ##_args);                                      \
 423     vec_free(_tmp);                                             \
 424 }
 425 #else
 426 #define FIB_PATH_DBG(_p, _fmt, _args...)
 427 #endif
 428
 429 static fib_path_t *
 430 fib_path_get (fib_node_index_t index)
 431 {
 432     return (pool_elt_at_index(fib_path_pool, index));
 433 }
 434
 435 static fib_node_index_t
 436 fib_path_get_index (fib_path_t *path)
 437 {
 438     return (path - fib_path_pool);
 439 }
 440
 441 static fib_node_t *
 442 fib_path_get_node (fib_node_index_t index)
 443 {
 444     return ((fib_node_t*)fib_path_get(index));
 445 }
 446
 447 static fib_path_t*
 448 fib_path_from_fib_node (fib_node_t *node)
 449 {
 450     ASSERT(FIB_NODE_TYPE_PATH == node->fn_type);
 451     return ((fib_path_t*)node);
 452 }
 453
 454 u8 *
 455 format_fib_path (u8 * s, va_list * args)
 456 {
 457     fib_node_index_t path_index = va_arg (*args, fib_node_index_t);
 458     u32 indent = va_arg (*args, u32);
 459     vnet_main_t * vnm = vnet_get_main();
 460     fib_path_oper_attribute_t oattr;
 461     fib_path_cfg_attribute_t cattr;
 462     fib_path_t *path;
 463
 464     path = fib_path_get(path_index);
 465
 466     s = format (s, "%Upath:[%d] ", format_white_space, indent,
 467                 fib_path_get_index(path));
 468     s = format (s, "pl-index:%d ", path->fp_pl_index);
 469     s = format (s, "%U ", format_dpo_proto, path->fp_nh_proto);
 470     s = format (s, "weight=%d ", path->fp_weight);
 471     s = format (s, "pref=%d ", path->fp_preference);
 472     s = format (s, "%s: ", fib_path_type_names[path->fp_type]);
 473     if (FIB_PATH_OPER_FLAG_NONE != path->fp_oper_flags) {
 474         s = format(s, " oper-flags:");
 475         FOR_EACH_FIB_PATH_OPER_ATTRIBUTE(oattr) {
 476             if ((1<<oattr) & path->fp_oper_flags) {
 477                 s = format (s, "%s,", fib_path_oper_attribute_names[oattr]);
 478             }
 479         }
 480     }
 481     if (FIB_PATH_CFG_FLAG_NONE != path->fp_cfg_flags) {
 482         s = format(s, " cfg-flags:");
 483         FOR_EACH_FIB_PATH_CFG_ATTRIBUTE(cattr) {
 484             if ((1<<cattr) & path->fp_cfg_flags) {
 485                 s = format (s, "%s,", fib_path_cfg_attribute_names[cattr]);
 486             }
 487         }
 488     }
 489     s = format(s, "\n%U", format_white_space, indent+2);
 490
 491     switch (path->fp_type)
 492     {
 493     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
 494         s = format (s, "%U", format_ip46_address,
 495                     &path->attached_next_hop.fp_nh,
 496                     IP46_TYPE_ANY);
 497         if (path->fp_oper_flags & FIB_PATH_OPER_FLAG_DROP)
 498         {
 499             s = format (s, " if_index:%d", path->attached_next_hop.fp_interface);
 500         }
 501         else
 502         {
 503             s = format (s, " %U",
 504                         format_vnet_sw_interface_name,
 505                         vnm,
 506                         vnet_get_sw_interface(
 507                             vnm,
 508                             path->attached_next_hop.fp_interface));
 509             if (vnet_sw_interface_is_p2p(vnet_get_main(),
 510                                          path->attached_next_hop.fp_interface))
 511             {
 512                 s = format (s, " (p2p)");
 513             }
 514         }
 515         if (!dpo_id_is_valid(&path->fp_dpo))
 516         {
 517             s = format(s, "\n%Uunresolved", format_white_space, indent+2);
 518         }
 519         else
 520         {
 521             s = format(s, "\n%U%U",
 522                        format_white_space, indent,
 523                        format_dpo_id,
 524                        &path->fp_dpo, 13);
 525         }
 526         break;
 527     case FIB_PATH_TYPE_ATTACHED:
 528         if (path->fp_oper_flags & FIB_PATH_OPER_FLAG_DROP)
 529         {
 530             s = format (s, "if_index:%d", path->attached_next_hop.fp_interface);
 531         }
 532         else
 533         {
 534             s = format (s, " %U",
 535                         format_vnet_sw_interface_name,
 536                         vnm,
 537                         vnet_get_sw_interface(
 538                             vnm,
 539                             path->attached.fp_interface));
 540         }
 541         break;
 542     case FIB_PATH_TYPE_RECURSIVE:
 543         if (DPO_PROTO_MPLS == path->fp_nh_proto)
 544         {
 545             s = format (s, "via %U %U",
 546                         format_mpls_unicast_label,
 547                         path->recursive.fp_nh.fp_local_label,
 548                         format_mpls_eos_bit,
 549                         path->recursive.fp_nh.fp_eos);
 550         }
 551         else
 552         {
 553             s = format (s, "via %U",
 554                         format_ip46_address,
 555                         &path->recursive.fp_nh.fp_ip,
 556                         IP46_TYPE_ANY);
 557         }
 558         s = format (s, " in fib:%d",
 559                     path->recursive.fp_tbl_id,
 560                     path->fp_via_fib);
 561         s = format (s, " via-fib:%d", path->fp_via_fib);
 562         s = format (s, " via-dpo:[%U:%d]",
 563                     format_dpo_type, path->fp_dpo.dpoi_type,
 564                     path->fp_dpo.dpoi_index);
 565
 566         break;
 567     case FIB_PATH_TYPE_UDP_ENCAP:
 568         s = format (s, "UDP-encap ID:%d", path->udp_encap.fp_udp_encap_id);
 569         break;
 570     case FIB_PATH_TYPE_BIER_TABLE:
 571         s = format (s, "via bier-table:[%U}",
 572                     format_bier_table_id,
 573                     &path->bier_table.fp_bier_tbl);
 574         s = format (s, " via-dpo:[%U:%d]",
 575                     format_dpo_type, path->fp_dpo.dpoi_type,
 576                     path->fp_dpo.dpoi_index);
 577         break;
 578     case FIB_PATH_TYPE_BIER_FMASK:
 579         s = format (s, "via-fmask:%d", path->bier_fmask.fp_bier_fmask);
 580         s = format (s, " via-dpo:[%U:%d]",
 581                     format_dpo_type, path->fp_dpo.dpoi_type,
 582                     path->fp_dpo.dpoi_index);
 583         break;
 584     case FIB_PATH_TYPE_BIER_IMP:
 585         s = format (s, "via %U", format_bier_imp,
 586                     path->bier_imp.fp_bier_imp, 0, BIER_SHOW_BRIEF);
 587         break;
 588     case FIB_PATH_TYPE_DVR:
 589         s = format (s, " %U",
 590                     format_vnet_sw_interface_name,
 591                     vnm,
 592                     vnet_get_sw_interface(
 593                         vnm,
 594                         path->dvr.fp_interface));
 595         break;
 596     case FIB_PATH_TYPE_RECEIVE:
 597     case FIB_PATH_TYPE_INTF_RX:
 598     case FIB_PATH_TYPE_SPECIAL:
 599     case FIB_PATH_TYPE_DEAG:
 600     case FIB_PATH_TYPE_EXCLUSIVE:
 601         if (dpo_id_is_valid(&path->fp_dpo))
 602         {
 603             s = format(s, "%U", format_dpo_id,
 604                        &path->fp_dpo, indent+2);
 605         }
 606         break;
 607     }
 608     return (s);
 609 }
 610
 611 u8 *
 612 fib_path_format (fib_node_index_t pi, u8 *s)
 613 {
 614     fib_path_t *path;
 615
 616     path = fib_path_get(pi);
 617     ASSERT(NULL != path);
 618
 619     return (format (s, "%U", format_fib_path, path));
 620 }
 621
 622 /*
 623  * fib_path_last_lock_gone
 624  *
 625  * We don't share paths, we share path lists, so the [un]lock functions
 626  * are no-ops
 627  */
 628 static void
 629 fib_path_last_lock_gone (fib_node_t *node)
 630 {
 631     ASSERT(0);
 632 }
 633
 634 static const adj_index_t
 635 fib_path_attached_next_hop_get_adj (fib_path_t *path,
 636                                     vnet_link_t link)
 637 {
 638     if (vnet_sw_interface_is_p2p(vnet_get_main(),
 639                                  path->attached_next_hop.fp_interface))
 640     {
 641         /*
 642          * if the interface is p2p then the adj for the specific
 643          * neighbour on that link will never exist. on p2p links
 644          * the subnet address (the attached route) links to the
 645          * auto-adj (see below), we want that adj here too.
 646          */
 647         return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
 648                                     link,
 649                                     &zero_addr,
 650                                     path->attached_next_hop.fp_interface));
 651     }
 652     else
 653     {
 654         return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
 655                                     link,
 656                                     &path->attached_next_hop.fp_nh,
 657                                     path->attached_next_hop.fp_interface));
 658     }
 659 }
 660
 661 static void
 662 fib_path_attached_next_hop_set (fib_path_t *path)
 663 {
 664     /*
 665      * resolve directly via the adjacnecy discribed by the
 666      * interface and next-hop
 667      */
 668     dpo_set(&path->fp_dpo,
 669             DPO_ADJACENCY,
 670             path->fp_nh_proto,
 671             fib_path_attached_next_hop_get_adj(
 672                  path,
 673                  dpo_proto_to_link(path->fp_nh_proto)));
 674
 675     /*
 676      * become a child of the adjacency so we receive updates
 677      * when its rewrite changes
 678      */
 679     path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
 680                                      FIB_NODE_TYPE_PATH,
 681                                      fib_path_get_index(path));
 682
 683     if (!vnet_sw_interface_is_admin_up(vnet_get_main(),
 684                                       path->attached_next_hop.fp_interface) ||
 685         !adj_is_up(path->fp_dpo.dpoi_index))
 686     {
 687         path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 688     }
 689 }
 690
 691 static const adj_index_t
 692 fib_path_attached_get_adj (fib_path_t *path,
 693                            vnet_link_t link)
 694 {
 695     if (vnet_sw_interface_is_p2p(vnet_get_main(),
 696                                  path->attached.fp_interface))
 697     {
 698         /*
 699          * point-2-point interfaces do not require a glean, since
 700          * there is nothing to ARP. Install a rewrite/nbr adj instead
 701          */
 702         return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
 703                                     link,
 704                                     &zero_addr,
 705                                     path->attached.fp_interface));
 706     }
 707     else
 708     {
 709         return (adj_glean_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
 710                                       path->attached.fp_interface,
 711                                       NULL));
 712     }
 713 }
 714
 715 /*
 716  * create of update the paths recursive adj
 717  */
 718 static void
 719 fib_path_recursive_adj_update (fib_path_t *path,
 720                                fib_forward_chain_type_t fct,
 721                                dpo_id_t *dpo)
 722 {
 723     dpo_id_t via_dpo = DPO_INVALID;
 724
 725     /*
 726      * get the DPO to resolve through from the via-entry
 727      */
 728     fib_entry_contribute_forwarding(path->fp_via_fib,
 729                                     fct,
 730                                     &via_dpo);
 731
 732
 733     /*
 734      * hope for the best - clear if restrictions apply.
 735      */
 736     path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
 737
 738     /*
 739      * Validate any recursion constraints and over-ride the via
 740      * adj if not met
 741      */
 742     if (path->fp_oper_flags & FIB_PATH_OPER_FLAG_RECURSIVE_LOOP)
 743     {
 744         path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 745         dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
 746     }
 747     else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RESOLVE_HOST)
 748     {
 749         /*
 750          * the via FIB must be a host route.
 751          * note the via FIB just added will always be a host route
 752          * since it is an RR source added host route. So what we need to
 753          * check is whether the route has other sources. If it does then
 754          * some other source has added it as a host route. If it doesn't
 755          * then it was added only here and inherits forwarding from a cover.
 756          * the cover is not a host route.
 757          * The RR source is the lowest priority source, so we check if it
 758          * is the best. if it is there are no other sources.
 759          */
 760         if (fib_entry_get_best_source(path->fp_via_fib) >= FIB_SOURCE_RR)
 761         {
 762             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 763             dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
 764
 765             /*
 766              * PIC edge trigger. let the load-balance maps know
 767              */
 768             load_balance_map_path_state_change(fib_path_get_index(path));
 769         }
 770     }
 771     else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RESOLVE_ATTACHED)
 772     {
 773         /*
 774          * RR source entries inherit the flags from the cover, so
 775          * we can check the via directly
 776          */
 777         if (!(FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags(path->fp_via_fib)))
 778         {
 779             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 780             dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
 781
 782             /*
 783              * PIC edge trigger. let the load-balance maps know
 784              */
 785             load_balance_map_path_state_change(fib_path_get_index(path));
 786         }
 787     }
 788     /*
 789      * check for over-riding factors on the FIB entry itself
 790      */
 791     if (!fib_entry_is_resolved(path->fp_via_fib))
 792     {
 793         path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 794         dpo_copy(&via_dpo, drop_dpo_get(path->fp_nh_proto));
 795
 796         /*
 797          * PIC edge trigger. let the load-balance maps know
 798          */
 799         load_balance_map_path_state_change(fib_path_get_index(path));
 800     }
 801
 802     /*
 803      * If this path is contributing a drop, then it's not resolved
 804      */
 805     if (dpo_is_drop(&via_dpo) || load_balance_is_drop(&via_dpo))
 806     {
 807         path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 808     }
 809
 810     /*
 811      * update the path's contributed DPO
 812      */
 813     dpo_copy(dpo, &via_dpo);
 814
 815     FIB_PATH_DBG(path, "recursive update:");
 816
 817     dpo_reset(&via_dpo);
 818 }
 819
 820 /*
 821  * re-evaulate the forwarding state for a via fmask path
 822  */
 823 static void
 824 fib_path_bier_fmask_update (fib_path_t *path,
 825                             dpo_id_t *dpo)
 826 {
 827     bier_fmask_contribute_forwarding(path->bier_fmask.fp_bier_fmask, dpo);
 828
 829     /*
 830      * if we are stakcing on the drop, then the path is not resolved
 831      */
 832     if (dpo_is_drop(dpo))
 833     {
 834         path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 835     }
 836     else
 837     {
 838         path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
 839     }
 840 }
 841
 842 /*
 843  * fib_path_is_permanent_drop
 844  *
 845  * Return !0 if the path is configured to permanently drop,
 846  * despite other attributes.
 847  */
 848 static int
 849 fib_path_is_permanent_drop (fib_path_t *path)
 850 {
 851     return ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DROP) ||
 852             (path->fp_oper_flags & FIB_PATH_OPER_FLAG_DROP));
 853 }
 854
 855 /*
 856  * fib_path_unresolve
 857  *
 858  * Remove our dependency on the resolution target
 859  */
 860 static void
 861 fib_path_unresolve (fib_path_t *path)
 862 {
 863     /*
 864      * the forced drop path does not need unresolving
 865      */
 866     if (fib_path_is_permanent_drop(path))
 867     {
 868         return;
 869     }
 870
 871     switch (path->fp_type)
 872     {
 873     case FIB_PATH_TYPE_RECURSIVE:
 874         if (FIB_NODE_INDEX_INVALID != path->fp_via_fib)
 875         {
 876             fib_prefix_t pfx;
 877
 878             fib_entry_get_prefix(path->fp_via_fib, &pfx);
 879             fib_entry_child_remove(path->fp_via_fib,
 880                                    path->fp_sibling);
 881             fib_table_entry_special_remove(path->recursive.fp_tbl_id,
 882                                            &pfx,
 883                                            FIB_SOURCE_RR);
 884             path->fp_via_fib = FIB_NODE_INDEX_INVALID;
 885         }
 886         break;
 887     case FIB_PATH_TYPE_BIER_FMASK:
 888         bier_fmask_child_remove(path->fp_via_bier_fmask,
 889                                 path->fp_sibling);
 890         break;
 891     case FIB_PATH_TYPE_BIER_IMP:
 892         bier_imp_unlock(path->fp_dpo.dpoi_index);
 893         break;
 894     case FIB_PATH_TYPE_BIER_TABLE:
 895         bier_table_ecmp_unlock(path->fp_via_bier_tbl);
 896         break;
 897     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
 898         adj_child_remove(path->fp_dpo.dpoi_index,
 899                          path->fp_sibling);
 900         adj_unlock(path->fp_dpo.dpoi_index);
 901         break;
 902     case FIB_PATH_TYPE_ATTACHED:
 903         adj_child_remove(path->fp_dpo.dpoi_index,
 904                          path->fp_sibling);
 905         adj_unlock(path->fp_dpo.dpoi_index);
 906         break;
 907     case FIB_PATH_TYPE_UDP_ENCAP:
 908         udp_encap_unlock_w_index(path->fp_dpo.dpoi_index);
 909         break;
 910     case FIB_PATH_TYPE_EXCLUSIVE:
 911         dpo_reset(&path->exclusive.fp_ex_dpo);
 912         break;
 913     case FIB_PATH_TYPE_SPECIAL:
 914     case FIB_PATH_TYPE_RECEIVE:
 915     case FIB_PATH_TYPE_INTF_RX:
 916     case FIB_PATH_TYPE_DEAG:
 917     case FIB_PATH_TYPE_DVR:
 918         /*
 919          * these hold only the path's DPO, which is reset below.
 920          */
 921         break;
 922     }
 923
 924     /*
 925      * release the adj we were holding and pick up the
 926      * drop just in case.
 927      */
 928     dpo_reset(&path->fp_dpo);
 929     path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
 930
 931     return;
 932 }
 933
 934 static fib_forward_chain_type_t
 935 fib_path_to_chain_type (const fib_path_t *path)
 936 {
 937     if (DPO_PROTO_MPLS == path->fp_nh_proto)
 938     {
 939         if (FIB_PATH_TYPE_RECURSIVE == path->fp_type &&
 940             MPLS_EOS == path->recursive.fp_nh.fp_eos)
 941         {
 942             return (FIB_FORW_CHAIN_TYPE_MPLS_EOS);
 943         }
 944         else
 945         {
 946             return (FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS);
 947         }
 948     }
 949     else
 950     {
 951         return (fib_forw_chain_type_from_dpo_proto(path->fp_nh_proto));
 952     }
 953 }
 954
 955 /*
 956  * fib_path_back_walk_notify
 957  *
 958  * A back walk has reach this path.
 959  */
 960 static fib_node_back_walk_rc_t
 961 fib_path_back_walk_notify (fib_node_t *node,
 962                            fib_node_back_walk_ctx_t *ctx)
 963 {
 964     fib_path_t *path;
 965
 966     path = fib_path_from_fib_node(node);
 967
 968     switch (path->fp_type)
 969     {
 970     case FIB_PATH_TYPE_RECURSIVE:
 971         if (FIB_NODE_BW_REASON_FLAG_EVALUATE & ctx->fnbw_reason)
 972         {
 973             /*
 974              * modify the recursive adjacency to use the new forwarding
 975              * of the via-fib.
 976              * this update is visible to packets in flight in the DP.
 977              */
 978             fib_path_recursive_adj_update(
 979                 path,
 980                 fib_path_to_chain_type(path),
 981                 &path->fp_dpo);
 982         }
 983         if ((FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE & ctx->fnbw_reason) ||
 984             (FIB_NODE_BW_REASON_FLAG_ADJ_DOWN   & ctx->fnbw_reason))
 985         {
 986             /*
 987              * ADJ updates (complete<->incomplete) do not need to propagate to
 988              * recursive entries.
 989              * The only reason its needed as far back as here, is that the adj
 990              * and the incomplete adj are a different DPO type, so the LBs need
 991              * to re-stack.
 992              * If this walk was quashed in the fib_entry, then any non-fib_path
 993              * children (like tunnels that collapse out the LB when they stack)
 994              * would not see the update.
 995              */
 996             return (FIB_NODE_BACK_WALK_CONTINUE);
 997         }
 998         break;
 999     case FIB_PATH_TYPE_BIER_FMASK:
1000         if (FIB_NODE_BW_REASON_FLAG_EVALUATE & ctx->fnbw_reason)
1001         {
1002             /*
1003              * update to use the BIER fmask's new forwading
1004              */
1005             fib_path_bier_fmask_update(path, &path->fp_dpo);
1006         }
1007         if ((FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE & ctx->fnbw_reason) ||
1008             (FIB_NODE_BW_REASON_FLAG_ADJ_DOWN   & ctx->fnbw_reason))
1009         {
1010             /*
1011              * ADJ updates (complete<->incomplete) do not need to propagate to
1012              * recursive entries.
1013              * The only reason its needed as far back as here, is that the adj
1014              * and the incomplete adj are a different DPO type, so the LBs need
1015              * to re-stack.
1016              * If this walk was quashed in the fib_entry, then any non-fib_path
1017              * children (like tunnels that collapse out the LB when they stack)
1018              * would not see the update.
1019              */
1020             return (FIB_NODE_BACK_WALK_CONTINUE);
1021         }
1022         break;
1023     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
1024         /*
1025 FIXME comment
1026          * ADJ_UPDATE backwalk pass silently through here and up to
1027          * the path-list when the multipath adj collapse occurs.
1028          * The reason we do this is that the assumtption is that VPP
1029          * runs in an environment where the Control-Plane is remote
1030          * and hence reacts slowly to link up down. In order to remove
1031          * this down link from the ECMP set quickly, we back-walk.
1032          * VPP also has dedicated CPUs, so we are not stealing resources
1033          * from the CP to do so.
1034          */
1035         if (FIB_NODE_BW_REASON_FLAG_INTERFACE_UP & ctx->fnbw_reason)
1036         {
1037             if (path->fp_oper_flags & FIB_PATH_OPER_FLAG_RESOLVED)
1038             {
1039                 /*
1040                  * alreday resolved. no need to walk back again
1041                  */
1042                 return (FIB_NODE_BACK_WALK_CONTINUE);
1043             }
1044             path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
1045         }
1046         if (FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN & ctx->fnbw_reason)
1047         {
1048             if (!(path->fp_oper_flags & FIB_PATH_OPER_FLAG_RESOLVED))
1049             {
1050                 /*
1051                  * alreday unresolved. no need to walk back again
1052                  */
1053                 return (FIB_NODE_BACK_WALK_CONTINUE);
1054             }
1055             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1056         }
1057         if (FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE & ctx->fnbw_reason)
1058         {
1059             /*
1060              * The interface this path resolves through has been deleted.
1061              * This will leave the path in a permanent drop state. The route
1062              * needs to be removed and readded (and hence the path-list deleted)
1063              * before it can forward again.
1064              */
1065             fib_path_unresolve(path);
1066             path->fp_oper_flags |= FIB_PATH_OPER_FLAG_DROP;
1067         }
1068         if (FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE & ctx->fnbw_reason)
1069         {
1070             /*
1071              * restack the DPO to pick up the correct DPO sub-type
1072              */
1073             uword if_is_up;
1074             adj_index_t ai;
1075
1076             if_is_up = vnet_sw_interface_is_admin_up(
1077                            vnet_get_main(),
1078                            path->attached_next_hop.fp_interface);
1079
1080             ai = fib_path_attached_next_hop_get_adj(
1081                      path,
1082                      dpo_proto_to_link(path->fp_nh_proto));
1083
1084             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1085             if (if_is_up && adj_is_up(ai))
1086             {
1087                 path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
1088             }
1089
1090             dpo_set(&path->fp_dpo, DPO_ADJACENCY, path->fp_nh_proto, ai);
1091             adj_unlock(ai);
1092
1093             if (!if_is_up)
1094             {
1095                 /*
1096                  * If the interface is not up there is no reason to walk
1097                  * back to children. if we did they would only evalute
1098                  * that this path is unresolved and hence it would
1099                  * not contribute the adjacency - so it would be wasted
1100                  * CPU time.
1101                  */
1102                 return (FIB_NODE_BACK_WALK_CONTINUE);
1103             }
1104         }
1105         if (FIB_NODE_BW_REASON_FLAG_ADJ_DOWN & ctx->fnbw_reason)
1106         {
1107             if (!(path->fp_oper_flags & FIB_PATH_OPER_FLAG_RESOLVED))
1108             {
1109                 /*
1110                  * alreday unresolved. no need to walk back again
1111                  */
1112                 return (FIB_NODE_BACK_WALK_CONTINUE);
1113             }
1114             /*
1115              * the adj has gone down. the path is no longer resolved.
1116              */
1117             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1118         }
1119         break;
1120     case FIB_PATH_TYPE_ATTACHED:
1121     case FIB_PATH_TYPE_DVR:
1122         /*
1123          * FIXME; this could schedule a lower priority walk, since attached
1124          * routes are not usually in ECMP configurations so the backwalk to
1125          * the FIB entry does not need to be high priority
1126          */
1127         if (FIB_NODE_BW_REASON_FLAG_INTERFACE_UP & ctx->fnbw_reason)
1128         {
1129             path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
1130         }
1131         if (FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN & ctx->fnbw_reason)
1132         {
1133             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1134         }
1135         if (FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE & ctx->fnbw_reason)
1136         {
1137             fib_path_unresolve(path);
1138             path->fp_oper_flags |= FIB_PATH_OPER_FLAG_DROP;
1139         }
1140         break;
1141     case FIB_PATH_TYPE_UDP_ENCAP:
1142     {
1143         dpo_id_t via_dpo = DPO_INVALID;
1144
1145         /*
1146          * hope for the best - clear if restrictions apply.
1147          */
1148         path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
1149
1150         udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
1151                                         path->fp_nh_proto,
1152                                         &via_dpo);
1153         /*
1154          * If this path is contributing a drop, then it's not resolved
1155          */
1156         if (dpo_is_drop(&via_dpo) || load_balance_is_drop(&via_dpo))
1157         {
1158             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1159         }
1160
1161         /*
1162          * update the path's contributed DPO
1163          */
1164         dpo_copy(&path->fp_dpo, &via_dpo);
1165         dpo_reset(&via_dpo);
1166         break;
1167     }
1168     case FIB_PATH_TYPE_INTF_RX:
1169         ASSERT(0);
1170     case FIB_PATH_TYPE_DEAG:
1171         /*
1172          * FIXME When VRF delete is allowed this will need a poke.
1173          */
1174     case FIB_PATH_TYPE_SPECIAL:
1175     case FIB_PATH_TYPE_RECEIVE:
1176     case FIB_PATH_TYPE_EXCLUSIVE:
1177     case FIB_PATH_TYPE_BIER_TABLE:
1178     case FIB_PATH_TYPE_BIER_IMP:
1179         /*
1180          * these path types have no parents. so to be
1181          * walked from one is unexpected.
1182          */
1183         ASSERT(0);
1184         break;
1185     }
1186
1187     /*
1188      * propagate the backwalk further to the path-list
1189      */
1190     fib_path_list_back_walk(path->fp_pl_index, ctx);
1191
1192     return (FIB_NODE_BACK_WALK_CONTINUE);
1193 }
1194
1195 static void
1196 fib_path_memory_show (void)
1197 {
1198     fib_show_memory_usage("Path",
1199                           pool_elts(fib_path_pool),
1200                           pool_len(fib_path_pool),
1201                           sizeof(fib_path_t));
1202 }
1203
1204 /*
1205  * The FIB path's graph node virtual function table
1206  */
1207 static const fib_node_vft_t fib_path_vft = {
1208     .fnv_get = fib_path_get_node,
1209     .fnv_last_lock = fib_path_last_lock_gone,
1210     .fnv_back_walk = fib_path_back_walk_notify,
1211     .fnv_mem_show = fib_path_memory_show,
1212 };
1213
1214 static fib_path_cfg_flags_t
1215 fib_path_route_flags_to_cfg_flags (const fib_route_path_t *rpath)
1216 {
1217     fib_path_cfg_flags_t cfg_flags = FIB_PATH_CFG_FLAG_NONE;
1218
1219     if (rpath->frp_flags & FIB_ROUTE_PATH_RESOLVE_VIA_HOST)
1220         cfg_flags |= FIB_PATH_CFG_FLAG_RESOLVE_HOST;
1221     if (rpath->frp_flags & FIB_ROUTE_PATH_RESOLVE_VIA_ATTACHED)
1222         cfg_flags |= FIB_PATH_CFG_FLAG_RESOLVE_ATTACHED;
1223     if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL)
1224         cfg_flags |= FIB_PATH_CFG_FLAG_LOCAL;
1225     if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED)
1226         cfg_flags |= FIB_PATH_CFG_FLAG_ATTACHED;
1227     if (rpath->frp_flags & FIB_ROUTE_PATH_INTF_RX)
1228         cfg_flags |= FIB_PATH_CFG_FLAG_INTF_RX;
1229     if (rpath->frp_flags & FIB_ROUTE_PATH_RPF_ID)
1230         cfg_flags |= FIB_PATH_CFG_FLAG_RPF_ID;
1231     if (rpath->frp_flags & FIB_ROUTE_PATH_EXCLUSIVE)
1232         cfg_flags |= FIB_PATH_CFG_FLAG_EXCLUSIVE;
1233     if (rpath->frp_flags & FIB_ROUTE_PATH_DROP)
1234         cfg_flags |= FIB_PATH_CFG_FLAG_DROP;
1235     if (rpath->frp_flags & FIB_ROUTE_PATH_SOURCE_LOOKUP)
1236         cfg_flags |= FIB_PATH_CFG_FLAG_DEAG_SRC;
1237
1238     return (cfg_flags);
1239 }
1240
1241 /*
1242  * fib_path_create
1243  *
1244  * Create and initialise a new path object.
1245  * return the index of the path.
1246  */
1247 fib_node_index_t
1248 fib_path_create (fib_node_index_t pl_index,
1249                  const fib_route_path_t *rpath)
1250 {
1251     fib_path_t *path;
1252
1253     pool_get(fib_path_pool, path);
1254     memset(path, 0, sizeof(*path));
1255
1256     fib_node_init(&path->fp_node,
1257                   FIB_NODE_TYPE_PATH);
1258
1259     dpo_reset(&path->fp_dpo);
1260     path->fp_pl_index = pl_index;
1261     path->fp_nh_proto = rpath->frp_proto;
1262     path->fp_via_fib = FIB_NODE_INDEX_INVALID;
1263     path->fp_weight = rpath->frp_weight;
1264     if (0 == path->fp_weight)
1265     {
1266         /*
1267          * a weight of 0 is a meaningless value. We could either reject it, and thus force
1268          * clients to always use 1, or we can accept it and fixup approrpiately.
1269          */
1270         path->fp_weight = 1;
1271     }
1272     path->fp_preference = rpath->frp_preference;
1273     path->fp_cfg_flags = fib_path_route_flags_to_cfg_flags(rpath);
1274
1275     /*
1276      * deduce the path's tpye from the parementers and save what is needed.
1277      */
1278     if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_LOCAL)
1279     {
1280         path->fp_type = FIB_PATH_TYPE_RECEIVE;
1281         path->receive.fp_interface = rpath->frp_sw_if_index;
1282         path->receive.fp_addr = rpath->frp_addr;
1283     }
1284     else if (rpath->frp_flags & FIB_ROUTE_PATH_UDP_ENCAP)
1285     {
1286         path->fp_type = FIB_PATH_TYPE_UDP_ENCAP;
1287         path->udp_encap.fp_udp_encap_id = rpath->frp_udp_encap_id;
1288     }
1289     else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_INTF_RX)
1290     {
1291         path->fp_type = FIB_PATH_TYPE_INTF_RX;
1292         path->intf_rx.fp_interface = rpath->frp_sw_if_index;
1293     }
1294     else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID)
1295     {
1296         path->fp_type = FIB_PATH_TYPE_DEAG;
1297         path->deag.fp_tbl_id = rpath->frp_fib_index;
1298         path->deag.fp_rpf_id = rpath->frp_rpf_id;
1299     }
1300     else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_FMASK)
1301     {
1302         path->fp_type = FIB_PATH_TYPE_BIER_FMASK;
1303         path->bier_fmask.fp_bier_fmask = rpath->frp_bier_fmask;
1304     }
1305     else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_IMP)
1306     {
1307         path->fp_type = FIB_PATH_TYPE_BIER_IMP;
1308         path->bier_imp.fp_bier_imp = rpath->frp_bier_imp;
1309     }
1310     else if (rpath->frp_flags & FIB_ROUTE_PATH_BIER_TABLE)
1311     {
1312         path->fp_type = FIB_PATH_TYPE_BIER_TABLE;
1313         path->bier_table.fp_bier_tbl = rpath->frp_bier_tbl;
1314     }
1315     else if (rpath->frp_flags & FIB_ROUTE_PATH_DEAG)
1316     {
1317         path->fp_type = FIB_PATH_TYPE_DEAG;
1318         path->deag.fp_tbl_id = rpath->frp_fib_index;
1319     }
1320     else if (rpath->frp_flags & FIB_ROUTE_PATH_DVR)
1321     {
1322         path->fp_type = FIB_PATH_TYPE_DVR;
1323         path->dvr.fp_interface = rpath->frp_sw_if_index;
1324     }
1325     else if (~0 != rpath->frp_sw_if_index)
1326     {
1327         if (ip46_address_is_zero(&rpath->frp_addr))
1328         {
1329             path->fp_type = FIB_PATH_TYPE_ATTACHED;
1330             path->attached.fp_interface = rpath->frp_sw_if_index;
1331         }
1332         else
1333         {
1334             path->fp_type = FIB_PATH_TYPE_ATTACHED_NEXT_HOP;
1335             path->attached_next_hop.fp_interface = rpath->frp_sw_if_index;
1336             path->attached_next_hop.fp_nh = rpath->frp_addr;
1337         }
1338     }
1339     else
1340     {
1341         if (ip46_address_is_zero(&rpath->frp_addr))
1342         {
1343             if (~0 == rpath->frp_fib_index)
1344             {
1345                 path->fp_type = FIB_PATH_TYPE_SPECIAL;
1346             }
1347             else
1348             {
1349                 path->fp_type = FIB_PATH_TYPE_DEAG;
1350                 path->deag.fp_tbl_id = rpath->frp_fib_index;
1351             }
1352         }
1353         else
1354         {
1355             path->fp_type = FIB_PATH_TYPE_RECURSIVE;
1356             if (DPO_PROTO_MPLS == path->fp_nh_proto)
1357             {
1358                 path->recursive.fp_nh.fp_local_label = rpath->frp_local_label;
1359                 path->recursive.fp_nh.fp_eos = rpath->frp_eos;
1360             }
1361             else
1362             {
1363                 path->recursive.fp_nh.fp_ip = rpath->frp_addr;
1364             }
1365             path->recursive.fp_tbl_id = rpath->frp_fib_index;
1366         }
1367     }
1368
1369     FIB_PATH_DBG(path, "create");
1370
1371     return (fib_path_get_index(path));
1372 }
1373
1374 /*
1375  * fib_path_create_special
1376  *
1377  * Create and initialise a new path object.
1378  * return the index of the path.
1379  */
1380 fib_node_index_t
1381 fib_path_create_special (fib_node_index_t pl_index,
1382                          dpo_proto_t nh_proto,
1383                          fib_path_cfg_flags_t flags,
1384                          const dpo_id_t *dpo)
1385 {
1386     fib_path_t *path;
1387
1388     pool_get(fib_path_pool, path);
1389     memset(path, 0, sizeof(*path));
1390
1391     fib_node_init(&path->fp_node,
1392                   FIB_NODE_TYPE_PATH);
1393     dpo_reset(&path->fp_dpo);
1394
1395     path->fp_pl_index = pl_index;
1396     path->fp_weight = 1;
1397     path->fp_preference = 0;
1398     path->fp_nh_proto = nh_proto;
1399     path->fp_via_fib = FIB_NODE_INDEX_INVALID;
1400     path->fp_cfg_flags = flags;
1401
1402     if (FIB_PATH_CFG_FLAG_DROP & flags)
1403     {
1404         path->fp_type = FIB_PATH_TYPE_SPECIAL;
1405     }
1406     else if (FIB_PATH_CFG_FLAG_LOCAL & flags)
1407     {
1408         path->fp_type = FIB_PATH_TYPE_RECEIVE;
1409         path->attached.fp_interface = FIB_NODE_INDEX_INVALID;
1410     }
1411     else
1412     {
1413         path->fp_type = FIB_PATH_TYPE_EXCLUSIVE;
1414         ASSERT(NULL != dpo);
1415         dpo_copy(&path->exclusive.fp_ex_dpo, dpo);
1416     }
1417
1418     return (fib_path_get_index(path));
1419 }
1420
1421 /*
1422  * fib_path_copy
1423  *
1424  * Copy a path. return index of new path.
1425  */
1426 fib_node_index_t
1427 fib_path_copy (fib_node_index_t path_index,
1428                fib_node_index_t path_list_index)
1429 {
1430     fib_path_t *path, *orig_path;
1431
1432     pool_get(fib_path_pool, path);
1433
1434     orig_path = fib_path_get(path_index);
1435     ASSERT(NULL != orig_path);
1436
1437     memcpy(path, orig_path, sizeof(*path));
1438
1439     FIB_PATH_DBG(path, "create-copy:%d", path_index);
1440
1441     /*
1442      * reset the dynamic section
1443      */
1444     fib_node_init(&path->fp_node, FIB_NODE_TYPE_PATH);
1445     path->fp_oper_flags     = FIB_PATH_OPER_FLAG_NONE;
1446     path->fp_pl_index  = path_list_index;
1447     path->fp_via_fib   = FIB_NODE_INDEX_INVALID;
1448     memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
1449     dpo_reset(&path->fp_dpo);
1450
1451     return (fib_path_get_index(path));
1452 }
1453
1454 /*
1455  * fib_path_destroy
1456  *
1457  * destroy a path that is no longer required
1458  */
1459 void
1460 fib_path_destroy (fib_node_index_t path_index)
1461 {
1462     fib_path_t *path;
1463
1464     path = fib_path_get(path_index);
1465
1466     ASSERT(NULL != path);
1467     FIB_PATH_DBG(path, "destroy");
1468
1469     fib_path_unresolve(path);
1470
1471     fib_node_deinit(&path->fp_node);
1472     pool_put(fib_path_pool, path);
1473 }
1474
1475 /*
1476  * fib_path_destroy
1477  *
1478  * destroy a path that is no longer required
1479  */
1480 uword
1481 fib_path_hash (fib_node_index_t path_index)
1482 {
1483     fib_path_t *path;
1484
1485     path = fib_path_get(path_index);
1486
1487     return (hash_memory(STRUCT_MARK_PTR(path, path_hash_start),
1488                         (STRUCT_OFFSET_OF(fib_path_t, path_hash_end) -
1489                          STRUCT_OFFSET_OF(fib_path_t, path_hash_start)),
1490                         0));
1491 }
1492
1493 /*
1494  * fib_path_cmp_i
1495  *
1496  * Compare two paths for equivalence.
1497  */
1498 static int
1499 fib_path_cmp_i (const fib_path_t *path1,
1500                 const fib_path_t *path2)
1501 {
1502     int res;
1503
1504     res = 1;
1505
1506     /*
1507      * paths of different types and protocol are not equal.
1508      * different weights and/or preference only are the same path.
1509      */
1510     if (path1->fp_type != path2->fp_type)
1511     {
1512         res = (path1->fp_type - path2->fp_type);
1513     }
1514     else if (path1->fp_nh_proto != path2->fp_nh_proto)
1515     {
1516         res = (path1->fp_nh_proto - path2->fp_nh_proto);
1517     }
1518     else
1519     {
1520         /*
1521          * both paths are of the same type.
1522          * consider each type and its attributes in turn.
1523          */
1524         switch (path1->fp_type)
1525         {
1526         case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
1527             res = ip46_address_cmp(&path1->attached_next_hop.fp_nh,
1528                                    &path2->attached_next_hop.fp_nh);
1529             if (0 == res) {
1530                 res = (path1->attached_next_hop.fp_interface -
1531                        path2->attached_next_hop.fp_interface);
1532             }
1533             break;
1534         case FIB_PATH_TYPE_ATTACHED:
1535             res = (path1->attached.fp_interface -
1536                    path2->attached.fp_interface);
1537             break;
1538         case FIB_PATH_TYPE_RECURSIVE:
1539             res = ip46_address_cmp(&path1->recursive.fp_nh,
1540                                    &path2->recursive.fp_nh);
1541
1542             if (0 == res)
1543             {
1544                 res = (path1->recursive.fp_tbl_id - path2->recursive.fp_tbl_id);
1545             }
1546             break;
1547         case FIB_PATH_TYPE_BIER_FMASK:
1548             res = (path1->bier_fmask.fp_bier_fmask -
1549                    path2->bier_fmask.fp_bier_fmask);
1550             break;
1551         case FIB_PATH_TYPE_BIER_IMP:
1552             res = (path1->bier_imp.fp_bier_imp -
1553                    path2->bier_imp.fp_bier_imp);
1554             break;
1555         case FIB_PATH_TYPE_BIER_TABLE:
1556             res = bier_table_id_cmp(&path1->bier_table.fp_bier_tbl,
1557                                     &path2->bier_table.fp_bier_tbl);
1558             break;
1559         case FIB_PATH_TYPE_DEAG:
1560             res = (path1->deag.fp_tbl_id - path2->deag.fp_tbl_id);
1561             if (0 == res)
1562             {
1563                 res = (path1->deag.fp_rpf_id - path2->deag.fp_rpf_id);
1564             }
1565             break;
1566         case FIB_PATH_TYPE_INTF_RX:
1567             res = (path1->intf_rx.fp_interface - path2->intf_rx.fp_interface);
1568             break;
1569         case FIB_PATH_TYPE_UDP_ENCAP:
1570             res = (path1->udp_encap.fp_udp_encap_id - path2->udp_encap.fp_udp_encap_id);
1571             break;
1572         case FIB_PATH_TYPE_DVR:
1573             res = (path1->dvr.fp_interface - path2->dvr.fp_interface);
1574             break;
1575         case FIB_PATH_TYPE_SPECIAL:
1576         case FIB_PATH_TYPE_RECEIVE:
1577         case FIB_PATH_TYPE_EXCLUSIVE:
1578             res = 0;
1579             break;
1580         }
1581     }
1582     return (res);
1583 }
1584
1585 /*
1586  * fib_path_cmp_for_sort
1587  *
1588  * Compare two paths for equivalence. Used during path sorting.
1589  * As usual 0 means equal.
1590  */
1591 int
1592 fib_path_cmp_for_sort (void * v1,
1593                        void * v2)
1594 {
1595     fib_node_index_t *pi1 = v1, *pi2 = v2;
1596     fib_path_t *path1, *path2;
1597
1598     path1 = fib_path_get(*pi1);
1599     path2 = fib_path_get(*pi2);
1600
1601     /*
1602      * when sorting paths we want the highest preference paths
1603      * first, so that the choices set built is in prefernce order
1604      */
1605     if (path1->fp_preference != path2->fp_preference)
1606     {
1607         return (path1->fp_preference - path2->fp_preference);
1608     }
1609
1610     return (fib_path_cmp_i(path1, path2));
1611 }
1612
1613 /*
1614  * fib_path_cmp
1615  *
1616  * Compare two paths for equivalence.
1617  */
1618 int
1619 fib_path_cmp (fib_node_index_t pi1,
1620               fib_node_index_t pi2)
1621 {
1622     fib_path_t *path1, *path2;
1623
1624     path1 = fib_path_get(pi1);
1625     path2 = fib_path_get(pi2);
1626
1627     return (fib_path_cmp_i(path1, path2));
1628 }
1629
1630 int
1631 fib_path_cmp_w_route_path (fib_node_index_t path_index,
1632                            const fib_route_path_t *rpath)
1633 {
1634     fib_path_t *path;
1635     int res;
1636
1637     path = fib_path_get(path_index);
1638
1639     res = 1;
1640
1641     if (path->fp_weight != rpath->frp_weight)
1642     {
1643         res = (path->fp_weight - rpath->frp_weight);
1644     }
1645     else
1646     {
1647         /*
1648          * both paths are of the same type.
1649          * consider each type and its attributes in turn.
1650          */
1651         switch (path->fp_type)
1652         {
1653         case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
1654             res = ip46_address_cmp(&path->attached_next_hop.fp_nh,
1655                                    &rpath->frp_addr);
1656             if (0 == res)
1657             {
1658                 res = (path->attached_next_hop.fp_interface -
1659                        rpath->frp_sw_if_index);
1660             }
1661             break;
1662         case FIB_PATH_TYPE_ATTACHED:
1663             res = (path->attached.fp_interface - rpath->frp_sw_if_index);
1664             break;
1665         case FIB_PATH_TYPE_RECURSIVE:
1666             if (DPO_PROTO_MPLS == path->fp_nh_proto)
1667             {
1668                 res = path->recursive.fp_nh.fp_local_label - rpath->frp_local_label;
1669
1670                 if (res == 0)
1671                 {
1672                     res = path->recursive.fp_nh.fp_eos - rpath->frp_eos;
1673                 }
1674             }
1675             else
1676             {
1677                 res = ip46_address_cmp(&path->recursive.fp_nh.fp_ip,
1678                                        &rpath->frp_addr);
1679             }
1680
1681             if (0 == res)
1682             {
1683                 res = (path->recursive.fp_tbl_id - rpath->frp_fib_index);
1684             }
1685             break;
1686         case FIB_PATH_TYPE_BIER_FMASK:
1687             res = (path->bier_fmask.fp_bier_fmask - rpath->frp_bier_fmask);
1688             break;
1689         case FIB_PATH_TYPE_BIER_IMP:
1690             res = (path->bier_imp.fp_bier_imp - rpath->frp_bier_imp);
1691             break;
1692         case FIB_PATH_TYPE_BIER_TABLE:
1693             res = bier_table_id_cmp(&path->bier_table.fp_bier_tbl,
1694                                     &rpath->frp_bier_tbl);
1695             break;
1696         case FIB_PATH_TYPE_INTF_RX:
1697             res = (path->intf_rx.fp_interface - rpath->frp_sw_if_index);
1698             break;
1699         case FIB_PATH_TYPE_UDP_ENCAP:
1700             res = (path->udp_encap.fp_udp_encap_id - rpath->frp_udp_encap_id);
1701             break;
1702         case FIB_PATH_TYPE_DEAG:
1703             res = (path->deag.fp_tbl_id - rpath->frp_fib_index);
1704             if (0 == res)
1705             {
1706                 res = (path->deag.fp_rpf_id - rpath->frp_rpf_id);
1707             }
1708             break;
1709         case FIB_PATH_TYPE_DVR:
1710             res = (path->dvr.fp_interface - rpath->frp_sw_if_index);
1711             break;
1712         case FIB_PATH_TYPE_SPECIAL:
1713         case FIB_PATH_TYPE_RECEIVE:
1714         case FIB_PATH_TYPE_EXCLUSIVE:
1715             res = 0;
1716             break;
1717         }
1718     }
1719     return (res);
1720 }
1721
1722 /*
1723  * fib_path_recursive_loop_detect
1724  *
1725  * A forward walk of the FIB object graph to detect for a cycle/loop. This
1726  * walk is initiated when an entry is linking to a new path list or from an old.
1727  * The entry vector passed contains all the FIB entrys that are children of this
1728  * path (it is all the entries encountered on the walk so far). If this vector
1729  * contains the entry this path resolve via, then a loop is about to form.
1730  * The loop must be allowed to form, since we need the dependencies in place
1731  * so that we can track when the loop breaks.
1732  * However, we MUST not produce a loop in the forwarding graph (else packets
1733  * would loop around the switch path until the loop breaks), so we mark recursive
1734  * paths as looped so that they do not contribute forwarding information.
1735  * By marking the path as looped, an etry such as;
1736  *    X/Y
1737  *     via a.a.a.a (looped)
1738  *     via b.b.b.b (not looped)
1739  * can still forward using the info provided by b.b.b.b only
1740  */
1741 int
1742 fib_path_recursive_loop_detect (fib_node_index_t path_index,
1743                                 fib_node_index_t **entry_indicies)
1744 {
1745     fib_path_t *path;
1746
1747     path = fib_path_get(path_index);
1748
1749     /*
1750      * the forced drop path is never looped, cos it is never resolved.
1751      */
1752     if (fib_path_is_permanent_drop(path))
1753     {
1754         return (0);
1755     }
1756
1757     switch (path->fp_type)
1758     {
1759     case FIB_PATH_TYPE_RECURSIVE:
1760     {
1761         fib_node_index_t *entry_index, *entries;
1762         int looped = 0;
1763         entries = *entry_indicies;
1764
1765         vec_foreach(entry_index, entries) {
1766             if (*entry_index == path->fp_via_fib)
1767             {
1768                 /*
1769                  * the entry that is about to link to this path-list (or
1770                  * one of this path-list's children) is the same entry that
1771                  * this recursive path resolves through. this is a cycle.
1772                  * abort the walk.
1773                  */
1774                 looped = 1;
1775                 break;
1776             }
1777         }
1778
1779         if (looped)
1780         {
1781             FIB_PATH_DBG(path, "recursive loop formed");
1782             path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
1783
1784             dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1785         }
1786         else
1787         {
1788             /*
1789              * no loop here yet. keep forward walking the graph.
1790              */
1791             if (fib_entry_recursive_loop_detect(path->fp_via_fib, entry_indicies))
1792             {
1793                 FIB_PATH_DBG(path, "recursive loop formed");
1794                 path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
1795             }
1796             else
1797             {
1798                 FIB_PATH_DBG(path, "recursive loop cleared");
1799                 path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
1800             }
1801         }
1802         break;
1803     }
1804     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
1805     case FIB_PATH_TYPE_ATTACHED:
1806     case FIB_PATH_TYPE_SPECIAL:
1807     case FIB_PATH_TYPE_DEAG:
1808     case FIB_PATH_TYPE_DVR:
1809     case FIB_PATH_TYPE_RECEIVE:
1810     case FIB_PATH_TYPE_INTF_RX:
1811     case FIB_PATH_TYPE_UDP_ENCAP:
1812     case FIB_PATH_TYPE_EXCLUSIVE:
1813     case FIB_PATH_TYPE_BIER_FMASK:
1814     case FIB_PATH_TYPE_BIER_TABLE:
1815     case FIB_PATH_TYPE_BIER_IMP:
1816         /*
1817          * these path types cannot be part of a loop, since they are the leaves
1818          * of the graph.
1819          */
1820         break;
1821     }
1822
1823     return (fib_path_is_looped(path_index));
1824 }
1825
1826 int
1827 fib_path_resolve (fib_node_index_t path_index)
1828 {
1829     fib_path_t *path;
1830
1831     path = fib_path_get(path_index);
1832
1833     /*
1834      * hope for the best.
1835      */
1836     path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED;
1837
1838     /*
1839      * the forced drop path resolves via the drop adj
1840      */
1841     if (fib_path_is_permanent_drop(path))
1842     {
1843         dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1844         path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1845         return (fib_path_is_resolved(path_index));
1846     }
1847
1848     switch (path->fp_type)
1849     {
1850     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
1851         fib_path_attached_next_hop_set(path);
1852         break;
1853     case FIB_PATH_TYPE_ATTACHED:
1854         /*
1855          * path->attached.fp_interface
1856          */
1857         if (!vnet_sw_interface_is_admin_up(vnet_get_main(),
1858                                            path->attached.fp_interface))
1859         {
1860             path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
1861         }
1862         dpo_set(&path->fp_dpo,
1863                 DPO_ADJACENCY,
1864                 path->fp_nh_proto,
1865                 fib_path_attached_get_adj(path,
1866                                           dpo_proto_to_link(path->fp_nh_proto)));
1867
1868         /*
1869          * become a child of the adjacency so we receive updates
1870          * when the interface state changes
1871          */
1872         path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
1873                                          FIB_NODE_TYPE_PATH,
1874                                          fib_path_get_index(path));
1875         break;
1876     case FIB_PATH_TYPE_RECURSIVE:
1877     {
1878         /*
1879          * Create a RR source entry in the table for the address
1880          * that this path recurses through.
1881          * This resolve action is recursive, hence we may create
1882          * more paths in the process. more creates mean maybe realloc
1883          * of this path.
1884          */
1885         fib_node_index_t fei;
1886         fib_prefix_t pfx;
1887
1888         ASSERT(FIB_NODE_INDEX_INVALID == path->fp_via_fib);
1889
1890         if (DPO_PROTO_MPLS == path->fp_nh_proto)
1891         {
1892             fib_prefix_from_mpls_label(path->recursive.fp_nh.fp_local_label,
1893                                        path->recursive.fp_nh.fp_eos,
1894                                        &pfx);
1895         }
1896         else
1897         {
1898             fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx);
1899         }
1900
1901         fei = fib_table_entry_special_add(path->recursive.fp_tbl_id,
1902                                           &pfx,
1903                                           FIB_SOURCE_RR,
1904                                           FIB_ENTRY_FLAG_NONE);
1905
1906         path = fib_path_get(path_index);
1907         path->fp_via_fib = fei;
1908
1909         /*
1910          * become a dependent child of the entry so the path is
1911          * informed when the forwarding for the entry changes.
1912          */
1913         path->fp_sibling = fib_entry_child_add(path->fp_via_fib,
1914                                                FIB_NODE_TYPE_PATH,
1915                                                fib_path_get_index(path));
1916
1917         /*
1918          * create and configure the IP DPO
1919          */
1920         fib_path_recursive_adj_update(
1921             path,
1922             fib_path_to_chain_type(path),
1923             &path->fp_dpo);
1924
1925         break;
1926     }
1927     case FIB_PATH_TYPE_BIER_FMASK:
1928     {
1929         /*
1930          * become a dependent child of the entry so the path is
1931          * informed when the forwarding for the entry changes.
1932          */
1933         path->fp_sibling = bier_fmask_child_add(path->bier_fmask.fp_bier_fmask,
1934                                                 FIB_NODE_TYPE_PATH,
1935                                                 fib_path_get_index(path));
1936
1937         path->fp_via_bier_fmask = path->bier_fmask.fp_bier_fmask;
1938         fib_path_bier_fmask_update(path, &path->fp_dpo);
1939
1940         break;
1941     }
1942     case FIB_PATH_TYPE_BIER_IMP:
1943         bier_imp_lock(path->bier_imp.fp_bier_imp);
1944         bier_imp_contribute_forwarding(path->bier_imp.fp_bier_imp,
1945                                        DPO_PROTO_IP4,
1946                                        &path->fp_dpo);
1947         break;
1948     case FIB_PATH_TYPE_BIER_TABLE:
1949     {
1950         /*
1951          * Find/create the BIER table to link to
1952          */
1953         ASSERT(FIB_NODE_INDEX_INVALID == path->fp_via_bier_tbl);
1954
1955         path->fp_via_bier_tbl =
1956             bier_table_ecmp_create_and_lock(&path->bier_table.fp_bier_tbl);
1957
1958         bier_table_contribute_forwarding(path->fp_via_bier_tbl,
1959                                          &path->fp_dpo);
1960         break;
1961     }
1962     case FIB_PATH_TYPE_SPECIAL:
1963         /*
1964          * Resolve via the drop
1965          */
1966         dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
1967         break;
1968     case FIB_PATH_TYPE_DEAG:
1969     {
1970         if (DPO_PROTO_BIER == path->fp_nh_proto)
1971         {
1972             bier_disp_table_contribute_forwarding(path->deag.fp_tbl_id,
1973                                                   &path->fp_dpo);
1974         }
1975         else
1976         {
1977             /*
1978              * Resolve via a lookup DPO.
1979              * FIXME. control plane should add routes with a table ID
1980              */
1981             lookup_input_t input;
1982             lookup_cast_t cast;
1983
1984             cast = (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ?
1985                     LOOKUP_MULTICAST :
1986                     LOOKUP_UNICAST);
1987             input = (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DEAG_SRC ?
1988                      LOOKUP_INPUT_SRC_ADDR :
1989                      LOOKUP_INPUT_DST_ADDR);
1990
1991             lookup_dpo_add_or_lock_w_fib_index(path->deag.fp_tbl_id,
1992                                                path->fp_nh_proto,
1993                                                cast,
1994                                                input,
1995                                                LOOKUP_TABLE_FROM_CONFIG,
1996                                                &path->fp_dpo);
1997         }
1998         break;
1999     }
2000     case FIB_PATH_TYPE_DVR:
2001         dvr_dpo_add_or_lock(path->attached.fp_interface,
2002                             path->fp_nh_proto,
2003                             &path->fp_dpo);
2004         break;
2005     case FIB_PATH_TYPE_RECEIVE:
2006         /*
2007          * Resolve via a receive DPO.
2008          */
2009         receive_dpo_add_or_lock(path->fp_nh_proto,
2010                                 path->receive.fp_interface,
2011                                 &path->receive.fp_addr,
2012                                 &path->fp_dpo);
2013         break;
2014     case FIB_PATH_TYPE_UDP_ENCAP:
2015         udp_encap_lock(path->udp_encap.fp_udp_encap_id);
2016         udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
2017                                         path->fp_nh_proto,
2018                                         &path->fp_dpo);
2019         break;
2020     case FIB_PATH_TYPE_INTF_RX: {
2021         /*
2022          * Resolve via a receive DPO.
2023          */
2024         interface_rx_dpo_add_or_lock(path->fp_nh_proto,
2025                                      path->intf_rx.fp_interface,
2026                                      &path->fp_dpo);
2027         break;
2028     }
2029     case FIB_PATH_TYPE_EXCLUSIVE:
2030         /*
2031          * Resolve via the user provided DPO
2032          */
2033         dpo_copy(&path->fp_dpo, &path->exclusive.fp_ex_dpo);
2034         break;
2035     }
2036
2037     return (fib_path_is_resolved(path_index));
2038 }
2039
2040 u32
2041 fib_path_get_resolving_interface (fib_node_index_t path_index)
2042 {
2043     fib_path_t *path;
2044
2045     path = fib_path_get(path_index);
2046
2047     switch (path->fp_type)
2048     {
2049     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
2050         return (path->attached_next_hop.fp_interface);
2051     case FIB_PATH_TYPE_ATTACHED:
2052         return (path->attached.fp_interface);
2053     case FIB_PATH_TYPE_RECEIVE:
2054         return (path->receive.fp_interface);
2055     case FIB_PATH_TYPE_RECURSIVE:
2056         if (fib_path_is_resolved(path_index))
2057         {
2058             return (fib_entry_get_resolving_interface(path->fp_via_fib));
2059         }
2060         break;
2061     case FIB_PATH_TYPE_DVR:
2062         return (path->dvr.fp_interface);
2063     case FIB_PATH_TYPE_INTF_RX:
2064     case FIB_PATH_TYPE_UDP_ENCAP:
2065     case FIB_PATH_TYPE_SPECIAL:
2066     case FIB_PATH_TYPE_DEAG:
2067     case FIB_PATH_TYPE_EXCLUSIVE:
2068     case FIB_PATH_TYPE_BIER_FMASK:
2069     case FIB_PATH_TYPE_BIER_TABLE:
2070     case FIB_PATH_TYPE_BIER_IMP:
2071         break;
2072     }
2073     return (~0);
2074 }
2075
2076 index_t
2077 fib_path_get_resolving_index (fib_node_index_t path_index)
2078 {
2079     fib_path_t *path;
2080
2081     path = fib_path_get(path_index);
2082
2083     switch (path->fp_type)
2084     {
2085     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
2086     case FIB_PATH_TYPE_ATTACHED:
2087     case FIB_PATH_TYPE_RECEIVE:
2088     case FIB_PATH_TYPE_INTF_RX:
2089     case FIB_PATH_TYPE_SPECIAL:
2090     case FIB_PATH_TYPE_DEAG:
2091     case FIB_PATH_TYPE_DVR:
2092     case FIB_PATH_TYPE_EXCLUSIVE:
2093         break;
2094     case FIB_PATH_TYPE_UDP_ENCAP:
2095         return (path->udp_encap.fp_udp_encap_id);
2096     case FIB_PATH_TYPE_RECURSIVE:
2097         return (path->fp_via_fib);
2098     case FIB_PATH_TYPE_BIER_FMASK:
2099         return (path->bier_fmask.fp_bier_fmask);
2100    case FIB_PATH_TYPE_BIER_TABLE:
2101        return (path->fp_via_bier_tbl);
2102    case FIB_PATH_TYPE_BIER_IMP:
2103        return (path->bier_imp.fp_bier_imp);
2104     }
2105     return (~0);
2106 }
2107
2108 adj_index_t
2109 fib_path_get_adj (fib_node_index_t path_index)
2110 {
2111     fib_path_t *path;
2112
2113     path = fib_path_get(path_index);
2114
2115     ASSERT(dpo_is_adj(&path->fp_dpo));
2116     if (dpo_is_adj(&path->fp_dpo))
2117     {
2118         return (path->fp_dpo.dpoi_index);
2119     }
2120     return (ADJ_INDEX_INVALID);
2121 }
2122
2123 u16
2124 fib_path_get_weight (fib_node_index_t path_index)
2125 {
2126     fib_path_t *path;
2127
2128     path = fib_path_get(path_index);
2129
2130     ASSERT(path);
2131
2132     return (path->fp_weight);
2133 }
2134
2135 u16
2136 fib_path_get_preference (fib_node_index_t path_index)
2137 {
2138     fib_path_t *path;
2139
2140     path = fib_path_get(path_index);
2141
2142     ASSERT(path);
2143
2144     return (path->fp_preference);
2145 }
2146
2147 u32
2148 fib_path_get_rpf_id (fib_node_index_t path_index)
2149 {
2150     fib_path_t *path;
2151
2152     path = fib_path_get(path_index);
2153
2154     ASSERT(path);
2155
2156     if (FIB_PATH_CFG_FLAG_RPF_ID & path->fp_cfg_flags)
2157     {
2158         return (path->deag.fp_rpf_id);
2159     }
2160
2161     return (~0);
2162 }
2163
2164 /**
2165  * @brief Contribute the path's adjacency to the list passed.
2166  * By calling this function over all paths, recursively, a child
2167  * can construct its full set of forwarding adjacencies, and hence its
2168  * uRPF list.
2169  */
2170 void
2171 fib_path_contribute_urpf (fib_node_index_t path_index,
2172                           index_t urpf)
2173 {
2174     fib_path_t *path;
2175
2176     path = fib_path_get(path_index);
2177
2178     /*
2179      * resolved and unresolved paths contribute to the RPF list.
2180      */
2181     switch (path->fp_type)
2182     {
2183     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
2184         fib_urpf_list_append(urpf, path->attached_next_hop.fp_interface);
2185         break;
2186
2187     case FIB_PATH_TYPE_ATTACHED:
2188         fib_urpf_list_append(urpf, path->attached.fp_interface);
2189         break;
2190
2191     case FIB_PATH_TYPE_RECURSIVE:
2192         if (FIB_NODE_INDEX_INVALID != path->fp_via_fib &&
2193             !fib_path_is_looped(path_index))
2194         {
2195             /*
2196              * there's unresolved due to constraints, and there's unresolved
2197              * due to ain't got no via. can't do nowt w'out via.
2198              */
2199             fib_entry_contribute_urpf(path->fp_via_fib, urpf);
2200         }
2201         break;
2202
2203     case FIB_PATH_TYPE_EXCLUSIVE:
2204     case FIB_PATH_TYPE_SPECIAL:
2205     {
2206         /*
2207          * these path types may link to an adj, if that's what
2208          * the clinet gave
2209          */
2210         u32 rpf_sw_if_index;
2211
2212         rpf_sw_if_index = dpo_get_urpf(&path->fp_dpo);
2213
2214         if (~0 != rpf_sw_if_index)
2215         {
2216             fib_urpf_list_append(urpf, rpf_sw_if_index);
2217         }
2218         break;
2219     }
2220     case FIB_PATH_TYPE_DVR:
2221         fib_urpf_list_append(urpf, path->dvr.fp_interface);
2222         break;
2223     case FIB_PATH_TYPE_DEAG:
2224     case FIB_PATH_TYPE_RECEIVE:
2225     case FIB_PATH_TYPE_INTF_RX:
2226     case FIB_PATH_TYPE_UDP_ENCAP:
2227     case FIB_PATH_TYPE_BIER_FMASK:
2228     case FIB_PATH_TYPE_BIER_TABLE:
2229     case FIB_PATH_TYPE_BIER_IMP:
2230         /*
2231          * these path types don't link to an adj
2232          */
2233         break;
2234     }
2235 }
2236
2237 void
2238 fib_path_stack_mpls_disp (fib_node_index_t path_index,
2239                           dpo_proto_t payload_proto,
2240                           dpo_id_t *dpo)
2241 {
2242     fib_path_t *path;
2243
2244     path = fib_path_get(path_index);
2245
2246     ASSERT(path);
2247
2248     switch (path->fp_type)
2249     {
2250     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
2251     {
2252         dpo_id_t tmp = DPO_INVALID;
2253
2254         dpo_copy(&tmp, dpo);
2255         dpo_set(dpo,
2256                 DPO_MPLS_DISPOSITION,
2257                 payload_proto,
2258                 mpls_disp_dpo_create(payload_proto, ~0, &tmp));
2259         dpo_reset(&tmp);
2260         break;
2261     }
2262     case FIB_PATH_TYPE_DEAG:
2263     {
2264         dpo_id_t tmp = DPO_INVALID;
2265
2266         dpo_copy(&tmp, dpo);
2267         dpo_set(dpo,
2268                 DPO_MPLS_DISPOSITION,
2269                 payload_proto,
2270                 mpls_disp_dpo_create(payload_proto,
2271                                      path->deag.fp_rpf_id,
2272                                      &tmp));
2273         dpo_reset(&tmp);
2274         break;
2275     }
2276     case FIB_PATH_TYPE_RECEIVE:
2277     case FIB_PATH_TYPE_ATTACHED:
2278     case FIB_PATH_TYPE_RECURSIVE:
2279     case FIB_PATH_TYPE_INTF_RX:
2280     case FIB_PATH_TYPE_UDP_ENCAP:
2281     case FIB_PATH_TYPE_EXCLUSIVE:
2282     case FIB_PATH_TYPE_SPECIAL:
2283     case FIB_PATH_TYPE_BIER_FMASK:
2284     case FIB_PATH_TYPE_BIER_TABLE:
2285     case FIB_PATH_TYPE_BIER_IMP:
2286     case FIB_PATH_TYPE_DVR:
2287         break;
2288     }
2289 }
2290
2291 void
2292 fib_path_contribute_forwarding (fib_node_index_t path_index,
2293                                 fib_forward_chain_type_t fct,
2294                                 dpo_id_t *dpo)
2295 {
2296     fib_path_t *path;
2297
2298     path = fib_path_get(path_index);
2299
2300     ASSERT(path);
2301     ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS != fct);
2302
2303     FIB_PATH_DBG(path, "contribute");
2304
2305     /*
2306      * The DPO stored in the path was created when the path was resolved.
2307      * This then represents the path's 'native' protocol; IP.
2308      * For all others will need to go find something else.
2309      */
2310     if (fib_path_to_chain_type(path) == fct)
2311     {
2312         dpo_copy(dpo, &path->fp_dpo);
2313     }
2314     else
2315     {
2316         switch (path->fp_type)
2317         {
2318         case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
2319             switch (fct)
2320             {
2321             case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
2322             case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
2323             case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
2324             case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
2325             case FIB_FORW_CHAIN_TYPE_ETHERNET:
2326             case FIB_FORW_CHAIN_TYPE_NSH:
2327             {
2328                 adj_index_t ai;
2329
2330                 /*
2331                  * get a appropriate link type adj.
2332                  */
2333                 ai = fib_path_attached_next_hop_get_adj(
2334                          path,
2335                          fib_forw_chain_type_to_link_type(fct));
2336                 dpo_set(dpo, DPO_ADJACENCY,
2337                         fib_forw_chain_type_to_dpo_proto(fct), ai);
2338                 adj_unlock(ai);
2339
2340                 break;
2341             }
2342             case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
2343             case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
2344             case FIB_FORW_CHAIN_TYPE_BIER:
2345                 break;
2346             }
2347             break;
2348         case FIB_PATH_TYPE_RECURSIVE:
2349             switch (fct)
2350             {
2351             case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
2352             case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
2353             case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
2354             case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
2355             case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
2356             case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
2357             case FIB_FORW_CHAIN_TYPE_BIER:
2358                 fib_path_recursive_adj_update(path, fct, dpo);
2359                 break;
2360             case FIB_FORW_CHAIN_TYPE_ETHERNET:
2361             case FIB_FORW_CHAIN_TYPE_NSH:
2362                 ASSERT(0);
2363                 break;
2364             }
2365             break;
2366         case FIB_PATH_TYPE_BIER_TABLE:
2367             switch (fct)
2368             {
2369             case FIB_FORW_CHAIN_TYPE_BIER:
2370                 bier_table_contribute_forwarding(path->fp_via_bier_tbl, dpo);
2371                 break;
2372             case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
2373             case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
2374             case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
2375             case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
2376             case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
2377             case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
2378             case FIB_FORW_CHAIN_TYPE_ETHERNET:
2379             case FIB_FORW_CHAIN_TYPE_NSH:
2380                 ASSERT(0);
2381                 break;
2382             }
2383             break;
2384         case FIB_PATH_TYPE_BIER_FMASK:
2385             switch (fct)
2386             {
2387             case FIB_FORW_CHAIN_TYPE_BIER:
2388                 fib_path_bier_fmask_update(path, dpo);
2389                 break;
2390             case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
2391             case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
2392             case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
2393             case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
2394             case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
2395             case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
2396             case FIB_FORW_CHAIN_TYPE_ETHERNET:
2397             case FIB_FORW_CHAIN_TYPE_NSH:
2398                 ASSERT(0);
2399                 break;
2400             }
2401             break;
2402         case FIB_PATH_TYPE_BIER_IMP:
2403             bier_imp_contribute_forwarding(path->bier_imp.fp_bier_imp,
2404                                            fib_forw_chain_type_to_dpo_proto(fct),
2405                                            dpo);
2406             break;
2407         case FIB_PATH_TYPE_DEAG:
2408             switch (fct)
2409             {
2410             case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
2411                 lookup_dpo_add_or_lock_w_table_id(MPLS_FIB_DEFAULT_TABLE_ID,
2412                                                   DPO_PROTO_MPLS,
2413                                                   LOOKUP_UNICAST,
2414                                                   LOOKUP_INPUT_DST_ADDR,
2415                                                   LOOKUP_TABLE_FROM_CONFIG,
2416                                                   dpo);
2417                 break;
2418             case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
2419             case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
2420             case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
2421                 dpo_copy(dpo, &path->fp_dpo);
2422                 break;
2423             case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
2424             case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
2425             case FIB_FORW_CHAIN_TYPE_BIER:
2426                 break;
2427             case FIB_FORW_CHAIN_TYPE_ETHERNET:
2428             case FIB_FORW_CHAIN_TYPE_NSH:
2429                 ASSERT(0);
2430                 break;
2431             }
2432             break;
2433         case FIB_PATH_TYPE_EXCLUSIVE:
2434             dpo_copy(dpo, &path->exclusive.fp_ex_dpo);
2435             break;
2436         case FIB_PATH_TYPE_ATTACHED:
2437             switch (fct)
2438             {
2439             case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
2440             case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
2441             case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
2442             case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
2443             case FIB_FORW_CHAIN_TYPE_ETHERNET:
2444             case FIB_FORW_CHAIN_TYPE_NSH:
2445             case FIB_FORW_CHAIN_TYPE_BIER:
2446                 {
2447                     adj_index_t ai;
2448
2449                     /*
2450                      * get a appropriate link type adj.
2451                      */
2452                     ai = fib_path_attached_get_adj(
2453                             path,
2454                             fib_forw_chain_type_to_link_type(fct));
2455                     dpo_set(dpo, DPO_ADJACENCY,
2456                             fib_forw_chain_type_to_dpo_proto(fct), ai);
2457                     adj_unlock(ai);
2458                     break;
2459                 }
2460             case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
2461             case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
2462                 {
2463                     adj_index_t ai;
2464
2465                     /*
2466                      * Create the adj needed for sending IP multicast traffic
2467                      */
2468                     ai = adj_mcast_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
2469                                                fib_forw_chain_type_to_link_type(fct),
2470                                                path->attached.fp_interface);
2471                     dpo_set(dpo, DPO_ADJACENCY,
2472                             fib_forw_chain_type_to_dpo_proto(fct),
2473                             ai);
2474                     adj_unlock(ai);
2475                 }
2476                 break;
2477             }
2478             break;
2479         case FIB_PATH_TYPE_INTF_RX:
2480             /*
2481              * Create the adj needed for sending IP multicast traffic
2482              */
2483             interface_rx_dpo_add_or_lock(fib_forw_chain_type_to_dpo_proto(fct),
2484                                          path->attached.fp_interface,
2485                                          dpo);
2486             break;
2487         case FIB_PATH_TYPE_UDP_ENCAP:
2488             udp_encap_contribute_forwarding(path->udp_encap.fp_udp_encap_id,
2489                                             path->fp_nh_proto,
2490                                             dpo);
2491             break;
2492         case FIB_PATH_TYPE_RECEIVE:
2493         case FIB_PATH_TYPE_SPECIAL:
2494         case FIB_PATH_TYPE_DVR:
2495             dpo_copy(dpo, &path->fp_dpo);
2496             break;
2497         }
2498     }
2499 }
2500
2501 load_balance_path_t *
2502 fib_path_append_nh_for_multipath_hash (fib_node_index_t path_index,
2503                                        fib_forward_chain_type_t fct,
2504                                        load_balance_path_t *hash_key)
2505 {
2506     load_balance_path_t *mnh;
2507     fib_path_t *path;
2508
2509     path = fib_path_get(path_index);
2510
2511     ASSERT(path);
2512
2513     if (fib_path_is_resolved(path_index))
2514     {
2515         vec_add2(hash_key, mnh, 1);
2516
2517         mnh->path_weight = path->fp_weight;
2518         mnh->path_index = path_index;
2519         fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo);
2520     }
2521
2522     return (hash_key);
2523 }
2524
2525 int
2526 fib_path_is_recursive_constrained (fib_node_index_t path_index)
2527 {
2528     fib_path_t *path;
2529
2530     path = fib_path_get(path_index);
2531
2532     return ((FIB_PATH_TYPE_RECURSIVE == path->fp_type) &&
2533             ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RESOLVE_ATTACHED) ||
2534              (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RESOLVE_HOST)));
2535 }
2536
2537 int
2538 fib_path_is_exclusive (fib_node_index_t path_index)
2539 {
2540     fib_path_t *path;
2541
2542     path = fib_path_get(path_index);
2543
2544     return (FIB_PATH_TYPE_EXCLUSIVE == path->fp_type);
2545 }
2546
2547 int
2548 fib_path_is_deag (fib_node_index_t path_index)
2549 {
2550     fib_path_t *path;
2551
2552     path = fib_path_get(path_index);
2553
2554     return (FIB_PATH_TYPE_DEAG == path->fp_type);
2555 }
2556
2557 int
2558 fib_path_is_resolved (fib_node_index_t path_index)
2559 {
2560     fib_path_t *path;
2561
2562     path = fib_path_get(path_index);
2563
2564     return (dpo_id_is_valid(&path->fp_dpo) &&
2565             (path->fp_oper_flags & FIB_PATH_OPER_FLAG_RESOLVED) &&
2566             !fib_path_is_looped(path_index) &&
2567             !fib_path_is_permanent_drop(path));
2568 }
2569
2570 int
2571 fib_path_is_looped (fib_node_index_t path_index)
2572 {
2573     fib_path_t *path;
2574
2575     path = fib_path_get(path_index);
2576
2577     return (path->fp_oper_flags & FIB_PATH_OPER_FLAG_RECURSIVE_LOOP);
2578 }
2579
2580 fib_path_list_walk_rc_t
2581 fib_path_encode (fib_node_index_t path_list_index,
2582                  fib_node_index_t path_index,
2583                  void *ctx)
2584 {
2585     fib_route_path_encode_t **api_rpaths = ctx;
2586     fib_route_path_encode_t *api_rpath;
2587     fib_path_t *path;
2588
2589     path = fib_path_get(path_index);
2590     if (!path)
2591       return (FIB_PATH_LIST_WALK_CONTINUE);
2592     vec_add2(*api_rpaths, api_rpath, 1);
2593     api_rpath->rpath.frp_weight = path->fp_weight;
2594     api_rpath->rpath.frp_preference = path->fp_preference;
2595     api_rpath->rpath.frp_proto = path->fp_nh_proto;
2596     api_rpath->rpath.frp_sw_if_index = ~0;
2597     api_rpath->dpo = path->fp_dpo;
2598
2599     switch (path->fp_type)
2600       {
2601       case FIB_PATH_TYPE_RECEIVE:
2602         api_rpath->rpath.frp_addr = path->receive.fp_addr;
2603         api_rpath->rpath.frp_sw_if_index = path->receive.fp_interface;
2604         break;
2605       case FIB_PATH_TYPE_ATTACHED:
2606         api_rpath->rpath.frp_sw_if_index = path->attached.fp_interface;
2607         break;
2608       case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
2609         api_rpath->rpath.frp_sw_if_index = path->attached_next_hop.fp_interface;
2610         api_rpath->rpath.frp_addr = path->attached_next_hop.fp_nh;
2611         break;
2612       case FIB_PATH_TYPE_BIER_FMASK:
2613         api_rpath->rpath.frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
2614         break;
2615       case FIB_PATH_TYPE_SPECIAL:
2616         break;
2617       case FIB_PATH_TYPE_DEAG:
2618         api_rpath->rpath.frp_fib_index = path->deag.fp_tbl_id;
2619         break;
2620       case FIB_PATH_TYPE_RECURSIVE:
2621         api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip;
2622         break;
2623       default:
2624         break;
2625       }
2626
2627     return (FIB_PATH_LIST_WALK_CONTINUE);
2628 }
2629
2630 dpo_proto_t
2631 fib_path_get_proto (fib_node_index_t path_index)
2632 {
2633     fib_path_t *path;
2634
2635     path = fib_path_get(path_index);
2636
2637     return (path->fp_nh_proto);
2638 }
2639
2640 void
2641 fib_path_module_init (void)
2642 {
2643     fib_node_register_type (FIB_NODE_TYPE_PATH, &fib_path_vft);
2644 }
2645
2646 static clib_error_t *
2647 show_fib_path_command (vlib_main_t * vm,
2648                         unformat_input_t * input,
2649                         vlib_cli_command_t * cmd)
2650 {
2651     fib_node_index_t pi;
2652     fib_path_t *path;
2653
2654     if (unformat (input, "%d", &pi))
2655     {
2656         /*
2657          * show one in detail
2658          */
2659         if (!pool_is_free_index(fib_path_pool, pi))
2660         {
2661             path = fib_path_get(pi);
2662             u8 *s = format(NULL, "%U", format_fib_path, pi, 1);
2663             s = format(s, "children:");
2664             s = fib_node_children_format(path->fp_node.fn_children, s);
2665             vlib_cli_output (vm, "%s", s);
2666             vec_free(s);
2667         }
2668         else
2669         {
2670             vlib_cli_output (vm, "path %d invalid", pi);
2671         }
2672     }
2673     else
2674     {
2675         vlib_cli_output (vm, "FIB Paths");
2676         pool_foreach_index (pi, fib_path_pool,
2677         ({
2678             vlib_cli_output (vm, "%U", format_fib_path, pi, 0);
2679         }));
2680     }
2681
2682     return (NULL);
2683 }
2684
2685 VLIB_CLI_COMMAND (show_fib_path, static) = {
2686   .path = "show fib paths",
2687   .function = show_fib_path_command,
2688   .short_help = "show fib paths",
2689 };