Merging upstream version 10.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 194 insertions, 334 deletions

diff --git a/zebra/zebra_evpn_mac.c b/zebra/zebra_evpn_mac.c
index 6d5cd66..bfc060d 100644
--- a/zebra/zebra_evpn_mac.c
+++ b/zebra/zebra_evpn_mac.c
@@ -103,9 +103,7 @@ static void zebra_evpn_mac_ifp_unlink(struct zebra_mac *zmac)
 
 	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
 		zlog_debug("VNI %d MAC %pEA unlinked from ifp %s (%u)",
-			   zmac->zevpn->vni,
-			   &zmac->macaddr,
-			   ifp->name, ifp->ifindex);
+				zmac->zevpn->vni, &zmac->macaddr, ifp->name, ifp->ifindex);
 
 	zif = ifp->info;
 	list_delete_node(zif->mac_list, &zmac->ifp_listnode);
@@ -122,7 +120,7 @@ void zebra_evpn_mac_ifp_del(struct interface *ifp)
 	if (zif->mac_list) {
 		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
 			zlog_debug("MAC list deleted for ifp %s (%u)",
-				   zif->ifp->name, zif->ifp->ifindex);
+						zif->ifp->name, zif->ifp->ifindex);
 
 		for (ALL_LIST_ELEMENTS_RO(zif->mac_list, node, zmac)) {
 			zebra_evpn_mac_ifp_unlink(zmac);
@@ -161,9 +159,7 @@ static void zebra_evpn_mac_ifp_link(struct zebra_mac *zmac,
 
 	if (IS_ZEBRA_DEBUG_EVPN_MH_MAC)
 		zlog_debug("VNI %d MAC %pEA linked to ifp %s (%u)",
-			   zmac->zevpn->vni,
-			   &zmac->macaddr,
-			   ifp->name, ifp->ifindex);
+				zmac->zevpn->vni, &zmac->macaddr, ifp->name, ifp->ifindex);
 
 	zmac->ifp = ifp;
 	listnode_init(&zmac->ifp_listnode, zmac);
@@ -205,7 +201,7 @@ int zebra_evpn_rem_mac_install(struct zebra_evpn *zevpn, struct zebra_mac *mac,
 		return -1;
 
 	sticky = !!CHECK_FLAG(mac->flags,
-			      (ZEBRA_MAC_STICKY | ZEBRA_MAC_REMOTE_DEF_GW));
+						(ZEBRA_MAC_STICKY | ZEBRA_MAC_REMOTE_DEF_GW));
 
 	/* If nexthop group for the FDB entry is inactive (not programmed in
 	 * the dataplane) the MAC entry cannot be installed
@@ -249,7 +245,7 @@ int zebra_evpn_rem_mac_uninstall(struct zebra_evpn *zevpn,
 	enum zebra_dplane_result res;
 
 	/* If the MAC was not installed there is no need to uninstall it */
-	if (!force && mac->es && !(mac->es->flags & ZEBRA_EVPNES_NHG_ACTIVE))
+	if (!force && mac->es && !CHECK_FLAG(mac->es->flags, ZEBRA_EVPNES_NHG_ACTIVE))
 		return -1;
 
 	if (!zevpn->vxlan_if) {
@@ -282,8 +278,7 @@ int zebra_evpn_rem_mac_uninstall(struct zebra_evpn *zevpn,
 	ifp = zevpn->vxlan_if;
 	vtep_ip = mac->fwd_info.r_vtep_ip;
 
-	res = dplane_rem_mac_del(ifp, br_ifp, vid, &mac->macaddr, vni->vni,
-				 vtep_ip);
+	res = dplane_rem_mac_del(ifp, br_ifp, vid, &mac->macaddr, vni->vni, vtep_ip);
 	if (res != ZEBRA_DPLANE_REQUEST_FAILURE)
 		return 0;
 	else
@@ -341,8 +336,7 @@ static void zebra_evpn_mac_get_access_info(struct zebra_mac *mac,
 
 		*vid = mac->fwd_info.local.vid;
 		zns = zebra_ns_lookup(mac->fwd_info.local.ns_id);
-		*p_ifp = if_lookup_by_index_per_ns(zns,
-						   mac->fwd_info.local.ifindex);
+		*p_ifp = if_lookup_by_index_per_ns(zns, mac->fwd_info.local.ifindex);
 	}
 }
 
@@ -355,26 +349,19 @@ static char *zebra_evpn_zebra_mac_flag_dump(struct zebra_mac *mac, char *buf,
 		return buf;
 	}
 
-	snprintfrr(
-		buf, len, "%s%s%s%s%s%s%s%s%s%s%s%s",
+	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_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_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)
-			? "PEER Active "
-			: "",
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_ACTIVE) ? "PEER Active " : "",
 		CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_PROXY) ? "PROXY " : "",
-		CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL_INACTIVE)
-			? "LOC Inactive "
-			: "");
+		CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL_INACTIVE) ? "LOC Inactive " : "");
 	return buf;
 }
 
@@ -407,8 +394,7 @@ static void zebra_evpn_dad_mac_auto_recovery_exp(struct event *t)
 		zlog_debug(
 			"%s: duplicate addr mac %pEA flags %slearn count %u host count %u auto recovery expired",
 			__func__, &mac->macaddr,
-			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-						       sizeof(mac_buf)),
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)),
 			mac->dad_count, listcount(mac->neigh_list));
 	}
 
@@ -418,8 +404,7 @@ static void zebra_evpn_dad_mac_auto_recovery_exp(struct event *t)
 			if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL))
 				ZEBRA_NEIGH_SET_INACTIVE(nbr);
 			else if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE))
-				zebra_evpn_rem_neigh_install(
-					zevpn, nbr, false /*was_static*/);
+				zebra_evpn_rem_neigh_install(zevpn, nbr, false /*was_static*/);
 		}
 
 		UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
@@ -438,13 +423,11 @@ static void zebra_evpn_dad_mac_auto_recovery_exp(struct event *t)
 	if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
 		/* Inform to BGP */
 		if (zebra_evpn_mac_send_add_to_client(zevpn->vni, &mac->macaddr,
-						      mac->flags, mac->loc_seq,
-						      mac->es))
+						      mac->flags, mac->loc_seq, mac->es))
 			return;
 
 		/* Process all neighbors associated with this MAC. */
-		zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
-							     0 /*es_change*/);
+		zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0, 0 /*es_change*/);
 
 	} else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
 		zebra_evpn_process_neigh_on_remote_mac_add(zevpn, mac);
@@ -479,8 +462,7 @@ static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 			zlog_debug(
 				"%s: duplicate addr MAC %pEA flags %sskip update to client, learn count %u recover time %u",
 				__func__, &mac->macaddr,
-				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							       sizeof(mac_buf)),
+				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
@@ -516,8 +498,7 @@ static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 			zlog_debug(
 				"%s: duplicate addr MAC %pEA flags %sdetection time passed, reset learn count %u",
 				__func__, &mac->macaddr,
-				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							       sizeof(mac_buf)),
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)),
 				mac->dad_count);
 		}
 
