#include "zebra/rib.h"
#include "zebra/rt.h"
+#include "zebra/interface.h"
#include "zebra/zserv.h"
#include "zebra/redistribute.h"
#include "zebra/debug.h"
#include "zebra/zebra_memory.h"
#include "zebra/zebra_vrf.h"
#include "zebra/zebra_mpls.h"
+#include "zebra/zebra_errors.h"
DEFINE_MTYPE_STATIC(ZEBRA, LSP, "MPLS LSP object")
DEFINE_MTYPE_STATIC(ZEBRA, FEC, "MPLS FEC object")
static int fec_del(zebra_fec_t *fec);
static unsigned int label_hash(void *p);
-static int label_cmp(const void *p1, const void *p2);
+static bool label_cmp(const void *p1, const void *p2);
static int nhlfe_nexthop_active_ipv4(zebra_nhlfe_t *nhlfe,
struct nexthop *nexthop);
static int nhlfe_nexthop_active_ipv6(zebra_nhlfe_t *nhlfe,
stream_put_prefix(s, &rn->p);
stream_putl(s, fec->label);
stream_putw_at(s, 0, stream_get_endp(s));
- return zebra_server_send_message(client, s);
+ return zserv_send_message(client, s);
}
/*
if (!fec) {
fec = XCALLOC(MTYPE_FEC, sizeof(zebra_fec_t));
- if (!fec)
- return NULL;
rn->info = fec;
fec->rn = rn;
*/
static int fec_del(zebra_fec_t *fec)
{
- list_delete_and_null(&fec->client_list);
+ list_delete(&fec->client_list);
fec->rn->info = NULL;
route_unlock_node(fec->rn);
XFREE(MTYPE_FEC, fec);
/*
* Compare 2 LSP hash entries based on in-label.
*/
-static int label_cmp(const void *p1, const void *p2)
+static bool label_cmp(const void *p1, const void *p2)
{
const zebra_ile_t *ile1 = p1;
const zebra_ile_t *ile2 = p2;
{
struct nexthop *nexthop;
struct interface *ifp;
+ struct zebra_ns *zns;
nexthop = nhlfe->nexthop;
if (!nexthop) // unexpected
* which will not be in the default
* VRF. So let's look in all of them
*/
- ifp = if_lookup_by_index(nexthop->ifindex, VRF_UNKNOWN);
+ zns = zebra_ns_lookup(NS_DEFAULT);
+ ifp = if_lookup_by_index_per_ns(zns, nexthop->ifindex);
if (ifp && if_is_operative(ifp))
SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE);
else
lsp = (zebra_lsp_t *)backet->data;
if (CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED))
- kernel_del_lsp(lsp);
+ (void)kernel_del_lsp(lsp);
}
/*
if (newbest) {
UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
- kernel_add_lsp(lsp);
-
- zvrf->lsp_installs++;
+ switch (kernel_add_lsp(lsp)) {
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
+ flog_err(
+ EC_ZEBRA_DP_INVALID_RC,
+ "No current DataPlane interfaces can return this, please fix");
+ break;
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
+ break;
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
+ zvrf->lsp_installs++;
+ break;
+ }
}
} else {
/* Installed, may need an update and/or delete. */
if (!newbest) {
- kernel_del_lsp(lsp);
-
- zvrf->lsp_removals++;
+ switch (kernel_del_lsp(lsp)) {
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
+ flog_err(
+ EC_ZEBRA_DP_INVALID_RC,
+ "No current DataPlane interfaces can return this, please fix");
+ break;
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
+ break;
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
+ zvrf->lsp_removals++;
+ break;
+ }
} else if (CHECK_FLAG(lsp->flags, LSP_FLAG_CHANGED)) {
zebra_nhlfe_t *nhlfe;
struct nexthop *nexthop;
}
}
- kernel_upd_lsp(lsp);
-
- zvrf->lsp_installs++;
+ switch (kernel_upd_lsp(lsp)) {
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
+ flog_err(
+ EC_ZEBRA_DP_INVALID_RC,
+ "No current DataPlane interfaces can return this, please fix");
+ break;
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
+ break;
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
+ zvrf->lsp_installs++;
+ break;
+ }
}
}
return 0;
if (zebrad.lsp_process_q == NULL) {
- zlog_err("%s: work_queue does not exist!", __func__);
+ flog_err(EC_ZEBRA_WQ_NONEXISTENT,
+ "%s: work_queue does not exist!", __func__);
return -1;
}
return NULL;
nhlfe = XCALLOC(MTYPE_NHLFE, sizeof(zebra_nhlfe_t));
- if (!nhlfe)
- return NULL;
nhlfe->lsp = lsp;
nhlfe->type = lsp_type;
{
zebra->lsp_process_q = work_queue_new(zebra->master, "LSP processing");
if (!zebra->lsp_process_q) {
- zlog_err("%s: could not initialise work queue!", __func__);
+ flog_err(EC_ZEBRA_WQ_NONEXISTENT,
+ "%s: could not initialise work queue!", __func__);
return -1;
}
/* Public functions */
-void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum southbound_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 SOUTHBOUND_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
clear_nhlfe_installed(lsp);
- zlog_warn("LSP Install Failure: %u", lsp->ile.in_label);
+ flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE,
+ "LSP Install Failure: %u", lsp->ile.in_label);
break;
- case SOUTHBOUND_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 SOUTHBOUND_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
clear_nhlfe_installed(lsp);
break;
- case SOUTHBOUND_DELETE_FAILURE:
- zlog_warn("LSP Deletion Failure: %u", lsp->ile.in_label);
+ 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;
}
}
fec = fec_add(table, p, MPLS_INVALID_LABEL, 0, label_index);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_err(
+ flog_err(
+ EC_ZEBRA_FEC_ADD_FAILED,
"Failed to add FEC %s upon register, client %s",
buf, zebra_route_string(client->proto));
return -1;
fec = fec_find(table, p);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_err("Failed to find FEC %s upon unregister, client %s",
+ flog_err(EC_ZEBRA_FEC_RM_FAILED,
+ "Failed to find FEC %s upon unregister, client %s",
buf, zebra_route_string(client->proto));
return -1;
}
MPLS_INVALID_LABEL_INDEX);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_err("Failed to add FEC %s upon config", buf);
+ flog_err(EC_ZEBRA_FEC_ADD_FAILED,
+ "Failed to add FEC %s upon config", buf);
return -1;
}
fec = fec_find(table, p);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_err("Failed to find FEC %s upon delete", buf);
+ flog_err(EC_ZEBRA_FEC_RM_FAILED,
+ "Failed to find FEC %s upon delete", buf);
return -1;
}
struct hash *lsp_table;
lsp = (zebra_lsp_t *)backet->data;
- if (!lsp || !lsp->nhlfe_list)
+ if (!lsp->nhlfe_list)
return;
lsp_table = ctxt;
* (VTY command handler).
*/
void zebra_mpls_print_lsp(struct vty *vty, struct zebra_vrf *zvrf,
- mpls_label_t label, uint8_t use_json)
+ mpls_label_t label, bool use_json)
{
struct hash *lsp_table;
zebra_lsp_t *lsp;
* Display MPLS label forwarding table (VTY command handler).
*/
void zebra_mpls_print_lsp_table(struct vty *vty, struct zebra_vrf *zvrf,
- uint8_t use_json)
+ bool use_json)
{
char buf[BUFSIZ];
json_object *json = NULL;
switch (nexthop->type) {
case NEXTHOP_TYPE_IFINDEX: {
+ struct zebra_ns *zns;
struct interface *ifp;
- ifp = if_lookup_by_index(
- nexthop->ifindex, VRF_UNKNOWN);
+ zns = zebra_ns_lookup(NS_DEFAULT);
+ ifp = if_lookup_by_index_per_ns(
+ zns,
+ nexthop->ifindex);
vty_out(vty, "%15s", ifp->name);
break;
}
vty_out(vty, "\n");
}
- list_delete_and_null(&lsp_list);
+ list_delete(&lsp_list);
}
/*
}
}
- list_delete_and_null(&slsp_list);
+ list_delete(&slsp_list);
return (zvrf->slsp_table->count ? 1 : 0);
}
mpls_enabled = 0;
if (mpls_kernel_init() < 0) {
- zlog_warn("Disabling MPLS support (no kernel support)");
+ flog_warn(EC_ZEBRA_MPLS_SUPPORT_DISABLED,
+ "Disabling MPLS support (no kernel support)");
return;
}
if (!mpls_processq_init(&zebrad))
mpls_enabled = 1;
- hook_register(zapi_client_close, zebra_mpls_cleanup_fecs_for_client);
+ hook_register(zserv_client_close, zebra_mpls_cleanup_fecs_for_client);
}
projects / mirror_frr.git / blobdiff