Merge pull request #3052 from donaldsharp/dplane_2

Dplane 2

zebra/debug.c

@@ -33,6 +33,7 @@ unsigned long zebra_debug_nht;
 unsigned long zebra_debug_mpls;
 unsigned long zebra_debug_vxlan;
 unsigned long zebra_debug_pw;
+unsigned long zebra_debug_dplane;
 
 DEFINE_HOOK(zebra_debug_show_debugging, (struct vty *vty), (vty));
 
@@ -89,6 +90,10 @@ DEFUN_NOSH (show_debugging_zebra,
 		vty_out(vty, "  Zebra VXLAN debugging is on\n");
 	if (IS_ZEBRA_DEBUG_PW)
 		vty_out(vty, "  Zebra pseudowire debugging is on\n");
+	if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
+		vty_out(vty, "  Zebra detailed dataplane debugging is on\n");
+	else if (IS_ZEBRA_DEBUG_DPLANE)
+		vty_out(vty, "  Zebra dataplane debugging is on\n");
 
 	hook_call(zebra_debug_show_debugging, vty);
 	return CMD_SUCCESS;
@@ -261,6 +266,23 @@ DEFUN (debug_zebra_fpm,
 	return CMD_SUCCESS;
 }
 
+DEFUN (debug_zebra_dplane,
+       debug_zebra_dplane_cmd,
+       "debug zebra dplane [detailed]",
+       DEBUG_STR
+       "Zebra configuration\n"
+       "Debug zebra dataplane events\n"
+       "Detailed debug information\n")
+{
+	int idx = 0;
+	SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE);
+
+	if (argv_find(argv, argc, "detailed", &idx))
+		SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED);
+
+	return CMD_SUCCESS;
+}
+
 DEFUN (no_debug_zebra_events,
        no_debug_zebra_events_cmd,
        "no debug zebra events",
@@ -376,6 +398,18 @@ DEFUN (no_debug_zebra_fpm,
 	return CMD_SUCCESS;
 }
 
+DEFUN (no_debug_zebra_dplane,
+       no_debug_zebra_dplane_cmd,
+       "no debug zebra dplane",
+       NO_STR
+       DEBUG_STR
+       "Zebra configuration\n"
+       "Debug zebra dataplane events\n")
+{
+	zebra_debug_dplane = 0;
+	return CMD_SUCCESS;
+}
+
 /* Debug node. */
 struct cmd_node debug_node = {DEBUG_NODE, "", /* Debug node has no interface. */
 			      1};
@@ -449,6 +483,15 @@ static int config_write_debug(struct vty *vty)
 		vty_out(vty, "debug zebra pseudowires\n");
 		write++;
 	}
+
+	if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED)) {
+		vty_out(vty, "debug zebra dplane detailed\n");
+		write++;
+	} else if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE)) {
+		vty_out(vty, "debug zebra dplane\n");
+		write++;
+	}
+
 	return write;
 }
 
@@ -462,6 +505,7 @@ void zebra_debug_init(void)
 	zebra_debug_mpls = 0;
 	zebra_debug_vxlan = 0;
 	zebra_debug_pw = 0;
+	zebra_debug_dplane = 0;
 
 	install_node(&debug_node, config_write_debug);
 