@@ -545,10 +526,10 @@ static void zebra_evpn_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 %pEA detected as duplicate during %s VTEP %pI4",
-			  mac->zevpn->vni, &mac->macaddr,
-			  is_local ? "local update, last" :
-			  "remote update, from", &vtep_ip);
+			"VNI %u: MAC %pEA detected as duplicate during %s VTEP %pI4",
+			mac->zevpn->vni, &mac->macaddr,
+			is_local ? "local update, last" : "remote update, from",
+			&vtep_ip);
 
 		SET_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE);
 
@@ -583,15 +564,13 @@ static void zebra_evpn_dup_addr_detect_for_mac(struct zebra_vrf *zvrf,
 				zlog_debug(
 					"%s: duplicate addr MAC %pEA flags %sauto recovery time %u start",
 					__func__, &mac->macaddr,
-					zebra_evpn_zebra_mac_flag_dump(
-						mac, mac_buf, sizeof(mac_buf)),
+					zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)),
 					zvrf->dad_freeze_time);
 			}
 
 			event_add_timer(zrouter.master,
-					zebra_evpn_dad_mac_auto_recovery_exp,
-					mac, zvrf->dad_freeze_time,
-					&mac->dad_mac_auto_recovery_timer);
+					zebra_evpn_dad_mac_auto_recovery_exp, mac,
+					zvrf->dad_freeze_time, &mac->dad_mac_auto_recovery_timer);
 		}
 
 		/* In case of local update, do not inform to client (BGPd),
@@ -638,22 +617,18 @@ void zebra_evpn_print_mac(struct zebra_mac *mac, void *ctxt, json_object *json)
 			zebra_evpn_mac_get_access_info(mac, &ifp, &vid);
 			json_object_string_add(json_mac, "type", "local");
 			if (ifp) {
-				json_object_string_add(json_mac, "intf",
-						       ifp->name);
-				json_object_int_add(json_mac, "ifindex",
-						    ifp->ifindex);
+				json_object_string_add(json_mac, "intf", ifp->name);
+				json_object_int_add(json_mac, "ifindex", ifp->ifindex);
 			}
 			if (vid)
 				json_object_int_add(json_mac, "vlan", vid);
 		} else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
 			json_object_string_add(json_mac, "type", "remote");
 			if (mac->es)
-				json_object_string_add(json_mac, "remoteEs",
-						       mac->es->esi_str);
+				json_object_string_add(json_mac, "remoteEs", mac->es->esi_str);
 			else
 				json_object_string_addf(
-					json_mac, "remoteVtep", "%pI4",
-					&mac->fwd_info.r_vtep_ip);
+					json_mac, "remoteVtep", "%pI4", &mac->fwd_info.r_vtep_ip);
 		} else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_AUTO))
 			json_object_string_add(json_mac, "type", "auto");
 
@@ -664,12 +639,10 @@ void zebra_evpn_print_mac(struct zebra_mac *mac, void *ctxt, json_object *json)
 			json_object_boolean_true_add(json_mac, "sviMac");
 
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW))
-			json_object_boolean_true_add(json_mac,
-						     "defaultGateway");
+			json_object_boolean_true_add(json_mac, "defaultGateway");
 
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE_DEF_GW))
-			json_object_boolean_true_add(json_mac,
-						     "remoteGatewayMac");
+			json_object_boolean_true_add(json_mac, "remoteGatewayMac");
 
 		json_object_string_add(json_mac, "uptime", up_str);
 		json_object_int_add(json_mac, "localSequence", mac->loc_seq);
@@ -690,46 +663,31 @@ void zebra_evpn_print_mac(struct zebra_mac *mac, void *ctxt, json_object *json)
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_ACTIVE))
 			json_object_boolean_true_add(json_mac, "peerActive");
 		if (mac->hold_timer)
-			json_object_string_add(
-				json_mac, "peerActiveHold",
-				event_timer_to_hhmmss(thread_buf,
-						      sizeof(thread_buf),
-						      mac->hold_timer));
+			json_object_string_add(json_mac, "peerActiveHold",
+				event_timer_to_hhmmss(thread_buf, sizeof(thread_buf), mac->hold_timer));
 		if (mac->es)
-			json_object_string_add(json_mac, "esi",
-					mac->es->esi_str);
+			json_object_string_add(json_mac, "esi", mac->es->esi_str);
 		/* print all the associated neigh */
 		if (!listcount(mac->neigh_list))
 			json_object_string_add(json_mac, "neighbors", "none");
 		else {
 			json_object *json_active_nbrs = json_object_new_array();
-			json_object *json_inactive_nbrs =
-				json_object_new_array();
+			json_object *json_inactive_nbrs = json_object_new_array();
 			json_object *json_nbrs = json_object_new_object();
 
 			for (ALL_LIST_ELEMENTS_RO(mac->neigh_list, node, n)) {
 				if (IS_ZEBRA_NEIGH_ACTIVE(n))
-					json_object_array_add(
-						json_active_nbrs,
-						json_object_new_string(
-							ipaddr2str(
-								&n->ip, buf2,
-								sizeof(buf2))));
+					json_object_array_add(json_active_nbrs,
+						json_object_new_string(ipaddr2str(&n->ip, buf2, sizeof(buf2))));
 				else
 					json_object_array_add(
 						json_inactive_nbrs,
-						json_object_new_string(
-							ipaddr2str(
-								&n->ip, buf2,
-								sizeof(buf2))));
+						json_object_new_string(ipaddr2str(&n->ip, buf2, sizeof(buf2))));
 			}
 
-			json_object_object_add(json_nbrs, "active",
-					       json_active_nbrs);
-			json_object_object_add(json_nbrs, "inactive",
-					       json_inactive_nbrs);
-			json_object_object_add(json_mac, "neighbors",
-					       json_nbrs);
+			json_object_object_add(json_nbrs, "active", json_active_nbrs);
+			json_object_object_add(json_nbrs, "inactive", json_inactive_nbrs);
+			json_object_object_add(json_mac, "neighbors", json_nbrs);
 		}
 
 		json_object_object_add(json, buf1, json_mac);
@@ -746,18 +704,15 @@ void zebra_evpn_print_mac(struct zebra_mac *mac, void *ctxt, json_object *json)
 				vty_out(vty, " ESI: %s\n", mac->es->esi_str);
 
 			if (ifp)
-				vty_out(vty, " Intf: %s(%u)", ifp->name,
-					ifp->ifindex);
+				vty_out(vty, " Intf: %s(%u)", ifp->name, ifp->ifindex);
 			else
 				vty_out(vty, " Intf: -");
 			vty_out(vty, " VLAN: %u", vid);
 		} else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
 			if (mac->es)
-				vty_out(vty, " Remote ES: %s",
-					mac->es->esi_str);
+				vty_out(vty, " Remote ES: %s", mac->es->esi_str);
 			else
-				vty_out(vty, " Remote VTEP: %pI4",
-					&mac->fwd_info.r_vtep_ip);
+				vty_out(vty, " Remote VTEP: %pI4", &mac->fwd_info.r_vtep_ip);
 		} else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_AUTO)) {
 			vty_out(vty, " Auto Mac ");
 		}
