1 files changed, 245 insertions, 123 deletions

diff --git a/zebra/zebra_evpn_mac.c b/zebra/zebra_evpn_mac.c
index 44394b95aa..5227a480fc 100644
--- a/zebra/zebra_evpn_mac.c
+++ b/zebra/zebra_evpn_mac.c
@@ -29,6 +29,7 @@
 #include "prefix.h"
 #include "vlan.h"
 #include "json.h"
+#include "printfrr.h"
 
 #include "zebra/zserv.h"
 #include "zebra/debug.h"
@@ -254,6 +255,37 @@ static void zebra_evpn_mac_get_access_info(zebra_mac_t *mac,
 	}
 }
 
+#define MAC_BUF_SIZE 256
+static char *zebra_evpn_zebra_mac_flag_dump(struct zebra_mac_t_ *mac, char *buf,
+					    size_t len)
+{
+	if (mac->flags == 0) {
+		snprintfrr(buf, len, "None ");
+		return buf;
+	}
+
+	snprintfrr(
+		buf, len, "%s%s%s%s%s%s%s%s%s%s%s%s",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL) ? "LOC " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE) ? "REM " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_AUTO) ? "AUTO " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_STICKY) ? "STICKY " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE_RMAC) ? "REM Router "
+							      : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW) ? "Default GW " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE_DEF_GW) ? "REM DEF GW "
+								: "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE) ? "DUP " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_FPM_SENT) ? "FPM " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_ACTIVE) ? "LOC Active "
+								 : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_PROXY) ? "PROXY " : "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL_INACTIVE)
+			? "LOC Inactive "
+			: "");
+	return buf;
+}
+
 static int zebra_evpn_dad_mac_auto_recovery_exp(struct thread *t)
 {
 	struct zebra_vrf *zvrf = NULL;
@@ -278,12 +310,17 @@ static int zebra_evpn_dad_mac_auto_recovery_exp(struct thread *t)
 	if (!mac)
 		return 0;
 
-	if (IS_ZEBRA_DEBUG_VXLAN)
+	if (IS_ZEBRA_DEBUG_VXLAN) {
+		char mac_buf[MAC_BUF_SIZE];
+
 		zlog_debug(
-			"%s: duplicate addr mac %s flags 0x%x learn count %u host count %u auto recovery expired",
+			"%s: duplicate addr mac %s flags %slearn count %u host count %u auto recovery expired",
 			__func__,
 			prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
-			mac->flags, mac->dad_count, listcount(mac->neigh_list));
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+						       sizeof(mac_buf)),
+			mac->dad_count, listcount(mac->neigh_list));
+	}
 
 	/* Remove all IPs as duplicate associcated with this MAC */
 	for (ALL_LIST_ELEMENTS_RO(mac->neigh_list, node, nbr)) {
@@ -350,14 +387,17 @@ static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 	 * Remote MAC event -> hold on installing it.
 	 */
 	if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE)) {
-		if (IS_ZEBRA_DEBUG_VXLAN)
+		if (IS_ZEBRA_DEBUG_VXLAN) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"%s: duplicate addr MAC %s flags 0x%x skip update to client, learn count %u recover time %u",
+				"%s: duplicate addr MAC %s flags %sskip update to client, learn count %u recover time %u",
 				__func__,
 				prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
-				mac->flags, mac->dad_count,
-				zvrf->dad_freeze_time);
-
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							       sizeof(mac_buf)),
+				mac->dad_count, zvrf->dad_freeze_time);
+		}
 		/* For duplicate MAC do not update
 		 * client but update neigh due to
 		 * this MAC update.
@@ -385,12 +425,17 @@ static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 	}
 
 	if (reset_params) {
-		if (IS_ZEBRA_DEBUG_VXLAN)
+		if (IS_ZEBRA_DEBUG_VXLAN) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"%s: duplicate addr MAC %s flags 0x%x detection time passed, reset learn count %u",
+				"%s: duplicate addr MAC %s flags %sdetection time passed, reset learn count %u",
 				__func__,
 				prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
-				mac->flags, mac->dad_count);
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							       sizeof(mac_buf)),
+				mac->dad_count);
+		}
 
 		mac->dad_count = 0;
 		/* Start dup. addr detection (DAD) start time,
@@ -452,13 +497,18 @@ static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 		/* Start auto recovery timer for this MAC */
 		THREAD_OFF(mac->dad_mac_auto_recovery_timer);
 		if (zvrf->dad_freeze && zvrf->dad_freeze_time) {
-			if (IS_ZEBRA_DEBUG_VXLAN)
+			if (IS_ZEBRA_DEBUG_VXLAN) {
+				char mac_buf[MAC_BUF_SIZE];
+
 				zlog_debug(
-					"%s: duplicate addr MAC %s flags 0x%x auto recovery time %u start",
+					"%s: duplicate addr MAC %s flags %sauto recovery time %u start",
 					__func__,
 					prefix_mac2str(&mac->macaddr, buf,
 						       sizeof(buf)),
-					mac->flags, zvrf->dad_freeze_time);
+					zebra_evpn_zebra_mac_flag_dump(
+						mac, mac_buf, sizeof(mac_buf)),
+					zvrf->dad_freeze_time);
+			}
 
 			thread_add_timer(zrouter.master,
 					 zebra_evpn_dad_mac_auto_recovery_exp,
@@ -694,7 +744,7 @@ void zebra_evpn_print_mac(zebra_mac_t *mac, void *ctxt, json_object *json)
 }
 
 static char *zebra_evpn_print_mac_flags(zebra_mac_t *mac, char *flags_buf,
-	uint32_t flags_buf_sz)
+					size_t flags_buf_sz)
 {
 	snprintf(flags_buf, flags_buf_sz, "%s%s%s%s",
 			mac->sync_neigh_cnt ?
@@ -903,14 +953,19 @@ int zebra_evpn_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
 	/* Write packet size. */
 	stream_putw_at(s, 0, stream_get_endp(s));
 
-	if (IS_ZEBRA_DEBUG_VXLAN)
+	if (IS_ZEBRA_DEBUG_VXLAN) {
+		char flag_buf[MACIP_BUF_SIZE];
+
 		zlog_debug(
-			"Send MACIP %s f 0x%x MAC %s IP %s seq %u L2-VNI %u ESI %s to %s",
-			(cmd == ZEBRA_MACIP_ADD) ? "Add" : "Del", flags,
+			"Send MACIP %s f %s MAC %s IP %s seq %u L2-VNI %u ESI %s to %s",
+			(cmd == ZEBRA_MACIP_ADD) ? "Add" : "Del",
+			zclient_evpn_dump_macip_flags(flags, flag_buf,
+						      sizeof(flag_buf)),
 			prefix_mac2str(macaddr, buf, sizeof(buf)),
 			ipaddr2str(ip, buf2, sizeof(buf2)), seq, vni,
 			es ? es->esi_str : "-",
 			zebra_route_string(client->proto));
+	}
 
 	if (cmd == ZEBRA_MACIP_ADD)
 		client->macipadd_cnt++;
@@ -982,10 +1037,12 @@ zebra_mac_t *zebra_evpn_mac_add(zebra_evpn_t *zevpn, struct ethaddr *macaddr)
 	mac->uptime = monotime(NULL);
 	if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
 		char buf[ETHER_ADDR_STRLEN];
+		char mac_buf[MAC_BUF_SIZE];
 
-		zlog_debug("%s: MAC %s flags 0x%x", __func__,
+		zlog_debug("%s: MAC %s flags %s", __func__,
 			   prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
-			   mac->flags);
+			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							  sizeof(mac_buf)));
 	}
 	return mac;
 }