@@ -477,6 +521,7 @@ void zebra_debug_init(void)
 	install_element(ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
 	install_element(ENABLE_NODE, &debug_zebra_rib_cmd);
 	install_element(ENABLE_NODE, &debug_zebra_fpm_cmd);
+	install_element(ENABLE_NODE, &debug_zebra_dplane_cmd);
 	install_element(ENABLE_NODE, &no_debug_zebra_events_cmd);
 	install_element(ENABLE_NODE, &no_debug_zebra_nht_cmd);
 	install_element(ENABLE_NODE, &no_debug_zebra_mpls_cmd);
@@ -486,6 +531,7 @@ void zebra_debug_init(void)
 	install_element(ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
 	install_element(ENABLE_NODE, &no_debug_zebra_rib_cmd);
 	install_element(ENABLE_NODE, &no_debug_zebra_fpm_cmd);
+	install_element(ENABLE_NODE, &no_debug_zebra_dplane_cmd);
 
 	install_element(CONFIG_NODE, &debug_zebra_events_cmd);
 	install_element(CONFIG_NODE, &debug_zebra_nht_cmd);
@@ -497,6 +543,7 @@ void zebra_debug_init(void)
 	install_element(CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
 	install_element(CONFIG_NODE, &debug_zebra_rib_cmd);
 	install_element(CONFIG_NODE, &debug_zebra_fpm_cmd);
+	install_element(CONFIG_NODE, &debug_zebra_dplane_cmd);
 	install_element(CONFIG_NODE, &no_debug_zebra_events_cmd);
 	install_element(CONFIG_NODE, &no_debug_zebra_nht_cmd);
 	install_element(CONFIG_NODE, &no_debug_zebra_mpls_cmd);
@@ -506,4 +553,5 @@ void zebra_debug_init(void)
 	install_element(CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
 	install_element(CONFIG_NODE, &no_debug_zebra_rib_cmd);
 	install_element(CONFIG_NODE, &no_debug_zebra_fpm_cmd);
+	install_element(CONFIG_NODE, &no_debug_zebra_dplane_cmd);
 }

zebra/debug.h

@@ -48,6 +48,9 @@
 
 #define ZEBRA_DEBUG_PW      0x01
 
+#define ZEBRA_DEBUG_DPLANE           0x01
+#define ZEBRA_DEBUG_DPLANE_DETAILED  0x02
+
 /* Debug related macro. */
 #define IS_ZEBRA_DEBUG_EVENT  (zebra_debug_event & ZEBRA_DEBUG_EVENT)
 
@@ -72,6 +75,10 @@
 #define IS_ZEBRA_DEBUG_VXLAN (zebra_debug_vxlan & ZEBRA_DEBUG_VXLAN)
 #define IS_ZEBRA_DEBUG_PW  (zebra_debug_pw & ZEBRA_DEBUG_PW)
 
+#define IS_ZEBRA_DEBUG_DPLANE (zebra_debug_dplane & ZEBRA_DEBUG_DPLANE)
+#define IS_ZEBRA_DEBUG_DPLANE_DETAIL \
+	(zebra_debug_dplane & ZEBRA_DEBUG_DPLANE_DETAILED)
+
 extern unsigned long zebra_debug_event;
 extern unsigned long zebra_debug_packet;
 extern unsigned long zebra_debug_kernel;
@@ -81,6 +88,7 @@ extern unsigned long zebra_debug_nht;
 extern unsigned long zebra_debug_mpls;
 extern unsigned long zebra_debug_vxlan;
 extern unsigned long zebra_debug_pw;
+extern unsigned long zebra_debug_dplane;
 
 extern void zebra_debug_init(void);
 

zebra/if_netlink.c

@@ -705,8 +705,8 @@ static int netlink_interface(struct nlmsghdr *h, ns_id_t ns_id, int startup)
 }
 
 /* Request for specific interface or address information from the kernel */
-static int netlink_request_intf_addr(struct zebra_ns *zns, int family, int type,
+static int netlink_request_intf_addr(struct nlsock *netlink_cmd, int family,
-				     uint32_t filter_mask)
+				     int type, uint32_t filter_mask)
 {
 	struct {
 		struct nlmsghdr n;
@@ -724,39 +724,44 @@ static int netlink_request_intf_addr(struct zebra_ns *zns, int family, int type,
 	if (filter_mask)
 		addattr32(&req.n, sizeof(req), IFLA_EXT_MASK, filter_mask);
 
-	return netlink_request(&zns->netlink_cmd, &req.n);
+	return netlink_request(netlink_cmd, &req.n);
 }
 
 /* Interface lookup by netlink socket. */
 int interface_lookup_netlink(struct zebra_ns *zns)
 {
 	int ret;
+	struct zebra_dplane_info dp_info;
+	struct nlsock *netlink_cmd = &zns->netlink_cmd;
+
+	/* Capture key info from ns struct */
+	zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
 
 	/* Get interface information. */
-	ret = netlink_request_intf_addr(zns, AF_PACKET, RTM_GETLINK, 0);
+	ret = netlink_request_intf_addr(netlink_cmd, AF_PACKET, RTM_GETLINK, 0);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_interface, &zns->netlink_cmd, zns, 0,
+	ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
 				 1);
 	if (ret < 0)
 		return ret;
 
 	/* Get interface information - for bridge interfaces. */
-	ret = netlink_request_intf_addr(zns, AF_BRIDGE, RTM_GETLINK,
+	ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
 					RTEXT_FILTER_BRVLAN);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_interface, &zns->netlink_cmd, zns, 0,
+	ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
 				 0);
 	if (ret < 0)
 		return ret;
 
 	/* Get interface information - for bridge interfaces. */
-	ret = netlink_request_intf_addr(zns, AF_BRIDGE, RTM_GETLINK,
+	ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
 					RTEXT_FILTER_BRVLAN);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_interface, &zns->netlink_cmd, zns, 0,
+	ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
 				 0);
 	if (ret < 0)
 		return ret;
@@ -765,19 +770,19 @@ int interface_lookup_netlink(struct zebra_ns *zns)
 	zebra_if_update_all_links();
 
 	/* Get IPv4 address of the interfaces. */
-	ret = netlink_request_intf_addr(zns, AF_INET, RTM_GETADDR, 0);
+	ret = netlink_request_intf_addr(netlink_cmd, AF_INET, RTM_GETADDR, 0);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_interface_addr, &zns->netlink_cmd, zns,
+	ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
 				 0, 1);
 	if (ret < 0)
 		return ret;
 
 	/* Get IPv6 address of the interfaces. */
-	ret = netlink_request_intf_addr(zns, AF_INET6, RTM_GETADDR, 0);
+	ret = netlink_request_intf_addr(netlink_cmd, AF_INET6, RTM_GETADDR, 0);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_interface_addr, &zns->netlink_cmd, zns,
+	ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
 				 0, 1);
 	if (ret < 0)
 		return ret;

zebra/kernel_netlink.c

@@ -373,7 +373,13 @@ static long netlink_read_file(char *buf, const char *fname)
 static int kernel_read(struct thread *thread)
 {
 	struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG(thread);
-	netlink_parse_info(netlink_information_fetch, &zns->netlink, zns, 5, 0);
+	struct zebra_dplane_info dp_info;
+
+	/* Capture key info from ns struct */
+	zebra_dplane_info_from_zns(&dp_info, zns, false);
+
+	netlink_parse_info(netlink_information_fetch, &zns->netlink, &dp_info,
+			   5, 0);
 	zns->t_netlink = NULL;
 	thread_add_read(zebrad.master, kernel_read, zns, zns->netlink.sock,
 			&zns->t_netlink);
@@ -672,8 +678,8 @@ static void netlink_parse_extended_ack(struct nlmsghdr *h)
  *            the filter.
  */
 int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
-		       struct nlsock *nl, struct zebra_ns *zns, int count,
+		       struct nlsock *nl, struct zebra_dplane_info *zns,
-		       int startup)
+		       int count, int startup)
 {
 	int status;
 	int ret = 0;
@@ -811,7 +817,7 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 
 				/* Deal with errors that occur because of races
 				 * in link handling */
-				if (nl == &zns->netlink_cmd
+				if (zns->is_cmd
 				    && ((msg_type == RTM_DELROUTE
 					 && (-errnum == ENODEV
 					     || -errnum == ESRCH))
@@ -838,8 +844,7 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 				 * so do not log these as an error.
 				 */
 				if (msg_type == RTM_DELNEIGH
-				    || (nl == &zns->netlink_cmd
+				    || (zns->is_cmd && msg_type == RTM_NEWROUTE
-					&& msg_type == RTM_NEWROUTE
 					&& (-errnum == ESRCH
 					    || -errnum == ENETUNREACH))) {
 					/* This is known to happen in some
@@ -935,6 +940,7 @@ int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
 	struct iovec iov;
 	struct msghdr msg;
 	int save_errno = 0;
+	struct zebra_dplane_info dp_info;
 
 	memset(&snl, 0, sizeof snl);
 	memset(&iov, 0, sizeof iov);
@@ -981,7 +987,8 @@ int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
 	 * Get reply from netlink socket.
 	 * The reply should either be an acknowlegement or an error.
 	 */
-	return netlink_parse_info(filter, nl, zns, 0, startup);
+	zebra_dplane_info_from_zns(&dp_info, zns, (nl == &(zns->netlink_cmd)));
+	return netlink_parse_info(filter, nl, &dp_info, 0, startup);
 }
 
 /* Issue request message to kernel via netlink socket. GET messages

zebra/kernel_netlink.h

@@ -52,7 +52,7 @@ extern bool netlink_read;
 extern void netlink_read_init(const char *fname);
 #endif /* HANDLE_NETLINK_FUZZING */
 extern int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
-			      struct nlsock *nl, struct zebra_ns *zns,
+			      struct nlsock *nl, struct zebra_dplane_info *zns,
 			      int count, int startup);
 extern int netlink_talk_filter(struct nlmsghdr *h, ns_id_t ns, int startup);
 extern int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),

zebra/rt.h

@@ -29,31 +29,7 @@
 #include "zebra/rib.h"
 #include "zebra/zebra_ns.h"
 #include "zebra/zebra_mpls.h"
-
+#include "zebra/zebra_dplane.h"
-/*
- * Philosophy Note:
- *
- * Flags being SET/UNSET do not belong in the South Bound
- * Interface.  This Setting belongs at the calling level
- * because we can and will have multiple different interfaces
- * and we will have potentially multiple different
- * modules/filters to call.  As such Setting/Unsetting
- * success failure should be handled by the caller.
- */
-
-
-enum dp_results {
-	DP_INSTALL_SUCCESS,
-	DP_INSTALL_FAILURE,
-	DP_DELETE_SUCCESS,
-	DP_DELETE_FAILURE,
-};
-
-enum dp_req_result {
-	DP_REQUEST_QUEUED,
-	DP_REQUEST_SUCCESS,
-	DP_REQUEST_FAILURE,
-};
 
 /*
  * Install/delete the specified prefix p from the kernel
@@ -66,11 +42,11 @@ enum dp_req_result {
  * semantics so we will end up with a delete than
  * a re-add.
  */
-extern enum dp_req_result kernel_route_rib(struct route_node *rn,
+extern enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
-					   const struct prefix *p,
+						 const struct prefix *p,
-					   const struct prefix *src_p,
+						 const struct prefix *src_p,
-					   struct route_entry *old,
+						 struct route_entry *old,
-					   struct route_entry *new);
+						 struct route_entry *new);
 
 /*
  * So route install/failure may not be immediately known
@@ -80,7 +56,7 @@ extern enum dp_req_result kernel_route_rib(struct route_node *rn,
 extern void kernel_route_rib_pass_fail(struct route_node *rn,
 				       const struct prefix *p,
 				       struct route_entry *re,
-				       enum dp_results res);
+				       enum zebra_dplane_status res);
 
 extern int kernel_address_add_ipv4(struct interface *, struct connected *);
 extern int kernel_address_delete_ipv4(struct interface *, struct connected *);
@@ -91,9 +67,9 @@ extern int kernel_neigh_update(int cmd, int ifindex, uint32_t addr, char *lla,
 extern int kernel_interface_set_master(struct interface *master,
 				       struct interface *slave);
 
-extern enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp);
+extern enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp);
-extern enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp);
+extern enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp);
-extern enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp);
+extern enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp);
 
 /*
  * Add the ability to pass back up the lsp install/delete
@@ -104,7 +80,7 @@ extern enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp);
  * the install/failure to set/unset flags and to notify
  * as needed.
  */
-extern void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum dp_results res);
+extern void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum zebra_dplane_status res);
 
 extern int mpls_kernel_init(void);
 

