zebra: rename vni to evpn where appropriate

The main zebra_vni_t hash structure has been renamed to zebra_evpn_t
to allow for other transport underlays. Rename functions and variables
to reflect this change.

Signed-off-by: Pat Ruddy <pat@voltanet.io>

diff --git a/zebra/zebra_evpn_mh.c b/zebra/zebra_evpn_mh.c
index fae36ec6fac7cbe28d2e325dc76f4b6c412314f1..d5ad15ce02ef6a55f2ff88fdacc92794f3480da2 100644 (file)
--- a/zebra/zebra_evpn_mh.c
+++ b/zebra/zebra_evpn_mh.c
@@ -55,9 +55,9 @@ DEFINE_MTYPE_STATIC(ZEBRA, ZES_EVI, "ES info per-EVI");
 DEFINE_MTYPE_STATIC(ZEBRA, ZMH_INFO, "MH global info");
 DEFINE_MTYPE_STATIC(ZEBRA, ZES_VTEP, "VTEP attached to the ES");
 
-static void zebra_evpn_es_get_one_base_vni(void);
+static void zebra_evpn_es_get_one_base_evpn(void);
 static int zebra_evpn_es_evi_send_to_client(struct zebra_evpn_es *es,
-               zebra_vni_t *vni, bool add);
+               zebra_evpn_t *zevpn, bool add);
 static void zebra_evpn_local_es_del(struct zebra_evpn_es *es);
 static int zebra_evpn_local_es_update(struct zebra_if *zif, uint32_t lid,
                struct ethaddr *sysmac);
@@ -67,7 +67,7 @@ esi_t zero_esi_buf, *zero_esi = &zero_esi_buf;
 /*****************************************************************************/
 /* Ethernet Segment to EVI association -
  * 1. The ES-EVI entry is maintained as a RB tree per L2-VNI
- * (zebra_vni_t.es_evi_rb_tree).
+ * (zebra_evpn_t.es_evi_rb_tree).
  * 2. Each local ES-EVI entry is sent to BGP which advertises it as an
  * EAD-EVI (Type-1 EVPN) route
  * 3. Local ES-EVI setup is re-evaluated on the following triggers -
@@ -81,7 +81,7 @@ esi_t zero_esi_buf, *zero_esi = &zero_esi_buf;
  * is then sent to zebra which allocates a NHG for it.
  */
 
-/* compare ES-IDs for the ES-EVI RB tree maintained per-VNI */
+/* compare ES-IDs for the ES-EVI RB tree maintained per-EVPN */
 static int zebra_es_evi_rb_cmp(const struct zebra_evpn_es_evi *es_evi1,
                const struct zebra_evpn_es_evi *es_evi2)
 {
@@ -94,17 +94,17 @@ RB_GENERATE(zebra_es_evi_rb_head, zebra_evpn_es_evi,
  * tables.
  */
 static struct zebra_evpn_es_evi *zebra_evpn_es_evi_new(struct zebra_evpn_es *es,
-               zebra_vni_t *zvni)
+               zebra_evpn_t *zevpn)
 {
        struct zebra_evpn_es_evi *es_evi;
 
        es_evi = XCALLOC(MTYPE_ZES_EVI, sizeof(struct zebra_evpn_es_evi));
 
        es_evi->es = es;
-       es_evi->zvni = zvni;
+       es_evi->zevpn = zevpn;
 
-       /* insert into the VNI-ESI rb tree */
-       if (RB_INSERT(zebra_es_evi_rb_head, &zvni->es_evi_rb_tree, es_evi)) {
+       /* insert into the EVPN-ESI rb tree */
+       if (RB_INSERT(zebra_es_evi_rb_head, &zevpn->es_evi_rb_tree, es_evi)) {
                XFREE(MTYPE_ZES_EVI, es_evi);
                return NULL;
        }
@@ -115,15 +115,15 @@ static struct zebra_evpn_es_evi *zebra_evpn_es_evi_new(struct zebra_evpn_es *es,
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("es %s evi %d new",
-                               es_evi->es->esi_str, es_evi->zvni->vni);
+                               es_evi->es->esi_str, es_evi->zevpn->vni);
 
        return es_evi;
 }
 
-/* returns TRUE if the VNI is ready to be sent to BGP */
-static inline bool zebra_evpn_vni_send_to_client_ok(zebra_vni_t *zvni)
+/* returns TRUE if the EVPN is ready to be sent to BGP */
+static inline bool zebra_evpn_send_to_client_ok(zebra_evpn_t *zevpn)
 {
-       return !!(zvni->flags & ZVNI_READY_FOR_BGP);
+       return !!(zevpn->flags & ZEVPN_READY_FOR_BGP);
 }
 
 /* Evaluate if the es_evi is ready to be sent BGP -
@@ -142,7 +142,7 @@ static void zebra_evpn_es_evi_re_eval_send_to_client(
        /* ES and L2-VNI have to be individually ready for BGP */
        if ((es_evi->flags & ZEBRA_EVPNES_EVI_LOCAL) &&
                        (es_evi->es->flags & ZEBRA_EVPNES_READY_FOR_BGP) &&
-                       zebra_evpn_vni_send_to_client_ok(es_evi->zvni))
+                       zebra_evpn_send_to_client_ok(es_evi->zevpn))
                es_evi->flags |= ZEBRA_EVPNES_EVI_READY_FOR_BGP;
        else
                es_evi->flags &= ~ZEBRA_EVPNES_EVI_READY_FOR_BGP;
@@ -153,10 +153,10 @@ static void zebra_evpn_es_evi_re_eval_send_to_client(
                return;
 
        if (new_ready)
-               zebra_evpn_es_evi_send_to_client(es_evi->es, es_evi->zvni,
+               zebra_evpn_es_evi_send_to_client(es_evi->es, es_evi->zevpn,
                                true /* add */);
        else
-               zebra_evpn_es_evi_send_to_client(es_evi->es, es_evi->zvni,
+               zebra_evpn_es_evi_send_to_client(es_evi->es, es_evi->zevpn,
                                false /* add */);
 }
 
@@ -166,17 +166,17 @@ static void zebra_evpn_es_evi_re_eval_send_to_client(
 static void zebra_evpn_es_evi_free(struct zebra_evpn_es_evi *es_evi)
 {
        struct zebra_evpn_es *es = es_evi->es;
-       zebra_vni_t *zvni = es_evi->zvni;
+       zebra_evpn_t *zevpn = es_evi->zevpn;
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("es %s evi %d free",
-                               es_evi->es->esi_str, es_evi->zvni->vni);
+                               es_evi->es->esi_str, es_evi->zevpn->vni);
 
        /* remove from the ES's VNI list */
        list_delete_node(es->es_evi_list, &es_evi->es_listnode);
 
        /* remove from the VNI-ESI rb tree */
-       RB_REMOVE(zebra_es_evi_rb_head, &zvni->es_evi_rb_tree, es_evi);
+       RB_REMOVE(zebra_es_evi_rb_head, &zevpn->es_evi_rb_tree, es_evi);
 
        /* remove from the VNI-ESI rb tree */
        XFREE(MTYPE_ZES_EVI, es_evi);
@@ -184,13 +184,13 @@ static void zebra_evpn_es_evi_free(struct zebra_evpn_es_evi *es_evi)
 
 /* find the ES-EVI in the per-L2-VNI RB tree */
 static struct zebra_evpn_es_evi *zebra_evpn_es_evi_find(
-               struct zebra_evpn_es *es, zebra_vni_t *zvni)
+               struct zebra_evpn_es *es, zebra_evpn_t *zevpn)
 {
        struct zebra_evpn_es_evi es_evi;
 
        es_evi.es = es;
 
-       return RB_FIND(zebra_es_evi_rb_head, &zvni->es_evi_rb_tree, &es_evi);
+       return RB_FIND(zebra_es_evi_rb_head, &zevpn->es_evi_rb_tree, &es_evi);
 }
 
 /* Tell BGP about an ES-EVI deletion and then delete it */
@@ -201,50 +201,50 @@ static void zebra_evpn_local_es_evi_do_del(struct zebra_evpn_es_evi *es_evi)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("local es %s evi %d del",
-                               es_evi->es->esi_str, es_evi->zvni->vni);
+                               es_evi->es->esi_str, es_evi->zevpn->vni);
 
        if (es_evi->flags & ZEBRA_EVPNES_EVI_READY_FOR_BGP) {
                /* send a del only if add was sent for it earlier */
                zebra_evpn_es_evi_send_to_client(es_evi->es,
-                               es_evi->zvni, false /* add */);
+                               es_evi->zevpn, false /* add */);
        }
 
-       /* delete it from the VNI's local list */
-       list_delete_node(es_evi->zvni->local_es_evi_list,
+       /* delete it from the EVPN's local list */
+       list_delete_node(es_evi->zevpn->local_es_evi_list,
                        &es_evi->l2vni_listnode);
 
        es_evi->flags &= ~ZEBRA_EVPNES_EVI_LOCAL;
        zebra_evpn_es_evi_free(es_evi);
 }
 static void zebra_evpn_local_es_evi_del(struct zebra_evpn_es *es,
-               zebra_vni_t *zvni)
+               zebra_evpn_t *zevpn)
 {
        struct zebra_evpn_es_evi *es_evi;
 
-       es_evi = zebra_evpn_es_evi_find(es, zvni);
+       es_evi = zebra_evpn_es_evi_find(es, zevpn);
        if (es_evi)
                zebra_evpn_local_es_evi_do_del(es_evi);
 }
 
 /* Create an ES-EVI if it doesn't already exist and tell BGP */
 static void zebra_evpn_local_es_evi_add(struct zebra_evpn_es *es,
-               zebra_vni_t *zvni)
+               zebra_evpn_t *zevpn)
 {
        struct zebra_evpn_es_evi *es_evi;
 
-       es_evi = zebra_evpn_es_evi_find(es, zvni);
+       es_evi = zebra_evpn_es_evi_find(es, zevpn);
        if (!es_evi) {
-               es_evi = zebra_evpn_es_evi_new(es, zvni);
+               es_evi = zebra_evpn_es_evi_new(es, zevpn);
                if (!es_evi)
                        return;
 
                if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                        zlog_debug("local es %s evi %d add",
-                                       es_evi->es->esi_str, es_evi->zvni->vni);
+                                       es_evi->es->esi_str, es_evi->zevpn->vni);
                es_evi->flags |= ZEBRA_EVPNES_EVI_LOCAL;
-               /* add to the VNI's local list */
+               /* add to the EVPN's local list */
                listnode_init(&es_evi->l2vni_listnode, es_evi);
-               listnode_add(zvni->local_es_evi_list, &es_evi->l2vni_listnode);
+               listnode_add(zevpn->local_es_evi_list, &es_evi->l2vni_listnode);
 
                zebra_evpn_es_evi_re_eval_send_to_client(es_evi);
        }
@@ -263,7 +263,7 @@ static void zebra_evpn_es_evi_show_entry(struct vty *vty,
                        strlcat(type_str, "L", sizeof(type_str));
 
                vty_out(vty, "%-8d %-30s %-4s\n",
-                               es_evi->zvni->vni, es_evi->es->esi_str,
+                               es_evi->zevpn->vni, es_evi->es->esi_str,
                                type_str);
        }
 }