@@ -999,10 +1056,12 @@ int zebra_evpn_mac_del(zebra_evpn_t *zevpn, zebra_mac_t *mac)
 
 	if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
 		char buf[ETHER_ADDR_STRLEN];
+		char mac_buf[MAC_BUF_SIZE];
 
-		zlog_debug("%s: MAC %s flags 0x%x", __func__,
+		zlog_debug("%s: MAC %s flags %s", __func__,
 			   prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
-			   mac->flags);
+			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							  sizeof(mac_buf)));
 	}
 
 	/* If the MAC is freed before the neigh we will end up
@@ -1047,11 +1106,13 @@ static bool zebra_evpn_check_mac_del_from_db(struct mac_walk_ctx *wctx,
 		 && !listcount(mac->neigh_list)) {
 		if (IS_ZEBRA_DEBUG_VXLAN) {
 			char buf[ETHER_ADDR_STRLEN];
+			char mac_buf[MAC_BUF_SIZE];
 
 			zlog_debug(
-				"%s: Del MAC %s flags 0x%x", __func__,
+				"%s: Del MAC %s flags %s", __func__,
 				prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
-				mac->flags);
+				zebra_evpn_zebra_mac_flag_dump(
+					mac, mac_buf, sizeof(mac_buf)));
 		}
 		wctx->uninstall = 0;
 
@@ -1204,24 +1265,34 @@ int zebra_evpn_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
 	zebra_evpn_mac_get_access_info(mac, &ifp, &vid);
 
 	if (!ifp) {
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"%s: dp-install sync-mac vni %u mac %pEA es %s 0x%x %sskipped, no access-port",
+				"%s: dp-install sync-mac vni %u mac %pEA es %s %s%sskipped, no access-port",
 				caller, zevpn->vni, &mac->macaddr,
-				mac->es ? mac->es->esi_str : "-", mac->flags,
+				mac->es ? mac->es->esi_str : "-",
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							       sizeof(mac_buf)),
 				set_inactive ? "inactive " : "");
+		}
 		return -1;
 	}
 
 	zif = ifp->info;
 	br_ifp = zif->brslave_info.br_if;
 	if (!br_ifp) {
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"%s: dp-install sync-mac vni %u mac %pEA es %s 0x%x %sskipped, no br",
+				"%s: dp-install sync-mac vni %u mac %pEA es %s %s%sskipped, no br",
 				caller, zevpn->vni, &mac->macaddr,
-				mac->es ? mac->es->esi_str : "-", mac->flags,
+				mac->es ? mac->es->esi_str : "-",
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							       sizeof(mac_buf)),
 				set_inactive ? "inactive " : "");
+		}
 		return -1;
 	}
 
@@ -1236,13 +1307,18 @@ int zebra_evpn_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
 	 * supported and if the local ES is oper-down.
 	 */
 	if (mac->es && zebra_evpn_es_local_mac_via_network_port(mac->es)) {
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"dp-%s sync-nw-mac vni %u mac %pEA es %s 0x%x %s",
+				"dp-%s sync-nw-mac vni %u mac %pEA es %s %s%s",
 				set_static ? "install" : "uninstall",
 				zevpn->vni, &mac->macaddr,
-				mac->es ? mac->es->esi_str : "-", mac->flags,
+				mac->es ? mac->es->esi_str : "-",
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							       sizeof(mac_buf)),
 				set_inactive ? "inactive " : "");
