X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ffib%2Ffib_path.c;h=eebba1b1548351b5b43927dd5cb0b3f659931674;hb=097fa66b986f06281f603767d321ab13ab6c88c3;hp=fddb8ecdd5a3e42557b2ce41c8fe9465cb6531c1;hpb=79ae2d306269524b9de662dbbf532a04e11b7634;p=vpp.git

diff --git a/src/vnet/fib/fib_path.c b/src/vnet/fib/fib_path.c
index fddb8ecdd5a..eebba1b1548 100644
--- a/src/vnet/fib/fib_path.c
+++ b/src/vnet/fib/fib_path.c
@@ -23,8 +23,9 @@
 #include <vnet/dpo/lookup_dpo.h>
 #include <vnet/dpo/interface_rx_dpo.h>
 #include <vnet/dpo/mpls_disposition.h>
-#include <vnet/dpo/l2_bridge_dpo.h>
-#include <vnet/dpo/drop_dpo.h>
+#include <vnet/dpo/dvr_dpo.h>
+#include <vnet/dpo/ip_null_dpo.h>
+#include <vnet/dpo/classify_dpo.h>
 
 #include <vnet/adj/adj.h>
 #include <vnet/adj/adj_mcast.h>
@@ -37,6 +38,7 @@
 #include <vnet/fib/fib_internal.h>
 #include <vnet/fib/fib_urpf_list.h>
 #include <vnet/fib/mpls_fib.h>
+#include <vnet/fib/fib_path_ext.h>
 #include <vnet/udp/udp_encap.h>
 #include <vnet/bier/bier_fmask.h>
 #include <vnet/bier/bier_table.h>
@@ -80,7 +82,7 @@ typedef enum fib_path_type_t_ {
      */
     FIB_PATH_TYPE_INTF_RX,
     /**
-     * interface receive.
+     * Path resolves via a UDP encap object.
      */
     FIB_PATH_TYPE_UDP_ENCAP,
     /**
@@ -99,6 +101,10 @@ typedef enum fib_path_type_t_ {
      * bier-fmask. it's via a BIER f-mask.
      */
     FIB_PATH_TYPE_BIER_FMASK,
+    /**
+     * via a DVR.
+     */
+    FIB_PATH_TYPE_DVR,
     /**
      * Marker. Add new types before this one, then update it.
      */
@@ -123,6 +129,7 @@ typedef enum fib_path_type_t_ {
     [FIB_PATH_TYPE_BIER_IMP]          = "bier-imp",	        \
     [FIB_PATH_TYPE_BIER_TABLE]        = "bier-table",	        \
     [FIB_PATH_TYPE_BIER_FMASK]        = "bier-fmask",	        \
+    [FIB_PATH_TYPE_DVR]               = "dvr",   	        \
 }
 
 #define FOR_EACH_FIB_PATH_TYPE(_item)           \
@@ -345,6 +352,18 @@ typedef struct fib_path_t_ {
 	     */
 	    u32 fp_udp_encap_id;
 	} udp_encap;
+	struct {
+	    /**
+	     * The UDP Encap object this path resolves through
+	     */
+	    u32 fp_classify_table_id;
+	} classify;
+	struct {
+	    /**
+	     * The interface
+	     */
+	    u32 fp_interface;
+	} dvr;
     };
     STRUCT_MARK(path_hash_end);
 
@@ -398,22 +417,22 @@ static const char *fib_path_cfg_attribute_names[]  = FIB_PATH_CFG_ATTRIBUTES;
  */
 static fib_path_t *fib_path_pool;
 
+/**
+ * the logger
+ */
+vlib_log_class_t fib_path_logger;
+
 /*
  * Debug macro
  */