@@ -784,24 +739,18 @@ void zebra_evpn_print_mac(struct zebra_mac *mac, void *ctxt, json_object *json)
 			vty_out(vty, " peer-active");
 		if (mac->hold_timer)
 			vty_out(vty, " (ht: %s)",
-				event_timer_to_hhmmss(thread_buf,
-						      sizeof(thread_buf),
-						      mac->hold_timer));
+				event_timer_to_hhmmss(thread_buf, sizeof(thread_buf), mac->hold_timer));
 		vty_out(vty, "\n");
-		vty_out(vty, " Local Seq: %u Remote Seq: %u\n", mac->loc_seq,
-			mac->rem_seq);
+		vty_out(vty, " Local Seq: %u Remote Seq: %u\n", mac->loc_seq, mac->rem_seq);
 		vty_out(vty, " Uptime: %s\n", up_str);
 
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE)) {
 			vty_out(vty, " Duplicate, detected at %s",
-				time_to_string(mac->dad_dup_detect_time,
-					       timebuf));
+				time_to_string(mac->dad_dup_detect_time, timebuf));
 		} else if (mac->dad_count) {
-			monotime_since(&mac->detect_start_time,
-				       &detect_start_time);
+			monotime_since(&mac->detect_start_time, &detect_start_time);
 			if (detect_start_time.tv_sec <= zvrf->dad_time) {
-				time_to_string(mac->detect_start_time.tv_sec,
-					       timebuf);
+				time_to_string(mac->detect_start_time.tv_sec, timebuf);
 				vty_out(vty,
 					" Duplicate detection started at %s, detection count %u\n",
 					timebuf, mac->dad_count);
@@ -816,9 +765,7 @@ void zebra_evpn_print_mac(struct zebra_mac *mac, void *ctxt, json_object *json)
 			for (ALL_LIST_ELEMENTS_RO(mac->neigh_list, node, n)) {
 				vty_out(vty, "    %s %s\n",
 					ipaddr2str(&n->ip, buf2, sizeof(buf2)),
-					(IS_ZEBRA_NEIGH_ACTIVE(n)
-						 ? "Active"
-						 : "Inactive"));
+					(IS_ZEBRA_NEIGH_ACTIVE(n) ? "Active" : "Inactive"));
 			}
 		}
 
@@ -831,9 +778,9 @@ static char *zebra_evpn_print_mac_flags(struct zebra_mac *mac, char *flags_buf,
 {
 	snprintf(flags_buf, flags_buf_sz, "%s%s%s%s",
 		 mac->sync_neigh_cnt ? "N" : "",
-		 (mac->flags & ZEBRA_MAC_ES_PEER_ACTIVE) ? "P" : "",
-		 (mac->flags & ZEBRA_MAC_ES_PEER_PROXY) ? "X" : "",
-		 (mac->flags & ZEBRA_MAC_LOCAL_INACTIVE) ? "I" : "");
+		 CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_ACTIVE) ? "P" : "",
+		 CHECK_FLAG(mac->flags, ZEBRA_MAC_ES_PEER_PROXY) ? "X" : "",
+		 CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL_INACTIVE) ? "I" : "");
 
 	return flags_buf;
 }
@@ -870,14 +817,12 @@ void zebra_evpn_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
 		zebra_evpn_mac_get_access_info(mac, &ifp, &vid);
 		if (json_mac_hdr == NULL) {
 			vty_out(vty, "%-17s %-6s %-5s %-30s", buf1, "local",
-				zebra_evpn_print_mac_flags(mac, flags_buf,
-                sizeof(flags_buf)),
+				zebra_evpn_print_mac_flags(mac, flags_buf, sizeof(flags_buf)),
 				ifp ? ifp->name : "-");
 		} else {
 			json_object_string_add(json_mac, "type", "local");
 			if (ifp)
-				json_object_string_add(json_mac, "intf",
-						       ifp->name);
+				json_object_string_add(json_mac, "intf", ifp->name);
 		}
 		if (vid) {
 			if (json_mac_hdr == NULL)
@@ -891,18 +836,13 @@ void zebra_evpn_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
 			vty_out(vty, " %u/%u", mac->loc_seq, mac->rem_seq);
 			vty_out(vty, "\n");
 		} else {
-			json_object_int_add(json_mac, "localSequence",
-					    mac->loc_seq);
-			json_object_int_add(json_mac, "remoteSequence",
-					    mac->rem_seq);
-			json_object_int_add(json_mac, "detectionCount",
-					    mac->dad_count);
+			json_object_int_add(json_mac, "localSequence", mac->loc_seq);
+			json_object_int_add(json_mac, "remoteSequence", mac->rem_seq);
+			json_object_int_add(json_mac, "detectionCount", mac->dad_count);
 			if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
-				json_object_boolean_true_add(json_mac,
-							     "isDuplicate");
+				json_object_boolean_true_add(json_mac, "isDuplicate");
 			else
-				json_object_boolean_false_add(json_mac,
-							      "isDuplicate");
+				json_object_boolean_false_add(json_mac, "isDuplicate");
 			json_object_object_add(json_mac_hdr, buf1, json_mac);
 		}
 
@@ -910,19 +850,16 @@ void zebra_evpn_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
 
 	} else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
 
-		if ((wctx->flags & SHOW_REMOTE_MAC_FROM_VTEP)
-		    && !IPV4_ADDR_SAME(&mac->fwd_info.r_vtep_ip,
-				       &wctx->r_vtep_ip))
+		if (CHECK_FLAG(wctx->flags, SHOW_REMOTE_MAC_FROM_VTEP)
+		    && !IPV4_ADDR_SAME(&mac->fwd_info.r_vtep_ip, &wctx->r_vtep_ip))
 			return;
 
 		if (json_mac_hdr == NULL) {
-			if ((wctx->flags & SHOW_REMOTE_MAC_FROM_VTEP)
+			if (CHECK_FLAG(wctx->flags, SHOW_REMOTE_MAC_FROM_VTEP)
 			    && (wctx->count == 0)) {
 				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", "VLAN",
-					"Seq #'s");
+					"MAC", "Type", "Flags", "Intf/Remote ES/VTEP", "VLAN", "Seq #'s");
 			}
 			if (mac->es == NULL)
 				inet_ntop(AF_INET, &mac->fwd_info.r_vtep_ip,
@@ -930,32 +867,24 @@ void zebra_evpn_print_mac_hash(struct hash_bucket *bucket, void *ctxt)
 
 			vty_out(vty, "%-17s %-6s %-5s %-30s %-5s %u/%u\n", buf1,
 				"remote",
-				zebra_evpn_print_mac_flags(mac, flags_buf,
-							   sizeof(flags_buf)),
+				zebra_evpn_print_mac_flags(mac, flags_buf, sizeof(flags_buf)),
 				mac->es ? mac->es->esi_str : addr_buf,
 				"", mac->loc_seq, mac->rem_seq);
 		} else {
 			json_object_string_add(json_mac, "type", "remote");
 			if (mac->es)
-				json_object_string_add(json_mac, "remoteEs",
-						       mac->es->esi_str);
+				json_object_string_add(json_mac, "remoteEs", mac->es->esi_str);
 			else
 				json_object_string_addf(
-					json_mac, "remoteVtep", "%pI4",
-					&mac->fwd_info.r_vtep_ip);
+					json_mac, "remoteVtep", "%pI4", &mac->fwd_info.r_vtep_ip);
 			json_object_object_add(json_mac_hdr, buf1, json_mac);