zebra/rt_netlink.c

@@ -890,13 +890,16 @@ static int netlink_request_route(struct zebra_ns *zns, int family, int type)
 int netlink_route_read(struct zebra_ns *zns)
 {
 	int ret;
+	struct zebra_dplane_info dp_info;
+
+	zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
 
 	/* Get IPv4 routing table. */
 	ret = netlink_request_route(zns, AF_INET, RTM_GETROUTE);
 	if (ret < 0)
 		return ret;
 	ret = netlink_parse_info(netlink_route_change_read_unicast,
-				 &zns->netlink_cmd, zns, 0, 1);
+				 &zns->netlink_cmd, &dp_info, 0, 1);
 	if (ret < 0)
 		return ret;
 
@@ -905,7 +908,7 @@ int netlink_route_read(struct zebra_ns *zns)
 	if (ret < 0)
 		return ret;
 	ret = netlink_parse_info(netlink_route_change_read_unicast,
-				 &zns->netlink_cmd, zns, 0, 1);
+				 &zns->netlink_cmd, &dp_info, 0, 1);
 	if (ret < 0)
 		return ret;
 
@@ -1818,11 +1821,11 @@ int kernel_get_ipmr_sg_stats(struct zebra_vrf *zvrf, void *in)
 	return suc;
 }
 
-enum dp_req_result kernel_route_rib(struct route_node *rn,
+enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
-				    const struct prefix *p,
+					  const struct prefix *p,
-				    const struct prefix *src_p,
+					  const struct prefix *src_p,
-				    struct route_entry *old,
+					  struct route_entry *old,
-				    struct route_entry *new)
+					  struct route_entry *new)
 {
 	int ret = 0;
 
@@ -1852,20 +1855,20 @@ enum dp_req_result kernel_route_rib(struct route_node *rn,
 						      new, 0);
 		}
 		kernel_route_rib_pass_fail(rn, p, new,
-					   (!ret) ? DP_INSTALL_SUCCESS
+					   (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-						  : DP_INSTALL_FAILURE);
+						  : ZEBRA_DPLANE_INSTALL_FAILURE);
-		return DP_REQUEST_SUCCESS;
+		return ZEBRA_DPLANE_REQUEST_SUCCESS;
 	}
 
 	if (old) {
 		ret = netlink_route_multipath(RTM_DELROUTE, p, src_p, old, 0);
 
 		kernel_route_rib_pass_fail(rn, p, old,
-					   (!ret) ? DP_DELETE_SUCCESS
+					   (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
-						  : DP_DELETE_FAILURE);
+						  : ZEBRA_DPLANE_DELETE_FAILURE);
 	}
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
@@ -2102,8 +2105,8 @@ static int netlink_macfdb_table(struct nlmsghdr *h, ns_id_t ns_id, int startup)
 }
 
 /* Request for MAC FDB information from the kernel */
-static int netlink_request_macs(struct zebra_ns *zns, int family, int type,
+static int netlink_request_macs(struct nlsock *netlink_cmd, int family,
-				ifindex_t master_ifindex)
+				int type, ifindex_t master_ifindex)
 {
 	struct {
 		struct nlmsghdr n;
@@ -2119,7 +2122,7 @@ static int netlink_request_macs(struct zebra_ns *zns, int family, int type,
 	if (master_ifindex)
 		addattr32(&req.n, sizeof(req), IFLA_MASTER, master_ifindex);
 
-	return netlink_request(&zns->netlink_cmd, &req.n);
+	return netlink_request(netlink_cmd, &req.n);
 }
 
 /*
@@ -2129,15 +2132,19 @@ static int netlink_request_macs(struct zebra_ns *zns, int family, int type,
 int netlink_macfdb_read(struct zebra_ns *zns)
 {
 	int ret;
+	struct zebra_dplane_info dp_info;
+
+	zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
 
 	/* Get bridge FDB table. */
-	ret = netlink_request_macs(zns, AF_BRIDGE, RTM_GETNEIGH, 0);
+	ret = netlink_request_macs(&zns->netlink_cmd, AF_BRIDGE, RTM_GETNEIGH,
+				   0);
 	if (ret < 0)
 		return ret;
 	/* We are reading entire table. */
 	filter_vlan = 0;
-	ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd, zns,
+	ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd,
-				 0, 1);
+				 &dp_info, 0, 1);
 
 	return ret;
 }