+		}
 		if (set_static)
 			/* XXX - old_static needs to be computed more
 			 * accurately
@@ -1256,13 +1332,17 @@ int zebra_evpn_sync_mac_dp_install(zebra_mac_t *mac, bool set_inactive,
 		return 0;
 	}
 
-	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
-		zlog_debug(
-			"dp-install sync-mac vni %u mac %pEA es %s 0x%x %s%s",
-			zevpn->vni, &mac->macaddr,
-			mac->es ? mac->es->esi_str : "-", mac->flags,
-			set_static ? "static " : "",
-			set_inactive ? "inactive " : "");
+	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+		char mac_buf[MAC_BUF_SIZE];
+
+		zlog_debug("dp-install sync-mac vni %u mac %pEA es %s %s%s%s",
+			   zevpn->vni, &mac->macaddr,
+			   mac->es ? mac->es->esi_str : "-",
+			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							  sizeof(mac_buf)),
+			   set_static ? "static " : "",
+			   set_inactive ? "inactive " : "");
+	}
 
 	dplane_local_mac_add(ifp, br_ifp, vid, &mac->macaddr, sticky,
 			     set_static, set_inactive);
@@ -1310,12 +1390,17 @@ static int zebra_evpn_mac_hold_exp_cb(struct thread *t)
 	new_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
 	new_static = zebra_evpn_mac_is_static(mac);
 
-	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+		char mac_buf[MAC_BUF_SIZE];
+
 		zlog_debug(
-			"sync-mac vni %u mac %s es %s 0x%x hold expired",
+			"sync-mac vni %u mac %s es %s %shold expired",
 			mac->zevpn->vni,
 			prefix_mac2str(&mac->macaddr, macbuf, sizeof(macbuf)),
-			mac->es ? mac->es->esi_str : "-", mac->flags);
+			mac->es ? mac->es->esi_str : "-",
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+						       sizeof(mac_buf)));
+	}
 
 	/* re-program the local mac in the dataplane if the mac is no
 	 * longer static
@@ -1340,12 +1425,17 @@ static inline void zebra_evpn_mac_start_hold_timer(zebra_mac_t *mac)
 	if (mac->hold_timer)
 		return;
 
-	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+		char mac_buf[MAC_BUF_SIZE];
+
 		zlog_debug(
-			"sync-mac vni %u mac %s es %s 0x%x hold started",
+			"sync-mac vni %u mac %s es %s %shold started",
 			mac->zevpn->vni,
 			prefix_mac2str(&mac->macaddr, macbuf, sizeof(macbuf)),
-			mac->es ? mac->es->esi_str : "-", mac->flags);
+			mac->es ? mac->es->esi_str : "-",
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+						       sizeof(mac_buf)));
+	}
 	thread_add_timer(zrouter.master, zebra_evpn_mac_hold_exp_cb, mac,
 			 zmh_info->mac_hold_time, &mac->hold_timer);
 }
@@ -1357,12 +1447,18 @@ void zebra_evpn_mac_stop_hold_timer(zebra_mac_t *mac)
 	if (!mac->hold_timer)
 		return;
 
-	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+		char mac_buf[MAC_BUF_SIZE];
+
 		zlog_debug(
-			"sync-mac vni %u mac %s es %s 0x%x hold stopped",
+			"sync-mac vni %u mac %s es %s %shold stopped",
 			mac->zevpn->vni,
 			prefix_mac2str(&mac->macaddr, macbuf, sizeof(macbuf)),
-			mac->es ? mac->es->esi_str : "-", mac->flags);
+			mac->es ? mac->es->esi_str : "-",
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+						       sizeof(mac_buf)));
+	}
+
 	THREAD_OFF(mac->hold_timer);
 }
 
@@ -1372,13 +1468,18 @@ void zebra_evpn_sync_mac_del(zebra_mac_t *mac)
 	bool old_static;
 	bool new_static;
 
-	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+		char mac_buf[MAC_BUF_SIZE];
+
 		zlog_debug(
-			"sync-mac del vni %u mac %s es %s seq %d f 0x%x",
+			"sync-mac del vni %u mac %s es %s seq %d f %s",
 			mac->zevpn->vni,
 			prefix_mac2str(&mac->macaddr, macbuf, sizeof(macbuf)),
 			mac->es ? mac->es->esi_str : "-", mac->loc_seq,
-			mac->flags);
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+						       sizeof(mac_buf)));
+	}
+
 	old_static = zebra_evpn_mac_is_static(mac);
 	UNSET_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_PROXY);
 	if (CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_ACTIVE))
@@ -1395,16 +1496,21 @@ void zebra_evpn_sync_mac_del(zebra_mac_t *mac)
 static inline bool zebra_evpn_mac_is_bgp_seq_ok(zebra_evpn_t *zevpn,
 						zebra_mac_t *mac, uint32_t seq,
 						uint16_t ipa_len,
-						struct ipaddr *ipaddr)
+						struct ipaddr *ipaddr,
+						bool sync)
 {
 	char macbuf[ETHER_ADDR_STRLEN];
 	char ipbuf[INET6_ADDRSTRLEN];
 	uint32_t tmp_seq;
+	const char *n_type;
 
-	if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL))
+	if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
 		tmp_seq = mac->loc_seq;
-	else
+		n_type = "local";
+	} else {
 		tmp_seq = mac->rem_seq;
+		n_type = "remote";
+	}
 
 	if (seq < tmp_seq) {
 		/* if the mac was never advertised to bgp we must accept
@@ -1413,31 +1519,44 @@ static inline bool zebra_evpn_mac_is_bgp_seq_ok(zebra_evpn_t *zevpn,
 		 */
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)
 		    && !zebra_evpn_mac_is_ready_for_bgp(mac->flags)) {
-			if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+			if (IS_ZEBRA_DEBUG_EVPN_MH_MAC
+			    || IS_ZEBRA_DEBUG_VXLAN) {
+				char mac_buf[MAC_BUF_SIZE];
+
 				zlog_debug(
-					"sync-macip accept vni %u mac %s%s%s lower seq %u f 0x%x",
-					zevpn->vni,
+					"%s-macip accept vni %u %s-mac %s%s%s lower seq %u f %s",
+					sync ? "sync" : "rem", zevpn->vni,
+					n_type,
 					prefix_mac2str(&mac->macaddr, macbuf,
 						       sizeof(macbuf)),
 					ipa_len ? " IP " : "",
 					ipa_len ? ipaddr2str(ipaddr, ipbuf,
 							     sizeof(ipbuf))
 						: "",
-					tmp_seq, mac->flags);
+					tmp_seq,
+					zebra_evpn_zebra_mac_flag_dump(
+						mac, mac_buf, sizeof(mac_buf)));
+			}
+
 			return true;
 		}
 
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC || IS_ZEBRA_DEBUG_VXLAN) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"sync-macip ignore vni %u mac %s%s%s as existing has higher seq %u f 0x%x",
-				zevpn->vni,
+				"%s-macip ignore vni %u %s-mac %s%s%s as existing has higher seq %u f %s",
+				sync ? "sync" : "rem", zevpn->vni, n_type,
 				prefix_mac2str(&mac->macaddr, macbuf,
 					       sizeof(macbuf)),
 				ipa_len ? " IP " : "",
 				ipa_len ? ipaddr2str(ipaddr, ipbuf,
 						     sizeof(ipbuf))
 					: "",