-			json_object_int_add(json_mac, "localSequence",
-					    mac->loc_seq);
-			json_object_int_add(json_mac, "remoteSequence",
-					    mac->rem_seq);
-			json_object_int_add(json_mac, "detectionCount",
-					    mac->dad_count);
+			json_object_int_add(json_mac, "localSequence", mac->loc_seq);
+			json_object_int_add(json_mac, "remoteSequence", mac->rem_seq);
+			json_object_int_add(json_mac, "detectionCount", mac->dad_count);
 			if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
-				json_object_boolean_true_add(json_mac,
-							     "isDuplicate");
+				json_object_boolean_true_add(json_mac, "isDuplicate");
 			else
-				json_object_boolean_false_add(json_mac,
-							      "isDuplicate");
+				json_object_boolean_false_add(json_mac, "isDuplicate");
 		}
 
 		wctx->count++;
@@ -1004,7 +933,7 @@ int zebra_evpn_macip_send_msg_to_client(vni_t vni,
 	if (!client)
 		return 0;
 
-	s = stream_new(ZEBRA_MAX_PACKET_SIZ);
+	s = stream_new(ZEBRA_SMALL_PACKET_SIZE);
 
 	zclient_create_header(s, cmd, zebra_vrf_get_evpn_id());
 	stream_putl(s, vni);
@@ -1040,9 +969,9 @@ int zebra_evpn_macip_send_msg_to_client(vni_t vni,
 		zlog_debug(
 			"Send MACIP %s f %s state %u MAC %pEA IP %pIA 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)),
-			state, macaddr, ip, seq, vni, es ? es->esi_str : "-",
+			zclient_evpn_dump_macip_flags(flags, flag_buf, sizeof(flag_buf)),
+			state, macaddr, ip, seq, vni,
+			es ? es->esi_str : "-",
 			zebra_route_string(client->proto));
 	}
 
@@ -1076,8 +1005,7 @@ static bool mac_cmp(const void *p1, const void *p2)
 	if (pmac1 == NULL || pmac2 == NULL)
 		return false;
 
-	return (memcmp(pmac1->macaddr.octet, pmac2->macaddr.octet, ETH_ALEN)
-		== 0);
+	return (memcmp(pmac1->macaddr.octet, pmac2->macaddr.octet, ETH_ALEN) == 0);
 }
 
 /*
@@ -1117,10 +1045,8 @@ struct zebra_mac *zebra_evpn_mac_add(struct zebra_evpn *zevpn,
 	if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
 		char mac_buf[MAC_BUF_SIZE];
 
-		zlog_debug("%s: MAC %pEA flags %s", __func__,
-			   &mac->macaddr,
-			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							  sizeof(mac_buf)));
+		zlog_debug("%s: MAC %pEA flags %s", __func__, &mac->macaddr,
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 	}
 	return mac;
 }
@@ -1135,10 +1061,8 @@ int zebra_evpn_mac_del(struct zebra_evpn *zevpn, struct zebra_mac *mac)
 	if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC) {
 		char mac_buf[MAC_BUF_SIZE];
 
-		zlog_debug("%s: MAC %pEA flags %s", __func__,
-			   &mac->macaddr,
-			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							  sizeof(mac_buf)));
+		zlog_debug("%s: MAC %pEA flags %s", __func__, &mac->macaddr,
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 	}
 
 	/* force de-ref any ES entry linked to the MAC */
@@ -1165,9 +1089,8 @@ int zebra_evpn_mac_del(struct zebra_evpn *zevpn, struct zebra_mac *mac)
 		if (IS_ZEBRA_DEBUG_VXLAN)
 			zlog_debug(
 				"MAC %pEA (flags 0x%x vni %u) has non-empty neigh list "
-				"count %u, mark MAC as AUTO",
-				&mac->macaddr, mac->flags, zevpn->vni,
-				listcount(mac->neigh_list));
+				"count %u, mark MAC as AUTO", &mac->macaddr, mac->flags,
+				zevpn->vni, listcount(mac->neigh_list));
 
 		SET_FLAG(mac->flags, ZEBRA_MAC_AUTO);
 		return 0;
@@ -1204,25 +1127,25 @@ struct zebra_mac *zebra_evpn_mac_add_auto(struct zebra_evpn *zevpn,
 static bool zebra_evpn_check_mac_del_from_db(struct mac_walk_ctx *wctx,
 					     struct zebra_mac *mac)
 {
-	if ((wctx->flags & DEL_LOCAL_MAC) && (mac->flags & ZEBRA_MAC_LOCAL))
+	if (CHECK_FLAG(wctx->flags, DEL_LOCAL_MAC)
+		 && CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL))
 		return true;
-	else if ((wctx->flags & DEL_REMOTE_MAC)
-		 && (mac->flags & ZEBRA_MAC_REMOTE))
+	else if (CHECK_FLAG(wctx->flags, DEL_REMOTE_MAC)
+		 && CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE))
 		return true;
-	else if ((wctx->flags & DEL_REMOTE_MAC_FROM_VTEP)
-		 && (mac->flags & ZEBRA_MAC_REMOTE)
+	else if (CHECK_FLAG(wctx->flags, DEL_REMOTE_MAC_FROM_VTEP)
+		 && CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)
 		 && IPV4_ADDR_SAME(&mac->fwd_info.r_vtep_ip, &wctx->r_vtep_ip))
 		return true;