-#ifdef FIB_DEBUG
-#define FIB_PATH_DBG(_p, _fmt, _args...)			\
-{       		          				\
-    u8 *_tmp = NULL;						\
-    _tmp = fib_path_format(fib_path_get_index(_p), _tmp);	\
-    clib_warning("path:[%d:%U]:" _fmt,				\
-		 fib_path_get_index(_p), format_fib_path, _p, 0,\
-		 ##_args);					\
-    vec_free(_tmp);						\
+#define FIB_PATH_DBG(_p, _fmt, _args...)                                \
+{                                                                       \
+    vlib_log_debug (fib_path_logger,                                    \
+                    "[%U]: " _fmt,                                      \
+                    format_fib_path, fib_path_get_index(_p), 0,         \
+                    FIB_PATH_FORMAT_FLAGS_ONE_LINE,                     \
+                    ##_args);                                           \
 }
-#else
-#define FIB_PATH_DBG(_p, _fmt, _args...)
-#endif
 
 static fib_path_t *
 fib_path_get (fib_node_index_t index)
@@ -445,10 +464,21 @@ format_fib_path (u8 * s, va_list * args)
 {
     fib_node_index_t path_index = va_arg (*args, fib_node_index_t);
     u32 indent = va_arg (*args, u32);
+    fib_format_path_flags_t flags =  va_arg (*args, fib_format_path_flags_t);
     vnet_main_t * vnm = vnet_get_main();
     fib_path_oper_attribute_t oattr;
     fib_path_cfg_attribute_t cattr;
     fib_path_t *path;
+    const char *eol;
+
+    if (flags & FIB_PATH_FORMAT_FLAGS_ONE_LINE)
+    {
+        eol = "";
+    }
+    else
+    {
+        eol = "\n";
+    }
 
     path = fib_path_get(path_index);
 
@@ -475,7 +505,8 @@ format_fib_path (u8 * s, va_list * args)
 	    }
 	}
     }
-    s = format(s, "\n%U", format_white_space, indent+2);
+    if (!(flags & FIB_PATH_FORMAT_FLAGS_ONE_LINE))
+        s = format(s, "\n%U", format_white_space, indent+2);
 
     switch (path->fp_type)
     {
@@ -503,11 +534,11 @@ format_fib_path (u8 * s, va_list * args)
 	}
 	if (!dpo_id_is_valid(&path->fp_dpo))
 	{
-	    s = format(s, "\n%Uunresolved", format_white_space, indent+2);
+	    s = format(s, "%s%Uunresolved", eol, format_white_space, indent+2);
 	}
 	else
 	{
-	    s = format(s, "\n%U%U",
+	    s = format(s, "%s%U%U", eol,
 		       format_white_space, indent,
                        format_dpo_id,
 		       &path->fp_dpo, 13);
@@ -574,10 +605,22 @@ format_fib_path (u8 * s, va_list * args)
         s = format (s, "via %U", format_bier_imp,
                     path->bier_imp.fp_bier_imp, 0, BIER_SHOW_BRIEF);
         break;
+    case FIB_PATH_TYPE_DVR:
+        s = format (s, " %U",
+                    format_vnet_sw_interface_name,
+                    vnm,
+                    vnet_get_sw_interface(
+                        vnm,
+                        path->dvr.fp_interface));
+        break;
+    case FIB_PATH_TYPE_DEAG:
+        s = format (s, " %sfib-index:%d",
+                    (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ?  "m" : ""),
+                    path->deag.fp_tbl_id);
+        break;
     case FIB_PATH_TYPE_RECEIVE:
     case FIB_PATH_TYPE_INTF_RX:
     case FIB_PATH_TYPE_SPECIAL:
-    case FIB_PATH_TYPE_DEAG:
     case FIB_PATH_TYPE_EXCLUSIVE:
 	if (dpo_id_is_valid(&path->fp_dpo))
 	{
@@ -589,17 +632,6 @@ format_fib_path (u8 * s, va_list * args)
     return (s);
 }
 
-u8 *
-fib_path_format (fib_node_index_t pi, u8 *s)
-{
-    fib_path_t *path;
-
-    path = fib_path_get(pi);
-    ASSERT(NULL != path);
-
-    return (format (s, "%U", format_fib_path, path));
-}
-
 /*
  * fib_path_last_lock_gone
  *
@@ -661,8 +693,8 @@ fib_path_attached_next_hop_set (fib_path_t *path)
 				     FIB_NODE_TYPE_PATH,
 				     fib_path_get_index(path));
 
-    if (!vnet_sw_interface_is_admin_up(vnet_get_main(),
-				      path->attached_next_hop.fp_interface) ||
+    if (!vnet_sw_interface_is_up(vnet_get_main(),
+                                 path->attached_next_hop.fp_interface) ||
         !adj_is_up(path->fp_dpo.dpoi_index))
     {
 	path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
@@ -688,6 +720,7 @@ fib_path_attached_get_adj (fib_path_t *path,
     else
     {
         return (adj_glean_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto),
+                                      link,
                                       path->attached.fp_interface,
                                       NULL));
     }
@@ -854,14 +887,14 @@ fib_path_unresolve (fib_path_t *path)
     case FIB_PATH_TYPE_RECURSIVE:
 	if (FIB_NODE_INDEX_INVALID != path->fp_via_fib)
 	{
-	    fib_prefix_t pfx;
-
-	    fib_entry_get_prefix(path->fp_via_fib, &pfx);
 	    fib_entry_child_remove(path->fp_via_fib,
 				   path->fp_sibling);
-	    fib_table_entry_special_remove(path->recursive.fp_tbl_id,
-					   &pfx,
+            fib_table_entry_special_remove(path->recursive.fp_tbl_id,
+                                           fib_entry_get_prefix(path->fp_via_fib),
 					   FIB_SOURCE_RR);
+            fib_table_unlock(path->recursive.fp_tbl_id,
+                             dpo_proto_to_fib(path->fp_nh_proto),
+                             FIB_SOURCE_RR);
 	    path->fp_via_fib = FIB_NODE_INDEX_INVALID;
 	}
 	break;
@@ -881,15 +914,12 @@ fib_path_unresolve (fib_path_t *path)
         adj_unlock(path->fp_dpo.dpoi_index);
         break;
     case FIB_PATH_TYPE_ATTACHED:
-        if (DPO_PROTO_ETHERNET != path->fp_nh_proto)
-        {
-            adj_child_remove(path->fp_dpo.dpoi_index,
-                             path->fp_sibling);
-            adj_unlock(path->fp_dpo.dpoi_index);
-        }
+        adj_child_remove(path->fp_dpo.dpoi_index,
+                         path->fp_sibling);
+        adj_unlock(path->fp_dpo.dpoi_index);
         break;
     case FIB_PATH_TYPE_UDP_ENCAP:
-	udp_encap_unlock_w_index(path->fp_dpo.dpoi_index);
+	udp_encap_unlock(path->fp_dpo.dpoi_index);
         break;
     case FIB_PATH_TYPE_EXCLUSIVE:
 	dpo_reset(&path->exclusive.fp_ex_dpo);
@@ -898,6 +928,7 @@ fib_path_unresolve (fib_path_t *path)
     case FIB_PATH_TYPE_RECEIVE:
     case FIB_PATH_TYPE_INTF_RX:
     case FIB_PATH_TYPE_DEAG:
+    case FIB_PATH_TYPE_DVR:
         /*
          * these hold only the path's DPO, which is reset below.
          */
@@ -948,6 +979,9 @@ fib_path_back_walk_notify (fib_node_t *node,
 
     path = fib_path_from_fib_node(node);
 
+    FIB_PATH_DBG(path, "bw:%U",
+                 format_fib_node_bw_reason, ctx->fnbw_reason);
+
     switch (path->fp_type)
     {
     case FIB_PATH_TYPE_RECURSIVE:
@@ -1056,7 +1090,7 @@ FIXME comment
             uword if_is_up;
             adj_index_t ai;
 
-            if_is_up = vnet_sw_interface_is_admin_up(
+            if_is_up = vnet_sw_interface_is_up(
                            vnet_get_main(),
                            path->attached_next_hop.fp_interface);
 
@@ -1101,6 +1135,7 @@ FIXME comment
         }
 	break;
     case FIB_PATH_TYPE_ATTACHED:
+    case FIB_PATH_TYPE_DVR:
 	/*
 	 * FIXME; this could schedule a lower priority walk, since attached
 	 * routes are not usually in ECMP configurations so the backwalk to
@@ -1216,6 +1251,10 @@ fib_path_route_flags_to_cfg_flags (const fib_route_path_t *rpath)
 	cfg_flags |= FIB_PATH_CFG_FLAG_DROP;
     if (rpath->frp_flags & FIB_ROUTE_PATH_SOURCE_LOOKUP)
 	cfg_flags |= FIB_PATH_CFG_FLAG_DEAG_SRC;
+    if (rpath->frp_flags & FIB_ROUTE_PATH_ICMP_UNREACH)
+	cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_UNREACH;
+    if (rpath->frp_flags & FIB_ROUTE_PATH_ICMP_PROHIBIT)
+	cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_PROHIBIT;
 
     return (cfg_flags);
 }
@@ -1233,7 +1272,7 @@ fib_path_create (fib_node_index_t pl_index,
     fib_path_t *path;
 
     pool_get(fib_path_pool, path);
-    memset(path, 0, sizeof(*path));
+    clib_memset(path, 0, sizeof(*path));
 
     fib_node_init(&path->fp_node,
 		  FIB_NODE_TYPE_PATH);
@@ -1299,6 +1338,26 @@ fib_path_create (fib_node_index_t pl_index,
 	path->fp_type = FIB_PATH_TYPE_DEAG;
 	path->deag.fp_tbl_id = rpath->frp_fib_index;
     }
+    else if (rpath->frp_flags & FIB_ROUTE_PATH_DVR)
+    {
+	path->fp_type = FIB_PATH_TYPE_DVR;
+	path->dvr.fp_interface = rpath->frp_sw_if_index;
+    }
+    else if (rpath->frp_flags & FIB_ROUTE_PATH_EXCLUSIVE)
+    {
+	path->fp_type = FIB_PATH_TYPE_EXCLUSIVE;
+	dpo_copy(&path->exclusive.fp_ex_dpo, &rpath->dpo);
+    }
+    else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT) ||
+        (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH))
+    {
+        path->fp_type = FIB_PATH_TYPE_SPECIAL;
+    }
+    else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY))
+    {
+        path->fp_type = FIB_PATH_TYPE_SPECIAL;
+        path->classify.fp_classify_table_id = rpath->frp_classify_table_id;
+    }
     else if (~0 != rpath->frp_sw_if_index)
     {
         if (ip46_address_is_zero(&rpath->frp_addr))
@@ -1325,7 +1384,8 @@ fib_path_create (fib_node_index_t pl_index,
 	    {
 		path->fp_type = FIB_PATH_TYPE_DEAG;
 		path->deag.fp_tbl_id = rpath->frp_fib_index;
-	    }		
+                path->deag.fp_rpf_id = ~0;
+	    }
 	}
 	else
 	{
@@ -1363,7 +1423,7 @@ fib_path_create_special (fib_node_index_t pl_index,
     fib_path_t *path;
 
     pool_get(fib_path_pool, path);
-    memset(path, 0, sizeof(*path));
+    clib_memset(path, 0, sizeof(*path));
 
     fib_node_init(&path->fp_node,
 		  FIB_NODE_TYPE_PATH);
@@ -1422,7 +1482,7 @@ fib_path_copy (fib_node_index_t path_index,
     path->fp_oper_flags     = FIB_PATH_OPER_FLAG_NONE;
     path->fp_pl_index  = path_list_index;
     path->fp_via_fib   = FIB_NODE_INDEX_INVALID;
-    memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
+    clib_memset(&path->fp_dpo, 0, sizeof(path->fp_dpo));
     dpo_reset(&path->fp_dpo);
 
     return (fib_path_get_index(path));
@@ -1546,9 +1606,14 @@ fib_path_cmp_i (const fib_path_t *path1,
 	case FIB_PATH_TYPE_UDP_ENCAP:
 	    res = (path1->udp_encap.fp_udp_encap_id - path2->udp_encap.fp_udp_encap_id);
 	    break;
+	case FIB_PATH_TYPE_DVR:
+	    res = (path1->dvr.fp_interface - path2->dvr.fp_interface);
+	    break;
+	case FIB_PATH_TYPE_EXCLUSIVE:
+	    res = dpo_cmp(&path1->exclusive.fp_ex_dpo, &path2->exclusive.fp_ex_dpo);
+	    break;
 	case FIB_PATH_TYPE_SPECIAL:
 	case FIB_PATH_TYPE_RECEIVE:
-	case FIB_PATH_TYPE_EXCLUSIVE:
 	    res = 0;
 	    break;
 	}
@@ -1680,9 +1745,23 @@ fib_path_cmp_w_route_path (fib_node_index_t path_index,
                 res = (path->deag.fp_rpf_id - rpath->frp_rpf_id);
             }
             break;
-	case FIB_PATH_TYPE_SPECIAL:
-	case FIB_PATH_TYPE_RECEIVE:
+	case FIB_PATH_TYPE_DVR:
+	    res = (path->dvr.fp_interface - rpath->frp_sw_if_index);
+	    break;
 	case FIB_PATH_TYPE_EXCLUSIVE:
+	    res = dpo_cmp(&path->exclusive.fp_ex_dpo, &rpath->dpo);
+	    break;
+	case FIB_PATH_TYPE_RECEIVE:
+            if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL)
+            {
+                res = 0;
+            }
+            else
+            {
+                res = 1;
+            }
+            break;
+	case FIB_PATH_TYPE_SPECIAL:
 	    res = 0;
 	    break;
 	}
@@ -1758,7 +1837,7 @@ fib_path_recursive_loop_detect (fib_node_index_t path_index,
 	{
 	    /*
 	     * no loop here yet. keep forward walking the graph.
-	     */	    
+	     */
 	    if (fib_entry_recursive_loop_detect(path->fp_via_fib, entry_indicies))
 	    {
 		FIB_PATH_DBG(path, "recursive loop formed");
@@ -1774,8 +1853,21 @@ fib_path_recursive_loop_detect (fib_node_index_t path_index,
     }
     case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
     case FIB_PATH_TYPE_ATTACHED:
+	if (adj_recursive_loop_detect(path->fp_dpo.dpoi_index,
+                                      entry_indicies))
+	{
+	    FIB_PATH_DBG(path, "recursive loop formed");
+	    path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
+	}
+        else
+        {
+            FIB_PATH_DBG(path, "recursive loop cleared");
+            path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RECURSIVE_LOOP;
+        }
+        break;
     case FIB_PATH_TYPE_SPECIAL:
     case FIB_PATH_TYPE_DEAG:
+    case FIB_PATH_TYPE_DVR:
     case FIB_PATH_TYPE_RECEIVE:
     case FIB_PATH_TYPE_INTF_RX:
     case FIB_PATH_TYPE_UDP_ENCAP:
@@ -1821,36 +1913,39 @@ fib_path_resolve (fib_node_index_t path_index)
 	fib_path_attached_next_hop_set(path);
 	break;
     case FIB_PATH_TYPE_ATTACHED:
-        if (DPO_PROTO_ETHERNET == path->fp_nh_proto)
+    {
+        dpo_id_t tmp = DPO_INVALID;
+
+        /*
+         * path->attached.fp_interface
+         */
+        if (!vnet_sw_interface_is_up(vnet_get_main(),
+                                     path->attached.fp_interface))
         {
-            l2_bridge_dpo_add_or_lock(path->attached.fp_interface,
-                                      &path->fp_dpo);
+            path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
         }
-        else
-        {
-            /*
-             * path->attached.fp_interface
-             */
-            if (!vnet_sw_interface_is_admin_up(vnet_get_main(),
-                                               path->attached.fp_interface))
-            {
-                path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED;
-            }
-            dpo_set(&path->fp_dpo,
-                    DPO_ADJACENCY,
-                    path->fp_nh_proto,
-                    fib_path_attached_get_adj(path,
-                                              dpo_proto_to_link(path->fp_nh_proto)));
+        dpo_set(&tmp,
+                DPO_ADJACENCY,
+                path->fp_nh_proto,
+                fib_path_attached_get_adj(path,
+                                          dpo_proto_to_link(path->fp_nh_proto)));
 
-            /*
-             * become a child of the adjacency so we receive updates
-             * when the interface state changes
-             */
-            path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
-                                             FIB_NODE_TYPE_PATH,
-                                             fib_path_get_index(path));
-        }
+        /*
+         * re-fetch after possible mem realloc
+         */
+        path = fib_path_get(path_index);
+        dpo_copy(&path->fp_dpo, &tmp);
+
+        /*
+         * become a child of the adjacency so we receive updates
+         * when the interface state changes
+         */
+        path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index,
+                                         FIB_NODE_TYPE_PATH,
+                                         fib_path_get_index(path));
+        dpo_reset(&tmp);
 	break;
+    }
     case FIB_PATH_TYPE_RECURSIVE:
     {
 	/*
@@ -1876,6 +1971,9 @@ fib_path_resolve (fib_node_index_t path_index)
 	    fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx);
 	}
 
+        fib_table_lock(path->recursive.fp_tbl_id,
+                       dpo_proto_to_fib(path->fp_nh_proto),
+                       FIB_SOURCE_RR);
 	fei = fib_table_entry_special_add(path->recursive.fp_tbl_id,
 					  &pfx,
 					  FIB_SOURCE_RR,
@@ -1938,11 +2036,33 @@ fib_path_resolve (fib_node_index_t path_index)
         break;
     }
     case FIB_PATH_TYPE_SPECIAL:
-	/*
-	 * Resolve via the drop
-	 */
-	dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
-	break;
+        if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT)
+        {
+            ip_null_dpo_add_and_lock (path->fp_nh_proto,
+                                      IP_NULL_ACTION_SEND_ICMP_PROHIBIT,
+                                      &path->fp_dpo);
+        }
+        else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH)
+        {
+            ip_null_dpo_add_and_lock (path->fp_nh_proto,
+                                      IP_NULL_ACTION_SEND_ICMP_UNREACH,
+                                      &path->fp_dpo);
+        }
+        else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY)
+        {
+            dpo_set (&path->fp_dpo, DPO_CLASSIFY,
+                     path->fp_nh_proto,
+                     classify_dpo_create (path->fp_nh_proto,
+                                          path->classify.fp_classify_table_id));
+        }
+        else
+        {
+            /*
+             * Resolve via the drop
+             */
+            dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto));
+        }
+        break;
     case FIB_PATH_TYPE_DEAG:
     {
         if (DPO_PROTO_BIER == path->fp_nh_proto)
@@ -1975,6 +2095,11 @@ fib_path_resolve (fib_node_index_t path_index)
         }
         break;
     }