@@ -2152,8 +2159,10 @@ int netlink_macfdb_read_for_bridge(struct zebra_ns *zns, struct interface *ifp,
 	struct zebra_if *br_zif;
 	struct zebra_if *zif;
 	struct zebra_l2info_vxlan *vxl;
+	struct zebra_dplane_info dp_info;
 	int ret = 0;
 
+	zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
 
 	/* Save VLAN we're filtering on, if needed. */
 	br_zif = (struct zebra_if *)br_if->info;
@@ -2164,12 +2173,12 @@ int netlink_macfdb_read_for_bridge(struct zebra_ns *zns, struct interface *ifp,
 
 	/* Get bridge FDB table for specific bridge - we do the VLAN filtering.
 	 */
-	ret = netlink_request_macs(zns, AF_BRIDGE, RTM_GETNEIGH,
+	ret = netlink_request_macs(&zns->netlink_cmd, AF_BRIDGE, RTM_GETNEIGH,
 				   br_if->ifindex);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd, zns,
+	ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd,
-				 0, 0);
+				 &dp_info, 0, 0);
 
 	/* Reset VLAN filter. */
 	filter_vlan = 0;
@@ -2419,8 +2428,8 @@ static int netlink_neigh_table(struct nlmsghdr *h, ns_id_t ns_id, int startup)
 }
 
 /* Request for IP neighbor information from the kernel */
-static int netlink_request_neigh(struct zebra_ns *zns, int family, int type,
+static int netlink_request_neigh(struct nlsock *netlink_cmd, int family,
-				 ifindex_t ifindex)
+				 int type, ifindex_t ifindex)
 {
 	struct {
 		struct nlmsghdr n;
@@ -2436,7 +2445,7 @@ static int netlink_request_neigh(struct zebra_ns *zns, int family, int type,
 	if (ifindex)
 		addattr32(&req.n, sizeof(req), NDA_IFINDEX, ifindex);
 
-	return netlink_request(&zns->netlink_cmd, &req.n);
+	return netlink_request(netlink_cmd, &req.n);
 }
 
 /*
@@ -2446,13 +2455,17 @@ static int netlink_request_neigh(struct zebra_ns *zns, int family, int type,
 int netlink_neigh_read(struct zebra_ns *zns)
 {
 	int ret;
+	struct zebra_dplane_info dp_info;
+
+	zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
 
 	/* Get IP neighbor table. */
-	ret = netlink_request_neigh(zns, AF_UNSPEC, RTM_GETNEIGH, 0);
+	ret = netlink_request_neigh(&zns->netlink_cmd, AF_UNSPEC, RTM_GETNEIGH,
+				    0);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd, zns, 0,
+	ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd,
-				 1);
+				 &dp_info, 0, 1);
 
 	return ret;
 }
@@ -2464,13 +2477,16 @@ int netlink_neigh_read(struct zebra_ns *zns)
 int netlink_neigh_read_for_vlan(struct zebra_ns *zns, struct interface *vlan_if)
 {
 	int ret = 0;
+	struct zebra_dplane_info dp_info;
 
-	ret = netlink_request_neigh(zns, AF_UNSPEC, RTM_GETNEIGH,
+	zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
+
+	ret = netlink_request_neigh(&zns->netlink_cmd, AF_UNSPEC, RTM_GETNEIGH,
 				    vlan_if->ifindex);
 	if (ret < 0)
 		return ret;
-	ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd, zns, 0,
+	ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd,
-				 0);
+				 &dp_info, 0, 0);
 
 	return ret;
 }

zebra/rt_socket.c

@@ -391,18 +391,18 @@ static int kernel_rtm(int cmd, const struct prefix *p, struct route_entry *re)
 	return 0;
 }
 