-	else if ((wctx->flags & DEL_LOCAL_MAC) && (mac->flags & ZEBRA_MAC_AUTO)
+	else if (CHECK_FLAG(wctx->flags, DEL_LOCAL_MAC)
+		 && CHECK_FLAG(mac->flags, ZEBRA_MAC_AUTO)
 		 && !listcount(mac->neigh_list)) {
 		if (IS_ZEBRA_DEBUG_VXLAN) {
 			char mac_buf[MAC_BUF_SIZE];
 
 			zlog_debug(
-				"%s: Del MAC %pEA flags %s", __func__,
-				&mac->macaddr,
-				zebra_evpn_zebra_mac_flag_dump(
-					mac, mac_buf, sizeof(mac_buf)));
+				"%s: Del MAC %pEA flags %s", __func__, &mac->macaddr,
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 		}
 		wctx->uninstall = 0;
 
@@ -1241,21 +1164,17 @@ static void zebra_evpn_mac_del_hash_entry(struct hash_bucket *bucket, void *arg)
 	struct zebra_mac *mac = bucket->data;
 
 	if (zebra_evpn_check_mac_del_from_db(wctx, mac)) {
-		if (wctx->upd_client && (mac->flags & ZEBRA_MAC_LOCAL)) {
+		if (wctx->upd_client && CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
 			zebra_evpn_mac_send_del_to_client(wctx->zevpn->vni,
-							  &mac->macaddr,
-							  mac->flags, false);
+							  &mac->macaddr, mac->flags, false);
 		}
 		if (wctx->uninstall) {
 			if (zebra_evpn_mac_is_static(mac))
-				zebra_evpn_sync_mac_dp_install(
-					mac, false /* set_inactive */,
-					true /* force_clear_static */,
-					__func__);
+				zebra_evpn_sync_mac_dp_install(mac, false /* set_inactive */,
+									true /* force_clear_static */, __func__);
 
 			if (mac->flags & ZEBRA_MAC_REMOTE)
-				zebra_evpn_rem_mac_uninstall(wctx->zevpn, mac,
-							     false /*force*/);
+				zebra_evpn_rem_mac_uninstall(wctx->zevpn, mac, false /*force*/);
 		}
 
 		zebra_evpn_mac_del(wctx->zevpn, mac);
@@ -1330,8 +1249,7 @@ int zebra_evpn_mac_send_add_to_client(vni_t vni, const struct ethaddr *macaddr,
 		SET_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
 
 	return zebra_evpn_macip_send_msg_to_client(vni, macaddr, NULL, flags,
-						   seq, ZEBRA_NEIGH_ACTIVE, es,
-						   ZEBRA_MACIP_ADD);
+						   seq, ZEBRA_NEIGH_ACTIVE, es, ZEBRA_MACIP_ADD);
 }
 
 /*
@@ -1357,9 +1275,8 @@ int zebra_evpn_mac_send_del_to_client(vni_t vni, const struct ethaddr *macaddr,
 			state = ZEBRA_NEIGH_INACTIVE;
 	}
 
-	return zebra_evpn_macip_send_msg_to_client(
-		vni, macaddr, NULL, 0 /* flags */, 0 /* seq */, state, NULL,
-		ZEBRA_MACIP_DEL);
+	return zebra_evpn_macip_send_msg_to_client(vni, macaddr, NULL,
+					0 /* flags */, 0 /* seq */, state, NULL, ZEBRA_MACIP_DEL);
 }
 
 /*
@@ -1412,8 +1329,7 @@ int zebra_evpn_sync_mac_dp_install(struct zebra_mac *mac, bool set_inactive,
 				"%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 : "-",
-				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							       sizeof(mac_buf)),
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)),
 				set_inactive ? "inactive " : "");
 		}
 		return -1;
@@ -1429,8 +1345,7 @@ int zebra_evpn_sync_mac_dp_install(struct zebra_mac *mac, bool set_inactive,
 				"%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 : "-",
-				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							       sizeof(mac_buf)),
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)),
 				set_inactive ? "inactive " : "");
 		}
 		return -1;
@@ -1455,19 +1370,16 @@ int zebra_evpn_sync_mac_dp_install(struct zebra_mac *mac, bool set_inactive,
 				set_static ? "install" : "uninstall",
 				zevpn->vni, &mac->macaddr,
 				mac->es ? mac->es->esi_str : "-",
-				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							       sizeof(mac_buf)),
+				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
 			 */
-			zebra_evpn_rem_mac_install(zevpn, mac,
-						   true /* old_static */);
+			zebra_evpn_rem_mac_install(zevpn, mac, true /* old_static */);
 		else
-			zebra_evpn_rem_mac_uninstall(zevpn, mac,
-						     false /* force */);
+			zebra_evpn_rem_mac_uninstall(zevpn, mac, false /* force */);
 
 		return 0;
 	}
@@ -1478,14 +1390,13 @@ int zebra_evpn_sync_mac_dp_install(struct zebra_mac *mac, bool set_inactive,
 		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)),
+			   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);
+						set_static, set_inactive);
 	return 0;
 }
 
@@ -1495,12 +1406,11 @@ void zebra_evpn_mac_send_add_del_to_client(struct zebra_mac *mac,
 {
 	if (new_bgp_ready)
 		zebra_evpn_mac_send_add_to_client(mac->zevpn->vni,
-						  &mac->macaddr, mac->flags,
-						  mac->loc_seq, mac->es);
+											&mac->macaddr, mac->flags,
+											mac->loc_seq, mac->es);
 	else if (old_bgp_ready)
 		zebra_evpn_mac_send_del_to_client(mac->zevpn->vni,
-						  &mac->macaddr, mac->flags,
-						  true /* force */);
+								&mac->macaddr, mac->flags, true /* force */);
 }
 
 /* MAC hold timer is used to age out peer-active flag.
@@ -1537,8 +1447,7 @@ static void zebra_evpn_mac_hold_exp_cb(struct event *t)
 			"sync-mac vni %u mac %pEA es %s %shold expired",
 			mac->zevpn->vni, &mac->macaddr,
 			mac->es ? mac->es->esi_str : "-",
-			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-						       sizeof(mac_buf)));
+			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
@@ -1546,13 +1455,11 @@ static void zebra_evpn_mac_hold_exp_cb(struct event *t)
 	 */
 	if (old_static != new_static)
 		zebra_evpn_sync_mac_dp_install(mac, false /* set_inactive */,
-					       false /* force_clear_static */,
-					       __func__);
+							false /* force_clear_static */, __func__);
 
 	/* inform bgp if needed */
 	if (old_bgp_ready != new_bgp_ready)
-		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready,
-						      new_bgp_ready);
+		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready, new_bgp_ready);
 }
 
 static inline void zebra_evpn_mac_start_hold_timer(struct zebra_mac *mac)
@@ -1567,8 +1474,7 @@ static inline void zebra_evpn_mac_start_hold_timer(struct zebra_mac *mac)
 			"sync-mac vni %u mac %pEA es %s %shold started",
 			mac->zevpn->vni, &mac->macaddr,
 			mac->es ? mac->es->esi_str : "-",
-			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-						       sizeof(mac_buf)));
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 	}
 	event_add_timer(zrouter.master, zebra_evpn_mac_hold_exp_cb, mac,
 			zmh_info->mac_hold_time, &mac->hold_timer);
@@ -1586,8 +1492,7 @@ void zebra_evpn_mac_stop_hold_timer(struct zebra_mac *mac)
 			"sync-mac vni %u mac %pEA es %s %shold stopped",
 			mac->zevpn->vni, &mac->macaddr,
 			mac->es ? mac->es->esi_str : "-",
-			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-						       sizeof(mac_buf)));
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 	}
 
 	EVENT_OFF(mac->hold_timer);
@@ -1605,8 +1510,7 @@ void zebra_evpn_sync_mac_del(struct zebra_mac *mac)
 			"sync-mac del vni %u mac %pEA es %s seq %d f %s",
 			mac->zevpn->vni, &mac->macaddr,
 			mac->es ? mac->es->esi_str : "-", mac->loc_seq,
-			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-						       sizeof(mac_buf)));
+			zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 	}
 
 	old_static = zebra_evpn_mac_is_static(mac);
@@ -1618,8 +1522,7 @@ void zebra_evpn_sync_mac_del(struct zebra_mac *mac)
 	if (old_static != new_static)
 		/* program the local mac in the kernel */
 		zebra_evpn_sync_mac_dp_install(mac, false /* set_inactive */,
-					       false /* force_clear_static */,
-					       __func__);
+									false /* force_clear_static */, __func__);
 }
 
 static inline bool zebra_evpn_mac_is_bgp_seq_ok(struct zebra_evpn *zevpn,
@@ -1647,8 +1550,7 @@ static inline bool zebra_evpn_mac_is_bgp_seq_ok(struct zebra_evpn *zevpn,
 				zlog_debug(
 					"%s-macip not ready vni %u %s-mac %pEA lower seq %u f 0x%x",
 					sync ? "sync" : "rem", zevpn->vni,
-					n_type, &mac->macaddr, tmp_seq,
-					mac->flags);
+					n_type, &mac->macaddr, tmp_seq, mac->flags);
 			return true;
 		}
 