@@ -281,7 +281,7 @@ static void zebra_evpn_es_evi_show_entry_detail(struct vty *vty,
                        strlcat(type_str, "L", sizeof(type_str));
 
                vty_out(vty, "VNI %d ESI: %s\n",
-                               es_evi->zvni->vni, es_evi->es->esi_str);
+                               es_evi->zevpn->vni, es_evi->es->esi_str);
                vty_out(vty, " Type: %s\n", type_str);
                vty_out(vty, " Ready for BGP: %s\n",
                                (es_evi->flags &
@@ -291,12 +291,12 @@ static void zebra_evpn_es_evi_show_entry_detail(struct vty *vty,
        }
 }
 
-static void zebra_evpn_es_evi_show_one_vni(zebra_vni_t *zvni,
+static void zebra_evpn_es_evi_show_one_evpn(zebra_evpn_t *zevpn,
                struct vty *vty, json_object *json, int detail)
 {
        struct zebra_evpn_es_evi *es_evi;
 
-       RB_FOREACH(es_evi, zebra_es_evi_rb_head, &zvni->es_evi_rb_tree) {
+       RB_FOREACH(es_evi, zebra_es_evi_rb_head, &zevpn->es_evi_rb_tree) {
                if (detail)
                        zebra_evpn_es_evi_show_entry_detail(vty, es_evi, json);
                else
@@ -310,13 +310,13 @@ struct evpn_mh_show_ctx {
        int detail;
 };
 
-static void zebra_evpn_es_evi_show_one_vni_hash_cb(struct hash_bucket *bucket,
+static void zebra_evpn_es_evi_show_one_evpn_hash_cb(struct hash_bucket *bucket,
                void *ctxt)
 {
-       zebra_vni_t *zvni = (zebra_vni_t *)bucket->data;
+       zebra_evpn_t *zevpn = (zebra_evpn_t *)bucket->data;
        struct evpn_mh_show_ctx *wctx = (struct evpn_mh_show_ctx *)ctxt;
 
-       zebra_evpn_es_evi_show_one_vni(zvni, wctx->vty,
+       zebra_evpn_es_evi_show_one_evpn(zevpn, wctx->vty,
                        wctx->json, wctx->detail);
 }
 
@@ -338,71 +338,71 @@ void zebra_evpn_es_evi_show(struct vty *vty, bool uj, int detail)
                vty_out(vty, "%-8s %-30s %-4s\n", "VNI", "ESI", "Type");
        }
        /* Display all L2-VNIs */
-       hash_iterate(zvrf->vni_table, zebra_evpn_es_evi_show_one_vni_hash_cb,
+       hash_iterate(zvrf->evpn_table, zebra_evpn_es_evi_show_one_evpn_hash_cb,
                        &wctx);
 }
 
 void zebra_evpn_es_evi_show_vni(struct vty *vty, bool uj, vni_t vni, int detail)
 {
        json_object *json = NULL;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
 
-       zvni = zvni_lookup(vni);
-       if (zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (zevpn) {
                if (!detail && !json) {
                        vty_out(vty, "Type: L local, R remote\n");
                        vty_out(vty, "%-8s %-30s %-4s\n", "VNI", "ESI", "Type");
                }
        } else {
                if (!uj)
-                       vty_out(vty, "VNI %d doesn't exist\n", vni);
+                       vty_out(vty, "VNI %d doesn't exist\n", zevpn->vni);
        }
-       zebra_evpn_es_evi_show_one_vni(zvni, vty, json, detail);
+       zebra_evpn_es_evi_show_one_evpn(zevpn, vty, json, detail);
 }
 
 /* Initialize the ES tables maintained per-L2_VNI */
-void zebra_evpn_vni_es_init(zebra_vni_t *zvni)
+void zebra_evpn_evpn_es_init(zebra_evpn_t *zevpn)
 {
        /* Initialize the ES-EVI RB tree */
-       RB_INIT(zebra_es_evi_rb_head, &zvni->es_evi_rb_tree);
+       RB_INIT(zebra_es_evi_rb_head, &zevpn->es_evi_rb_tree);
 
        /* Initialize the local and remote ES lists maintained for quick
         * walks by type
         */
-       zvni->local_es_evi_list = list_new();
-       listset_app_node_mem(zvni->local_es_evi_list);
+       zevpn->local_es_evi_list = list_new();
+       listset_app_node_mem(zevpn->local_es_evi_list);
 }
 
-/* Cleanup the ES info maintained per-L2_VNI */
-void zebra_evpn_vni_es_cleanup(zebra_vni_t *zvni)
+/* Cleanup the ES info maintained per- EVPN */
+void zebra_evpn_evpn_es_cleanup(zebra_evpn_t *zevpn)
 {
        struct zebra_evpn_es_evi *es_evi;
        struct zebra_evpn_es_evi *es_evi_next;
 
        RB_FOREACH_SAFE(es_evi, zebra_es_evi_rb_head,
-                       &zvni->es_evi_rb_tree, es_evi_next) {
+                       &zevpn->es_evi_rb_tree, es_evi_next) {
                zebra_evpn_local_es_evi_do_del(es_evi);
        }
 
-       list_delete(&zvni->local_es_evi_list);
-       zebra_evpn_es_clear_base_vni(zvni);
+       list_delete(&zevpn->local_es_evi_list);
+       zebra_evpn_es_clear_base_evpn(zevpn);
 }
 
 /* called when the oper state or bridge membership changes for the
  * vxlan device
  */
-void zebra_evpn_vni_update_all_es(zebra_vni_t *zvni)
+void zebra_evpn_update_all_es(zebra_evpn_t *zevpn)
 {
        struct zebra_evpn_es_evi *es_evi;
        struct listnode *node;
 
-       /* the VNI is now elgible as a base for EVPN-MH */
-       if (zebra_evpn_vni_send_to_client_ok(zvni))
-               zebra_evpn_es_set_base_vni(zvni);
+       /* the EVPN is now elgible as a base for EVPN-MH */
+       if (zebra_evpn_send_to_client_ok(zevpn))
+               zebra_evpn_es_set_base_evpn(zevpn);
        else
-               zebra_evpn_es_clear_base_vni(zvni);
+               zebra_evpn_es_clear_base_evpn(zevpn);
 
-       for (ALL_LIST_ELEMENTS_RO(zvni->local_es_evi_list, node, es_evi))
+       for (ALL_LIST_ELEMENTS_RO(zevpn->local_es_evi_list, node, es_evi))
                zebra_evpn_es_evi_re_eval_send_to_client(es_evi);
 }
 
@@ -514,24 +514,24 @@ static void zebra_evpn_acc_bd_free_on_deref(struct zebra_evpn_access_bd *acc_bd)
 }
 
 /* called when a EVPN-L2VNI is set or cleared against a BD */
-static void zebra_evpn_acc_bd_vni_set(struct zebra_evpn_access_bd *acc_bd,
-               zebra_vni_t *zvni, zebra_vni_t *old_zvni)
+static void zebra_evpn_acc_bd_evpn_set(struct zebra_evpn_access_bd *acc_bd,
+               zebra_evpn_t *zevpn, zebra_evpn_t *old_zevpn)
 {
        struct zebra_if *zif;
        struct listnode *node;
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("access vlan %d l2-vni %u set",
-                               acc_bd->vid, zvni ? zvni->vni : 0);
+                               acc_bd->vid, zevpn ? zevpn->vni : 0);
 
        for (ALL_LIST_ELEMENTS_RO(acc_bd->mbr_zifs, node, zif)) {
                if (!zif->es_info.es)
                        continue;
 
-               if (zvni)
-                       zebra_evpn_local_es_evi_add(zif->es_info.es, zvni);
-               else if (old_zvni)
-                       zebra_evpn_local_es_evi_del(zif->es_info.es, old_zvni);
+               if (zevpn)
+                       zebra_evpn_local_es_evi_add(zif->es_info.es, zevpn);
+               else if (old_zevpn)
+                       zebra_evpn_local_es_evi_del(zif->es_info.es, old_zevpn);
        }
 }
 
@@ -540,7 +540,7 @@ void zebra_evpn_vl_vxl_ref(uint16_t vid, struct zebra_if *vxlan_zif)
 {
        struct zebra_evpn_access_bd *acc_bd;
        struct zebra_if *old_vxlan_zif;
-       zebra_vni_t *old_zvni;
+       zebra_evpn_t *old_zevpn;
 
        if (!vid)
                return;
@@ -554,20 +554,20 @@ void zebra_evpn_vl_vxl_ref(uint16_t vid, struct zebra_if *vxlan_zif)
        if (vxlan_zif == old_vxlan_zif)
                return;
 
-       old_zvni = acc_bd->zvni;
-       acc_bd->zvni = zvni_lookup(vxlan_zif->l2info.vxl.vni);
-       if (acc_bd->zvni == old_zvni)
+       old_zevpn = acc_bd->zevpn;
+       acc_bd->zevpn = zevpn_lookup(vxlan_zif->l2info.vxl.vni);
+       if (acc_bd->zevpn == old_zevpn)
                return;
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("access vlan %d vni %u ref",
                                acc_bd->vid, vxlan_zif->l2info.vxl.vni);
 
-       if (old_zvni)
-               zebra_evpn_acc_bd_vni_set(acc_bd, NULL, old_zvni);
+       if (old_zevpn)
+               zebra_evpn_acc_bd_evpn_set(acc_bd, NULL, old_zevpn);
 
-       if (acc_bd->zvni)
-               zebra_evpn_acc_bd_vni_set(acc_bd, acc_bd->zvni, NULL);
+       if (acc_bd->zevpn)
+               zebra_evpn_acc_bd_evpn_set(acc_bd, acc_bd->zevpn, NULL);
 }
 
 /* handle VLAN->VxLAN_IF deref */
@@ -590,18 +590,18 @@ void zebra_evpn_vl_vxl_deref(uint16_t vid, struct zebra_if *vxlan_zif)
                zlog_debug("access vlan %d vni %u deref",
                                acc_bd->vid, vxlan_zif->l2info.vxl.vni);
 
-       if (acc_bd->zvni)
-               zebra_evpn_acc_bd_vni_set(acc_bd, NULL, acc_bd->zvni);
+       if (acc_bd->zevpn)
+               zebra_evpn_acc_bd_evpn_set(acc_bd, NULL, acc_bd->zevpn);
 
-       acc_bd->zvni = NULL;
+       acc_bd->zevpn = NULL;
        acc_bd->vxlan_zif = NULL;
 
        /* if there are no other references the access_bd can be freed */
        zebra_evpn_acc_bd_free_on_deref(acc_bd);
 }
 
-/* handle EVPN L2VNI add/del */
-void zebra_evpn_vxl_vni_set(struct zebra_if *zif, zebra_vni_t *zvni,
+/* handle EVPN add/del */
+void zebra_evpn_vxl_evpn_set(struct zebra_if *zif, zebra_evpn_t *zevpn,
                bool set)
 {
        struct zebra_l2info_vxlan *vxl;
@@ -617,16 +617,16 @@ void zebra_evpn_vxl_vni_set(struct zebra_if *zif, zebra_vni_t *zvni,
                return;
 
        if (set) {
-               zebra_evpn_es_set_base_vni(zvni);
-               if (acc_bd->zvni != zvni) {
-                       acc_bd->zvni = zvni;
-                       zebra_evpn_acc_bd_vni_set(acc_bd, zvni, NULL);
+               zebra_evpn_es_set_base_evpn(zevpn);
+               if (acc_bd->zevpn != zevpn) {
+                       acc_bd->zevpn = zevpn;
+                       zebra_evpn_acc_bd_evpn_set(acc_bd, zevpn, NULL);
                }
        } else {
-               if (acc_bd->zvni) {
-                       zebra_vni_t *old_zvni = acc_bd->zvni;
-                       acc_bd->zvni = NULL;
-                       zebra_evpn_acc_bd_vni_set(acc_bd, NULL, old_zvni);
+               if (acc_bd->zevpn) {
+                       zebra_evpn_t *old_zevpn = acc_bd->zevpn;
+                       acc_bd->zevpn = NULL;
+                       zebra_evpn_acc_bd_evpn_set(acc_bd, NULL, old_zevpn);
                }
        }
 }
@@ -651,8 +651,8 @@ void zebra_evpn_vl_mbr_ref(uint16_t vid, struct zebra_if *zif)
                                vid, zif->ifp->name);
 
        listnode_add(acc_bd->mbr_zifs, zif);
-       if (acc_bd->zvni && zif->es_info.es)
-               zebra_evpn_local_es_evi_add(zif->es_info.es, acc_bd->zvni);
+       if (acc_bd->zevpn && zif->es_info.es)
+               zebra_evpn_local_es_evi_add(zif->es_info.es, acc_bd->zevpn);
 }
 
 /* handle deletion of VLAN members */
@@ -678,8 +678,8 @@ void zebra_evpn_vl_mbr_deref(uint16_t vid, struct zebra_if *zif)
 
        list_delete_node(acc_bd->mbr_zifs, node);
 
-       if (acc_bd->zvni && zif->es_info.es)
-               zebra_evpn_local_es_evi_del(zif->es_info.es, acc_bd->zvni);
+       if (acc_bd->zevpn && zif->es_info.es)
+               zebra_evpn_local_es_evi_del(zif->es_info.es, acc_bd->zevpn);
 
        /* if there are no other references the access_bd can be freed */
        zebra_evpn_acc_bd_free_on_deref(acc_bd);
@@ -699,7 +699,7 @@ static void zebra_evpn_acc_vl_show_entry_detail(struct vty *vty,
                                acc_bd->vxlan_zif ?
                                acc_bd->vxlan_zif->ifp->name : "-");
                vty_out(vty, " L2-VNI: %d\n",
-                               acc_bd->zvni ? acc_bd->zvni->vni : 0);
+                               acc_bd->zevpn ? acc_bd->zevpn->vni : 0);
                vty_out(vty, " Member Count: %d\n",
                                listcount(acc_bd->mbr_zifs));
                vty_out(vty, " Members: \n");
@@ -717,7 +717,7 @@ static void zebra_evpn_acc_vl_show_entry(struct vty *vty,
                                acc_bd->vid,
                                acc_bd->vxlan_zif ?
                                acc_bd->vxlan_zif->ifp->name : "-",
-                               acc_bd->zvni ? acc_bd->zvni->vni : 0,
+                               acc_bd->zevpn ? acc_bd->zevpn->vni : 0,
                                listcount(acc_bd->mbr_zifs));
 }
 
@@ -961,7 +961,7 @@ static void zebra_evpn_nh_del(struct zebra_evpn_es_vtep *es_vtep)
 /* A list of remote VTEPs is maintained for each ES. This list includes -
  * 1. VTEPs for which we have imported the ESR i.e. ES-peers
  * 2. VTEPs that have an "active" ES-EVI VTEP i.e. EAD-per-ES and EAD-per-EVI
- *    have been imported into one or more VNIs
+ *    have been imported into one or more EVPNs
  */
 static int zebra_evpn_es_vtep_cmp(void *p1, void *p2)
 {
@@ -1257,11 +1257,11 @@ void zebra_evpn_es_send_all_to_client(bool add)
 
                                if (add)
                                        zebra_evpn_es_evi_send_to_client(
-                                               es, es_evi->zvni,
+                                               es, es_evi->zevpn,
                                                true /* add */);
                                else
                                        zebra_evpn_es_evi_send_to_client(
-                                               es, es_evi->zvni,
+                                               es, es_evi->zevpn,
                                                false /* add */);
                        }
                        if (!add)
@@ -1283,8 +1283,8 @@ static void zebra_evpn_es_setup_evis(struct zebra_evpn_es *es)
 
        bf_for_each_set_bit(zif->vlan_bitmap, vid, IF_VLAN_BITMAP_MAX) {
                acc_bd = zebra_evpn_acc_vl_find(vid);
-               if (acc_bd->zvni)
-                       zebra_evpn_local_es_evi_add(es, acc_bd->zvni);
+               if (acc_bd->zevpn)
+                       zebra_evpn_local_es_evi_add(es, acc_bd->zevpn);
        }
 }
 
@@ -1328,8 +1328,8 @@ static void zebra_evpn_es_local_info_set(struct zebra_evpn_es *es,
        /* setup base-vni if one doesn't already exist; the ES will get sent
         * to BGP as a part of that process
         */
-       if (!zmh_info->es_base_vni)
-               zebra_evpn_es_get_one_base_vni();
+       if (!zmh_info->es_base_evpn)
+               zebra_evpn_es_get_one_base_evpn();
        else
                /* send notification to bgp */
                zebra_evpn_es_re_eval_send_to_client(es,
@@ -1621,7 +1621,7 @@ bool zebra_evpn_es_mac_ref(zebra_mac_t *mac, esi_t *esi)
 
 /* Inform BGP about local ES-EVI add or del */
 static int zebra_evpn_es_evi_send_to_client(struct zebra_evpn_es *es,
-               zebra_vni_t *zvni, bool add)
+               zebra_evpn_t *zevpn, bool add)
 {
        struct zserv *client;
        struct stream *s;
@@ -1637,7 +1637,7 @@ static int zebra_evpn_es_evi_send_to_client(struct zebra_evpn_es *es,
                        add ? ZEBRA_LOCAL_ES_EVI_ADD : ZEBRA_LOCAL_ES_EVI_DEL,
                        zebra_vrf_get_evpn_id());
        stream_put(s, &es->esi, sizeof(esi_t));
-       stream_putl(s, zvni->vni);
+       stream_putl(s, zevpn->vni);
 
        /* Write packet size. */
        stream_putw_at(s, 0, stream_get_endp(s));
@@ -1645,7 +1645,7 @@ static int zebra_evpn_es_evi_send_to_client(struct zebra_evpn_es *es,
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("send %s local es %s evi %u to %s",
                                add ? "add" : "del",
-                               es->esi_str, zvni->vni,
+                               es->esi_str, zevpn->vni,
                                zebra_route_string(client->proto));
 
        client->local_es_add_cnt++;
@@ -1979,39 +1979,39 @@ DEFPY(zebra_evpn_es_id,
  * necessary
  */
 /* called when a new vni is added or becomes oper up or becomes a bridge port */
-void zebra_evpn_es_set_base_vni(zebra_vni_t *zvni)
+void zebra_evpn_es_set_base_evpn(zebra_evpn_t *zevpn)
 {
        struct listnode *node;
        struct zebra_evpn_es *es;
 
-       if (zmh_info->es_base_vni) {
-               if (zmh_info->es_base_vni != zvni) {
-                       /* unrelated VNI; ignore it */
+       if (zmh_info->es_base_evpn) {
+               if (zmh_info->es_base_evpn != zevpn) {
+                       /* unrelated EVPN; ignore it */
                        return;
                }
                /* check if the local vtep-ip has changed */
        } else {
-               /* check if the VNI can be used as base VNI */
-               if (!zebra_evpn_vni_send_to_client_ok(zvni))
+               /* check if the EVPN can be used as base EVPN */
+               if (!zebra_evpn_send_to_client_ok(zevpn))
                        return;
 
                if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                        zlog_debug("es base vni set to %d",
-                                       zvni->vni);
-               zmh_info->es_base_vni = zvni;
+                                       zevpn->vni);
+               zmh_info->es_base_evpn = zevpn;
        }
 
        /* update local VTEP-IP */
        if (zmh_info->es_originator_ip.s_addr ==
-                       zmh_info->es_base_vni->local_vtep_ip.s_addr)
+                       zmh_info->es_base_evpn->local_vtep_ip.s_addr)
                return;
 
        zmh_info->es_originator_ip.s_addr =
-               zmh_info->es_base_vni->local_vtep_ip.s_addr;
+               zmh_info->es_base_evpn->local_vtep_ip.s_addr;
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                zlog_debug("es originator ip set to %s",
-                       inet_ntoa(zmh_info->es_base_vni->local_vtep_ip));
+                       inet_ntoa(zmh_info->es_base_evpn->local_vtep_ip));
 
        /* if originator ip changes we need to update bgp */
        for (ALL_LIST_ELEMENTS_RO(zmh_info->local_es_list, node, es)) {
@@ -2026,20 +2026,20 @@ void zebra_evpn_es_set_base_vni(zebra_vni_t *zvni)
 /* called when a vni is removed or becomes oper down or is removed from a
  * bridge
  */
-void zebra_evpn_es_clear_base_vni(zebra_vni_t *zvni)
+void zebra_evpn_es_clear_base_evpn(zebra_evpn_t *zevpn)
 {
        struct listnode *node;
        struct zebra_evpn_es *es;
 
-       if (zmh_info->es_base_vni != zvni)
+       if (zmh_info->es_base_evpn != zevpn)
                return;
 
-       zmh_info->es_base_vni = NULL;
-       /* lost current base VNI; try to find a new one */
-       zebra_evpn_es_get_one_base_vni();
+       zmh_info->es_base_evpn = NULL;
+       /* lost current base EVPN; try to find a new one */
+       zebra_evpn_es_get_one_base_evpn();
 
-       /* couldn't locate an eligible base vni */
-       if (!zmh_info->es_base_vni && zmh_info->es_originator_ip.s_addr) {
+       /* couldn't locate an eligible base evpn */
+       if (!zmh_info->es_base_evpn && zmh_info->es_originator_ip.s_addr) {
                if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
                        zlog_debug("es originator ip cleared");
 
@@ -2053,27 +2053,27 @@ void zebra_evpn_es_clear_base_vni(zebra_vni_t *zvni)
 }
 
 /* Locate an "eligible" L2-VNI to follow */
-static int zebra_evpn_es_get_one_base_vni_cb(struct hash_bucket *b, void *data)
+static int zebra_evpn_es_get_one_base_evpn_cb(struct hash_bucket *b, void *data)
 {
-       zebra_vni_t *zvni = b->data;
+       zebra_evpn_t *zevpn = b->data;
 
-       zebra_evpn_es_set_base_vni(zvni);
+       zebra_evpn_es_set_base_evpn(zevpn);
 
-       if (zmh_info->es_base_vni)
+       if (zmh_info->es_base_evpn)
                return HASHWALK_ABORT;
 
        return HASHWALK_CONTINUE;
 }
 
-/* locate a base_vni to follow for the purposes of common params like
+/* locate a base_evpn to follow for the purposes of common params like
  * originator IP
  */
-static void zebra_evpn_es_get_one_base_vni(void)
+static void zebra_evpn_es_get_one_base_evpn(void)
 {
        struct zebra_vrf *zvrf;
 
        zvrf = zebra_vrf_get_evpn();
-       hash_walk(zvrf->vni_table, zebra_evpn_es_get_one_base_vni_cb, NULL);
+       hash_walk(zvrf->evpn_table, zebra_evpn_es_get_one_base_evpn_cb, NULL);
 }
 
 /*****************************************************************************/

diff --git a/zebra/zebra_evpn_mh.h b/zebra/zebra_evpn_mh.h
index 46c25a04bc142468dc9d490baa71ab3226677599..ed62677e3b2deeedfd2eb66a51f80609a87f5ba4 100644 (file)
--- a/zebra/zebra_evpn_mh.h
+++ b/zebra/zebra_evpn_mh.h
@@ -79,8 +79,8 @@ RB_HEAD(zebra_es_rb_head, zebra_evpn_es);
 RB_PROTOTYPE(zebra_es_rb_head, zebra_evpn_es, rb_node, zebra_es_rb_cmp);
 
 /* ES per-EVI info
- * - ES-EVIs are maintained per-VNI (vni->es_evi_rb_tree)
- * - Local ES-EVIs are linked to per-VNI list for quick access
+ * - ES-EVIs are maintained per-EVPN (vni->es_evi_rb_tree)
+ * - Local ES-EVIs are linked to per-EVPN list for quick access
  * - Although some infrastucture is present for remote ES-EVIs, currently
  *   BGP does NOT send remote ES-EVIs to zebra. This may change in the
  *   future (but must be changed thoughtfully and only if needed as ES-EVI
@@ -88,7 +88,7 @@ RB_PROTOTYPE(zebra_es_rb_head, zebra_evpn_es, rb_node, zebra_es_rb_cmp);
  */
 struct zebra_evpn_es_evi {
        struct zebra_evpn_es *es;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
 
        /* ES-EVI flags */
        uint32_t flags;
@@ -97,11 +97,11 @@ struct zebra_evpn_es_evi {
 #define ZEBRA_EVPNES_EVI_READY_FOR_BGP (1 << 1) /* ready to be sent to BGP */
 
        /* memory used for adding the es_evi to
-        * es_evi->zvni->es_evi_rb_tree
+        * es_evi->zevpn->es_evi_rb_tree
         */
        RB_ENTRY(zebra_evpn_es_evi) rb_node;
        /* memory used for linking the es_evi to
-        * es_evi->zvni->local_es_evi_list
+        * es_evi->zevpn->local_es_evi_list
         */
        struct listnode l2vni_listnode;
        /* memory used for linking the es_evi to
@@ -135,8 +135,8 @@ struct zebra_evpn_access_bd {
        struct zebra_if *vxlan_zif; /* vxlan device */
        /* list of members associated with the BD i.e. (potential) ESs */
        struct list *mbr_zifs;
-       /* presence of zvni activates the EVI on all the ESs in mbr_zifs */
-       zebra_vni_t *zvni;
+       /* presence of zevpn activates the EVI on all the ESs in mbr_zifs */
+       zebra_evpn_t *zevpn;
 };
 
 /* multihoming information stored in zrouter */
@@ -155,7 +155,7 @@ struct zebra_evpn_mh_info {
         * XXX: once single vxlan device model becomes available this will
         * not be necessary
         */
-       zebra_vni_t *es_base_vni;
+       zebra_evpn_t *es_base_evpn;
        struct in_addr es_originator_ip;
 
        /* L2 NH and NHG ids -
@@ -198,12 +198,12 @@ extern void zebra_evpn_mh_terminate(void);
 extern bool zebra_evpn_is_if_es_capable(struct zebra_if *zif);
 extern void zebra_evpn_if_init(struct zebra_if *zif);
 extern void zebra_evpn_if_cleanup(struct zebra_if *zif);
-extern void zebra_evpn_vni_es_init(zebra_vni_t *zvni);
-extern void zebra_evpn_vni_es_cleanup(zebra_vni_t *zvni);
-extern void zebra_evpn_vxl_vni_set(struct zebra_if *zif, zebra_vni_t *zvni,
+extern void zebra_evpn_evpn_es_init(zebra_evpn_t *zevpn);
+extern void zebra_evpn_evpn_es_cleanup(zebra_evpn_t *zevpn);
+extern void zebra_evpn_vxl_evpn_set(struct zebra_if *zif, zebra_evpn_t *zevpn,
                bool set);
-extern void zebra_evpn_es_set_base_vni(zebra_vni_t *zvni);
-extern void zebra_evpn_es_clear_base_vni(zebra_vni_t *zvni);
+extern void zebra_evpn_es_set_base_evpn(zebra_evpn_t *zevpn);
+extern void zebra_evpn_es_clear_base_evpn(zebra_evpn_t *zevpn);
 extern void zebra_evpn_vl_vxl_ref(uint16_t vid, struct zebra_if *vxlan_zif);
 extern void zebra_evpn_vl_vxl_deref(uint16_t vid, struct zebra_if *vxlan_zif);
 extern void zebra_evpn_vl_mbr_ref(uint16_t vid, struct zebra_if *zif);
@@ -213,7 +213,7 @@ extern void zebra_evpn_es_if_oper_state_change(struct zebra_if *zif, bool up);
 extern void zebra_evpn_es_show(struct vty *vty, bool uj);
 extern void zebra_evpn_es_show_detail(struct vty *vty, bool uj);
 extern void zebra_evpn_es_show_esi(struct vty *vty, bool uj, esi_t *esi);
-extern void zebra_evpn_vni_update_all_es(zebra_vni_t *zvni);
+extern void zebra_evpn_update_all_es(zebra_evpn_t *zevpn);
 extern void zebra_evpn_proc_remote_es(ZAPI_HANDLER_ARGS);
 extern void zebra_evpn_es_evi_show(struct vty *vty, bool uj, int detail);
 extern void zebra_evpn_es_evi_show_vni(struct vty *vty, bool uj,

diff --git a/zebra/zebra_vrf.h b/zebra/zebra_vrf.h
index d200f5a4c8cbdca6b4630c862999f3d7d9be8527..910d1923175fad9105565ac79fc2499f101ce509 100644 (file)
--- a/zebra/zebra_vrf.h
+++ b/zebra/zebra_vrf.h
@@ -130,9 +130,9 @@ struct zebra_vrf {
 #define MPLS_FLAG_SCHEDULE_LSPS    (1 << 0)
 
        /*
-        * VNI hash table (for EVPN). Only in the EVPN instance.
+        * EVPN hash table. Only in the EVPN instance.
         */
-       struct hash *vni_table;
+       struct hash *evpn_table;
 
        /*
         * Whether EVPN is enabled or not. Only in the EVPN instance.

diff --git a/zebra/zebra_vxlan.c b/zebra/zebra_vxlan.c
index ee167fa5a3430d8bb99d74dc181be1886abb724e..e002e77d96d062696fcc666fbf7ec05257383e3e 100644 (file)
--- a/zebra/zebra_vxlan.c
+++ b/zebra/zebra_vxlan.c
@@ -54,11 +54,11 @@
 #include "zebra/zebra_router.h"
 
 DEFINE_MTYPE_STATIC(ZEBRA, HOST_PREFIX, "host prefix");
-DEFINE_MTYPE_STATIC(ZEBRA, ZVNI, "VNI hash");
+DEFINE_MTYPE_STATIC(ZEBRA, ZEVPN, "EVPN hash");
 DEFINE_MTYPE_STATIC(ZEBRA, ZL3VNI, "L3 VNI hash");
-DEFINE_MTYPE_STATIC(ZEBRA, ZVNI_VTEP, "VNI remote VTEP");
-DEFINE_MTYPE_STATIC(ZEBRA, MAC, "VNI MAC");
-DEFINE_MTYPE_STATIC(ZEBRA, NEIGH, "VNI Neighbor");
+DEFINE_MTYPE_STATIC(ZEBRA, ZEVPN_VTEP, "EVPN remote VTEP/PTUN");
+DEFINE_MTYPE_STATIC(ZEBRA, MAC, "EVPN MAC");
+DEFINE_MTYPE_STATIC(ZEBRA, NEIGH, "EVPN Neighbor");
 DEFINE_MTYPE_STATIC(ZEBRA, ZVXLAN_SG, "zebra VxLAN multicast group");
 
 DEFINE_HOOK(zebra_rmac_update, (zebra_mac_t *rmac, zebra_l3vni_t *zl3vni,
@@ -78,49 +78,49 @@ static const struct message zvtep_flood_str[] = {
 /* static function declarations */
 static int ip_prefix_send_to_client(vrf_id_t vrf_id, struct prefix *p,
                                    uint16_t cmd);
-static void zvni_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json);
-static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt);
-static void zvni_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt);
-static void zvni_print_neigh_hash_all_vni(struct hash_bucket *bucket,
-                                         void **args);
+static void zevpn_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json);
+static void zevpn_print_neigh_hash(struct hash_bucket *bucket, void *ctxt);
+static void zevpn_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt);
+static void zevpn_print_neigh_hash_all_evpn(struct hash_bucket *bucket,
+                                           void **args);
 static void zl3vni_print_nh(zebra_neigh_t *n, struct vty *vty,
                            json_object *json);
 static void zl3vni_print_rmac(zebra_mac_t *zrmac, struct vty *vty,
                              json_object *json);
-static void zvni_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json);
-static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt);
-static void zvni_print_mac_hash_all_vni(struct hash_bucket *bucket, void *ctxt);
-static void zvni_print(zebra_vni_t *zvni, void **ctxt);
-static void zvni_print_hash(struct hash_bucket *bucket, void *ctxt[]);
+static void zevpn_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json);
+static void zevpn_print_mac_hash(struct hash_bucket *bucket, void *ctxt);
+static void zevpn_print_mac_hash_all_evpn(struct hash_bucket *bucket, void *ctxt);
+static void zevpn_print(zebra_evpn_t *zevpn, void **ctxt);
+static void zevpn_print_hash(struct hash_bucket *bucket, void *ctxt[]);
 
-static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
+static int zevpn_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
                                         struct ipaddr *ip, uint8_t flags,
                                         uint32_t seq, int state,
                                         struct zebra_evpn_es *es,
                                         uint16_t cmd);
 static unsigned int neigh_hash_keymake(const void *p);
-static void *zvni_neigh_alloc(void *p);
-static zebra_neigh_t *zvni_neigh_add(zebra_vni_t *zvni, struct ipaddr *ip,
+static void *zevpn_neigh_alloc(void *p);
+static zebra_neigh_t *zevpn_neigh_add(zebra_evpn_t *zevpn, struct ipaddr *ip,
                                     struct ethaddr *mac, zebra_mac_t *zmac,
                                         uint32_t n_flags);
-static int zvni_neigh_del(zebra_vni_t *zvni, zebra_neigh_t *n);
-static void zvni_neigh_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+static int zevpn_neigh_del(zebra_evpn_t *zevpn, zebra_neigh_t *n);
+static void zevpn_neigh_del_all(zebra_evpn_t *zevpn, int uninstall, int upd_client,
                               uint32_t flags);
-static zebra_neigh_t *zvni_neigh_lookup(zebra_vni_t *zvni, struct ipaddr *ip);
-static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
+static zebra_neigh_t *zevpn_neigh_lookup(zebra_evpn_t *zevpn, struct ipaddr *ip);
+static int zevpn_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
                                         struct ethaddr *mac, zebra_mac_t *zmac,
                                         uint32_t flags, uint32_t seq);
-static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
+static int zevpn_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
                                         struct ethaddr *mac,
                                         uint32_t flags, int state, bool force);
-static int zvni_rem_neigh_install(zebra_vni_t *zvni,
+static int zevpn_rem_neigh_install(zebra_evpn_t *zevpn,
                zebra_neigh_t *n, bool was_static);
-static int zvni_neigh_uninstall(zebra_vni_t *zvni, zebra_neigh_t *n);
-static int zvni_neigh_probe(zebra_vni_t *zvni, zebra_neigh_t *n);
-static zebra_vni_t *zvni_from_svi(struct interface *ifp,
+static int zevpn_neigh_uninstall(zebra_evpn_t *zevpn, zebra_neigh_t *n);
+static int zevpn_neigh_probe(zebra_evpn_t *zevpn, zebra_neigh_t *n);
+static zebra_evpn_t *zevpn_from_svi(struct interface *ifp,
                                  struct interface *br_if);
-static struct interface *zvni_map_to_svi(vlanid_t vid, struct interface *br_if);
-static struct interface *zvni_map_to_macvlan(struct interface *br_if,
+static struct interface *zevpn_map_to_svi(vlanid_t vid, struct interface *br_if);
+static struct interface *zevpn_map_to_macvlan(struct interface *br_if,
                                             struct interface *svi_if);
 
 /* l3-vni next-hop neigh related APIs */
@@ -154,53 +154,53 @@ static void zebra_vxlan_process_l3vni_oper_down(zebra_l3vni_t *zl3vni);
 
 static unsigned int mac_hash_keymake(const void *p);
 static bool mac_cmp(const void *p1, const void *p2);
-static void *zvni_mac_alloc(void *p);
-static zebra_mac_t *zvni_mac_add(zebra_vni_t *zvni, struct ethaddr *macaddr);
-static int zvni_mac_del(zebra_vni_t *zvni, zebra_mac_t *mac);
-static void zvni_mac_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+static void *zevpn_mac_alloc(void *p);
+static zebra_mac_t *zevpn_mac_add(zebra_evpn_t *zevpn, struct ethaddr *macaddr);
+static int zevpn_mac_del(zebra_evpn_t *zevpn, zebra_mac_t *mac);
+static void zevpn_mac_del_all(zebra_evpn_t *zevpn, int uninstall, int upd_client,
                             uint32_t flags);
-static zebra_mac_t *zvni_mac_lookup(zebra_vni_t *zvni, struct ethaddr *macaddr);
-static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
+static zebra_mac_t *zevpn_mac_lookup(zebra_evpn_t *zevpn, struct ethaddr *macaddr);
+static int zevpn_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
                uint32_t flags, uint32_t seq, struct zebra_evpn_es *es);
-static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
+static int zevpn_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
                uint32_t flags, bool force);
-static zebra_vni_t *zvni_map_vlan(struct interface *ifp,
+static zebra_evpn_t *zevpn_map_vlan(struct interface *ifp,
                                  struct interface *br_if, vlanid_t vid);
-static int zvni_rem_mac_install(zebra_vni_t *zvni,
+static int zevpn_rem_mac_install(zebra_evpn_t *zevpn,
                zebra_mac_t *mac, bool was_static);
-static int zvni_rem_mac_uninstall(zebra_vni_t *zvni, zebra_mac_t *mac);
-static void zvni_install_mac_hash(struct hash_bucket *bucket, void *ctxt);
-
-static unsigned int vni_hash_keymake(const void *p);
-static void *zvni_alloc(void *p);
-static zebra_vni_t *zvni_add(vni_t vni);
-static int zvni_del(zebra_vni_t *zvni);
-static int zvni_send_add_to_client(zebra_vni_t *zvni);
-static int zvni_send_del_to_client(zebra_vni_t *zvni);
-static void zvni_build_hash_table(void);
-static int zvni_vtep_match(struct in_addr *vtep_ip, zebra_vtep_t *zvtep);
-static zebra_vtep_t *zvni_vtep_find(zebra_vni_t *zvni, struct in_addr *vtep_ip);
-static zebra_vtep_t *zvni_vtep_add(zebra_vni_t *zvni, struct in_addr *vtep_ip,
+static int zevpn_rem_mac_uninstall(zebra_evpn_t *zevpn, zebra_mac_t *mac);
+static void zevpn_install_mac_hash(struct hash_bucket *bucket, void *ctxt);
+
+static unsigned int evpn_hash_keymake(const void *p);
+static void *zevpn_alloc(void *p);
+static zebra_evpn_t *zevpn_add(vni_t vni);
+static int zevpn_del(zebra_evpn_t *zevpn);
+static int zevpn_send_add_to_client(zebra_evpn_t *zevpn);
+static int zevpn_send_del_to_client(zebra_evpn_t *zevpn);
+static void zevpn_build_hash_table(void);
+static int zevpn_vtep_match(struct in_addr *vtep_ip, zebra_vtep_t *zvtep);
+static zebra_vtep_t *zevpn_vtep_find(zebra_evpn_t *zevpn, struct in_addr *vtep_ip);
+static zebra_vtep_t *zevpn_vtep_add(zebra_evpn_t *zevpn, struct in_addr *vtep_ip,
                int flood_control);
-static int zvni_vtep_del(zebra_vni_t *zvni, zebra_vtep_t *zvtep);
-static int zvni_vtep_del_all(zebra_vni_t *zvni, int uninstall);
-static int zvni_vtep_install(zebra_vni_t *zvni, zebra_vtep_t *zvtep);
-static int zvni_vtep_uninstall(zebra_vni_t *zvni, struct in_addr *vtep_ip);
-static int zvni_del_macip_for_intf(struct interface *ifp, zebra_vni_t *zvni);
-static int zvni_add_macip_for_intf(struct interface *ifp, zebra_vni_t *zvni);
-static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
+static int zevpn_vtep_del(zebra_evpn_t *zevpn, zebra_vtep_t *zvtep);
+static int zevpn_vtep_del_all(zebra_evpn_t *zevpn, int uninstall);
+static int zevpn_vtep_install(zebra_evpn_t *zevpn, zebra_vtep_t *zvtep);
+static int zevpn_vtep_uninstall(zebra_evpn_t *zevpn, struct in_addr *vtep_ip);
+static int zevpn_del_macip_for_intf(struct interface *ifp, zebra_evpn_t *zevpn);
+static int zevpn_add_macip_for_intf(struct interface *ifp, zebra_evpn_t *zevpn);
+static int zevpn_gw_macip_add(struct interface *ifp, zebra_evpn_t *zevpn,
                             struct ethaddr *macaddr, struct ipaddr *ip);
-static int zvni_gw_macip_del(struct interface *ifp, zebra_vni_t *zvni,
+static int zevpn_gw_macip_del(struct interface *ifp, zebra_evpn_t *zevpn,
                             struct ipaddr *ip);
 struct interface *zebra_get_vrr_intf_for_svi(struct interface *ifp);
-static int advertise_gw_macip_enabled(zebra_vni_t *zvni);
-static int advertise_svi_macip_enabled(zebra_vni_t *zvni);
+static int advertise_gw_macip_enabled(zebra_evpn_t *zevpn);
+static int advertise_svi_macip_enabled(zebra_evpn_t *zevpn);
 static int zebra_vxlan_ip_inherit_dad_from_mac(struct zebra_vrf *zvrf,
                                               zebra_mac_t *old_zmac,
                                               zebra_mac_t *new_zmac,
                                               zebra_neigh_t *nbr);
 static int remote_neigh_count(zebra_mac_t *zmac);
-static void zvni_deref_ip2mac(zebra_vni_t *zvni, zebra_mac_t *mac);
+static void zevpn_deref_ip2mac(zebra_evpn_t *zevpn, zebra_mac_t *mac);
 static int zebra_vxlan_dad_mac_auto_recovery_exp(struct thread *t);
 static int zebra_vxlan_dad_ip_auto_recovery_exp(struct thread *t);
 static void zebra_vxlan_dup_addr_detect_for_neigh(struct zebra_vrf *zvrf,
@@ -227,9 +227,9 @@ static void zebra_vxlan_sg_ref(struct in_addr local_vtep_ip,
                                struct in_addr mcast_grp);
 static void zebra_vxlan_sg_cleanup(struct hash_bucket *bucket, void *arg);
 
-static void zvni_send_mac_to_client(zebra_vni_t *zvn);
-static void zvni_send_neigh_to_client(zebra_vni_t *zvni);
-static void zebra_vxlan_rem_mac_del(zebra_vni_t *zvni,
+static void zevpn_send_mac_to_client(zebra_evpn_t *zvn);
+static void zevpn_send_neigh_to_client(zebra_evpn_t *zevpn);
+static void zebra_vxlan_rem_mac_del(zebra_evpn_t *zevpn,
                zebra_mac_t *zmac);
 static inline void zebra_vxlan_mac_stop_hold_timer(zebra_mac_t *mac);
 static inline bool zebra_vxlan_mac_is_static(zebra_mac_t *mac);
@@ -293,10 +293,10 @@ static uint32_t rb_host_count(struct host_rb_tree_entry *hrbe)
 }
 
 /*
- * Return number of valid MACs in a VNI's MAC hash table - all
+ * Return number of valid MACs in an EVPN's MAC hash table - all
  * remote MACs and non-internal (auto) local MACs count.
  */
-static uint32_t num_valid_macs(zebra_vni_t *zvni)
+static uint32_t num_valid_macs(zebra_evpn_t *zevpn)
 {
        unsigned int i;
        uint32_t num_macs = 0;
@@ -304,7 +304,7 @@ static uint32_t num_valid_macs(zebra_vni_t *zvni)
        struct hash_bucket *hb;
        zebra_mac_t *mac;
 
-       hash = zvni->mac_table;
+       hash = zevpn->mac_table;
        if (!hash)
                return num_macs;
        for (i = 0; i < hash->size; i++) {
@@ -320,7 +320,7 @@ static uint32_t num_valid_macs(zebra_vni_t *zvni)
        return num_macs;
 }
 
-static uint32_t num_dup_detected_macs(zebra_vni_t *zvni)
+static uint32_t num_dup_detected_macs(zebra_evpn_t *zevpn)
 {
        unsigned int i;
        uint32_t num_macs = 0;
@@ -328,7 +328,7 @@ static uint32_t num_dup_detected_macs(zebra_vni_t *zvni)
        struct hash_bucket *hb;
        zebra_mac_t *mac;
 
-       hash = zvni->mac_table;
+       hash = zevpn->mac_table;
        if (!hash)
                return num_macs;
        for (i = 0; i < hash->size; i++) {
@@ -342,7 +342,7 @@ static uint32_t num_dup_detected_macs(zebra_vni_t *zvni)
        return num_macs;
 }
 
-static uint32_t num_dup_detected_neighs(zebra_vni_t *zvni)
+static uint32_t num_dup_detected_neighs(zebra_evpn_t *zevpn)
 {
        unsigned int i;
        uint32_t num_neighs = 0;
@@ -350,7 +350,7 @@ static uint32_t num_dup_detected_neighs(zebra_vni_t *zvni)
        struct hash_bucket *hb;
        zebra_neigh_t *nbr;
 
-       hash = zvni->neigh_table;
+       hash = zevpn->neigh_table;
        if (!hash)
                return num_neighs;
        for (i = 0; i < hash->size; i++) {
@@ -364,7 +364,7 @@ static uint32_t num_dup_detected_neighs(zebra_vni_t *zvni)
        return num_neighs;
 }
 
-static int advertise_gw_macip_enabled(zebra_vni_t *zvni)
+static int advertise_gw_macip_enabled(zebra_evpn_t *zevpn)
 {
        struct zebra_vrf *zvrf;
 
@@ -372,13 +372,13 @@ static int advertise_gw_macip_enabled(zebra_vni_t *zvni)
        if (zvrf && zvrf->advertise_gw_macip)
                return 1;
 
-       if (zvni && zvni->advertise_gw_macip)
+       if (zevpn && zevpn->advertise_gw_macip)
                return 1;
 
        return 0;
 }
 
-static int advertise_svi_macip_enabled(zebra_vni_t *zvni)
+static int advertise_svi_macip_enabled(zebra_evpn_t *zevpn)
 {
        struct zebra_vrf *zvrf;
 
@@ -386,7 +386,7 @@ static int advertise_svi_macip_enabled(zebra_vni_t *zvni)
        if (zvrf && zvrf->advertise_svi_macip)
                return 1;
 
-       if (zvni && zvni->advertise_svi_macip)
+       if (zevpn && zevpn->advertise_svi_macip)
                return 1;
 
        return 0;
@@ -528,7 +528,7 @@ static void zebra_vxlan_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
        if (mac->dad_count >= zvrf->dad_max_moves) {
                flog_warn(EC_ZEBRA_DUP_MAC_DETECTED,
                          "VNI %u: MAC %s detected as duplicate during %s VTEP %s",
-                         mac->zvni->vni,
+                         mac->zevpn->vni,
                          prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
                          is_local ? "local update, last" :
                          "remote update, from", inet_ntoa(vtep_ip));
@@ -553,7 +553,7 @@ static void zebra_vxlan_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 
                        flog_warn(EC_ZEBRA_DUP_IP_INHERIT_DETECTED,
                                  "VNI %u: MAC %s IP %s detected as duplicate during %s update, inherit duplicate from MAC",
-                                 mac->zvni->vni,
+                                 mac->zevpn->vni,
                                  prefix_mac2str(&mac->macaddr,
                                                 buf, sizeof(buf)),
                                  ipaddr2str(&nbr->ip, buf1, sizeof(buf1)),
@@ -681,7 +681,7 @@ static void zebra_vxlan_dup_addr_detect_for_neigh(struct zebra_vrf *zvrf,
        if (nbr->dad_count >= zvrf->dad_max_moves) {
                flog_warn(EC_ZEBRA_DUP_IP_DETECTED,
                          "VNI %u: MAC %s IP %s detected as duplicate during %s VTEP %s",
-                         nbr->zvni->vni,
+                         nbr->zevpn->vni,
                          prefix_mac2str(&nbr->emac, buf, sizeof(buf)),
                          ipaddr2str(&nbr->ip, buf1, sizeof(buf1)),
                          is_local ? "local update, last" :
@@ -721,7 +721,7 @@ static void zebra_vxlan_dup_addr_detect_for_neigh(struct zebra_vrf *zvrf,
  * display - just because we're dealing with IPv6 addresses that can
  * widely vary.
  */
-static void zvni_find_neigh_addr_width(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_find_neigh_addr_width(struct hash_bucket *bucket, void *ctxt)
 {
        zebra_neigh_t *n;
        char buf[INET6_ADDRSTRLEN];
@@ -740,7 +740,7 @@ static void zvni_find_neigh_addr_width(struct hash_bucket *bucket, void *ctxt)
 /*
  * Print a specific neighbor entry.
  */
-static void zvni_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json)
+static void zevpn_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json)
 {
        struct vty *vty;
        char buf1[ETHER_ADDR_STRLEN];
@@ -883,7 +883,7 @@ static void zvni_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json)
        }
 }
 
-static void zvni_print_neigh_hdr(struct vty *vty,
+static void zevpn_print_neigh_hdr(struct vty *vty,
                struct neigh_walk_ctx *wctx)
 {
        vty_out(vty,
@@ -893,7 +893,7 @@ static void zvni_print_neigh_hdr(struct vty *vty,
                "State", "MAC", "Remote ES/VTEP", "Seq #'s");
 }
 
-static char *zvni_print_neigh_flags(zebra_neigh_t *n, char *flags_buf,
+static char *zevpn_print_neigh_flags(zebra_neigh_t *n, char *flags_buf,
                uint32_t flags_buf_sz)
 {
        snprintf(flags_buf, flags_buf_sz, "%s%s%s",
@@ -910,10 +910,10 @@ static char *zvni_print_neigh_flags(zebra_neigh_t *n, char *flags_buf,
 /*
  * Print neighbor hash entry - called for display of all neighbors.
  */
-static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
 {
        struct vty *vty;
-       json_object *json_vni = NULL, *json_row = NULL;
+       json_object *json_evpn = NULL, *json_row = NULL;
        zebra_neigh_t *n;
        char buf1[ETHER_ADDR_STRLEN];
        char buf2[INET6_ADDRSTRLEN];
@@ -922,10 +922,10 @@ static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
        char flags_buf[6];
 
        vty = wctx->vty;
-       json_vni = wctx->json;
+       json_evpn = wctx->json;
        n = (zebra_neigh_t *)bucket->data;
 
-       if (json_vni)
+       if (json_evpn)
                json_row = json_object_new_object();
 
        prefix_mac2str(&n->emac, buf1, sizeof(buf1));
@@ -938,7 +938,7 @@ static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
                if (json_vni == NULL) {
                        vty_out(vty, "%*s %-6s %-5s %-8s %-17s %-30s %u/%u\n",
                                -wctx->addr_width, buf2, "local",
-                               zvni_print_neigh_flags(n, flags_buf,
+                               zevpn_print_neigh_flags(n, flags_buf,
                                        sizeof(flags_buf)), state_str,
                                buf1, "", n->loc_seq, n->rem_seq);
                } else {
@@ -970,10 +970,10 @@ static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
                if (json_vni == NULL) {
                        if ((wctx->flags & SHOW_REMOTE_NEIGH_FROM_VTEP) &&
                            (wctx->count == 0))
-                               zvni_print_neigh_hdr(vty, wctx);
+                               zevpn_print_neigh_hdr(vty, wctx);
                        vty_out(vty, "%*s %-6s %-5s %-8s %-17s %-30s %u/%u\n",
                                -wctx->addr_width, buf2, "remote",
-                               zvni_print_neigh_flags(n, flags_buf,
+                               zevpn_print_neigh_flags(n, flags_buf,
                                        sizeof(flags_buf)),
                                state_str, buf1,
                                n->mac->es ? n->mac->es->esi_str :
@@ -1008,46 +1008,46 @@ static void zvni_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
                wctx->count++;
        }
 
-       if (json_vni)
-               json_object_object_add(json_vni, buf2, json_row);
+       if (json_evpn)
+               json_object_object_add(json_evpn, buf2, json_row);
 }
 
 /*
  * Print neighbor hash entry in detail - called for display of all neighbors.
  */
-static void zvni_print_neigh_hash_detail(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_neigh_hash_detail(struct hash_bucket *bucket, void *ctxt)
 {
        struct vty *vty;
-       json_object *json_vni = NULL, *json_row = NULL;
+       json_object *json_evpn = NULL, *json_row = NULL;
        zebra_neigh_t *n;
        char buf[INET6_ADDRSTRLEN];
        struct neigh_walk_ctx *wctx = ctxt;
 
        vty = wctx->vty;
-       json_vni = wctx->json;
+       json_evpn = wctx->json;
        n = (zebra_neigh_t *)bucket->data;
        if (!n)
                return;
 
        ipaddr2str(&n->ip, buf, sizeof(buf));
-       if (json_vni)
+       if (json_evpn)
                json_row = json_object_new_object();
 
-       zvni_print_neigh(n, vty, json_row);
+       zevpn_print_neigh(n, vty, json_row);
 
-       if (json_vni)
-               json_object_object_add(json_vni, buf, json_row);
+       if (json_evpn)
+               json_object_object_add(json_evpn, buf, json_row);
 }
 
 /*
- * Print neighbors for all VNI.
+ * Print neighbors for all EVPN.
  */
-static void zvni_print_neigh_hash_all_vni(struct hash_bucket *bucket,
+static void zevpn_print_neigh_hash_all_evpn(struct hash_bucket *bucket,
                                          void **args)
 {
        struct vty *vty;
-       json_object *json = NULL, *json_vni = NULL;
-       zebra_vni_t *zvni;
+       json_object *json = NULL, *json_evpn = NULL;
+       zebra_evpn_t *zevpn;
        uint32_t num_neigh;
        struct neigh_walk_ctx wctx;
        char vni_str[VNI_STR_LEN];
@@ -1057,26 +1057,26 @@ static void zvni_print_neigh_hash_all_vni(struct hash_bucket *bucket,
        json = (json_object *)args[1];
        print_dup = (uint32_t)(uintptr_t)args[2];
 
-       zvni = (zebra_vni_t *)bucket->data;
+       zevpn = (zebra_evpn_t *)bucket->data;
 
-       num_neigh = hashcount(zvni->neigh_table);
+       num_neigh = hashcount(zevpn->neigh_table);
 
        if (print_dup)
-               num_neigh = num_dup_detected_neighs(zvni);
+               num_neigh = num_dup_detected_neighs(zevpn);
 
        if (json == NULL) {
                vty_out(vty,
                        "\nVNI %u #ARP (IPv4 and IPv6, local and remote) %u\n\n",
-                       zvni->vni, num_neigh);
+                       zevpn->vni, num_neigh);
        } else {
-               json_vni = json_object_new_object();
-               json_object_int_add(json_vni, "numArpNd", num_neigh);
-               snprintf(vni_str, sizeof(vni_str), "%u", zvni->vni);
+               json_evpn = json_object_new_object();
+               json_object_int_add(json_evpn, "numArpNd", num_neigh);
+               snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
        }
 
        if (!num_neigh) {
                if (json)
-                       json_object_object_add(json, vni_str, json_vni);
+                       json_object_object_add(json, vni_str, json_evpn);
                return;
        }
 
@@ -1085,26 +1085,26 @@ static void zvni_print_neigh_hash_all_vni(struct hash_bucket *bucket,
         * the maximum width.
         */
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.addr_width = 15;
-       wctx.json = json_vni;
-       hash_iterate(zvni->neigh_table, zvni_find_neigh_addr_width, &wctx);
+       wctx.json = json_evpn;
+       hash_iterate(zevpn->neigh_table, zevpn_find_neigh_addr_width, &wctx);
 
        if (json == NULL)
-               zvni_print_neigh_hdr(vty, &wctx);
+               zevpn_print_neigh_hdr(vty, &wctx);
 
        if (print_dup)
-               hash_iterate(zvni->neigh_table, zvni_print_dad_neigh_hash,
+               hash_iterate(zevpn->neigh_table, zevpn_print_dad_neigh_hash,
                             &wctx);
        else
-               hash_iterate(zvni->neigh_table, zvni_print_neigh_hash, &wctx);
+               hash_iterate(zevpn->neigh_table, zevpn_print_neigh_hash, &wctx);
 
        if (json)
-               json_object_object_add(json, vni_str, json_vni);
+               json_object_object_add(json, vni_str, json_evpn);
 }
 
-static void zvni_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt)
 {
        zebra_neigh_t *nbr;
 
@@ -1113,10 +1113,10 @@ static void zvni_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt)
                return;
 
        if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
-               zvni_print_neigh_hash(bucket, ctxt);
+               zevpn_print_neigh_hash(bucket, ctxt);
 }
 
-static void zvni_print_dad_neigh_hash_detail(struct hash_bucket *bucket,
+static void zevpn_print_dad_neigh_hash_detail(struct hash_bucket *bucket,
                                             void *ctxt)
 {
        zebra_neigh_t *nbr;
@@ -1126,18 +1126,18 @@ static void zvni_print_dad_neigh_hash_detail(struct hash_bucket *bucket,
                return;
 
        if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
-               zvni_print_neigh_hash_detail(bucket, ctxt);
+               zevpn_print_neigh_hash_detail(bucket, ctxt);
 }
 
 /*
- * Print neighbors for all VNIs in detail.
+ * Print neighbors for all EVPNs in detail.
  */
-static void zvni_print_neigh_hash_all_vni_detail(struct hash_bucket *bucket,
+static void zevpn_print_neigh_hash_all_evpn_detail(struct hash_bucket *bucket,
                                                 void **args)
 {
        struct vty *vty;
-       json_object *json = NULL, *json_vni = NULL;
-       zebra_vni_t *zvni;
+       json_object *json = NULL, *json_evpn = NULL;
+       zebra_evpn_t *zevpn;
        uint32_t num_neigh;
        struct neigh_walk_ctx wctx;
        char vni_str[VNI_STR_LEN];
@@ -1147,47 +1147,47 @@ static void zvni_print_neigh_hash_all_vni_detail(struct hash_bucket *bucket,
        json = (json_object *)args[1];
        print_dup = (uint32_t)(uintptr_t)args[2];
 
-       zvni = (zebra_vni_t *)bucket->data;
-       if (!zvni) {
+       zevpn = (zebra_evpn_t *)bucket->data;
+       if (!zevpn) {
                if (json)
                        vty_out(vty, "{}\n");
                return;
        }
-       num_neigh = hashcount(zvni->neigh_table);
+       num_neigh = hashcount(zevpn->neigh_table);
 
-       if (print_dup && num_dup_detected_neighs(zvni) == 0)
+       if (print_dup && num_dup_detected_neighs(zevpn) == 0)
                return;
 
        if (json == NULL) {
                vty_out(vty,
                        "\nVNI %u #ARP (IPv4 and IPv6, local and remote) %u\n\n",
-                       zvni->vni, num_neigh);
+                       zevpn->vni, num_neigh);
        } else {
-               json_vni = json_object_new_object();
-               json_object_int_add(json_vni, "numArpNd", num_neigh);
-               snprintf(vni_str, sizeof(vni_str), "%u", zvni->vni);
+               json_evpn = json_object_new_object();
+               json_object_int_add(json_evpn, "numArpNd", num_neigh);
+               snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
        }
        if (!num_neigh) {
                if (json)
-                       json_object_object_add(json, vni_str, json_vni);
+                       json_object_object_add(json, vni_str, json_evpn);
                return;
        }
 
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.addr_width = 15;
-       wctx.json = json_vni;
+       wctx.json = json_evpn;
 
        if (print_dup)
-               hash_iterate(zvni->neigh_table,
-                            zvni_print_dad_neigh_hash_detail, &wctx);
+               hash_iterate(zevpn->neigh_table,
+                            zevpn_print_dad_neigh_hash_detail, &wctx);
        else
-               hash_iterate(zvni->neigh_table, zvni_print_neigh_hash_detail,
+               hash_iterate(zevpn->neigh_table, zevpn_print_neigh_hash_detail,
                             &wctx);
 
        if (json)
-               json_object_object_add(json, vni_str, json_vni);
+               json_object_object_add(json, vni_str, json_evpn);
 }
 
 /* print a specific next hop for an l3vni */
@@ -1278,9 +1278,9 @@ zebra_vxlan_mac_get_access_info(zebra_mac_t *mac,
 
                /* get the access port from the es */
                *ifpP = mac->es->zif ? mac->es->zif->ifp : NULL;
-               /* get the vlan from the VNI */
-               if (mac->zvni->vxlan_if) {
-                       zif = mac->zvni->vxlan_if->info;
+               /* get the vlan from the EVPN */
+               if (mac->zevpn->vxlan_if) {
+                       zif = mac->zevpn->vxlan_if->info;
                        *vid = zif->l2info.vxl.access_vlan;
                } else {
                        *vid = 0;
@@ -1298,7 +1298,7 @@ zebra_vxlan_mac_get_access_info(zebra_mac_t *mac,
 /*
  * Print a specific MAC entry.
  */
-static void zvni_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json)
+static void zevpn_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json)
 {
        struct vty *vty;
        zebra_neigh_t *n = NULL;
@@ -1510,7 +1510,7 @@ static void zvni_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json)
        }
 }
 
-static char *zvni_print_mac_flags(zebra_mac_t *mac, char *flags_buf,
+static char *zevpn_print_mac_flags(zebra_mac_t *mac, char *flags_buf,
        uint32_t flags_buf_sz)
 {
        snprintf(flags_buf, flags_buf_sz, "%s%s%s%s",
@@ -1529,7 +1529,7 @@ static char *zvni_print_mac_flags(zebra_mac_t *mac, char *flags_buf,
 /*
  * Print MAC hash entry - called for display of all MACs.
  */
-static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
 {
        struct vty *vty;
        json_object *json_mac_hdr = NULL, *json_mac = NULL;
@@ -1558,7 +1558,7 @@ static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
                                &ifp, &vid);
                if (json_mac_hdr == NULL) {
                        vty_out(vty, "%-17s %-6s %-5s %-30s", buf1, "local",
-                                       zvni_print_mac_flags(mac, flags_buf,
+                                       zevpn_print_mac_flags(mac, flags_buf,
                                                sizeof(flags_buf)),
                                        ifp ? ifp->name : "-");
                } else {
@@ -1606,7 +1606,7 @@ static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
                if (json_mac_hdr == NULL) {
                        if ((wctx->flags & SHOW_REMOTE_MAC_FROM_VTEP) &&
                                        (wctx->count == 0)) {
-                               vty_out(vty, "\nVNI %u\n\n", wctx->zvni->vni);
+                               vty_out(vty, "\nVNI %u\n\n", wctx->zevpn->vni);
                                vty_out(vty, "%-17s %-6s %-5s%-30s %-5s %s\n",
                                        "MAC", "Type", "Flags",
                                        "Intf/Remote ES/VTEP",
@@ -1614,7 +1614,7 @@ static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
                        }
                        vty_out(vty, "%-17s %-6s %-5s %-30s %-5s %u/%u\n", buf1,
                                "remote",
-                               zvni_print_mac_flags(mac, flags_buf,
+                               zevpn_print_mac_flags(mac, flags_buf,
                                        sizeof(flags_buf)),
                                mac->es ?  mac->es->esi_str :
                                inet_ntoa(mac->fwd_info.r_vtep_ip),
@@ -1644,7 +1644,7 @@ static void zvni_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
 }
 
 /* Print Duplicate MAC */
-static void zvni_print_dad_mac_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_dad_mac_hash(struct hash_bucket *bucket, void *ctxt)
 {
        zebra_mac_t *mac;
 
@@ -1653,13 +1653,13 @@ static void zvni_print_dad_mac_hash(struct hash_bucket *bucket, void *ctxt)
                return;
 
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
-               zvni_print_mac_hash(bucket, ctxt);
+               zevpn_print_mac_hash(bucket, ctxt);
 }
 
 /*
  * Print MAC hash entry in detail - called for display of all MACs.
  */
-static void zvni_print_mac_hash_detail(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_mac_hash_detail(struct hash_bucket *bucket, void *ctxt)
 {
        struct vty *vty;
        json_object *json_mac_hdr = NULL;
@@ -1676,11 +1676,11 @@ static void zvni_print_mac_hash_detail(struct hash_bucket *bucket, void *ctxt)
        wctx->count++;
        prefix_mac2str(&mac->macaddr, buf1, sizeof(buf1));
 
-       zvni_print_mac(mac, vty, json_mac_hdr);
+       zevpn_print_mac(mac, vty, json_mac_hdr);
 }
 
 /* Print Duplicate MAC in detail */
-static void zvni_print_dad_mac_hash_detail(struct hash_bucket *bucket,
+static void zevpn_print_dad_mac_hash_detail(struct hash_bucket *bucket,
                                           void *ctxt)
 {
        zebra_mac_t *mac;
@@ -1690,18 +1690,18 @@ static void zvni_print_dad_mac_hash_detail(struct hash_bucket *bucket,
                return;
 
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
-               zvni_print_mac_hash_detail(bucket, ctxt);
+               zevpn_print_mac_hash_detail(bucket, ctxt);
 }
 
 /*
- * Print MACs for all VNI.
+ * Print MACs for all EVPNs.
  */
-static void zvni_print_mac_hash_all_vni(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_print_mac_hash_all_evpn(struct hash_bucket *bucket, void *ctxt)
 {
        struct vty *vty;
-       json_object *json = NULL, *json_vni = NULL;
+       json_object *json = NULL, *json_evpn = NULL;
        json_object *json_mac = NULL;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_macs;
        struct mac_walk_ctx *wctx = ctxt;
        char vni_str[VNI_STR_LEN];
@@ -1709,73 +1709,73 @@ static void zvni_print_mac_hash_all_vni(struct hash_bucket *bucket, void *ctxt)
        vty = wctx->vty;
        json = wctx->json;
 
-       zvni = (zebra_vni_t *)bucket->data;
-       wctx->zvni = zvni;
+       zevpn = (zebra_evpn_t *)bucket->data;
+       wctx->zevpn = zevpn;
 
        /*We are iterating over a new VNI, set the count to 0*/
        wctx->count = 0;
 
-       num_macs = num_valid_macs(zvni);
+       num_macs = num_valid_macs(zevpn);
        if (!num_macs)
                return;
 
        if (wctx->print_dup)
-               num_macs = num_dup_detected_macs(zvni);
+               num_macs = num_dup_detected_macs(zevpn);
 
        if (json) {
-               json_vni = json_object_new_object();
+               json_evpn = json_object_new_object();
                json_mac = json_object_new_object();
-               snprintf(vni_str, sizeof(vni_str), "%u", zvni->vni);
+               snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
        }
 
        if (!CHECK_FLAG(wctx->flags, SHOW_REMOTE_MAC_FROM_VTEP)) {
                if (json == NULL) {
                        vty_out(vty, "\nVNI %u #MACs (local and remote) %u\n\n",
-                               zvni->vni, num_macs);
+                               zevpn->vni, num_macs);
                        vty_out(vty,
                                "Flags: N=sync-neighs, I=local-inactive, P=peer-active, X=peer-proxy\n");
                        vty_out(vty, "%-17s %-6s %-5s %-30s %-5s %s\n", "MAC",
                                "Type", "Flags", "Intf/Remote ES/VTEP",
                                "VLAN", "Seq #'s");
                } else
-                       json_object_int_add(json_vni, "numMacs", num_macs);
+                       json_object_int_add(json_evpn, "numMacs", num_macs);
        }
 
        if (!num_macs) {
                if (json) {
-                       json_object_int_add(json_vni, "numMacs", num_macs);
-                       json_object_object_add(json, vni_str, json_vni);
+                       json_object_int_add(json_evpn, "numMacs", num_macs);
+                       json_object_object_add(json, vni_str, json_evpn);
                }
                return;
        }
 
-       /* assign per-vni to wctx->json object to fill macs
-        * under the vni. Re-assign primary json object to fill
-        * next vni information.
+       /* assign per-evpn to wctx->json object to fill macs
+        * under the evpn. Re-assign primary json object to fill
+        * next evpn information.
         */
        wctx->json = json_mac;
        if (wctx->print_dup)
-               hash_iterate(zvni->mac_table, zvni_print_dad_mac_hash, wctx);
+               hash_iterate(zevpn->mac_table, zevpn_print_dad_mac_hash, wctx);
        else
-               hash_iterate(zvni->mac_table, zvni_print_mac_hash, wctx);
+               hash_iterate(zevpn->mac_table, zevpn_print_mac_hash, wctx);
        wctx->json = json;
        if (json) {
                if (wctx->count)
-                       json_object_object_add(json_vni, "macs", json_mac);
-               json_object_object_add(json, vni_str, json_vni);
+                       json_object_object_add(json_evpn, "macs", json_mac);
+               json_object_object_add(json, vni_str, json_evpn);
        }
 }
 
 /*
- * Print MACs in detail for all VNI.
+ * Print MACs in detail for all EVPNs.
  */
-static void zvni_print_mac_hash_all_vni_detail(struct hash_bucket *bucket,
+static void zevpn_print_mac_hash_all_evpn_detail(struct hash_bucket *bucket,
                                               void *ctxt)
 {
        struct vty *vty;
-       json_object *json = NULL, *json_vni = NULL;
+       json_object *json = NULL, *json_evpn = NULL;
        json_object *json_mac = NULL;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_macs;
        struct mac_walk_ctx *wctx = ctxt;
        char vni_str[VNI_STR_LEN];
@@ -1783,52 +1783,52 @@ static void zvni_print_mac_hash_all_vni_detail(struct hash_bucket *bucket,
        vty = wctx->vty;
        json = wctx->json;
 
-       zvni = (zebra_vni_t *)bucket->data;
-       if (!zvni) {
+       zevpn = (zebra_evpn_t *)bucket->data;
+       if (!zevpn) {
                if (json)
                        vty_out(vty, "{}\n");
                return;
        }
-       wctx->zvni = zvni;
+       wctx->zevpn = zevpn;
 
-       /*We are iterating over a new VNI, set the count to 0*/
+       /*We are iterating over a new EVPN, set the count to 0*/
        wctx->count = 0;
 
-       num_macs = num_valid_macs(zvni);
+       num_macs = num_valid_macs(zevpn);
        if (!num_macs)
                return;
 
-       if (wctx->print_dup && (num_dup_detected_macs(zvni) == 0))
+       if (wctx->print_dup && (num_dup_detected_macs(zevpn) == 0))
                return;
 
        if (json) {
-               json_vni = json_object_new_object();
+               json_evpn = json_object_new_object();
                json_mac = json_object_new_object();
-               snprintf(vni_str, sizeof(vni_str), "%u", zvni->vni);
+               snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
        }
 
        if (!CHECK_FLAG(wctx->flags, SHOW_REMOTE_MAC_FROM_VTEP)) {
                if (json == NULL) {
                        vty_out(vty, "\nVNI %u #MACs (local and remote) %u\n\n",
-                               zvni->vni, num_macs);
+                               zevpn->vni, num_macs);
                } else
-                       json_object_int_add(json_vni, "numMacs", num_macs);
+                       json_object_int_add(json_evpn, "numMacs", num_macs);
        }
-       /* assign per-vni to wctx->json object to fill macs
-        * under the vni. Re-assign primary json object to fill
-        * next vni information.
+       /* assign per-evpn to wctx->json object to fill macs
+        * under the evpn. Re-assign primary json object to fill
+        * next evpn information.
         */
        wctx->json = json_mac;
        if (wctx->print_dup)
-               hash_iterate(zvni->mac_table, zvni_print_dad_mac_hash_detail,
+               hash_iterate(zevpn->mac_table, zevpn_print_dad_mac_hash_detail,
                             wctx);
        else
-               hash_iterate(zvni->mac_table, zvni_print_mac_hash_detail, wctx);
+               hash_iterate(zevpn->mac_table, zevpn_print_mac_hash_detail, wctx);
        wctx->json = json;
        if (json) {
                if (wctx->count)
-                       json_object_object_add(json_vni, "macs", json_mac);
-               json_object_object_add(json, vni_str, json_vni);
+                       json_object_object_add(json_evpn, "macs", json_mac);
+               json_object_object_add(json, vni_str, json_evpn);
        }
 }
 
@@ -1836,7 +1836,7 @@ static void zl3vni_print_nh_hash(struct hash_bucket *bucket, void *ctx)
 {
        struct nh_walk_ctx *wctx = NULL;
        struct vty *vty = NULL;
-       struct json_object *json_vni = NULL;
+       struct json_object *json_evpn = NULL;
        struct json_object *json_nh = NULL;
        zebra_neigh_t *n = NULL;
        char buf1[ETHER_ADDR_STRLEN];
@@ -1844,12 +1844,12 @@ static void zl3vni_print_nh_hash(struct hash_bucket *bucket, void *ctx)
 
        wctx = (struct nh_walk_ctx *)ctx;
        vty = wctx->vty;
-       json_vni = wctx->json;
-       if (json_vni)
+       json_evpn = wctx->json;
+       if (json_evpn)
                json_nh = json_object_new_object();
        n = (zebra_neigh_t *)bucket->data;
 
-       if (!json_vni) {
+       if (!json_evpn) {
                vty_out(vty, "%-15s %-17s\n",
                        ipaddr2str(&(n->ip), buf2, sizeof(buf2)),
                        prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
@@ -1859,7 +1859,7 @@ static void zl3vni_print_nh_hash(struct hash_bucket *bucket, void *ctx)
                json_object_string_add(
                        json_nh, "routerMac",
                        prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
-               json_object_object_add(json_vni,
+               json_object_object_add(json_evpn,
                                       ipaddr2str(&(n->ip), buf2, sizeof(buf2)),
                                       json_nh);
        }
@@ -1870,7 +1870,7 @@ static void zl3vni_print_nh_hash_all_vni(struct hash_bucket *bucket,
 {
        struct vty *vty = NULL;
        json_object *json = NULL;
-       json_object *json_vni = NULL;
+       json_object *json_evpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
        uint32_t num_nh = 0;
        struct nh_walk_ctx wctx;
@@ -1886,22 +1886,22 @@ static void zl3vni_print_nh_hash_all_vni(struct hash_bucket *bucket,
                return;
 
        if (json) {
-               json_vni = json_object_new_object();
-               snprintf(vni_str, sizeof(vni_str), "%u", zl3vni->vni);
+               json_evpn = json_object_new_object();
+               snprintf(vni_str, VNI_STR_LEN, "%u", zl3vni->vni);
        }
 
        if (json == NULL) {
                vty_out(vty, "\nVNI %u #Next-Hops %u\n\n", zl3vni->vni, num_nh);
                vty_out(vty, "%-15s %-17s\n", "IP", "RMAC");
        } else
-               json_object_int_add(json_vni, "numNextHops", num_nh);
+               json_object_int_add(json_evpn, "numNextHops", num_nh);
 
        memset(&wctx, 0, sizeof(struct nh_walk_ctx));
        wctx.vty = vty;
-       wctx.json = json_vni;
+       wctx.json = json_evpn;
        hash_iterate(zl3vni->nh_table, zl3vni_print_nh_hash, &wctx);
        if (json)
-               json_object_object_add(json, vni_str, json_vni);
+               json_object_object_add(json, vni_str, json_evpn);
 }
 
 static void zl3vni_print_rmac_hash_all_vni(struct hash_bucket *bucket,
@@ -1909,7 +1909,7 @@ static void zl3vni_print_rmac_hash_all_vni(struct hash_bucket *bucket,
 {
        struct vty *vty = NULL;
        json_object *json = NULL;
-       json_object *json_vni = NULL;
+       json_object *json_evpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
        uint32_t num_rmacs;
        struct rmac_walk_ctx wctx;
@@ -1925,15 +1925,15 @@ static void zl3vni_print_rmac_hash_all_vni(struct hash_bucket *bucket,
                return;
 
        if (json) {
-               json_vni = json_object_new_object();
-               snprintf(vni_str, sizeof(vni_str), "%u", zl3vni->vni);
+               json_evpn = json_object_new_object();
+               snprintf(vni_str, VNI_STR_LEN, "%u", zl3vni->vni);
        }
 
        if (json == NULL) {
                vty_out(vty, "\nVNI %u #RMACs %u\n\n", zl3vni->vni, num_rmacs);
                vty_out(vty, "%-17s %-21s\n", "RMAC", "Remote VTEP");
        } else
-               json_object_int_add(json_vni, "numRmacs", num_rmacs);
+               json_object_int_add(json_evpn, "numRmacs", num_rmacs);
 
        /* assign per-vni to wctx->json object to fill macs
         * under the vni. Re-assign primary json object to fill
@@ -1941,10 +1941,10 @@ static void zl3vni_print_rmac_hash_all_vni(struct hash_bucket *bucket,
         */
        memset(&wctx, 0, sizeof(struct rmac_walk_ctx));
        wctx.vty = vty;
-       wctx.json = json_vni;
+       wctx.json = json_evpn;
        hash_iterate(zl3vni->rmac_table, zl3vni_print_rmac_hash, &wctx);
        if (json)
-               json_object_object_add(json, vni_str, json_vni);
+               json_object_object_add(json, vni_str, json_evpn);
 }
 
 static void zl3vni_print_rmac_hash(struct hash_bucket *bucket, void *ctx)
@@ -1985,8 +1985,8 @@ static void zl3vni_print(zebra_l3vni_t *zl3vni, void **ctx)
        char buf[ETHER_ADDR_STRLEN];
        struct vty *vty = NULL;
        json_object *json = NULL;
-       zebra_vni_t *zvni = NULL;
-       json_object *json_vni_list = NULL;
+       zebra_evpn_t *zevpn = NULL;
+       json_object *json_evpn_list = NULL;
        struct listnode *node = NULL, *nnode = NULL;
 
        vty = ctx[0];
@@ -2011,11 +2011,11 @@ static void zl3vni_print(zebra_l3vni_t *zl3vni, void **ctx)
                vty_out(vty, "  Router MAC: %s\n",
                        zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
                vty_out(vty, "  L2 VNIs: ");
-               for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zvni))
-                       vty_out(vty, "%u ", zvni->vni);
+               for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zevpn))
+                       vty_out(vty, "%u ", zevpn->vni);
                vty_out(vty, "\n");
        } else {
-               json_vni_list = json_object_new_array();
+               json_evpn_list = json_object_new_array();
                json_object_int_add(json, "vni", zl3vni->vni);
                json_object_string_add(json, "type", "L3");
                json_object_string_add(json, "localVtepIp",
@@ -2037,18 +2037,18 @@ static void zl3vni_print(zebra_l3vni_t *zl3vni, void **ctx)
                        CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
                                ? "prefix-routes-only"
                                : "none");
-               for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zvni)) {
-                       json_object_array_add(json_vni_list,
-                                             json_object_new_int(zvni->vni));
+               for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zevpn)) {
+                       json_object_array_add(json_evpn_list,
+                                             json_object_new_int(zevpn->vni));
                }
-               json_object_object_add(json, "l2Vnis", json_vni_list);
+               json_object_object_add(json, "l2Vnis", json_evpn_list);
        }
 }
 
 /*
- * Print a specific VNI entry.
+ * Print a specific EVPN entry.
  */
-static void zvni_print(zebra_vni_t *zvni, void **ctxt)
+static void zevpn_print(zebra_evpn_t *zevpn, void **ctxt)
 {
        struct vty *vty;
        zebra_vtep_t *zvtep;
@@ -2062,44 +2062,44 @@ static void zvni_print(zebra_vni_t *zvni, void **ctxt)
        json = ctxt[1];
 
        if (json == NULL) {
-               vty_out(vty, "VNI: %u\n", zvni->vni);
+               vty_out(vty, "VNI: %u\n", zevpn->vni);
                vty_out(vty, " Type: %s\n", "L2");
-               vty_out(vty, " Tenant VRF: %s\n", vrf_id_to_name(zvni->vrf_id));
+               vty_out(vty, " Tenant VRF: %s\n", vrf_id_to_name(zevpn->vrf_id));
        } else {
-               json_object_int_add(json, "vni", zvni->vni);
+               json_object_int_add(json, "vni", zevpn->vni);
                json_object_string_add(json, "type", "L2");
                json_object_string_add(json, "vrf",
-                                      vrf_id_to_name(zvni->vrf_id));
+                                      vrf_id_to_name(zevpn->vrf_id));
        }
 
-       if (!zvni->vxlan_if) { // unexpected
+       if (!zevpn->vxlan_if) { // unexpected
                if (json == NULL)
                        vty_out(vty, " VxLAN interface: unknown\n");
                return;
        }
-       num_macs = num_valid_macs(zvni);
-       num_neigh = hashcount(zvni->neigh_table);
+       num_macs = num_valid_macs(zevpn);
+       num_neigh = hashcount(zevpn->neigh_table);
        if (json == NULL) {
-               vty_out(vty, " VxLAN interface: %s\n", zvni->vxlan_if->name);
-               vty_out(vty, " VxLAN ifIndex: %u\n", zvni->vxlan_if->ifindex);
+               vty_out(vty, " VxLAN interface: %s\n", zevpn->vxlan_if->name);
+               vty_out(vty, " VxLAN ifIndex: %u\n", zevpn->vxlan_if->ifindex);
                vty_out(vty, " Local VTEP IP: %s\n",
-                       inet_ntoa(zvni->local_vtep_ip));
+                       inet_ntoa(zevpn->local_vtep_ip));
                vty_out(vty, " Mcast group: %s\n",
-                               inet_ntoa(zvni->mcast_grp));
+                               inet_ntoa(zevpn->mcast_grp));
        } else {
                json_object_string_add(json, "vxlanInterface",
-                                      zvni->vxlan_if->name);
-               json_object_int_add(json, "ifindex", zvni->vxlan_if->ifindex);
+                                      zevpn->vxlan_if->name);
+               json_object_int_add(json, "ifindex", zevpn->vxlan_if->ifindex);
                json_object_string_add(json, "vtepIp",
-                                      inet_ntoa(zvni->local_vtep_ip));
+                                      inet_ntoa(zevpn->local_vtep_ip));
                json_object_string_add(json, "mcastGroup",
-                               inet_ntoa(zvni->mcast_grp));
+                               inet_ntoa(zevpn->mcast_grp));
                json_object_string_add(json, "advertiseGatewayMacip",
-                                      zvni->advertise_gw_macip ? "Yes" : "No");
+                                      zevpn->advertise_gw_macip ? "Yes" : "No");
                json_object_int_add(json, "numMacs", num_macs);
                json_object_int_add(json, "numArpNd", num_neigh);
        }
-       if (!zvni->vteps) {
+       if (!zevpn->vteps) {
                if (json == NULL)
                        vty_out(vty, " No remote VTEPs known for this VNI\n");
        } else {
@@ -2107,7 +2107,7 @@ static void zvni_print(zebra_vni_t *zvni, void **ctxt)
                        vty_out(vty, " Remote VTEPs for this VNI:\n");
                else
                        json_vtep_list = json_object_new_array();
-               for (zvtep = zvni->vteps; zvtep; zvtep = zvtep->next) {
+               for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
                        const char *flood_str = lookup_msg(zvtep_flood_str,
                                        zvtep->flood_control,
                                        VXLAN_FLOOD_STR_DEFAULT);
@@ -2135,7 +2135,7 @@ static void zvni_print(zebra_vni_t *zvni, void **ctxt)
                        " Number of ARPs (IPv4 and IPv6, local and remote) known for this VNI: %u\n",
                        num_neigh);
                vty_out(vty, " Advertise-gw-macip: %s\n",
-                       zvni->advertise_gw_macip ? "Yes" : "No");
+                       zevpn->advertise_gw_macip ? "Yes" : "No");
        }
 }
 
@@ -2144,7 +2144,7 @@ static void zl3vni_print_hash(struct hash_bucket *bucket, void *ctx[])
 {
        struct vty *vty = NULL;
        json_object *json = NULL;
-       json_object *json_vni = NULL;
+       json_object *json_evpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        vty = (struct vty *)ctx[0];
@@ -2161,25 +2161,25 @@ static void zl3vni_print_hash(struct hash_bucket *bucket, void *ctx[])
        } else {
                char vni_str[VNI_STR_LEN];
 
-               snprintf(vni_str, sizeof(vni_str), "%u", zl3vni->vni);
-               json_vni = json_object_new_object();
-               json_object_int_add(json_vni, "vni", zl3vni->vni);
-               json_object_string_add(json_vni, "vxlanIf",
+               snprintf(vni_str, VNI_STR_LEN, "%u", zl3vni->vni);
+               json_evpn = json_object_new_object();
+               json_object_int_add(json_evpn, "vni", zl3vni->vni);
+               json_object_string_add(json_evpn, "vxlanIf",
                                       zl3vni_vxlan_if_name(zl3vni));
-               json_object_int_add(json_vni, "numMacs",
+               json_object_int_add(json_evpn, "numMacs",
                                    hashcount(zl3vni->rmac_table));
-               json_object_int_add(json_vni, "numArpNd",
+               json_object_int_add(json_evpn, "numArpNd",
                                    hashcount(zl3vni->nh_table));
-               json_object_string_add(json_vni, "numRemoteVteps", "n/a");
-               json_object_string_add(json_vni, "type", "L3");
-               json_object_string_add(json_vni, "tenantVrf",
+               json_object_string_add(json_evpn, "numRemoteVteps", "n/a");
+               json_object_string_add(json_evpn, "type", "L3");
+               json_object_string_add(json_evpn, "tenantVrf",
                                       zl3vni_vrf_name(zl3vni));
-               json_object_object_add(json, vni_str, json_vni);
+               json_object_object_add(json, vni_str, json_evpn);
        }
 }
 
 /* Private Structure to pass callback data for hash iterator */
-struct zvni_evpn_show {
+struct zevpn_show {
        struct vty *vty;
        json_object *json;
        struct zebra_vrf *zvrf;
@@ -2193,7 +2193,7 @@ static void zl3vni_print_hash_detail(struct hash_bucket *bucket, void *data)
        zebra_l3vni_t *zl3vni = NULL;
        json_object *json_array = NULL;
        bool use_json = false;
-       struct zvni_evpn_show *zes = data;
+       struct zevpn_show *zes = data;
 
        vty = zes->vty;
        json_array = zes->json;
@@ -2210,87 +2210,87 @@ static void zl3vni_print_hash_detail(struct hash_bucket *bucket, void *data)
 
 
 /*
- * Print a VNI hash entry - called for display of all VNIs.
+ * Print an EVPN hash entry - called for display of all VNIs.
  */
-static void zvni_print_hash(struct hash_bucket *bucket, void *ctxt[])
+static void zevpn_print_hash(struct hash_bucket *bucket, void *ctxt[])
 {
        struct vty *vty;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_vtep_t *zvtep;
        uint32_t num_vteps = 0;
        uint32_t num_macs = 0;
        uint32_t num_neigh = 0;
        json_object *json = NULL;
-       json_object *json_vni = NULL;
+       json_object *json_evpn = NULL;
        json_object *json_ip_str = NULL;
        json_object *json_vtep_list = NULL;
 
        vty = ctxt[0];
        json = ctxt[1];
 
-       zvni = (zebra_vni_t *)bucket->data;
+       zevpn = (zebra_evpn_t *)bucket->data;
 
-       zvtep = zvni->vteps;
+       zvtep = zevpn->vteps;
        while (zvtep) {
                num_vteps++;
                zvtep = zvtep->next;
        }
 
-       num_macs = num_valid_macs(zvni);
-       num_neigh = hashcount(zvni->neigh_table);
+       num_macs = num_valid_macs(zevpn);
+       num_neigh = hashcount(zevpn->neigh_table);
        if (json == NULL)
                vty_out(vty, "%-10u %-4s %-21s %-8u %-8u %-15u %-37s\n",
-                       zvni->vni, "L2",
-                       zvni->vxlan_if ? zvni->vxlan_if->name : "unknown",
+                       zevpn->vni, "L2",
+                       zevpn->vxlan_if ? zevpn->vxlan_if->name : "unknown",
                        num_macs, num_neigh, num_vteps,
-                       vrf_id_to_name(zvni->vrf_id));
+                       vrf_id_to_name(zevpn->vrf_id));
        else {
                char vni_str[VNI_STR_LEN];
-               snprintf(vni_str, sizeof(vni_str), "%u", zvni->vni);
-               json_vni = json_object_new_object();
-               json_object_int_add(json_vni, "vni", zvni->vni);
-               json_object_string_add(json_vni, "type", "L2");
-               json_object_string_add(json_vni, "vxlanIf",
-                                      zvni->vxlan_if ? zvni->vxlan_if->name
+               snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
+               json_evpn = json_object_new_object();
+               json_object_int_add(json_evpn, "vni", zevpn->vni);
+               json_object_string_add(json_evpn, "type", "L2");
+               json_object_string_add(json_evpn, "vxlanIf",
+                                      zevpn->vxlan_if ? zevpn->vxlan_if->name
                                                      : "unknown");
-               json_object_int_add(json_vni, "numMacs", num_macs);
-               json_object_int_add(json_vni, "numArpNd", num_neigh);
-               json_object_int_add(json_vni, "numRemoteVteps", num_vteps);
-               json_object_string_add(json_vni, "tenantVrf",
-                                      vrf_id_to_name(zvni->vrf_id));
+               json_object_int_add(json_evpn, "numMacs", num_macs);
+               json_object_int_add(json_evpn, "numArpNd", num_neigh);
+               json_object_int_add(json_evpn, "numRemoteVteps", num_vteps);
+               json_object_string_add(json_evpn, "tenantVrf",
+                                      vrf_id_to_name(zevpn->vrf_id));
                if (num_vteps) {
                        json_vtep_list = json_object_new_array();
-                       for (zvtep = zvni->vteps; zvtep; zvtep = zvtep->next) {
+                       for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
                                json_ip_str = json_object_new_string(
                                        inet_ntoa(zvtep->vtep_ip));
                                json_object_array_add(json_vtep_list,
                                                      json_ip_str);
                        }
-                       json_object_object_add(json_vni, "remoteVteps",
+                       json_object_object_add(json_evpn, "remoteVteps",
                                               json_vtep_list);
                }
-               json_object_object_add(json, vni_str, json_vni);
+               json_object_object_add(json, vni_str, json_evpn);
        }
 }
 
 /*
- * Print a VNI hash entry in detail - called for display of all VNIs.
+ * Print an EVPN hash entry in detail - called for display of all EVPNs.
  */
-static void zvni_print_hash_detail(struct hash_bucket *bucket, void *data)
+static void zevpn_print_hash_detail(struct hash_bucket *bucket, void *data)
 {
        struct vty *vty;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        json_object *json_array = NULL;
        bool use_json = false;
-       struct zvni_evpn_show *zes = data;
+       struct zevpn_show *zes = data;
 
        vty = zes->vty;
        json_array = zes->json;
        use_json = zes->use_json;
 
-       zvni = (zebra_vni_t *)bucket->data;
+       zevpn = (zebra_evpn_t *)bucket->data;
 
-       zebra_vxlan_print_vni(vty, zes->zvrf, zvni->vni, use_json, json_array);
+       zebra_vxlan_print_vni(vty, zes->zvrf, zevpn->vni, use_json, json_array);
 
        if (!use_json)
                vty_out(vty, "\n");
@@ -2299,7 +2299,7 @@ static void zvni_print_hash_detail(struct hash_bucket *bucket, void *data)
 /*
  * Inform BGP about local MACIP.
  */
-static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
+static int zevpn_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
                                         struct ipaddr *ip, uint8_t flags,
                                         uint32_t seq, int state,
                                         struct zebra_evpn_es *es,
@@ -2407,7 +2407,7 @@ static int neigh_list_cmp(void *p1, void *p2)
 /*
  * Callback to allocate neighbor hash entry.
  */
-static void *zvni_neigh_alloc(void *p)
+static void *zevpn_neigh_alloc(void *p)
 {
        const zebra_neigh_t *tmp_n = p;
        zebra_neigh_t *n;
@@ -2421,7 +2421,7 @@ static void *zvni_neigh_alloc(void *p)
 /*
  * Add neighbor entry.
  */
-static zebra_neigh_t *zvni_neigh_add(zebra_vni_t *zvni, struct ipaddr *ip,
+static zebra_neigh_t *zevpn_neigh_add(zebra_evpn_t *zevpn, struct ipaddr *ip,
                struct ethaddr *mac, zebra_mac_t *zmac,
                uint32_t n_flags)
 {
@@ -2430,16 +2430,16 @@ static zebra_neigh_t *zvni_neigh_add(zebra_vni_t *zvni, struct ipaddr *ip,
 
        memset(&tmp_n, 0, sizeof(zebra_neigh_t));
        memcpy(&tmp_n.ip, ip, sizeof(struct ipaddr));
-       n = hash_get(zvni->neigh_table, &tmp_n, zvni_neigh_alloc);
+       n = hash_get(zevpn->neigh_table, &tmp_n, zevpn_neigh_alloc);
        assert(n);
 
        n->state = ZEBRA_NEIGH_INACTIVE;
-       n->zvni = zvni;
+       n->zevpn = zevpn;
        n->dad_ip_auto_recovery_timer = NULL;
        n->flags = n_flags;
 
        if (!zmac)
-               zmac = zvni_mac_lookup(zvni, mac);
+               zmac = zevpn_mac_lookup(zevpn, mac);
        zebra_vxlan_local_neigh_ref_mac(n, mac,
                        zmac, false /* send_mac_update */);
 
@@ -2449,7 +2449,7 @@ static zebra_neigh_t *zvni_neigh_add(zebra_vni_t *zvni, struct ipaddr *ip,
 /*
  * Delete neighbor entry.
  */
-static int zvni_neigh_del(zebra_vni_t *zvni, zebra_neigh_t *n)
+static int zevpn_neigh_del(zebra_evpn_t *zevpn, zebra_neigh_t *n)
 {
        zebra_neigh_t *tmp_n;
 
@@ -2460,7 +2460,7 @@ static int zvni_neigh_del(zebra_vni_t *zvni, zebra_neigh_t *n)
        THREAD_OFF(n->dad_ip_auto_recovery_timer);
 
        /* Free the VNI hash entry and allocated memory. */
-       tmp_n = hash_release(zvni->neigh_table, n);
+       tmp_n = hash_release(zevpn->neigh_table, n);
        XFREE(MTYPE_NEIGH, tmp_n);
 
        return 0;
@@ -2469,7 +2469,7 @@ static int zvni_neigh_del(zebra_vni_t *zvni, zebra_neigh_t *n)
 /*
  * Free neighbor hash entry (callback)
  */
-static void zvni_neigh_del_hash_entry(struct hash_bucket *bucket, void *arg)
+static void zevpn_neigh_del_hash_entry(struct hash_bucket *bucket, void *arg)
 {
        struct neigh_walk_ctx *wctx = arg;
        zebra_neigh_t *n = bucket->data;
@@ -2481,7 +2481,7 @@ static void zvni_neigh_del_hash_entry(struct hash_bucket *bucket, void *arg)
                && (n->flags & ZEBRA_NEIGH_REMOTE)
                && IPV4_ADDR_SAME(&n->r_vtep_ip, &wctx->r_vtep_ip))) {
                if (wctx->upd_client && (n->flags & ZEBRA_NEIGH_LOCAL))
-                       zvni_neigh_send_del_to_client(wctx->zvni->vni, &n->ip,
+                       zevpn_neigh_send_del_to_client(wctx->zevpn->vni, &n->ip,
                                        &n->emac, n->flags, n->state,
                                        false /*force*/);
 
@@ -2492,46 +2492,46 @@ static void zvni_neigh_del_hash_entry(struct hash_bucket *bucket, void *arg)
                                        true /* force_clear_static */,
                                        __func__);
                        if ((n->flags & ZEBRA_NEIGH_REMOTE))
-                               zvni_neigh_uninstall(wctx->zvni, n);
+                               zevpn_neigh_uninstall(wctx->zevpn, n);
                }
 
-               zvni_neigh_del(wctx->zvni, n);
+               zevpn_neigh_del(wctx->zevpn, n);
        }
 
        return;
 }
 
 /*
- * Delete all neighbor entries for this VNI.
+ * Delete all neighbor entries for this EVPN.
  */
-static void zvni_neigh_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+static void zevpn_neigh_del_all(zebra_evpn_t *zevpn, int uninstall, int upd_client,
                               uint32_t flags)
 {
        struct neigh_walk_ctx wctx;
 
-       if (!zvni->neigh_table)
+       if (!zevpn->neigh_table)
                return;
 
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.uninstall = uninstall;
        wctx.upd_client = upd_client;
        wctx.flags = flags;
 
-       hash_iterate(zvni->neigh_table, zvni_neigh_del_hash_entry, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_neigh_del_hash_entry, &wctx);
 }
 
 /*
  * Look up neighbor hash entry.
  */
-static zebra_neigh_t *zvni_neigh_lookup(zebra_vni_t *zvni, struct ipaddr *ip)
+static zebra_neigh_t *zevpn_neigh_lookup(zebra_evpn_t *zevpn, struct ipaddr *ip)
 {
        zebra_neigh_t tmp;
        zebra_neigh_t *n;
 
        memset(&tmp, 0, sizeof(tmp));
        memcpy(&tmp.ip, ip, sizeof(struct ipaddr));
-       n = hash_lookup(zvni->neigh_table, &tmp);
+       n = hash_lookup(zevpn->neigh_table, &tmp);
 
        return n;
 }
@@ -2540,7 +2540,7 @@ static zebra_neigh_t *zvni_neigh_lookup(zebra_vni_t *zvni, struct ipaddr *ip)
  * Process all neighbors associated with a MAC upon the MAC being learnt
  * locally or undergoing any other change (such as sequence number).
  */
-static void zvni_process_neigh_on_local_mac_change(zebra_vni_t *zvni,
+static void zevpn_process_neigh_on_local_mac_change(zebra_evpn_t *zevpn,
                zebra_mac_t *zmac, bool seq_change, bool es_change)
 {
        zebra_neigh_t *n = NULL;
@@ -2548,12 +2548,12 @@ static void zvni_process_neigh_on_local_mac_change(zebra_vni_t *zvni,
        struct zebra_vrf *zvrf = NULL;
        char buf[ETHER_ADDR_STRLEN];
 
-       zvrf = vrf_info_lookup(zvni->vxlan_if->vrf_id);
+       zvrf = vrf_info_lookup(zevpn->vxlan_if->vrf_id);
 
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug("Processing neighbors on local MAC %s %s, VNI %u",
                           prefix_mac2str(&zmac->macaddr, buf, sizeof(buf)),
-                          seq_change ? "CHANGE" : "ADD", zvni->vni);
+                          seq_change ? "CHANGE" : "ADD", zevpn->vni);
 
        /* Walk all neighbors and mark any inactive local neighbors as
         * active and/or update sequence number upon a move, and inform BGP.
@@ -2570,8 +2570,8 @@ static void zvni_process_neigh_on_local_mac_change(zebra_vni_t *zvni,
                                if (!(zvrf->dup_addr_detect &&
                                      zvrf->dad_freeze && !!CHECK_FLAG(n->flags,
                                                ZEBRA_NEIGH_DUPLICATE)))
-                                       zvni_neigh_send_add_to_client(
-                                               zvni->vni, &n->ip, &n->emac,
+                                       zevpn_neigh_send_add_to_client(
+                                               zevpn->vni, &n->ip, &n->emac,
                                                n->mac, n->flags, n->loc_seq);
                        }
                }
@@ -2582,7 +2582,7 @@ static void zvni_process_neigh_on_local_mac_change(zebra_vni_t *zvni,
  * Process all neighbors associated with a local MAC upon the MAC being
  * deleted.
  */
-static void zvni_process_neigh_on_local_mac_del(zebra_vni_t *zvni,
+static void zevpn_process_neigh_on_local_mac_del(zebra_evpn_t *zevpn,
                                                zebra_mac_t *zmac)
 {
        zebra_neigh_t *n = NULL;
@@ -2592,7 +2592,7 @@ static void zvni_process_neigh_on_local_mac_del(zebra_vni_t *zvni,
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug("Processing neighbors on local MAC %s DEL, VNI %u",
                           prefix_mac2str(&zmac->macaddr, buf, sizeof(buf)),
-                          zvni->vni);
+                          zevpn->vni);
 
        /* Walk all local neighbors and mark as inactive and inform
         * BGP, if needed.
@@ -2605,7 +2605,7 @@ static void zvni_process_neigh_on_local_mac_del(zebra_vni_t *zvni,
                        if (IS_ZEBRA_NEIGH_ACTIVE(n)) {
                                ZEBRA_NEIGH_SET_INACTIVE(n);
                                n->loc_seq = 0;
-                               zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+                               zevpn_neigh_send_del_to_client(zevpn->vni, &n->ip,
                                                &n->emac, n->flags,
                                                ZEBRA_NEIGH_ACTIVE,
                                                false /*force*/);
@@ -2618,7 +2618,7 @@ static void zvni_process_neigh_on_local_mac_del(zebra_vni_t *zvni,
  * Process all neighbors associated with a MAC upon the MAC being remotely
  * learnt.
  */
-static void zvni_process_neigh_on_remote_mac_add(zebra_vni_t *zvni,
+static void zevpn_process_neigh_on_remote_mac_add(zebra_evpn_t *zevpn,
                                                 zebra_mac_t *zmac)
 {
        zebra_neigh_t *n = NULL;
@@ -2628,7 +2628,7 @@ static void zvni_process_neigh_on_remote_mac_add(zebra_vni_t *zvni,
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug("Processing neighbors on remote MAC %s ADD, VNI %u",
                           prefix_mac2str(&zmac->macaddr, buf, sizeof(buf)),
-                          zvni->vni);
+                          zevpn->vni);
 
        /* Walk all local neighbors and mark as inactive and inform
         * BGP, if needed.
@@ -2638,7 +2638,7 @@ static void zvni_process_neigh_on_remote_mac_add(zebra_vni_t *zvni,
                        if (IS_ZEBRA_NEIGH_ACTIVE(n)) {
                                ZEBRA_NEIGH_SET_INACTIVE(n);
                                n->loc_seq = 0;
-                               zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+                               zevpn_neigh_send_del_to_client(zevpn->vni, &n->ip,
                                                &n->emac, n->flags,
                                                ZEBRA_NEIGH_ACTIVE,
                                                false /* force */);
@@ -2651,13 +2651,13 @@ static void zvni_process_neigh_on_remote_mac_add(zebra_vni_t *zvni,
  * Process all neighbors associated with a remote MAC upon the MAC being
  * deleted.
  */
-static void zvni_process_neigh_on_remote_mac_del(zebra_vni_t *zvni,
+static void zevpn_process_neigh_on_remote_mac_del(zebra_evpn_t *zevpn,
                                                 zebra_mac_t *zmac)
 {
        /* NOTE: Currently a NO-OP. */
 }
 
-static void zvni_probe_neigh_on_mac_add(zebra_vni_t *zvni, zebra_mac_t *zmac)
+static void zevpn_probe_neigh_on_mac_add(zebra_evpn_t *zevpn, zebra_mac_t *zmac)
 {
        zebra_neigh_t *nbr = NULL;
        struct listnode *node = NULL;
@@ -2665,14 +2665,14 @@ static void zvni_probe_neigh_on_mac_add(zebra_vni_t *zvni, zebra_mac_t *zmac)
        for (ALL_LIST_ELEMENTS_RO(zmac->neigh_list, node, nbr)) {
                if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL) &&
                    IS_ZEBRA_NEIGH_INACTIVE(nbr))
-                       zvni_neigh_probe(zvni, nbr);
+                       zevpn_neigh_probe(zevpn, nbr);
        }
 }
 
 /*
  * Inform BGP about local neighbor addition.
  */
-static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
+static int zevpn_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
                                         struct ethaddr *macaddr,
                                         zebra_mac_t *zmac,
                                         uint32_t neigh_flags,
@@ -2703,7 +2703,7 @@ static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
        if (CHECK_FLAG(neigh_flags, ZEBRA_NEIGH_SVI_IP))
                SET_FLAG(flags, ZEBRA_MACIP_TYPE_SVI_IP);
 
-       return zvni_macip_send_msg_to_client(vni, macaddr, ip, flags,
+       return zevpn_macip_send_msg_to_client(vni, macaddr, ip, flags,
                        seq, ZEBRA_NEIGH_ACTIVE,
                        zmac ? zmac->es : NULL,
                        ZEBRA_MACIP_ADD);
@@ -2712,7 +2712,7 @@ static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
 /*
  * Inform BGP about local neighbor deletion.
  */
-static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
+static int zevpn_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
                struct ethaddr *macaddr, uint32_t flags,
                int state, bool force)
 {
@@ -2723,14 +2723,14 @@ static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
                        return 0;
        }
 
-       return zvni_macip_send_msg_to_client(vni, macaddr, ip, flags,
+       return zevpn_macip_send_msg_to_client(vni, macaddr, ip, flags,
                        0, state, NULL, ZEBRA_MACIP_DEL);
 }
 
 /*
  * Install remote neighbor into the kernel.
  */
-static int zvni_rem_neigh_install(zebra_vni_t *zvni, zebra_neigh_t *n,
+static int zevpn_rem_neigh_install(zebra_evpn_t *zevpn, zebra_neigh_t *n,
                bool was_static)
 {
        struct zebra_if *zif;
@@ -2742,12 +2742,12 @@ static int zvni_rem_neigh_install(zebra_vni_t *zvni, zebra_neigh_t *n,
        if (!(n->flags & ZEBRA_NEIGH_REMOTE))
                return 0;
 
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (!zif)
                return -1;
        vxl = &zif->l2info.vxl;
 
-       vlan_if = zvni_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
+       vlan_if = zevpn_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
        if (!vlan_if)
                return -1;
 
@@ -2765,7 +2765,7 @@ static int zvni_rem_neigh_install(zebra_vni_t *zvni, zebra_neigh_t *n,
 /*
  * Uninstall remote neighbor from the kernel.
  */
-static int zvni_neigh_uninstall(zebra_vni_t *zvni, zebra_neigh_t *n)
+static int zevpn_neigh_uninstall(zebra_evpn_t *zevpn, zebra_neigh_t *n)
 {
        struct zebra_if *zif;
        struct zebra_l2info_vxlan *vxl;
@@ -2774,18 +2774,18 @@ static int zvni_neigh_uninstall(zebra_vni_t *zvni, zebra_neigh_t *n)
        if (!(n->flags & ZEBRA_NEIGH_REMOTE))
                return 0;
 
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("VNI %u hash %p couldn't be uninstalled - no intf",
-                                  zvni->vni, zvni);
+                                  zevpn->vni, zevpn);
                return -1;
        }
 
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (!zif)
                return -1;
        vxl = &zif->l2info.vxl;
-       vlan_if = zvni_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
+       vlan_if = zevpn_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
        if (!vlan_if)
                return -1;
 
@@ -2800,18 +2800,18 @@ static int zvni_neigh_uninstall(zebra_vni_t *zvni, zebra_neigh_t *n)
 /*
  * Probe neighbor from the kernel.
  */
-static int zvni_neigh_probe(zebra_vni_t *zvni, zebra_neigh_t *n)
+static int zevpn_neigh_probe(zebra_evpn_t *zevpn, zebra_neigh_t *n)
 {
        struct zebra_if *zif;
        struct zebra_l2info_vxlan *vxl;
        struct interface *vlan_if;
 
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (!zif)
                return -1;
        vxl = &zif->l2info.vxl;
 
-       vlan_if = zvni_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
+       vlan_if = zevpn_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
        if (!vlan_if)
                return -1;
 
@@ -2823,7 +2823,7 @@ static int zvni_neigh_probe(zebra_vni_t *zvni, zebra_neigh_t *n)
 /*
  * Install neighbor hash entry - called upon access VLAN change.
  */
-static void zvni_install_neigh_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_install_neigh_hash(struct hash_bucket *bucket, void *ctxt)
 {
        zebra_neigh_t *n;
        struct neigh_walk_ctx *wctx = ctxt;
@@ -2831,7 +2831,7 @@ static void zvni_install_neigh_hash(struct hash_bucket *bucket, void *ctxt)
        n = (zebra_neigh_t *)bucket->data;
 
        if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE))
-               zvni_rem_neigh_install(wctx->zvni, n, false /*was_static*/);
+               zevpn_rem_neigh_install(wctx->zevpn, n, false /*was_static*/);
 }
 
 /* Get the VRR interface for SVI if any */
@@ -2859,7 +2859,7 @@ struct interface *zebra_get_vrr_intf_for_svi(struct interface *ifp)
        return NULL;
 }
 
-static int zvni_del_macip_for_intf(struct interface *ifp, zebra_vni_t *zvni)
+static int zevpn_del_macip_for_intf(struct interface *ifp, zebra_evpn_t *zevpn)
 {
        struct listnode *cnode = NULL, *cnnode = NULL;
        struct connected *c = NULL;
@@ -2886,13 +2886,13 @@ static int zvni_del_macip_for_intf(struct interface *ifp, zebra_vni_t *zvni)
                        continue;
                }
 
-               zvni_gw_macip_del(ifp, zvni, &ip);
+               zevpn_gw_macip_del(ifp, zevpn, &ip);
        }
 
        return 0;
 }
 
-static int zvni_add_macip_for_intf(struct interface *ifp, zebra_vni_t *zvni)
+static int zevpn_add_macip_for_intf(struct interface *ifp, zebra_evpn_t *zevpn)
 {
        struct listnode *cnode = NULL, *cnnode = NULL;
        struct connected *c = NULL;
@@ -2919,13 +2919,13 @@ static int zvni_add_macip_for_intf(struct interface *ifp, zebra_vni_t *zvni)
                        continue;
                }
 
-               zvni_gw_macip_add(ifp, zvni, &macaddr, &ip);
+               zevpn_gw_macip_add(ifp, zevpn, &macaddr, &ip);
        }
        return 0;
 }
 
 
-static int zvni_advertise_subnet(zebra_vni_t *zvni, struct interface *ifp,
+static int zevpn_advertise_subnet(zebra_evpn_t *zevpn, struct interface *ifp,
                                 int advertise)
 {
        struct listnode *cnode = NULL, *cnnode = NULL;
@@ -2955,9 +2955,9 @@ static int zvni_advertise_subnet(zebra_vni_t *zvni, struct interface *ifp,
 }
 
 /*
- * zvni_gw_macip_add_to_client
+ * zevpn_gw_macip_add_to_client
  */
-static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
+static int zevpn_gw_macip_add(struct interface *ifp, zebra_evpn_t *zevpn,
                             struct ethaddr *macaddr, struct ipaddr *ip)
 {
        char buf[ETHER_ADDR_STRLEN];
@@ -2967,15 +2967,15 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
 
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (!zif)
                return -1;
 
        vxl = &zif->l2info.vxl;
 
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac) {
-               mac = zvni_mac_add(zvni, macaddr);
+               mac = zevpn_mac_add(zevpn, macaddr);
                if (!mac) {
                        flog_err(EC_ZEBRA_MAC_ADD_FAILED,
                                 "Failed to add MAC %s intf %s(%u) VID %u",
@@ -2993,16 +2993,16 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
        mac->fwd_info.local.ifindex = ifp->ifindex;
        mac->fwd_info.local.vid = vxl->access_vlan;
 
-       n = zvni_neigh_lookup(zvni, ip);
+       n = zevpn_neigh_lookup(zevpn, ip);
        if (!n) {
-               n = zvni_neigh_add(zvni, ip, macaddr, mac, 0);
+               n = zevpn_neigh_add(zevpn, ip, macaddr, mac, 0);
                if (!n) {
                        flog_err(
                                EC_ZEBRA_MAC_ADD_FAILED,
                                "Failed to add neighbor %s MAC %s intf %s(%u) -> VNI %u",
                                ipaddr2str(ip, buf2, sizeof(buf2)),
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               ifp->name, ifp->ifindex, zvni->vni);
+                               ifp->name, ifp->ifindex, zevpn->vni);
                        return -1;
                }
        }
@@ -3014,7 +3014,7 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
        n->ifindex = ifp->ifindex;
 
        /* Only advertise in BGP if the knob is enabled */
-       if (advertise_gw_macip_enabled(zvni)) {
+       if (advertise_gw_macip_enabled(zevpn)) {
 
                SET_FLAG(mac->flags, ZEBRA_MAC_DEF_GW);
                SET_FLAG(n->flags, ZEBRA_NEIGH_DEF_GW);
@@ -3025,23 +3025,23 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                        "SVI %s(%u) L2-VNI %u, sending GW MAC %s IP %s add to BGP with flags 0x%x",
-                       ifp->name, ifp->ifindex, zvni->vni,
+                       ifp->name, ifp->ifindex, zevpn->vni,
                        prefix_mac2str(macaddr, buf, sizeof(buf)),
                        ipaddr2str(ip, buf2, sizeof(buf2)), n->flags);
 
-               zvni_neigh_send_add_to_client(zvni->vni, ip, &n->emac, n->mac,
+               zevpn_neigh_send_add_to_client(zevpn->vni, ip, &n->emac, n->mac,
                                              n->flags, n->loc_seq);
-       } else if (advertise_svi_macip_enabled(zvni)) {
+       } else if (advertise_svi_macip_enabled(zevpn)) {
 
                SET_FLAG(n->flags, ZEBRA_NEIGH_SVI_IP);
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                        "SVI %s(%u) L2-VNI %u, sending SVI MAC %s IP %s add to BGP with flags 0x%x",
-                       ifp->name, ifp->ifindex, zvni->vni,
+                       ifp->name, ifp->ifindex, zevpn->vni,
                        prefix_mac2str(macaddr, buf, sizeof(buf)),
                        ipaddr2str(ip, buf2, sizeof(buf2)), n->flags);
 
-               zvni_neigh_send_add_to_client(zvni->vni, ip, &n->emac, n->mac,
+               zevpn_neigh_send_add_to_client(zevpn->vni, ip, &n->emac, n->mac,
                                              n->flags, n->loc_seq);
        }
 
@@ -3049,9 +3049,9 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
 }
 
 /*
- * zvni_gw_macip_del_from_client
+ * zevpn_gw_macip_del_from_client
  */
-static int zvni_gw_macip_del(struct interface *ifp, zebra_vni_t *zvni,
+static int zevpn_gw_macip_del(struct interface *ifp, zebra_evpn_t *zevpn,
                             struct ipaddr *ip)
 {
        char buf1[ETHER_ADDR_STRLEN];
@@ -3060,19 +3060,19 @@ static int zvni_gw_macip_del(struct interface *ifp, zebra_vni_t *zvni,
        zebra_mac_t *mac = NULL;
 
        /* If the neigh entry is not present nothing to do*/
-       n = zvni_neigh_lookup(zvni, ip);
+       n = zevpn_neigh_lookup(zevpn, ip);
        if (!n)
                return 0;
 
        /* mac entry should be present */
-       mac = zvni_mac_lookup(zvni, &n->emac);
+       mac = zevpn_mac_lookup(zevpn, &n->emac);
        if (!mac) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("MAC %s doesn't exist for neigh %s on VNI %u",
                                   prefix_mac2str(&n->emac,
                                                  buf1, sizeof(buf1)),
                                   ipaddr2str(ip, buf2, sizeof(buf2)),
-                                  zvni->vni);
+                                  zevpn->vni);
                return -1;
        }
 
@@ -3084,29 +3084,29 @@ static int zvni_gw_macip_del(struct interface *ifp, zebra_vni_t *zvni,
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug(
                        "%u:SVI %s(%u) VNI %u, sending GW MAC %s IP %s del to BGP",
-                       ifp->vrf_id, ifp->name, ifp->ifindex, zvni->vni,
+                       ifp->vrf_id, ifp->name, ifp->ifindex, zevpn->vni,
                        prefix_mac2str(&(n->emac), buf1, sizeof(buf1)),
                        ipaddr2str(ip, buf2, sizeof(buf2)));
 
        /* Remove neighbor from BGP. */
-       zvni_neigh_send_del_to_client(zvni->vni, &n->ip, &n->emac,
+       zevpn_neigh_send_del_to_client(zevpn->vni, &n->ip, &n->emac,
                                      n->flags, ZEBRA_NEIGH_ACTIVE,
                                      false /*force*/);
 
        /* Delete this neighbor entry. */
-       zvni_neigh_del(zvni, n);
+       zevpn_neigh_del(zevpn, n);
 
        /* see if the mac needs to be deleted as well*/
        if (mac)
-               zvni_deref_ip2mac(zvni, mac);
+               zevpn_deref_ip2mac(zevpn, mac);
 
        return 0;
 }
 
-static void zvni_gw_macip_del_for_vni_hash(struct hash_bucket *bucket,
+static void zevpn_gw_macip_del_for_evpn_hash(struct hash_bucket *bucket,
                                           void *ctxt)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan zl2_info;
        struct interface *vlan_if = NULL;
@@ -3114,19 +3114,19 @@ static void zvni_gw_macip_del_for_vni_hash(struct hash_bucket *bucket,
        struct interface *ifp;
 
        /* Add primary SVI MAC*/
-       zvni = (zebra_vni_t *)bucket->data;
+       zevpn = (zebra_evpn_t *)bucket->data;
 
        /* Global (Zvrf) advertise-default-gw is disabled,
-        * but zvni advertise-default-gw is enabled
+        * but zevpn advertise-default-gw is enabled
         */
-       if (zvni->advertise_gw_macip) {
+       if (zevpn->advertise_gw_macip) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("VNI: %u GW-MACIP enabled, retain gw-macip",
-                                  zvni->vni);
+                                  zevpn->vni);
                return;
        }
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        if (!ifp)
                return;
        zif = ifp->info;
@@ -3138,34 +3138,34 @@ static void zvni_gw_macip_del_for_vni_hash(struct hash_bucket *bucket,
        zl2_info = zif->l2info.vxl;
 
        vlan_if =
-               zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
+               zevpn_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
        if (!vlan_if)
                return;
 
        /* Del primary MAC-IP */
-       zvni_del_macip_for_intf(vlan_if, zvni);
+       zevpn_del_macip_for_intf(vlan_if, zevpn);
 
        /* Del VRR MAC-IP - if any*/
        vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
        if (vrr_if)
-               zvni_del_macip_for_intf(vrr_if, zvni);
+               zevpn_del_macip_for_intf(vrr_if, zevpn);
 
        return;
 }
 
-static void zvni_gw_macip_add_for_vni_hash(struct hash_bucket *bucket,
+static void zevpn_gw_macip_add_for_evpn_hash(struct hash_bucket *bucket,
                                           void *ctxt)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan zl2_info;
        struct interface *vlan_if = NULL;
        struct interface *vrr_if = NULL;
        struct interface *ifp = NULL;
 
-       zvni = (zebra_vni_t *)bucket->data;
+       zevpn = (zebra_evpn_t *)bucket->data;
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        if (!ifp)
                return;
        zif = ifp->info;
@@ -3176,48 +3176,48 @@ static void zvni_gw_macip_add_for_vni_hash(struct hash_bucket *bucket,
        zl2_info = zif->l2info.vxl;
 
        vlan_if =
-               zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
+               zevpn_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
        if (!vlan_if)
                return;
 
        /* Add primary SVI MAC-IP */
-       zvni_add_macip_for_intf(vlan_if, zvni);
+       zevpn_add_macip_for_intf(vlan_if, zevpn);
 
-       if (advertise_gw_macip_enabled(zvni)) {
+       if (advertise_gw_macip_enabled(zevpn)) {
                /* Add VRR MAC-IP - if any*/
                vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
                if (vrr_if)
-                       zvni_add_macip_for_intf(vrr_if, zvni);
+                       zevpn_add_macip_for_intf(vrr_if, zevpn);
        }
 
        return;
 }
 
-static void zvni_svi_macip_del_for_vni_hash(struct hash_bucket *bucket,
+static void zevpn_svi_macip_del_for_evpn_hash(struct hash_bucket *bucket,
                                           void *ctxt)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan zl2_info;
        struct interface *vlan_if = NULL;
        struct interface *ifp;
 
        /* Add primary SVI MAC*/
-       zvni = (zebra_vni_t *)bucket->data;
-       if (!zvni)
+       zevpn = (zebra_evpn_t *)bucket->data;
+       if (!zevpn)
                return;
 
-       /* Global(vrf) advertise-svi-ip disabled, but zvni advertise-svi-ip
+       /* Global(vrf) advertise-svi-ip disabled, but zevpn advertise-svi-ip
         * enabled
         */
-       if (zvni->advertise_svi_macip) {
+       if (zevpn->advertise_svi_macip) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("VNI: %u SVI-MACIP enabled, retain svi-macip",
-                                  zvni->vni);
+                                  zevpn->vni);
                return;
        }
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        if (!ifp)
                return;
        zif = ifp->info;
@@ -3228,18 +3228,18 @@ static void zvni_svi_macip_del_for_vni_hash(struct hash_bucket *bucket,
 
        zl2_info = zif->l2info.vxl;
 
-       vlan_if = zvni_map_to_svi(zl2_info.access_vlan,
+       vlan_if = zevpn_map_to_svi(zl2_info.access_vlan,
                                  zif->brslave_info.br_if);
        if (!vlan_if)
                return;
 
        /* Del primary MAC-IP */
-       zvni_del_macip_for_intf(vlan_if, zvni);
+       zevpn_del_macip_for_intf(vlan_if, zevpn);
 
        return;
 }
 
-static inline void zvni_local_neigh_update_log(const char *pfx,
+static inline void zevpn_local_neigh_update_log(const char *pfx,
                zebra_neigh_t *n, bool is_router, bool local_inactive,
                bool old_bgp_ready, bool new_bgp_ready,
                bool inform_dataplane, bool inform_bgp, const char *sfx)
@@ -3251,7 +3251,7 @@ static inline void zvni_local_neigh_update_log(const char *pfx,
                return;
 
        zlog_debug("%s neigh vni %u ip %s mac %s f 0x%x%s%s%s%s%s%s %s",
-               pfx, n->zvni->vni,
+               pfx, n->zevpn->vni,
                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                prefix_mac2str(&n->emac, macbuf, sizeof(macbuf)),
                n->flags, is_router ? " router" : "",
@@ -3263,7 +3263,7 @@ static inline void zvni_local_neigh_update_log(const char *pfx,
                sfx);
 }
 
-static int zvni_local_neigh_update(zebra_vni_t *zvni,
+static int zevpn_local_neigh_update(zebra_evpn_t *zevpn,
                                   struct interface *ifp,
                                   struct ipaddr *ip,
                                   struct ethaddr *macaddr,
@@ -3289,20 +3289,20 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
        bool new_bgp_ready;
 
        /* Check if the MAC exists. */
-       zmac = zvni_mac_lookup(zvni, macaddr);
+       zmac = zevpn_mac_lookup(zevpn, macaddr);
        if (!zmac) {
                /* create a dummy MAC if the MAC is not already present */
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                                "AUTO MAC %s created for neigh %s on VNI %u",
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               ipaddr2str(ip, buf2, sizeof(buf2)), zvni->vni);
+                               ipaddr2str(ip, buf2, sizeof(buf2)), zevpn->vni);
 
-               zmac = zvni_mac_add(zvni, macaddr);
+               zmac = zevpn_mac_add(zevpn, macaddr);
                if (!zmac) {
                        zlog_debug("Failed to add MAC %s VNI %u",
                                   prefix_mac2str(macaddr, buf, sizeof(buf)),
-                                  zvni->vni);
+                                  zevpn->vni);
                        return -1;
                }
 
@@ -3322,26 +3322,26 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
                }
        }
 
-       zvrf = vrf_info_lookup(zvni->vxlan_if->vrf_id);
+       zvrf = vrf_info_lookup(zevpn->vxlan_if->vrf_id);
        if (!zvrf) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("        Unable to find vrf for: %d",
-                                  zvni->vxlan_if->vrf_id);
+                                  zevpn->vxlan_if->vrf_id);
                return -1;
        }
 
        /* Check if the neighbor exists. */
-       n = zvni_neigh_lookup(zvni, ip);
+       n = zevpn_neigh_lookup(zevpn, ip);
        if (!n) {
                /* New neighbor - create */
-               n = zvni_neigh_add(zvni, ip, macaddr, zmac, 0);
+               n = zevpn_neigh_add(zevpn, ip, macaddr, zmac, 0);
                if (!n) {
                        flog_err(
                                EC_ZEBRA_MAC_ADD_FAILED,
                                "Failed to add neighbor %s MAC %s intf %s(%u) -> VNI %u",
                                ipaddr2str(ip, buf2, sizeof(buf2)),
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               ifp->name, ifp->ifindex, zvni->vni);
+                               ifp->name, ifp->ifindex, zevpn->vni);
                        return -1;
                }
                /* Set "local" forwarding info. */
@@ -3406,7 +3406,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
                                                    CHECK_FLAG(n->flags,
                                                        ZEBRA_NEIGH_DUPLICATE));
 
-                               zvni_local_neigh_update_log("local", n,
+                               zevpn_local_neigh_update_log("local", n,
                                        is_router, local_inactive,
                                        old_bgp_ready, new_bgp_ready,
                                        false, false, "flag-update");
@@ -3433,7 +3433,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
                         * in different situations.
                         */
                        if (old_bgp_ready) {
-                               zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+                               zevpn_neigh_send_del_to_client(zevpn->vni, &n->ip,
                                              &n->emac, n->flags, n->state,
                                              false /*force*/);
                                old_bgp_ready = false;
@@ -3535,7 +3535,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
        if (zebra_vxlan_ip_inherit_dad_from_mac(zvrf, old_zmac, zmac, n)) {
                flog_warn(EC_ZEBRA_DUP_IP_INHERIT_DETECTED,
                        "VNI %u: MAC %s IP %s detected as duplicate during local update, inherit duplicate from MAC",
-                       zvni->vni,
+                       zevpn->vni,
                        prefix_mac2str(macaddr, buf, sizeof(buf)),
                        ipaddr2str(&n->ip, buf2, sizeof(buf2)));
        }
@@ -3559,7 +3559,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
         * learnt. If not, force neighbor to be inactive and reset its seq.
         */
        if (!CHECK_FLAG(zmac->flags, ZEBRA_MAC_LOCAL)) {
-               zvni_local_neigh_update_log("local",
+               zevpn_local_neigh_update_log("local",
                                n, is_router, local_inactive,
                                false, false, inform_dataplane, false,
                                "auto-mac");
@@ -3569,7 +3569,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
                return 0;
        }
 
-       zvni_local_neigh_update_log("local",
+       zevpn_local_neigh_update_log("local",
                n, is_router, local_inactive, false, false, inform_dataplane,
                true, created ? "created" : "updated");
 
@@ -3581,12 +3581,12 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("Seq changed for MAC %s VNI %u - old %u new %u",
                                   prefix_mac2str(macaddr, buf, sizeof(buf)),
-                                  zvni->vni, zmac->loc_seq, mac_new_seq);
+                                  zevpn->vni, zmac->loc_seq, mac_new_seq);
                zmac->loc_seq = mac_new_seq;
-               if (zvni_mac_send_add_to_client(zvni->vni, macaddr,
+               if (zevpn_mac_send_add_to_client(zevpn->vni, macaddr,
                                        zmac->flags, zmac->loc_seq, zmac->es))
                        return -1;
-               zvni_process_neigh_on_local_mac_change(zvni, zmac, 1,
+               zevpn_process_neigh_on_local_mac_change(zevpn, zmac, 1,
                                0 /*es_change*/);
                return 0;
        }
@@ -3606,7 +3606,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
        return 0;
 }
 
-static int zvni_remote_neigh_update(zebra_vni_t *zvni,
+static int zevpn_remote_neigh_update(zebra_evpn_t *zevpn,
                                    struct interface *ifp,
                                    struct ipaddr *ip,
                                    struct ethaddr *macaddr,
@@ -3618,7 +3618,7 @@ static int zvni_remote_neigh_update(zebra_vni_t *zvni,
        zebra_mac_t *zmac = NULL;
 
        /* If the neighbor is unknown, there is no further action. */
-       n = zvni_neigh_lookup(zvni, ip);
+       n = zevpn_neigh_lookup(zevpn, ip);
        if (!n)
                return 0;
 
@@ -3626,7 +3626,7 @@ static int zvni_remote_neigh_update(zebra_vni_t *zvni,
        if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
 #ifdef GNU_LINUX
                if (state & NUD_STALE)
-                       zvni_rem_neigh_install(zvni, n, false /*was_static*/);
+                       zevpn_rem_neigh_install(zevpn, n, false /*was_static*/);
 #endif
        } else {
                /* We got a "remote" neighbor notification for an entry
@@ -3634,13 +3634,13 @@ static int zvni_remote_neigh_update(zebra_vni_t *zvni,
                 * scenario - but only if the MAC is already "remote".
                 * Just mark our entry as "remote".
                 */
-               zmac = zvni_mac_lookup(zvni, macaddr);
+               zmac = zevpn_mac_lookup(zevpn, macaddr);
                if (!zmac || !CHECK_FLAG(zmac->flags, ZEBRA_MAC_REMOTE)) {
                        zlog_debug(
                                "Ignore remote neigh %s (MAC %s) on L2-VNI %u - MAC unknown or local",
                                ipaddr2str(&n->ip, buf2, sizeof(buf2)),
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               zvni->vni);
+                               zevpn->vni);
                        return -1;
                }
 
@@ -3685,7 +3685,7 @@ static bool mac_cmp(const void *p1, const void *p2)
 /*
  * Callback to allocate MAC hash entry.
  */
-static void *zvni_mac_alloc(void *p)
+static void *zevpn_mac_alloc(void *p)
 {
        const zebra_mac_t *tmp_mac = p;
        zebra_mac_t *mac;
@@ -3699,17 +3699,17 @@ static void *zvni_mac_alloc(void *p)
 /*
  * Add MAC entry.
  */
-static zebra_mac_t *zvni_mac_add(zebra_vni_t *zvni, struct ethaddr *macaddr)
+static zebra_mac_t *zevpn_mac_add(zebra_evpn_t *zevpn, struct ethaddr *macaddr)
 {
        zebra_mac_t tmp_mac;
        zebra_mac_t *mac = NULL;
 
        memset(&tmp_mac, 0, sizeof(zebra_mac_t));
        memcpy(&tmp_mac.macaddr, macaddr, ETH_ALEN);
-       mac = hash_get(zvni->mac_table, &tmp_mac, zvni_mac_alloc);
+       mac = hash_get(zevpn->mac_table, &tmp_mac, zevpn_mac_alloc);
        assert(mac);
 
-       mac->zvni = zvni;
+       mac->zevpn = zevpn;
        mac->dad_mac_auto_recovery_timer = NULL;
 
        mac->neigh_list = list_new();
@@ -3730,7 +3730,7 @@ static zebra_mac_t *zvni_mac_add(zebra_vni_t *zvni, struct ethaddr *macaddr)
 /*
  * Delete MAC entry.
  */
-static int zvni_mac_del(zebra_vni_t *zvni, zebra_mac_t *mac)
+static int zevpn_mac_del(zebra_evpn_t *zevpn, zebra_mac_t *mac)
 {
        zebra_mac_t *tmp_mac;
 
@@ -3756,13 +3756,13 @@ static int zvni_mac_del(zebra_vni_t *zvni, zebra_mac_t *mac)
        list_delete(&mac->neigh_list);
 
        /* Free the VNI hash entry and allocated memory. */
-       tmp_mac = hash_release(zvni->mac_table, mac);
+       tmp_mac = hash_release(zevpn->mac_table, mac);
        XFREE(MTYPE_MAC, tmp_mac);
 
        return 0;
 }
 
-static bool zvni_check_mac_del_from_db(struct mac_walk_ctx *wctx,
+static bool zevpn_check_mac_del_from_db(struct mac_walk_ctx *wctx,
                                       zebra_mac_t *mac)
 {
        if ((wctx->flags & DEL_LOCAL_MAC) &&
@@ -3797,14 +3797,14 @@ static bool zvni_check_mac_del_from_db(struct mac_walk_ctx *wctx,
 /*
  * Free MAC hash entry (callback)
  */
-static void zvni_mac_del_hash_entry(struct hash_bucket *bucket, void *arg)
+static void zevpn_mac_del_hash_entry(struct hash_bucket *bucket, void *arg)
 {
        struct mac_walk_ctx *wctx = arg;
        zebra_mac_t *mac = bucket->data;
 
-       if (zvni_check_mac_del_from_db(wctx, mac)) {
+       if (zevpn_check_mac_del_from_db(wctx, mac)) {
                if (wctx->upd_client && (mac->flags & ZEBRA_MAC_LOCAL)) {
-                       zvni_mac_send_del_to_client(wctx->zvni->vni,
+                       zevpn_mac_send_del_to_client(wctx->zevpn->vni,
                                        &mac->macaddr, mac->flags, false);
                }
                if (wctx->uninstall) {
@@ -3815,46 +3815,46 @@ static void zvni_mac_del_hash_entry(struct hash_bucket *bucket, void *arg)
                                                __func__);
 
                        if (mac->flags & ZEBRA_MAC_REMOTE)
-                               zvni_rem_mac_uninstall(wctx->zvni, mac);
+                               zevpn_rem_mac_uninstall(wctx->zevpn, mac);
                }
 
-               zvni_mac_del(wctx->zvni, mac);
+               zevpn_mac_del(wctx->zevpn, mac);
        }
 
        return;
 }
 
 /*
- * Delete all MAC entries for this VNI.
+ * Delete all MAC entries for this EVPN.
  */
-static void zvni_mac_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+static void zevpn_mac_del_all(zebra_evpn_t *zevpn, int uninstall, int upd_client,
                             uint32_t flags)
 {
        struct mac_walk_ctx wctx;
 
-       if (!zvni->mac_table)
+       if (!zevpn->mac_table)
                return;
 
        memset(&wctx, 0, sizeof(struct mac_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.uninstall = uninstall;
        wctx.upd_client = upd_client;
        wctx.flags = flags;
 
-       hash_iterate(zvni->mac_table, zvni_mac_del_hash_entry, &wctx);
+       hash_iterate(zevpn->mac_table, zevpn_mac_del_hash_entry, &wctx);
 }
 
 /*
  * Look up MAC hash entry.
  */
-static zebra_mac_t *zvni_mac_lookup(zebra_vni_t *zvni, struct ethaddr *mac)
+static zebra_mac_t *zevpn_mac_lookup(zebra_evpn_t *zevpn, struct ethaddr *mac)
 {
        zebra_mac_t tmp;
        zebra_mac_t *pmac;
 
        memset(&tmp, 0, sizeof(tmp));
        memcpy(&tmp.macaddr, mac, ETH_ALEN);
-       pmac = hash_lookup(zvni->mac_table, &tmp);
+       pmac = hash_lookup(zevpn->mac_table, &tmp);
 
        return pmac;
 }
@@ -3862,7 +3862,7 @@ static zebra_mac_t *zvni_mac_lookup(zebra_vni_t *zvni, struct ethaddr *mac)
 /*
  * Inform BGP about local MAC addition.
  */
-static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
+static int zevpn_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
                uint32_t mac_flags, uint32_t seq, struct zebra_evpn_es *es)
 {
        uint8_t flags = 0;
@@ -3887,7 +3887,7 @@ static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
        if (CHECK_FLAG(mac_flags, ZEBRA_MAC_DEF_GW))
                SET_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
 
-       return zvni_macip_send_msg_to_client(vni, macaddr, NULL, flags,
+       return zevpn_macip_send_msg_to_client(vni, macaddr, NULL, flags,
                        seq, ZEBRA_NEIGH_ACTIVE, es,
                        ZEBRA_MACIP_ADD);
 }
@@ -3895,7 +3895,7 @@ static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
 /*
  * Inform BGP about local MAC deletion.
  */
-static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
+static int zevpn_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
                uint32_t flags, bool force)
 {
        if (!force) {
@@ -3905,16 +3905,16 @@ static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
                        return 0;
        }
 
-       return zvni_macip_send_msg_to_client(vni, macaddr, NULL, 0 /* flags */,
+       return zevpn_macip_send_msg_to_client(vni, macaddr, NULL, 0 /* flags */,
                        0 /* seq */, ZEBRA_NEIGH_ACTIVE, NULL,
                        ZEBRA_MACIP_DEL);
 }
 
 /*
- * Map port or (port, VLAN) to a VNI. This is invoked upon getting MAC
+ * Map port or (port, VLAN) to an EVPN. This is invoked upon getting MAC
  * notifications, to see if they are of interest.
  */
-static zebra_vni_t *zvni_map_vlan(struct interface *ifp,
+static zebra_evpn_t *zevpn_map_vlan(struct interface *ifp,
                                  struct interface *br_if, vlanid_t vid)
 {
        struct zebra_ns *zns;
@@ -3924,7 +3924,7 @@ static zebra_vni_t *zvni_map_vlan(struct interface *ifp,
        struct zebra_l2info_bridge *br;
        struct zebra_l2info_vxlan *vxl = NULL;
        uint8_t bridge_vlan_aware;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        int found = 0;
 
        /* Determine if bridge is VLAN-aware or not */
@@ -3959,15 +3959,15 @@ static zebra_vni_t *zvni_map_vlan(struct interface *ifp,
        if (!found)
                return NULL;
 
-       zvni = zvni_lookup(vxl->vni);
-       return zvni;
+       zevpn = zevpn_lookup(vxl->vni);
+       return zevpn;
 }
 
 /*
  * Map SVI and associated bridge to a VNI. This is invoked upon getting
  * neighbor notifications, to see if they are of interest.
  */
-static zebra_vni_t *zvni_from_svi(struct interface *ifp,
+static zebra_evpn_t *zevpn_from_svi(struct interface *ifp,
                                  struct interface *br_if)
 {
        struct zebra_ns *zns;
@@ -3978,7 +3978,7 @@ static zebra_vni_t *zvni_from_svi(struct interface *ifp,
        struct zebra_l2info_vxlan *vxl = NULL;
        uint8_t bridge_vlan_aware;
        vlanid_t vid = 0;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        int found = 0;
 
        if (!br_if)
@@ -4031,8 +4031,8 @@ static zebra_vni_t *zvni_from_svi(struct interface *ifp,
        if (!found)
                return NULL;
 
-       zvni = zvni_lookup(vxl->vni);
-       return zvni;
+       zevpn = zevpn_lookup(vxl->vni);
+       return zevpn;
 }
 
 /* Map to SVI on bridge corresponding to specified VLAN. This can be one
@@ -4042,7 +4042,7 @@ static zebra_vni_t *zvni_from_svi(struct interface *ifp,
  * (b) In the case of a VLAN-unaware bridge, the SVI is the bridge interface
  * itself
  */
-static struct interface *zvni_map_to_svi(vlanid_t vid, struct interface *br_if)
+static struct interface *zevpn_map_to_svi(vlanid_t vid, struct interface *br_if)
 {
        struct zebra_ns *zns;
        struct route_node *rn;
@@ -4092,7 +4092,7 @@ static struct interface *zvni_map_to_svi(vlanid_t vid, struct interface *br_if)
 
 /* Map to MAC-VLAN interface corresponding to specified SVI interface.
  */
-static struct interface *zvni_map_to_macvlan(struct interface *br_if,
+static struct interface *zevpn_map_to_macvlan(struct interface *br_if,
                                             struct interface *svi_if)
 {
        struct zebra_ns *zns;
@@ -4139,7 +4139,7 @@ static struct interface *zvni_map_to_macvlan(struct interface *br_if,
 /*
  * Install remote MAC into the forwarding plane.
  */
-static int zvni_rem_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac,
+static int zevpn_rem_mac_install(zebra_evpn_t *zevpn, zebra_mac_t *mac,
                bool was_static)
 {
        const struct zebra_if *zif, *br_zif;
@@ -4154,7 +4154,7 @@ static int zvni_rem_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac,
        if (!(mac->flags & ZEBRA_MAC_REMOTE))
                return 0;
 
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (!zif)
                return -1;
 
@@ -4187,7 +4187,7 @@ static int zvni_rem_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac,
        else
                vid = 0;
 
-       res = dplane_rem_mac_add(zvni->vxlan_if, br_ifp, vid,
+       res = dplane_rem_mac_add(zevpn->vxlan_if, br_ifp, vid,
                             &mac->macaddr, vtep_ip, sticky,
                                 nhg_id, was_static);
        if (res != ZEBRA_DPLANE_REQUEST_FAILURE)
@@ -4199,7 +4199,7 @@ static int zvni_rem_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac,
 /*
  * Uninstall remote MAC from the forwarding plane.
  */
-static int zvni_rem_mac_uninstall(zebra_vni_t *zvni, zebra_mac_t *mac)
+static int zevpn_rem_mac_uninstall(zebra_evpn_t *zevpn, zebra_mac_t *mac)
 {
        const struct zebra_if *zif, *br_zif;
        const struct zebra_l2info_vxlan *vxl;
@@ -4211,14 +4211,14 @@ static int zvni_rem_mac_uninstall(zebra_vni_t *zvni, zebra_mac_t *mac)
        if (!(mac->flags & ZEBRA_MAC_REMOTE))
                return 0;
 
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("VNI %u hash %p couldn't be uninstalled - no intf",
-                                  zvni->vni, zvni);
+                                  zevpn->vni, zevpn);
                return -1;
        }
 
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (!zif)
                return -1;
 
@@ -4235,7 +4235,7 @@ static int zvni_rem_mac_uninstall(zebra_vni_t *zvni, zebra_mac_t *mac)
        else
                vid = 0;
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        vtep_ip = mac->fwd_info.r_vtep_ip;
 
        res = dplane_rem_mac_del(ifp, br_ifp, vid, &mac->macaddr, vtep_ip);
@@ -4248,7 +4248,7 @@ static int zvni_rem_mac_uninstall(zebra_vni_t *zvni, zebra_mac_t *mac)
 /*
  * Install MAC hash entry - called upon access VLAN change.
  */
-static void zvni_install_mac_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_install_mac_hash(struct hash_bucket *bucket, void *ctxt)
 {
        zebra_mac_t *mac;
        struct mac_walk_ctx *wctx = ctxt;
@@ -4256,7 +4256,7 @@ static void zvni_install_mac_hash(struct hash_bucket *bucket, void *ctxt)
        mac = (zebra_mac_t *)bucket->data;
 
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE))
-               zvni_rem_mac_install(wctx->zvni, mac, false);
+               zevpn_rem_mac_install(wctx->zevpn, mac, false);
 }
 
 /*
@@ -4280,7 +4280,7 @@ static int remote_neigh_count(zebra_mac_t *zmac)
  * Decrement neighbor refcount of MAC; uninstall and free it if
  * appropriate.
  */
-static void zvni_deref_ip2mac(zebra_vni_t *zvni, zebra_mac_t *mac)
+static void zevpn_deref_ip2mac(zebra_evpn_t *zevpn, zebra_mac_t *mac)
 {
        if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_AUTO))
                return;
@@ -4290,20 +4290,20 @@ static void zvni_deref_ip2mac(zebra_vni_t *zvni, zebra_mac_t *mac)
         */
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE) &&
            remote_neigh_count(mac) == 0) {
-               zvni_rem_mac_uninstall(zvni, mac);
+               zevpn_rem_mac_uninstall(zevpn, mac);
                zebra_evpn_es_mac_deref_entry(mac);
                UNSET_FLAG(mac->flags, ZEBRA_MAC_REMOTE);
        }
 
        /* If no neighbors, delete the MAC. */
        if (list_isempty(mac->neigh_list))
-               zvni_mac_del(zvni, mac);
+               zevpn_mac_del(zevpn, mac);
 }
 
 /*
- * Read and populate local MACs and neighbors corresponding to this VNI.
+ * Read and populate local MACs and neighbors corresponding to this EVPN.
  */
-static void zvni_read_mac_neigh(zebra_vni_t *zvni, struct interface *ifp)
+static void zevpn_read_mac_neigh(zebra_evpn_t *zevpn, struct interface *ifp)
 {
        struct zebra_ns *zns;
        struct zebra_if *zif;
@@ -4318,20 +4318,20 @@ static void zvni_read_mac_neigh(zebra_vni_t *zvni, struct interface *ifp)
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug(
                        "Reading MAC FDB and Neighbors for intf %s(%u) VNI %u master %u",
-                       ifp->name, ifp->ifindex, zvni->vni,
+                       ifp->name, ifp->ifindex, zevpn->vni,
                        zif->brslave_info.bridge_ifindex);
 
        macfdb_read_for_bridge(zns, ifp, zif->brslave_info.br_if);
-       vlan_if = zvni_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
+       vlan_if = zevpn_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
        if (vlan_if) {
 
                /* Add SVI MAC-IP */
-               zvni_add_macip_for_intf(vlan_if, zvni);
+               zevpn_add_macip_for_intf(vlan_if, zevpn);
 
                /* Add VRR MAC-IP - if any*/
                vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
                if (vrr_if)
-                       zvni_add_macip_for_intf(vrr_if, zvni);
+                       zevpn_add_macip_for_intf(vrr_if, zevpn);
 
                neigh_read_for_vlan(zns, vlan_if);
        }
@@ -4340,11 +4340,11 @@ static void zvni_read_mac_neigh(zebra_vni_t *zvni, struct interface *ifp)
 /*
  * Hash function for VNI.
  */
-static unsigned int vni_hash_keymake(const void *p)
+static unsigned int evpn_hash_keymake(const void *p)
 {
-       const zebra_vni_t *zvni = p;
+       const zebra_evpn_t *zevpn = p;
 
-       return (jhash_1word(zvni->vni, 0));
+       return (jhash_1word(zevpn->vni, 0));
 }
 
 /*
@@ -4352,96 +4352,96 @@ static unsigned int vni_hash_keymake(const void *p)
  */
 static bool vni_hash_cmp(const void *p1, const void *p2)
 {
-       const zebra_vni_t *zvni1 = p1;
-       const zebra_vni_t *zvni2 = p2;
+       const zebra_evpn_t *zevpn1 = p1;
+       const zebra_evpn_t *zevpn2 = p2;
 
-       return (zvni1->vni == zvni2->vni);
+       return (zevpn1->vni == zevpn2->vni);
 }
 
 int vni_list_cmp(void *p1, void *p2)
 {
-       const zebra_vni_t *zvni1 = p1;
-       const zebra_vni_t *zvni2 = p2;
+       const zebra_evpn_t *zevpn1 = p1;
+       const zebra_evpn_t *zevpn2 = p2;
 
-       if (zvni1->vni == zvni2->vni)
+       if (zevpn1->vni == zevpn2->vni)
                return 0;
-       return (zvni1->vni < zvni2->vni) ? -1 : 1;
+       return (zevpn1->vni < zevpn2->vni) ? -1 : 1;
 }
 
 /*
  * Callback to allocate VNI hash entry.
  */
-static void *zvni_alloc(void *p)
+static void *zevpn_alloc(void *p)
 {
-       const zebra_vni_t *tmp_vni = p;
-       zebra_vni_t *zvni;
+       const zebra_evpn_t *tmp_vni = p;
+       zebra_evpn_t *zevpn;
 
-       zvni = XCALLOC(MTYPE_ZVNI, sizeof(zebra_vni_t));
-       zvni->vni = tmp_vni->vni;
-       return ((void *)zvni);
+       zevpn = XCALLOC(MTYPE_ZEVPN, sizeof(zebra_evpn_t));
+       zevpn->vni = tmp_vni->vni;
+       return ((void *)zevpn);
 }
 
 /*
- * Look up VNI hash entry.
+ * Look up EVPN hash entry.
  */
-zebra_vni_t *zvni_lookup(vni_t vni)
+zebra_evpn_t *zevpn_lookup(vni_t vni)
 {
        struct zebra_vrf *zvrf;
-       zebra_vni_t tmp_vni;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t tmp_vni;
+       zebra_evpn_t *zevpn = NULL;
 
        zvrf = zebra_vrf_get_evpn();
        assert(zvrf);
-       memset(&tmp_vni, 0, sizeof(zebra_vni_t));
+       memset(&tmp_vni, 0, sizeof(zebra_evpn_t));
        tmp_vni.vni = vni;
-       zvni = hash_lookup(zvrf->vni_table, &tmp_vni);
+       zevpn = hash_lookup(zvrf->evpn_table, &tmp_vni);
 
-       return zvni;
+       return zevpn;
 }
 
 /*
- * Add VNI hash entry.
+ * Add EVPN hash entry.
  */
-static zebra_vni_t *zvni_add(vni_t vni)
+static zebra_evpn_t *zevpn_add(vni_t vni)
 {
        struct zebra_vrf *zvrf;
-       zebra_vni_t tmp_zvni;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t tmp_zevpn;
+       zebra_evpn_t *zevpn = NULL;
 
        zvrf = zebra_vrf_get_evpn();
        assert(zvrf);
-       memset(&tmp_zvni, 0, sizeof(zebra_vni_t));
-       tmp_zvni.vni = vni;
-       zvni = hash_get(zvrf->vni_table, &tmp_zvni, zvni_alloc);
-       assert(zvni);
+       memset(&tmp_zevpn, 0, sizeof(zebra_evpn_t));
+       tmp_zevpn.vni = vni;
+       zevpn = hash_get(zvrf->evpn_table, &tmp_zevpn, zevpn_alloc);
+       assert(zevpn);
 
-       zebra_evpn_vni_es_init(zvni);
+       zebra_evpn_evpn_es_init(zevpn);
 
        /* Create hash table for MAC */
-       zvni->mac_table =
-               hash_create(mac_hash_keymake, mac_cmp, "Zebra VNI MAC Table");
+       zevpn->mac_table =
+               hash_create(mac_hash_keymake, mac_cmp, "Zebra EVPN MAC Table");
 
        /* Create hash table for neighbors */
-       zvni->neigh_table = hash_create(neigh_hash_keymake, neigh_cmp,
-                                       "Zebra VNI Neighbor Table");
+       zevpn->neigh_table = hash_create(neigh_hash_keymake, neigh_cmp,
+                                       "Zebra EVPN Neighbor Table");
 
-       return zvni;
+       return zevpn;
 }
 
-/* vni<=>vxlan_zif association */
-static void zvni_vxlan_if_set(zebra_vni_t *zvni, struct interface *ifp,
+/* EVPN<=>vxlan_zif association */
+static void zevpn_vxlan_if_set(zebra_evpn_t *zevpn, struct interface *ifp,
                bool set)
 {
        struct zebra_if *zif;
 
        if (set) {
-               if (zvni->vxlan_if == ifp)
+               if (zevpn->vxlan_if == ifp)
                        return;
-               zvni->vxlan_if = ifp;
+               zevpn->vxlan_if = ifp;
        } else {
-               if (!zvni->vxlan_if)
+               if (!zevpn->vxlan_if)
                        return;
-               zvni->vxlan_if = NULL;
+               zevpn->vxlan_if = NULL;
        }
 
        if (ifp)
@@ -4449,46 +4449,46 @@ static void zvni_vxlan_if_set(zebra_vni_t *zvni, struct interface *ifp,
        else
                zif = NULL;
 
-       zebra_evpn_vxl_vni_set(zif, zvni, set);
+       zebra_evpn_vxl_evpn_set(zif, zevpn, set);
 }
 
 /*
- * Delete VNI hash entry.
+ * Delete EVPN hash entry.
  */
-static int zvni_del(zebra_vni_t *zvni)
+static int zevpn_del(zebra_evpn_t *zevpn)
 {
        struct zebra_vrf *zvrf;
-       zebra_vni_t *tmp_zvni;
+       zebra_evpn_t *tmp_zevpn;
 
        zvrf = zebra_vrf_get_evpn();
        assert(zvrf);
 
-       zvni_vxlan_if_set(zvni, zvni->vxlan_if, false /* set */);
+       zevpn_vxlan_if_set(zevpn, zevpn->vxlan_if, false /* set */);
 
        /* Remove references to the BUM mcast grp */
-       zebra_vxlan_sg_deref(zvni->local_vtep_ip, zvni->mcast_grp);
+       zebra_vxlan_sg_deref(zevpn->local_vtep_ip, zevpn->mcast_grp);
 
        /* Free the neighbor hash table. */
-       hash_free(zvni->neigh_table);
-       zvni->neigh_table = NULL;
+       hash_free(zevpn->neigh_table);
+       zevpn->neigh_table = NULL;
 
        /* Free the MAC hash table. */
-       hash_free(zvni->mac_table);
-       zvni->mac_table = NULL;
+       hash_free(zevpn->mac_table);
+       zevpn->mac_table = NULL;
 
-       zebra_evpn_vni_es_cleanup(zvni);
+       zebra_evpn_evpn_es_cleanup(zevpn);
 
-       /* Free the VNI hash entry and allocated memory. */
-       tmp_zvni = hash_release(zvrf->vni_table, zvni);
-       XFREE(MTYPE_ZVNI, tmp_zvni);
+       /* Free the EVPN hash entry and allocated memory. */
+       tmp_zevpn = hash_release(zvrf->evpn_table, zevpn);
+       XFREE(MTYPE_ZEVPN, tmp_zevpn);
 
        return 0;
 }
 
 /*
- * Inform BGP about local VNI addition.
+ * Inform BGP about local EVPN addition.
  */
-static int zvni_send_add_to_client(zebra_vni_t *zvni)
+static int zevpn_send_add_to_client(zebra_evpn_t *zevpn)
 {
        struct zserv *client;
        struct stream *s;
@@ -4502,37 +4502,37 @@ static int zvni_send_add_to_client(zebra_vni_t *zvni)
        s = stream_new(ZEBRA_MAX_PACKET_SIZ);
 
        zclient_create_header(s, ZEBRA_VNI_ADD, zebra_vrf_get_evpn_id());
-       stream_putl(s, zvni->vni);
-       stream_put_in_addr(s, &zvni->local_vtep_ip);
-       stream_put(s, &zvni->vrf_id, sizeof(vrf_id_t)); /* tenant vrf */
-       stream_put_in_addr(s, &zvni->mcast_grp);
+       stream_putl(s, zevpn->vni);
+       stream_put_in_addr(s, &zevpn->local_vtep_ip);
+       stream_put(s, &zevpn->vrf_id, sizeof(vrf_id_t)); /* tenant vrf */
+       stream_put_in_addr(s, &zevpn->mcast_grp);
 
        /* Write packet size. */
        stream_putw_at(s, 0, stream_get_endp(s));
 
        if (IS_ZEBRA_DEBUG_VXLAN)
-               zlog_debug("Send VNI_ADD %u %s tenant vrf %s to %s", zvni->vni,
-                          inet_ntoa(zvni->local_vtep_ip),
-                          vrf_id_to_name(zvni->vrf_id),
+               zlog_debug("Send EVPN_ADD %u %s tenant vrf %s to %s", zevpn->vni,
+                          inet_ntoa(zevpn->local_vtep_ip),
+                          vrf_id_to_name(zevpn->vrf_id),
                           zebra_route_string(client->proto));
 
        client->vniadd_cnt++;
        rc = zserv_send_message(client, s);
 
-       if (!(zvni->flags & ZVNI_READY_FOR_BGP)) {
-               zvni->flags |= ZVNI_READY_FOR_BGP;
-               /* once the VNI is sent the ES-EVIs can also be replayed
+       if (!(zevpn->flags & ZEVPN_READY_FOR_BGP)) {
+               zevpn->flags |= ZEVPN_READY_FOR_BGP;
+               /* once the EVPN is sent the ES-EVIs can also be replayed
                 * to BGP
                 */
-               zebra_evpn_vni_update_all_es(zvni);
+               zebra_evpn_update_all_es(zevpn);
        }
        return rc;
 }
 
 /*
- * Inform BGP about local VNI deletion.
+ * Inform BGP about local EVPN deletion.
  */
-static int zvni_send_del_to_client(zebra_vni_t *zvni)
+static int zevpn_send_del_to_client(zebra_evpn_t *zevpn)
 {
        struct zserv *client;
        struct stream *s;
@@ -4542,23 +4542,23 @@ static int zvni_send_del_to_client(zebra_vni_t *zvni)
        if (!client)
                return 0;
 
-       if (zvni->flags & ZVNI_READY_FOR_BGP) {
-               zvni->flags &= ~ZVNI_READY_FOR_BGP;
-               /* the ES-EVIs must be removed from BGP before the VNI is */
-               zebra_evpn_vni_update_all_es(zvni);
+       if (zevpn->flags & ZEVPN_READY_FOR_BGP) {
+               zevpn->flags &= ~ZEVPN_READY_FOR_BGP;
+               /* the ES-EVIs must be removed from BGP before the EVPN is */
+               zebra_evpn_update_all_es(zevpn);
        }
 
        s = stream_new(ZEBRA_MAX_PACKET_SIZ);
        stream_reset(s);
 
        zclient_create_header(s, ZEBRA_VNI_DEL, zebra_vrf_get_evpn_id());
-       stream_putl(s, zvni->vni);
+       stream_putl(s, zevpn->vni);
 
        /* Write packet size. */
        stream_putw_at(s, 0, stream_get_endp(s));
 
        if (IS_ZEBRA_DEBUG_VXLAN)
-               zlog_debug("Send VNI_DEL %u to %s", zvni->vni,
+               zlog_debug("Send EVPN_DEL %u to %s", zevpn->vni,
                           zebra_route_string(client->proto));
 
        client->vnidel_cnt++;
@@ -4569,17 +4569,17 @@ static int zvni_send_del_to_client(zebra_vni_t *zvni)
  * Build the VNI hash table by going over the VxLAN interfaces. This
  * is called when EVPN (advertise-all-vni) is enabled.
  */
-static void zvni_build_hash_table(void)
+static void zevpn_build_hash_table(void)
 {
        struct zebra_ns *zns;
        struct route_node *rn;
        struct interface *ifp;
 
-       /* Walk VxLAN interfaces and create VNI hash. */
+       /* Walk VxLAN interfaces and create EVPN hash. */
        zns = zebra_ns_lookup(NS_DEFAULT);
        for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
                vni_t vni;
-               zebra_vni_t *zvni = NULL;
+               zebra_evpn_t *zevpn = NULL;
                zebra_l3vni_t *zl3vni = NULL;
                struct zebra_if *zif;
                struct zebra_l2info_vxlan *vxl;
@@ -4636,11 +4636,11 @@ static void zvni_build_hash_table(void)
                                        ifp->name, ifp->ifindex, vni,
                                        inet_ntoa(vxl->vtep_ip));
 
-                       /* VNI hash entry is expected to exist, if the BGP process is killed */
-                       zvni = zvni_lookup(vni);
-                       if (zvni) {
+                       /* EVPN hash entry is expected to exist, if the BGP process is killed */
+                       zevpn = zevpn_lookup(vni);
+                       if (zevpn) {
                                zlog_debug(
-                                       "VNI hash already present for IF %s(%u) L2-VNI %u",
+                                       "EVPN hash already present for IF %s(%u) L2-VNI %u",
                                        ifp->name, ifp->ifindex, vni);
 
                                /*
@@ -4649,48 +4649,48 @@ static void zvni_build_hash_table(void)
                                 */
                                if (if_is_operative(ifp) &&
                                        zif->brslave_info.br_if)
-                                       zvni_send_add_to_client(zvni);
+                                       zevpn_send_add_to_client(zevpn);
 
                                /* Send Local MAC-entries to client */
-                               zvni_send_mac_to_client(zvni);
+                               zevpn_send_mac_to_client(zevpn);
 
                                /* Send Loval Neighbor entries to client */
-                               zvni_send_neigh_to_client(zvni);
+                               zevpn_send_neigh_to_client(zevpn);
                        } else {
-                               zvni = zvni_add(vni);
-                               if (!zvni) {
+                               zevpn = zevpn_add(vni);
+                               if (!zevpn) {
                                        zlog_debug(
-                                               "Failed to add VNI hash, IF %s(%u) L2-VNI %u",
+                                               "Failed to add EVPN hash, IF %s(%u) L2-VNI %u",
                                                ifp->name, ifp->ifindex, vni);
                                        return;
                                }
 
-                               if (zvni->local_vtep_ip.s_addr !=
+                               if (zevpn->local_vtep_ip.s_addr !=
                                        vxl->vtep_ip.s_addr ||
-                                       zvni->mcast_grp.s_addr !=
+                                       zevpn->mcast_grp.s_addr !=
                                        vxl->mcast_grp.s_addr) {
                                        zebra_vxlan_sg_deref(
-                                               zvni->local_vtep_ip,
-                                               zvni->mcast_grp);
+                                               zevpn->local_vtep_ip,
+                                               zevpn->mcast_grp);
                                        zebra_vxlan_sg_ref(vxl->vtep_ip,
                                                vxl->mcast_grp);
-                                       zvni->local_vtep_ip = vxl->vtep_ip;
-                                       zvni->mcast_grp = vxl->mcast_grp;
+                                       zevpn->local_vtep_ip = vxl->vtep_ip;
+                                       zevpn->mcast_grp = vxl->mcast_grp;
                                        /* on local vtep-ip check if ES
                                         * orig-ip needs to be updated
                                         */
-                                       zebra_evpn_es_set_base_vni(zvni);
+                                       zebra_evpn_es_set_base_evpn(zevpn);
                                }
-                               zvni_vxlan_if_set(zvni, ifp, true /* set */);
-                               vlan_if = zvni_map_to_svi(vxl->access_vlan,
+                               zevpn_vxlan_if_set(zevpn, ifp, true /* set */);
+                               vlan_if = zevpn_map_to_svi(vxl->access_vlan,
                                                zif->brslave_info.br_if);
                                if (vlan_if) {
-                                       zvni->vrf_id = vlan_if->vrf_id;
+                                       zevpn->vrf_id = vlan_if->vrf_id;
                                        zl3vni = zl3vni_from_vrf(
                                                        vlan_if->vrf_id);
                                        if (zl3vni)
                                                listnode_add_sort(
-                                                       zl3vni->l2vnis, zvni);
+                                                       zl3vni->l2vnis, zevpn);
                                }
 
                                /*
@@ -4699,7 +4699,7 @@ static void zvni_build_hash_table(void)
                                 */
                                if (if_is_operative(ifp) &&
                                        zif->brslave_info.br_if)
-                                       zvni_send_add_to_client(zvni);
+                                       zevpn_send_add_to_client(zevpn);
                        }
                }
        }
@@ -4708,23 +4708,23 @@ static void zvni_build_hash_table(void)
 /*
  * See if remote VTEP matches with prefix.
  */
-static int zvni_vtep_match(struct in_addr *vtep_ip, zebra_vtep_t *zvtep)
+static int zevpn_vtep_match(struct in_addr *vtep_ip, zebra_vtep_t *zvtep)
 {
        return (IPV4_ADDR_SAME(vtep_ip, &zvtep->vtep_ip));
 }
 
 /*
- * Locate remote VTEP in VNI hash table.
+ * Locate remote VTEP in EVPN hash table.
  */
-static zebra_vtep_t *zvni_vtep_find(zebra_vni_t *zvni, struct in_addr *vtep_ip)
+static zebra_vtep_t *zevpn_vtep_find(zebra_evpn_t *zevpn, struct in_addr *vtep_ip)
 {
        zebra_vtep_t *zvtep;
 
-       if (!zvni)
+       if (!zevpn)
                return NULL;
 
-       for (zvtep = zvni->vteps; zvtep; zvtep = zvtep->next) {
-               if (zvni_vtep_match(vtep_ip, zvtep))
+       for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
+               if (zevpn_vtep_match(vtep_ip, zvtep))
                        break;
        }
 
@@ -4732,61 +4732,61 @@ static zebra_vtep_t *zvni_vtep_find(zebra_vni_t *zvni, struct in_addr *vtep_ip)
 }
 
 /*
- * Add remote VTEP to VNI hash table.
+ * Add remote VTEP to EVPN hash table.
  */
-static zebra_vtep_t *zvni_vtep_add(zebra_vni_t *zvni, struct in_addr *vtep_ip,
+static zebra_vtep_t *zevpn_vtep_add(zebra_evpn_t *zevpn, struct in_addr *vtep_ip,
                int flood_control)
 
 {
        zebra_vtep_t *zvtep;
 
-       zvtep = XCALLOC(MTYPE_ZVNI_VTEP, sizeof(zebra_vtep_t));
+       zvtep = XCALLOC(MTYPE_ZEVPN_VTEP, sizeof(zebra_vtep_t));
 
        zvtep->vtep_ip = *vtep_ip;
        zvtep->flood_control = flood_control;
 
-       if (zvni->vteps)
-               zvni->vteps->prev = zvtep;
-       zvtep->next = zvni->vteps;
-       zvni->vteps = zvtep;
+       if (zevpn->vteps)
+               zevpn->vteps->prev = zvtep;
+       zvtep->next = zevpn->vteps;
+       zevpn->vteps = zvtep;
 
        return zvtep;
 }
 
 /*
- * Remove remote VTEP from VNI hash table.
+ * Remove remote VTEP from EVPN hash table.
  */
-static int zvni_vtep_del(zebra_vni_t *zvni, zebra_vtep_t *zvtep)
+static int zevpn_vtep_del(zebra_evpn_t *zevpn, zebra_vtep_t *zvtep)
 {
        if (zvtep->next)
                zvtep->next->prev = zvtep->prev;
        if (zvtep->prev)
                zvtep->prev->next = zvtep->next;
        else
-               zvni->vteps = zvtep->next;
+               zevpn->vteps = zvtep->next;
 
        zvtep->prev = zvtep->next = NULL;
-       XFREE(MTYPE_ZVNI_VTEP, zvtep);
+       XFREE(MTYPE_ZEVPN_VTEP, zvtep);
 
        return 0;
 }
 
 /*
- * Delete all remote VTEPs for this VNI (upon VNI delete). Also
+ * Delete all remote VTEPs for this EVPN (upon VNI delete). Also
  * uninstall from kernel if asked to.
  */
-static int zvni_vtep_del_all(zebra_vni_t *zvni, int uninstall)
+static int zevpn_vtep_del_all(zebra_evpn_t *zevpn, int uninstall)
 {
        zebra_vtep_t *zvtep, *zvtep_next;
 
-       if (!zvni)
+       if (!zevpn)
                return -1;
 
-       for (zvtep = zvni->vteps; zvtep; zvtep = zvtep_next) {
+       for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep_next) {
                zvtep_next = zvtep->next;
                if (uninstall)
-                       zvni_vtep_uninstall(zvni, &zvtep->vtep_ip);
-               zvni_vtep_del(zvni, zvtep);
+                       zevpn_vtep_uninstall(zevpn, &zvtep->vtep_ip);
+               zevpn_vtep_del(zevpn, zvtep);
        }
 
        return 0;
@@ -4796,13 +4796,13 @@ static int zvni_vtep_del_all(zebra_vni_t *zvni, int uninstall)
  * Install remote VTEP into the kernel if the remote VTEP has asked
  * for head-end-replication.
  */
-static int zvni_vtep_install(zebra_vni_t *zvni, zebra_vtep_t *zvtep)
+static int zevpn_vtep_install(zebra_evpn_t *zevpn, zebra_vtep_t *zvtep)
 {
        if (is_vxlan_flooding_head_end() &&
            (zvtep->flood_control == VXLAN_FLOOD_HEAD_END_REPL)) {
                if (ZEBRA_DPLANE_REQUEST_FAILURE ==
-                   dplane_vtep_add(zvni->vxlan_if,
-                                   &zvtep->vtep_ip, zvni->vni))
+                   dplane_vtep_add(zevpn->vxlan_if,
+                                   &zvtep->vtep_ip, zevpn->vni))
                        return -1;
        }
 
@@ -4812,16 +4812,16 @@ static int zvni_vtep_install(zebra_vni_t *zvni, zebra_vtep_t *zvtep)
 /*
  * Uninstall remote VTEP from the kernel.
  */
-static int zvni_vtep_uninstall(zebra_vni_t *zvni, struct in_addr *vtep_ip)
+static int zevpn_vtep_uninstall(zebra_evpn_t *zevpn, struct in_addr *vtep_ip)
 {
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                zlog_debug("VNI %u hash %p couldn't be uninstalled - no intf",
-                          zvni->vni, zvni);
+                          zevpn->vni, zevpn);
                return -1;
        }
 
        if (ZEBRA_DPLANE_REQUEST_FAILURE ==
-           dplane_vtep_delete(zvni->vxlan_if, vtep_ip, zvni->vni))
+           dplane_vtep_delete(zevpn->vxlan_if, vtep_ip, zevpn->vni))
                return -1;
 
        return 0;
@@ -4831,50 +4831,50 @@ static int zvni_vtep_uninstall(zebra_vni_t *zvni, struct in_addr *vtep_ip)
  * Install or uninstall flood entries in the kernel corresponding to
  * remote VTEPs. This is invoked upon change to BUM handling.
  */
-static void zvni_handle_flooding_remote_vteps(struct hash_bucket *bucket,
+static void zevpn_handle_flooding_remote_vteps(struct hash_bucket *bucket,
                                              void *zvrf)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_vtep_t *zvtep;
 
-       zvni = (zebra_vni_t *)bucket->data;
-       if (!zvni)
+       zevpn = (zebra_evpn_t *)bucket->data;
+       if (!zevpn)
                return;
 
-       for (zvtep = zvni->vteps; zvtep; zvtep = zvtep->next) {
+       for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
                if (is_vxlan_flooding_head_end())
-                       zvni_vtep_install(zvni, zvtep);
+                       zevpn_vtep_install(zevpn, zvtep);
                else
-                       zvni_vtep_uninstall(zvni, &zvtep->vtep_ip);
+                       zevpn_vtep_uninstall(zevpn, &zvtep->vtep_ip);
        }
 }
 
 /*
- * Cleanup VNI/VTEP and update kernel
+ * Cleanup EVPN/VTEP and update kernel
  */
-static void zvni_cleanup_all(struct hash_bucket *bucket, void *arg)
+static void zevpn_cleanup_all(struct hash_bucket *bucket, void *arg)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
        struct zebra_vrf *zvrf = (struct zebra_vrf *)arg;
 
-       zvni = (zebra_vni_t *)bucket->data;
+       zevpn = (zebra_evpn_t *)bucket->data;
 
        /* remove from l3-vni list */
        if (zvrf->l3vni)
                zl3vni = zl3vni_lookup(zvrf->l3vni);
        if (zl3vni)
-               listnode_delete(zl3vni->l2vnis, zvni);
+               listnode_delete(zl3vni->l2vnis, zevpn);
 
        /* Free up all neighbors and MACs, if any. */
-       zvni_neigh_del_all(zvni, 1, 0, DEL_ALL_NEIGH);
-       zvni_mac_del_all(zvni, 1, 0, DEL_ALL_MAC);
+       zevpn_neigh_del_all(zevpn, 1, 0, DEL_ALL_NEIGH);
+       zevpn_mac_del_all(zevpn, 1, 0, DEL_ALL_MAC);
 
        /* Free up all remote VTEPs, if any. */
-       zvni_vtep_del_all(zvni, 1);
+       zevpn_vtep_del_all(zevpn, 1);
 
        /* Delete the hash entry. */
-       zvni_del(zvni);
+       zevpn_del(zevpn);
 }
 
 /* cleanup L3VNI */
@@ -5537,7 +5537,7 @@ struct interface *zl3vni_map_to_svi_if(zebra_l3vni_t *zl3vni)
 
        vxl = &zif->l2info.vxl;
 
-       return zvni_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
+       return zevpn_map_to_svi(vxl->access_vlan, zif->brslave_info.br_if);
 }
 
 struct interface *zl3vni_map_to_mac_vlan_if(zebra_l3vni_t *zl3vni)
@@ -5554,7 +5554,7 @@ struct interface *zl3vni_map_to_mac_vlan_if(zebra_l3vni_t *zl3vni)
        if (!zif)
                return NULL;
 
-       return zvni_map_to_macvlan(zif->brslave_info.br_if, zl3vni->svi_if);
+       return zevpn_map_to_macvlan(zif->brslave_info.br_if, zl3vni->svi_if);
 }
 
 
@@ -5767,13 +5767,13 @@ static void zebra_vxlan_process_l3vni_oper_down(zebra_l3vni_t *zl3vni)
        zl3vni_send_del_to_client(zl3vni);
 }
 
-static void zvni_add_to_l3vni_list(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_add_to_l3vni_list(struct hash_bucket *bucket, void *ctxt)
 {
-       zebra_vni_t *zvni = (zebra_vni_t *)bucket->data;
+       zebra_evpn_t *zevpn = (zebra_evpn_t *)bucket->data;
        zebra_l3vni_t *zl3vni = (zebra_l3vni_t *)ctxt;
 
-       if (zvni->vrf_id == zl3vni_vrf_id(zl3vni))
-               listnode_add_sort(zl3vni->l2vnis, zvni);
+       if (zevpn->vrf_id == zl3vni_vrf_id(zl3vni))
+               listnode_add_sort(zl3vni->l2vnis, zevpn);
 }
 
 /*
@@ -5782,7 +5782,7 @@ static void zvni_add_to_l3vni_list(struct hash_bucket *bucket, void *ctxt)
 static int zebra_vxlan_handle_vni_transition(struct zebra_vrf *zvrf, vni_t vni,
                                             int add)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
 
        /* There is a possibility that VNI notification was already received
         * from kernel and we programmed it as L2-VNI
@@ -5794,28 +5794,28 @@ static int zebra_vxlan_handle_vni_transition(struct zebra_vrf *zvrf, vni_t vni,
         */
        if (add) {
                /* Locate hash entry */
-               zvni = zvni_lookup(vni);
-               if (!zvni)
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn)
                        return 0;
 
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("Del L2-VNI %u - transition to L3-VNI", vni);
 
-               /* Delete VNI from BGP. */
-               zvni_send_del_to_client(zvni);
+               /* Delete EVPN from BGP. */
+               zevpn_send_del_to_client(zevpn);
 
                /* Free up all neighbors and MAC, if any. */
-               zvni_neigh_del_all(zvni, 0, 0, DEL_ALL_NEIGH);
-               zvni_mac_del_all(zvni, 0, 0, DEL_ALL_MAC);
+               zevpn_neigh_del_all(zevpn, 0, 0, DEL_ALL_NEIGH);
+               zevpn_mac_del_all(zevpn, 0, 0, DEL_ALL_MAC);
 
                /* Free up all remote VTEPs, if any. */
-               zvni_vtep_del_all(zvni, 0);
+               zevpn_vtep_del_all(zevpn, 0);
 
                /* Delete the hash entry. */
-               if (zvni_del(zvni)) {
+               if (zevpn_del(zevpn)) {
                        flog_err(EC_ZEBRA_VNI_DEL_FAILED,
-                                "Failed to del VNI hash %p, VNI %u", zvni,
-                                zvni->vni);
+                                "Failed to del EVPN hash %p, VNI %u", zevpn,
+                                zevpn->vni);
                        return -1;
                }
        } else {
@@ -5938,7 +5938,7 @@ void zebra_vxlan_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
        struct interface *ifp;
        bool sticky;
        bool set_static;
-       zebra_vni_t *zvni = mac->zvni;
+       zebra_evpn_t *zevpn = mac->zevpn;
        vlanid_t vid;
        struct zebra_if *zif;
        struct interface *br_ifp;
@@ -5951,7 +5951,7 @@ void zebra_vxlan_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
                if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug("%s: dp-install sync-mac vni %u mac %s es %s 0x%x %sskipped, no access-port",
                                        caller,
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(&mac->macaddr, macbuf,
                                                sizeof(macbuf)),
                                        mac->es ?
@@ -5967,7 +5967,7 @@ void zebra_vxlan_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
                if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug("%s: dp-install sync-mac vni %u mac %s es %s 0x%x %sskipped, no br",
                                        caller,
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(&mac->macaddr, macbuf,
                                                sizeof(macbuf)),
                                        mac->es ?
@@ -5985,7 +5985,7 @@ void zebra_vxlan_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                zlog_debug("dp-install sync-mac vni %u mac %s es %s 0x%x %s%s",
-                               zvni->vni,
+                               zevpn->vni,
                                prefix_mac2str(&mac->macaddr, macbuf,
                                        sizeof(macbuf)),
                                mac->es ?
@@ -6002,11 +6002,11 @@ static void zebra_vxlan_mac_send_add_del_to_client(zebra_mac_t *mac,
        bool old_bgp_ready, bool new_bgp_ready)
 {
        if (new_bgp_ready)
-               zvni_mac_send_add_to_client(mac->zvni->vni,
+               zevpn_mac_send_add_to_client(mac->zevpn->vni,
                                &mac->macaddr, mac->flags,
                                mac->loc_seq, mac->es);
        else if (old_bgp_ready)
-               zvni_mac_send_del_to_client(mac->zvni->vni,
+               zevpn_mac_send_del_to_client(mac->zevpn->vni,
                                &mac->macaddr, mac->flags,
                                true /* force */);
 }
@@ -6041,7 +6041,7 @@ static int zebra_vxlan_mac_hold_exp_cb(struct thread *t)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                zlog_debug("sync-mac vni %u mac %s es %s 0x%x hold expired",
-                               mac->zvni->vni,
+                               mac->zevpn->vni,
                                prefix_mac2str(&mac->macaddr, macbuf,
                                        sizeof(macbuf)),
                                mac->es ?
@@ -6072,7 +6072,7 @@ static inline void zebra_vxlan_mac_start_hold_timer(zebra_mac_t *mac)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                zlog_debug("sync-mac vni %u mac %s es %s 0x%x hold started",
-                               mac->zvni->vni,
+                               mac->zevpn->vni,
                                prefix_mac2str(&mac->macaddr, macbuf,
                                        sizeof(macbuf)),
                                mac->es ?
@@ -6093,7 +6093,7 @@ static inline void zebra_vxlan_mac_stop_hold_timer(zebra_mac_t *mac)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                zlog_debug("sync-mac vni %u mac %s es %s 0x%x hold stopped",
-                               mac->zvni->vni,
+                               mac->zevpn->vni,
                                prefix_mac2str(&mac->macaddr, macbuf,
                                        sizeof(macbuf)),
                                mac->es ?
@@ -6116,7 +6116,7 @@ static void zebra_vxlan_sync_mac_del(zebra_mac_t *mac)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                zlog_debug("sync-mac del vni %u mac %s es %s seq %d f 0x%x",
-                               mac->zvni->vni,
+                               mac->zevpn->vni,
                                prefix_mac2str(&mac->macaddr,
                                        macbuf, sizeof(macbuf)),
                                mac->es ? mac->es->esi_str : "-",
@@ -6134,7 +6134,7 @@ static void zebra_vxlan_sync_mac_del(zebra_mac_t *mac)
                                false /* force_clear_static */, __func__);
 }
 
-static inline bool zebra_vxlan_mac_is_bgp_seq_ok(zebra_vni_t *zvni,
+static inline bool zebra_vxlan_mac_is_bgp_seq_ok(zebra_evpn_t *zevpn,
                zebra_mac_t *mac, uint32_t seq, uint16_t ipa_len,
                struct ipaddr *ipaddr)
 {
@@ -6156,7 +6156,7 @@ static inline bool zebra_vxlan_mac_is_bgp_seq_ok(zebra_vni_t *zvni,
                                !zebra_vxlan_mac_is_ready_for_bgp(mac->flags)) {
                        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                                zlog_debug("sync-macip accept vni %u mac %s%s%s lower seq %u f 0x%x",
-                                               zvni->vni,
+                                               zevpn->vni,
                                                prefix_mac2str(&mac->macaddr,
                                                        macbuf, sizeof(macbuf)),
                                                ipa_len ? " IP " : "",
@@ -6169,7 +6169,7 @@ static inline bool zebra_vxlan_mac_is_bgp_seq_ok(zebra_vni_t *zvni,
 
                if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug("sync-macip ignore vni %u mac %s%s%s as existing has higher seq %u f 0x%x",
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(&mac->macaddr,
                                                macbuf, sizeof(macbuf)),
                                        ipa_len ? " IP " : "",
@@ -6184,7 +6184,7 @@ static inline bool zebra_vxlan_mac_is_bgp_seq_ok(zebra_vni_t *zvni,
 }
 
 /* sync-path that is active on an ES peer */
-static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
+static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_evpn_t *zevpn,
                struct ethaddr *macaddr, uint16_t ipa_len,
                struct ipaddr *ipaddr, uint8_t flags,
                uint32_t seq, esi_t *esi,
@@ -6202,7 +6202,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
        bool old_bgp_ready;
        bool new_bgp_ready;
 
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac) {
                /* if it is a new local path we need to inform both
                 * the control protocol and the data-plane
@@ -6213,7 +6213,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
                ctx->mac_inactive =  true;
 
                /* create the MAC and associate it with the dest ES */
-               mac = zvni_mac_add(zvni, macaddr);
+               mac = zevpn_mac_add(zevpn, macaddr);
                zebra_evpn_es_mac_ref(mac, esi);
 
                /* local mac activated by an ES peer */
@@ -6242,7 +6242,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
                if (sticky || remote_gw) {
                        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                                zlog_debug("Ignore sync-macip vni %u mac %s%s%s%s%s",
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(macaddr,
                                                macbuf, sizeof(macbuf)),
                                        ipa_len ? " IP " : "",
@@ -6254,7 +6254,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
                        ctx->ignore_macip = true;
                        return NULL;
                }
-               if (!zebra_vxlan_mac_is_bgp_seq_ok(zvni, mac, seq,
+               if (!zebra_vxlan_mac_is_bgp_seq_ok(zevpn, mac, seq,
                                        ipa_len, ipaddr)) {
                        ctx->ignore_macip = true;
                        return NULL;
@@ -6308,7 +6308,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
                if (IS_ZEBRA_DEBUG_EVPN_MH_MAC &&
                                (old_flags != new_flags))
                        zlog_debug("sync-mac vni %u mac %s old_f 0x%x new_f 0x%x",
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(macaddr,
                                                macbuf, sizeof(macbuf)),
                                        old_flags, mac->flags);
@@ -6349,7 +6349,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
                zlog_debug("sync-mac %s vni %u mac %s es %s seq %d f 0x%x%s%s",
                                ctx->mac_created ?
                                "created" : "updated",
-                               zvni->vni,
+                               zevpn->vni,
                                prefix_mac2str(macaddr,
                                        macbuf, sizeof(macbuf)),
                                mac->es ? mac->es->esi_str : "-",
@@ -6365,7 +6365,7 @@ static zebra_mac_t *zebra_vxlan_proc_sync_mac_update(zebra_vni_t *zvni,
         * bgp with updated info
         */
        if (seq_change || es_change || !old_local)
-               zvni_process_neigh_on_local_mac_change(zvni, mac,
+               zevpn_process_neigh_on_local_mac_change(zevpn, mac,
                                seq_change, es_change);
 
        if (inform_dataplane) {
@@ -6426,7 +6426,7 @@ static void zebra_vxlan_sync_neigh_dp_install(zebra_neigh_t *n,
        if (!ifp) {
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                        zlog_debug("%s: dp-install sync-neigh vni %u ip %s mac %s if %d f 0x%x skipped",
-                               caller, n->zvni->vni,
+                               caller, n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6447,7 +6447,7 @@ static void zebra_vxlan_sync_neigh_dp_install(zebra_neigh_t *n,
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                zlog_debug("%s: dp-install sync-neigh vni %u ip %s mac %s if %s(%d) f 0x%x%s%s%s",
-                               caller, n->zvni->vni,
+                               caller, n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6463,10 +6463,10 @@ static void zebra_vxlan_neigh_send_add_del_to_client(zebra_neigh_t *n,
                bool old_bgp_ready, bool new_bgp_ready)
 {
        if (new_bgp_ready)
-               zvni_neigh_send_add_to_client(n->zvni->vni, &n->ip,
+               zevpn_neigh_send_add_to_client(n->zevpn->vni, &n->ip,
                        &n->emac, n->mac, n->flags, n->loc_seq);
        else if (old_bgp_ready)
-               zvni_neigh_send_del_to_client(n->zvni->vni, &n->ip,
+               zevpn_neigh_send_del_to_client(n->zevpn->vni, &n->ip,
                        &n->emac, n->flags, n->state, true /*force*/);
 }
 
@@ -6518,7 +6518,7 @@ static void zebra_vxlan_sync_neigh_static_chg(zebra_neigh_t *n,
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                zlog_debug("sync-neigh ref-chg vni %u ip %s mac %s f 0x%x %d%s%s%s%s by %s",
-                       n->zvni->vni,
+                       n->zevpn->vni,
                        ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                        prefix_mac2str(&n->emac, macbuf,
                                sizeof(macbuf)),
@@ -6561,7 +6561,7 @@ static int zebra_vxlan_neigh_hold_exp_cb(struct thread *t)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                zlog_debug("sync-neigh vni %u ip %s mac %s 0x%x hold expired",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6593,7 +6593,7 @@ static inline void zebra_vxlan_neigh_start_hold_timer(zebra_neigh_t *n)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                zlog_debug("sync-neigh vni %u ip %s mac %s 0x%x hold start",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6614,7 +6614,7 @@ static inline void zebra_vxlan_neigh_stop_hold_timer(zebra_neigh_t *n)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                zlog_debug("sync-neigh vni %u ip %s mac %s 0x%x hold stop",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6632,7 +6632,7 @@ static inline bool zebra_vxlan_neigh_clear_sync_info(zebra_neigh_t *n)
        if (n->flags & ZEBRA_NEIGH_ALL_PEER_FLAGS) {
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                        zlog_debug("sync-neigh vni %u ip %s mac %s 0x%x clear",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6658,7 +6658,7 @@ static void zebra_vxlan_local_neigh_deref_mac(zebra_neigh_t *n,
                bool send_mac_update)
 {
        zebra_mac_t *mac = n->mac;
-       zebra_vni_t *zvni = n->zvni;
+       zebra_evpn_t *zevpn = n->zevpn;
        char macbuf[ETHER_ADDR_STRLEN];
        char ipbuf[INET6_ADDRSTRLEN];
        bool old_static;
@@ -6675,7 +6675,7 @@ static void zebra_vxlan_local_neigh_deref_mac(zebra_neigh_t *n,
                new_static = zebra_vxlan_mac_is_static(mac);
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                        zlog_debug("sync-neigh deref mac vni %u ip %s mac %s ref %d",
-                                       n->zvni->vni,
+                                       n->zevpn->vni,
                                        ipaddr2str(&n->ip, ipbuf,
                                                sizeof(ipbuf)),
                                        prefix_mac2str(&n->emac, macbuf,
@@ -6690,7 +6690,7 @@ static void zebra_vxlan_local_neigh_deref_mac(zebra_neigh_t *n,
        }
 
        listnode_delete(mac->neigh_list, n);
-       zvni_deref_ip2mac(zvni, mac);
+       zevpn_deref_ip2mac(zevpn, mac);
 }
 
 static void zebra_vxlan_local_neigh_ref_mac(zebra_neigh_t *n,
@@ -6716,7 +6716,7 @@ static void zebra_vxlan_local_neigh_ref_mac(zebra_neigh_t *n,
                new_static = zebra_vxlan_mac_is_static(mac);
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                        zlog_debug("sync-neigh ref mac vni %u ip %s mac %s ref %d",
-                                       n->zvni->vni,
+                                       n->zevpn->vni,
                                        ipaddr2str(&n->ip, ipbuf,
                                                sizeof(ipbuf)),
                                        prefix_mac2str(&n->emac, macbuf,
@@ -6731,7 +6731,7 @@ static void zebra_vxlan_local_neigh_ref_mac(zebra_neigh_t *n,
        }
 }
 
-static inline bool zebra_vxlan_neigh_is_bgp_seq_ok(zebra_vni_t *zvni,
+static inline bool zebra_vxlan_neigh_is_bgp_seq_ok(zebra_evpn_t *zevpn,
                zebra_neigh_t *n, struct ethaddr *macaddr, uint32_t seq)
 {
        char macbuf[ETHER_ADDR_STRLEN];
@@ -6752,7 +6752,7 @@ static inline bool zebra_vxlan_neigh_is_bgp_seq_ok(zebra_vni_t *zvni,
                                !zebra_vxlan_neigh_is_ready_for_bgp(n)) {
                        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                                zlog_debug("sync-macip accept vni %u mac %s IP %s lower seq %u f 0x%x",
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(macaddr,
                                                macbuf, sizeof(macbuf)),
                                        ipaddr2str(&n->ip,
@@ -6763,7 +6763,7 @@ static inline bool zebra_vxlan_neigh_is_bgp_seq_ok(zebra_vni_t *zvni,
 
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                        zlog_debug("sync-macip ignore vni %u mac %s IP %s as existing has higher seq %u f 0x%x",
-                               zvni->vni,
+                               zevpn->vni,
                                prefix_mac2str(macaddr,
                                        macbuf, sizeof(macbuf)),
                                ipaddr2str(&n->ip,
@@ -6784,7 +6784,7 @@ static void zebra_vxlan_sync_neigh_del(zebra_neigh_t *n)
 
        if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                zlog_debug("sync-neigh del vni %u ip %s mac %s f 0x%x",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -6802,7 +6802,7 @@ static void zebra_vxlan_sync_neigh_del(zebra_neigh_t *n)
                        false /*defer_mac_dp*/, __func__);
 }
 
-static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
+static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_evpn_t *zevpn,
                zebra_neigh_t *n, uint16_t ipa_len,
                struct ipaddr *ipaddr, uint8_t flags, uint32_t seq,
                esi_t *esi, struct sync_mac_ip_ctx *ctx)
@@ -6826,12 +6826,12 @@ static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
        ifindex_t ifindex = 0;
 
        /* locate l3-svi */
-       zif = zvni->vxlan_if->info;
+       zif = zevpn->vxlan_if->info;
        if (zif) {
                struct zebra_l2info_vxlan *vxl;
 
                vxl = &zif->l2info.vxl;
-               ifp = zvni_map_to_svi(vxl->access_vlan,
+               ifp = zevpn_map_to_svi(vxl->access_vlan,
                                zif->brslave_info.br_if);
                if (ifp)
                        ifindex = ifp->ifindex;
@@ -6851,7 +6851,7 @@ static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
                        SET_FLAG(n_flags, ZEBRA_NEIGH_ES_PEER_ACTIVE);
                SET_FLAG(n_flags, ZEBRA_NEIGH_LOCAL_INACTIVE);
 
-               n = zvni_neigh_add(zvni, ipaddr, &mac->macaddr, mac,
+               n = zevpn_neigh_add(zevpn, ipaddr, &mac->macaddr, mac,
                                n_flags);
                n->ifindex = ifindex;
                ZEBRA_NEIGH_SET_ACTIVE(n);
@@ -6877,7 +6877,7 @@ static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
                /* deref and clear old info */
                if (mac_change) {
                        if (old_bgp_ready) {
-                               zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+                               zevpn_neigh_send_del_to_client(zevpn->vni, &n->ip,
                                                &n->emac, n->flags, n->state,
                                                false /*force*/);
                                old_bgp_ready = false;
@@ -6934,7 +6934,7 @@ static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH &&
                                (old_flags != n->flags))
                        zlog_debug("sync-neigh vni %u ip %s mac %s old_f 0x%x new_f 0x%x",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -7000,7 +7000,7 @@ static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
                zlog_debug("sync-neigh %s vni %u ip %s mac %s if %s(%d) seq %d f 0x%x%s%s",
                                created ?
                                "created" : "updated",
-                               n->zvni->vni,
+                               n->zevpn->vni,
                                ipaddr2str(&n->ip, ipbuf, sizeof(ipbuf)),
                                prefix_mac2str(&n->emac, macbuf,
                                        sizeof(macbuf)),
@@ -7020,7 +7020,7 @@ static zebra_neigh_t *zebra_vxlan_proc_sync_neigh_update(zebra_vni_t *zvni,
        return n;
 }
 
-static void zebra_vxlan_process_sync_macip_add(zebra_vni_t *zvni,
+static void zebra_vxlan_process_sync_macip_add(zebra_evpn_t *zevpn,
                                     struct ethaddr *macaddr,
                                     uint16_t ipa_len,
                                     struct ipaddr *ipaddr,
@@ -7042,7 +7042,7 @@ static void zebra_vxlan_process_sync_macip_add(zebra_vni_t *zvni,
                if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_NEIGH ||
                                IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug("Ignore sync-macip vni %u mac %s%s%s%s%s",
-                               zvni->vni,
+                               zevpn->vni,
                                prefix_mac2str(macaddr, macbuf, sizeof(macbuf)),
                                ipa_len ? " IP " : "",
                                ipa_len ?
@@ -7053,20 +7053,20 @@ static void zebra_vxlan_process_sync_macip_add(zebra_vni_t *zvni,
        }
 
        if (ipa_len) {
-               n = zvni_neigh_lookup(zvni, ipaddr);
+               n = zevpn_neigh_lookup(zevpn, ipaddr);
                if (n &&
-                               !zebra_vxlan_neigh_is_bgp_seq_ok(zvni,
+                               !zebra_vxlan_neigh_is_bgp_seq_ok(zevpn,
                                        n, macaddr, seq))
                        return;
        }
 
        memset(&ctx, 0, sizeof(ctx));
-       ctx.mac = zebra_vxlan_proc_sync_mac_update(zvni, macaddr, ipa_len,
+       ctx.mac = zebra_vxlan_proc_sync_mac_update(zevpn, macaddr, ipa_len,
                        ipaddr, flags, seq, esi, &ctx);
        if (ctx.ignore_macip || !ctx.mac || !ipa_len)
                return;
 
-       zebra_vxlan_proc_sync_neigh_update(zvni, n, ipa_len,
+       zebra_vxlan_proc_sync_neigh_update(zevpn, n, ipa_len,
                        ipaddr, flags, seq, esi, &ctx);
 }
 
@@ -7081,7 +7081,7 @@ static void process_remote_macip_add(vni_t vni,
                                     struct in_addr vtep_ip,
                                     esi_t *esi)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_vtep_t *zvtep;
        zebra_mac_t *mac = NULL, *old_mac = NULL;
        zebra_neigh_t *n = NULL;
@@ -7100,14 +7100,14 @@ static void process_remote_macip_add(vni_t vni,
        esi_t *old_esi;
        bool old_static = false;
 
-       /* Locate VNI hash entry - expected to exist. */
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       /* Locate EVPN hash entry - expected to exist. */
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                zlog_warn("Unknown VNI %u upon remote MACIP ADD", vni);
                return;
        }
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        if (ifp)
                zif = ifp->info;
        if (!ifp ||
@@ -7125,7 +7125,7 @@ static void process_remote_macip_add(vni_t vni,
         * REMOTE - if ES is not local
         */
        if (flags & ZEBRA_MACIP_TYPE_SYNC_PATH) {
-               zebra_vxlan_process_sync_macip_add(zvni, macaddr, ipa_len,
+               zebra_vxlan_process_sync_macip_add(zevpn, macaddr, ipa_len,
                                ipaddr, flags, seq, esi);
                return;
        }
@@ -7135,19 +7135,19 @@ static void process_remote_macip_add(vni_t vni,
         * routes before advertising type-3 routes.
         */
        if (vtep_ip.s_addr) {
-               zvtep = zvni_vtep_find(zvni, &vtep_ip);
+               zvtep = zevpn_vtep_find(zevpn, &vtep_ip);
                if (!zvtep) {
-                       zvtep = zvni_vtep_add(zvni, &vtep_ip,
+                       zvtep = zevpn_vtep_add(zevpn, &vtep_ip,
                                        VXLAN_FLOOD_DISABLED);
                        if (!zvtep) {
                                flog_err(
                                        EC_ZEBRA_VTEP_ADD_FAILED,
-                                       "Failed to add remote VTEP, VNI %u zvni %p upon remote MACIP ADD",
-                                       vni, zvni);
+                                       "Failed to add remote VTEP, VNI %u zevpn %p upon remote MACIP ADD",
+                                       vni, zevpn);
                                return;
                        }
 
-                       zvni_vtep_install(zvni, zvtep);
+                       zevpn_vtep_install(zevpn, zvtep);
                }
        }
 
@@ -7155,7 +7155,7 @@ static void process_remote_macip_add(vni_t vni,
        remote_gw = !!CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
        is_router = !!CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_ROUTER_FLAG);
 
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
 
        /* Ignore if the mac is already present as a gateway mac */
        if (mac &&
@@ -7171,7 +7171,7 @@ static void process_remote_macip_add(vni_t vni,
                return;
        }
 
-       zvrf = vrf_info_lookup(zvni->vxlan_if->vrf_id);
+       zvrf = vrf_info_lookup(zevpn->vxlan_if->vrf_id);
        if (!zvrf)
                return;
 
@@ -7192,7 +7192,7 @@ static void process_remote_macip_add(vni_t vni,
 
        if (update_mac) {
                if (!mac) {
-                       mac = zvni_mac_add(zvni, macaddr);
+                       mac = zevpn_mac_add(zevpn, macaddr);
                        if (!mac) {
                                zlog_warn(
                                        "Failed to add MAC %s VNI %u Remote VTEP %s",
@@ -7261,7 +7261,7 @@ static void process_remote_macip_add(vni_t vni,
                        old_static = zebra_vxlan_mac_is_static(mac);
                        if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                                zlog_debug("sync-mac->remote vni %u mac %s es %s seq %d f 0x%x",
-                                               zvni->vni,
+                                               zevpn->vni,
                                                prefix_mac2str(macaddr,
                                                        buf, sizeof(buf)),
                                                mac->es ?
@@ -7269,7 +7269,7 @@ static void process_remote_macip_add(vni_t vni,
                                                mac->loc_seq,
                                                mac->flags);
                        zebra_vxlan_mac_clear_sync_info(mac);
-                       zvni_mac_send_del_to_client(zvni->vni, macaddr,
+                       zevpn_mac_send_del_to_client(zevpn->vni, macaddr,
                                        mac->flags, false /* force */);
                }
 
@@ -7295,9 +7295,9 @@ static void process_remote_macip_add(vni_t vni,
                                                    false);
 
                if (!is_dup_detect) {
-                       zvni_process_neigh_on_remote_mac_add(zvni, mac);
+                       zevpn_process_neigh_on_remote_mac_add(zevpn, mac);
                        /* Install the entry. */
-                       zvni_rem_mac_install(zvni, mac, old_static);
+                       zevpn_rem_mac_install(zevpn, mac, old_static);
                }
        }
 
@@ -7317,7 +7317,7 @@ static void process_remote_macip_add(vni_t vni,
        /* Check if the remote neighbor itself is unknown or has a
         * change. If so, create or update and then install the entry.
         */
-       n = zvni_neigh_lookup(zvni, ipaddr);
+       n = zevpn_neigh_lookup(zevpn, ipaddr);
        if (!n
            || !CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)
            || is_router != !!CHECK_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG)
@@ -7328,7 +7328,7 @@ static void process_remote_macip_add(vni_t vni,
 
        if (update_neigh) {
                if (!n) {
-                       n = zvni_neigh_add(zvni, ipaddr, macaddr, mac, 0);
+                       n = zevpn_neigh_add(zevpn, ipaddr, macaddr, mac, 0);
                        if (!n) {
                                zlog_warn(
                                        "Failed to add Neigh %s MAC %s VNI %u Remote VTEP %s",
@@ -7374,7 +7374,7 @@ static void process_remote_macip_add(vni_t vni,
                                old_static = zebra_vxlan_neigh_is_static(n);
                                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                                        zlog_debug("sync->remote neigh vni %u ip %s mac %s seq %d f0x%x",
-                                               n->zvni->vni,
+                                               n->zevpn->vni,
                                                ipaddr2str(&n->ip, buf1,
                                                        sizeof(buf1)),
                                                prefix_mac2str(&n->emac, buf,
@@ -7382,17 +7382,17 @@ static void process_remote_macip_add(vni_t vni,
                                                seq, n->flags);
                                zebra_vxlan_neigh_clear_sync_info(n);
                                if (IS_ZEBRA_NEIGH_ACTIVE(n))
-                                       zvni_mac_send_del_to_client(zvni->vni,
+                                       zevpn_mac_send_del_to_client(zevpn->vni,
                                                macaddr, mac->flags,
                                                false /*force*/);
                        }
                        if (memcmp(&n->emac, macaddr, sizeof(*macaddr)) != 0) {
                                /* update neigh list for macs */
-                               old_mac = zvni_mac_lookup(zvni, &n->emac);
+                               old_mac = zevpn_mac_lookup(zevpn, &n->emac);
                                if (old_mac) {
                                        listnode_delete(old_mac->neigh_list, n);
                                        n->mac = NULL;
-                                       zvni_deref_ip2mac(zvni, old_mac);
+                                       zevpn_deref_ip2mac(zevpn, old_mac);
                                }
                                n->mac = mac;
                                listnode_add_sort(mac->neigh_list, n);
@@ -7437,7 +7437,7 @@ static void process_remote_macip_add(vni_t vni,
                                                        mac, n)) {
                        flog_warn(EC_ZEBRA_DUP_IP_INHERIT_DETECTED,
                                "VNI %u: MAC %s IP %s detected as duplicate during remote update, inherit duplicate from MAC",
-                               zvni->vni,
+                               zevpn->vni,
                                prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
                                ipaddr2str(&n->ip, buf1, sizeof(buf1)));
                }
@@ -7450,19 +7450,19 @@ static void process_remote_macip_add(vni_t vni,
                                                      false);
                /* Install the entry. */
                if (!is_dup_detect)
-                       zvni_rem_neigh_install(zvni, n, old_static);
+                       zevpn_rem_neigh_install(zevpn, n, old_static);
        }
 
-       zvni_probe_neigh_on_mac_add(zvni, mac);
+       zevpn_probe_neigh_on_mac_add(zevpn, mac);
 
        /* Update seq number. */
        n->rem_seq = seq;
 }
 
-static void zebra_vxlan_rem_mac_del(zebra_vni_t *zvni,
+static void zebra_vxlan_rem_mac_del(zebra_evpn_t *zevpn,
                zebra_mac_t *mac)
 {
-       zvni_process_neigh_on_remote_mac_del(zvni, mac);
+       zevpn_process_neigh_on_remote_mac_del(zevpn, mac);
        /* the remote sequence number in the auto mac entry
         * needs to be reset to 0 as the mac entry may have
         * been removed on all VTEPs (including
@@ -7474,13 +7474,13 @@ static void zebra_vxlan_rem_mac_del(zebra_vni_t *zvni,
         * go away, we need to uninstall the MAC.
         */
        if (remote_neigh_count(mac) == 0) {
-               zvni_rem_mac_uninstall(zvni, mac);
+               zevpn_rem_mac_uninstall(zevpn, mac);
                zebra_evpn_es_mac_deref_entry(mac);
                UNSET_FLAG(mac->flags, ZEBRA_MAC_REMOTE);
        }
 
        if (list_isempty(mac->neigh_list))
-               zvni_mac_del(zvni, mac);
+               zevpn_mac_del(zevpn, mac);
        else
                SET_FLAG(mac->flags, ZEBRA_MAC_AUTO);
 }
@@ -7492,7 +7492,7 @@ static void process_remote_macip_del(vni_t vni,
                                     struct ipaddr *ipaddr,
                                     struct in_addr vtep_ip)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_mac_t *mac = NULL;
        zebra_neigh_t *n = NULL;
        struct interface *ifp = NULL;
@@ -7503,15 +7503,15 @@ static void process_remote_macip_del(vni_t vni,
        char buf[ETHER_ADDR_STRLEN];
        char buf1[INET6_ADDRSTRLEN];
 
-       /* Locate VNI hash entry - expected to exist. */
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       /* Locate EVPN hash entry - expected to exist. */
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("Unknown VNI %u upon remote MACIP DEL", vni);
                return;
        }
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        if (ifp)
                zif = ifp->info;
        if (!ifp ||
@@ -7526,9 +7526,9 @@ static void process_remote_macip_del(vni_t vni,
        zns = zebra_ns_lookup(NS_DEFAULT);
        vxl = &zif->l2info.vxl;
 
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (ipa_len)
-               n = zvni_neigh_lookup(zvni, ipaddr);
+               n = zevpn_neigh_lookup(zevpn, ipaddr);
 
        if (n && !mac) {
                zlog_warn("Failed to locate MAC %s for neigh %s VNI %u upon remote MACIP DEL",
@@ -7543,7 +7543,7 @@ static void process_remote_macip_del(vni_t vni,
        if (!mac && !n)
                return;
 
-       zvrf = vrf_info_lookup(zvni->vxlan_if->vrf_id);
+       zvrf = vrf_info_lookup(zevpn->vxlan_if->vrf_id);
 
        /* Ignore the delete if this mac is a gateway mac-ip */
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)
@@ -7566,7 +7566,7 @@ static void process_remote_macip_del(vni_t vni,
                    (memcmp(n->emac.octet, macaddr->octet, ETH_ALEN) == 0)) {
                        struct interface *vlan_if;
 
-                       vlan_if = zvni_map_to_svi(vxl->access_vlan,
+                       vlan_if = zevpn_map_to_svi(vxl->access_vlan,
                                        zif->brslave_info.br_if);
                        if (IS_ZEBRA_DEBUG_VXLAN)
                                zlog_debug(
@@ -7588,9 +7588,9 @@ static void process_remote_macip_del(vni_t vni,
                        if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_LOCAL)) {
                                zebra_vxlan_sync_neigh_del(n);
                        } else if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
-                               zvni_neigh_uninstall(zvni, n);
-                               zvni_neigh_del(zvni, n);
-                               zvni_deref_ip2mac(zvni, mac);
+                               zevpn_neigh_uninstall(zevpn, n);
+                               zevpn_neigh_del(zevpn, n);
+                               zevpn_deref_ip2mac(zevpn, mac);
                        }
                }
        } else {
@@ -7618,7 +7618,7 @@ static void process_remote_macip_del(vni_t vni,
                        if (!ipa_len)
                                zebra_vxlan_sync_mac_del(mac);
                } else if (CHECK_FLAG(mac->flags, ZEBRA_NEIGH_REMOTE)) {
-                       zebra_vxlan_rem_mac_del(zvni, mac);
+                       zebra_vxlan_rem_mac_del(zevpn, mac);
                }
        }
 }
@@ -8017,22 +8017,22 @@ void zebra_vxlan_print_vrf_vni(struct vty *vty, struct zebra_vrf *zvrf,
 void zebra_vxlan_print_neigh_vni(struct vty *vty, struct zebra_vrf *zvrf,
                                 vni_t vni, bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_neigh;
        struct neigh_walk_ctx wctx;
        json_object *json = NULL;
 
        if (!is_evpn_enabled())
                return;
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (use_json)
                        vty_out(vty, "{}\n");
                else
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
-       num_neigh = hashcount(zvni->neigh_table);
+       num_neigh = hashcount(zevpn->neigh_table);
        if (!num_neigh)
                return;
 
@@ -8044,21 +8044,21 @@ void zebra_vxlan_print_neigh_vni(struct vty *vty, struct zebra_vrf *zvrf,
         * the maximum width.
         */
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.addr_width = 15;
        wctx.json = json;
-       hash_iterate(zvni->neigh_table, zvni_find_neigh_addr_width, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_find_neigh_addr_width, &wctx);
 
        if (!use_json) {
                vty_out(vty,
                        "Number of ARPs (local and remote) known for this VNI: %u\n",
                        num_neigh);
-               zvni_print_neigh_hdr(vty, &wctx);
+               zevpn_print_neigh_hdr(vty, &wctx);
        } else
                json_object_int_add(json, "numArpNd", num_neigh);
 
-       hash_iterate(zvni->neigh_table, zvni_print_neigh_hash, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_print_neigh_hash, &wctx);
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
                                             json, JSON_C_TO_STRING_PRETTY));
@@ -8085,9 +8085,9 @@ void zebra_vxlan_print_neigh_all_vni(struct vty *vty, struct zebra_vrf *zvrf,
        args[1] = json;
        args[2] = (void *)(ptrdiff_t)print_dup;
 
-       hash_iterate(zvrf->vni_table,
+       hash_iterate(zvrf->evpn_table,
                     (void (*)(struct hash_bucket *,
-                              void *))zvni_print_neigh_hash_all_vni,
+                              void *))zevpn_print_neigh_hash_all_evpn,
                     args);
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8116,9 +8116,9 @@ void zebra_vxlan_print_neigh_all_vni_detail(struct vty *vty,
        args[1] = json;
        args[2] = (void *)(ptrdiff_t)print_dup;
 
-       hash_iterate(zvrf->vni_table,
+       hash_iterate(zvrf->evpn_table,
                     (void (*)(struct hash_bucket *,
-                              void *))zvni_print_neigh_hash_all_vni_detail,
+                              void *))zevpn_print_neigh_hash_all_evpn_detail,
                     args);
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8134,21 +8134,21 @@ void zebra_vxlan_print_specific_neigh_vni(struct vty *vty,
                                          struct zebra_vrf *zvrf, vni_t vni,
                                          struct ipaddr *ip, bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_neigh_t *n;
        json_object *json = NULL;
 
        if (!is_evpn_enabled())
                return;
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (use_json)
                        vty_out(vty, "{}\n");
                else
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
-       n = zvni_neigh_lookup(zvni, ip);
+       n = zevpn_neigh_lookup(zevpn, ip);
        if (!n) {
                if (!use_json)
                        vty_out(vty,
@@ -8159,7 +8159,7 @@ void zebra_vxlan_print_specific_neigh_vni(struct vty *vty,
        if (use_json)
                json = json_object_new_object();
 
-       zvni_print_neigh(n, vty, json);
+       zevpn_print_neigh(n, vty, json);
 
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8176,22 +8176,22 @@ void zebra_vxlan_print_neigh_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
                                      vni_t vni, struct in_addr vtep_ip,
                                      bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_neigh;
        struct neigh_walk_ctx wctx;
        json_object *json = NULL;
 
        if (!is_evpn_enabled())
                return;
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (use_json)
                        vty_out(vty, "{}\n");
                else
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
-       num_neigh = hashcount(zvni->neigh_table);
+       num_neigh = hashcount(zevpn->neigh_table);
        if (!num_neigh)
                return;
 
@@ -8199,14 +8199,14 @@ void zebra_vxlan_print_neigh_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
                json = json_object_new_object();
 
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.addr_width = 15;
        wctx.flags = SHOW_REMOTE_NEIGH_FROM_VTEP;
        wctx.r_vtep_ip = vtep_ip;
        wctx.json = json;
-       hash_iterate(zvni->neigh_table, zvni_find_neigh_addr_width, &wctx);
-       hash_iterate(zvni->neigh_table, zvni_print_neigh_hash, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_find_neigh_addr_width, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_print_neigh_hash, &wctx);
 
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8224,7 +8224,7 @@ void zebra_vxlan_print_neigh_vni_dad(struct vty *vty,
                                     vni_t vni,
                                     bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_neigh;
        struct neigh_walk_ctx wctx;
        json_object *json = NULL;
@@ -8232,17 +8232,17 @@ void zebra_vxlan_print_neigh_vni_dad(struct vty *vty,
        if (!is_evpn_enabled())
                return;
 
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
 
-       num_neigh = hashcount(zvni->neigh_table);
+       num_neigh = hashcount(zevpn->neigh_table);
        if (!num_neigh)
                return;
 
-       num_neigh = num_dup_detected_neighs(zvni);
+       num_neigh = num_dup_detected_neighs(zevpn);
        if (!num_neigh)
                return;
 
@@ -8254,11 +8254,11 @@ void zebra_vxlan_print_neigh_vni_dad(struct vty *vty,
         * the maximum width.
         */
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.addr_width = 15;
        wctx.json = json;
-       hash_iterate(zvni->neigh_table, zvni_find_neigh_addr_width, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_find_neigh_addr_width, &wctx);
 
        if (!use_json) {
                vty_out(vty,
@@ -8270,7 +8270,7 @@ void zebra_vxlan_print_neigh_vni_dad(struct vty *vty,
        } else
                json_object_int_add(json, "numArpNd", num_neigh);
 
-       hash_iterate(zvni->neigh_table, zvni_print_dad_neigh_hash, &wctx);
+       hash_iterate(zevpn->neigh_table, zevpn_print_dad_neigh_hash, &wctx);
 
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8285,7 +8285,7 @@ void zebra_vxlan_print_neigh_vni_dad(struct vty *vty,
 void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
                                vni_t vni, bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_macs;
        struct mac_walk_ctx wctx;
        json_object *json = NULL;
@@ -8293,15 +8293,15 @@ void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
 
        if (!is_evpn_enabled())
                return;
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (use_json)
                        vty_out(vty, "{}\n");
                else
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
-       num_macs = num_valid_macs(zvni);
+       num_macs = num_valid_macs(zevpn);
        if (!num_macs)
                return;
 
@@ -8311,7 +8311,7 @@ void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
        }
 
        memset(&wctx, 0, sizeof(struct mac_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.json = json_mac;
 
@@ -8327,7 +8327,7 @@ void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
        } else
                json_object_int_add(json, "numMacs", num_macs);
 
-       hash_iterate(zvni->mac_table, zvni_print_mac_hash, &wctx);
+       hash_iterate(zevpn->mac_table, zevpn_print_mac_hash, &wctx);
 
        if (use_json) {
                json_object_object_add(json, "macs", json_mac);
@@ -8358,7 +8358,7 @@ void zebra_vxlan_print_macs_all_vni(struct vty *vty, struct zebra_vrf *zvrf,
        wctx.vty = vty;
        wctx.json = json;
        wctx.print_dup = print_dup;
-       hash_iterate(zvrf->vni_table, zvni_print_mac_hash_all_vni, &wctx);
+       hash_iterate(zvrf->evpn_table, zevpn_print_mac_hash_all_evpn, &wctx);
 
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8389,7 +8389,7 @@ void zebra_vxlan_print_macs_all_vni_detail(struct vty *vty,
        wctx.vty = vty;
        wctx.json = json;
        wctx.print_dup = print_dup;
-       hash_iterate(zvrf->vni_table, zvni_print_mac_hash_all_vni_detail,
+       hash_iterate(zvrf->evpn_table, zevpn_print_mac_hash_all_evpn_detail,
                     &wctx);
 
        if (use_json) {
@@ -8420,7 +8420,7 @@ void zebra_vxlan_print_macs_all_vni_vtep(struct vty *vty,
        wctx.flags = SHOW_REMOTE_MAC_FROM_VTEP;
        wctx.r_vtep_ip = vtep_ip;
        wctx.json = json;
-       hash_iterate(zvrf->vni_table, zvni_print_mac_hash_all_vni, &wctx);
+       hash_iterate(zvrf->evpn_table, zevpn_print_mac_hash_all_evpn, &wctx);
 
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
@@ -8436,22 +8436,22 @@ void zebra_vxlan_print_specific_mac_vni(struct vty *vty, struct zebra_vrf *zvrf,
                                        vni_t vni, struct ethaddr *macaddr,
                                        bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_mac_t *mac;
        json_object *json = NULL;
 
        if (!is_evpn_enabled())
                return;
 
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (use_json)
                        vty_out(vty, "{}\n");
                else
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac) {
                if (use_json)
                        vty_out(vty, "{}\n");
@@ -8465,7 +8465,7 @@ void zebra_vxlan_print_specific_mac_vni(struct vty *vty, struct zebra_vrf *zvrf,
        if (use_json)
                json = json_object_new_object();
 
-       zvni_print_mac(mac, vty, json);
+       zevpn_print_mac(mac, vty, json);
        if (use_json) {
                vty_out(vty, "%s\n", json_object_to_json_string_ext(
                                             json, JSON_C_TO_STRING_PRETTY));
@@ -8478,7 +8478,7 @@ void zebra_vxlan_print_macs_vni_dad(struct vty *vty,
                                    struct zebra_vrf *zvrf,
                                    vni_t vni, bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        struct mac_walk_ctx wctx;
        uint32_t num_macs;
        json_object *json = NULL;
@@ -8487,17 +8487,17 @@ void zebra_vxlan_print_macs_vni_dad(struct vty *vty,
        if (!is_evpn_enabled())
                return;
 
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
 
-       num_macs = num_valid_macs(zvni);
+       num_macs = num_valid_macs(zevpn);
        if (!num_macs)
                return;
 
-       num_macs = num_dup_detected_macs(zvni);
+       num_macs = num_dup_detected_macs(zevpn);
        if (!num_macs)
                return;
 
@@ -8507,7 +8507,7 @@ void zebra_vxlan_print_macs_vni_dad(struct vty *vty,
        }
 
        memset(&wctx, 0, sizeof(struct mac_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.json = json_mac;
 
@@ -8520,7 +8520,7 @@ void zebra_vxlan_print_macs_vni_dad(struct vty *vty,
        } else
                json_object_int_add(json, "numMacs", num_macs);
 
-       hash_iterate(zvni->mac_table, zvni_print_dad_mac_hash, &wctx);
+       hash_iterate(zevpn->mac_table, zevpn_print_dad_mac_hash, &wctx);
 
        if (use_json) {
                json_object_object_add(json, "macs", json_mac);
@@ -8534,7 +8534,7 @@ void zebra_vxlan_print_macs_vni_dad(struct vty *vty,
 int zebra_vxlan_clear_dup_detect_vni_mac(struct zebra_vrf *zvrf, vni_t vni,
                                         struct ethaddr *macaddr)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_mac_t *mac;
        struct listnode *node = NULL;
        zebra_neigh_t *nbr = NULL;
@@ -8542,13 +8542,13 @@ int zebra_vxlan_clear_dup_detect_vni_mac(struct zebra_vrf *zvrf, vni_t vni,
        if (!is_evpn_enabled())
                return 0;
 
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                zlog_warn("VNI %u does not exist\n", vni);
                return -1;
        }
 
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac) {
                zlog_warn("Requested MAC does not exist in VNI %u\n", vni);
                return -1;
@@ -8573,7 +8573,7 @@ int zebra_vxlan_clear_dup_detect_vni_mac(struct zebra_vrf *zvrf, vni_t vni,
                        if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL))
                                ZEBRA_NEIGH_SET_INACTIVE(nbr);
                        else if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE))
-                               zvni_rem_neigh_install(zvni, nbr,
+                               zevpn_rem_neigh_install(zevpn, nbr,
                                        false /*was_static*/);
                }
 
@@ -8597,21 +8597,21 @@ int zebra_vxlan_clear_dup_detect_vni_mac(struct zebra_vrf *zvrf, vni_t vni,
        /* Local: Notify Peer VTEPs, Remote: Install the entry */
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
                /* Inform to BGP */
-               if (zvni_mac_send_add_to_client(zvni->vni,
+               if (zevpn_mac_send_add_to_client(zevpn->vni,
                                        &mac->macaddr,
                                        mac->flags,
                                        mac->loc_seq, mac->es))
                        return 0;
 
                /* Process all neighbors associated with this MAC. */
-               zvni_process_neigh_on_local_mac_change(zvni, mac, 0,
+               zevpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
                                0 /*es_change*/);
 
        } else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
-               zvni_process_neigh_on_remote_mac_add(zvni, mac);
+               zevpn_process_neigh_on_remote_mac_add(zevpn, mac);
 
                /* Install the entry. */
-               zvni_rem_mac_install(zvni, mac, false /* was_static */);
+               zevpn_rem_mac_install(zevpn, mac, false /* was_static */);
        }
 
        return 0;
@@ -8620,7 +8620,7 @@ int zebra_vxlan_clear_dup_detect_vni_mac(struct zebra_vrf *zvrf, vni_t vni,
 int zebra_vxlan_clear_dup_detect_vni_ip(struct zebra_vrf *zvrf, vni_t vni,
                                        struct ipaddr *ip)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_neigh_t *nbr;
        zebra_mac_t *mac;
        char buf[INET6_ADDRSTRLEN];
@@ -8629,13 +8629,13 @@ int zebra_vxlan_clear_dup_detect_vni_ip(struct zebra_vrf *zvrf, vni_t vni,
        if (!is_evpn_enabled())
                return 0;
 
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                zlog_debug("VNI %u does not exist\n", vni);
                return -1;
        }
 
-       nbr = zvni_neigh_lookup(zvni, ip);
+       nbr = zevpn_neigh_lookup(zevpn, ip);
        if (!nbr) {
                zlog_warn("Requested host IP does not exist in VNI %u\n", vni);
                return -1;
@@ -8649,7 +8649,7 @@ int zebra_vxlan_clear_dup_detect_vni_ip(struct zebra_vrf *zvrf, vni_t vni,
                return -1;
        }
 
-       mac = zvni_mac_lookup(zvni, &nbr->emac);
+       mac = zevpn_mac_lookup(zevpn, &nbr->emac);
 
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE)) {
                zlog_warn(
@@ -8670,21 +8670,21 @@ int zebra_vxlan_clear_dup_detect_vni_ip(struct zebra_vrf *zvrf, vni_t vni,
        THREAD_OFF(nbr->dad_ip_auto_recovery_timer);
 
        if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)) {
-               zvni_neigh_send_add_to_client(zvni->vni, ip,
+               zevpn_neigh_send_add_to_client(zevpn->vni, ip,
                                              &nbr->emac, nbr->mac,
                                              nbr->flags, nbr->loc_seq);
        } else if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE)) {
-               zvni_rem_neigh_install(zvni, nbr, false /*was_static*/);
+               zevpn_rem_neigh_install(zevpn, nbr, false /*was_static*/);
        }
 
        return 0;
 }
 
-static void zvni_clear_dup_mac_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_clear_dup_mac_hash(struct hash_bucket *bucket, void *ctxt)
 {
        struct mac_walk_ctx *wctx = ctxt;
        zebra_mac_t *mac;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        struct listnode *node = NULL;
        zebra_neigh_t *nbr = NULL;
 
@@ -8692,7 +8692,7 @@ static void zvni_clear_dup_mac_hash(struct hash_bucket *bucket, void *ctxt)
        if (!mac)
                return;
 
-       zvni = wctx->zvni;
+       zevpn = wctx->zevpn;
 
        if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
                return;
@@ -8719,35 +8719,35 @@ static void zvni_clear_dup_mac_hash(struct hash_bucket *bucket, void *ctxt)
        /* Local: Notify Peer VTEPs, Remote: Install the entry */
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
                /* Inform to BGP */
-               if (zvni_mac_send_add_to_client(zvni->vni,
+               if (zevpn_mac_send_add_to_client(zevpn->vni,
                                        &mac->macaddr,
                                        mac->flags, mac->loc_seq, mac->es))
                        return;
 
                /* Process all neighbors associated with this MAC. */
-               zvni_process_neigh_on_local_mac_change(zvni, mac, 0,
+               zevpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
                                0 /*es_change*/);
 
        } else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
-               zvni_process_neigh_on_remote_mac_add(zvni, mac);
+               zevpn_process_neigh_on_remote_mac_add(zevpn, mac);
 
                /* Install the entry. */
-               zvni_rem_mac_install(zvni, mac, false /* was_static */);
+               zevpn_rem_mac_install(zevpn, mac, false /* was_static */);
        }
 }
 
-static void zvni_clear_dup_neigh_hash(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_clear_dup_neigh_hash(struct hash_bucket *bucket, void *ctxt)
 {
        struct neigh_walk_ctx *wctx = ctxt;
        zebra_neigh_t *nbr;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        char buf[INET6_ADDRSTRLEN];
 
        nbr = (zebra_neigh_t *)bucket->data;
        if (!nbr)
                return;
 
-       zvni = wctx->zvni;
+       zevpn = wctx->zevpn;
 
        if (!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
                return;
@@ -8766,41 +8766,41 @@ static void zvni_clear_dup_neigh_hash(struct hash_bucket *bucket, void *ctxt)
        THREAD_OFF(nbr->dad_ip_auto_recovery_timer);
 
        if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)) {
-               zvni_neigh_send_add_to_client(zvni->vni, &nbr->ip,
+               zevpn_neigh_send_add_to_client(zevpn->vni, &nbr->ip,
                                              &nbr->emac, nbr->mac,
                                              nbr->flags, nbr->loc_seq);
        } else if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE)) {
-               zvni_rem_neigh_install(zvni, nbr, false /*was_static*/);
+               zevpn_rem_neigh_install(zevpn, nbr, false /*was_static*/);
        }
 }
 
-static void zvni_clear_dup_detect_hash_vni_all(struct hash_bucket *bucket,
+static void zevpn_clear_dup_detect_hash_vni_all(struct hash_bucket *bucket,
                                            void **args)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        struct zebra_vrf *zvrf;
        struct mac_walk_ctx m_wctx;
        struct neigh_walk_ctx n_wctx;
 
-       zvni = (zebra_vni_t *)bucket->data;
-       if (!zvni)
+       zevpn = (zebra_evpn_t *)bucket->data;
+       if (!zevpn)
                return;
 
        zvrf = (struct zebra_vrf *)args[0];
 
-       if (hashcount(zvni->neigh_table)) {
+       if (hashcount(zevpn->neigh_table)) {
                memset(&n_wctx, 0, sizeof(struct neigh_walk_ctx));
-               n_wctx.zvni = zvni;
+               n_wctx.zevpn = zevpn;
                n_wctx.zvrf = zvrf;
-               hash_iterate(zvni->neigh_table, zvni_clear_dup_neigh_hash,
+               hash_iterate(zevpn->neigh_table, zevpn_clear_dup_neigh_hash,
                             &n_wctx);
        }
 
-       if (num_valid_macs(zvni)) {
+       if (num_valid_macs(zevpn)) {
                memset(&m_wctx, 0, sizeof(struct mac_walk_ctx));
-               m_wctx.zvni = zvni;
+               m_wctx.zevpn = zevpn;
                m_wctx.zvrf = zvrf;
-               hash_iterate(zvni->mac_table, zvni_clear_dup_mac_hash, &m_wctx);
+               hash_iterate(zevpn->mac_table, zevpn_clear_dup_mac_hash, &m_wctx);
        }
 
 }
@@ -8814,41 +8814,41 @@ int zebra_vxlan_clear_dup_detect_vni_all(struct zebra_vrf *zvrf)
 
        args[0] = zvrf;
 
-       hash_iterate(zvrf->vni_table,
+       hash_iterate(zvrf->evpn_table,
                     (void (*)(struct hash_bucket *, void *))
-                    zvni_clear_dup_detect_hash_vni_all, args);
+                    zevpn_clear_dup_detect_hash_vni_all, args);
 
        return 0;
 }
 
 int zebra_vxlan_clear_dup_detect_vni(struct zebra_vrf *zvrf, vni_t vni)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        struct mac_walk_ctx m_wctx;
        struct neigh_walk_ctx n_wctx;
 
        if (!is_evpn_enabled())
                return 0;
 
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                zlog_warn("VNI %u does not exist\n", vni);
-               return -1;
+               return CMD_WARNING;
        }
 
-       if (hashcount(zvni->neigh_table)) {
+       if (hashcount(zevpn->neigh_table)) {
                memset(&n_wctx, 0, sizeof(struct neigh_walk_ctx));
-               n_wctx.zvni = zvni;
+               n_wctx.zevpn = zevpn;
                n_wctx.zvrf = zvrf;
-               hash_iterate(zvni->neigh_table, zvni_clear_dup_neigh_hash,
+               hash_iterate(zevpn->neigh_table, zevpn_clear_dup_neigh_hash,
                             &n_wctx);
        }
 
-       if (num_valid_macs(zvni)) {
+       if (num_valid_macs(zevpn)) {
                memset(&m_wctx, 0, sizeof(struct mac_walk_ctx));
-               m_wctx.zvni = zvni;
+               m_wctx.zevpn = zevpn;
                m_wctx.zvrf = zvrf;
-               hash_iterate(zvni->mac_table, zvni_clear_dup_mac_hash, &m_wctx);
+               hash_iterate(zevpn->mac_table, zevpn_clear_dup_mac_hash, &m_wctx);
        }
 
        return 0;
@@ -8861,7 +8861,7 @@ void zebra_vxlan_print_macs_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
                                     vni_t vni, struct in_addr vtep_ip,
                                     bool use_json)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        uint32_t num_macs;
        struct mac_walk_ctx wctx;
        json_object *json = NULL;
@@ -8869,15 +8869,15 @@ void zebra_vxlan_print_macs_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
 
        if (!is_evpn_enabled())
                return;
-       zvni = zvni_lookup(vni);
-       if (!zvni) {
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn) {
                if (use_json)
                        vty_out(vty, "{}\n");
                else
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
                return;
        }
-       num_macs = num_valid_macs(zvni);
+       num_macs = num_valid_macs(zevpn);
        if (!num_macs)
                return;
 
@@ -8887,12 +8887,12 @@ void zebra_vxlan_print_macs_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
        }
 
        memset(&wctx, 0, sizeof(struct mac_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
        wctx.vty = vty;
        wctx.flags = SHOW_REMOTE_MAC_FROM_VTEP;
        wctx.r_vtep_ip = vtep_ip;
        wctx.json = json_mac;
-       hash_iterate(zvni->mac_table, zvni_print_mac_hash, &wctx);
+       hash_iterate(zevpn->mac_table, zevpn_print_mac_hash, &wctx);
 
        if (use_json) {
                json_object_int_add(json, "numMacs", wctx.count);
@@ -8919,7 +8919,7 @@ void zebra_vxlan_print_vni(struct vty *vty, struct zebra_vrf *zvrf, vni_t vni,
        json_object *json = NULL;
        void *args[2];
        zebra_l3vni_t *zl3vni = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
 
        if (!is_evpn_enabled())
                return;
@@ -8934,9 +8934,9 @@ void zebra_vxlan_print_vni(struct vty *vty, struct zebra_vrf *zvrf, vni_t vni,
        if (zl3vni) {
                zl3vni_print(zl3vni, (void *)args);
        } else {
-               zvni = zvni_lookup(vni);
-               if (zvni)
-                       zvni_print(zvni, (void *)args);
+               zevpn = zevpn_lookup(vni);
+               if (zevpn)
+                       zevpn_print(zevpn, (void *)args);
                else if (!json)
                        vty_out(vty, "%% VNI %u does not exist\n", vni);
        }
@@ -8974,7 +8974,7 @@ void zebra_vxlan_print_evpn(struct vty *vty, bool uj)
                return;
 
        num_l3vnis = hashcount(zrouter.l3vni_table);
-       num_l2vnis = hashcount(zvrf->vni_table);
+       num_l2vnis = hashcount(zvrf->evpn_table);
        num_vnis = num_l2vnis + num_l3vnis;
 
        if (uj) {
@@ -9046,8 +9046,8 @@ void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf,
        args[1] = json;
 
        /* Display all L2-VNIs */
-       hash_iterate(zvrf->vni_table,
-                    (void (*)(struct hash_bucket *, void *))zvni_print_hash,
+       hash_iterate(zvrf->evpn_table,
+                    (void (*)(struct hash_bucket *, void *))zevpn_print_hash,
                     args);
 
        /* Display all L3-VNIs */
@@ -9112,7 +9112,7 @@ void zebra_vxlan_print_vnis_detail(struct vty *vty, struct zebra_vrf *zvrf,
 {
        json_object *json_array = NULL;
        struct zebra_ns *zns = NULL;
-       struct zvni_evpn_show zes;
+       struct zevpn_show zes;
 
        if (!is_evpn_enabled())
                return;
@@ -9131,8 +9131,8 @@ void zebra_vxlan_print_vnis_detail(struct vty *vty, struct zebra_vrf *zvrf,
 
        /* Display all L2-VNIs */
        hash_iterate(
-               zvrf->vni_table,
-               (void (*)(struct hash_bucket *, void *))zvni_print_hash_detail,
+               zvrf->evpn_table,
+               (void (*)(struct hash_bucket *, void *))zevpn_print_hash_detail,
                &zes);
 
        /* Display all L3-VNIs */
@@ -9162,7 +9162,7 @@ int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
        char buf[INET6_ADDRSTRLEN];
        char buf2[ETHER_ADDR_STRLEN];
        zebra_neigh_t *n = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_mac_t *zmac = NULL;
        zebra_l3vni_t *zl3vni = NULL;
        struct zebra_vrf *zvrf;
@@ -9179,41 +9179,41 @@ int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
        /* We are only interested in neighbors on an SVI that resides on top
         * of a VxLAN bridge.
         */
-       zvni = zvni_from_svi(ifp, link_if);
-       if (!zvni) {
+       zevpn = zevpn_from_svi(ifp, link_if);
+       if (!zevpn) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
-                               "%s: Del neighbor %s VNI is not present for interface %s",
+                               "%s: Del neighbor %s EVPN is not present for interface %s",
                                __func__, ipaddr2str(ip, buf, sizeof(buf)),
                                ifp->name);
                return 0;
        }
 
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                zlog_debug(
                        "VNI %u hash %p doesn't have intf upon local neighbor DEL",
-                       zvni->vni, zvni);
+                       zevpn->vni, zevpn);
                return -1;
        }
 
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug("Del neighbor %s intf %s(%u) -> L2-VNI %u",
                           ipaddr2str(ip, buf, sizeof(buf)), ifp->name,
-                          ifp->ifindex, zvni->vni);
+                          ifp->ifindex, zevpn->vni);
 
        /* If entry doesn't exist, nothing to do. */
-       n = zvni_neigh_lookup(zvni, ip);
+       n = zevpn_neigh_lookup(zevpn, ip);
        if (!n)
                return 0;
 
-       zmac = zvni_mac_lookup(zvni, &n->emac);
+       zmac = zevpn_mac_lookup(zevpn, &n->emac);
        if (!zmac) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                                "Trying to del a neigh %s without a mac %s on VNI %u",
                                ipaddr2str(ip, buf, sizeof(buf)),
                                prefix_mac2str(&n->emac, buf2, sizeof(buf2)),
-                               zvni->vni);
+                               zevpn->vni);
 
                return 0;
        }
@@ -9222,7 +9222,7 @@ int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
         * deleted it, it needs to be re-installed as Quagga is the owner.
         */
        if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
-               zvni_rem_neigh_install(zvni, n, false /*was_static*/);
+               zevpn_rem_neigh_install(zevpn, n, false /*was_static*/);
                return 0;
        }
 
@@ -9234,7 +9234,7 @@ int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
        if (zebra_vxlan_neigh_is_static(n)) {
                if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
                        zlog_debug("re-add sync neigh vni %u ip %s mac %s 0x%x",
-                                       n->zvni->vni,
+                                       n->zevpn->vni,
                                        ipaddr2str(&n->ip, buf, sizeof(buf)),
                                        prefix_mac2str(&n->emac, buf2,
                                                sizeof(buf2)),
@@ -9255,10 +9255,10 @@ int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
                return 0;
        }
 
-       zvrf = vrf_info_lookup(zvni->vxlan_if->vrf_id);
+       zvrf = vrf_info_lookup(zevpn->vxlan_if->vrf_id);
        if (!zvrf) {
                zlog_debug("%s: VNI %u vrf lookup failed.", __func__,
-                          zvni->vni);
+                          zevpn->vni);
                return -1;
        }
 
@@ -9271,17 +9271,17 @@ int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
            ZEBRA_NEIGH_SET_INACTIVE(n);
 
        /* Remove neighbor from BGP. */
-       zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+       zevpn_neigh_send_del_to_client(zevpn->vni, &n->ip,
                        &n->emac, n->flags, n->state,
                        false /* force */);
 
        /* Delete this neighbor entry. */
-       zvni_neigh_del(zvni, n);
+       zevpn_neigh_del(zevpn, n);
 
        /* see if the AUTO mac needs to be deleted */
        if (CHECK_FLAG(zmac->flags, ZEBRA_MAC_AUTO)
            && !listcount(zmac->neigh_list))
-               zvni_mac_del(zvni, zmac);
+               zevpn_mac_del(zevpn, zmac);
 
        return 0;
 }
@@ -9303,7 +9303,7 @@ int zebra_vxlan_handle_kernel_neigh_update(struct interface *ifp,
 {
        char buf[ETHER_ADDR_STRLEN];
        char buf2[INET6_ADDRSTRLEN];
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        /* check if this is a remote neigh entry corresponding to remote
@@ -9316,8 +9316,8 @@ int zebra_vxlan_handle_kernel_neigh_update(struct interface *ifp,
        /* We are only interested in neighbors on an SVI that resides on top
         * of a VxLAN bridge.
         */
-       zvni = zvni_from_svi(ifp, link_if);
-       if (!zvni)
+       zevpn = zevpn_from_svi(ifp, link_if);
+       if (!zevpn)
                return 0;
 
        if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
@@ -9328,14 +9328,14 @@ int zebra_vxlan_handle_kernel_neigh_update(struct interface *ifp,
                        ifp->ifindex, state, is_ext ? "ext-learned " : "",
                        is_router ? "router " : "",
                        local_inactive ? "local_inactive " : "",
-                       zvni->vni);
+                       zevpn->vni);
 
        /* Is this about a local neighbor or a remote one? */
        if (!is_ext)
-               return zvni_local_neigh_update(zvni, ifp, ip, macaddr,
+               return zevpn_local_neigh_update(zevpn, ifp, ip, macaddr,
                                is_router, local_inactive, dp_static);
 
-       return zvni_remote_neigh_update(zvni, ifp, ip, macaddr, state);
+       return zevpn_remote_neigh_update(zevpn, ifp, ip, macaddr, state);
 }
 
 static int32_t
@@ -9513,7 +9513,7 @@ int zebra_vxlan_check_readd_vtep(struct interface *ifp,
        struct zebra_vrf *zvrf = NULL;
        struct zebra_l2info_vxlan *vxl;
        vni_t vni;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_vtep_t *zvtep = NULL;
 
        zif = ifp->info;
@@ -9531,12 +9531,12 @@ int zebra_vxlan_check_readd_vtep(struct interface *ifp,
                return -1;
 
        /* Locate hash entry; it is expected to exist. */
-       zvni = zvni_lookup(vni);
-       if (!zvni)
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn)
                return 0;
 
        /* If the remote vtep entry doesn't exists nothing to do */
-       zvtep = zvni_vtep_find(zvni, &vtep_ip);
+       zvtep = zevpn_vtep_find(zevpn, &vtep_ip);
        if (!zvtep)
                return 0;
 
@@ -9545,7 +9545,7 @@ int zebra_vxlan_check_readd_vtep(struct interface *ifp,
                        "Del MAC for remote VTEP %s intf %s(%u) VNI %u - readd",
                        inet_ntoa(vtep_ip), ifp->name, ifp->ifindex, vni);
 
-       zvni_vtep_install(zvni, zvtep);
+       zevpn_vtep_install(zevpn, zvtep);
        return 0;
 }
 
@@ -9561,7 +9561,7 @@ int zebra_vxlan_check_del_local_mac(struct interface *ifp,
        struct zebra_if *zif;
        struct zebra_l2info_vxlan *vxl;
        vni_t vni;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_mac_t *mac;
        char buf[ETHER_ADDR_STRLEN];
 
@@ -9575,12 +9575,12 @@ int zebra_vxlan_check_del_local_mac(struct interface *ifp,
                return 0;
 
        /* Locate hash entry; it is expected to exist. */
-       zvni = zvni_lookup(vni);
-       if (!zvni)
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn)
                return 0;
 
        /* If entry doesn't exist, nothing to do. */
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac)
                return 0;
 
@@ -9595,7 +9595,7 @@ int zebra_vxlan_check_del_local_mac(struct interface *ifp,
                        ifp->ifindex, vni, mac->flags);
 
        /* Remove MAC from BGP. */
-       zvni_mac_send_del_to_client(zvni->vni, macaddr,
+       zevpn_mac_send_del_to_client(zevpn->vni, macaddr,
                        mac->flags, false /* force */);
 
        /*
@@ -9603,7 +9603,7 @@ int zebra_vxlan_check_del_local_mac(struct interface *ifp,
         * else mark it as AUTO for forward reference
         */
        if (!listcount(mac->neigh_list)) {
-               zvni_mac_del(zvni, mac);
+               zevpn_mac_del(zevpn, mac);
        } else {
                UNSET_FLAG(mac->flags, ZEBRA_MAC_ALL_LOCAL_FLAGS);
                UNSET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
@@ -9625,7 +9625,7 @@ int zebra_vxlan_check_readd_remote_mac(struct interface *ifp,
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
        vni_t vni;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
        zebra_mac_t *mac = NULL;
        char buf[ETHER_ADDR_STRLEN];
@@ -9645,12 +9645,12 @@ int zebra_vxlan_check_readd_remote_mac(struct interface *ifp,
                return zebra_vxlan_readd_remote_rmac(zl3vni, macaddr);
 
        /* Locate hash entry; it is expected to exist. */
-       zvni = zvni_lookup(vni);
-       if (!zvni)
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn)
                return 0;
 
        /* If entry doesn't exist, nothing to do. */
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac)
                return 0;
 
@@ -9663,7 +9663,7 @@ int zebra_vxlan_check_readd_remote_mac(struct interface *ifp,
                           prefix_mac2str(macaddr, buf, sizeof(buf)), ifp->name,
                           ifp->ifindex, vni);
 
-       zvni_rem_mac_install(zvni, mac, false /* was_static */);
+       zevpn_rem_mac_install(zevpn, mac, false /* was_static */);
        return 0;
 }
 
@@ -9673,7 +9673,7 @@ int zebra_vxlan_check_readd_remote_mac(struct interface *ifp,
 int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
                              struct ethaddr *macaddr, vlanid_t vid)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_mac_t *mac;
        char buf[ETHER_ADDR_STRLEN];
        bool old_bgp_ready;
@@ -9682,18 +9682,18 @@ int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
        /* We are interested in MACs only on ports or (port, VLAN) that
         * map to a VNI.
         */
-       zvni = zvni_map_vlan(ifp, br_if, vid);
-       if (!zvni)
+       zevpn = zevpn_map_vlan(ifp, br_if, vid);
+       if (!zevpn)
                return 0;
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                zlog_debug(
                        "VNI %u hash %p doesn't have intf upon local MAC DEL",
-                       zvni->vni, zvni);
+                       zevpn->vni, zevpn);
                return -1;
        }
 
        /* If entry doesn't exist, nothing to do. */
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac)
                return 0;
 
@@ -9704,7 +9704,7 @@ int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug("DEL MAC %s intf %s(%u) VID %u -> VNI %u seq %u flags 0x%x nbr count %u",
                           prefix_mac2str(macaddr, buf, sizeof(buf)), ifp->name,
-                          ifp->ifindex, vid, zvni->vni, mac->loc_seq,
+                          ifp->ifindex, vid, zevpn->vni, mac->loc_seq,
                           mac->flags, listcount(mac->neigh_list));
 
        old_bgp_ready = zebra_vxlan_mac_is_ready_for_bgp(mac->flags);
@@ -9716,7 +9716,7 @@ int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
 
                if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug("re-add sync-mac vni %u mac %s es %s seq %d f 0x%x",
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(macaddr,
                                                buf, sizeof(buf)),
                                        mac->es ? mac->es->esi_str : "-",
@@ -9740,10 +9740,10 @@ int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
        }
 
        /* Update all the neigh entries associated with this mac */
-       zvni_process_neigh_on_local_mac_del(zvni, mac);
+       zevpn_process_neigh_on_local_mac_del(zevpn, mac);
 
        /* Remove MAC from BGP. */
-       zvni_mac_send_del_to_client(zvni->vni, macaddr,
+       zevpn_mac_send_del_to_client(zevpn->vni, macaddr,
                        mac->flags, false /* force */);
 
        zebra_evpn_es_mac_deref_entry(mac);
@@ -9753,7 +9753,7 @@ int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
         * else mark it as AUTO for forward reference
         */
        if (!listcount(mac->neigh_list)) {
-               zvni_mac_del(zvni, mac);
+               zevpn_mac_del(zevpn, mac);
        } else {
                UNSET_FLAG(mac->flags, ZEBRA_MAC_ALL_LOCAL_FLAGS);
                UNSET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
@@ -9794,7 +9794,7 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
                                         bool sticky, bool local_inactive,
                                         bool dp_static)
 {
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_mac_t *mac;
        struct zebra_vrf *zvrf;
        char buf[ETHER_ADDR_STRLEN];
@@ -9815,53 +9815,53 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
                return -1;
 
        /* We are interested in MACs only on ports or (port, VLAN) that
-        * map to a VNI.
+        * map to an EVPN.
         */
-       zvni = zvni_map_vlan(ifp, br_if, vid);
-       if (!zvni) {
+       zevpn = zevpn_map_vlan(ifp, br_if, vid);
+       if (!zevpn) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
-                               "        Add/Update %sMAC %s intf %s(%u) VID %u, could not find VNI",
+                               "        Add/Update %sMAC %s intf %s(%u) VID %u, could not find EVPN",
                                sticky ? "sticky " : "",
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
                                ifp->name, ifp->ifindex, vid);
                return 0;
        }
 
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                                "        VNI %u hash %p doesn't have intf upon local MAC ADD",
-                               zvni->vni, zvni);
+                               zevpn->vni, zevpn);
                return -1;
        }
 
-       zvrf = vrf_info_lookup(zvni->vxlan_if->vrf_id);
+       zvrf = vrf_info_lookup(zevpn->vxlan_if->vrf_id);
        if (!zvrf) {
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug("        No Vrf found for vrf_id: %d",
-                                  zvni->vxlan_if->vrf_id);
+                                  zevpn->vxlan_if->vrf_id);
                return -1;
        }
 
        /* Check if we need to create or update or it is a NO-OP. */
-       mac = zvni_mac_lookup(zvni, macaddr);
+       mac = zevpn_mac_lookup(zevpn, macaddr);
        if (!mac) {
                if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug(
                                "ADD %sMAC %s intf %s(%u) VID %u -> VNI %u%s",
                                sticky ? "sticky " : "",
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               ifp->name, ifp->ifindex, vid, zvni->vni,
+                               ifp->name, ifp->ifindex, vid, zevpn->vni,
                                local_inactive ? " local-inactive" : "");
 
-               mac = zvni_mac_add(zvni, macaddr);
+               mac = zevpn_mac_add(zevpn, macaddr);
                if (!mac) {
                        flog_err(
                                EC_ZEBRA_MAC_ADD_FAILED,
                                "Failed to add MAC %s intf %s(%u) VID %u VNI %u",
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               ifp->name, ifp->ifindex, vid, zvni->vni);
+                               ifp->name, ifp->ifindex, vid, zevpn->vni);
                        return -1;
                }
                SET_FLAG(mac->flags, ZEBRA_MAC_LOCAL);
@@ -9876,7 +9876,7 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
                                "UPD %sMAC %s intf %s(%u) VID %u -> VNI %u %scurFlags 0x%x",
                                sticky ? "sticky " : "",
                                prefix_mac2str(macaddr, buf, sizeof(buf)),
-                               ifp->name, ifp->ifindex, vid, zvni->vni,
+                               ifp->name, ifp->ifindex, vid, zevpn->vni,
                                local_inactive ? "local-inactive " : "",
                                mac->flags);
 
@@ -9911,7 +9911,7 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
                                                prefix_mac2str(macaddr, buf,
                                                               sizeof(buf)),
                                                ifp->name, ifp->ifindex, vid,
-                                               zvni->vni,
+                                               zevpn->vni,
                                                local_inactive ?
                                                " local_inactive" : "");
                                return 0;
@@ -9968,7 +9968,7 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
                                        prefix_mac2str(macaddr, buf,
                                                       sizeof(buf)),
                                        inet_ntoa(mac->fwd_info.r_vtep_ip),
-                                       zvni->vni);
+                                       zevpn->vni);
                                return 0;
                        }
 
@@ -10030,7 +10030,7 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
                        (new_bgp_ready != old_bgp_ready)) {
                if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
                        zlog_debug("local mac vni %u mac %s es %s seq %d f 0x%x%s",
-                                       zvni->vni,
+                                       zevpn->vni,
                                        prefix_mac2str(macaddr,
                                                buf, sizeof(buf)),
                                        mac->es ? mac->es->esi_str : "",
@@ -10058,13 +10058,13 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
 
        /* Process all neighbors associated with this MAC, if required. */
        if (upd_neigh)
-               zvni_process_neigh_on_local_mac_change(zvni, mac, 0, es_change);
+               zevpn_process_neigh_on_local_mac_change(zevpn, mac, 0, es_change);
 
        return 0;
 }
 
 /*
- * Handle message from client to delete a remote VTEP for a VNI.
+ * Handle message from client to delete a remote VTEP for an EVPN.
  */
 void zebra_vxlan_remote_vtep_del(ZAPI_HANDLER_ARGS)
 {
@@ -10072,7 +10072,7 @@ void zebra_vxlan_remote_vtep_del(ZAPI_HANDLER_ARGS)
        unsigned short l = 0;
        vni_t vni;
        struct in_addr vtep_ip;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_vtep_t *zvtep;
        struct interface *ifp;
        struct zebra_if *zif;
@@ -10111,8 +10111,8 @@ void zebra_vxlan_remote_vtep_del(ZAPI_HANDLER_ARGS)
                                   zebra_route_string(client->proto));
 
                /* Locate VNI hash entry - expected to exist. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
                        if (IS_ZEBRA_DEBUG_VXLAN)
                                zlog_debug(
                                        "Failed to locate VNI hash upon remote VTEP DEL, VNI %u",
@@ -10120,11 +10120,11 @@ void zebra_vxlan_remote_vtep_del(ZAPI_HANDLER_ARGS)
                        continue;
                }
 
-               ifp = zvni->vxlan_if;
+               ifp = zevpn->vxlan_if;
                if (!ifp) {
                        zlog_debug(
                                "VNI %u hash %p doesn't have intf upon remote VTEP DEL",
-                               zvni->vni, zvni);
+                               zevpn->vni, zevpn);
                        continue;
                }
                zif = ifp->info;
@@ -10139,12 +10139,12 @@ void zebra_vxlan_remote_vtep_del(ZAPI_HANDLER_ARGS)
                 * and
                 * then, the VTEP entry itself and remove it.
                 */
-               zvtep = zvni_vtep_find(zvni, &vtep_ip);
+               zvtep = zevpn_vtep_find(zevpn, &vtep_ip);
                if (!zvtep)
                        continue;
 
-               zvni_vtep_uninstall(zvni, &vtep_ip);
-               zvni_vtep_del(zvni, zvtep);
+               zevpn_vtep_uninstall(zevpn, &vtep_ip);
+               zevpn_vtep_del(zevpn, zvtep);
        }
 
 stream_failure:
@@ -10152,7 +10152,7 @@ stream_failure:
 }
 
 /*
- * Handle message from client to add a remote VTEP for a VNI.
+ * Handle message from client to add a remote VTEP for an EVPN.
  */
 void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
 {
@@ -10160,7 +10160,7 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
        unsigned short l = 0;
        vni_t vni;
        struct in_addr vtep_ip;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        struct interface *ifp;
        struct zebra_if *zif;
        int flood_control;
@@ -10195,21 +10195,21 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
                                        zebra_route_string(client->proto));
 
                /* Locate VNI hash entry - expected to exist. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
                        flog_err(
                                EC_ZEBRA_VTEP_ADD_FAILED,
-                               "Failed to locate VNI hash upon remote VTEP ADD, VNI %u",
+                               "Failed to locate EVPN hash upon remote VTEP ADD, VNI %u",
                                vni);
                        continue;
                }
 
-               ifp = zvni->vxlan_if;
+               ifp = zevpn->vxlan_if;
                if (!ifp) {
                        flog_err(
                                EC_ZEBRA_VTEP_ADD_FAILED,
                                "VNI %u hash %p doesn't have intf upon remote VTEP ADD",
-                               zvni->vni, zvni);
+                               zevpn->vni, zevpn);
                        continue;
                }
 
@@ -10219,7 +10219,7 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
                if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
                        continue;
 
-               zvtep = zvni_vtep_find(zvni, &vtep_ip);
+               zvtep = zevpn_vtep_find(zevpn, &vtep_ip);
                if (zvtep) {
                        /* If the remote VTEP already exists check if
                         * the flood mode has changed
@@ -10231,18 +10231,18 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
                                         * is no longer; get rid of the HER fdb
                                         * entry installed before
                                         */
-                                       zvni_vtep_uninstall(zvni, &vtep_ip);
+                                       zevpn_vtep_uninstall(zevpn, &vtep_ip);
                                zvtep->flood_control = flood_control;
-                               zvni_vtep_install(zvni, zvtep);
+                               zevpn_vtep_install(zevpn, zvtep);
                        }
                } else {
-                       zvtep = zvni_vtep_add(zvni, &vtep_ip, flood_control);
+                       zvtep = zevpn_vtep_add(zevpn, &vtep_ip, flood_control);
                        if (zvtep)
-                               zvni_vtep_install(zvni, zvtep);
+                               zevpn_vtep_install(zevpn, zvtep);
                        else
                                flog_err(EC_ZEBRA_VTEP_ADD_FAILED,
-                                       "Failed to add remote VTEP, VNI %u zvni %p",
-                                       vni, zvni);
+                                       "Failed to add remote VTEP, VNI %u zevpn %p",
+                                       vni, zevpn);
                }
        }
 
@@ -10263,7 +10263,7 @@ int zebra_vxlan_add_del_gw_macip(struct interface *ifp, struct prefix *p,
 {
        struct ipaddr ip;
        struct ethaddr macaddr;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
 
        memset(&ip, 0, sizeof(struct ipaddr));
        memset(&macaddr, 0, sizeof(struct ethaddr));
@@ -10307,14 +10307,14 @@ int zebra_vxlan_add_del_gw_macip(struct interface *ifp, struct prefix *p,
                                svi_if_link = if_lookup_by_index_per_ns(
                                        zebra_ns_lookup(NS_DEFAULT),
                                        svi_if_zif->link_ifindex);
-                               zvni = zvni_from_svi(svi_if, svi_if_link);
+                               zevpn = zevpn_from_svi(svi_if, svi_if_link);
                        }
                } else if (IS_ZEBRA_IF_BRIDGE(svi_if)) {
                        /*
                         * If it is a vlan unaware bridge then svi is the bridge
                         * itself
                         */
-                       zvni = zvni_from_svi(svi_if, svi_if);
+                       zevpn = zevpn_from_svi(svi_if, svi_if);
                }
        } else if (IS_ZEBRA_IF_VLAN(ifp)) {
                struct zebra_if *svi_if_zif =
@@ -10328,18 +10328,18 @@ int zebra_vxlan_add_del_gw_macip(struct interface *ifp, struct prefix *p,
                                zebra_ns_lookup(NS_DEFAULT),
                                svi_if_zif->link_ifindex);
                        if (svi_if_link)
-                               zvni = zvni_from_svi(ifp, svi_if_link);
+                               zevpn = zevpn_from_svi(ifp, svi_if_link);
                }
        } else if (IS_ZEBRA_IF_BRIDGE(ifp)) {
-               zvni = zvni_from_svi(ifp, ifp);
+               zevpn = zevpn_from_svi(ifp, ifp);
        }
 
-       if (!zvni)
+       if (!zevpn)
                return 0;
 
-       if (!zvni->vxlan_if) {
+       if (!zevpn->vxlan_if) {
                zlog_debug("VNI %u hash %p doesn't have intf upon MACVLAN up",
-                          zvni->vni, zvni);
+                          zevpn->vni, zevpn);
                return -1;
        }
 
@@ -10358,9 +10358,9 @@ int zebra_vxlan_add_del_gw_macip(struct interface *ifp, struct prefix *p,
 
 
        if (add)
-               zvni_gw_macip_add(ifp, zvni, &macaddr, &ip);
+               zevpn_gw_macip_add(ifp, zevpn, &macaddr, &ip);
        else
-               zvni_gw_macip_del(ifp, zvni, &ip);
+               zevpn_gw_macip_del(ifp, zevpn, &ip);
 
        return 0;
 }
@@ -10370,7 +10370,7 @@ int zebra_vxlan_add_del_gw_macip(struct interface *ifp, struct prefix *p,
  * SVI can be associated to either L3-VNI or L2-VNI.
  * For L2-VNI: At this point, this is a NOP since
  *     the kernel deletes the neighbor entries on this SVI (if any).
- *      We only need to update the vrf corresponding to zvni.
+ *      We only need to update the vrf corresponding to zevpn.
  * For L3-VNI: L3-VNI is operationally down, update mac-ip routes and delete
  *     from bgp
  */
@@ -10387,17 +10387,17 @@ int zebra_vxlan_svi_down(struct interface *ifp, struct interface *link_if)
                /* remove association with svi-if */
                zl3vni->svi_if = NULL;
        } else {
-               zebra_vni_t *zvni = NULL;
+               zebra_evpn_t *zevpn = NULL;
 
-               /* since we dont have svi corresponding to zvni, we associate it
+               /* since we dont have svi corresponding to zevpn, we associate it
                 * to default vrf. Note: the corresponding neigh entries on the
                 * SVI would have already been deleted */
-               zvni = zvni_from_svi(ifp, link_if);
-               if (zvni) {
-                       zvni->vrf_id = VRF_DEFAULT;
+               zevpn = zevpn_from_svi(ifp, link_if);
+               if (zevpn) {
+                       zevpn->vrf_id = VRF_DEFAULT;
 
                        /* update the tenant vrf in BGP */
-                       zvni_send_add_to_client(zvni);
+                       zevpn_send_add_to_client(zevpn);
                }
        }
        return 0;
@@ -10413,7 +10413,7 @@ int zebra_vxlan_svi_down(struct interface *ifp, struct interface *link_if)
  */
 int zebra_vxlan_svi_up(struct interface *ifp, struct interface *link_if)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        zl3vni = zl3vni_from_svi(ifp, link_if);
@@ -10430,31 +10430,31 @@ int zebra_vxlan_svi_up(struct interface *ifp, struct interface *link_if)
                /* process SVI up for l2-vni */
                struct neigh_walk_ctx n_wctx;
 
-               zvni = zvni_from_svi(ifp, link_if);
-               if (!zvni)
+               zevpn = zevpn_from_svi(ifp, link_if);
+               if (!zevpn)
                        return 0;
 
-               if (!zvni->vxlan_if) {
+               if (!zevpn->vxlan_if) {
                        zlog_debug(
                                "VNI %u hash %p doesn't have intf upon SVI up",
-                               zvni->vni, zvni);
+                               zevpn->vni, zevpn);
                        return -1;
                }
 
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                                "SVI %s(%u) VNI %u VRF %s is UP, installing neighbors",
-                               ifp->name, ifp->ifindex, zvni->vni,
+                               ifp->name, ifp->ifindex, zevpn->vni,
                                vrf_id_to_name(ifp->vrf_id));
 
                /* update the vrf information for l2-vni and inform bgp */
-               zvni->vrf_id = ifp->vrf_id;
-               zvni_send_add_to_client(zvni);
+               zevpn->vrf_id = ifp->vrf_id;
+               zevpn_send_add_to_client(zevpn);
 
                /* Install any remote neighbors for this VNI. */
                memset(&n_wctx, 0, sizeof(struct neigh_walk_ctx));
-               n_wctx.zvni = zvni;
-               hash_iterate(zvni->neigh_table, zvni_install_neigh_hash,
+               n_wctx.zevpn = zevpn;
+               hash_iterate(zevpn->neigh_table, zevpn_install_neigh_hash,
                             &n_wctx);
        }
 
@@ -10541,7 +10541,7 @@ int zebra_vxlan_if_down(struct interface *ifp)
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
        zebra_l3vni_t *zl3vni = NULL;
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
 
        /* Check if EVPN is enabled. */
        if (!is_evpn_enabled())
@@ -10567,25 +10567,25 @@ int zebra_vxlan_if_down(struct interface *ifp)
                                   ifp->ifindex, vni);
 
                /* Locate hash entry; it is expected to exist. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
                        zlog_debug(
                                "Failed to locate VNI hash at DOWN, IF %s(%u) VNI %u",
                                ifp->name, ifp->ifindex, vni);
                        return -1;
                }
 
-               assert(zvni->vxlan_if == ifp);
+               assert(zevpn->vxlan_if == ifp);
 
                /* Delete this VNI from BGP. */
-               zvni_send_del_to_client(zvni);
+               zevpn_send_del_to_client(zevpn);
 
                /* Free up all neighbors and MACs, if any. */
-               zvni_neigh_del_all(zvni, 1, 0, DEL_ALL_NEIGH);
-               zvni_mac_del_all(zvni, 1, 0, DEL_ALL_MAC);
+               zevpn_neigh_del_all(zevpn, 1, 0, DEL_ALL_NEIGH);
+               zevpn_mac_del_all(zevpn, 1, 0, DEL_ALL_MAC);
 
                /* Free up all remote VTEPs, if any. */
-               zvni_vtep_del_all(zvni, 1);
+               zevpn_vtep_del_all(zevpn, 1);
        }
        return 0;
 }
@@ -10598,7 +10598,7 @@ int zebra_vxlan_if_up(struct interface *ifp)
        vni_t vni;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        /* Check if EVPN is enabled. */
@@ -10636,29 +10636,29 @@ int zebra_vxlan_if_up(struct interface *ifp)
                                   ifp->ifindex, vni);
 
                /* Locate hash entry; it is expected to exist. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
                        zlog_debug(
-                               "Failed to locate VNI hash at UP, IF %s(%u) VNI %u",
+                               "Failed to locate EVPN hash at UP, IF %s(%u) VNI %u",
                                ifp->name, ifp->ifindex, vni);
                        return -1;
                }
 
-               assert(zvni->vxlan_if == ifp);
-               vlan_if = zvni_map_to_svi(vxl->access_vlan,
+               assert(zevpn->vxlan_if == ifp);
+               vlan_if = zevpn_map_to_svi(vxl->access_vlan,
                                          zif->brslave_info.br_if);
                if (vlan_if) {
-                       zvni->vrf_id = vlan_if->vrf_id;
+                       zevpn->vrf_id = vlan_if->vrf_id;
                        zl3vni = zl3vni_from_vrf(vlan_if->vrf_id);
                        if (zl3vni)
-                               listnode_add_sort(zl3vni->l2vnis, zvni);
+                               listnode_add_sort(zl3vni->l2vnis, zevpn);
                }
 
                /* If part of a bridge, inform BGP about this VNI. */
                /* Also, read and populate local MACs and neighbors. */
                if (zif->brslave_info.br_if) {
-                       zvni_send_add_to_client(zvni);
-                       zvni_read_mac_neigh(zvni, ifp);
+                       zevpn_send_add_to_client(zevpn);
+                       zevpn_read_mac_neigh(zevpn, ifp);
                }
        }
 
@@ -10674,7 +10674,7 @@ int zebra_vxlan_if_del(struct interface *ifp)
        vni_t vni;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        /* Check if EVPN is enabled. */
@@ -10707,8 +10707,8 @@ int zebra_vxlan_if_del(struct interface *ifp)
                                   ifp->ifindex);
 
                /* Locate hash entry; it is expected to exist. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
                        zlog_debug(
                                "Failed to locate VNI hash at del, IF %s(%u) VNI %u",
                                ifp->name, ifp->ifindex, vni);
@@ -10716,24 +10716,24 @@ int zebra_vxlan_if_del(struct interface *ifp)
                }
 
                /* remove from l3-vni list */
-               zl3vni = zl3vni_from_vrf(zvni->vrf_id);
+               zl3vni = zl3vni_from_vrf(zevpn->vrf_id);
                if (zl3vni)
-                       listnode_delete(zl3vni->l2vnis, zvni);
+                       listnode_delete(zl3vni->l2vnis, zevpn);
                /* Delete VNI from BGP. */
-               zvni_send_del_to_client(zvni);
+               zevpn_send_del_to_client(zevpn);
 
                /* Free up all neighbors and MAC, if any. */
-               zvni_neigh_del_all(zvni, 0, 0, DEL_ALL_NEIGH);
-               zvni_mac_del_all(zvni, 0, 0, DEL_ALL_MAC);
+               zevpn_neigh_del_all(zevpn, 0, 0, DEL_ALL_NEIGH);
+               zevpn_mac_del_all(zevpn, 0, 0, DEL_ALL_MAC);
 
                /* Free up all remote VTEPs, if any. */
-               zvni_vtep_del_all(zvni, 0);
+               zevpn_vtep_del_all(zevpn, 0);
 
                /* Delete the hash entry. */
-               if (zvni_del(zvni)) {
+               if (zevpn_del(zevpn)) {
                        flog_err(EC_ZEBRA_VNI_DEL_FAILED,
-                                "Failed to del VNI hash %p, IF %s(%u) VNI %u",
-                                zvni, ifp->name, ifp->ifindex, zvni->vni);
+                                "Failed to del EVPN hash %p, IF %s(%u) VNI %u",
+                                zevpn, ifp->name, ifp->ifindex, zevpn->vni);
                        return -1;
                }
        }
@@ -10748,7 +10748,7 @@ int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
        vni_t vni;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        /* Check if EVPN is enabled. */
@@ -10819,10 +10819,10 @@ int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
        } else {
 
                /* Update VNI hash. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
                        zlog_debug(
-                               "Failed to find L2-VNI hash on update, IF %s(%u) VNI %u",
+                               "Failed to find EVPN hash on update, IF %s(%u) VNI %u",
                                ifp->name, ifp->ifindex, vni);
                        return -1;
                }
@@ -10839,10 +10839,10 @@ int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
                    && (zif->brslave_info.bridge_ifindex == IFINDEX_INTERNAL)) {
                        /* Delete from client, remove all remote VTEPs */
                        /* Also, free up all MACs and neighbors. */
-                       zvni_send_del_to_client(zvni);
-                       zvni_neigh_del_all(zvni, 1, 0, DEL_ALL_NEIGH);
-                       zvni_mac_del_all(zvni, 1, 0, DEL_ALL_MAC);
-                       zvni_vtep_del_all(zvni, 1);
+                       zevpn_send_del_to_client(zevpn);
+                       zevpn_neigh_del_all(zevpn, 1, 0, DEL_ALL_NEIGH);
+                       zevpn_mac_del_all(zevpn, 1, 0, DEL_ALL_MAC);
+                       zevpn_vtep_del_all(zevpn, 1);
                        return 0;
                }
 
@@ -10851,23 +10851,23 @@ int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
                        /* Remove all existing local neigh and MACs for this VNI
                         * (including from BGP)
                         */
-                       zvni_neigh_del_all(zvni, 0, 1, DEL_LOCAL_MAC);
-                       zvni_mac_del_all(zvni, 0, 1, DEL_LOCAL_MAC);
+                       zevpn_neigh_del_all(zevpn, 0, 1, DEL_LOCAL_MAC);
+                       zevpn_mac_del_all(zevpn, 0, 1, DEL_LOCAL_MAC);
                }
 
-               if (zvni->local_vtep_ip.s_addr != vxl->vtep_ip.s_addr ||
-                       zvni->mcast_grp.s_addr != vxl->mcast_grp.s_addr) {
-                       zebra_vxlan_sg_deref(zvni->local_vtep_ip,
-                               zvni->mcast_grp);
+               if (zevpn->local_vtep_ip.s_addr != vxl->vtep_ip.s_addr ||
+                       zevpn->mcast_grp.s_addr != vxl->mcast_grp.s_addr) {
+                       zebra_vxlan_sg_deref(zevpn->local_vtep_ip,
+                               zevpn->mcast_grp);
                        zebra_vxlan_sg_ref(vxl->vtep_ip, vxl->mcast_grp);
-                       zvni->local_vtep_ip = vxl->vtep_ip;
-                       zvni->mcast_grp = vxl->mcast_grp;
+                       zevpn->local_vtep_ip = vxl->vtep_ip;
+                       zevpn->mcast_grp = vxl->mcast_grp;
                        /* on local vtep-ip check if ES orig-ip
                         * needs to be updated
                         */
-                       zebra_evpn_es_set_base_vni(zvni);
+                       zebra_evpn_es_set_base_evpn(zevpn);
                }
-               zvni_vxlan_if_set(zvni, ifp, true /* set */);
+               zevpn_vxlan_if_set(zevpn, ifp, true /* set */);
                /* Take further actions needed.
                 * Note that if we are here, there is a change of interest.
                 */
@@ -10880,7 +10880,7 @@ int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
                        & (ZEBRA_VXLIF_MASTER_CHANGE |
                           ZEBRA_VXLIF_LOCAL_IP_CHANGE |
                           ZEBRA_VXLIF_MCAST_GRP_CHANGE))
-                       zvni_send_add_to_client(zvni);
+                       zevpn_send_add_to_client(zevpn);
 
                /* If there is a valid new master or a VLAN mapping change,
                 * read and populate local MACs and neighbors.
@@ -10888,21 +10888,21 @@ int zebra_vxlan_if_update(struct interface *ifp, uint16_t chgflags)
                 * for this VNI (based on new VLAN).
                 */
                if (chgflags & ZEBRA_VXLIF_MASTER_CHANGE)
-                       zvni_read_mac_neigh(zvni, ifp);
+                       zevpn_read_mac_neigh(zevpn, ifp);
                else if (chgflags & ZEBRA_VXLIF_VLAN_CHANGE) {
                        struct mac_walk_ctx m_wctx;
                        struct neigh_walk_ctx n_wctx;
 
-                       zvni_read_mac_neigh(zvni, ifp);
+                       zevpn_read_mac_neigh(zevpn, ifp);
 
                        memset(&m_wctx, 0, sizeof(struct mac_walk_ctx));
-                       m_wctx.zvni = zvni;
-                       hash_iterate(zvni->mac_table, zvni_install_mac_hash,
+                       m_wctx.zevpn = zevpn;
+                       hash_iterate(zevpn->mac_table, zevpn_install_mac_hash,
                                     &m_wctx);
 
                        memset(&n_wctx, 0, sizeof(struct neigh_walk_ctx));
-                       n_wctx.zvni = zvni;
-                       hash_iterate(zvni->neigh_table, zvni_install_neigh_hash,
+                       n_wctx.zevpn = zevpn;
+                       hash_iterate(zevpn->neigh_table, zevpn_install_neigh_hash,
                                     &n_wctx);
                }
        }
@@ -10918,7 +10918,7 @@ int zebra_vxlan_if_add(struct interface *ifp)
        vni_t vni;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan *vxl = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        zebra_l3vni_t *zl3vni = NULL;
 
        /* Check if EVPN is enabled. */
@@ -10958,39 +10958,39 @@ int zebra_vxlan_if_add(struct interface *ifp)
                /* process if-add for l2-vni */
                struct interface *vlan_if = NULL;
 
-               /* Create or update VNI hash. */
-               zvni = zvni_lookup(vni);
-               if (!zvni) {
-                       zvni = zvni_add(vni);
-                       if (!zvni) {
+               /* Create or update EVPN hash. */
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn) {
+                       zevpn = zevpn_add(vni);
+                       if (!zevpn) {
                                flog_err(
                                        EC_ZEBRA_VNI_ADD_FAILED,
-                                       "Failed to add VNI hash, IF %s(%u) VNI %u",
+                                       "Failed to add EVPN hash, IF %s(%u) VNI %u",
                                        ifp->name, ifp->ifindex, vni);
                                return -1;
                        }
                }
 
-               if (zvni->local_vtep_ip.s_addr != vxl->vtep_ip.s_addr ||
-                       zvni->mcast_grp.s_addr != vxl->mcast_grp.s_addr) {
-                       zebra_vxlan_sg_deref(zvni->local_vtep_ip,
-                               zvni->mcast_grp);
+               if (zevpn->local_vtep_ip.s_addr != vxl->vtep_ip.s_addr ||
+                       zevpn->mcast_grp.s_addr != vxl->mcast_grp.s_addr) {
+                       zebra_vxlan_sg_deref(zevpn->local_vtep_ip,
+                               zevpn->mcast_grp);
                        zebra_vxlan_sg_ref(vxl->vtep_ip, vxl->mcast_grp);
-                       zvni->local_vtep_ip = vxl->vtep_ip;
-                       zvni->mcast_grp = vxl->mcast_grp;
+                       zevpn->local_vtep_ip = vxl->vtep_ip;
+                       zevpn->mcast_grp = vxl->mcast_grp;
                        /* on local vtep-ip check if ES orig-ip
                         * needs to be updated
                         */
-                       zebra_evpn_es_set_base_vni(zvni);
+                       zebra_evpn_es_set_base_evpn(zevpn);
                }
-               zvni_vxlan_if_set(zvni, ifp, true /* set */);
-               vlan_if = zvni_map_to_svi(vxl->access_vlan,
+               zevpn_vxlan_if_set(zevpn, ifp, true /* set */);
+               vlan_if = zevpn_map_to_svi(vxl->access_vlan,
                                          zif->brslave_info.br_if);
                if (vlan_if) {
-                       zvni->vrf_id = vlan_if->vrf_id;
+                       zevpn->vrf_id = vlan_if->vrf_id;
                        zl3vni = zl3vni_from_vrf(vlan_if->vrf_id);
                        if (zl3vni)
-                               listnode_add_sort(zl3vni->l2vnis, zvni);
+                               listnode_add_sort(zl3vni->l2vnis, zevpn);
                }
 
                if (IS_ZEBRA_DEBUG_VXLAN) {
@@ -11017,10 +11017,10 @@ int zebra_vxlan_if_add(struct interface *ifp)
                        return 0;
 
                /* Inform BGP */
-               zvni_send_add_to_client(zvni);
+               zevpn_send_add_to_client(zevpn);
 
                /* Read and populate local MACs and neighbors */
-               zvni_read_mac_neigh(zvni, ifp);
+               zevpn_read_mac_neigh(zevpn, ifp);
        }
 
        return 0;
@@ -11098,7 +11098,7 @@ int zebra_vxlan_process_vrf_vni_cmd(struct zebra_vrf *zvrf, vni_t vni,
                                                    : "NIL");
 
                /* formulate l2vni list */
-               hash_iterate(zvrf_evpn->vni_table, zvni_add_to_l3vni_list,
+               hash_iterate(zvrf_evpn->evpn_table, zevpn_add_to_l3vni_list,
                             zl3vni);
 
                if (is_l3vni_oper_up(zl3vni))
@@ -11228,7 +11228,7 @@ void zebra_vxlan_flood_control(ZAPI_HANDLER_ARGS)
        /* Install or uninstall flood entries corresponding to
         * remote VTEPs.
         */
-       hash_iterate(zvrf->vni_table, zvni_handle_flooding_remote_vteps,
+       hash_iterate(zvrf->evpn_table, zevpn_handle_flooding_remote_vteps,
                     zvrf);
 
 stream_failure:
@@ -11244,7 +11244,7 @@ void zebra_vxlan_advertise_svi_macip(ZAPI_HANDLER_ARGS)
        struct stream *s;
        int advertise;
        vni_t vni = 0;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct interface *ifp = NULL;
 
        if (!EVPN_ENABLED(zvrf)) {
@@ -11271,11 +11271,11 @@ void zebra_vxlan_advertise_svi_macip(ZAPI_HANDLER_ARGS)
 
                if (advertise) {
                        zvrf->advertise_svi_macip = advertise;
-                       hash_iterate(zvrf->vni_table,
-                                    zvni_gw_macip_add_for_vni_hash, NULL);
+                       hash_iterate(zvrf->evpn_table,
+                                    zevpn_gw_macip_add_for_evpn_hash, NULL);
                } else {
-                       hash_iterate(zvrf->vni_table,
-                                    zvni_svi_macip_del_for_vni_hash, NULL);
+                       hash_iterate(zvrf->evpn_table,
+                                    zevpn_svi_macip_del_for_evpn_hash, NULL);
                        zvrf->advertise_svi_macip = advertise;
                }
 
@@ -11284,27 +11284,27 @@ void zebra_vxlan_advertise_svi_macip(ZAPI_HANDLER_ARGS)
                struct zebra_l2info_vxlan zl2_info;
                struct interface *vlan_if = NULL;
 
-               zvni = zvni_lookup(vni);
-               if (!zvni)
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn)
                        return;
 
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                                "EVPN SVI macip Adv %s on VNI %d , currently %s",
                                advertise ? "enabled" : "disabled", vni,
-                               advertise_svi_macip_enabled(zvni)
+                               advertise_svi_macip_enabled(zevpn)
                                        ? "enabled"
                                        : "disabled");
 
-               if (zvni->advertise_svi_macip == advertise)
+               if (zevpn->advertise_svi_macip == advertise)
                        return;
 
                /* Store flag even though SVI is not present.
                 * Once SVI comes up triggers self MAC-IP route add.
                 */
-               zvni->advertise_svi_macip = advertise;
+               zevpn->advertise_svi_macip = advertise;
 
-               ifp = zvni->vxlan_if;
+               ifp = zevpn->vxlan_if;
                if (!ifp)
                        return;
 
@@ -11315,17 +11315,17 @@ void zebra_vxlan_advertise_svi_macip(ZAPI_HANDLER_ARGS)
                        return;
 
                zl2_info = zif->l2info.vxl;
-               vlan_if = zvni_map_to_svi(zl2_info.access_vlan,
+               vlan_if = zevpn_map_to_svi(zl2_info.access_vlan,
                                          zif->brslave_info.br_if);
                if (!vlan_if)
                        return;
 
                if (advertise) {
                        /* Add primary SVI MAC-IP */
-                       zvni_add_macip_for_intf(vlan_if, zvni);
+                       zevpn_add_macip_for_intf(vlan_if, zevpn);
                } else {
                        /* Del primary SVI MAC-IP */
-                       zvni_del_macip_for_intf(vlan_if, zvni);
+                       zevpn_del_macip_for_intf(vlan_if, zevpn);
                }
        }
 
@@ -11342,7 +11342,7 @@ void zebra_vxlan_advertise_subnet(ZAPI_HANDLER_ARGS)
        struct stream *s;
        int advertise;
        vni_t vni = 0;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct interface *ifp = NULL;
        struct zebra_if *zif = NULL;
        struct zebra_l2info_vxlan zl2_info;
@@ -11358,22 +11358,22 @@ void zebra_vxlan_advertise_subnet(ZAPI_HANDLER_ARGS)
        STREAM_GETC(s, advertise);
        STREAM_GET(&vni, s, 3);
 
-       zvni = zvni_lookup(vni);
-       if (!zvni)
+       zevpn = zevpn_lookup(vni);
+       if (!zevpn)
                return;
 
-       if (zvni->advertise_subnet == advertise)
+       if (zevpn->advertise_subnet == advertise)
                return;
 
        if (IS_ZEBRA_DEBUG_VXLAN)
                zlog_debug("EVPN subnet Adv %s on VNI %d , currently %s",
                           advertise ? "enabled" : "disabled", vni,
-                          zvni->advertise_subnet ? "enabled" : "disabled");
+                          zevpn->advertise_subnet ? "enabled" : "disabled");
 
 
-       zvni->advertise_subnet = advertise;
+       zevpn->advertise_subnet = advertise;
 
-       ifp = zvni->vxlan_if;
+       ifp = zevpn->vxlan_if;
        if (!ifp)
                return;
 
@@ -11386,14 +11386,14 @@ void zebra_vxlan_advertise_subnet(ZAPI_HANDLER_ARGS)
        zl2_info = zif->l2info.vxl;
 
        vlan_if =
-               zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
+               zevpn_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
        if (!vlan_if)
                return;
 
-       if (zvni->advertise_subnet)
-               zvni_advertise_subnet(zvni, vlan_if, 1);
+       if (zevpn->advertise_subnet)
+               zevpn_advertise_subnet(zevpn, vlan_if, 1);
        else
-               zvni_advertise_subnet(zvni, vlan_if, 0);
+               zevpn_advertise_subnet(zevpn, vlan_if, 0);
 
 stream_failure:
        return;
@@ -11408,7 +11408,7 @@ void zebra_vxlan_advertise_gw_macip(ZAPI_HANDLER_ARGS)
        struct stream *s;
        int advertise;
        vni_t vni = 0;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct interface *ifp = NULL;
 
        if (!EVPN_ENABLED(zvrf)) {
@@ -11434,12 +11434,12 @@ void zebra_vxlan_advertise_gw_macip(ZAPI_HANDLER_ARGS)
 
                zvrf->advertise_gw_macip = advertise;
 
-               if (advertise_gw_macip_enabled(zvni))
-                       hash_iterate(zvrf->vni_table,
-                                    zvni_gw_macip_add_for_vni_hash, NULL);
+               if (advertise_gw_macip_enabled(zevpn))
+                       hash_iterate(zvrf->evpn_table,
+                                    zevpn_gw_macip_add_for_evpn_hash, NULL);
                else
-                       hash_iterate(zvrf->vni_table,
-                                    zvni_gw_macip_del_for_vni_hash, NULL);
+                       hash_iterate(zvrf->evpn_table,
+                                    zevpn_gw_macip_del_for_evpn_hash, NULL);
 
        } else {
                struct zebra_if *zif = NULL;
@@ -11447,23 +11447,23 @@ void zebra_vxlan_advertise_gw_macip(ZAPI_HANDLER_ARGS)
                struct interface *vlan_if = NULL;
                struct interface *vrr_if = NULL;
 
-               zvni = zvni_lookup(vni);
-               if (!zvni)
+               zevpn = zevpn_lookup(vni);
+               if (!zevpn)
                        return;
 
                if (IS_ZEBRA_DEBUG_VXLAN)
                        zlog_debug(
                                "EVPN gateway macip Adv %s on VNI %d , currently %s",
                                advertise ? "enabled" : "disabled", vni,
-                               advertise_gw_macip_enabled(zvni) ? "enabled"
+                               advertise_gw_macip_enabled(zevpn) ? "enabled"
                                                                 : "disabled");
 
-               if (zvni->advertise_gw_macip == advertise)
+               if (zevpn->advertise_gw_macip == advertise)
                        return;
 
-               zvni->advertise_gw_macip = advertise;
+               zevpn->advertise_gw_macip = advertise;
 
-               ifp = zvni->vxlan_if;
+               ifp = zevpn->vxlan_if;
                if (!ifp)
                        return;
 
@@ -11475,27 +11475,27 @@ void zebra_vxlan_advertise_gw_macip(ZAPI_HANDLER_ARGS)
 
                zl2_info = zif->l2info.vxl;
 
-               vlan_if = zvni_map_to_svi(zl2_info.access_vlan,
+               vlan_if = zevpn_map_to_svi(zl2_info.access_vlan,
                                          zif->brslave_info.br_if);
                if (!vlan_if)
                        return;
 
-               if (advertise_gw_macip_enabled(zvni)) {
+               if (advertise_gw_macip_enabled(zevpn)) {
                        /* Add primary SVI MAC-IP */
-                       zvni_add_macip_for_intf(vlan_if, zvni);
+                       zevpn_add_macip_for_intf(vlan_if, zevpn);
 
                        /* Add VRR MAC-IP - if any*/
                        vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
                        if (vrr_if)
-                               zvni_add_macip_for_intf(vrr_if, zvni);
+                               zevpn_add_macip_for_intf(vrr_if, zevpn);
                } else {
                        /* Del primary MAC-IP */
-                       zvni_del_macip_for_intf(vlan_if, zvni);
+                       zevpn_del_macip_for_intf(vlan_if, zevpn);
 
                        /* Del VRR MAC-IP - if any*/
                        vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
                        if (vrr_if)
-                               zvni_del_macip_for_intf(vrr_if, zvni);
+                               zevpn_del_macip_for_intf(vrr_if, zevpn);
                }
        }
 
@@ -11547,11 +11547,11 @@ void zebra_vxlan_advertise_all_vni(ZAPI_HANDLER_ARGS)
                /* Replay all ESs */
                zebra_evpn_es_send_all_to_client(true /* add */);
 
-               /* Build VNI hash table and inform BGP. */
-               zvni_build_hash_table();
+               /* Build EVPN hash table and inform BGP. */
+               zevpn_build_hash_table();
 
                /* Add all SVI (L3 GW) MACs to BGP*/
-               hash_iterate(zvrf->vni_table, zvni_gw_macip_add_for_vni_hash,
+               hash_iterate(zvrf->evpn_table, zevpn_gw_macip_add_for_evpn_hash,
                             NULL);
 
                /* Read the MAC FDB */
@@ -11560,10 +11560,10 @@ void zebra_vxlan_advertise_all_vni(ZAPI_HANDLER_ARGS)
                /* Read neighbors */
                neigh_read(zvrf->zns);
        } else {
-               /* Cleanup VTEPs for all VNIs - uninstall from
+               /* Cleanup VTEPs for all EVPNs - uninstall from
                 * kernel and free entries.
                 */
-               hash_iterate(zvrf->vni_table, zvni_cleanup_all, zvrf);
+               hash_iterate(zvrf->evpn_table, zevpn_cleanup_all, zvrf);
 
                /* Delete all ESs in BGP */
                zebra_evpn_es_send_all_to_client(false /* add */);
@@ -11580,40 +11580,40 @@ stream_failure:
 }
 
 /*
- * Allocate VNI hash table for this VRF and do other initialization.
+ * Allocate EVPN hash table for this VRF and do other initialization.
  * NOTE: Currently supported only for default VRF.
  */
 void zebra_vxlan_init_tables(struct zebra_vrf *zvrf)
 {
        if (!zvrf)
                return;
-       zvrf->vni_table = hash_create(vni_hash_keymake, vni_hash_cmp,
-                                     "Zebra VRF VNI Table");
+       zvrf->evpn_table = hash_create(evpn_hash_keymake, vni_hash_cmp,
+                                     "Zebra VRF EVPN Table");
        zvrf->vxlan_sg_table = hash_create(zebra_vxlan_sg_hash_key_make,
                        zebra_vxlan_sg_hash_eq, "Zebra VxLAN SG Table");
 }
 
-/* Cleanup VNI info, but don't free the table. */
+/* Cleanup EVPN info, but don't free the table. */
 void zebra_vxlan_cleanup_tables(struct zebra_vrf *zvrf)
 {
        struct zebra_vrf *evpn_zvrf = zebra_vrf_get_evpn();
 
        if (!zvrf)
                return;
-       hash_iterate(zvrf->vni_table, zvni_cleanup_all, zvrf);
+       hash_iterate(zvrf->evpn_table, zevpn_cleanup_all, zvrf);
        hash_iterate(zvrf->vxlan_sg_table, zebra_vxlan_sg_cleanup, NULL);
 
        if (zvrf == evpn_zvrf)
                zebra_evpn_es_cleanup();
 }
 
-/* Close all VNI handling */
+/* Close all EVPN handling */
 void zebra_vxlan_close_tables(struct zebra_vrf *zvrf)
 {
        if (!zvrf)
                return;
-       hash_iterate(zvrf->vni_table, zvni_cleanup_all, zvrf);
-       hash_free(zvrf->vni_table);
+       hash_iterate(zvrf->evpn_table, zevpn_cleanup_all, zvrf);
+       hash_free(zvrf->evpn_table);
 }
 
 /* init the l3vni table */
@@ -11648,22 +11648,22 @@ static int zebra_vxlan_dad_ip_auto_recovery_exp(struct thread *t)
 {
        struct zebra_vrf *zvrf = NULL;
        zebra_neigh_t *nbr = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        char buf1[INET6_ADDRSTRLEN];
        char buf2[ETHER_ADDR_STRLEN];
 
        nbr = THREAD_ARG(t);
 
        /* since this is asynchronous we need sanity checks*/
-       zvrf = vrf_info_lookup(nbr->zvni->vrf_id);
+       zvrf = vrf_info_lookup(nbr->zevpn->vrf_id);
        if (!zvrf)
                return 0;
 
-       zvni = zvni_lookup(nbr->zvni->vni);
-       if (!zvni)
+       zevpn = zevpn_lookup(nbr->zevpn->vni);
+       if (!zevpn)
                return 0;
 
-       nbr = zvni_neigh_lookup(zvni, &nbr->ip);
+       nbr = zevpn_neigh_lookup(zevpn, &nbr->ip);
        if (!nbr)
                return 0;
 
@@ -11673,7 +11673,7 @@ static int zebra_vxlan_dad_ip_auto_recovery_exp(struct thread *t)
                        __func__,
                        prefix_mac2str(&nbr->emac, buf2, sizeof(buf2)),
                        ipaddr2str(&nbr->ip, buf1, sizeof(buf1)), nbr->flags,
-                       nbr->dad_count, zvni->vni);
+                       nbr->dad_count, zevpn->vni);
 
        UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
        nbr->dad_count = 0;
@@ -11685,10 +11685,10 @@ static int zebra_vxlan_dad_ip_auto_recovery_exp(struct thread *t)
 
        /* Send to BGP */
        if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)) {
-               zvni_neigh_send_add_to_client(zvni->vni, &nbr->ip, &nbr->emac,
+               zevpn_neigh_send_add_to_client(zevpn->vni, &nbr->ip, &nbr->emac,
                                nbr->mac, nbr->flags, nbr->loc_seq);
        } else if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE)) {
-               zvni_rem_neigh_install(zvni, nbr, false /*was_static*/);
+               zevpn_rem_neigh_install(zevpn, nbr, false /*was_static*/);
        }
 
        return 0;
@@ -11698,7 +11698,7 @@ static int zebra_vxlan_dad_mac_auto_recovery_exp(struct thread *t)
 {
        struct zebra_vrf *zvrf = NULL;
        zebra_mac_t *mac = NULL;
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
        struct listnode *node = NULL;
        zebra_neigh_t *nbr = NULL;
        char buf[ETHER_ADDR_STRLEN];
@@ -11706,15 +11706,15 @@ static int zebra_vxlan_dad_mac_auto_recovery_exp(struct thread *t)
        mac = THREAD_ARG(t);
 
        /* since this is asynchronous we need sanity checks*/
-       zvrf = vrf_info_lookup(mac->zvni->vrf_id);
+       zvrf = vrf_info_lookup(mac->zevpn->vrf_id);
        if (!zvrf)
                return 0;
 
-       zvni = zvni_lookup(mac->zvni->vni);
-       if (!zvni)
+       zevpn = zevpn_lookup(mac->zevpn->vni);
+       if (!zevpn)
                return 0;
 
-       mac = zvni_mac_lookup(zvni, &mac->macaddr);
+       mac = zevpn_mac_lookup(zevpn, &mac->macaddr);
        if (!mac)
                return 0;
 
@@ -11731,7 +11731,7 @@ static int zebra_vxlan_dad_mac_auto_recovery_exp(struct thread *t)
                        if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL))
                                ZEBRA_NEIGH_SET_INACTIVE(nbr);
                        else if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE))
-                               zvni_rem_neigh_install(zvni, nbr,
+                               zevpn_rem_neigh_install(zevpn, nbr,
                                        false /*was_static*/);
                }
 
@@ -11750,19 +11750,19 @@ static int zebra_vxlan_dad_mac_auto_recovery_exp(struct thread *t)
 
        if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
                /* Inform to BGP */
-               if (zvni_mac_send_add_to_client(zvni->vni, &mac->macaddr,
+               if (zevpn_mac_send_add_to_client(zevpn->vni, &mac->macaddr,
                                        mac->flags, mac->loc_seq, mac->es))
                        return -1;
 
                /* Process all neighbors associated with this MAC. */
-               zvni_process_neigh_on_local_mac_change(zvni, mac, 0,
+               zevpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
                        0 /*es_change*/);
 
        } else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
-               zvni_process_neigh_on_remote_mac_add(zvni, mac);
+               zevpn_process_neigh_on_remote_mac_add(zevpn, mac);
 
                /* Install the entry. */
-               zvni_rem_mac_install(zvni, mac, false /* was_static */);
+               zevpn_rem_mac_install(zevpn, mac, false /* was_static */);
        }
 
        return 0;
@@ -12021,7 +12021,7 @@ void zebra_vxlan_sg_replay(ZAPI_HANDLER_ARGS)
 
 /************************** EVPN BGP config management ************************/
 /* Notify Local MACs to the clienti, skips GW MAC */
-static void zvni_send_mac_hash_entry_to_client(struct hash_bucket *bucket,
+static void zevpn_send_mac_hash_entry_to_client(struct hash_bucket *bucket,
                                               void *arg)
 {
        struct mac_walk_ctx *wctx = arg;
@@ -12031,27 +12031,27 @@ static void zvni_send_mac_hash_entry_to_client(struct hash_bucket *bucket,
                return;
 
        if (CHECK_FLAG(zmac->flags, ZEBRA_MAC_LOCAL))
-               zvni_mac_send_add_to_client(wctx->zvni->vni, &zmac->macaddr,
+               zevpn_mac_send_add_to_client(wctx->zevpn->vni, &zmac->macaddr,
                                zmac->flags, zmac->loc_seq, zmac->es);
 }
 
-/* Iterator to Notify Local MACs of a L2VNI */
-static void zvni_send_mac_to_client(zebra_vni_t *zvni)
+/* Iterator to Notify Local MACs of a EVPN */
+static void zevpn_send_mac_to_client(zebra_evpn_t *zevpn)
 {
        struct mac_walk_ctx wctx;
 
-       if (!zvni->mac_table)
+       if (!zevpn->mac_table)
                return;
 
        memset(&wctx, 0, sizeof(struct mac_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
 
-       hash_iterate(zvni->mac_table, zvni_send_mac_hash_entry_to_client,
+       hash_iterate(zevpn->mac_table, zevpn_send_mac_hash_entry_to_client,
                        &wctx);
 }
 
 /* Notify Neighbor entries to the Client, skips the GW entry */
-static void zvni_send_neigh_hash_entry_to_client(struct hash_bucket *bucket,
+static void zevpn_send_neigh_hash_entry_to_client(struct hash_bucket *bucket,
                                                 void *arg)
 {
        struct mac_walk_ctx *wctx = arg;
@@ -12063,42 +12063,42 @@ static void zvni_send_neigh_hash_entry_to_client(struct hash_bucket *bucket,
 
        if (CHECK_FLAG(zn->flags, ZEBRA_NEIGH_LOCAL) &&
                IS_ZEBRA_NEIGH_ACTIVE(zn)) {
-               zmac = zvni_mac_lookup(wctx->zvni, &zn->emac);
+               zmac = zevpn_mac_lookup(wctx->zevpn, &zn->emac);
                if (!zmac)
                        return;
 
-               zvni_neigh_send_add_to_client(wctx->zvni->vni, &zn->ip,
+               zevpn_neigh_send_add_to_client(wctx->zevpn->vni, &zn->ip,
                                                &zn->emac, zn->mac, zn->flags,
                                                zn->loc_seq);
        }
 }
 
-/* Iterator of a specific L2VNI */
-static void zvni_send_neigh_to_client(zebra_vni_t *zvni)
+/* Iterator of a specific EVPN */
+static void zevpn_send_neigh_to_client(zebra_evpn_t *zevpn)
 {
        struct neigh_walk_ctx wctx;
 
        memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
-       wctx.zvni = zvni;
+       wctx.zevpn = zevpn;
 
-       hash_iterate(zvni->neigh_table, zvni_send_neigh_hash_entry_to_client,
+       hash_iterate(zevpn->neigh_table, zevpn_send_neigh_hash_entry_to_client,
                        &wctx);
 }
 
-static void zvni_evpn_cfg_cleanup(struct hash_bucket *bucket, void *ctxt)
+static void zevpn_cfg_cleanup(struct hash_bucket *bucket, void *ctxt)
 {
-       zebra_vni_t *zvni = NULL;
+       zebra_evpn_t *zevpn = NULL;
 
-       zvni = (zebra_vni_t *)bucket->data;
-       zvni->advertise_gw_macip = 0;
-       zvni->advertise_svi_macip = 0;
-       zvni->advertise_subnet = 0;
+       zevpn = (zebra_evpn_t *)bucket->data;
+       zevpn->advertise_gw_macip = 0;
+       zevpn->advertise_svi_macip = 0;
+       zevpn->advertise_subnet = 0;
 
-       zvni_neigh_del_all(zvni, 1, 0,
+       zevpn_neigh_del_all(zevpn, 1, 0,
                           DEL_REMOTE_NEIGH | DEL_REMOTE_NEIGH_FROM_VTEP);
-       zvni_mac_del_all(zvni, 1, 0,
+       zevpn_mac_del_all(zevpn, 1, 0,
                         DEL_REMOTE_MAC | DEL_REMOTE_MAC_FROM_VTEP);
-       zvni_vtep_del_all(zvni, 1);
+       zevpn_vtep_del_all(zevpn, 1);
 }
 
 /* Cleanup EVPN configuration of a specific VRF */
@@ -12111,7 +12111,7 @@ static void zebra_evpn_vrf_cfg_cleanup(struct zebra_vrf *zvrf)
        zvrf->advertise_svi_macip = 0;
        zvrf->vxlan_flood_ctrl = VXLAN_FLOOD_HEAD_END_REPL;
 
-       hash_iterate(zvrf->vni_table, zvni_evpn_cfg_cleanup, NULL);
+       hash_iterate(zvrf->evpn_table, zevpn_cfg_cleanup, NULL);
 
        if (zvrf->l3vni)
                zl3vni = zl3vni_lookup(zvrf->l3vni);

diff --git a/zebra/zebra_vxlan_private.h b/zebra/zebra_vxlan_private.h
index e2eae56873b5e55c827c10a041050941435cb8cb..0a4b34d425564d45fdc7c75f22c70e1a728a7456 100644 (file)
--- a/zebra/zebra_vxlan_private.h
+++ b/zebra/zebra_vxlan_private.h
@@ -37,7 +37,7 @@ extern "C" {
 #define ERR_STR_SZ 256
 
 /* definitions */
-typedef struct zebra_vni_t_ zebra_vni_t;
+typedef struct zebra_evpn_t_ zebra_evpn_t;
 typedef struct zebra_vtep_t_ zebra_vtep_t;
 typedef struct zebra_mac_t_ zebra_mac_t;
 typedef struct zebra_neigh_t_ zebra_neigh_t;
@@ -72,13 +72,13 @@ RB_PROTOTYPE(zebra_es_evi_rb_head, zebra_evpn_es_evi, rb_node,
  * Contains information pertaining to a VNI:
  * - the list of remote VTEPs (with this VNI)
  */
-struct zebra_vni_t_ {
+struct zebra_evpn_t_ {
        /* VNI - key */
        vni_t vni;
 
        /* ES flags */
        uint32_t flags;
-#define ZVNI_READY_FOR_BGP (1 << 0) /* ready to be sent to BGP */
+#define ZEVPN_READY_FOR_BGP (1 << 0) /* ready to be sent to BGP */
 
        /* Flag for advertising gw macip */
        uint8_t advertise_gw_macip;
@@ -333,8 +333,8 @@ struct zebra_mac_t_ {
 #define ZEBRA_MAC_ALL_PEER_FLAGS (ZEBRA_MAC_ES_PEER_PROXY |\
                ZEBRA_MAC_ES_PEER_ACTIVE)
 
-       /* back pointer to zvni */
-       zebra_vni_t     *zvni;
+       /* back pointer to zevpn */
+       zebra_evpn_t     *zevpn;
 
        /* Local or remote info. */
        union {
@@ -383,7 +383,7 @@ struct zebra_mac_t_ {
  * Context for MAC hash walk - used by callbacks.
  */
 struct mac_walk_ctx {
-       zebra_vni_t *zvni;      /* VNI hash */
+       zebra_evpn_t *zevpn;     /* EVPN hash */
        struct zebra_vrf *zvrf; /* VRF - for client notification. */
        int uninstall;          /* uninstall from kernel? */
        int upd_client;         /* uninstall from client? */
@@ -451,7 +451,7 @@ struct zebra_neigh_t_ {
        /* Underlying interface. */
        ifindex_t ifindex;
 
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
 
        uint32_t flags;
 #define ZEBRA_NEIGH_LOCAL     0x01
@@ -509,7 +509,7 @@ struct zebra_neigh_t_ {
  * Context for neighbor hash walk - used by callbacks.
  */
 struct neigh_walk_ctx {
-       zebra_vni_t *zvni;      /* VNI hash */
+       zebra_evpn_t *zevpn;      /* VNI hash */
        struct zebra_vrf *zvrf; /* VRF - for client notification. */
        int uninstall;          /* uninstall from kernel? */
        int upd_client;         /* uninstall from client? */
@@ -532,7 +532,7 @@ struct neigh_walk_ctx {
 /* context for neigh hash walk - update l3vni and rmac */
 struct neigh_l3info_walk_ctx {
 
-       zebra_vni_t *zvni;
+       zebra_evpn_t *zevpn;
        zebra_l3vni_t *zl3vni;
        int add;
 };
@@ -579,7 +579,7 @@ typedef struct zebra_vxlan_sg_ {
        uint32_t ref_cnt;
 } zebra_vxlan_sg_t;
 
-extern zebra_vni_t *zvni_lookup(vni_t vni);
+extern zebra_evpn_t *zevpn_lookup(vni_t vni);
 extern void zebra_vxlan_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
                bool force_clear_static, const char *caller);