From 89272910f738c05ba7986e7d91c14dc0eb1f6ba6 Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Mon, 27 Aug 2018 10:43:37 -0400 Subject: [PATCH 1/5] zebra: Start breakup of zns into zrouter and zns The `struct zebra_ns` data structure is being used for both router information as well as support for the vrf backend( as appropriate ). This is a confusing state. Start the movement of `struct zebra_ns` into 2 things `struct zebra_router` and `struct zebra_ns`. In this new regime `struct zebra_router` is purely for handling data about the router. It has no knowledge of the underlying representation of the Data Plane. `struct zebra_ns` becomes a linux specific bit of code that allows us to handle the vrf backend and is allowed to have knowledge about underlying data plane constructs. When someone implements a *bsd backend the zebra_vrf data structure will need to be abstracted to take advantage of this instead of relying on zebra_ns. Signed-off-by: Donald Sharp --- zebra/main.c | 6 +- zebra/subdir.am | 2 + zebra/zebra_ns.c | 123 -------------------------------- zebra/zebra_ns.h | 25 ------- zebra/zebra_rib.c | 5 +- zebra/zebra_rnh.c | 13 ++-- zebra/zebra_router.c | 162 +++++++++++++++++++++++++++++++++++++++++++ zebra/zebra_router.h | 71 +++++++++++++++++++ zebra/zebra_vrf.c | 31 ++++----- zebra/zebra_vty.c | 5 +- zebra/zebra_vxlan.c | 63 ++++------------- 11 files changed, 278 insertions(+), 228 deletions(-) create mode 100644 zebra/zebra_router.c create mode 100644 zebra/zebra_router.h diff --git a/zebra/main.c b/zebra/main.c index 148bcab7e4..d8952a7b28 100644 --- a/zebra/main.c +++ b/zebra/main.c @@ -39,6 +39,7 @@ #include "routemap.h" #include "frr_pthread.h" +#include "zebra/zebra_router.h" #include "zebra/zebra_errors.h" #include "zebra/rib.h" #include "zebra/zserv.h" @@ -174,6 +175,8 @@ static void sigint(void) work_queue_free_and_null(&zebrad.ribq); meta_queue_free(zebrad.mq); + zebra_router_terminate(); + frr_fini(); exit(0); } @@ -354,6 +357,7 @@ int main(int argc, char **argv) zebrad.master = frr_init(); /* Zebra related initialize. */ + zebra_router_init(); zserv_init(); rib_init(); zebra_if_init(); @@ -418,7 +422,7 @@ int main(int argc, char **argv) /* RNH init */ zebra_rnh_init(); - + /* Error init */ zebra_error_init(); diff --git a/zebra/subdir.am b/zebra/subdir.am index bf2c393233..b8f5e0d409 100644 --- a/zebra/subdir.am +++ b/zebra/subdir.am @@ -79,6 +79,7 @@ zebra_zebra_SOURCES = \ zebra/zebra_ptm_redistribute.c \ zebra/zebra_pw.c \ zebra/zebra_rib.c \ + zebra/zebra_router.c \ zebra/zebra_rnh.c \ zebra/zebra_routemap.c \ zebra/zebra_vrf.c \ @@ -131,6 +132,7 @@ noinst_HEADERS += \ zebra/zebra_pw.h \ zebra/zebra_rnh.h \ zebra/zebra_routemap.h \ + zebra/zebra_router.h \ zebra/zebra_vrf.h \ zebra/zebra_vxlan.h \ zebra/zebra_vxlan_private.h \ diff --git a/zebra/zebra_ns.c b/zebra/zebra_ns.c index e251b26be1..75cacc04e1 100644 --- a/zebra/zebra_ns.c +++ b/zebra/zebra_ns.c @@ -44,28 +44,8 @@ extern struct zebra_privs_t zserv_privs; DEFINE_MTYPE(ZEBRA, ZEBRA_NS, "Zebra Name Space") -static inline int zebra_ns_table_entry_compare(const struct zebra_ns_table *e1, - const struct zebra_ns_table *e2); - -RB_GENERATE(zebra_ns_table_head, zebra_ns_table, zebra_ns_table_entry, - zebra_ns_table_entry_compare); - static struct zebra_ns *dzns; -static inline int zebra_ns_table_entry_compare(const struct zebra_ns_table *e1, - const struct zebra_ns_table *e2) -{ - if (e1->tableid < e2->tableid) - return -1; - if (e1->tableid > e2->tableid) - return 1; - if (e1->ns_id < e2->ns_id) - return -1; - if (e1->ns_id > e2->ns_id) - return 1; - return (e1->afi - e2->afi); -} - static int logicalrouter_config_write(struct vty *vty); struct zebra_ns *zebra_ns_lookup(ns_id_t ns_id) @@ -173,104 +153,8 @@ int zebra_ns_enable(ns_id_t ns_id, void **info) return 0; } -struct route_table *zebra_ns_find_table(struct zebra_ns *zns, uint32_t tableid, - afi_t afi) -{ - struct zebra_ns_table finder; - struct zebra_ns_table *znst; - - memset(&finder, 0, sizeof(finder)); - finder.afi = afi; - finder.tableid = tableid; - finder.ns_id = zns->ns_id; - znst = RB_FIND(zebra_ns_table_head, &zns->ns_tables, &finder); - - if (znst) - return znst->table; - else - return NULL; -} - -unsigned long zebra_ns_score_proto(uint8_t proto, unsigned short instance) -{ - struct zebra_ns *zns; - struct zebra_ns_table *znst; - unsigned long cnt = 0; - - zns = zebra_ns_lookup(NS_DEFAULT); - - RB_FOREACH (znst, zebra_ns_table_head, &zns->ns_tables) { - if (znst->ns_id != NS_DEFAULT) - continue; - cnt += rib_score_proto_table(proto, instance, znst->table); - } - return cnt; -} - -void zebra_ns_sweep_route(void) -{ - struct zebra_ns_table *znst; - struct zebra_ns *zns; - - zns = zebra_ns_lookup(NS_DEFAULT); - - RB_FOREACH (znst, zebra_ns_table_head, &zns->ns_tables) { - if (znst->ns_id != NS_DEFAULT) - continue; - rib_sweep_table(znst->table); - } -} - -struct route_table *zebra_ns_get_table(struct zebra_ns *zns, - struct zebra_vrf *zvrf, uint32_t tableid, - afi_t afi) -{ - struct zebra_ns_table finder; - struct zebra_ns_table *znst; - rib_table_info_t *info; - - memset(&finder, 0, sizeof(finder)); - finder.afi = afi; - finder.tableid = tableid; - finder.ns_id = zns->ns_id; - znst = RB_FIND(zebra_ns_table_head, &zns->ns_tables, &finder); - - if (znst) - return znst->table; - - znst = XCALLOC(MTYPE_ZEBRA_NS, sizeof(*znst)); - znst->tableid = tableid; - znst->afi = afi; - znst->ns_id = zns->ns_id; - znst->table = - (afi == AFI_IP6) ? srcdest_table_init() : route_table_init(); - - info = XCALLOC(MTYPE_RIB_TABLE_INFO, sizeof(*info)); - info->zvrf = zvrf; - info->afi = afi; - info->safi = SAFI_UNICAST; - route_table_set_info(znst->table, info); - znst->table->cleanup = zebra_rtable_node_cleanup; - - RB_INSERT(zebra_ns_table_head, &zns->ns_tables, znst); - return znst->table; -} - -static void zebra_ns_free_table(struct zebra_ns_table *znst) -{ - void *table_info; - - rib_close_table(znst->table); - - table_info = route_table_get_info(znst->table); - route_table_finish(znst->table); - XFREE(MTYPE_RIB_TABLE_INFO, table_info); - XFREE(MTYPE_ZEBRA_NS, znst); -} - int zebra_ns_disable(ns_id_t ns_id, void **info) { - struct zebra_ns_table *znst, *tmp; struct zebra_ns *zns = (struct zebra_ns *)(*info); hash_clean(zns->rules_hash, zebra_pbr_rules_free); @@ -283,13 +167,6 @@ int zebra_ns_disable(ns_id_t ns_id, void **info) zebra_pbr_iptable_free); hash_free(zns->iptable_hash); - RB_FOREACH_SAFE (znst, zebra_ns_table_head, &zns->ns_tables, tmp) { - if (znst->ns_id != ns_id) - continue; - RB_REMOVE(zebra_ns_table_head, &zns->ns_tables, znst); - zebra_ns_free_table(znst); - } - route_table_finish(zns->if_table); zebra_vxlan_ns_disable(zns); #if defined(HAVE_RTADV) diff --git a/zebra/zebra_ns.h b/zebra/zebra_ns.h index ed70a34c0b..8944f0b6f7 100644 --- a/zebra/zebra_ns.h +++ b/zebra/zebra_ns.h @@ -38,19 +38,6 @@ struct nlsock { }; #endif -struct zebra_ns_table { - RB_ENTRY(zebra_ns_table) zebra_ns_table_entry; - - uint32_t tableid; - afi_t afi; - ns_id_t ns_id; - - struct route_table *table; -}; -RB_HEAD(zebra_ns_table_head, zebra_ns_table); -RB_PROTOTYPE(zebra_ns_table_head, zebra_ns_table, zebra_ns_table_entry, - zebra_ns_table_entry_compare) - struct zebra_ns { /* net-ns name. */ char name[VRF_NAMSIZ]; @@ -66,15 +53,10 @@ struct zebra_ns { struct route_table *if_table; - /* L3-VNI hash table (for EVPN). Only in default instance */ - struct hash *l3vni_table; - #if defined(HAVE_RTADV) struct rtadv rtadv; #endif /* HAVE_RTADV */ - struct zebra_ns_table_head ns_tables; - struct hash *rules_hash; struct hash *ipset_hash; @@ -94,13 +76,6 @@ int zebra_ns_enable(ns_id_t ns_id, void **info); int zebra_ns_disabled(struct ns *ns); int zebra_ns_disable(ns_id_t ns_id, void **info); -extern struct route_table *zebra_ns_find_table(struct zebra_ns *zns, - uint32_t tableid, afi_t afi); -extern struct route_table *zebra_ns_get_table(struct zebra_ns *zns, - struct zebra_vrf *zvrf, - uint32_t tableid, afi_t afi); int zebra_ns_config_write(struct vty *vty, struct ns *ns); -unsigned long zebra_ns_score_proto(uint8_t proto, unsigned short instance); -void zebra_ns_sweep_route(void); #endif diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c index db610098f0..89cbdaf373 100644 --- a/zebra/zebra_rib.c +++ b/zebra/zebra_rib.c @@ -38,6 +38,7 @@ #include "vrf.h" #include "workqueue.h" +#include "zebra/zebra_router.h" #include "zebra/connected.h" #include "zebra/debug.h" #include "zebra/interface.h" @@ -2930,7 +2931,7 @@ void rib_sweep_route(void) rib_sweep_table(zvrf->table[AFI_IP6][SAFI_UNICAST]); } - zebra_ns_sweep_route(); + zebra_router_sweep_route(); } /* Remove specific by protocol routes from 'table'. */ @@ -2972,7 +2973,7 @@ unsigned long rib_score_proto(uint8_t proto, unsigned short instance) proto, instance, zvrf->table[AFI_IP6][SAFI_UNICAST]); - cnt += zebra_ns_score_proto(proto, instance); + cnt += zebra_router_score_proto(proto, instance); return cnt; } diff --git a/zebra/zebra_rnh.c b/zebra/zebra_rnh.c index 0a531990dc..df4435b619 100644 --- a/zebra/zebra_rnh.c +++ b/zebra/zebra_rnh.c @@ -36,6 +36,7 @@ #include "nexthop.h" #include "vrf.h" +#include "zebra/zebra_router.h" #include "zebra/rib.h" #include "zebra/rt.h" #include "zebra/zserv.h" @@ -469,12 +470,11 @@ static void zebra_rnh_process_pbr_tables(int family, struct route_node *prn, struct route_entry *re) { - struct zebra_ns_table *znst; + struct zebra_router_table *zrt; struct route_entry *o_re; struct route_node *o_rn; struct listnode *node; struct zserv *client; - struct zebra_ns *zns; afi_t afi = AFI_IP; if (family == AF_INET6) @@ -492,13 +492,12 @@ static void zebra_rnh_process_pbr_tables(int family, if (!client) return; - zns = zebra_ns_lookup(NS_DEFAULT); - RB_FOREACH (znst, zebra_ns_table_head, &zns->ns_tables) { - if (afi != znst->afi) + RB_FOREACH (zrt, zebra_router_table_head, &zrouter.tables) { + if (afi != zrt->afi) continue; - for (o_rn = route_top(znst->table); - o_rn; o_rn = srcdest_route_next(o_rn)) { + for (o_rn = route_top(zrt->table); o_rn; + o_rn = srcdest_route_next(o_rn)) { RNODE_FOREACH_RE (o_rn, o_re) { if (o_re->type == ZEBRA_ROUTE_PBR) break; diff --git a/zebra/zebra_router.c b/zebra/zebra_router.c new file mode 100644 index 0000000000..1116848a89 --- /dev/null +++ b/zebra/zebra_router.c @@ -0,0 +1,162 @@ +/* Zebra Router Code. + * Copyright (C) 2018 Cumulus Networks, Inc. + * Donald Sharp + * + * This file is part of FRR. + * + * FRR 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, or (at your option) any + * later version. + * + * FRR 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 FRR; see the file COPYING. If not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ +#include "zebra.h" + +#include "zebra_router.h" +#include "zebra_memory.h" + +struct zebra_router zrouter; + +static inline int +zebra_router_table_entry_compare(const struct zebra_router_table *e1, + const struct zebra_router_table *e2); + +RB_GENERATE(zebra_router_table_head, zebra_router_table, + zebra_router_table_entry, zebra_router_table_entry_compare); + + +static inline int +zebra_router_table_entry_compare(const struct zebra_router_table *e1, + const struct zebra_router_table *e2) +{ + if (e1->tableid < e2->tableid) + return -1; + if (e1->tableid > e2->tableid) + return 1; + if (e1->ns_id < e2->ns_id) + return -1; + if (e1->ns_id > e2->ns_id) + return 1; + if (e1->afi < e2->afi) + return -1; + if (e1->afi > e2->afi) + return 1; + return (e1->safi - e2->safi); +} + + +struct route_table *zebra_router_find_table(struct zebra_vrf *zvrf, + uint32_t tableid, afi_t afi, + safi_t safi) +{ + struct zebra_router_table finder; + struct zebra_router_table *zrt; + + memset(&finder, 0, sizeof(finder)); + finder.afi = afi; + finder.safi = safi; + finder.tableid = tableid; + finder.ns_id = zvrf->zns->ns_id; + zrt = RB_FIND(zebra_router_table_head, &zrouter.tables, &finder); + + if (zrt) + return zrt->table; + else + return NULL; +} + +struct route_table *zebra_router_get_table(struct zebra_vrf *zvrf, + uint32_t tableid, afi_t afi, + safi_t safi) +{ + struct zebra_router_table finder; + struct zebra_router_table *zrt; + rib_table_info_t *info; + + memset(&finder, 0, sizeof(finder)); + finder.afi = afi; + finder.safi = safi; + finder.tableid = tableid; + finder.ns_id = zvrf->zns->ns_id; + zrt = RB_FIND(zebra_router_table_head, &zrouter.tables, &finder); + + if (zrt) + return zrt->table; + + zrt = XCALLOC(MTYPE_ZEBRA_NS, sizeof(*zrt)); + zrt->tableid = tableid; + zrt->afi = afi; + zrt->ns_id = zvrf->zns->ns_id; + zrt->table = + (afi == AFI_IP6) ? srcdest_table_init() : route_table_init(); + + info = XCALLOC(MTYPE_RIB_TABLE_INFO, sizeof(*info)); + info->zvrf = zvrf; + info->afi = afi; + info->safi = SAFI_UNICAST; + route_table_set_info(zrt->table, info); + zrt->table->cleanup = zebra_rtable_node_cleanup; + + RB_INSERT(zebra_router_table_head, &zrouter.tables, zrt); + return zrt->table; +} + +unsigned long zebra_router_score_proto(uint8_t proto, unsigned short instance) +{ + struct zebra_router_table *zrt; + unsigned long cnt = 0; + + RB_FOREACH (zrt, zebra_router_table_head, &zrouter.tables) { + if (zrt->ns_id != NS_DEFAULT) + continue; + cnt += rib_score_proto_table(proto, instance, zrt->table); + } + return cnt; +} + +void zebra_router_sweep_route(void) +{ + struct zebra_router_table *zrt; + + RB_FOREACH (zrt, zebra_router_table_head, &zrouter.tables) { + if (zrt->ns_id != NS_DEFAULT) + continue; + rib_sweep_table(zrt->table); + } +} + +static void zebra_router_free_table(struct zebra_router_table *zrt) +{ + void *table_info; + + rib_close_table(zrt->table); + + table_info = route_table_get_info(zrt->table); + route_table_finish(zrt->table); + XFREE(MTYPE_RIB_TABLE_INFO, table_info); + XFREE(MTYPE_ZEBRA_NS, zrt); +} + +void zebra_router_terminate(void) +{ + struct zebra_router_table *zrt, *tmp; + + RB_FOREACH_SAFE (zrt, zebra_router_table_head, &zrouter.tables, tmp) { + RB_REMOVE(zebra_router_table_head, &zrouter.tables, zrt); + zebra_router_free_table(zrt); + } +} + +void zebra_router_init(void) +{ + zrouter.l3vni_table = NULL; +} diff --git a/zebra/zebra_router.h b/zebra/zebra_router.h new file mode 100644 index 0000000000..456f168227 --- /dev/null +++ b/zebra/zebra_router.h @@ -0,0 +1,71 @@ +/* Zebra Router header. + * Copyright (C) 2018 Cumulus Networks, Inc. + * Donald Sharp + * + * This file is part of FRR. + * + * FRR 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, or (at your option) any + * later version. + * + * FRR 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 FRR; see the file COPYING. If not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ +#ifndef __ZEBRA_ROUTER_H__ +#define __ZEBRA_ROUTER_H__ + +#include "zebra/zebra_ns.h" + +/* + * This header file contains the idea of a router and as such + * owns data that is associated with a router from zebra's + * perspective. + */ + +struct zebra_router_table { + RB_ENTRY(zebra_router_table) zebra_router_table_entry; + + uint32_t tableid; + afi_t afi; + safi_t safi; + ns_id_t ns_id; + + struct route_table *table; +}; +RB_HEAD(zebra_router_table_head, zebra_router_table); +RB_PROTOTYPE(zebra_router_table_head, zebra_router_table, + zebra_router_table_entry, zebra_router_table_entry_compare) + +struct zebra_router { + + struct zebra_router_table_head tables; + /* L3-VNI hash table (for EVPN). Only in default instance */ + struct hash *l3vni_table; +}; + +extern struct zebra_router zrouter; + +extern void zebra_router_init(void); +extern void zebra_router_terminate(void); + +extern struct route_table *zebra_router_find_table(struct zebra_vrf *zvrf, + uint32_t tableid, afi_t afi, + safi_t safi); +extern struct route_table *zebra_router_get_table(struct zebra_vrf *zvrf, + uint32_t tableid, afi_t afi, + safi_t safi); + +extern int zebra_router_config_write(struct vty *vty); + +extern unsigned long zebra_router_score_proto(uint8_t proto, + unsigned short instance); +extern void zebra_router_sweep_route(void); +#endif diff --git a/zebra/zebra_vrf.c b/zebra/zebra_vrf.c index a1692d3c3e..e98a533609 100644 --- a/zebra/zebra_vrf.c +++ b/zebra/zebra_vrf.c @@ -28,6 +28,7 @@ #include "vrf.h" #include "vty.h" +#include "zebra/zebra_router.h" #include "zebra/debug.h" #include "zebra/zapi_msg.h" #include "zebra/rib.h" @@ -144,7 +145,6 @@ static int zebra_vrf_enable(struct vrf *vrf) static int zebra_vrf_disable(struct vrf *vrf) { struct zebra_vrf *zvrf = vrf->info; - struct route_table *table; struct interface *ifp; afi_t afi; safi_t safi; @@ -202,15 +202,16 @@ static int zebra_vrf_disable(struct vrf *vrf) /* Cleanup (free) routing tables and NHT tables. */ for (afi = AFI_IP; afi <= AFI_IP6; afi++) { - void *table_info; - - for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) { - table = zvrf->table[afi][safi]; - table_info = route_table_get_info(table); - route_table_finish(table); - XFREE(MTYPE_RIB_TABLE_INFO, table_info); + /* + * Set the table pointer to NULL as that + * we no-longer need a copy of it, nor do we + * own this data, the zebra_router structure + * owns these tables. Once we've cleaned up the + * table, see rib_close_table above + * we no-longer need this pointer. + */ + for (safi = SAFI_UNICAST; safi <= SAFI_MULTICAST; safi++) zvrf->table[afi][safi] = NULL; - } route_table_finish(zvrf->rnh_table[afi]); zvrf->rnh_table[afi] = NULL; @@ -374,10 +375,8 @@ static void zebra_vrf_table_create(struct zebra_vrf *zvrf, afi_t afi, assert(!zvrf->table[afi][safi]); - if (afi == AFI_IP6) - table = srcdest_table_init(); - else - table = route_table_init(); + table = zebra_router_get_table(zvrf, zvrf->table_id, afi, safi); + table->cleanup = zebra_rtable_node_cleanup; zvrf->table[afi][safi] = table; @@ -442,14 +441,11 @@ struct route_table *zebra_vrf_other_route_table(afi_t afi, uint32_t table_id, vrf_id_t vrf_id) { struct zebra_vrf *zvrf; - struct zebra_ns *zns; zvrf = vrf_info_lookup(vrf_id); if (!zvrf) return NULL; - zns = zvrf->zns; - if (afi >= AFI_MAX) return NULL; @@ -461,7 +457,8 @@ struct route_table *zebra_vrf_other_route_table(afi_t afi, uint32_t table_id, * so in all cases, it does not use specific table * so it is possible to configure tables in this VRF */ - return zebra_ns_get_table(zns, zvrf, table_id, afi); + return zebra_router_get_table(zvrf, table_id, afi, + SAFI_UNICAST); } } diff --git a/zebra/zebra_vty.c b/zebra/zebra_vty.c index fdedb30f84..40d673a891 100644 --- a/zebra/zebra_vty.c +++ b/zebra/zebra_vty.c @@ -35,6 +35,7 @@ #include "srcdest_table.h" #include "vxlan.h" +#include "zebra/zebra_router.h" #include "zebra/zserv.h" #include "zebra/zebra_vrf.h" #include "zebra/zebra_mpls.h" @@ -896,7 +897,7 @@ DEFPY (show_route_table, struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT); struct route_table *t; - t = zebra_ns_find_table(zvrf->zns, table, afi); + t = zebra_router_find_table(zvrf, table, afi, SAFI_UNICAST); if (t) do_show_route_helper(vty, zvrf, t, afi, false, 0, false, false, 0, 0, !!json); @@ -925,7 +926,7 @@ DEFPY (show_route_table_vrf, VRF_GET_ID(vrf_id, vrf_name, !!json); zvrf = zebra_vrf_lookup_by_id(vrf_id); - t = zebra_ns_find_table(zvrf->zns, table, afi); + t = zebra_router_find_table(zvrf, table, afi, SAFI_UNICAST); if (t) do_show_route_helper(vty, zvrf, t, afi, false, 0, false, false, 0, 0, !!json); diff --git a/zebra/zebra_vxlan.c b/zebra/zebra_vxlan.c index fe182780be..bc463b716a 100644 --- a/zebra/zebra_vxlan.c +++ b/zebra/zebra_vxlan.c @@ -37,6 +37,7 @@ #include #endif +#include "zebra/zebra_router.h" #include "zebra/debug.h" #include "zebra/interface.h" #include "zebra/rib.h" @@ -3643,15 +3644,12 @@ static void *zl3vni_alloc(void *p) */ static zebra_l3vni_t *zl3vni_lookup(vni_t vni) { - struct zebra_ns *zns; zebra_l3vni_t tmp_l3vni; zebra_l3vni_t *zl3vni = NULL; - zns = zebra_ns_lookup(NS_DEFAULT); - assert(zns); memset(&tmp_l3vni, 0, sizeof(zebra_l3vni_t)); tmp_l3vni.vni = vni; - zl3vni = hash_lookup(zns->l3vni_table, &tmp_l3vni); + zl3vni = hash_lookup(zrouter.l3vni_table, &tmp_l3vni); return zl3vni; } @@ -3662,16 +3660,12 @@ static zebra_l3vni_t *zl3vni_lookup(vni_t vni) static zebra_l3vni_t *zl3vni_add(vni_t vni, vrf_id_t vrf_id) { zebra_l3vni_t tmp_zl3vni; - struct zebra_ns *zns = NULL; zebra_l3vni_t *zl3vni = NULL; - zns = zebra_ns_lookup(NS_DEFAULT); - assert(zns); - memset(&tmp_zl3vni, 0, sizeof(zebra_l3vni_t)); tmp_zl3vni.vni = vni; - zl3vni = hash_get(zns->l3vni_table, &tmp_zl3vni, zl3vni_alloc); + zl3vni = hash_get(zrouter.l3vni_table, &tmp_zl3vni, zl3vni_alloc); assert(zl3vni); zl3vni->vrf_id = vrf_id; @@ -3696,12 +3690,8 @@ static zebra_l3vni_t *zl3vni_add(vni_t vni, vrf_id_t vrf_id) */ static int zl3vni_del(zebra_l3vni_t *zl3vni) { - struct zebra_ns *zns; zebra_l3vni_t *tmp_zl3vni; - zns = zebra_ns_lookup(NS_DEFAULT); - assert(zns); - /* free the list of l2vnis */ list_delete(&zl3vni->l2vnis); zl3vni->l2vnis = NULL; @@ -3715,7 +3705,7 @@ static int zl3vni_del(zebra_l3vni_t *zl3vni) zl3vni->nh_table = NULL; /* Free the VNI hash entry and allocated memory. */ - tmp_zl3vni = hash_release(zns->l3vni_table, zl3vni); + tmp_zl3vni = hash_release(zrouter.l3vni_table, zl3vni); if (tmp_zl3vni) XFREE(MTYPE_ZL3VNI, tmp_zl3vni); @@ -4634,7 +4624,6 @@ void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t l3vni, bool use_json) void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, bool use_json) { - struct zebra_ns *zns = NULL; json_object *json = NULL; void *args[2]; @@ -4644,19 +4633,12 @@ void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, bool use_json) return; } - zns = zebra_ns_lookup(NS_DEFAULT); - if (!zns) { - if (use_json) - vty_out(vty, "{}\n"); - return; - } - if (use_json) json = json_object_new_object(); args[0] = vty; args[1] = json; - hash_iterate(zns->l3vni_table, + hash_iterate(zrouter.l3vni_table, (void (*)(struct hash_backet *, void *))zl3vni_print_rmac_hash_all_vni, args); @@ -4759,7 +4741,6 @@ void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t l3vni, bool use_json) void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, bool use_json) { - struct zebra_ns *zns = NULL; json_object *json = NULL; void *args[2]; @@ -4769,16 +4750,12 @@ void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, bool use_json) return; } - zns = zebra_ns_lookup(NS_DEFAULT); - if (!zns) - return; - if (use_json) json = json_object_new_object(); args[0] = vty; args[1] = json; - hash_iterate(zns->l3vni_table, + hash_iterate(zrouter.l3vni_table, (void (*)(struct hash_backet *, void *))zl3vni_print_nh_hash_all_vni, args); @@ -5273,21 +5250,16 @@ void zebra_vxlan_print_evpn(struct vty *vty, bool uj) int num_l3vnis = 0; int num_vnis = 0; json_object *json = NULL; - struct zebra_ns *zns = NULL; struct zebra_vrf *zvrf = NULL; if (!is_evpn_enabled()) return; - zns = zebra_ns_lookup(NS_DEFAULT); - if (!zns) - return; - zvrf = vrf_info_lookup(VRF_DEFAULT); if (!zvrf) return; - num_l3vnis = hashcount(zns->l3vni_table); + num_l3vnis = hashcount(zrouter.l3vni_table); num_l2vnis = hashcount(zvrf->vni_table); num_vnis = num_l2vnis + num_l3vnis; @@ -5319,17 +5291,11 @@ void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf, bool use_json) { json_object *json = NULL; - struct zebra_ns *zns = NULL; void *args[2]; if (!is_evpn_enabled()) return; - zns = zebra_ns_lookup(NS_DEFAULT); - if (!zns) - return; - - if (use_json) json = json_object_new_object(); else @@ -5346,7 +5312,7 @@ void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf, args); /* Display all L3-VNIs */ - hash_iterate(zns->l3vni_table, + hash_iterate(zrouter.l3vni_table, (void (*)(struct hash_backet *, void *))zl3vni_print_hash, args); @@ -7160,7 +7126,6 @@ void zebra_vxlan_advertise_all_vni(ZAPI_HANDLER_ARGS) { struct stream *s = NULL; int advertise = 0; - struct zebra_ns *zns = NULL; enum vxlan_flood_control flood_ctrl; if (zvrf_id(zvrf) != VRF_DEFAULT) { @@ -7206,11 +7171,7 @@ void zebra_vxlan_advertise_all_vni(ZAPI_HANDLER_ARGS) hash_iterate(zvrf->vni_table, zvni_cleanup_all, zvrf); /* cleanup all l3vnis */ - zns = zebra_ns_lookup(NS_DEFAULT); - if (!zns) - return; - - hash_iterate(zns->l3vni_table, zl3vni_cleanup_all, NULL); + hash_iterate(zrouter.l3vni_table, zl3vni_cleanup_all, NULL); } stream_failure: @@ -7249,14 +7210,14 @@ void zebra_vxlan_close_tables(struct zebra_vrf *zvrf) /* init the l3vni table */ void zebra_vxlan_ns_init(struct zebra_ns *zns) { - zns->l3vni_table = hash_create(l3vni_hash_keymake, l3vni_hash_cmp, - "Zebra VRF L3 VNI table"); + zrouter.l3vni_table = hash_create(l3vni_hash_keymake, l3vni_hash_cmp, + "Zebra VRF L3 VNI table"); } /* free l3vni table */ void zebra_vxlan_ns_disable(struct zebra_ns *zns) { - hash_free(zns->l3vni_table); + hash_free(zrouter.l3vni_table); } /* get the l3vni svi ifindex */ From 7f0ea8a4a23f4500421e89268b442cf145d0d75f Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Mon, 27 Aug 2018 14:36:46 -0400 Subject: [PATCH 2/5] zebra: Move rules_hash to zrouter Move the rules_hash to the zrouter data structure and provide the additional bit of work needed to lookup the rule based upon the namespace id as well. Make the callers of functions not care about what namespace id we are in. Signed-off-by: Donald Sharp Signed-off-by: Donald Sharp --- zebra/zapi_msg.c | 5 +++-- zebra/zebra_ns.c | 10 +++------- zebra/zebra_ns.h | 2 -- zebra/zebra_pbr.c | 44 ++++++++++++++++++++++++++------------------ zebra/zebra_pbr.h | 6 ++++-- zebra/zebra_router.c | 8 ++++++++ zebra/zebra_router.h | 3 +++ 7 files changed, 47 insertions(+), 31 deletions(-) diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c index 149d2cb6a5..c9325d8443 100644 --- a/zebra/zapi_msg.c +++ b/zebra/zapi_msg.c @@ -2243,10 +2243,11 @@ static inline void zread_rule(ZAPI_HANDLER_ARGS) if (zpr.rule.filter.fwmark) zpr.rule.filter.filter_bm |= PBR_FILTER_FWMARK; + zpr.vrf_id = zvrf->vrf->vrf_id; if (hdr->command == ZEBRA_RULE_ADD) - zebra_pbr_add_rule(zvrf->zns, &zpr); + zebra_pbr_add_rule(&zpr); else - zebra_pbr_del_rule(zvrf->zns, &zpr); + zebra_pbr_del_rule(&zpr); } stream_failure: diff --git a/zebra/zebra_ns.c b/zebra/zebra_ns.c index 75cacc04e1..300989e33c 100644 --- a/zebra/zebra_ns.c +++ b/zebra/zebra_ns.c @@ -121,10 +121,6 @@ int zebra_ns_enable(ns_id_t ns_id, void **info) zns->ns_id = ns_id; - zns->rules_hash = - hash_create_size(8, zebra_pbr_rules_hash_key, - zebra_pbr_rules_hash_equal, "Rules Hash"); - zns->ipset_hash = hash_create_size(8, zebra_pbr_ipset_hash_key, zebra_pbr_ipset_hash_equal, "IPset Hash"); @@ -157,9 +153,8 @@ int zebra_ns_disable(ns_id_t ns_id, void **info) { struct zebra_ns *zns = (struct zebra_ns *)(*info); - hash_clean(zns->rules_hash, zebra_pbr_rules_free); - hash_free(zns->rules_hash); - hash_clean(zns->ipset_entry_hash, zebra_pbr_ipset_entry_free); + hash_clean(zns->ipset_entry_hash, + zebra_pbr_ipset_entry_free), hash_clean(zns->ipset_hash, zebra_pbr_ipset_free); hash_free(zns->ipset_hash); hash_free(zns->ipset_entry_hash); @@ -216,6 +211,7 @@ int zebra_ns_init(void) zebra_ns_notify_parse(); zebra_ns_notify_init(); } + return 0; } diff --git a/zebra/zebra_ns.h b/zebra/zebra_ns.h index 8944f0b6f7..2af4304209 100644 --- a/zebra/zebra_ns.h +++ b/zebra/zebra_ns.h @@ -57,8 +57,6 @@ struct zebra_ns { struct rtadv rtadv; #endif /* HAVE_RTADV */ - struct hash *rules_hash; - struct hash *ipset_hash; struct hash *ipset_entry_hash; diff --git a/zebra/zebra_pbr.c b/zebra/zebra_pbr.c index 1a528780c1..059930f4e1 100644 --- a/zebra/zebra_pbr.c +++ b/zebra/zebra_pbr.c @@ -26,6 +26,7 @@ #include #include +#include "zebra/zebra_router.h" #include "zebra/zebra_pbr.h" #include "zebra/rt.h" #include "zebra/zapi_msg.h" @@ -158,6 +159,9 @@ uint32_t zebra_pbr_rules_hash_key(void *arg) key = jhash_1word(rule->rule.filter.fwmark, key); else key = jhash_1word(0, key); + + key = jhash_1word(rule->vrf_id, key); + return jhash_3words(rule->rule.filter.src_port, rule->rule.filter.dst_port, prefix_hash_key(&rule->rule.filter.dst_ip), @@ -201,6 +205,9 @@ bool zebra_pbr_rules_hash_equal(const void *arg1, const void *arg2) if (r1->ifp != r2->ifp) return false; + if (r1->vrf_id != r2->vrf_id) + return false; + return true; } @@ -208,6 +215,7 @@ struct pbr_rule_unique_lookup { struct zebra_pbr_rule *rule; uint32_t unique; struct interface *ifp; + vrf_id_t vrf_id; }; static int pbr_rule_lookup_unique_walker(struct hash_backet *b, void *data) @@ -215,7 +223,9 @@ static int pbr_rule_lookup_unique_walker(struct hash_backet *b, void *data) struct pbr_rule_unique_lookup *pul = data; struct zebra_pbr_rule *rule = b->data; - if (pul->unique == rule->rule.unique && pul->ifp == rule->ifp) { + if (pul->unique == rule->rule.unique + && pul->ifp == rule->ifp + && pul->vrf_id == rule->vrf_id) { pul->rule = rule; return HASHWALK_ABORT; } @@ -223,16 +233,15 @@ static int pbr_rule_lookup_unique_walker(struct hash_backet *b, void *data) return HASHWALK_CONTINUE; } -static struct zebra_pbr_rule *pbr_rule_lookup_unique(struct zebra_ns *zns, - uint32_t unique, - struct interface *ifp) +static struct zebra_pbr_rule *pbr_rule_lookup_unique(struct zebra_pbr_rule *zrule) { struct pbr_rule_unique_lookup pul; - pul.unique = unique; - pul.ifp = ifp; + pul.unique = zrule->rule.unique; + pul.ifp = zrule->ifp; pul.rule = NULL; - hash_walk(zns->rules_hash, &pbr_rule_lookup_unique_walker, &pul); + pul.vrf_id = zrule->vrf_id; + hash_walk(zrouter.rules_hash, &pbr_rule_lookup_unique_walker, &pul); return pul.rule; } @@ -438,30 +447,30 @@ static void *pbr_rule_alloc_intern(void *arg) return new; } -void zebra_pbr_add_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule) +void zebra_pbr_add_rule(struct zebra_pbr_rule *rule) { struct zebra_pbr_rule *unique = - pbr_rule_lookup_unique(zns, rule->rule.unique, rule->ifp); + pbr_rule_lookup_unique(rule); - (void)hash_get(zns->rules_hash, rule, pbr_rule_alloc_intern); + (void)hash_get(zrouter.rules_hash, rule, pbr_rule_alloc_intern); (void)kernel_add_pbr_rule(rule); /* * Rule Replace semantics, if we have an old, install the * new rule, look above, and then delete the old */ if (unique) - zebra_pbr_del_rule(zns, unique); + zebra_pbr_del_rule(unique); } -void zebra_pbr_del_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule) +void zebra_pbr_del_rule(struct zebra_pbr_rule *rule) { struct zebra_pbr_rule *lookup; - lookup = hash_lookup(zns->rules_hash, rule); + lookup = hash_lookup(zrouter.rules_hash, rule); (void)kernel_del_pbr_rule(rule); if (lookup) { - hash_release(zns->rules_hash, lookup); + hash_release(zrouter.rules_hash, lookup); XFREE(MTYPE_TMP, lookup); } else zlog_debug("%s: Rule being deleted we know nothing about", @@ -470,13 +479,12 @@ void zebra_pbr_del_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule) static void zebra_pbr_cleanup_rules(struct hash_backet *b, void *data) { - struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT); struct zebra_pbr_rule *rule = b->data; int *sock = data; if (rule->sock == *sock) { (void)kernel_del_pbr_rule(rule); - hash_release(zns->rules_hash, rule); + hash_release(zrouter.rules_hash, rule); XFREE(MTYPE_TMP, rule); } } @@ -527,7 +535,7 @@ static int zebra_pbr_client_close_cleanup(struct zserv *client) if (!sock) return 0; - hash_iterate(zns->rules_hash, zebra_pbr_cleanup_rules, &sock); + hash_iterate(zrouter.rules_hash, zebra_pbr_cleanup_rules, &sock); hash_iterate(zns->iptable_hash, zebra_pbr_cleanup_iptable, &sock); hash_iterate(zns->ipset_entry_hash, @@ -1136,7 +1144,7 @@ static void zebra_pbr_show_iptable_unit(struct zebra_pbr_iptable *iptable, prfl.fwmark = iptable->fwmark; prfl.ptr = NULL; - hash_walk(zns->rules_hash, + hash_walk(zrouter.rules_hash, &zebra_pbr_rule_lookup_fwmark_walkcb, &prfl); if (prfl.ptr) { struct zebra_pbr_rule *zpr = prfl.ptr; diff --git a/zebra/zebra_pbr.h b/zebra/zebra_pbr.h index 093fcfa8b0..bc651d5114 100644 --- a/zebra/zebra_pbr.h +++ b/zebra/zebra_pbr.h @@ -38,6 +38,8 @@ struct zebra_pbr_rule { struct pbr_rule rule; struct interface *ifp; + + vrf_id_t vrf_id; }; #define IS_RULE_FILTERING_ON_SRC_IP(r) \ @@ -151,8 +153,8 @@ extern const struct message icmp_typecode_str[]; const char *zebra_pbr_ipset_type2str(uint32_t type); -void zebra_pbr_add_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule); -void zebra_pbr_del_rule(struct zebra_ns *zns, struct zebra_pbr_rule *rule); +void zebra_pbr_add_rule(struct zebra_pbr_rule *rule); +void zebra_pbr_del_rule(struct zebra_pbr_rule *rule); void zebra_pbr_create_ipset(struct zebra_ns *zns, struct zebra_pbr_ipset *ipset); void zebra_pbr_destroy_ipset(struct zebra_ns *zns, diff --git a/zebra/zebra_router.c b/zebra/zebra_router.c index 1116848a89..94d7ab1b8c 100644 --- a/zebra/zebra_router.c +++ b/zebra/zebra_router.c @@ -23,6 +23,7 @@ #include "zebra_router.h" #include "zebra_memory.h" +#include "zebra_pbr.h" struct zebra_router zrouter; @@ -154,9 +155,16 @@ void zebra_router_terminate(void) RB_REMOVE(zebra_router_table_head, &zrouter.tables, zrt); zebra_router_free_table(zrt); } + + hash_clean(zrouter.rules_hash, zebra_pbr_rules_free); + hash_free(zrouter.rules_hash); } void zebra_router_init(void) { zrouter.l3vni_table = NULL; + + zrouter.rules_hash = hash_create_size(8, zebra_pbr_rules_hash_key, + zebra_pbr_rules_hash_equal, + "Rules Hash"); } diff --git a/zebra/zebra_router.h b/zebra/zebra_router.h index 456f168227..246f3857c2 100644 --- a/zebra/zebra_router.h +++ b/zebra/zebra_router.h @@ -47,8 +47,11 @@ RB_PROTOTYPE(zebra_router_table_head, zebra_router_table, struct zebra_router { struct zebra_router_table_head tables; + /* L3-VNI hash table (for EVPN). Only in default instance */ struct hash *l3vni_table; + + struct hash *rules_hash; }; extern struct zebra_router zrouter; From 62f20a52ab08c89697c094d4f44df5cf0272499a Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Mon, 27 Aug 2018 15:24:02 -0400 Subject: [PATCH 3/5] zebra: Move ipset_hash, ipset_entry_hash and iptable_hash into zrouter These three data structures belong in the `zebra_router` structure as that they do not belong in `struct zebra_ns`. Signed-off-by: Donald Sharp --- zebra/zapi_msg.c | 16 ++-- zebra/zebra_ns.c | 23 ------ zebra/zebra_ns.h | 6 -- zebra/zebra_pbr.c | 182 +++++++++++++++++-------------------------- zebra/zebra_pbr.h | 55 +++++-------- zebra/zebra_router.c | 19 +++++ zebra/zebra_router.h | 6 ++ 7 files changed, 125 insertions(+), 182 deletions(-) diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c index c9325d8443..276b825b34 100644 --- a/zebra/zapi_msg.c +++ b/zebra/zapi_msg.c @@ -2273,9 +2273,9 @@ static inline void zread_ipset(ZAPI_HANDLER_ARGS) STREAM_GET(&zpi.ipset_name, s, ZEBRA_IPSET_NAME_SIZE); if (hdr->command == ZEBRA_IPSET_CREATE) - zebra_pbr_create_ipset(zvrf->zns, &zpi); + zebra_pbr_create_ipset(&zpi); else - zebra_pbr_destroy_ipset(zvrf->zns, &zpi); + zebra_pbr_destroy_ipset(&zpi); } stream_failure: @@ -2328,12 +2328,12 @@ static inline void zread_ipset_entry(ZAPI_HANDLER_ARGS) zpi.filter_bm |= PBR_FILTER_PROTO; /* calculate backpointer */ - zpi.backpointer = zebra_pbr_lookup_ipset_pername( - zvrf->zns, ipset.ipset_name); + zpi.backpointer = + zebra_pbr_lookup_ipset_pername(ipset.ipset_name); if (hdr->command == ZEBRA_IPSET_ENTRY_ADD) - zebra_pbr_add_ipset_entry(zvrf->zns, &zpi); + zebra_pbr_add_ipset_entry(&zpi); else - zebra_pbr_del_ipset_entry(zvrf->zns, &zpi); + zebra_pbr_del_ipset_entry(&zpi); } stream_failure: @@ -2368,9 +2368,9 @@ static inline void zread_iptable(ZAPI_HANDLER_ARGS) zebra_pbr_iptable_update_interfacelist(s, &zpi); if (hdr->command == ZEBRA_IPTABLE_ADD) - zebra_pbr_add_iptable(zvrf->zns, &zpi); + zebra_pbr_add_iptable(&zpi); else - zebra_pbr_del_iptable(zvrf->zns, &zpi); + zebra_pbr_del_iptable(&zpi); stream_failure: return; } diff --git a/zebra/zebra_ns.c b/zebra/zebra_ns.c index 300989e33c..e65f23dc8a 100644 --- a/zebra/zebra_ns.c +++ b/zebra/zebra_ns.c @@ -121,20 +121,6 @@ int zebra_ns_enable(ns_id_t ns_id, void **info) zns->ns_id = ns_id; - zns->ipset_hash = - hash_create_size(8, zebra_pbr_ipset_hash_key, - zebra_pbr_ipset_hash_equal, "IPset Hash"); - - zns->ipset_entry_hash = - hash_create_size(8, zebra_pbr_ipset_entry_hash_key, - zebra_pbr_ipset_entry_hash_equal, - "IPset Hash Entry"); - - zns->iptable_hash = - hash_create_size(8, zebra_pbr_iptable_hash_key, - zebra_pbr_iptable_hash_equal, - "IPtable Hash Entry"); - #if defined(HAVE_RTADV) rtadv_init(zns); #endif @@ -153,15 +139,6 @@ int zebra_ns_disable(ns_id_t ns_id, void **info) { struct zebra_ns *zns = (struct zebra_ns *)(*info); - hash_clean(zns->ipset_entry_hash, - zebra_pbr_ipset_entry_free), - hash_clean(zns->ipset_hash, zebra_pbr_ipset_free); - hash_free(zns->ipset_hash); - hash_free(zns->ipset_entry_hash); - hash_clean(zns->iptable_hash, - zebra_pbr_iptable_free); - hash_free(zns->iptable_hash); - route_table_finish(zns->if_table); zebra_vxlan_ns_disable(zns); #if defined(HAVE_RTADV) diff --git a/zebra/zebra_ns.h b/zebra/zebra_ns.h index 2af4304209..2498be7162 100644 --- a/zebra/zebra_ns.h +++ b/zebra/zebra_ns.h @@ -57,12 +57,6 @@ struct zebra_ns { struct rtadv rtadv; #endif /* HAVE_RTADV */ - struct hash *ipset_hash; - - struct hash *ipset_entry_hash; - - struct hash *iptable_hash; - /* Back pointer */ struct ns *ns; }; diff --git a/zebra/zebra_pbr.c b/zebra/zebra_pbr.c index 059930f4e1..d774994a84 100644 --- a/zebra/zebra_pbr.c +++ b/zebra/zebra_pbr.c @@ -103,30 +103,24 @@ static const struct message fragment_value_str[] = { }; /* static function declarations */ -DEFINE_HOOK(zebra_pbr_ipset_entry_wrap_script_get_stat, (struct zebra_ns *zns, - struct zebra_pbr_ipset_entry *ipset, - uint64_t *pkts, uint64_t *bytes), - (zns, ipset, pkts, bytes)) +DEFINE_HOOK(zebra_pbr_ipset_entry_wrap_script_get_stat, + (struct zebra_pbr_ipset_entry *ipset, uint64_t *pkts, + uint64_t *bytes), + (ipset, pkts, bytes)) -DEFINE_HOOK(zebra_pbr_iptable_wrap_script_get_stat, (struct zebra_ns *zns, - struct zebra_pbr_iptable *iptable, - uint64_t *pkts, uint64_t *bytes), - (zns, iptable, pkts, bytes)) +DEFINE_HOOK(zebra_pbr_iptable_wrap_script_get_stat, + (struct zebra_pbr_iptable *iptable, uint64_t *pkts, + uint64_t *bytes), + (iptable, pkts, bytes)) -DEFINE_HOOK(zebra_pbr_iptable_wrap_script_update, (struct zebra_ns *zns, - int cmd, - struct zebra_pbr_iptable *iptable), - (zns, cmd, iptable)); +DEFINE_HOOK(zebra_pbr_iptable_wrap_script_update, + (int cmd, struct zebra_pbr_iptable *iptable), (cmd, iptable)); -DEFINE_HOOK(zebra_pbr_ipset_entry_wrap_script_update, (struct zebra_ns *zns, - int cmd, - struct zebra_pbr_ipset_entry *ipset), - (zns, cmd, ipset)); +DEFINE_HOOK(zebra_pbr_ipset_entry_wrap_script_update, + (int cmd, struct zebra_pbr_ipset_entry *ipset), (cmd, ipset)); -DEFINE_HOOK(zebra_pbr_ipset_wrap_script_update, (struct zebra_ns *zns, - int cmd, - struct zebra_pbr_ipset *ipset), - (zns, cmd, ipset)); +DEFINE_HOOK(zebra_pbr_ipset_wrap_script_update, + (int cmd, struct zebra_pbr_ipset *ipset), (cmd, ipset)); /* Private functions */ @@ -233,7 +227,8 @@ static int pbr_rule_lookup_unique_walker(struct hash_backet *b, void *data) return HASHWALK_CONTINUE; } -static struct zebra_pbr_rule *pbr_rule_lookup_unique(struct zebra_pbr_rule *zrule) +static struct zebra_pbr_rule * +pbr_rule_lookup_unique(struct zebra_pbr_rule *zrule) { struct pbr_rule_unique_lookup pul; @@ -249,15 +244,9 @@ static struct zebra_pbr_rule *pbr_rule_lookup_unique(struct zebra_pbr_rule *zrul void zebra_pbr_ipset_free(void *arg) { struct zebra_pbr_ipset *ipset; - struct zebra_ns *zns; ipset = (struct zebra_pbr_ipset *)arg; - if (vrf_is_backend_netns()) - zns = zebra_ns_lookup(ipset->vrf_id); - else - zns = zebra_ns_lookup(NS_DEFAULT); - hook_call(zebra_pbr_ipset_wrap_script_update, - zns, 0, ipset); + hook_call(zebra_pbr_ipset_wrap_script_update, 0, ipset); XFREE(MTYPE_TMP, ipset); } @@ -265,8 +254,9 @@ uint32_t zebra_pbr_ipset_hash_key(void *arg) { struct zebra_pbr_ipset *ipset = (struct zebra_pbr_ipset *)arg; uint32_t *pnt = (uint32_t *)&ipset->ipset_name; + uint32_t key = jhash_1word(ipset->vrf_id, 0x63ab42de); - return jhash2(pnt, ZEBRA_IPSET_NAME_HASH_SIZE, 0x63ab42de); + return jhash2(pnt, ZEBRA_IPSET_NAME_HASH_SIZE, key); } bool zebra_pbr_ipset_hash_equal(const void *arg1, const void *arg2) @@ -280,6 +270,9 @@ bool zebra_pbr_ipset_hash_equal(const void *arg1, const void *arg2) return false; if (r1->unique != r2->unique) return false; + if (r1->vrf_id != r2->vrf_id) + return false; + if (strncmp(r1->ipset_name, r2->ipset_name, ZEBRA_IPSET_NAME_SIZE)) return false; @@ -289,17 +282,10 @@ bool zebra_pbr_ipset_hash_equal(const void *arg1, const void *arg2) void zebra_pbr_ipset_entry_free(void *arg) { struct zebra_pbr_ipset_entry *ipset; - struct zebra_ns *zns; ipset = (struct zebra_pbr_ipset_entry *)arg; - if (ipset->backpointer && vrf_is_backend_netns()) { - struct zebra_pbr_ipset *ips = ipset->backpointer; - zns = zebra_ns_lookup((ns_id_t)ips->vrf_id); - } else - zns = zebra_ns_lookup(NS_DEFAULT); - hook_call(zebra_pbr_ipset_entry_wrap_script_update, - zns, 0, ipset); + hook_call(zebra_pbr_ipset_entry_wrap_script_update, 0, ipset); XFREE(MTYPE_TMP, ipset); } @@ -360,15 +346,9 @@ void zebra_pbr_iptable_free(void *arg) struct zebra_pbr_iptable *iptable; struct listnode *node, *nnode; char *name; - struct zebra_ns *zns; iptable = (struct zebra_pbr_iptable *)arg; - if (vrf_is_backend_netns()) - zns = zebra_ns_lookup((ns_id_t)iptable->vrf_id); - else - zns = zebra_ns_lookup(NS_DEFAULT); - hook_call(zebra_pbr_iptable_wrap_script_update, - zns, 0, iptable); + hook_call(zebra_pbr_iptable_wrap_script_update, 0, iptable); for (ALL_LIST_ELEMENTS(iptable->interface_name_list, node, nnode, name)) { @@ -394,6 +374,8 @@ uint32_t zebra_pbr_iptable_hash_key(void *arg) key = jhash_1word(iptable->tcp_mask_flags, key); key = jhash_1word(iptable->dscp_value, key); key = jhash_1word(iptable->fragment, key); + key = jhash_1word(iptable->vrf_id, key); + return jhash_3words(iptable->filter_bm, iptable->type, iptable->unique, key); } @@ -405,6 +387,8 @@ bool zebra_pbr_iptable_hash_equal(const void *arg1, const void *arg2) r1 = (const struct zebra_pbr_iptable *)arg1; r2 = (const struct zebra_pbr_iptable *)arg2; + if (r1->vrf_id != r2->vrf_id) + return 0; if (r1->type != r2->type) return false; if (r1->unique != r2->unique) @@ -491,57 +475,48 @@ static void zebra_pbr_cleanup_rules(struct hash_backet *b, void *data) static void zebra_pbr_cleanup_ipset(struct hash_backet *b, void *data) { - struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT); struct zebra_pbr_ipset *ipset = b->data; int *sock = data; if (ipset->sock == *sock) { - hook_call(zebra_pbr_ipset_wrap_script_update, - zns, 0, ipset); - hash_release(zns->ipset_hash, ipset); + hook_call(zebra_pbr_ipset_wrap_script_update, 0, ipset); + hash_release(zrouter.ipset_hash, ipset); } } static void zebra_pbr_cleanup_ipset_entry(struct hash_backet *b, void *data) { - struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT); struct zebra_pbr_ipset_entry *ipset = b->data; int *sock = data; if (ipset->sock == *sock) { - hook_call(zebra_pbr_ipset_entry_wrap_script_update, - zns, 0, ipset); - hash_release(zns->ipset_entry_hash, ipset); + hook_call(zebra_pbr_ipset_entry_wrap_script_update, 0, ipset); + hash_release(zrouter.ipset_entry_hash, ipset); } } static void zebra_pbr_cleanup_iptable(struct hash_backet *b, void *data) { - struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT); struct zebra_pbr_iptable *iptable = b->data; int *sock = data; if (iptable->sock == *sock) { - hook_call(zebra_pbr_iptable_wrap_script_update, - zns, 0, iptable); - hash_release(zns->iptable_hash, iptable); + hook_call(zebra_pbr_iptable_wrap_script_update, 0, iptable); + hash_release(zrouter.iptable_hash, iptable); } } static int zebra_pbr_client_close_cleanup(struct zserv *client) { int sock = client->sock; - struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT); if (!sock) return 0; hash_iterate(zrouter.rules_hash, zebra_pbr_cleanup_rules, &sock); - hash_iterate(zns->iptable_hash, - zebra_pbr_cleanup_iptable, &sock); - hash_iterate(zns->ipset_entry_hash, - zebra_pbr_cleanup_ipset_entry, &sock); - hash_iterate(zns->ipset_hash, - zebra_pbr_cleanup_ipset, &sock); + hash_iterate(zrouter.iptable_hash, zebra_pbr_cleanup_iptable, &sock); + hash_iterate(zrouter.ipset_entry_hash, zebra_pbr_cleanup_ipset_entry, + &sock); + hash_iterate(zrouter.ipset_hash, zebra_pbr_cleanup_ipset, &sock); return 1; } @@ -564,29 +539,25 @@ static void *pbr_ipset_alloc_intern(void *arg) return new; } -void zebra_pbr_create_ipset(struct zebra_ns *zns, - struct zebra_pbr_ipset *ipset) +void zebra_pbr_create_ipset(struct zebra_pbr_ipset *ipset) { int ret; - (void)hash_get(zns->ipset_hash, ipset, pbr_ipset_alloc_intern); - ret = hook_call(zebra_pbr_ipset_wrap_script_update, - zns, 1, ipset); + (void)hash_get(zrouter.ipset_hash, ipset, pbr_ipset_alloc_intern); + ret = hook_call(zebra_pbr_ipset_wrap_script_update, 1, ipset); kernel_pbr_ipset_add_del_status(ipset, ret ? ZEBRA_DPLANE_INSTALL_SUCCESS : ZEBRA_DPLANE_INSTALL_FAILURE); } -void zebra_pbr_destroy_ipset(struct zebra_ns *zns, - struct zebra_pbr_ipset *ipset) +void zebra_pbr_destroy_ipset(struct zebra_pbr_ipset *ipset) { struct zebra_pbr_ipset *lookup; - lookup = hash_lookup(zns->ipset_hash, ipset); - hook_call(zebra_pbr_ipset_wrap_script_update, - zns, 0, ipset); + lookup = hash_lookup(zrouter.ipset_hash, ipset); + hook_call(zebra_pbr_ipset_wrap_script_update, 0, ipset); if (lookup) { - hash_release(zns->ipset_hash, lookup); + hash_release(zrouter.ipset_hash, lookup); XFREE(MTYPE_TMP, lookup); } else zlog_debug( @@ -619,8 +590,7 @@ static int zebra_pbr_ipset_pername_walkcb(struct hash_backet *backet, void *arg) return HASHWALK_CONTINUE; } -struct zebra_pbr_ipset *zebra_pbr_lookup_ipset_pername(struct zebra_ns *zns, - char *ipsetname) +struct zebra_pbr_ipset *zebra_pbr_lookup_ipset_pername(char *ipsetname) { struct pbr_ipset_name_lookup pinl; struct pbr_ipset_name_lookup *ptr = &pinl; @@ -630,7 +600,7 @@ struct zebra_pbr_ipset *zebra_pbr_lookup_ipset_pername(struct zebra_ns *zns, memset(ptr, 0, sizeof(struct pbr_ipset_name_lookup)); snprintf((char *)ptr->ipset_name, ZEBRA_IPSET_NAME_SIZE, "%s", ipsetname); - hash_walk(zns->ipset_hash, zebra_pbr_ipset_pername_walkcb, ptr); + hash_walk(zrouter.ipset_hash, zebra_pbr_ipset_pername_walkcb, ptr); return ptr->ipset; } @@ -648,30 +618,26 @@ static void *pbr_ipset_entry_alloc_intern(void *arg) return new; } -void zebra_pbr_add_ipset_entry(struct zebra_ns *zns, - struct zebra_pbr_ipset_entry *ipset) +void zebra_pbr_add_ipset_entry(struct zebra_pbr_ipset_entry *ipset) { int ret; - (void)hash_get(zns->ipset_entry_hash, ipset, + (void)hash_get(zrouter.ipset_entry_hash, ipset, pbr_ipset_entry_alloc_intern); - ret = hook_call(zebra_pbr_ipset_entry_wrap_script_update, - zns, 1, ipset); + ret = hook_call(zebra_pbr_ipset_entry_wrap_script_update, 1, ipset); kernel_pbr_ipset_entry_add_del_status(ipset, ret ? ZEBRA_DPLANE_INSTALL_SUCCESS : ZEBRA_DPLANE_INSTALL_FAILURE); } -void zebra_pbr_del_ipset_entry(struct zebra_ns *zns, - struct zebra_pbr_ipset_entry *ipset) +void zebra_pbr_del_ipset_entry(struct zebra_pbr_ipset_entry *ipset) { struct zebra_pbr_ipset_entry *lookup; - lookup = hash_lookup(zns->ipset_entry_hash, ipset); - hook_call(zebra_pbr_ipset_entry_wrap_script_update, - zns, 0, ipset); + lookup = hash_lookup(zrouter.ipset_entry_hash, ipset); + hook_call(zebra_pbr_ipset_entry_wrap_script_update, 0, ipset); if (lookup) { - hash_release(zns->ipset_entry_hash, lookup); + hash_release(zrouter.ipset_entry_hash, lookup); XFREE(MTYPE_TMP, lookup); } else zlog_debug("%s: IPSet being deleted we know nothing about", @@ -692,31 +658,28 @@ static void *pbr_iptable_alloc_intern(void *arg) return new; } -void zebra_pbr_add_iptable(struct zebra_ns *zns, - struct zebra_pbr_iptable *iptable) +void zebra_pbr_add_iptable(struct zebra_pbr_iptable *iptable) { int ret; - (void)hash_get(zns->iptable_hash, iptable, - pbr_iptable_alloc_intern); - ret = hook_call(zebra_pbr_iptable_wrap_script_update, zns, 1, iptable); + (void)hash_get(zrouter.iptable_hash, iptable, pbr_iptable_alloc_intern); + ret = hook_call(zebra_pbr_iptable_wrap_script_update, 1, iptable); kernel_pbr_iptable_add_del_status(iptable, ret ? ZEBRA_DPLANE_INSTALL_SUCCESS : ZEBRA_DPLANE_INSTALL_FAILURE); } -void zebra_pbr_del_iptable(struct zebra_ns *zns, - struct zebra_pbr_iptable *iptable) +void zebra_pbr_del_iptable(struct zebra_pbr_iptable *iptable) { struct zebra_pbr_iptable *lookup; - lookup = hash_lookup(zns->iptable_hash, iptable); - hook_call(zebra_pbr_iptable_wrap_script_update, zns, 0, iptable); + lookup = hash_lookup(zrouter.iptable_hash, iptable); + hook_call(zebra_pbr_iptable_wrap_script_update, 0, iptable); if (lookup) { struct listnode *node, *nnode; char *name; - hash_release(zns->iptable_hash, lookup); + hash_release(zrouter.iptable_hash, lookup); for (ALL_LIST_ELEMENTS(iptable->interface_name_list, node, nnode, name)) { XFREE(MTYPE_PBR_IPTABLE_IFNAME, name); @@ -921,7 +884,6 @@ static int zebra_pbr_show_ipset_entry_walkcb(struct hash_backet *backet, struct zebra_pbr_ipset_entry *zpie = (struct zebra_pbr_ipset_entry *)backet->data; uint64_t pkts = 0, bytes = 0; - struct zebra_ns *zns = unique->zns; int ret = 0; if (zpie->backpointer != zpi) @@ -979,8 +941,8 @@ static int zebra_pbr_show_ipset_entry_walkcb(struct hash_backet *backet, } vty_out(vty, " (%u)\n", zpie->unique); - ret = hook_call(zebra_pbr_ipset_entry_wrap_script_get_stat, - zns, zpie, &pkts, &bytes); + ret = hook_call(zebra_pbr_ipset_entry_wrap_script_get_stat, zpie, &pkts, + &bytes); if (ret && pkts > 0) vty_out(vty, "\t pkts %" PRIu64 ", bytes %" PRIu64"\n", pkts, bytes); @@ -1001,7 +963,7 @@ static int zebra_pbr_show_ipset_walkcb(struct hash_backet *backet, void *arg) unique.vty = vty; unique.zpi = zpi; unique.zns = zns; - hash_walk(zns->ipset_entry_hash, zebra_pbr_show_ipset_entry_walkcb, + hash_walk(zrouter.ipset_entry_hash, zebra_pbr_show_ipset_entry_walkcb, &unique); vty_out(vty, "\n"); return HASHWALK_CONTINUE; @@ -1037,7 +999,7 @@ void zebra_pbr_show_ipset_list(struct vty *vty, char *ipsetname) struct zebra_pbr_env_display uniqueipset; if (ipsetname) { - zpi = zebra_pbr_lookup_ipset_pername(zns, ipsetname); + zpi = zebra_pbr_lookup_ipset_pername(ipsetname); if (!zpi) { vty_out(vty, "No IPset %s found\n", ipsetname); return; @@ -1048,15 +1010,14 @@ void zebra_pbr_show_ipset_list(struct vty *vty, char *ipsetname) unique.vty = vty; unique.zpi = zpi; unique.zns = zns; - hash_walk(zns->ipset_entry_hash, - zebra_pbr_show_ipset_entry_walkcb, - &unique); + hash_walk(zrouter.ipset_entry_hash, + zebra_pbr_show_ipset_entry_walkcb, &unique); return; } uniqueipset.zns = zns; uniqueipset.vty = vty; uniqueipset.name = NULL; - hash_walk(zns->ipset_hash, zebra_pbr_show_ipset_walkcb, + hash_walk(zrouter.ipset_hash, zebra_pbr_show_ipset_walkcb, &uniqueipset); } @@ -1134,8 +1095,8 @@ static void zebra_pbr_show_iptable_unit(struct zebra_pbr_iptable *iptable, " not" : "", lookup_msg(fragment_value_str, iptable->fragment, val_str)); } - ret = hook_call(zebra_pbr_iptable_wrap_script_get_stat, - zns, iptable, &pkts, &bytes); + ret = hook_call(zebra_pbr_iptable_wrap_script_get_stat, iptable, &pkts, + &bytes); if (ret && pkts > 0) vty_out(vty, "\t pkts %" PRIu64 ", bytes %" PRIu64"\n", pkts, bytes); @@ -1182,8 +1143,7 @@ void zebra_pbr_show_iptable(struct vty *vty, char *iptable_name) env.vty = vty; env.zns = zns; env.name = iptable_name; - hash_walk(zns->iptable_hash, zebra_pbr_show_iptable_walkcb, - &env); + hash_walk(zrouter.iptable_hash, zebra_pbr_show_iptable_walkcb, &env); } void zebra_pbr_iptable_update_interfacelist(struct stream *s, diff --git a/zebra/zebra_pbr.h b/zebra/zebra_pbr.h index bc651d5114..b0791f9749 100644 --- a/zebra/zebra_pbr.h +++ b/zebra/zebra_pbr.h @@ -155,21 +155,14 @@ const char *zebra_pbr_ipset_type2str(uint32_t type); void zebra_pbr_add_rule(struct zebra_pbr_rule *rule); void zebra_pbr_del_rule(struct zebra_pbr_rule *rule); -void zebra_pbr_create_ipset(struct zebra_ns *zns, - struct zebra_pbr_ipset *ipset); -void zebra_pbr_destroy_ipset(struct zebra_ns *zns, - struct zebra_pbr_ipset *ipset); -struct zebra_pbr_ipset *zebra_pbr_lookup_ipset_pername(struct zebra_ns *zns, - char *ipsetname); -void zebra_pbr_add_ipset_entry(struct zebra_ns *zns, - struct zebra_pbr_ipset_entry *ipset); -void zebra_pbr_del_ipset_entry(struct zebra_ns *zns, - struct zebra_pbr_ipset_entry *ipset); +void zebra_pbr_create_ipset(struct zebra_pbr_ipset *ipset); +void zebra_pbr_destroy_ipset(struct zebra_pbr_ipset *ipset); +struct zebra_pbr_ipset *zebra_pbr_lookup_ipset_pername(char *ipsetname); +void zebra_pbr_add_ipset_entry(struct zebra_pbr_ipset_entry *ipset); +void zebra_pbr_del_ipset_entry(struct zebra_pbr_ipset_entry *ipset); -void zebra_pbr_add_iptable(struct zebra_ns *zns, - struct zebra_pbr_iptable *iptable); -void zebra_pbr_del_iptable(struct zebra_ns *zns, - struct zebra_pbr_iptable *iptable); +void zebra_pbr_add_iptable(struct zebra_pbr_iptable *iptable); +void zebra_pbr_del_iptable(struct zebra_pbr_iptable *iptable); /* * Install specified rule for a specific interface. @@ -243,26 +236,20 @@ extern void zebra_pbr_iptable_update_interfacelist(struct stream *s, size_t zebra_pbr_tcpflags_snprintf(char *buffer, size_t len, uint16_t tcp_val); -DECLARE_HOOK(zebra_pbr_ipset_entry_wrap_script_get_stat, (struct zebra_ns *zns, - struct zebra_pbr_ipset_entry *ipset, - uint64_t *pkts, uint64_t *bytes), - (zns, ipset, pkts, bytes)) -DECLARE_HOOK(zebra_pbr_iptable_wrap_script_get_stat, (struct zebra_ns *zns, - struct zebra_pbr_iptable *iptable, - uint64_t *pkts, uint64_t *bytes), - (zns, iptable, pkts, bytes)) -DECLARE_HOOK(zebra_pbr_iptable_wrap_script_update, (struct zebra_ns *zns, - int cmd, - struct zebra_pbr_iptable *iptable), - (zns, cmd, iptable)); +DECLARE_HOOK(zebra_pbr_ipset_entry_wrap_script_get_stat, + (struct zebra_pbr_ipset_entry *ipset, uint64_t *pkts, + uint64_t *bytes), + (ipset, pkts, bytes)) +DECLARE_HOOK(zebra_pbr_iptable_wrap_script_get_stat, + (struct zebra_pbr_iptable *iptable, uint64_t *pkts, + uint64_t *bytes), + (iptable, pkts, bytes)) +DECLARE_HOOK(zebra_pbr_iptable_wrap_script_update, + (int cmd, struct zebra_pbr_iptable *iptable), (cmd, iptable)); -DECLARE_HOOK(zebra_pbr_ipset_entry_wrap_script_update, (struct zebra_ns *zns, - int cmd, - struct zebra_pbr_ipset_entry *ipset), - (zns, cmd, ipset)); -DECLARE_HOOK(zebra_pbr_ipset_wrap_script_update, (struct zebra_ns *zns, - int cmd, - struct zebra_pbr_ipset *ipset), - (zns, cmd, ipset)); +DECLARE_HOOK(zebra_pbr_ipset_entry_wrap_script_update, + (int cmd, struct zebra_pbr_ipset_entry *ipset), (cmd, ipset)); +DECLARE_HOOK(zebra_pbr_ipset_wrap_script_update, + (int cmd, struct zebra_pbr_ipset *ipset), (cmd, ipset)); #endif /* _ZEBRA_PBR_H */ diff --git a/zebra/zebra_router.c b/zebra/zebra_router.c index 94d7ab1b8c..99d96fd67f 100644 --- a/zebra/zebra_router.c +++ b/zebra/zebra_router.c @@ -158,6 +158,13 @@ void zebra_router_terminate(void) hash_clean(zrouter.rules_hash, zebra_pbr_rules_free); hash_free(zrouter.rules_hash); + + hash_clean(zrouter.ipset_entry_hash, zebra_pbr_ipset_entry_free), + hash_clean(zrouter.ipset_hash, zebra_pbr_ipset_free); + hash_free(zrouter.ipset_hash); + hash_free(zrouter.ipset_entry_hash); + hash_clean(zrouter.iptable_hash, zebra_pbr_iptable_free); + hash_free(zrouter.iptable_hash); } void zebra_router_init(void) @@ -167,4 +174,16 @@ void zebra_router_init(void) zrouter.rules_hash = hash_create_size(8, zebra_pbr_rules_hash_key, zebra_pbr_rules_hash_equal, "Rules Hash"); + + zrouter.ipset_hash = + hash_create_size(8, zebra_pbr_ipset_hash_key, + zebra_pbr_ipset_hash_equal, "IPset Hash"); + + zrouter.ipset_entry_hash = hash_create_size( + 8, zebra_pbr_ipset_entry_hash_key, + zebra_pbr_ipset_entry_hash_equal, "IPset Hash Entry"); + + zrouter.iptable_hash = hash_create_size(8, zebra_pbr_iptable_hash_key, + zebra_pbr_iptable_hash_equal, + "IPtable Hash Entry"); } diff --git a/zebra/zebra_router.h b/zebra/zebra_router.h index 246f3857c2..6f7013acd5 100644 --- a/zebra/zebra_router.h +++ b/zebra/zebra_router.h @@ -52,6 +52,12 @@ struct zebra_router { struct hash *l3vni_table; struct hash *rules_hash; + + struct hash *ipset_hash; + + struct hash *ipset_entry_hash; + + struct hash *iptable_hash; }; extern struct zebra_router zrouter; From 1c6fca1f624bed5f7ecf559fa48fbc4640a6a14b Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Mon, 27 Aug 2018 15:28:52 -0400 Subject: [PATCH 4/5] zebra: Remove _wrap_script from hook names The _wrap_script inclusion implies a certain end functionality of which we don't care. We just care that the hooks are called. Signed-off-by: Donald Sharp --- zebra/zebra_pbr.c | 38 +++++++++++++++++++------------------- zebra/zebra_pbr.h | 10 +++++----- 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/zebra/zebra_pbr.c b/zebra/zebra_pbr.c index d774994a84..833306bcc4 100644 --- a/zebra/zebra_pbr.c +++ b/zebra/zebra_pbr.c @@ -103,23 +103,23 @@ static const struct message fragment_value_str[] = { }; /* static function declarations */ -DEFINE_HOOK(zebra_pbr_ipset_entry_wrap_script_get_stat, +DEFINE_HOOK(zebra_pbr_ipset_entry_get_stat, (struct zebra_pbr_ipset_entry *ipset, uint64_t *pkts, uint64_t *bytes), (ipset, pkts, bytes)) -DEFINE_HOOK(zebra_pbr_iptable_wrap_script_get_stat, +DEFINE_HOOK(zebra_pbr_iptable_get_stat, (struct zebra_pbr_iptable *iptable, uint64_t *pkts, uint64_t *bytes), (iptable, pkts, bytes)) -DEFINE_HOOK(zebra_pbr_iptable_wrap_script_update, +DEFINE_HOOK(zebra_pbr_iptable_update, (int cmd, struct zebra_pbr_iptable *iptable), (cmd, iptable)); -DEFINE_HOOK(zebra_pbr_ipset_entry_wrap_script_update, +DEFINE_HOOK(zebra_pbr_ipset_entry_update, (int cmd, struct zebra_pbr_ipset_entry *ipset), (cmd, ipset)); -DEFINE_HOOK(zebra_pbr_ipset_wrap_script_update, +DEFINE_HOOK(zebra_pbr_ipset_update, (int cmd, struct zebra_pbr_ipset *ipset), (cmd, ipset)); /* Private functions */ @@ -246,7 +246,7 @@ void zebra_pbr_ipset_free(void *arg) struct zebra_pbr_ipset *ipset; ipset = (struct zebra_pbr_ipset *)arg; - hook_call(zebra_pbr_ipset_wrap_script_update, 0, ipset); + hook_call(zebra_pbr_ipset_update, 0, ipset); XFREE(MTYPE_TMP, ipset); } @@ -285,7 +285,7 @@ void zebra_pbr_ipset_entry_free(void *arg) ipset = (struct zebra_pbr_ipset_entry *)arg; - hook_call(zebra_pbr_ipset_entry_wrap_script_update, 0, ipset); + hook_call(zebra_pbr_ipset_entry_update, 0, ipset); XFREE(MTYPE_TMP, ipset); } @@ -348,7 +348,7 @@ void zebra_pbr_iptable_free(void *arg) char *name; iptable = (struct zebra_pbr_iptable *)arg; - hook_call(zebra_pbr_iptable_wrap_script_update, 0, iptable); + hook_call(zebra_pbr_iptable_update, 0, iptable); for (ALL_LIST_ELEMENTS(iptable->interface_name_list, node, nnode, name)) { @@ -479,7 +479,7 @@ static void zebra_pbr_cleanup_ipset(struct hash_backet *b, void *data) int *sock = data; if (ipset->sock == *sock) { - hook_call(zebra_pbr_ipset_wrap_script_update, 0, ipset); + hook_call(zebra_pbr_ipset_update, 0, ipset); hash_release(zrouter.ipset_hash, ipset); } } @@ -490,7 +490,7 @@ static void zebra_pbr_cleanup_ipset_entry(struct hash_backet *b, void *data) int *sock = data; if (ipset->sock == *sock) { - hook_call(zebra_pbr_ipset_entry_wrap_script_update, 0, ipset); + hook_call(zebra_pbr_ipset_entry_update, 0, ipset); hash_release(zrouter.ipset_entry_hash, ipset); } } @@ -501,7 +501,7 @@ static void zebra_pbr_cleanup_iptable(struct hash_backet *b, void *data) int *sock = data; if (iptable->sock == *sock) { - hook_call(zebra_pbr_iptable_wrap_script_update, 0, iptable); + hook_call(zebra_pbr_iptable_update, 0, iptable); hash_release(zrouter.iptable_hash, iptable); } } @@ -544,7 +544,7 @@ void zebra_pbr_create_ipset(struct zebra_pbr_ipset *ipset) int ret; (void)hash_get(zrouter.ipset_hash, ipset, pbr_ipset_alloc_intern); - ret = hook_call(zebra_pbr_ipset_wrap_script_update, 1, ipset); + ret = hook_call(zebra_pbr_ipset_update, 1, ipset); kernel_pbr_ipset_add_del_status(ipset, ret ? ZEBRA_DPLANE_INSTALL_SUCCESS : ZEBRA_DPLANE_INSTALL_FAILURE); @@ -555,7 +555,7 @@ void zebra_pbr_destroy_ipset(struct zebra_pbr_ipset *ipset) struct zebra_pbr_ipset *lookup; lookup = hash_lookup(zrouter.ipset_hash, ipset); - hook_call(zebra_pbr_ipset_wrap_script_update, 0, ipset); + hook_call(zebra_pbr_ipset_update, 0, ipset); if (lookup) { hash_release(zrouter.ipset_hash, lookup); XFREE(MTYPE_TMP, lookup); @@ -624,7 +624,7 @@ void zebra_pbr_add_ipset_entry(struct zebra_pbr_ipset_entry *ipset) (void)hash_get(zrouter.ipset_entry_hash, ipset, pbr_ipset_entry_alloc_intern); - ret = hook_call(zebra_pbr_ipset_entry_wrap_script_update, 1, ipset); + ret = hook_call(zebra_pbr_ipset_entry_update, 1, ipset); kernel_pbr_ipset_entry_add_del_status(ipset, ret ? ZEBRA_DPLANE_INSTALL_SUCCESS : ZEBRA_DPLANE_INSTALL_FAILURE); @@ -635,7 +635,7 @@ void zebra_pbr_del_ipset_entry(struct zebra_pbr_ipset_entry *ipset) struct zebra_pbr_ipset_entry *lookup; lookup = hash_lookup(zrouter.ipset_entry_hash, ipset); - hook_call(zebra_pbr_ipset_entry_wrap_script_update, 0, ipset); + hook_call(zebra_pbr_ipset_entry_update, 0, ipset); if (lookup) { hash_release(zrouter.ipset_entry_hash, lookup); XFREE(MTYPE_TMP, lookup); @@ -663,7 +663,7 @@ void zebra_pbr_add_iptable(struct zebra_pbr_iptable *iptable) int ret; (void)hash_get(zrouter.iptable_hash, iptable, pbr_iptable_alloc_intern); - ret = hook_call(zebra_pbr_iptable_wrap_script_update, 1, iptable); + ret = hook_call(zebra_pbr_iptable_update, 1, iptable); kernel_pbr_iptable_add_del_status(iptable, ret ? ZEBRA_DPLANE_INSTALL_SUCCESS : ZEBRA_DPLANE_INSTALL_FAILURE); @@ -674,7 +674,7 @@ void zebra_pbr_del_iptable(struct zebra_pbr_iptable *iptable) struct zebra_pbr_iptable *lookup; lookup = hash_lookup(zrouter.iptable_hash, iptable); - hook_call(zebra_pbr_iptable_wrap_script_update, 0, iptable); + hook_call(zebra_pbr_iptable_update, 0, iptable); if (lookup) { struct listnode *node, *nnode; char *name; @@ -941,7 +941,7 @@ static int zebra_pbr_show_ipset_entry_walkcb(struct hash_backet *backet, } vty_out(vty, " (%u)\n", zpie->unique); - ret = hook_call(zebra_pbr_ipset_entry_wrap_script_get_stat, zpie, &pkts, + ret = hook_call(zebra_pbr_ipset_entry_get_stat, zpie, &pkts, &bytes); if (ret && pkts > 0) vty_out(vty, "\t pkts %" PRIu64 ", bytes %" PRIu64"\n", @@ -1095,7 +1095,7 @@ static void zebra_pbr_show_iptable_unit(struct zebra_pbr_iptable *iptable, " not" : "", lookup_msg(fragment_value_str, iptable->fragment, val_str)); } - ret = hook_call(zebra_pbr_iptable_wrap_script_get_stat, iptable, &pkts, + ret = hook_call(zebra_pbr_iptable_get_stat, iptable, &pkts, &bytes); if (ret && pkts > 0) vty_out(vty, "\t pkts %" PRIu64 ", bytes %" PRIu64"\n", diff --git a/zebra/zebra_pbr.h b/zebra/zebra_pbr.h index b0791f9749..5b6c23896c 100644 --- a/zebra/zebra_pbr.h +++ b/zebra/zebra_pbr.h @@ -236,20 +236,20 @@ extern void zebra_pbr_iptable_update_interfacelist(struct stream *s, size_t zebra_pbr_tcpflags_snprintf(char *buffer, size_t len, uint16_t tcp_val); -DECLARE_HOOK(zebra_pbr_ipset_entry_wrap_script_get_stat, +DECLARE_HOOK(zebra_pbr_ipset_entry_get_stat, (struct zebra_pbr_ipset_entry *ipset, uint64_t *pkts, uint64_t *bytes), (ipset, pkts, bytes)) -DECLARE_HOOK(zebra_pbr_iptable_wrap_script_get_stat, +DECLARE_HOOK(zebra_pbr_iptable_get_stat, (struct zebra_pbr_iptable *iptable, uint64_t *pkts, uint64_t *bytes), (iptable, pkts, bytes)) -DECLARE_HOOK(zebra_pbr_iptable_wrap_script_update, +DECLARE_HOOK(zebra_pbr_iptable_update, (int cmd, struct zebra_pbr_iptable *iptable), (cmd, iptable)); -DECLARE_HOOK(zebra_pbr_ipset_entry_wrap_script_update, +DECLARE_HOOK(zebra_pbr_ipset_entry_update, (int cmd, struct zebra_pbr_ipset_entry *ipset), (cmd, ipset)); -DECLARE_HOOK(zebra_pbr_ipset_wrap_script_update, +DECLARE_HOOK(zebra_pbr_ipset_update, (int cmd, struct zebra_pbr_ipset *ipset), (cmd, ipset)); #endif /* _ZEBRA_PBR_H */ From a3be9fa1a70eb68608fc67d1b406e7a91702fcd3 Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Mon, 27 Aug 2018 15:34:36 -0400 Subject: [PATCH 5/5] zebra: Move rtadv to zebra_router The rtadv setting was not per namespace it is per router. Signed-off-by: Donald Sharp --- zebra/rtadv.c | 63 ++++++++++++++++++++------------------------ zebra/zebra_ns.h | 4 --- zebra/zebra_router.h | 4 +++ 3 files changed, 32 insertions(+), 39 deletions(-) diff --git a/zebra/rtadv.c b/zebra/rtadv.c index 3bb75f3446..a22f6395c9 100644 --- a/zebra/rtadv.c +++ b/zebra/rtadv.c @@ -45,6 +45,7 @@ #include "zebra/zebra_ns.h" #include "zebra/zebra_vrf.h" #include "zebra/zebra_errors.h" +#include "zebra/zebra_router.h" extern struct zebra_privs_t zserv_privs; @@ -391,8 +392,8 @@ static int rtadv_timer(struct thread *thread) struct zebra_if *zif; int period; - zns->rtadv.ra_timer = NULL; - if (zns->rtadv.adv_msec_if_count == 0) { + zrouter.rtadv.ra_timer = NULL; + if (zrouter.rtadv.adv_msec_if_count == 0) { period = 1000; /* 1 s */ rtadv_event(zns, RTADV_TIMER, 1 /* 1 s */); } else { @@ -424,7 +425,8 @@ static int rtadv_timer(struct thread *thread) "Fast RA Rexmit on interface %s", ifp->name); - rtadv_send_packet(zns->rtadv.sock, ifp); + rtadv_send_packet(zrouter.rtadv.sock, + ifp); } else { zif->rtadv.AdvIntervalTimer -= period; if (zif->rtadv.AdvIntervalTimer <= 0) { @@ -437,7 +439,8 @@ static int rtadv_timer(struct thread *thread) zif->rtadv .MaxRtrAdvInterval; rtadv_send_packet( - zns->rtadv.sock, ifp); + zrouter.rtadv.sock, + ifp); } } } @@ -452,7 +455,7 @@ static void rtadv_process_solicit(struct interface *ifp) struct zebra_ns *zns = zvrf->zns; assert(zns); - rtadv_send_packet(zns->rtadv.sock, ifp); + rtadv_send_packet(zrouter.rtadv.sock, ifp); } /* @@ -649,7 +652,7 @@ static int rtadv_read(struct thread *thread) struct zebra_ns *zns = THREAD_ARG(thread); sock = THREAD_FD(thread); - zns->rtadv.ra_read = NULL; + zrouter.rtadv.ra_read = NULL; /* Register myself. */ rtadv_event(zns, RTADV_READ, sock); @@ -808,18 +811,18 @@ static void ipv6_nd_suppress_ra_set(struct interface *ifp, if (zif->rtadv.AdvSendAdvertisements) { zif->rtadv.AdvSendAdvertisements = 0; zif->rtadv.AdvIntervalTimer = 0; - zns->rtadv.adv_if_count--; + zrouter.rtadv.adv_if_count--; - if_leave_all_router(zns->rtadv.sock, ifp); + if_leave_all_router(zrouter.rtadv.sock, ifp); - if (zns->rtadv.adv_if_count == 0) + if (zrouter.rtadv.adv_if_count == 0) rtadv_event(zns, RTADV_STOP, 0); } } else { if (!zif->rtadv.AdvSendAdvertisements) { zif->rtadv.AdvSendAdvertisements = 1; zif->rtadv.AdvIntervalTimer = 0; - zns->rtadv.adv_if_count++; + zrouter.rtadv.adv_if_count++; if (zif->rtadv.MaxRtrAdvInterval >= 1000) { /* Enable Fast RA only when RA interval is in @@ -829,10 +832,11 @@ static void ipv6_nd_suppress_ra_set(struct interface *ifp, RTADV_NUM_FAST_REXMITS; } - if_join_all_router(zns->rtadv.sock, ifp); + if_join_all_router(zrouter.rtadv.sock, ifp); - if (zns->rtadv.adv_if_count == 1) - rtadv_event(zns, RTADV_START, zns->rtadv.sock); + if (zrouter.rtadv.adv_if_count == 1) + rtadv_event(zns, RTADV_START, + zrouter.rtadv.sock); } } } @@ -972,10 +976,7 @@ DEFUN (ipv6_nd_ra_interval_msec, VTY_DECLVAR_CONTEXT(interface, ifp); unsigned interval; struct zebra_if *zif = ifp->info; - struct zebra_vrf *zvrf = vrf_info_lookup(ifp->vrf_id); - struct zebra_ns *zns; - zns = zvrf->zns; interval = strtoul(argv[idx_number]->arg, NULL, 10); if ((zif->rtadv.AdvDefaultLifetime != -1 && interval > (unsigned)zif->rtadv.AdvDefaultLifetime * 1000)) { @@ -985,10 +986,10 @@ DEFUN (ipv6_nd_ra_interval_msec, } if (zif->rtadv.MaxRtrAdvInterval % 1000) - zns->rtadv.adv_msec_if_count--; + zrouter.rtadv.adv_msec_if_count--; if (interval % 1000) - zns->rtadv.adv_msec_if_count++; + zrouter.rtadv.adv_msec_if_count++; SET_FLAG(zif->rtadv.ra_configured, VTY_RA_INTERVAL_CONFIGURED); zif->rtadv.MaxRtrAdvInterval = interval; @@ -1010,10 +1011,7 @@ DEFUN (ipv6_nd_ra_interval, VTY_DECLVAR_CONTEXT(interface, ifp); unsigned interval; struct zebra_if *zif = ifp->info; - struct zebra_vrf *zvrf = vrf_info_lookup(ifp->vrf_id); - struct zebra_ns *zns; - zns = zvrf->zns; interval = strtoul(argv[idx_number]->arg, NULL, 10); if ((zif->rtadv.AdvDefaultLifetime != -1 && interval > (unsigned)zif->rtadv.AdvDefaultLifetime)) { @@ -1023,7 +1021,7 @@ DEFUN (ipv6_nd_ra_interval, } if (zif->rtadv.MaxRtrAdvInterval % 1000) - zns->rtadv.adv_msec_if_count--; + zrouter.rtadv.adv_msec_if_count--; /* convert to milliseconds */ interval = interval * 1000; @@ -1049,14 +1047,9 @@ DEFUN (no_ipv6_nd_ra_interval, { VTY_DECLVAR_CONTEXT(interface, ifp); struct zebra_if *zif = ifp->info; - struct zebra_vrf *zvrf; - struct zebra_ns *zns; - - zvrf = vrf_info_lookup(ifp->vrf_id); - zns = zvrf->zns; if (zif->rtadv.MaxRtrAdvInterval % 1000) - zns->rtadv.adv_msec_if_count--; + zrouter.rtadv.adv_msec_if_count--; UNSET_FLAG(zif->rtadv.ra_configured, VTY_RA_INTERVAL_CONFIGURED); @@ -1701,7 +1694,7 @@ static int rtadv_config_write(struct vty *vty, struct interface *ifp) static void rtadv_event(struct zebra_ns *zns, enum rtadv_event event, int val) { - struct rtadv *rtadv = &zns->rtadv; + struct rtadv *rtadv = &zrouter.rtadv; switch (event) { case RTADV_START: @@ -1740,19 +1733,19 @@ static void rtadv_event(struct zebra_ns *zns, enum rtadv_event event, int val) void rtadv_init(struct zebra_ns *zns) { - zns->rtadv.sock = rtadv_make_socket(zns->ns_id); + zrouter.rtadv.sock = rtadv_make_socket(zns->ns_id); } void rtadv_terminate(struct zebra_ns *zns) { rtadv_event(zns, RTADV_STOP, 0); - if (zns->rtadv.sock >= 0) { - close(zns->rtadv.sock); - zns->rtadv.sock = -1; + if (zrouter.rtadv.sock >= 0) { + close(zrouter.rtadv.sock); + zrouter.rtadv.sock = -1; } - zns->rtadv.adv_if_count = 0; - zns->rtadv.adv_msec_if_count = 0; + zrouter.rtadv.adv_if_count = 0; + zrouter.rtadv.adv_msec_if_count = 0; } void rtadv_cmd_init(void) diff --git a/zebra/zebra_ns.h b/zebra/zebra_ns.h index 2498be7162..c1a9b41b8d 100644 --- a/zebra/zebra_ns.h +++ b/zebra/zebra_ns.h @@ -53,10 +53,6 @@ struct zebra_ns { struct route_table *if_table; -#if defined(HAVE_RTADV) - struct rtadv rtadv; -#endif /* HAVE_RTADV */ - /* Back pointer */ struct ns *ns; }; diff --git a/zebra/zebra_router.h b/zebra/zebra_router.h index 6f7013acd5..d6b8b66087 100644 --- a/zebra/zebra_router.h +++ b/zebra/zebra_router.h @@ -58,6 +58,10 @@ struct zebra_router { struct hash *ipset_entry_hash; struct hash *iptable_hash; + +#if defined(HAVE_RTADV) + struct rtadv rtadv; +#endif /* HAVE_RTADV */ }; extern struct zebra_router zrouter;