@@ -1660,10 +1562,9 @@ static inline bool zebra_evpn_mac_is_bgp_seq_ok(struct zebra_evpn *zevpn,
 			    IS_ZEBRA_DEBUG_VXLAN) {
 				zlog_debug(
 					"%s-macip accept vni %u %s-mac %pEA lower seq %u f %s",
-					sync ? "sync" : "rem", zevpn->vni,
-					n_type, &mac->macaddr, tmp_seq,
-					zebra_evpn_zebra_mac_flag_dump(
-						mac, mac_buf, sizeof(mac_buf)));
+					(sync ? "sync" : "rem"),
+					zevpn->vni, n_type, &mac->macaddr, tmp_seq,
+					zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 			}
 
 			return true;
@@ -1672,10 +1573,8 @@ static inline bool zebra_evpn_mac_is_bgp_seq_ok(struct zebra_evpn *zevpn,
 		if (IS_ZEBRA_DEBUG_EVPN_MH_MAC || IS_ZEBRA_DEBUG_VXLAN) {
 			zlog_debug(
 				"%s-macip ignore vni %u %s-mac %pEA as existing has higher seq %u f %s",
-				sync ? "sync" : "rem", zevpn->vni, n_type,
-				&mac->macaddr, tmp_seq,
-				zebra_evpn_zebra_mac_flag_dump(
-					mac, mac_buf, sizeof(mac_buf)));
+				(sync ? "sync" : "rem"), zevpn->vni, n_type, &mac->macaddr, tmp_seq,
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 		}
 
 		return false;
@@ -1749,9 +1648,7 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
 					"Ignore sync-macip vni %u mac %pEA%s%s%s%s",
 					zevpn->vni, macaddr,
 					ipa_len ? " IP " : "",
-					ipa_len ? ipaddr2str(ipaddr, ipbuf,
-							     sizeof(ipbuf))
-						: "",
+					ipa_len ? ipaddr2str(ipaddr, ipbuf, sizeof(ipbuf)) : "",
 					sticky ? " sticky" : "",
 					remote_gw ? " remote_gw" : "");
 			return NULL;
@@ -1766,16 +1663,16 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
 		new_flags = 0;
 		SET_FLAG(new_flags, ZEBRA_MAC_LOCAL);
 		/* retain old local activity flag */
-		if (old_flags & ZEBRA_MAC_LOCAL)
-			new_flags |= (old_flags & ZEBRA_MAC_LOCAL_INACTIVE);
+		if (CHECK_FLAG(old_flags, ZEBRA_MAC_LOCAL))
+			SET_FLAG (new_flags, CHECK_FLAG(old_flags, ZEBRA_MAC_LOCAL_INACTIVE));
 		else
-			new_flags |= ZEBRA_MAC_LOCAL_INACTIVE;
+			SET_FLAG(new_flags, ZEBRA_MAC_LOCAL_INACTIVE);
 
 		if (ipa_len) {
 			/* if mac-ip route do NOT update the peer flags
 			 * i.e. retain only flags as is
 			 */
-			new_flags |= (old_flags & ZEBRA_MAC_ALL_PEER_FLAGS);
+			SET_FLAG(new_flags, CHECK_FLAG(old_flags, ZEBRA_MAC_ALL_PEER_FLAGS));
 		} else {
 			/* if mac-only route update peer flags */
 			if (CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_PROXY_ADVERT)) {
@@ -1785,10 +1682,8 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
 				 * holdtimer on it. the peer-active flag is
 				 * cleared on holdtimer expiry.
 				 */
-				if (CHECK_FLAG(old_flags,
-					       ZEBRA_MAC_ES_PEER_ACTIVE)) {
-					SET_FLAG(new_flags,
-						 ZEBRA_MAC_ES_PEER_ACTIVE);
+				if (CHECK_FLAG(old_flags, ZEBRA_MAC_ES_PEER_ACTIVE)) {
+					SET_FLAG(new_flags, ZEBRA_MAC_ES_PEER_ACTIVE);
 					zebra_evpn_mac_start_hold_timer(mac);
 				}
 			} else {
@@ -1811,10 +1706,8 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
 			zlog_debug(
 				"sync-mac vni %u mac %pEA old_f %snew_f %s",
 				zevpn->vni, macaddr,
-				zebra_evpn_zebra_mac_flag_dump(
-					&omac, omac_buf, sizeof(omac_buf)),
-				zebra_evpn_zebra_mac_flag_dump(
-					mac, mac_buf, sizeof(mac_buf)));
+				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 */
@@ -1854,24 +1747,24 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
 		char mac_buf[MAC_BUF_SIZE];
 
 		zlog_debug("sync-mac %s vni %u mac %pEA es %s seq %d f %s%s%s",
-			   created ? "created" : "updated", zevpn->vni, macaddr,
-			   mac->es ? mac->es->esi_str : "-", mac->loc_seq,
-			   zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							  sizeof(mac_buf)),
-			   inform_bgp ? "inform_bgp" : "",
-			   inform_dataplane ? " inform_dp" : "");
+			created ? "created" : "updated",
+			zevpn->vni, macaddr,
+			mac->es ? mac->es->esi_str : "-",
+			mac->loc_seq,
+			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,
-						      new_bgp_ready);
+		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready, new_bgp_ready);
 
 	/* neighs using the mac may need to be re-sent to
 	 * bgp with updated info
 	 */
 	if (seq_change || es_change || !old_local)
 		zebra_evpn_process_neigh_on_local_mac_change(
-			zevpn, mac, seq_change, es_change);
+									zevpn, mac, seq_change, es_change);
 
 	if (inform_dataplane && !ipa_len) {
 		/* program the local mac in the kernel. when the ES
@@ -1879,9 +1772,8 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
 		 * the activity as we are yet to establish activity
 		 * locally
 		 */
-		zebra_evpn_sync_mac_dp_install(
-			mac, mac_inactive /* set_inactive */,
-			false /* force_clear_static */, __func__);
+		zebra_evpn_sync_mac_dp_install(mac, mac_inactive /* set_inactive */,
+									false /* force_clear_static */, __func__);
 	}
 
 	return mac;
@@ -1891,8 +1783,7 @@ struct zebra_mac *zebra_evpn_proc_sync_mac_update(struct zebra_evpn *zevpn,
  * is detected
  */
 static bool zebra_evpn_local_mac_update_fwd_info(struct zebra_mac *mac,
-						 struct interface *ifp,
-						 vlanid_t vid)
+						 struct interface *ifp, vlanid_t vid)
 {
 	struct zebra_if *zif = ifp->info;
 	bool es_change;
@@ -1934,8 +1825,8 @@ static void zebra_evpn_send_mac_hash_entry_to_client(struct hash_bucket *bucket,
 
 	if (CHECK_FLAG(zmac->flags, ZEBRA_MAC_LOCAL))
 		zebra_evpn_mac_send_add_to_client(wctx->zevpn->vni,
-						  &zmac->macaddr, zmac->flags,
-						  zmac->loc_seq, zmac->es);
+									&zmac->macaddr, zmac->flags,
+									zmac->loc_seq, zmac->es);
 }
 
 /* Iterator to Notify Local MACs of a EVPN */