-enum dp_req_result kernel_route_rib(struct route_node *rn,
+enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
-				    const struct prefix *p,
+					  const struct prefix *p,
-				    const struct prefix *src_p,
+					  const struct prefix *src_p,
-				    struct route_entry *old,
+					  struct route_entry *old,
-				    struct route_entry *new)
+					  struct route_entry *new)
 {
 	int route = 0;
 
 	if (src_p && src_p->prefixlen) {
 		flog_warn(EC_ZEBRA_UNSUPPORTED_V6_SRCDEST,
 			  "%s: IPv6 sourcedest routes unsupported!", __func__);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	frr_elevate_privs(&zserv_privs) {
@@ -418,16 +418,16 @@ enum dp_req_result kernel_route_rib(struct route_node *rn,
 	if (new) {
 		kernel_route_rib_pass_fail(
 			rn, p, new,
-			(!route) ? DP_INSTALL_SUCCESS
+			(!route) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-				 : DP_INSTALL_FAILURE);
+				 : ZEBRA_DPLANE_INSTALL_FAILURE);
 	} else {
 		kernel_route_rib_pass_fail(rn, p, old,
 					   (!route)
-						   ? DP_DELETE_SUCCESS
+						   ? ZEBRA_DPLANE_DELETE_SUCCESS
-						   : DP_DELETE_FAILURE);
+						   : ZEBRA_DPLANE_DELETE_FAILURE);
 	}
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,

zebra/rule_netlink.c

@@ -143,31 +143,31 @@ static int netlink_rule_update(int cmd, struct zebra_pbr_rule *rule)
  * goes in the rule to denote relative ordering; it may or may not be the
  * same as the rule's user-defined sequence number.
  */
-enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
 {
 	int ret = 0;
 
 	ret = netlink_rule_update(RTM_NEWRULE, rule);
 	kernel_pbr_rule_add_del_status(rule,
-				       (!ret) ? DP_INSTALL_SUCCESS
+				       (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-					      : DP_INSTALL_FAILURE);
+					      : ZEBRA_DPLANE_INSTALL_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 /*
  * Uninstall specified rule for a specific interface.
  */
-enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
 {
 	int ret = 0;
 
 	ret = netlink_rule_update(RTM_DELRULE, rule);
 	kernel_pbr_rule_add_del_status(rule,
-				       (!ret) ? DP_DELETE_SUCCESS
+				       (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
-					      : DP_DELETE_FAILURE);
+					      : ZEBRA_DPLANE_DELETE_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 /*

zebra/rule_socket.c

@@ -43,18 +43,18 @@
 #include "zebra/zebra_pbr.h"
 #include "zebra/zebra_errors.h"
 
-enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
 {
 	flog_err(EC_LIB_UNAVAILABLE, "%s not Implemented for this platform",
 		 __PRETTY_FUNCTION__);
-	return DP_REQUEST_FAILURE;
+	return ZEBRA_DPLANE_REQUEST_FAILURE;
 }
 
-enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
 {
 	flog_err(EC_LIB_UNAVAILABLE, "%s not Implemented for this platform",
 		 __PRETTY_FUNCTION__);
-	return DP_REQUEST_FAILURE;
+	return ZEBRA_DPLANE_REQUEST_FAILURE;
 }
 
 #endif

zebra/subdir.am

@@ -66,6 +66,7 @@ zebra_zebra_SOURCES = \
 	zebra/rule_socket.c \
 	zebra/zebra_l2.c \
 	zebra/zebra_memory.c \
+	zebra/zebra_dplane.c \
 	zebra/zebra_mpls.c \
 	zebra/zebra_mpls_netlink.c \
 	zebra/zebra_mpls_openbsd.c \
@@ -115,6 +116,7 @@ noinst_HEADERS += \
 	zebra/rule_netlink.h \
 	zebra/zebra_fpm_private.h \
 	zebra/zebra_l2.h \
+	zebra/zebra_dplane.h \
 	zebra/zebra_memory.h \
 	zebra/zebra_mpls.h \
 	zebra/zebra_mroute.h \

zebra/zebra_dplane.c

@@ -0,0 +1,21 @@
+/*
+ * Zebra dataplane layer.
+ * Copyright (c) 2018 Volta Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include "zebra_dplane.h"

zebra/zebra_dplane.h

@@ -0,0 +1,99 @@
+/*
+ * Zebra dataplane layer api interfaces.
+ * Copyright (c) 2018 Volta Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _ZEBRA_DPLANE_H
+#define _ZEBRA_DPLANE_H 1
+
+#include "zebra.h"
+#include "zserv.h"
+#include "prefix.h"
+#include "nexthop.h"
+#include "nexthop_group.h"
+
+
+/*
+ * API between the zebra dataplane system and the main zebra processing
+ * context.
+ */
+
+/* Key netlink info from zebra ns */
+struct zebra_dplane_info {
+	ns_id_t ns_id;
+
+#if defined(HAVE_NETLINK)
+	uint32_t nl_pid;
+	bool is_cmd;
+#endif
+};
+
+/* Utility to fill in zns info from main zns struct */
+static inline void
+zebra_dplane_info_from_zns(struct zebra_dplane_info *zns_info,
+			   const struct zebra_ns *zns, bool is_cmd)
+{
+	zns_info->ns_id = zns->ns_id;
+
+#if defined(HAVE_NETLINK)
+	zns_info->is_cmd = is_cmd;
+	if (is_cmd) {
+		zns_info->nl_pid = zns->netlink_cmd.snl.nl_pid;
+	} else {
+		zns_info->nl_pid = zns->netlink.snl.nl_pid;
+	}
+#endif /* NETLINK */
+}
+
+/*
+ * Enqueue a route install or update for the dataplane.
+ */
+
+/*
+ * Enqueue a route removal for the dataplane.
+ */
+
+/*
+ * Result codes used when returning status back to the main zebra context.
+ */
+
+/*
+ * Philosophy Note:
+ *
+ * Flags being SET/UNSET do not belong in the South Bound
+ * Interface.  This Setting belongs at the calling level
+ * because we can and will have multiple different interfaces
+ * and we will have potentially multiple different
+ * modules/filters to call.  As such Setting/Unsetting
+ * success failure should be handled by the caller.
+ */
+enum zebra_dplane_status {
+	ZEBRA_DPLANE_STATUS_NONE = 0,
+	ZEBRA_DPLANE_INSTALL_SUCCESS,
+	ZEBRA_DPLANE_INSTALL_FAILURE,
+	ZEBRA_DPLANE_DELETE_SUCCESS,
+	ZEBRA_DPLANE_DELETE_FAILURE,
+
+};
+
+enum zebra_dplane_result {
+	ZEBRA_DPLANE_REQUEST_QUEUED,
+	ZEBRA_DPLANE_REQUEST_SUCCESS,
+	ZEBRA_DPLANE_REQUEST_FAILURE,
+};
+
+#endif	/* _ZEBRA_DPLANE_H */

zebra/zebra_fpm_netlink.c

@@ -32,6 +32,7 @@
 #include "prefix.h"
 
 #include "zebra/zserv.h"
+#include "zebra/zebra_dplane.h"
 #include "zebra/zebra_ns.h"
 #include "zebra/zebra_vrf.h"
 #include "zebra/kernel_netlink.h"

zebra/zebra_mpls.c

@@ -917,14 +917,14 @@ static wq_item_status lsp_process(struct work_queue *wq, void *data)
 
 			UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
 			switch (kernel_add_lsp(lsp)) {
-			case DP_REQUEST_QUEUED:
+			case ZEBRA_DPLANE_REQUEST_QUEUED:
 				flog_err(
 					EC_ZEBRA_DP_INVALID_RC,
 					"No current DataPlane interfaces can return this, please fix");
 				break;
-			case DP_REQUEST_FAILURE:
+			case ZEBRA_DPLANE_REQUEST_FAILURE:
 				break;
-			case DP_REQUEST_SUCCESS:
+			case ZEBRA_DPLANE_REQUEST_SUCCESS:
 				zvrf->lsp_installs++;
 				break;
 			}
@@ -934,14 +934,14 @@ static wq_item_status lsp_process(struct work_queue *wq, void *data)
 		if (!newbest) {
 
 			switch (kernel_del_lsp(lsp)) {
-			case DP_REQUEST_QUEUED:
+			case ZEBRA_DPLANE_REQUEST_QUEUED:
 				flog_err(
 					EC_ZEBRA_DP_INVALID_RC,
 					"No current DataPlane interfaces can return this, please fix");
 				break;
-			case DP_REQUEST_FAILURE:
+			case ZEBRA_DPLANE_REQUEST_FAILURE:
 				break;
-			case DP_REQUEST_SUCCESS:
+			case ZEBRA_DPLANE_REQUEST_SUCCESS:
 				zvrf->lsp_removals++;
 				break;
 			}
@@ -974,14 +974,14 @@ static wq_item_status lsp_process(struct work_queue *wq, void *data)
 			}
 
 			switch (kernel_upd_lsp(lsp)) {
-			case DP_REQUEST_QUEUED:
+			case ZEBRA_DPLANE_REQUEST_QUEUED:
 				flog_err(
 					EC_ZEBRA_DP_INVALID_RC,
 					"No current DataPlane interfaces can return this, please fix");
 				break;
-			case DP_REQUEST_FAILURE:
+			case ZEBRA_DPLANE_REQUEST_FAILURE:
 				break;
-			case DP_REQUEST_SUCCESS:
+			case ZEBRA_DPLANE_REQUEST_SUCCESS:
 				zvrf->lsp_installs++;
 				break;
 			}
@@ -1716,7 +1716,7 @@ static int mpls_processq_init(struct zebra_t *zebra)
 
 /* Public functions */
 
-void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum dp_results res)
+void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum zebra_dplane_status res)
 {
 	struct nexthop *nexthop;
 	zebra_nhlfe_t *nhlfe;
@@ -1725,13 +1725,13 @@ void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum dp_results res)
 		return;
 
 	switch (res) {
-	case DP_INSTALL_FAILURE:
+	case ZEBRA_DPLANE_INSTALL_FAILURE:
 		UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 		clear_nhlfe_installed(lsp);
 		flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE,
 			  "LSP Install Failure: %u", lsp->ile.in_label);
 		break;
-	case DP_INSTALL_SUCCESS:
+	case ZEBRA_DPLANE_INSTALL_SUCCESS:
 		SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 		for (nhlfe = lsp->nhlfe_list; nhlfe; nhlfe = nhlfe->next) {
 			nexthop = nhlfe->nexthop;
@@ -1742,14 +1742,16 @@ void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum dp_results res)
 			SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
 		}
 		break;
-	case DP_DELETE_SUCCESS:
+	case ZEBRA_DPLANE_DELETE_SUCCESS:
 		UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
 		clear_nhlfe_installed(lsp);
 		break;
-	case DP_DELETE_FAILURE:
+	case ZEBRA_DPLANE_DELETE_FAILURE:
 		flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE,
 			  "LSP Deletion Failure: %u", lsp->ile.in_label);
 		break;
+	case ZEBRA_DPLANE_STATUS_NONE:
+		break;
 	}
 }
 