+    case FIB_PATH_TYPE_DVR:
+        dvr_dpo_add_or_lock(path->attached.fp_interface,
+                            path->fp_nh_proto,
+                            &path->fp_dpo);
+        break;
     case FIB_PATH_TYPE_RECEIVE:
 	/*
 	 * Resolve via a receive DPO.
@@ -2031,6 +2156,8 @@ fib_path_get_resolving_interface (fib_node_index_t path_index)
             return (fib_entry_get_resolving_interface(path->fp_via_fib));
         }
         break;
+    case FIB_PATH_TYPE_DVR:
+	return (path->dvr.fp_interface);
     case FIB_PATH_TYPE_INTF_RX:
     case FIB_PATH_TYPE_UDP_ENCAP:
     case FIB_PATH_TYPE_SPECIAL:
@@ -2041,7 +2168,7 @@ fib_path_get_resolving_interface (fib_node_index_t path_index)
     case FIB_PATH_TYPE_BIER_IMP:
 	break;
     }
-    return (~0);
+    return (dpo_get_urpf(&path->fp_dpo));
 }
 
 index_t
@@ -2059,6 +2186,7 @@ fib_path_get_resolving_index (fib_node_index_t path_index)
     case FIB_PATH_TYPE_INTF_RX:
     case FIB_PATH_TYPE_SPECIAL:
     case FIB_PATH_TYPE_DEAG:
+    case FIB_PATH_TYPE_DVR:
     case FIB_PATH_TYPE_EXCLUSIVE:
         break;
     case FIB_PATH_TYPE_UDP_ENCAP:
@@ -2187,6 +2315,9 @@ fib_path_contribute_urpf (fib_node_index_t path_index,
 	}
 	break;
     }
+    case FIB_PATH_TYPE_DVR:
+	fib_urpf_list_append(urpf, path->dvr.fp_interface);
+	break;
     case FIB_PATH_TYPE_DEAG:
     case FIB_PATH_TYPE_RECEIVE:
     case FIB_PATH_TYPE_INTF_RX:
@@ -2204,6 +2335,7 @@ fib_path_contribute_urpf (fib_node_index_t path_index,
 void
 fib_path_stack_mpls_disp (fib_node_index_t path_index,
                           dpo_proto_t payload_proto,
+                          fib_mpls_lsp_mode_t mode,
                           dpo_id_t *dpo)
 {
     fib_path_t *path;
@@ -2219,10 +2351,8 @@ fib_path_stack_mpls_disp (fib_node_index_t path_index,
         dpo_id_t tmp = DPO_INVALID;
 
         dpo_copy(&tmp, dpo);
-        dpo_set(dpo,
-                DPO_MPLS_DISPOSITION,
-                payload_proto,
-                mpls_disp_dpo_create(payload_proto, ~0, &tmp));
+
+        mpls_disp_dpo_create(payload_proto, ~0, mode, &tmp, dpo);
         dpo_reset(&tmp);
         break;
     }                
@@ -2231,12 +2361,10 @@ fib_path_stack_mpls_disp (fib_node_index_t path_index,
         dpo_id_t tmp = DPO_INVALID;
 
         dpo_copy(&tmp, dpo);
-        dpo_set(dpo,
-                DPO_MPLS_DISPOSITION,
-                payload_proto,
-                mpls_disp_dpo_create(payload_proto,
-                                     path->deag.fp_rpf_id,
-                                     &tmp));
+
+        mpls_disp_dpo_create(payload_proto,
+                             path->deag.fp_rpf_id,
+                             mode, &tmp, dpo);
         dpo_reset(&tmp);
         break;
     }
@@ -2250,6 +2378,7 @@ fib_path_stack_mpls_disp (fib_node_index_t path_index,
     case FIB_PATH_TYPE_BIER_FMASK:
     case FIB_PATH_TYPE_BIER_TABLE:
     case FIB_PATH_TYPE_BIER_IMP:
+    case FIB_PATH_TYPE_DVR:
         break;
     }
 }
@@ -2266,8 +2395,6 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
     ASSERT(path);
     ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS != fct);
 
-    FIB_PATH_DBG(path, "contribute");
-
     /*
      * The DPO stored in the path was created when the path was resolved.
      * This then represents the path's 'native' protocol; IP.
@@ -2290,6 +2417,8 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
 	    case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
 	    case FIB_FORW_CHAIN_TYPE_ETHERNET:
 	    case FIB_FORW_CHAIN_TYPE_NSH:
+	    case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
+	    case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
 	    {
 		adj_index_t ai;
 
@@ -2305,8 +2434,6 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
 
 		break;
 	    }
-	    case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
-	    case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
 	    case FIB_FORW_CHAIN_TYPE_BIER:
 		break;
 	    }
@@ -2384,10 +2511,10 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
 	    case FIB_FORW_CHAIN_TYPE_MPLS_EOS:
 	    case FIB_FORW_CHAIN_TYPE_UNICAST_IP4:
 	    case FIB_FORW_CHAIN_TYPE_UNICAST_IP6:
-		dpo_copy(dpo, &path->fp_dpo);
-		break;
 	    case FIB_FORW_CHAIN_TYPE_MCAST_IP4:
 	    case FIB_FORW_CHAIN_TYPE_MCAST_IP6:
+		dpo_copy(dpo, &path->fp_dpo);
+		break;
 	    case FIB_FORW_CHAIN_TYPE_BIER:
 		break;
 	    case FIB_FORW_CHAIN_TYPE_ETHERNET:
@@ -2400,11 +2527,6 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
 	    dpo_copy(dpo, &path->exclusive.fp_ex_dpo);
 	    break;
         case FIB_PATH_TYPE_ATTACHED:
-            if (DPO_PROTO_ETHERNET == path->fp_nh_proto)
-            {
-                dpo_copy(dpo, &path->fp_dpo);
-                break;
-            }
 	    switch (fct)
 	    {
 	    case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS:
@@ -2462,6 +2584,7 @@ fib_path_contribute_forwarding (fib_node_index_t path_index,
             break;
         case FIB_PATH_TYPE_RECEIVE:
         case FIB_PATH_TYPE_SPECIAL:
+        case FIB_PATH_TYPE_DVR:
             dpo_copy(dpo, &path->fp_dpo);
             break;
 	}
@@ -2480,15 +2603,20 @@ fib_path_append_nh_for_multipath_hash (fib_node_index_t path_index,
 
     ASSERT(path);
 
+    vec_add2(hash_key, mnh, 1);
+
+    mnh->path_weight = path->fp_weight;
+    mnh->path_index = path_index;
+
     if (fib_path_is_resolved(path_index))
     {
-	vec_add2(hash_key, mnh, 1);
-
-	mnh->path_weight = path->fp_weight;
-	mnh->path_index = path_index;
-	fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo);
+        fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo);
+    }
+    else
+    {
+        dpo_copy(&mnh->path_dpo,
+                 drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct)));
     }
-
     return (hash_key);
 }
 
@@ -2549,50 +2677,84 @@ fib_path_is_looped (fib_node_index_t path_index)
 
 fib_path_list_walk_rc_t
 fib_path_encode (fib_node_index_t path_list_index,
-		 fib_node_index_t path_index,
-                 void *ctx)
+                 fib_node_index_t path_index,
+                 const fib_path_ext_t *path_ext,
+                 void *args)
 {
-    fib_route_path_encode_t **api_rpaths = ctx;
-    fib_route_path_encode_t *api_rpath;
+    fib_path_encode_ctx_t *ctx = args;
+    fib_route_path_t *rpath;
     fib_path_t *path;
 
     path = fib_path_get(path_index);
     if (!path)
       return (FIB_PATH_LIST_WALK_CONTINUE);
-    vec_add2(*api_rpaths, api_rpath, 1);
-    api_rpath->rpath.frp_weight = path->fp_weight;
-    api_rpath->rpath.frp_preference = path->fp_preference;
-    api_rpath->rpath.frp_proto = path->fp_nh_proto;
-    api_rpath->rpath.frp_sw_if_index = ~0;
-    api_rpath->dpo = path->fp_dpo;
+
+    vec_add2(ctx->rpaths, rpath, 1);
+    rpath->frp_weight = path->fp_weight;
+    rpath->frp_preference = path->fp_preference;
+    rpath->frp_proto = path->fp_nh_proto;
+    rpath->frp_sw_if_index = ~0;
+    rpath->frp_fib_index = 0;
 
     switch (path->fp_type)
-      {
+    {
       case FIB_PATH_TYPE_RECEIVE:
-        api_rpath->rpath.frp_addr = path->receive.fp_addr;
-        api_rpath->rpath.frp_sw_if_index = path->receive.fp_interface;
+        rpath->frp_addr = path->receive.fp_addr;
+        rpath->frp_sw_if_index = path->receive.fp_interface;
+        rpath->frp_flags |= FIB_ROUTE_PATH_LOCAL;
         break;
       case FIB_PATH_TYPE_ATTACHED:
-        api_rpath->rpath.frp_sw_if_index = path->attached.fp_interface;
+        rpath->frp_sw_if_index = path->attached.fp_interface;
         break;
       case FIB_PATH_TYPE_ATTACHED_NEXT_HOP:
-        api_rpath->rpath.frp_sw_if_index = path->attached_next_hop.fp_interface;
-        api_rpath->rpath.frp_addr = path->attached_next_hop.fp_nh;
+        rpath->frp_sw_if_index = path->attached_next_hop.fp_interface;
+        rpath->frp_addr = path->attached_next_hop.fp_nh;
         break;
       case FIB_PATH_TYPE_BIER_FMASK:
-        api_rpath->rpath.frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
+        rpath->frp_bier_fmask = path->bier_fmask.fp_bier_fmask;
         break;
       case FIB_PATH_TYPE_SPECIAL:
         break;
       case FIB_PATH_TYPE_DEAG:
-        api_rpath->rpath.frp_fib_index = path->deag.fp_tbl_id;
+        rpath->frp_fib_index = path->deag.fp_tbl_id;
+        if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID)
+        {
+            rpath->frp_flags |= FIB_ROUTE_PATH_RPF_ID;
+        }
         break;
       case FIB_PATH_TYPE_RECURSIVE:
-        api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip;
+        rpath->frp_addr = path->recursive.fp_nh.fp_ip;
+        rpath->frp_fib_index = path->recursive.fp_tbl_id;
         break;
+      case FIB_PATH_TYPE_DVR:
+          rpath->frp_sw_if_index = path->dvr.fp_interface;
+          rpath->frp_flags |= FIB_ROUTE_PATH_DVR;
+          break;
+      case FIB_PATH_TYPE_UDP_ENCAP:
+          rpath->frp_udp_encap_id = path->udp_encap.fp_udp_encap_id;
+          rpath->frp_flags |= FIB_ROUTE_PATH_UDP_ENCAP;
+          break;
+      case FIB_PATH_TYPE_INTF_RX:
+	  rpath->frp_sw_if_index = path->receive.fp_interface;
+	  rpath->frp_flags |= FIB_ROUTE_PATH_INTF_RX;
+	  break;
+      case FIB_PATH_TYPE_EXCLUSIVE:
+        rpath->frp_flags |= FIB_ROUTE_PATH_EXCLUSIVE;
       default:
         break;
-      }
+    }
+
+    if (path_ext && path_ext->fpe_type == FIB_PATH_EXT_MPLS) 
+    {
+        rpath->frp_label_stack = path_ext->fpe_path.frp_label_stack;
+    }
+
+    if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DROP)
+        rpath->frp_flags |= FIB_ROUTE_PATH_DROP;
+    if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH)
+        rpath->frp_flags |= FIB_ROUTE_PATH_ICMP_UNREACH;
+    if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT)
+        rpath->frp_flags |= FIB_ROUTE_PATH_ICMP_PROHIBIT;
 
     return (FIB_PATH_LIST_WALK_CONTINUE);
 }
@@ -2611,6 +2773,7 @@ void
 fib_path_module_init (void)
 {
     fib_node_register_type (FIB_NODE_TYPE_PATH, &fib_path_vft);
+    fib_path_logger = vlib_log_register_class ("fib", "path");
 }
 
 static clib_error_t *
@@ -2629,8 +2792,9 @@ show_fib_path_command (vlib_main_t * vm,
 	if (!pool_is_free_index(fib_path_pool, pi))
 	{
 	    path = fib_path_get(pi);
-	    u8 *s = format(NULL, "%U", format_fib_path, pi, 1);
-	    s = format(s, "children:");
+	    u8 *s = format(NULL, "%U", format_fib_path, pi, 1,
+                           FIB_PATH_FORMAT_FLAGS_NONE);
+	    s = format(s, "\n  children:");
 	    s = fib_node_children_format(path->fp_node.fn_children, s);
 	    vlib_cli_output (vm, "%s", s);
 	    vec_free(s);
@@ -2645,7 +2809,8 @@ show_fib_path_command (vlib_main_t * vm,
 	vlib_cli_output (vm, "FIB Paths");
 	pool_foreach_index (pi, fib_path_pool,
 	({
-	    vlib_cli_output (vm, "%U", format_fib_path, pi, 0);
+	    vlib_cli_output (vm, "%U", format_fib_path, pi, 0,
+                             FIB_PATH_FORMAT_FLAGS_NONE);
 	}));
     }