@@ -1949,8 +1840,7 @@ void zebra_evpn_send_mac_list_to_client(struct zebra_evpn *zevpn)
 	memset(&wctx, 0, sizeof(wctx));
 	wctx.zevpn = zevpn;
 
-	hash_iterate(zevpn->mac_table, zebra_evpn_send_mac_hash_entry_to_client,
-		     &wctx);
+	hash_iterate(zevpn->mac_table, zebra_evpn_send_mac_hash_entry_to_client, &wctx);
 }
 
 void zebra_evpn_rem_mac_del(struct zebra_evpn *zevpn, struct zebra_mac *mac)
@@ -1992,8 +1882,7 @@ void zebra_evpn_print_dad_mac_hash(struct hash_bucket *bucket, void *ctxt)
 }
 
 /* Print Duplicate MAC in detail */
-void zebra_evpn_print_dad_mac_hash_detail(struct hash_bucket *bucket,
-					  void *ctxt)
+void zebra_evpn_print_dad_mac_hash_detail(struct hash_bucket *bucket, void *ctxt)
 {
 	struct zebra_mac *mac;
 
@@ -2043,11 +1932,13 @@ int zebra_evpn_mac_remote_macip_add(struct zebra_evpn *zevpn,
 	 * If so, that needs to be updated first. Note that client could
 	 * install MAC and MACIP separately or just install the latter.
 	 */
-	if (!mac || !CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)
-	    || sticky != !!CHECK_FLAG(mac->flags, ZEBRA_MAC_STICKY)
-	    || remote_gw != !!CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE_DEF_GW)
-	    || !IPV4_ADDR_SAME(&mac->fwd_info.r_vtep_ip, &vtep_ip)
-	    || memcmp(old_esi, esi, sizeof(esi_t)) || seq != mac->rem_seq)
+	if (!mac
+		|| !CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)
+		|| sticky != !!CHECK_FLAG(mac->flags, ZEBRA_MAC_STICKY)
+		|| remote_gw != !!CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE_DEF_GW)
+		|| !IPV4_ADDR_SAME(&mac->fwd_info.r_vtep_ip, &vtep_ip)
+		|| memcmp(old_esi, esi, sizeof(esi_t))
+		|| seq != mac->rem_seq)
 		update_mac = 1;
 
 	if (update_mac) {
@@ -2063,8 +1954,7 @@ int zebra_evpn_mac_remote_macip_add(struct zebra_evpn *zevpn,
 			 * the sequence number and ignore this update
 			 * if appropriate.
 			 */
-			if (!zebra_evpn_mac_is_bgp_seq_ok(zevpn, mac, seq,
-							  false))
+			if (!zebra_evpn_mac_is_bgp_seq_ok(zevpn, mac, seq, false))
 				return -1;
 
 			old_es_present = !!mac->es;
@@ -2091,8 +1981,7 @@ int zebra_evpn_mac_remote_macip_add(struct zebra_evpn *zevpn,
 		 * MAC is already marked duplicate set dad, then
 		 * is_dup_detect will be set to not install the entry.
 		 */
-		if ((!CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)
-		     && mac->dad_count)
+		if ((!CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE) && mac->dad_count)
 		    || CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
 			do_dad = true;
 
@@ -2108,14 +1997,12 @@ int zebra_evpn_mac_remote_macip_add(struct zebra_evpn *zevpn,
 					zevpn->vni, macaddr,
 					mac->es ? mac->es->esi_str : "-",
 					mac->loc_seq,
-					zebra_evpn_zebra_mac_flag_dump(
-						mac, mac_buf, sizeof(mac_buf)));
+					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,
-							  false /* force */);
+			zebra_evpn_mac_send_del_to_client(zevpn->vni, macaddr, mac->flags,
+										false /* force */);
 		}
 
 		/* Set "auto" and "remote" forwarding info. */
@@ -2135,8 +2022,7 @@ int zebra_evpn_mac_remote_macip_add(struct zebra_evpn *zevpn,
 			UNSET_FLAG(mac->flags, ZEBRA_MAC_REMOTE_DEF_GW);
 
 		zebra_evpn_dup_addr_detect_for_mac(
-			zvrf, mac, mac->fwd_info.r_vtep_ip, do_dad,
-			&is_dup_detect, false);
+			zvrf, mac, mac->fwd_info.r_vtep_ip, do_dad, &is_dup_detect, false);
 
 		if (!is_dup_detect) {
 			zebra_evpn_process_neigh_on_remote_mac_add(zevpn, mac);
@@ -2180,8 +2066,8 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 		if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
 			zlog_debug(
 				"ADD %sMAC %pEA intf %s(%u) VID %u -> VNI %u%s",
-				sticky ? "sticky " : "", macaddr,
-				ifp->name, ifp->ifindex, vid, zevpn->vni,
+				sticky ? "sticky " : "",
+				macaddr, ifp->name, ifp->ifindex, vid, zevpn->vni,
 				local_inactive ? " local-inactive" : "");
 
 		mac = zebra_evpn_mac_add(zevpn, macaddr);
@@ -2196,11 +2082,10 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 
 			zlog_debug(
 				"UPD %sMAC %pEA intf %s(%u) VID %u -> VNI %u %scurFlags %s",
-				sticky ? "sticky " : "", macaddr,
-				ifp->name, ifp->ifindex, vid, zevpn->vni,
+				sticky ? "sticky " : "",
+				macaddr, ifp->name, ifp->ifindex, vid, zevpn->vni,
 				local_inactive ? "local-inactive " : "",
-				zebra_evpn_zebra_mac_flag_dump(
-					mac, mac_buf, sizeof(mac_buf)));
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)));
 		}
 
 		if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
@@ -2209,42 +2094,34 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 			bool old_static;
 
 			zebra_evpn_mac_get_access_info(mac, &old_ifp, &old_vid);
-			old_bgp_ready =
-				zebra_evpn_mac_is_ready_for_bgp(mac->flags);
-			old_local_inactive =
-				!!(mac->flags & ZEBRA_MAC_LOCAL_INACTIVE);
+			old_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
+			old_local_inactive = !!(mac->flags & ZEBRA_MAC_LOCAL_INACTIVE);
 			old_static = zebra_evpn_mac_is_static(mac);
 			if (CHECK_FLAG(mac->flags, ZEBRA_MAC_STICKY))
 				mac_sticky = true;
-			es_change = zebra_evpn_local_mac_update_fwd_info(
-				mac, ifp, vid);
+			es_change = zebra_evpn_local_mac_update_fwd_info(mac, ifp, vid);
 
 			/*
 			 * Update any changes and if changes are relevant to
 			 * BGP, note it.
 			 */