-				tmp_seq, mac->flags);
+				tmp_seq,
+				zebra_evpn_zebra_mac_flag_dump(
+					mac, mac_buf, sizeof(mac_buf)));
+		}
 		return false;
 	}
 
@@ -1518,7 +1637,7 @@ zebra_evpn_proc_sync_mac_update(zebra_evpn_t *zevpn, struct ethaddr *macaddr,
 			return NULL;
 		}
 		if (!zebra_evpn_mac_is_bgp_seq_ok(zevpn, mac, seq, ipa_len,
-						  ipaddr)) {
+						  ipaddr, true)) {
 			ctx->ignore_macip = true;
 			return NULL;
 		}
@@ -1568,12 +1687,20 @@ zebra_evpn_proc_sync_mac_update(zebra_evpn_t *zevpn, struct ethaddr *macaddr,
 		memset(&mac->fwd_info, 0, sizeof(mac->fwd_info));
 		mac->flags = new_flags;
 
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC && (old_flags != new_flags))
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC && (old_flags != new_flags)) {
+			char mac_buf[MAC_BUF_SIZE], omac_buf[MAC_BUF_SIZE];
+			struct zebra_mac_t_ omac;
+
+			omac.flags = old_flags;
 			zlog_debug(
-				"sync-mac vni %u mac %s old_f 0x%x new_f 0x%x",
+				"sync-mac vni %u mac %s old_f %snew_f %s",
 				zevpn->vni,
 				prefix_mac2str(macaddr, macbuf, sizeof(macbuf)),
-				old_flags, mac->flags);
+				zebra_evpn_zebra_mac_flag_dump(
+					&omac, omac_buf, sizeof(omac_buf)),
+				zebra_evpn_zebra_mac_flag_dump(
+					mac, mac_buf, sizeof(mac_buf)));
+		}
 
 		/* update es */
 		es_change = zebra_evpn_es_mac_ref(mac, esi);
