Add first sketchy 'dplane' files.
Signed-off-by: Mark Stapp <mjs@voltanet.io>
Signed-off-by: Donald Sharp <sharpd@cumulusnetworks.com>
#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
* 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
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 *);
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
* 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);
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;
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,
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) {
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,
* 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;
}
/*
#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/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 \
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 \
--- /dev/null
+/*
+ * 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"
--- /dev/null
+/*
+ * 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.
+ */
+
+/*
+ * 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 */
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;
}
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;
}
}
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;
}
/* 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;
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;
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;
}
}
/*
* 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;
}
/*
* 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)
#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)
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)
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,
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,
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,
* 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;
}
}
* 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;
}
}
*/
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;
}
}
* 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;
}
}
* 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.
*/
extern void kernel_read_pbr_rules(struct zebra_ns *zns);
-enum dp_results;
/*
* 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.
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];
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))
}
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
"%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
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?
zsend_route_notify_owner(re, p, ZAPI_ROUTE_REMOVE_FAIL);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
*/
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;
}
*/
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;