-			if (mac_sticky == sticky && old_ifp == ifp
-			    && old_vid == vid
-			    && old_local_inactive == local_inactive
-			    && dp_static == old_static && !es_change) {
+			if (mac_sticky == sticky && old_ifp == ifp && old_vid == vid
+				&& old_local_inactive == local_inactive
+				&& dp_static == old_static && !es_change) {
 				if (IS_ZEBRA_DEBUG_VXLAN)
 					zlog_debug(
 						"        Add/Update %sMAC %pEA intf %s(%u) VID %u -> VNI %u%s, "
 						"entry exists and has not changed ",
 						sticky ? "sticky " : "",
-						macaddr, ifp->name,
-						ifp->ifindex, vid, zevpn->vni,
-						local_inactive
-							? " local_inactive"
-							: "");
+						macaddr, ifp->name, ifp->ifindex, vid, zevpn->vni,
+						local_inactive ? " local_inactive" : "");
 				return 0;
 			}
 			if (mac_sticky != sticky) {
 				if (sticky)
 					SET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
 				else
-					UNSET_FLAG(mac->flags,
-						   ZEBRA_MAC_STICKY);
+					UNSET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
 				inform_client = true;
 			}
 
@@ -2262,11 +2139,9 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 				/* force drop the peer/sync info as it is
 				 * simply no longer relevant
 				 */
-				if (CHECK_FLAG(mac->flags,
-					       ZEBRA_MAC_ALL_PEER_FLAGS)) {
+				if (CHECK_FLAG(mac->flags, ZEBRA_MAC_ALL_PEER_FLAGS)) {
 					zebra_evpn_mac_clear_sync_info(mac);
-					new_static =
-						zebra_evpn_mac_is_static(mac);
+					new_static = zebra_evpn_mac_is_static(mac);
 					/* if we clear peer-flags we
 					 * also need to notify the dataplane
 					 * to drop the static flag
@@ -2289,16 +2164,13 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 				flog_warn(
 					EC_ZEBRA_STICKY_MAC_ALREADY_LEARNT,
 					"MAC %pEA already learnt as remote sticky MAC behind VTEP %pI4 VNI %u",
-					macaddr,
-					&mac->fwd_info.r_vtep_ip,
-					zevpn->vni);
+					macaddr, &mac->fwd_info.r_vtep_ip, zevpn->vni);
 				return 0;
 			}
 
 			/* If an actual move, compute MAC's seq number */
 			if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
-				mac->loc_seq =
-					MAX(mac->rem_seq + 1, mac->loc_seq);
+				mac->loc_seq = MAX(mac->rem_seq + 1, mac->loc_seq);
 				vtep_ip = mac->fwd_info.r_vtep_ip;
 				/* Trigger DAD for remote MAC */
 				do_dad = true;
@@ -2307,8 +2179,7 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 			UNSET_FLAG(mac->flags, ZEBRA_MAC_REMOTE);
 			UNSET_FLAG(mac->flags, ZEBRA_MAC_AUTO);
 			SET_FLAG(mac->flags, ZEBRA_MAC_LOCAL);
-			es_change = zebra_evpn_local_mac_update_fwd_info(
-				mac, ifp, vid);
+			es_change = zebra_evpn_local_mac_update_fwd_info(mac, ifp, vid);
 			if (sticky)
 				SET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
 			else
@@ -2321,8 +2192,7 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 			upd_neigh = true;
 
 			zebra_evpn_dup_addr_detect_for_mac(
-				zvrf, mac, vtep_ip, do_dad, &is_dup_detect,
-				true);
+							zvrf, mac, vtep_ip, do_dad, &is_dup_detect, true);
 			if (is_dup_detect) {
 				inform_client = false;
 				upd_neigh = false;
@@ -2357,8 +2227,7 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 				"local mac vni %u mac %pEA es %s seq %d f %s%s",
 				zevpn->vni, macaddr,
 				mac->es ? mac->es->esi_str : "", mac->loc_seq,
-				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf,
-							       sizeof(mac_buf)),
+				zebra_evpn_zebra_mac_flag_dump(mac, mac_buf, sizeof(mac_buf)),
 				local_inactive ? "local-inactive" : "");
 		}
 
@@ -2374,18 +2243,15 @@ int zebra_evpn_add_update_local_mac(struct zebra_vrf *zvrf,
 	/* Inform dataplane if required. */
 	if (inform_dataplane)
 		zebra_evpn_sync_mac_dp_install(mac, false /* set_inactive */,
-					       false /* force_clear_static */,
-					       __func__);
+					       false /* force_clear_static */, __func__);
 
 	/* Inform BGP if required. */
 	if (inform_client)
-		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready,
-						      new_bgp_ready);
+		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready, new_bgp_ready);
 
 	/* Process all neighbors associated with this MAC, if required. */
 	if (upd_neigh)
-		zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
-							     es_change);
+		zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0, es_change);
 
 	return 0;
 }
@@ -2415,23 +2281,20 @@ int zebra_evpn_del_local_mac(struct zebra_evpn *zevpn, struct zebra_mac *mac,
 				"re-add sync-mac vni %u mac %pEA es %s seq %d f %s",
 				zevpn->vni, &mac->macaddr,
 				mac->es ? mac->es->esi_str : "-", mac->loc_seq,
-				zebra_evpn_zebra_mac_flag_dump(
-					mac, mac_buf, sizeof(mac_buf)));
+				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)) {
 			SET_FLAG(mac->flags, ZEBRA_MAC_LOCAL_INACTIVE);
-			new_bgp_ready =
-				zebra_evpn_mac_is_ready_for_bgp(mac->flags);
+			new_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
 			zebra_evpn_mac_send_add_del_to_client(
-				mac, old_bgp_ready, new_bgp_ready);
+											mac, old_bgp_ready, new_bgp_ready);
 		}
 
 		/* re-install the inactive entry in the kernel */
 		zebra_evpn_sync_mac_dp_install(mac, true /* set_inactive */,
-					       false /* force_clear_static */,
-					       __func__);
+					       false /* force_clear_static */, __func__);
 
 		return 0;
 	}
@@ -2519,8 +2382,7 @@ void zebra_evpn_mac_svi_del(struct interface *ifp, struct zebra_evpn *zevpn)
 
 		old_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
 		UNSET_FLAG(mac->flags, ZEBRA_MAC_SVI);
-		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready,
-						      false);
+		zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready, false);
 		zebra_evpn_deref_ip2mac(mac->zevpn, mac);
 	}
 }
@@ -2548,13 +2410,11 @@ void zebra_evpn_mac_svi_add(struct interface *ifp, struct zebra_evpn *zevpn)
 	if (IS_ZEBRA_DEBUG_EVPN_MH_ES)
 		zlog_debug("SVI %s mac add", zif->ifp->name);
 
-	old_bgp_ready = (mac && zebra_evpn_mac_is_ready_for_bgp(mac->flags))
-				? true
-				: false;
+	old_bgp_ready =
+		(mac && zebra_evpn_mac_is_ready_for_bgp(mac->flags)) ? true : false;
 
 	zebra_evpn_mac_gw_macip_add(ifp, zevpn, NULL, &mac, &macaddr, 0, false);
 
 	new_bgp_ready = zebra_evpn_mac_is_ready_for_bgp(mac->flags);
-	zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready,
-					      new_bgp_ready);
+	zebra_evpn_mac_send_add_del_to_client(mac, old_bgp_ready, new_bgp_ready);
 }