@@ -1607,13 +1734,18 @@ zebra_evpn_proc_sync_mac_update(zebra_evpn_t *zevpn, struct ethaddr *macaddr,
 		inform_bgp = true;
 	}
 
-	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
-		zlog_debug("sync-mac %s vni %u mac %s es %s seq %d f 0x%x%s%s",
+	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+		char mac_buf[MAC_BUF_SIZE];
+
+		zlog_debug("sync-mac %s vni %u mac %s es %s seq %d f %s%s%s",
 			   ctx->mac_created ? "created" : "updated", zevpn->vni,
 			   prefix_mac2str(macaddr, macbuf, sizeof(macbuf)),
 			   mac->es ? mac->es->esi_str : "-", mac->loc_seq,
-			   mac->flags, inform_bgp ? " inform_bgp" : "",
+			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							  sizeof(mac_buf)),
+			   inform_bgp ? "inform_bgp" : "",
 			   inform_dataplane ? " inform_dp" : "");
+	}
 
 	if (inform_bgp)
 		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready,
@@ -1768,7 +1900,6 @@ int process_mac_remote_macip_add(zebra_evpn_t *zevpn, struct zebra_vrf *zvrf,
 {
 	char buf[ETHER_ADDR_STRLEN];
 	char buf1[INET6_ADDRSTRLEN];
-	uint32_t tmp_seq;
 	bool sticky;
 	bool remote_gw;
 	int update_mac = 0;
@@ -1828,8 +1959,6 @@ int process_mac_remote_macip_add(zebra_evpn_t *zevpn, struct zebra_vrf *zvrf,
 			if (ipa_len)
 				SET_FLAG(mac->flags, ZEBRA_MAC_AUTO);
 		} else {
-			zebra_evpn_es_mac_ref(mac, esi);
-
 			/* When host moves but changes its (MAC,IP)
 			 * binding, BGP may install a MACIP entry that
 			 * corresponds to "older" location of the host
@@ -1838,26 +1967,11 @@ int process_mac_remote_macip_add(zebra_evpn_t *zevpn, struct zebra_vrf *zvrf,
 			 * the sequence number and ignore this update
 			 * if appropriate.
 			 */
-			if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL))
-				tmp_seq = mac->loc_seq;
-			else
-				tmp_seq = mac->rem_seq;
-
-			if (seq < tmp_seq) {
-				if (IS_ZEBRA_DEBUG_VXLAN)
-					zlog_debug(
-						"Ignore remote MACIP ADD VNI %u MAC %s%s%s as existing MAC has higher seq %u flags 0x%x",
-						zevpn->vni,
-						prefix_mac2str(macaddr, buf,
-							       sizeof(buf)),
-						ipa_len ? " IP " : "",
-						ipa_len ? ipaddr2str(
-								  ipaddr, buf1,
-								  sizeof(buf1))
-							: "",
-						tmp_seq, mac->flags);
+			if (!zebra_evpn_mac_is_bgp_seq_ok(
+				    zevpn, mac, seq, ipa_len, ipaddr, false))
 				return -1;
-			}
+
+			zebra_evpn_es_mac_ref(mac, esi);
 		}
 
 		/* Check MAC's curent state is local (this is the case
@@ -1881,14 +1995,20 @@ int process_mac_remote_macip_add(zebra_evpn_t *zevpn, struct zebra_vrf *zvrf,
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
 			/* force drop the sync flags */
 			old_static = zebra_evpn_mac_is_static(mac);
