From 4bbbd1f6b3465b10e868fbc6fe27a82aea448b4b Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Tue, 9 Aug 2022 09:22:43 -0400 Subject: [PATCH 1/5] zebra: Explicitly call out the correct queue name There were more than a few places where the NHG meta queue was not being explicitly called out. Let's be consistent and use the same nomenclature as much as possible when talking about metaQ's. Signed-off-by: Donald Sharp --- zebra/zebra_rib.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c index d0babbb9e4..76c7a05119 100644 --- a/zebra/zebra_rib.c +++ b/zebra/zebra_rib.c @@ -119,7 +119,8 @@ static const struct { /* no entry/default: 150 */ }; -/* EVPN/VXLAN subqueue is number 1 */ +/* Meta Q's specific names */ +#define META_QUEUE_NHG 0 #define META_QUEUE_EVPN 1 /* Wrapper struct for nhg workqueue items; a 'ctx' is an incoming update @@ -167,9 +168,9 @@ struct wq_evpn_wrapper { static const char *subqueue2str(uint8_t index) { switch (index) { - case 0: + case META_QUEUE_NHG: return "NHG Objects"; - case 1: + case META_QUEUE_EVPN: return "EVPN/VxLan Objects"; case 2: return "Connected Routes"; @@ -2407,7 +2408,7 @@ static void process_subq_nhg(struct listnode *lnode) struct nhg_ctx *ctx; struct nhg_hash_entry *nhe, *newnhe; struct wq_nhg_wrapper *w; - uint8_t qindex = route_info[ZEBRA_ROUTE_NHG].meta_q_map; + uint8_t qindex = META_QUEUE_NHG; w = listgetdata(lnode); @@ -2505,7 +2506,7 @@ static unsigned int process_subq(struct list *subq, uint8_t qindex) if (qindex == META_QUEUE_EVPN) process_subq_evpn(lnode); - else if (qindex == route_info[ZEBRA_ROUTE_NHG].meta_q_map) + else if (qindex == META_QUEUE_NHG) process_subq_nhg(lnode); else process_subq_route(lnode, qindex); @@ -2613,7 +2614,7 @@ static int rib_meta_queue_add(struct meta_queue *mq, void *data) static int rib_meta_queue_nhg_ctx_add(struct meta_queue *mq, void *data) { struct nhg_ctx *ctx = NULL; - uint8_t qindex = route_info[ZEBRA_ROUTE_NHG].meta_q_map; + uint8_t qindex = META_QUEUE_NHG; struct wq_nhg_wrapper *w; ctx = (struct nhg_ctx *)data; @@ -2639,7 +2640,7 @@ static int rib_meta_queue_nhg_ctx_add(struct meta_queue *mq, void *data) static int rib_meta_queue_nhg_add(struct meta_queue *mq, void *data) { struct nhg_hash_entry *nhe = NULL; - uint8_t qindex = route_info[ZEBRA_ROUTE_NHG].meta_q_map; + uint8_t qindex = META_QUEUE_NHG; struct wq_nhg_wrapper *w; nhe = (struct nhg_hash_entry *)data; @@ -2996,7 +2997,7 @@ void meta_queue_free(struct meta_queue *mq) for (i = 0; i < MQ_SIZE; i++) { /* Some subqueues may need cleanup - nhgs for example */ - if (i == route_info[ZEBRA_ROUTE_NHG].meta_q_map) + if (i == META_QUEUE_NHG) nhg_meta_queue_free(mq->subq[i]); else if (i == META_QUEUE_EVPN) evpn_meta_queue_free(mq->subq[i]); @@ -3027,8 +3028,7 @@ void rib_meta_queue_free_vrf(struct meta_queue *mq, struct zebra_vrf *zvrf) XFREE(MTYPE_WQ_WRAPPER, w); del = true; } - } else if (i == - route_info[ZEBRA_ROUTE_NHG].meta_q_map) { + } else if (i == META_QUEUE_NHG) { struct wq_nhg_wrapper *w = data; if (w->type == WQ_NHG_WRAPPER_TYPE_CTX && From 014e732d3e3851778653d8509f8e838c2a8891e3 Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Tue, 9 Aug 2022 09:47:44 -0400 Subject: [PATCH 2/5] zebra: Let's use enum for META Queue indexes Convert the meta queue values to an enum and use them. Signed-off-by: Donald Sharp --- zebra/zebra_rib.c | 156 ++++++++++++++++++++++++++++++---------------- 1 file changed, 101 insertions(+), 55 deletions(-) diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c index 76c7a05119..df3571ee47 100644 --- a/zebra/zebra_rib.c +++ b/zebra/zebra_rib.c @@ -77,52 +77,65 @@ static struct dplane_ctx_q rib_dplane_q; DEFINE_HOOK(rib_update, (struct route_node * rn, const char *reason), (rn, reason)); +/* Meta Q's specific names */ +enum meta_queue_indexes { + META_QUEUE_NHG, + META_QUEUE_EVPN, + META_QUEUE_CONNECTED, + META_QUEUE_KERNEL, + META_QUEUE_STATIC, + META_QUEUE_NOTBGP, + META_QUEUE_BGP, + META_QUEUE_OTHER, +}; + /* Each route type's string and default distance value. */ static const struct { int key; uint8_t distance; - uint8_t meta_q_map; + enum meta_queue_indexes meta_q_map; } route_info[ZEBRA_ROUTE_MAX] = { - [ZEBRA_ROUTE_NHG] = {ZEBRA_ROUTE_NHG, 255 /* Unneeded for nhg's */, 0}, - [ZEBRA_ROUTE_SYSTEM] = {ZEBRA_ROUTE_SYSTEM, 0, 7}, - [ZEBRA_ROUTE_KERNEL] = {ZEBRA_ROUTE_KERNEL, 0, 3}, - [ZEBRA_ROUTE_CONNECT] = {ZEBRA_ROUTE_CONNECT, 0, 2}, - [ZEBRA_ROUTE_STATIC] = {ZEBRA_ROUTE_STATIC, 1, 4}, - [ZEBRA_ROUTE_RIP] = {ZEBRA_ROUTE_RIP, 120, 5}, - [ZEBRA_ROUTE_RIPNG] = {ZEBRA_ROUTE_RIPNG, 120, 5}, - [ZEBRA_ROUTE_OSPF] = {ZEBRA_ROUTE_OSPF, 110, 5}, - [ZEBRA_ROUTE_OSPF6] = {ZEBRA_ROUTE_OSPF6, 110, 5}, - [ZEBRA_ROUTE_ISIS] = {ZEBRA_ROUTE_ISIS, 115, 5}, - [ZEBRA_ROUTE_BGP] = {ZEBRA_ROUTE_BGP, 20 /* IBGP is 200. */, 6}, - [ZEBRA_ROUTE_PIM] = {ZEBRA_ROUTE_PIM, 255, 7}, - [ZEBRA_ROUTE_EIGRP] = {ZEBRA_ROUTE_EIGRP, 90, 5}, - [ZEBRA_ROUTE_NHRP] = {ZEBRA_ROUTE_NHRP, 10, 5}, - [ZEBRA_ROUTE_HSLS] = {ZEBRA_ROUTE_HSLS, 255, 7}, - [ZEBRA_ROUTE_OLSR] = {ZEBRA_ROUTE_OLSR, 255, 7}, - [ZEBRA_ROUTE_TABLE] = {ZEBRA_ROUTE_TABLE, 150, 4}, - [ZEBRA_ROUTE_LDP] = {ZEBRA_ROUTE_LDP, 150, 7}, - [ZEBRA_ROUTE_VNC] = {ZEBRA_ROUTE_VNC, 20, 6}, - [ZEBRA_ROUTE_VNC_DIRECT] = {ZEBRA_ROUTE_VNC_DIRECT, 20, 6}, - [ZEBRA_ROUTE_VNC_DIRECT_RH] = {ZEBRA_ROUTE_VNC_DIRECT_RH, 20, 6}, - [ZEBRA_ROUTE_BGP_DIRECT] = {ZEBRA_ROUTE_BGP_DIRECT, 20, 6}, - [ZEBRA_ROUTE_BGP_DIRECT_EXT] = {ZEBRA_ROUTE_BGP_DIRECT_EXT, 20, 6}, - [ZEBRA_ROUTE_BABEL] = {ZEBRA_ROUTE_BABEL, 100, 5}, - [ZEBRA_ROUTE_SHARP] = {ZEBRA_ROUTE_SHARP, 150, 7}, - [ZEBRA_ROUTE_PBR] = {ZEBRA_ROUTE_PBR, 200, 7}, - [ZEBRA_ROUTE_BFD] = {ZEBRA_ROUTE_BFD, 255, 7}, - [ZEBRA_ROUTE_OPENFABRIC] = {ZEBRA_ROUTE_OPENFABRIC, 115, 5}, - [ZEBRA_ROUTE_VRRP] = {ZEBRA_ROUTE_VRRP, 255, 7}, - [ZEBRA_ROUTE_SRTE] = {ZEBRA_ROUTE_SRTE, 255, 7}, - [ZEBRA_ROUTE_ALL] = {ZEBRA_ROUTE_ALL, 255, 7}, + [ZEBRA_ROUTE_NHG] = {ZEBRA_ROUTE_NHG, 255 /* Unneeded for nhg's */, + META_QUEUE_NHG}, + [ZEBRA_ROUTE_SYSTEM] = {ZEBRA_ROUTE_SYSTEM, 0, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_KERNEL] = {ZEBRA_ROUTE_KERNEL, 0, META_QUEUE_KERNEL}, + [ZEBRA_ROUTE_CONNECT] = {ZEBRA_ROUTE_CONNECT, 0, META_QUEUE_CONNECTED}, + [ZEBRA_ROUTE_STATIC] = {ZEBRA_ROUTE_STATIC, 1, META_QUEUE_STATIC}, + [ZEBRA_ROUTE_RIP] = {ZEBRA_ROUTE_RIP, 120, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_RIPNG] = {ZEBRA_ROUTE_RIPNG, 120, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_OSPF] = {ZEBRA_ROUTE_OSPF, 110, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_OSPF6] = {ZEBRA_ROUTE_OSPF6, 110, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_ISIS] = {ZEBRA_ROUTE_ISIS, 115, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_BGP] = {ZEBRA_ROUTE_BGP, 20 /* IBGP is 200. */, + META_QUEUE_BGP}, + [ZEBRA_ROUTE_PIM] = {ZEBRA_ROUTE_PIM, 255, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_EIGRP] = {ZEBRA_ROUTE_EIGRP, 90, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_NHRP] = {ZEBRA_ROUTE_NHRP, 10, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_HSLS] = {ZEBRA_ROUTE_HSLS, 255, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_OLSR] = {ZEBRA_ROUTE_OLSR, 255, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_TABLE] = {ZEBRA_ROUTE_TABLE, 150, META_QUEUE_STATIC}, + [ZEBRA_ROUTE_LDP] = {ZEBRA_ROUTE_LDP, 150, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_VNC] = {ZEBRA_ROUTE_VNC, 20, META_QUEUE_BGP}, + [ZEBRA_ROUTE_VNC_DIRECT] = {ZEBRA_ROUTE_VNC_DIRECT, 20, META_QUEUE_BGP}, + [ZEBRA_ROUTE_VNC_DIRECT_RH] = {ZEBRA_ROUTE_VNC_DIRECT_RH, 20, + META_QUEUE_BGP}, + [ZEBRA_ROUTE_BGP_DIRECT] = {ZEBRA_ROUTE_BGP_DIRECT, 20, META_QUEUE_BGP}, + [ZEBRA_ROUTE_BGP_DIRECT_EXT] = {ZEBRA_ROUTE_BGP_DIRECT_EXT, 20, + META_QUEUE_BGP}, + [ZEBRA_ROUTE_BABEL] = {ZEBRA_ROUTE_BABEL, 100, META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_SHARP] = {ZEBRA_ROUTE_SHARP, 150, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_PBR] = {ZEBRA_ROUTE_PBR, 200, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_BFD] = {ZEBRA_ROUTE_BFD, 255, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_OPENFABRIC] = {ZEBRA_ROUTE_OPENFABRIC, 115, + META_QUEUE_NOTBGP}, + [ZEBRA_ROUTE_VRRP] = {ZEBRA_ROUTE_VRRP, 255, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_SRTE] = {ZEBRA_ROUTE_SRTE, 255, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_ALL] = {ZEBRA_ROUTE_ALL, 255, META_QUEUE_OTHER}, /* Any new route type added to zebra, should be mirrored here */ /* no entry/default: 150 */ }; -/* Meta Q's specific names */ -#define META_QUEUE_NHG 0 -#define META_QUEUE_EVPN 1 - /* Wrapper struct for nhg workqueue items; a 'ctx' is an incoming update * from the OS, and an 'nhe' is a nhe update. */ @@ -165,24 +178,24 @@ struct wq_evpn_wrapper { #pragma FRR printfrr_ext "%pZN" (struct route_node *) #endif -static const char *subqueue2str(uint8_t index) +static const char *subqueue2str(enum meta_queue_indexes index) { switch (index) { case META_QUEUE_NHG: return "NHG Objects"; case META_QUEUE_EVPN: return "EVPN/VxLan Objects"; - case 2: + case META_QUEUE_CONNECTED: return "Connected Routes"; - case 3: + case META_QUEUE_KERNEL: return "Kernel Routes"; - case 4: + case META_QUEUE_STATIC: return "Static Routes"; - case 5: + case META_QUEUE_NOTBGP: return "RIP/OSPF/ISIS/EIGRP/NHRP Routes"; - case 6: + case META_QUEUE_BGP: return "BGP Routes"; - case 7: + case META_QUEUE_OTHER: return "Other Routes"; } @@ -2497,19 +2510,30 @@ static void process_subq_route(struct listnode *lnode, uint8_t qindex) * Examine the specified subqueue; process one entry and return 1 if * there is a node, return 0 otherwise. */ -static unsigned int process_subq(struct list *subq, uint8_t qindex) +static unsigned int process_subq(struct list *subq, + enum meta_queue_indexes qindex) { struct listnode *lnode = listhead(subq); if (!lnode) return 0; - if (qindex == META_QUEUE_EVPN) + switch (qindex) { + case META_QUEUE_EVPN: process_subq_evpn(lnode); - else if (qindex == META_QUEUE_NHG) + break; + case META_QUEUE_NHG: process_subq_nhg(lnode); - else + break; + case META_QUEUE_CONNECTED: + case META_QUEUE_KERNEL: + case META_QUEUE_STATIC: + case META_QUEUE_NOTBGP: + case META_QUEUE_BGP: + case META_QUEUE_OTHER: process_subq_route(lnode, qindex); + break; + } list_delete_node(subq, lnode); @@ -2993,15 +3017,25 @@ static struct meta_queue *meta_queue_new(void) void meta_queue_free(struct meta_queue *mq) { - unsigned i; + enum meta_queue_indexes i; for (i = 0; i < MQ_SIZE; i++) { /* Some subqueues may need cleanup - nhgs for example */ - if (i == META_QUEUE_NHG) + switch (i) { + case META_QUEUE_NHG: nhg_meta_queue_free(mq->subq[i]); - else if (i == META_QUEUE_EVPN) + break; + case META_QUEUE_EVPN: evpn_meta_queue_free(mq->subq[i]); - + break; + case META_QUEUE_CONNECTED: + case META_QUEUE_KERNEL: + case META_QUEUE_STATIC: + case META_QUEUE_NOTBGP: + case META_QUEUE_BGP: + case META_QUEUE_OTHER: + break; + } list_delete(&mq->subq[i]); } @@ -3011,7 +3045,7 @@ void meta_queue_free(struct meta_queue *mq) void rib_meta_queue_free_vrf(struct meta_queue *mq, struct zebra_vrf *zvrf) { vrf_id_t vrf_id = zvrf->vrf->vrf_id; - unsigned int i; + enum meta_queue_indexes i; for (i = 0; i < MQ_SIZE; i++) { struct listnode *lnode, *nnode; @@ -3021,14 +3055,17 @@ void rib_meta_queue_free_vrf(struct meta_queue *mq, struct zebra_vrf *zvrf) for (ALL_LIST_ELEMENTS(mq->subq[i], lnode, nnode, data)) { del = false; - if (i == META_QUEUE_EVPN) { + switch (i) { + case META_QUEUE_EVPN: { struct wq_evpn_wrapper *w = data; if (w->vrf_id == vrf_id) { XFREE(MTYPE_WQ_WRAPPER, w); del = true; } - } else if (i == META_QUEUE_NHG) { + break; + } + case META_QUEUE_NHG: { struct wq_nhg_wrapper *w = data; if (w->type == WQ_NHG_WRAPPER_TYPE_CTX && @@ -3042,7 +3079,14 @@ void rib_meta_queue_free_vrf(struct meta_queue *mq, struct zebra_vrf *zvrf) XFREE(MTYPE_WQ_WRAPPER, w); del = true; } - } else { + break; + } + case META_QUEUE_CONNECTED: + case META_QUEUE_KERNEL: + case META_QUEUE_STATIC: + case META_QUEUE_NOTBGP: + case META_QUEUE_BGP: + case META_QUEUE_OTHER: { struct route_node *rnode = data; rib_dest_t *dest = rib_dest_from_rnode(rnode); @@ -3050,6 +3094,8 @@ void rib_meta_queue_free_vrf(struct meta_queue *mq, struct zebra_vrf *zvrf) route_unlock_node(rnode); del = true; } + break; + } } if (del) { From 57a552457855deb005ab5b5f6b2a2ddfe7e3d7ec Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Tue, 9 Aug 2022 10:23:35 -0400 Subject: [PATCH 3/5] zebra: System routes should be processed the same time as kernel For whatever reason. ZEBRA_ROUTE_SYSTEM routes were being processed last. Since a system route is just another kernel route type. Let's just switch it to be processed the same time as kernel routes. Signed-off-by: Donald Sharp --- zebra/zebra_rib.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c index df3571ee47..2651eab164 100644 --- a/zebra/zebra_rib.c +++ b/zebra/zebra_rib.c @@ -97,7 +97,7 @@ static const struct { } route_info[ZEBRA_ROUTE_MAX] = { [ZEBRA_ROUTE_NHG] = {ZEBRA_ROUTE_NHG, 255 /* Unneeded for nhg's */, META_QUEUE_NHG}, - [ZEBRA_ROUTE_SYSTEM] = {ZEBRA_ROUTE_SYSTEM, 0, META_QUEUE_OTHER}, + [ZEBRA_ROUTE_SYSTEM] = {ZEBRA_ROUTE_SYSTEM, 0, META_QUEUE_KERNEL}, [ZEBRA_ROUTE_KERNEL] = {ZEBRA_ROUTE_KERNEL, 0, META_QUEUE_KERNEL}, [ZEBRA_ROUTE_CONNECT] = {ZEBRA_ROUTE_CONNECT, 0, META_QUEUE_CONNECTED}, [ZEBRA_ROUTE_STATIC] = {ZEBRA_ROUTE_STATIC, 1, META_QUEUE_STATIC}, From a310ebc114af2f211e493ec29817b3debab2561a Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Tue, 9 Aug 2022 13:09:16 -0400 Subject: [PATCH 4/5] zebra: Combine meta_queue_free and meta_queue_vrf_free functions These functions essentially do the same thing. Combine them for the goodness of mankind. Signed-off-by: Donald Sharp --- zebra/rib.h | 4 +- zebra/zebra_rib.c | 192 +++++++++++++++++++------------------------ zebra/zebra_router.c | 2 +- zebra/zebra_vrf.c | 4 +- 4 files changed, 89 insertions(+), 113 deletions(-) diff --git a/zebra/rib.h b/zebra/rib.h index 60092c9632..a40843e27f 100644 --- a/zebra/rib.h +++ b/zebra/rib.h @@ -454,9 +454,7 @@ int zebra_rib_queue_evpn_rem_vtep_add(vrf_id_t vrf_id, vni_t vni, int zebra_rib_queue_evpn_rem_vtep_del(vrf_id_t vrf_id, vni_t vni, struct in_addr vtep_ip); -extern void meta_queue_free(struct meta_queue *mq); -extern void rib_meta_queue_free_vrf(struct meta_queue *mq, - struct zebra_vrf *zvrf); +extern void meta_queue_free(struct meta_queue *mq, struct zebra_vrf *zvrf); extern int zebra_rib_labeled_unicast(struct route_entry *re); extern struct route_table *rib_table_ipv6; diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c index 2651eab164..79eb99ddf9 100644 --- a/zebra/zebra_rib.c +++ b/zebra/zebra_rib.c @@ -2958,44 +2958,6 @@ int zebra_rib_queue_evpn_rem_vtep_del(vrf_id_t vrf_id, vni_t vni, return mq_add_handler(w, rib_meta_queue_evpn_add); } -/* Clean up the EVPN meta-queue list */ -static void evpn_meta_queue_free(struct list *l) -{ - struct listnode *node; - struct wq_evpn_wrapper *w; - - /* Free the node wrapper object, and the struct it wraps */ - while ((node = listhead(l)) != NULL) { - w = node->data; - node->data = NULL; - - XFREE(MTYPE_WQ_WRAPPER, w); - - list_delete_node(l, node); - } -} - -/* Clean up the nhg meta-queue list */ -static void nhg_meta_queue_free(struct list *l) -{ - struct wq_nhg_wrapper *w; - struct listnode *node; - - /* Free the node wrapper object, and the struct it wraps */ - while ((node = listhead(l)) != NULL) { - w = node->data; - node->data = NULL; - - if (w->type == WQ_NHG_WRAPPER_TYPE_CTX) - nhg_ctx_free(&w->u.ctx); - else if (w->type == WQ_NHG_WRAPPER_TYPE_NHG) - zebra_nhg_free(w->u.nhe); - - XFREE(MTYPE_WQ_WRAPPER, w); - - list_delete_node(l, node); - } -} /* Create new meta queue. A destructor function doesn't seem to be necessary here. @@ -3015,7 +2977,84 @@ static struct meta_queue *meta_queue_new(void) return new; } -void meta_queue_free(struct meta_queue *mq) +/* Clean up the EVPN meta-queue list */ +static void evpn_meta_queue_free(struct meta_queue *mq, struct list *l, + struct zebra_vrf *zvrf) +{ + struct listnode *node, *nnode; + struct wq_evpn_wrapper *w; + + /* Free the node wrapper object, and the struct it wraps */ + for (ALL_LIST_ELEMENTS(l, node, nnode, w)) { + if (zvrf) { + vrf_id_t vrf_id = zvrf->vrf->vrf_id; + + if (w->vrf_id != vrf_id) + continue; + } + + node->data = NULL; + + XFREE(MTYPE_WQ_WRAPPER, w); + + list_delete_node(l, node); + mq->size--; + } +} + +/* Clean up the nhg meta-queue list */ +static void nhg_meta_queue_free(struct meta_queue *mq, struct list *l, + struct zebra_vrf *zvrf) +{ + struct wq_nhg_wrapper *w; + struct listnode *node, *nnode; + + /* Free the node wrapper object, and the struct it wraps */ + for (ALL_LIST_ELEMENTS(l, node, nnode, w)) { + if (zvrf) { + vrf_id_t vrf_id = zvrf->vrf->vrf_id; + + if (w->type == WQ_NHG_WRAPPER_TYPE_CTX && + w->u.ctx->vrf_id != vrf_id) + continue; + else if (w->type == WQ_NHG_WRAPPER_TYPE_NHG && + w->u.nhe->vrf_id != vrf_id) + continue; + } + if (w->type == WQ_NHG_WRAPPER_TYPE_CTX) + nhg_ctx_free(&w->u.ctx); + else if (w->type == WQ_NHG_WRAPPER_TYPE_NHG) + zebra_nhg_free(w->u.nhe); + + node->data = NULL; + XFREE(MTYPE_WQ_WRAPPER, w); + + list_delete_node(l, node); + mq->size--; + } +} + +static void rib_meta_queue_free(struct meta_queue *mq, struct list *l, + struct zebra_vrf *zvrf) +{ + struct route_node *rnode; + struct listnode *node, *nnode; + + for (ALL_LIST_ELEMENTS(l, node, nnode, rnode)) { + rib_dest_t *dest = rib_dest_from_rnode(rnode); + + if (dest && rib_dest_vrf(dest) != zvrf) + continue; + + route_unlock_node(rnode); + node->data = NULL; + list_delete_node(l, node); + mq->size--; + } +} + + +void meta_queue_free(struct meta_queue *mq, struct zebra_vrf *zvrf) { enum meta_queue_indexes i; @@ -3023,10 +3062,10 @@ void meta_queue_free(struct meta_queue *mq) /* Some subqueues may need cleanup - nhgs for example */ switch (i) { case META_QUEUE_NHG: - nhg_meta_queue_free(mq->subq[i]); + nhg_meta_queue_free(mq, mq->subq[i], zvrf); break; case META_QUEUE_EVPN: - evpn_meta_queue_free(mq->subq[i]); + evpn_meta_queue_free(mq, mq->subq[i], zvrf); break; case META_QUEUE_CONNECTED: case META_QUEUE_KERNEL: @@ -3034,76 +3073,15 @@ void meta_queue_free(struct meta_queue *mq) case META_QUEUE_NOTBGP: case META_QUEUE_BGP: case META_QUEUE_OTHER: + rib_meta_queue_free(mq, mq->subq[i], zvrf); break; } - list_delete(&mq->subq[i]); + if (!zvrf) + list_delete(&mq->subq[i]); } - XFREE(MTYPE_WORK_QUEUE, mq); -} - -void rib_meta_queue_free_vrf(struct meta_queue *mq, struct zebra_vrf *zvrf) -{ - vrf_id_t vrf_id = zvrf->vrf->vrf_id; - enum meta_queue_indexes i; - - for (i = 0; i < MQ_SIZE; i++) { - struct listnode *lnode, *nnode; - void *data; - bool del; - - for (ALL_LIST_ELEMENTS(mq->subq[i], lnode, nnode, data)) { - del = false; - - switch (i) { - case META_QUEUE_EVPN: { - struct wq_evpn_wrapper *w = data; - - if (w->vrf_id == vrf_id) { - XFREE(MTYPE_WQ_WRAPPER, w); - del = true; - } - break; - } - case META_QUEUE_NHG: { - struct wq_nhg_wrapper *w = data; - - if (w->type == WQ_NHG_WRAPPER_TYPE_CTX && - w->u.ctx->vrf_id == vrf_id) { - nhg_ctx_free(&w->u.ctx); - XFREE(MTYPE_WQ_WRAPPER, w); - del = true; - } else if (w->type == WQ_NHG_WRAPPER_TYPE_NHG && - w->u.nhe->vrf_id == vrf_id) { - zebra_nhg_free(w->u.nhe); - XFREE(MTYPE_WQ_WRAPPER, w); - del = true; - } - break; - } - case META_QUEUE_CONNECTED: - case META_QUEUE_KERNEL: - case META_QUEUE_STATIC: - case META_QUEUE_NOTBGP: - case META_QUEUE_BGP: - case META_QUEUE_OTHER: { - struct route_node *rnode = data; - rib_dest_t *dest = rib_dest_from_rnode(rnode); - - if (dest && rib_dest_vrf(dest) == zvrf) { - route_unlock_node(rnode); - del = true; - } - break; - } - } - - if (del) { - list_delete_node(mq->subq[i], lnode); - mq->size--; - } - } - } + if (!zvrf) + XFREE(MTYPE_WORK_QUEUE, mq); } /* initialise zebra rib work queue */ diff --git a/zebra/zebra_router.c b/zebra/zebra_router.c index 24e71b4a8b..c66849863e 100644 --- a/zebra/zebra_router.c +++ b/zebra/zebra_router.c @@ -239,7 +239,7 @@ void zebra_router_terminate(void) zebra_router_free_table(zrt); work_queue_free_and_null(&zrouter.ribq); - meta_queue_free(zrouter.mq); + meta_queue_free(zrouter.mq, NULL); zebra_vxlan_disable(); zebra_mlag_terminate(); diff --git a/zebra/zebra_vrf.c b/zebra/zebra_vrf.c index 553864d089..6624f0beb9 100644 --- a/zebra/zebra_vrf.c +++ b/zebra/zebra_vrf.c @@ -218,7 +218,7 @@ static int zebra_vrf_disable(struct vrf *vrf) if_nbr_ipv6ll_to_ipv4ll_neigh_del_all(ifp); /* clean-up work queues */ - rib_meta_queue_free_vrf(zrouter.mq, zvrf); + meta_queue_free(zrouter.mq, zvrf); /* Cleanup (free) routing tables and NHT tables. */ for (afi = AFI_IP; afi <= AFI_IP6; afi++) { @@ -253,7 +253,7 @@ static int zebra_vrf_delete(struct vrf *vrf) table_manager_disable(zvrf); /* clean-up work queues */ - rib_meta_queue_free_vrf(zrouter.mq, zvrf); + meta_queue_free(zrouter.mq, zvrf); /* Free Vxlan and MPLS. */ zebra_vxlan_close_tables(zvrf); From 1548fbbc449583c6db859982d86fa2d30e6f66a4 Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Tue, 9 Aug 2022 14:12:15 -0400 Subject: [PATCH 5/5] zebra: Remove unused return codes in zebra_mpls.c There are some return codes for functions that are not really used. Clean them up. Signed-off-by: Donald Sharp --- zebra/zapi_msg.c | 16 ++-------------- zebra/zebra_mpls.c | 20 ++++++++------------ zebra/zebra_mpls.h | 10 +++++----- 3 files changed, 15 insertions(+), 31 deletions(-) diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c index 9895943016..a578395ef8 100644 --- a/zebra/zapi_msg.c +++ b/zebra/zapi_msg.c @@ -2492,7 +2492,6 @@ static void zread_mpls_labels_add(ZAPI_HANDLER_ARGS) { struct stream *s; struct zapi_labels zl; - int ret; /* Get input stream. */ s = msg; @@ -2510,12 +2509,7 @@ static void zread_mpls_labels_add(ZAPI_HANDLER_ARGS) if (zapi_labels_validate(&zl) < 0) return; - ret = mpls_zapi_labels_process(true, zvrf, &zl); - if (ret < 0) { - if (IS_ZEBRA_DEBUG_RECV) - zlog_debug("%s: Error processing zapi request", - __func__); - } + mpls_zapi_labels_process(true, zvrf, &zl); } /* @@ -2532,7 +2526,6 @@ static void zread_mpls_labels_delete(ZAPI_HANDLER_ARGS) { struct stream *s; struct zapi_labels zl; - int ret; /* Get input stream. */ s = msg; @@ -2547,12 +2540,7 @@ static void zread_mpls_labels_delete(ZAPI_HANDLER_ARGS) return; if (zl.nexthop_num > 0) { - ret = mpls_zapi_labels_process(false /*delete*/, zvrf, &zl); - if (ret < 0) { - if (IS_ZEBRA_DEBUG_RECV) - zlog_debug("%s: Error processing zapi request", - __func__); - } + mpls_zapi_labels_process(false /*delete*/, zvrf, &zl); } else { mpls_lsp_uninstall_all_vrf(zvrf, zl.type, zl.local_label); diff --git a/zebra/zebra_mpls.c b/zebra/zebra_mpls.c index ade381e27f..3010a516b9 100644 --- a/zebra/zebra_mpls.c +++ b/zebra/zebra_mpls.c @@ -2747,9 +2747,9 @@ static bool ftn_update_nexthop(bool add_p, struct nexthop *nexthop, return true; } -int mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, - struct prefix *prefix, uint8_t route_type, - unsigned short route_instance) +void mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, + struct prefix *prefix, uint8_t route_type, + unsigned short route_instance) { struct route_table *table; struct route_node *rn; @@ -2761,7 +2761,7 @@ int mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, /* Lookup table. */ table = zebra_vrf_table(afi, SAFI_UNICAST, zvrf_id(zvrf)); if (!table) - return -1; + return; /* Lookup existing route */ rn = route_node_get(table, prefix); @@ -2772,7 +2772,7 @@ int mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, break; } if (re == NULL) - return -1; + return; /* * Nexthops are now shared by multiple routes, so we have to make @@ -2801,8 +2801,6 @@ int mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, zebra_nhg_free(new_nhe); rib_queue_add(rn); - - return 0; } /* @@ -2884,8 +2882,8 @@ static bool ftn_update_znh(bool add_p, enum lsp_types_t type, * There are several changes that need to be made, in several zebra * data structures, so we want to do all the work required at once. */ -int mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf, - const struct zapi_labels *zl) +void mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf, + const struct zapi_labels *zl) { int i, counter, ret = 0; char buf[NEXTHOP_STRLEN]; @@ -2906,7 +2904,7 @@ int mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf, /* Lookup table. */ lsp_table = zvrf->lsp_table; if (!lsp_table) - return -1; + return; /* Find or create LSP object */ tmp_ile.in_label = zl->local_label; @@ -3070,8 +3068,6 @@ znh_done: if (new_nhe) zebra_nhg_free(new_nhe); - - return ret; } /* diff --git a/zebra/zebra_mpls.h b/zebra/zebra_mpls.h index a7a955a80b..a114f01339 100644 --- a/zebra/zebra_mpls.h +++ b/zebra/zebra_mpls.h @@ -261,15 +261,15 @@ void zebra_mpls_print_fec(struct vty *vty, struct zebra_vrf *zvrf, * Handle zapi request to install/uninstall LSP and * (optionally) FEC-To-NHLFE (FTN) bindings. */ -int mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf, - const struct zapi_labels *zl); +void mpls_zapi_labels_process(bool add_p, struct zebra_vrf *zvrf, + const struct zapi_labels *zl); /* * Uninstall all NHLFEs bound to a single FEC. */ -int mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, - struct prefix *prefix, uint8_t route_type, - unsigned short route_instance); +void mpls_ftn_uninstall(struct zebra_vrf *zvrf, enum lsp_types_t type, + struct prefix *prefix, uint8_t route_type, + unsigned short route_instance); /* * Install/update a NHLFE for an LSP in the forwarding table. This may be