proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-13 16:26:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #3052 from donaldsharp/dplane_2

Browse Source 
Dplane 2
This commit is contained in:
Russ White 2018-09-24 10:54:16 -04:00 committed by GitHub
commit a1b32de24e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 410 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
zebra/debug.c
View File

@ -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);
}

8
zebra/debug.h
View File

@ -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);

31
zebra/if_netlink.c
View File

@ -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,
uint32_t filter_mask)
static int netlink_request_intf_addr(struct nlsock *netlink_cmd, int family,
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;

21
zebra/kernel_netlink.c
View File

@ -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,
int startup)
struct nlsock *nl, struct zebra_dplane_info *zns,
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
&& msg_type == RTM_NEWROUTE
|| (zns->is_cmd && 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

2
zebra/kernel_netlink.h
View File

@ -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),

46
zebra/rt.h
View File

@ -29,31 +29,7 @@
#include "zebra/rib.h"
#include "zebra/zebra_ns.h"
#include "zebra/zebra_mpls.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,
};
#include "zebra/zebra_dplane.h"
/*
* 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,
const struct prefix *p,
const struct prefix *src_p,
struct route_entry *old,
struct route_entry *new);
extern enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
const struct prefix *p,
const struct prefix *src_p,
struct route_entry *old,
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 dp_req_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_add_lsp(zebra_lsp_t *lsp);
extern enum zebra_dplane_result kernel_upd_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);

78
zebra/rt_netlink.c
View File

@ -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,
const struct prefix *p,
const struct prefix *src_p,
struct route_entry *old,
struct route_entry *new)
enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
const struct prefix *p,
const struct prefix *src_p,
struct route_entry *old,
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
: DP_INSTALL_FAILURE);
return DP_REQUEST_SUCCESS;
(!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: ZEBRA_DPLANE_INSTALL_FAILURE);
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
: DP_DELETE_FAILURE);
(!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
: 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,
ifindex_t master_ifindex)
static int netlink_request_macs(struct nlsock *netlink_cmd, int family,
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,
0, 1);
ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd,
&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,
0, 0);
ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd,
&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,
ifindex_t ifindex)
static int netlink_request_neigh(struct nlsock *netlink_cmd, int family,
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,
1);
ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd,
&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,
0);
ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd,
&dp_info, 0, 0);
return ret;
}

22
zebra/rt_socket.c
View File

@ -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,
const struct prefix *p,
const struct prefix *src_p,
struct route_entry *old,
struct route_entry *new)
enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
const struct prefix *p,
const struct prefix *src_p,
struct route_entry *old,
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
: DP_INSTALL_FAILURE);
(!route) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: ZEBRA_DPLANE_INSTALL_FAILURE);
} else {
kernel_route_rib_pass_fail(rn, p, old,
(!route)
? DP_DELETE_SUCCESS
: DP_DELETE_FAILURE);
? ZEBRA_DPLANE_DELETE_SUCCESS
: 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,

16
zebra/rule_netlink.c
View File

@ -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
: DP_INSTALL_FAILURE);
(!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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
: DP_DELETE_FAILURE);
(!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
: ZEBRA_DPLANE_DELETE_FAILURE);
return DP_REQUEST_SUCCESS;
return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
/*

8
zebra/rule_socket.c
View File

@ -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

2
zebra/subdir.am
View File

@ -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 \

21
zebra/zebra_dplane.c Normal file
View File

@ -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"

99
zebra/zebra_dplane.h Normal file
View File

@ -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 */

1
zebra/zebra_fpm_netlink.c
View File

@ -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"

30
zebra/zebra_mpls.c
View File

@ -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;
}
}

40
zebra/zebra_mpls_netlink.c
View File

@ -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);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
kernel_lsp_pass_fail(lsp,
(!ret) ? DP_INSTALL_SUCCESS
: DP_INSTALL_FAILURE);
(!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
kernel_lsp_pass_fail(lsp,
(!ret) ? DP_INSTALL_SUCCESS
: DP_INSTALL_FAILURE);
(!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = netlink_mpls_multipath(RTM_DELROUTE, lsp);
kernel_lsp_pass_fail(lsp,
(!ret) ? DP_DELETE_SUCCESS
: DP_DELETE_FAILURE);
(!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
: ZEBRA_DPLANE_DELETE_FAILURE);
return DP_REQUEST_SUCCESS;
return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
int mpls_kernel_init(void)

12
zebra/zebra_mpls_null.c
View File

@ -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)

40
zebra/zebra_mpls_openbsd.c
View File

@ -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);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = kernel_lsp_cmd(RTM_ADD, lsp);
kernel_lsp_pass_fail(lsp,
(!ret) ? DP_INSTALL_SUCCESS
: DP_INSTALL_FAILURE);
(!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = kernel_lsp_cmd(RTM_CHANGE, lsp);
kernel_lsp_pass_fail(lsp,
(!ret) ? DP_INSTALL_SUCCESS
: DP_INSTALL_FAILURE);
return DP_REQUEST_SUCCESS;
(!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
: ZEBRA_DPLANE_INSTALL_FAILURE);
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);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
return DP_REQUEST_FAILURE;
kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = kernel_lsp_cmd(RTM_DELETE, lsp);
kernel_lsp_pass_fail(lsp,
(!ret) ? DP_DELETE_SUCCESS
: DP_DELETE_FAILURE);
(!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
: ZEBRA_DPLANE_DELETE_FAILURE);
return DP_REQUEST_SUCCESS;
return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
static int kmpw_install(struct zebra_pw *pw)

3
zebra/zebra_netns_id.c
View File

@ -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) */

60
zebra/zebra_pbr.c
View File

@ -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
: DP_INSTALL_FAILURE);
ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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
: DP_INSTALL_FAILURE);
ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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
: DP_INSTALL_FAILURE);
ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
: 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;
}
}

12
zebra/zebra_pbr.h
View File

@ -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.

24
zebra/zebra_rib.c
View File

@ -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;