-			if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+			if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+				char mac_buf[MAC_BUF_SIZE];
+
 				zlog_debug(
-					"sync-mac->remote vni %u mac %s es %s seq %d f 0x%x",
+					"sync-mac->remote vni %u mac %s es %s seq %d f %s",
 					zevpn->vni,
 					prefix_mac2str(macaddr, buf,
 						       sizeof(buf)),
 					mac->es ? mac->es->esi_str : "-",
-					mac->loc_seq, mac->flags);
+					mac->loc_seq,
+					zebra_evpn_zebra_mac_flag_dump(
+						mac, mac_buf, sizeof(mac_buf)));
+			}
+
 			zebra_evpn_mac_clear_sync_info(mac);
 			zebra_evpn_mac_send_del_to_client(zevpn->vni, macaddr,
 							  mac->flags,
@@ -1982,14 +2102,18 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf, zebra_evpn_t *zevpn,
 			SET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
 		inform_client = true;
 	} else {
-		if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"UPD %sMAC %s intf %s(%u) VID %u -> VNI %u %scurFlags 0x%x",
+				"UPD %sMAC %s intf %s(%u) VID %u -> VNI %u %scurFlags %s",
 				sticky ? "sticky " : "",
 				prefix_mac2str(macaddr, buf, sizeof(buf)),
 				ifp->name, ifp->ifindex, vid, zevpn->vni,
 				local_inactive ? "local-inactive " : "",
-				mac->flags);
+				zebra_evpn_zebra_mac_flag_dump(
+					mac, mac_buf, sizeof(mac_buf)));
+		}
 
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
 			struct interface *old_ifp;