zebra/zebra_mpls_netlink.c

@@ -29,22 +29,22 @@
 /*
  * Install Label Forwarding entry into the kernel.
  */
-enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp)
 {
 	int ret;
 
 	if (!lsp || !lsp->best_nhlfe) { // unexpected
-		kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
 
 	kernel_lsp_pass_fail(lsp,
-			     (!ret) ? DP_INSTALL_SUCCESS
+			     (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-				    : DP_INSTALL_FAILURE);
+				    : ZEBRA_DPLANE_INSTALL_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 /*
@@ -58,48 +58,48 @@ enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
  * through the metric field (before kernel-MPLS). This shouldn't be an issue
  * any longer, so REPLACE can be reintroduced.
  */
-enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp)
 {
 	int ret;
 
 	if (!lsp || !lsp->best_nhlfe) { // unexpected
-		kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
 
 	kernel_lsp_pass_fail(lsp,
-			     (!ret) ? DP_INSTALL_SUCCESS
+			     (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-				    : DP_INSTALL_FAILURE);
+				    : ZEBRA_DPLANE_INSTALL_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 /*
  * Delete Label Forwarding entry from the kernel.
  */
-enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp)
 {
 	int ret;
 
 	if (!lsp) { // unexpected
-		kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
-		kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	ret = netlink_mpls_multipath(RTM_DELROUTE, lsp);
 
 	kernel_lsp_pass_fail(lsp,
-			     (!ret) ? DP_DELETE_SUCCESS
+			     (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
-				    : DP_DELETE_FAILURE);
+				    : ZEBRA_DPLANE_DELETE_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 int mpls_kernel_init(void)

zebra/zebra_mpls_null.c

@@ -24,19 +24,19 @@
 
 #if !defined(HAVE_NETLINK) && !defined(OPEN_BSD)
 
-enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp)
 {
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
-enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp)
 {
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
-enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp)
 {
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 int mpls_kernel_init(void)

zebra/zebra_mpls_openbsd.c

@@ -285,62 +285,62 @@ static int kernel_lsp_cmd(int action, zebra_lsp_t *lsp)
 	return (0);
 }
 
-enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp)
 {
 	int ret;
 
 	if (!lsp || !lsp->best_nhlfe) { // unexpected
-		kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	ret = kernel_lsp_cmd(RTM_ADD, lsp);
 
 	kernel_lsp_pass_fail(lsp,
-			     (!ret) ? DP_INSTALL_SUCCESS
+			     (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-				    : DP_INSTALL_FAILURE);
+				    : ZEBRA_DPLANE_INSTALL_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
-enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp)
 {
 	int ret;
 
 	if (!lsp || !lsp->best_nhlfe) { // unexpected
-		kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	ret = kernel_lsp_cmd(RTM_CHANGE, lsp);
 
 	kernel_lsp_pass_fail(lsp,
-			     (!ret) ? DP_INSTALL_SUCCESS
+			     (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
-				    : DP_INSTALL_FAILURE);
+				    : ZEBRA_DPLANE_INSTALL_FAILURE);
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
-enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp)
 {
 	int ret;
 
 	if (!lsp) { // unexpected
-		kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
-		kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
+		kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
-		return DP_REQUEST_FAILURE;
+		return ZEBRA_DPLANE_REQUEST_FAILURE;
 	}
 
 	ret = kernel_lsp_cmd(RTM_DELETE, lsp);
 
 	kernel_lsp_pass_fail(lsp,
-			     (!ret) ? DP_DELETE_SUCCESS
+			     (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
-				    : DP_DELETE_FAILURE);
+				    : ZEBRA_DPLANE_DELETE_FAILURE);
 
-	return DP_REQUEST_SUCCESS;
+	return ZEBRA_DPLANE_REQUEST_SUCCESS;
 }
 
 static int kmpw_install(struct zebra_pw *pw)

zebra/zebra_netns_id.c

@@ -24,13 +24,14 @@
 #include "log.h"
 #include "lib_errors.h"
 
+#include "zebra/rib.h"
+#include "zebra/zebra_dplane.h"
 #if defined(HAVE_NETLINK)
 
 #include <linux/net_namespace.h>
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
 
-#include "rib.h"
 #include "zebra_ns.h"
 #include "kernel_netlink.h"
 #endif /* defined(HAVE_NETLINK) */

zebra/zebra_pbr.c

@@ -565,8 +565,8 @@ void zebra_pbr_create_ipset(struct zebra_ns *zns,
 	ret = hook_call(zebra_pbr_ipset_wrap_script_update,
 		  zns, 1, ipset);
 	kernel_pbr_ipset_add_del_status(ipset,
-					ret ? DP_INSTALL_SUCCESS
+					ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
-					: DP_INSTALL_FAILURE);
+					: ZEBRA_DPLANE_INSTALL_FAILURE);
 }
 
 void zebra_pbr_destroy_ipset(struct zebra_ns *zns,
@@ -650,8 +650,8 @@ void zebra_pbr_add_ipset_entry(struct zebra_ns *zns,
 	ret = hook_call(zebra_pbr_ipset_entry_wrap_script_update,
 		  zns, 1, ipset);
 	kernel_pbr_ipset_entry_add_del_status(ipset,
-					ret ? DP_INSTALL_SUCCESS
+					ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
-					: DP_INSTALL_FAILURE);
+					: ZEBRA_DPLANE_INSTALL_FAILURE);
 }
 
 void zebra_pbr_del_ipset_entry(struct zebra_ns *zns,
@@ -693,8 +693,8 @@ void zebra_pbr_add_iptable(struct zebra_ns *zns,
 		       pbr_iptable_alloc_intern);
 	ret = hook_call(zebra_pbr_iptable_wrap_script_update, zns, 1, iptable);
 	kernel_pbr_iptable_add_del_status(iptable,
-					  ret ? DP_INSTALL_SUCCESS
+					  ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
-					  : DP_INSTALL_FAILURE);
+					  : ZEBRA_DPLANE_INSTALL_FAILURE);
 }
 
 void zebra_pbr_del_iptable(struct zebra_ns *zns,
@@ -725,21 +725,23 @@ void zebra_pbr_del_iptable(struct zebra_ns *zns,
  * Handle success or failure of rule (un)install in the kernel.
  */
 void kernel_pbr_rule_add_del_status(struct zebra_pbr_rule *rule,
-				    enum dp_results res)
+				    enum zebra_dplane_status res)
 {
 	switch (res) {
-	case DP_INSTALL_SUCCESS:
+	case ZEBRA_DPLANE_INSTALL_SUCCESS:
 		zsend_rule_notify_owner(rule, ZAPI_RULE_INSTALLED);
 		break;
-	case DP_INSTALL_FAILURE:
+	case ZEBRA_DPLANE_INSTALL_FAILURE:
 		zsend_rule_notify_owner(rule, ZAPI_RULE_FAIL_INSTALL);
 		break;
-	case DP_DELETE_SUCCESS:
+	case ZEBRA_DPLANE_DELETE_SUCCESS:
 		zsend_rule_notify_owner(rule, ZAPI_RULE_REMOVED);
 		break;
-	case DP_DELETE_FAILURE:
+	case ZEBRA_DPLANE_DELETE_FAILURE:
 		zsend_rule_notify_owner(rule, ZAPI_RULE_FAIL_REMOVE);
 		break;
+	case ZEBRA_DPLANE_STATUS_NONE:
+		break;
 	}
 }
 
@@ -747,21 +749,23 @@ void kernel_pbr_rule_add_del_status(struct zebra_pbr_rule *rule,
  * Handle success or failure of ipset (un)install in the kernel.
  */
 void kernel_pbr_ipset_add_del_status(struct zebra_pbr_ipset *ipset,
-				    enum dp_results res)
+				    enum zebra_dplane_status res)
 {
 	switch (res) {
-	case DP_INSTALL_SUCCESS:
+	case ZEBRA_DPLANE_INSTALL_SUCCESS:
 		zsend_ipset_notify_owner(ipset, ZAPI_IPSET_INSTALLED);
 		break;
-	case DP_INSTALL_FAILURE:
+	case ZEBRA_DPLANE_INSTALL_FAILURE:
 		zsend_ipset_notify_owner(ipset, ZAPI_IPSET_FAIL_INSTALL);
 		break;
-	case DP_DELETE_SUCCESS:
+	case ZEBRA_DPLANE_DELETE_SUCCESS:
 		zsend_ipset_notify_owner(ipset, ZAPI_IPSET_REMOVED);
 		break;
-	case DP_DELETE_FAILURE:
+	case ZEBRA_DPLANE_DELETE_FAILURE:
 		zsend_ipset_notify_owner(ipset, ZAPI_IPSET_FAIL_REMOVE);
 		break;
+	case ZEBRA_DPLANE_STATUS_NONE:
+		break;
 	}
 }
 
@@ -770,25 +774,27 @@ void kernel_pbr_ipset_add_del_status(struct zebra_pbr_ipset *ipset,
  */
 void kernel_pbr_ipset_entry_add_del_status(
 			struct zebra_pbr_ipset_entry *ipset,
-			enum dp_results res)
+			enum zebra_dplane_status res)
 {
 	switch (res) {
-	case DP_INSTALL_SUCCESS:
+	case ZEBRA_DPLANE_INSTALL_SUCCESS:
 		zsend_ipset_entry_notify_owner(ipset,
 					       ZAPI_IPSET_ENTRY_INSTALLED);
 		break;
-	case DP_INSTALL_FAILURE:
+	case ZEBRA_DPLANE_INSTALL_FAILURE:
 		zsend_ipset_entry_notify_owner(ipset,
 					       ZAPI_IPSET_ENTRY_FAIL_INSTALL);
 		break;
-	case DP_DELETE_SUCCESS:
+	case ZEBRA_DPLANE_DELETE_SUCCESS:
 		zsend_ipset_entry_notify_owner(ipset,
 					       ZAPI_IPSET_ENTRY_REMOVED);
 		break;
-	case DP_DELETE_FAILURE:
+	case ZEBRA_DPLANE_DELETE_FAILURE:
 		zsend_ipset_entry_notify_owner(ipset,
 					       ZAPI_IPSET_ENTRY_FAIL_REMOVE);
 		break;
+	case ZEBRA_DPLANE_STATUS_NONE:
+		break;
 	}
 }
 
@@ -796,23 +802,25 @@ void kernel_pbr_ipset_entry_add_del_status(
  * Handle success or failure of ipset (un)install in the kernel.
  */
 void kernel_pbr_iptable_add_del_status(struct zebra_pbr_iptable *iptable,
-				       enum dp_results res)
+				       enum zebra_dplane_status res)
 {
 	switch (res) {
-	case DP_INSTALL_SUCCESS:
+	case ZEBRA_DPLANE_INSTALL_SUCCESS:
 		zsend_iptable_notify_owner(iptable, ZAPI_IPTABLE_INSTALLED);
 		break;
-	case DP_INSTALL_FAILURE:
+	case ZEBRA_DPLANE_INSTALL_FAILURE:
 		zsend_iptable_notify_owner(iptable, ZAPI_IPTABLE_FAIL_INSTALL);
 		break;
-	case DP_DELETE_SUCCESS:
+	case ZEBRA_DPLANE_DELETE_SUCCESS:
 		zsend_iptable_notify_owner(iptable,
 					   ZAPI_IPTABLE_REMOVED);
 		break;
-	case DP_DELETE_FAILURE:
+	case ZEBRA_DPLANE_DELETE_FAILURE:
 		zsend_iptable_notify_owner(iptable,
 					   ZAPI_IPTABLE_FAIL_REMOVE);
 		break;
+	case ZEBRA_DPLANE_STATUS_NONE:
+		break;
 	}
 }
 

zebra/zebra_pbr.h

@@ -175,12 +175,12 @@ void zebra_pbr_del_iptable(struct zebra_ns *zns,
  * forwarding plane may not coincide, hence the API requires a separate
  * rule priority - maps to preference/FRA_PRIORITY on Linux.
  */
-extern enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule);
+extern enum zebra_dplane_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule);
 
 /*
  * Uninstall specified rule for a specific interface.
  */
-extern enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule);
+extern enum zebra_dplane_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule);
 
 /*
  * Get to know existing PBR rules in the kernel - typically called at startup.
@@ -191,20 +191,20 @@ extern void kernel_read_pbr_rules(struct zebra_ns *zns);
  * Handle success or failure of rule (un)install in the kernel.
  */
 extern void kernel_pbr_rule_add_del_status(struct zebra_pbr_rule *rule,
-					   enum dp_results res);
+					   enum zebra_dplane_status res);
 
 /*
  * Handle success or failure of ipset kinds (un)install in the kernel.
  */
 extern void kernel_pbr_ipset_add_del_status(struct zebra_pbr_ipset *ipset,
-					   enum dp_results res);
+					   enum zebra_dplane_status res);
 
 extern void kernel_pbr_ipset_entry_add_del_status(
 				struct zebra_pbr_ipset_entry *ipset,
-				enum dp_results res);
+				enum zebra_dplane_status res);
 
 extern void kernel_pbr_iptable_add_del_status(struct zebra_pbr_iptable *iptable,
-			      enum dp_results res);
+			      enum zebra_dplane_status res);
 
 /*
  * Handle rule delete notification from kernel.

zebra/zebra_rib.c

@@ -1060,7 +1060,7 @@ int zebra_rib_labeled_unicast(struct route_entry *re)
 
 void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
 				struct route_entry *re,
-				enum dp_results res)
+				enum zebra_dplane_status res)
 {
 	struct nexthop *nexthop;
 	char buf[PREFIX_STRLEN];
@@ -1069,7 +1069,7 @@ void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
 	dest = rib_dest_from_rnode(rn);
 
 	switch (res) {
-	case DP_INSTALL_SUCCESS:
+	case ZEBRA_DPLANE_INSTALL_SUCCESS:
 		dest->selected_fib = re;
 		for (ALL_NEXTHOPS(re->ng, nexthop)) {
 			if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
@@ -1082,7 +1082,7 @@ void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
 		}
 		zsend_route_notify_owner(re, p, ZAPI_ROUTE_INSTALLED);
 		break;
-	case DP_INSTALL_FAILURE:
+	case ZEBRA_DPLANE_INSTALL_FAILURE:
 		/*
 		 * I am not sure this is the right thing to do here
 		 * but the code always set selected_fib before
@@ -1095,7 +1095,7 @@ void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
 			 "%u:%s: Route install failed", re->vrf_id,
 			 prefix2str(p, buf, sizeof(buf)));
 		break;
-	case DP_DELETE_SUCCESS:
+	case ZEBRA_DPLANE_DELETE_SUCCESS:
 		/*
 		 * The case where selected_fib is not re is
 		 * when we have received a system route
@@ -1110,7 +1110,7 @@ void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
 
 		zsend_route_notify_owner(re, p, ZAPI_ROUTE_REMOVED);
 		break;
-	case DP_DELETE_FAILURE:
+	case ZEBRA_DPLANE_DELETE_FAILURE:
 		/*
 		 * Should we set this to NULL if the
 		 * delete fails?
@@ -1122,6 +1122,8 @@ void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
 
 		zsend_route_notify_owner(re, p, ZAPI_ROUTE_REMOVE_FAIL);
 		break;
+	case ZEBRA_DPLANE_STATUS_NONE:
+		break;
 	}
 }
 
@@ -1172,17 +1174,17 @@ void rib_install_kernel(struct route_node *rn, struct route_entry *re,
 	 */
 	hook_call(rib_update, rn, "installing in kernel");
 	switch (kernel_route_rib(rn, p, src_p, old, re)) {
-	case DP_REQUEST_QUEUED:
+	case ZEBRA_DPLANE_REQUEST_QUEUED:
 		flog_err(
 			EC_ZEBRA_DP_INVALID_RC,
 			"No current known DataPlane interfaces can return this, please fix");
 		break;
-	case DP_REQUEST_FAILURE:
+	case ZEBRA_DPLANE_REQUEST_FAILURE:
 		flog_err(
 			EC_ZEBRA_DP_INSTALL_FAIL,
 			"No current known Rib Install Failure cases, please fix");
 		break;
-	case DP_REQUEST_SUCCESS:
+	case ZEBRA_DPLANE_REQUEST_SUCCESS:
 		zvrf->installs++;
 		break;
 	}
@@ -1212,17 +1214,17 @@ void rib_uninstall_kernel(struct route_node *rn, struct route_entry *re)
 	 */
 	hook_call(rib_update, rn, "uninstalling from kernel");
 	switch (kernel_route_rib(rn, p, src_p, re, NULL)) {
-	case DP_REQUEST_QUEUED:
+	case ZEBRA_DPLANE_REQUEST_QUEUED:
 		flog_err(
 			EC_ZEBRA_DP_INVALID_RC,
 			"No current known DataPlane interfaces can return this, please fix");
 		break;
-	case DP_REQUEST_FAILURE:
+	case ZEBRA_DPLANE_REQUEST_FAILURE:
 		flog_err(
 			EC_ZEBRA_DP_INSTALL_FAIL,
 			"No current known RIB Install Failure cases, please fix");
 		break;
-	case DP_REQUEST_SUCCESS:
+	case ZEBRA_DPLANE_REQUEST_SUCCESS:
 		if (zvrf)
 			zvrf->removals++;
 		break;