@@ -2137,14 +2261,19 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf, zebra_evpn_t *zevpn,
 	 */
 	if ((old_local_inactive != local_inactive)
 	    || (new_bgp_ready != old_bgp_ready)) {
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"local mac vni %u mac %s es %s seq %d f 0x%x%s",
+				"local mac vni %u mac %s es %s seq %d f %s%s",
 				zevpn->vni,
 				prefix_mac2str(macaddr, buf, sizeof(buf)),
 				mac->es ? mac->es->esi_str : "", mac->loc_seq,
-				mac->flags,
-				local_inactive ? " local-inactive" : "");
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
+							       sizeof(mac_buf)),
+				local_inactive ? "local-inactive" : "");
+		}
+
 		if (!is_dup_detect)
 			inform_client = true;
 	}
@@ -2173,28 +2302,17 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf, zebra_evpn_t *zevpn,
 	return 0;
 }
 
-int zebra_evpn_del_local_mac(zebra_evpn_t *zevpn, struct ethaddr *macaddr,
-			     struct interface *ifp)
+int zebra_evpn_del_local_mac(zebra_evpn_t *zevpn, zebra_mac_t *mac)
 {
-	zebra_mac_t *mac;
 	char buf[ETHER_ADDR_STRLEN];
 	bool old_bgp_ready;
 	bool new_bgp_ready;
-	/* If entry doesn't exist, nothing to do. */
-	mac = zebra_evpn_mac_lookup(zevpn, macaddr);
-	if (!mac)
-		return 0;
-
-	/* Is it a local entry? */
-	if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL))
-		return 0;
 
 	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, mac->fwd_info.local.vid, zevpn->vni,
-			mac->loc_seq, mac->flags, listcount(mac->neigh_list));
+		zlog_debug("DEL MAC %s VNI %u seq %u flags 0x%x nbr count %u",
+			   prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
+			   zevpn->vni, mac->loc_seq, mac->flags,
+			   listcount(mac->neigh_list));
 
 	old_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
 	if (zebra_evpn_mac_is_static(mac)) {
@@ -2203,13 +2321,17 @@ int zebra_evpn_del_local_mac(zebra_evpn_t *zevpn, struct ethaddr *macaddr,
 		 */
 		memset(&mac->fwd_info, 0, sizeof(mac->fwd_info));
 
-		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
+		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
+			char mac_buf[MAC_BUF_SIZE];
+
 			zlog_debug(
-				"re-add sync-mac vni %u mac %s es %s seq %d f 0x%x",
+				"re-add sync-mac vni %u mac %s es %s seq %d f %s",
 				zevpn->vni,
-				prefix_mac2str(macaddr, buf, sizeof(buf)),
+				prefix_mac2str(&mac->macaddr, buf, sizeof(buf)),
 				mac->es ? mac->es->esi_str : "-", mac->loc_seq,
-				mac->flags);
+				zebra_evpn_zebra_mac_flag_dump(
+					mac, mac_buf, sizeof(mac_buf)));
+		}
 
 		/* inform-bgp about change in local-activity if any */
 		if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL_INACTIVE)) {
@@ -2232,7 +2354,7 @@ int zebra_evpn_del_local_mac(zebra_evpn_t *zevpn, struct ethaddr *macaddr,
 	zebra_evpn_process_neigh_on_local_mac_del(zevpn, mac);
 
 	/* Remove MAC from BGP. */
-	zebra_evpn_mac_send_del_to_client(zevpn->vni, macaddr, mac->flags,
+	zebra_evpn_mac_send_del_to_client(zevpn->vni, &mac->macaddr, mac->flags,
 					  false /* force */);
 
 	zebra_evpn_es_mac_deref_entry(mac);