2 * Zebra EVPN Neighbor code
3 * Copyright (C) 2016, 2017 Cumulus Networks, Inc.
5 * This file is part of FRR.
7 * FRR is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * FRR is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with FRR; see the file COPYING. If not, write to the Free
19 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include "interface.h"
33 #include "zebra/zserv.h"
34 #include "zebra/debug.h"
35 #include "zebra/zebra_router.h"
37 #include "zebra/zebra_errors.h"
38 #include "zebra/zebra_vrf.h"
39 #include "zebra/zebra_evpn.h"
40 #include "zebra/zebra_evpn_mh.h"
41 #include "zebra/zebra_evpn_neigh.h"
42 #include "zebra/zebra_evpn_mac.h"
44 DEFINE_MTYPE_STATIC(ZEBRA
, NEIGH
, "EVI Neighbor");
47 * Make hash key for neighbors.
49 static unsigned int neigh_hash_keymake(const void *p
)
51 const struct zebra_neigh
*n
= p
;
52 const struct ipaddr
*ip
= &n
->ip
;
55 return jhash_1word(ip
->ipaddr_v4
.s_addr
, 0);
57 return jhash2(ip
->ipaddr_v6
.s6_addr32
,
58 array_size(ip
->ipaddr_v6
.s6_addr32
), 0);
62 * Compare two neighbor hash structures.
64 static bool neigh_cmp(const void *p1
, const void *p2
)
66 const struct zebra_neigh
*n1
= p1
;
67 const struct zebra_neigh
*n2
= p2
;
69 if (n1
== NULL
&& n2
== NULL
)
72 if (n1
== NULL
|| n2
== NULL
)
75 return ipaddr_cmp(&n1
->ip
, &n2
->ip
) == 0;
78 int neigh_list_cmp(void *p1
, void *p2
)
80 const struct zebra_neigh
*n1
= p1
;
81 const struct zebra_neigh
*n2
= p2
;
83 return ipaddr_cmp(&n1
->ip
, &n2
->ip
);
86 struct hash
*zebra_neigh_db_create(const char *desc
)
88 return hash_create_size(8, neigh_hash_keymake
, neigh_cmp
, desc
);
91 uint32_t num_dup_detected_neighs(struct zebra_evpn
*zevpn
)
94 uint32_t num_neighs
= 0;
96 struct hash_bucket
*hb
;
97 struct zebra_neigh
*nbr
;
99 hash
= zevpn
->neigh_table
;
102 for (i
= 0; i
< hash
->size
; i
++) {
103 for (hb
= hash
->index
[i
]; hb
; hb
= hb
->next
) {
104 nbr
= (struct zebra_neigh
*)hb
->data
;
105 if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
))
114 * Helper function to determine maximum width of neighbor IP address for
115 * display - just because we're dealing with IPv6 addresses that can
118 void zebra_evpn_find_neigh_addr_width(struct hash_bucket
*bucket
, void *ctxt
)
120 struct zebra_neigh
*n
;
121 char buf
[INET6_ADDRSTRLEN
];
122 struct neigh_walk_ctx
*wctx
= ctxt
;
125 n
= (struct zebra_neigh
*)bucket
->data
;
127 ipaddr2str(&n
->ip
, buf
, sizeof(buf
));
129 if (width
> wctx
->addr_width
)
130 wctx
->addr_width
= width
;
134 * Count of remote neighbors referencing this MAC.
136 int remote_neigh_count(struct zebra_mac
*zmac
)
138 struct zebra_neigh
*n
= NULL
;
139 struct listnode
*node
= NULL
;
142 for (ALL_LIST_ELEMENTS_RO(zmac
->neigh_list
, node
, n
)) {
143 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
))
151 * Install remote neighbor into the kernel.
153 int zebra_evpn_rem_neigh_install(struct zebra_evpn
*zevpn
,
154 struct zebra_neigh
*n
, bool was_static
)
156 struct interface
*vlan_if
;
160 if (!(n
->flags
& ZEBRA_NEIGH_REMOTE
))
163 vlan_if
= zevpn_map_to_svi(zevpn
);
167 flags
= DPLANE_NTF_EXT_LEARNED
;
168 if (n
->flags
& ZEBRA_NEIGH_ROUTER_FLAG
)
169 flags
|= DPLANE_NTF_ROUTER
;
170 ZEBRA_NEIGH_SET_ACTIVE(n
);
172 dplane_rem_neigh_add(vlan_if
, &n
->ip
, &n
->emac
, flags
, was_static
);
178 * Install neighbor hash entry - called upon access VLAN change.
180 void zebra_evpn_install_neigh_hash(struct hash_bucket
*bucket
, void *ctxt
)
182 struct zebra_neigh
*n
;
183 struct neigh_walk_ctx
*wctx
= ctxt
;
185 n
= (struct zebra_neigh
*)bucket
->data
;
187 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
))
188 zebra_evpn_rem_neigh_install(wctx
->zevpn
, n
,
189 false /*was_static*/);
193 * Callback to allocate neighbor hash entry.
195 static void *zebra_evpn_neigh_alloc(void *p
)
197 const struct zebra_neigh
*tmp_n
= p
;
198 struct zebra_neigh
*n
;
200 n
= XCALLOC(MTYPE_NEIGH
, sizeof(struct zebra_neigh
));
206 static void zebra_evpn_local_neigh_ref_mac(struct zebra_neigh
*n
,
207 const struct ethaddr
*macaddr
,
208 struct zebra_mac
*mac
,
209 bool send_mac_update
)
214 memcpy(&n
->emac
, macaddr
, ETH_ALEN
);
217 /* Link to new MAC */
221 listnode_add_sort(mac
->neigh_list
, n
);
222 if (n
->flags
& ZEBRA_NEIGH_ALL_PEER_FLAGS
) {
223 old_static
= zebra_evpn_mac_is_static(mac
);
224 ++mac
->sync_neigh_cnt
;
225 new_static
= zebra_evpn_mac_is_static(mac
);
226 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
228 "sync-neigh ref mac vni %u ip %pIA mac %pEA ref %d",
229 n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
230 mac
->sync_neigh_cnt
);
231 if ((old_static
!= new_static
) && send_mac_update
)
232 /* program the local mac in the kernel */
233 zebra_evpn_sync_mac_dp_install(
234 mac
, false /*set_inactive*/,
235 false /*force_clear_static*/, __func__
);
239 /* sync-path that is active on an ES peer */
240 static void zebra_evpn_sync_neigh_dp_install(struct zebra_neigh
*n
,
242 bool force_clear_static
,
245 struct zebra_ns
*zns
;
246 struct interface
*ifp
;
250 zns
= zebra_ns_lookup(NS_DEFAULT
);
251 ifp
= if_lookup_by_index_per_ns(zns
, n
->ifindex
);
253 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
255 "%s: dp-install sync-neigh vni %u ip %pIA mac %pEA if %d f 0x%x skipped",
256 caller
, n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
257 n
->ifindex
, n
->flags
);
261 if (force_clear_static
)
264 set_static
= zebra_evpn_neigh_is_static(n
);
266 set_router
= !!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
268 /* XXX - this will change post integration with the new kernel */
269 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
))
272 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
274 "%s: dp-install sync-neigh vni %u ip %pIA mac %pEA if %s(%d) f 0x%x%s%s%s",
275 caller
, n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
276 ifp
->name
, n
->ifindex
, n
->flags
,
277 set_router
? " router" : "",
278 set_static
? " static" : "",
279 set_inactive
? " inactive" : "");
280 dplane_local_neigh_add(ifp
, &n
->ip
, &n
->emac
, set_router
, set_static
,
285 * Inform BGP about local neighbor addition.
287 int zebra_evpn_neigh_send_add_to_client(vni_t vni
, const struct ipaddr
*ip
,
288 const struct ethaddr
*macaddr
,
289 struct zebra_mac
*zmac
,
290 uint32_t neigh_flags
, uint32_t seq
)
294 if (CHECK_FLAG(neigh_flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
)) {
295 /* host reachability has not been verified locally */
297 /* if no ES peer is claiming reachability we can't advertise
300 if (!CHECK_FLAG(neigh_flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
))
303 /* ES peers are claiming reachability; we will
304 * advertise the entry but with a proxy flag
306 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_PROXY_ADVERT
);
309 if (CHECK_FLAG(neigh_flags
, ZEBRA_NEIGH_DEF_GW
))
310 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
311 /* Set router flag (R-bit) based on local neigh entry add */
312 if (CHECK_FLAG(neigh_flags
, ZEBRA_NEIGH_ROUTER_FLAG
))
313 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
314 if (CHECK_FLAG(neigh_flags
, ZEBRA_NEIGH_SVI_IP
))
315 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_SVI_IP
);
317 return zebra_evpn_macip_send_msg_to_client(vni
, macaddr
, ip
, flags
, seq
,
318 ZEBRA_NEIGH_ACTIVE
, zmac
->es
,
323 * Inform BGP about local neighbor deletion.
325 int zebra_evpn_neigh_send_del_to_client(vni_t vni
, struct ipaddr
*ip
,
326 struct ethaddr
*macaddr
, uint32_t flags
,
327 int state
, bool force
)
330 if (CHECK_FLAG(flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
)
331 && !CHECK_FLAG(flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
))
332 /* the neigh was not advertised - nothing to delete */
336 return zebra_evpn_macip_send_msg_to_client(
337 vni
, macaddr
, ip
, flags
, 0, state
, NULL
, ZEBRA_MACIP_DEL
);
340 static void zebra_evpn_neigh_send_add_del_to_client(struct zebra_neigh
*n
,
345 zebra_evpn_neigh_send_add_to_client(n
->zevpn
->vni
, &n
->ip
,
346 &n
->emac
, n
->mac
, n
->flags
,
348 else if (old_bgp_ready
)
349 zebra_evpn_neigh_send_del_to_client(n
->zevpn
->vni
, &n
->ip
,
351 n
->state
, true /*force*/);
354 /* if the static flag associated with the neigh changes we need
355 * to update the sync-neigh references against the MAC
356 * and inform the dataplane about the static flag changes.
358 void zebra_evpn_sync_neigh_static_chg(struct zebra_neigh
*n
, bool old_n_static
,
359 bool new_n_static
, bool defer_n_dp
,
360 bool defer_mac_dp
, const char *caller
)
362 struct zebra_mac
*mac
= n
->mac
;
366 if (old_n_static
== new_n_static
)
369 /* update the neigh sync references in the dataplane. if
370 * the neigh is in the middle of updates the caller can
371 * request for a defer
374 zebra_evpn_sync_neigh_dp_install(n
, false /* set_inactive */,
375 false /* force_clear_static */,
381 /* update the mac sync ref cnt */
382 old_mac_static
= zebra_evpn_mac_is_static(mac
);
384 ++mac
->sync_neigh_cnt
;
385 } else if (old_n_static
) {
386 if (mac
->sync_neigh_cnt
)
387 --mac
->sync_neigh_cnt
;
389 new_mac_static
= zebra_evpn_mac_is_static(mac
);
391 /* update the mac sync references in the dataplane */
392 if ((old_mac_static
!= new_mac_static
) && !defer_mac_dp
)
393 zebra_evpn_sync_mac_dp_install(mac
, false /* set_inactive */,
394 false /* force_clear_static */,
397 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
399 "sync-neigh ref-chg vni %u ip %pIA mac %pEA f 0x%x %d%s%s%s%s by %s",
400 n
->zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
402 old_n_static
? " old_n_static" : "",
403 new_n_static
? " new_n_static" : "",
404 old_mac_static
? " old_mac_static" : "",
405 new_mac_static
? " new_mac_static" : "", caller
);
408 /* Neigh hold timer is used to age out peer-active flag.
410 * During this wait time we expect the dataplane component or an
411 * external neighmgr daemon to probe existing hosts to independently
412 * establish their presence on the ES.
414 static void zebra_evpn_neigh_hold_exp_cb(struct thread
*t
)
416 struct zebra_neigh
*n
;
423 /* the purpose of the hold timer is to age out the peer-active
426 if (!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
))
429 old_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
430 old_n_static
= zebra_evpn_neigh_is_static(n
);
431 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
);
432 new_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
433 new_n_static
= zebra_evpn_neigh_is_static(n
);
435 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
436 zlog_debug("sync-neigh vni %u ip %pIA mac %pEA 0x%x hold expired",
437 n
->zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
);
439 /* re-program the local neigh in the dataplane if the neigh is no
442 if (old_n_static
!= new_n_static
)
443 zebra_evpn_sync_neigh_static_chg(
444 n
, old_n_static
, new_n_static
, false /*defer_n_dp*/,
445 false /*defer_mac_dp*/, __func__
);
447 /* inform bgp if needed */
448 if (old_bgp_ready
!= new_bgp_ready
)
449 zebra_evpn_neigh_send_add_del_to_client(n
, old_bgp_ready
,
453 static inline void zebra_evpn_neigh_start_hold_timer(struct zebra_neigh
*n
)
458 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
459 zlog_debug("sync-neigh vni %u ip %pIA mac %pEA 0x%x hold start",
460 n
->zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
);
461 thread_add_timer(zrouter
.master
, zebra_evpn_neigh_hold_exp_cb
, n
,
462 zmh_info
->neigh_hold_time
, &n
->hold_timer
);
465 static void zebra_evpn_local_neigh_deref_mac(struct zebra_neigh
*n
,
466 bool send_mac_update
)
468 struct zebra_mac
*mac
= n
->mac
;
469 struct zebra_evpn
*zevpn
= n
->zevpn
;
477 if ((n
->flags
& ZEBRA_NEIGH_ALL_PEER_FLAGS
) && mac
->sync_neigh_cnt
) {
478 old_static
= zebra_evpn_mac_is_static(mac
);
479 --mac
->sync_neigh_cnt
;
480 new_static
= zebra_evpn_mac_is_static(mac
);
481 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
483 "sync-neigh deref mac vni %u ip %pIA mac %pEA ref %d",
484 n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
485 mac
->sync_neigh_cnt
);
486 if ((old_static
!= new_static
) && send_mac_update
)
487 /* program the local mac in the kernel */
488 zebra_evpn_sync_mac_dp_install(
489 mac
, false /* set_inactive */,
490 false /* force_clear_static */, __func__
);
493 listnode_delete(mac
->neigh_list
, n
);
494 zebra_evpn_deref_ip2mac(zevpn
, mac
);
497 bool zebra_evpn_neigh_is_bgp_seq_ok(struct zebra_evpn
*zevpn
,
498 struct zebra_neigh
*n
,
499 const struct ethaddr
*macaddr
, uint32_t seq
,
505 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
506 tmp_seq
= n
->loc_seq
;
509 tmp_seq
= n
->rem_seq
;
514 /* if the neigh was never advertised to bgp we must accept
515 * whatever sequence number bgp sends
516 * XXX - check with Vivek
518 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)
519 && !zebra_evpn_neigh_is_ready_for_bgp(n
)) {
520 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
521 || IS_ZEBRA_DEBUG_VXLAN
)
523 "%s-macip accept vni %u %s mac %pEA IP %pIA lower seq %u f 0x%x",
524 sync
? "sync" : "remote", zevpn
->vni
,
525 n_type
, macaddr
, &n
->ip
,
530 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
|| IS_ZEBRA_DEBUG_VXLAN
)
532 "%s-macip ignore vni %u %s mac %pEA IP %pIA as existing has higher seq %u f 0x%x",
533 sync
? "sync" : "remote", zevpn
->vni
, n_type
,
534 macaddr
, &n
->ip
, tmp_seq
, n
->flags
);
542 * Add neighbor entry.
544 static struct zebra_neigh
*zebra_evpn_neigh_add(struct zebra_evpn
*zevpn
,
545 const struct ipaddr
*ip
,
546 const struct ethaddr
*mac
,
547 struct zebra_mac
*zmac
,
550 struct zebra_neigh tmp_n
;
551 struct zebra_neigh
*n
= NULL
;
553 memset(&tmp_n
, 0, sizeof(struct zebra_neigh
));
554 memcpy(&tmp_n
.ip
, ip
, sizeof(struct ipaddr
));
555 n
= hash_get(zevpn
->neigh_table
, &tmp_n
, zebra_evpn_neigh_alloc
);
558 n
->state
= ZEBRA_NEIGH_INACTIVE
;
560 n
->dad_ip_auto_recovery_timer
= NULL
;
562 n
->uptime
= monotime(NULL
);
565 zmac
= zebra_evpn_mac_lookup(zevpn
, mac
);
566 zebra_evpn_local_neigh_ref_mac(n
, mac
, zmac
,
567 false /* send_mac_update */);
573 * Delete neighbor entry.
575 int zebra_evpn_neigh_del(struct zebra_evpn
*zevpn
, struct zebra_neigh
*n
)
577 struct zebra_neigh
*tmp_n
;
580 listnode_delete(n
->mac
->neigh_list
, n
);
582 /* Cancel auto recovery */
583 THREAD_OFF(n
->dad_ip_auto_recovery_timer
);
585 /* Cancel proxy hold timer */
586 zebra_evpn_neigh_stop_hold_timer(n
);
588 /* Free the VNI hash entry and allocated memory. */
589 tmp_n
= hash_release(zevpn
->neigh_table
, n
);
590 XFREE(MTYPE_NEIGH
, tmp_n
);
595 void zebra_evpn_sync_neigh_del(struct zebra_neigh
*n
)
600 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
601 zlog_debug("sync-neigh del vni %u ip %pIA mac %pEA f 0x%x",
602 n
->zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
);
604 old_n_static
= zebra_evpn_neigh_is_static(n
);
605 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_PROXY
);
606 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
))
607 zebra_evpn_neigh_start_hold_timer(n
);
608 new_n_static
= zebra_evpn_neigh_is_static(n
);
610 if (old_n_static
!= new_n_static
)
611 zebra_evpn_sync_neigh_static_chg(
612 n
, old_n_static
, new_n_static
, false /*defer-dp*/,
613 false /*defer_mac_dp*/, __func__
);
616 struct zebra_neigh
*zebra_evpn_proc_sync_neigh_update(
617 struct zebra_evpn
*zevpn
, struct zebra_neigh
*n
, uint16_t ipa_len
,
618 const struct ipaddr
*ipaddr
, uint8_t flags
, uint32_t seq
,
619 const esi_t
*esi
, struct sync_mac_ip_ctx
*ctx
)
621 struct interface
*ifp
= NULL
;
623 struct zebra_mac
*mac
= ctx
->mac
;
625 bool old_router
= false;
626 bool old_bgp_ready
= false;
628 bool inform_dataplane
= false;
629 bool inform_bgp
= false;
632 bool set_dp_inactive
= false;
634 ifindex_t ifindex
= 0;
637 ifp
= zevpn_map_to_svi(zevpn
);
639 ifindex
= ifp
->ifindex
;
641 is_router
= !!CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
642 old_mac_static
= zebra_evpn_mac_is_static(mac
);
645 uint32_t n_flags
= 0;
647 /* New neighbor - create */
648 SET_FLAG(n_flags
, ZEBRA_NEIGH_LOCAL
);
649 if (CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_PROXY_ADVERT
))
650 SET_FLAG(n_flags
, ZEBRA_NEIGH_ES_PEER_PROXY
);
652 SET_FLAG(n_flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
);
653 SET_FLAG(n_flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
);
655 n
= zebra_evpn_neigh_add(zevpn
, ipaddr
, &mac
->macaddr
, mac
,
657 n
->ifindex
= ifindex
;
658 ZEBRA_NEIGH_SET_ACTIVE(n
);
661 inform_dataplane
= true;
663 set_dp_inactive
= true;
666 uint32_t old_flags
= n
->flags
;
671 old_n_static
= zebra_evpn_neigh_is_static(n
);
672 old_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
673 old_router
= !!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
675 mac_change
= !!memcmp(&n
->emac
, &mac
->macaddr
, ETH_ALEN
);
677 /* deref and clear old info */
680 zebra_evpn_neigh_send_del_to_client(
681 zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
682 n
->state
, false /*force*/);
683 old_bgp_ready
= false;
685 zebra_evpn_local_neigh_deref_mac(n
,
686 false /*send_mac_update*/);
688 /* clear old fwd info */
690 n
->r_vtep_ip
.s_addr
= 0;
692 /* setup new flags */
694 SET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
);
695 /* retain activity flag if the neigh was
698 if (old_flags
& ZEBRA_NEIGH_LOCAL
) {
699 n
->flags
|= (old_flags
& ZEBRA_NEIGH_LOCAL_INACTIVE
);
701 inform_dataplane
= true;
702 set_dp_inactive
= true;
703 n
->flags
|= ZEBRA_NEIGH_LOCAL_INACTIVE
;
706 if (CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_PROXY_ADVERT
))
707 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_PROXY
);
709 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
);
711 if (CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_PROXY_ADVERT
)) {
712 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_PROXY
);
713 /* if the neigh was peer-active previously we
714 * need to keep the flag and start the
715 * holdtimer on it. the peer-active flag is
716 * cleared on holdtimer expiry.
718 if (CHECK_FLAG(old_flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
)) {
719 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
);
720 zebra_evpn_neigh_start_hold_timer(n
);
723 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
);
724 /* stop hold timer if a peer has verified
727 zebra_evpn_neigh_stop_hold_timer(n
);
729 ZEBRA_NEIGH_SET_ACTIVE(n
);
731 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
&& (old_flags
!= n
->flags
))
733 "sync-neigh vni %u ip %pIA mac %pEA old_f 0x%x new_f 0x%x",
734 n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
735 old_flags
, n
->flags
);
737 new_n_static
= zebra_evpn_neigh_is_static(n
);
739 set_dp_inactive
= true;
740 n
->flags
|= ZEBRA_NEIGH_LOCAL_INACTIVE
;
741 inform_dataplane
= true;
742 zebra_evpn_local_neigh_ref_mac(
743 n
, &mac
->macaddr
, mac
,
744 false /*send_mac_update*/);
745 } else if (old_n_static
!= new_n_static
) {
746 inform_dataplane
= true;
747 /* if static flags have changed without a mac change
748 * we need to create the correct sync-refs against
751 zebra_evpn_sync_neigh_static_chg(
752 n
, old_n_static
, new_n_static
,
753 true /*defer_dp*/, true /*defer_mac_dp*/,
757 /* Update the forwarding info. */
758 if (n
->ifindex
!= ifindex
) {
759 n
->ifindex
= ifindex
;
760 inform_dataplane
= true;
763 n
->uptime
= monotime(NULL
);
766 /* update the neigh seq. we don't bother with the mac seq as
767 * sync_mac_update already took care of that
769 tmp_seq
= MAX(n
->loc_seq
, seq
);
770 if (tmp_seq
!= n
->loc_seq
) {
771 n
->loc_seq
= tmp_seq
;
775 /* Mark Router flag (R-bit) */
777 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
779 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
781 if (old_router
!= is_router
)
782 inform_dataplane
= true;
784 new_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
785 if (old_bgp_ready
!= new_bgp_ready
)
788 new_mac_static
= zebra_evpn_mac_is_static(mac
);
789 if ((old_mac_static
!= new_mac_static
) || ctx
->mac_dp_update_deferred
)
790 zebra_evpn_sync_mac_dp_install(mac
, ctx
->mac_inactive
,
791 false /* force_clear_static */,
794 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
796 "sync-neigh %s vni %u ip %pIA mac %pEA if %s(%d) seq %d f 0x%x%s%s",
797 created
? "created" : "updated", n
->zevpn
->vni
,
799 ifp
? ifp
->name
: "", ifindex
, n
->loc_seq
, n
->flags
,
800 inform_bgp
? " inform_bgp" : "",
801 inform_dataplane
? " inform_dp" : "");
803 if (inform_dataplane
)
804 zebra_evpn_sync_neigh_dp_install(n
, set_dp_inactive
,
805 false /* force_clear_static */,
809 zebra_evpn_neigh_send_add_del_to_client(n
, old_bgp_ready
,
816 * Uninstall remote neighbor from the kernel.
818 static int zebra_evpn_neigh_uninstall(struct zebra_evpn
*zevpn
,
819 struct zebra_neigh
*n
)
821 struct interface
*vlan_if
;
823 if (!(n
->flags
& ZEBRA_NEIGH_REMOTE
))
826 vlan_if
= zevpn_map_to_svi(zevpn
);
830 ZEBRA_NEIGH_SET_INACTIVE(n
);
833 dplane_rem_neigh_delete(vlan_if
, &n
->ip
);
839 * Free neighbor hash entry (callback)
841 static void zebra_evpn_neigh_del_hash_entry(struct hash_bucket
*bucket
,
844 struct neigh_walk_ctx
*wctx
= arg
;
845 struct zebra_neigh
*n
= bucket
->data
;
847 if (((wctx
->flags
& DEL_LOCAL_NEIGH
) && (n
->flags
& ZEBRA_NEIGH_LOCAL
))
848 || ((wctx
->flags
& DEL_REMOTE_NEIGH
)
849 && (n
->flags
& ZEBRA_NEIGH_REMOTE
))
850 || ((wctx
->flags
& DEL_REMOTE_NEIGH_FROM_VTEP
)
851 && (n
->flags
& ZEBRA_NEIGH_REMOTE
)
852 && IPV4_ADDR_SAME(&n
->r_vtep_ip
, &wctx
->r_vtep_ip
))) {
853 if (wctx
->upd_client
&& (n
->flags
& ZEBRA_NEIGH_LOCAL
))
854 zebra_evpn_neigh_send_del_to_client(
855 wctx
->zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
856 n
->state
, false /*force*/);
858 if (wctx
->uninstall
) {
859 if (zebra_evpn_neigh_is_static(n
))
860 zebra_evpn_sync_neigh_dp_install(
861 n
, false /* set_inactive */,
862 true /* force_clear_static */,
864 if ((n
->flags
& ZEBRA_NEIGH_REMOTE
))
865 zebra_evpn_neigh_uninstall(wctx
->zevpn
, n
);
868 zebra_evpn_neigh_del(wctx
->zevpn
, n
);
875 * Delete all neighbor entries for this EVPN.
877 void zebra_evpn_neigh_del_all(struct zebra_evpn
*zevpn
, int uninstall
,
878 int upd_client
, uint32_t flags
)
880 struct neigh_walk_ctx wctx
;
882 if (!zevpn
->neigh_table
)
885 memset(&wctx
, 0, sizeof(struct neigh_walk_ctx
));
887 wctx
.uninstall
= uninstall
;
888 wctx
.upd_client
= upd_client
;
891 hash_iterate(zevpn
->neigh_table
, zebra_evpn_neigh_del_hash_entry
,
896 * Look up neighbor hash entry.
898 struct zebra_neigh
*zebra_evpn_neigh_lookup(struct zebra_evpn
*zevpn
,
899 const struct ipaddr
*ip
)
901 struct zebra_neigh tmp
;
902 struct zebra_neigh
*n
;
904 memset(&tmp
, 0, sizeof(tmp
));
905 memcpy(&tmp
.ip
, ip
, sizeof(struct ipaddr
));
906 n
= hash_lookup(zevpn
->neigh_table
, &tmp
);
912 * Process all neighbors associated with a MAC upon the MAC being learnt
913 * locally or undergoing any other change (such as sequence number).
915 void zebra_evpn_process_neigh_on_local_mac_change(struct zebra_evpn
*zevpn
,
916 struct zebra_mac
*zmac
,
920 struct zebra_neigh
*n
= NULL
;
921 struct listnode
*node
= NULL
;
922 struct zebra_vrf
*zvrf
= NULL
;
924 zvrf
= zevpn
->vxlan_if
->vrf
->info
;
926 if (IS_ZEBRA_DEBUG_VXLAN
)
927 zlog_debug("Processing neighbors on local MAC %pEA %s, VNI %u",
928 &zmac
->macaddr
, seq_change
? "CHANGE" : "ADD",
931 /* Walk all neighbors and mark any inactive local neighbors as
932 * active and/or update sequence number upon a move, and inform BGP.
933 * The action for remote neighbors is TBD.
934 * NOTE: We can't simply uninstall remote neighbors as the kernel may
935 * accidentally end up deleting a just-learnt local neighbor.
937 for (ALL_LIST_ELEMENTS_RO(zmac
->neigh_list
, node
, n
)) {
938 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
939 if (IS_ZEBRA_NEIGH_INACTIVE(n
) || seq_change
941 ZEBRA_NEIGH_SET_ACTIVE(n
);
942 n
->loc_seq
= zmac
->loc_seq
;
943 if (!(zebra_evpn_do_dup_addr_detect(zvrf
)
945 && !!CHECK_FLAG(n
->flags
,
946 ZEBRA_NEIGH_DUPLICATE
)))
947 zebra_evpn_neigh_send_add_to_client(
948 zevpn
->vni
, &n
->ip
, &n
->emac
,
949 n
->mac
, n
->flags
, n
->loc_seq
);
956 * Process all neighbors associated with a local MAC upon the MAC being
959 void zebra_evpn_process_neigh_on_local_mac_del(struct zebra_evpn
*zevpn
,
960 struct zebra_mac
*zmac
)
962 struct zebra_neigh
*n
= NULL
;
963 struct listnode
*node
= NULL
;
965 if (IS_ZEBRA_DEBUG_VXLAN
)
966 zlog_debug("Processing neighbors on local MAC %pEA DEL, VNI %u",
967 &zmac
->macaddr
, zevpn
->vni
);
969 /* Walk all local neighbors and mark as inactive and inform
971 * TBD: There is currently no handling for remote neighbors. We
972 * don't expect them to exist, if they do, do we install the MAC
973 * as a remote MAC and the neighbor as remote?
975 for (ALL_LIST_ELEMENTS_RO(zmac
->neigh_list
, node
, n
)) {
976 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
977 if (IS_ZEBRA_NEIGH_ACTIVE(n
)) {
978 ZEBRA_NEIGH_SET_INACTIVE(n
);
980 zebra_evpn_neigh_send_del_to_client(
981 zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
982 ZEBRA_NEIGH_ACTIVE
, false /*force*/);
989 * Process all neighbors associated with a MAC upon the MAC being remotely
992 void zebra_evpn_process_neigh_on_remote_mac_add(struct zebra_evpn
*zevpn
,
993 struct zebra_mac
*zmac
)
995 struct zebra_neigh
*n
= NULL
;
996 struct listnode
*node
= NULL
;
998 if (IS_ZEBRA_DEBUG_VXLAN
)
999 zlog_debug("Processing neighbors on remote MAC %pEA ADD, VNI %u",
1000 &zmac
->macaddr
, zevpn
->vni
);
1002 /* Walk all local neighbors and mark as inactive and inform
1005 for (ALL_LIST_ELEMENTS_RO(zmac
->neigh_list
, node
, n
)) {
1006 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
1007 if (IS_ZEBRA_NEIGH_ACTIVE(n
)) {
1008 ZEBRA_NEIGH_SET_INACTIVE(n
);
1010 zebra_evpn_neigh_send_del_to_client(
1011 zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
1012 ZEBRA_NEIGH_ACTIVE
, false /* force */);
1019 * Process all neighbors associated with a remote MAC upon the MAC being
1022 void zebra_evpn_process_neigh_on_remote_mac_del(struct zebra_evpn
*zevpn
,
1023 struct zebra_mac
*zmac
)
1025 /* NOTE: Currently a NO-OP. */
1028 static inline void zebra_evpn_local_neigh_update_log(
1029 const char *pfx
, struct zebra_neigh
*n
, bool is_router
,
1030 bool local_inactive
, bool old_bgp_ready
, bool new_bgp_ready
,
1031 bool inform_dataplane
, bool inform_bgp
, const char *sfx
)
1033 if (!IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
1036 zlog_debug("%s neigh vni %u ip %pIA mac %pEA f 0x%x%s%s%s%s%s%s %s", pfx
,
1037 n
->zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
1038 is_router
? " router" : "",
1039 local_inactive
? " local-inactive" : "",
1040 old_bgp_ready
? " old_bgp_ready" : "",
1041 new_bgp_ready
? " new_bgp_ready" : "",
1042 inform_dataplane
? " inform_dp" : "",
1043 inform_bgp
? " inform_bgp" : "", sfx
);
1046 /* As part Duplicate Address Detection (DAD) for IP mobility
1047 * MAC binding changes, ensure to inherit duplicate flag
1050 static int zebra_evpn_ip_inherit_dad_from_mac(struct zebra_vrf
*zvrf
,
1051 struct zebra_mac
*old_zmac
,
1052 struct zebra_mac
*new_zmac
,
1053 struct zebra_neigh
*nbr
)
1055 bool is_old_mac_dup
= false;
1056 bool is_new_mac_dup
= false;
1058 if (!zebra_evpn_do_dup_addr_detect(zvrf
))
1060 /* Check old or new MAC is detected as duplicate
1061 * mark this neigh as duplicate
1065 CHECK_FLAG(old_zmac
->flags
, ZEBRA_MAC_DUPLICATE
);
1068 CHECK_FLAG(new_zmac
->flags
, ZEBRA_MAC_DUPLICATE
);
1069 /* Old and/or new MAC can be in duplicate state,
1070 * based on that IP/Neigh Inherits the flag.
1071 * If New MAC is marked duplicate, inherit to the IP.
1072 * If old MAC is duplicate but new MAC is not, clear
1073 * duplicate flag for IP and reset detection params
1074 * and let IP DAD retrigger.
1076 if (is_new_mac_dup
&& !CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
)) {
1077 SET_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
);
1078 /* Capture Duplicate detection time */
1079 nbr
->dad_dup_detect_time
= monotime(NULL
);
1080 /* Mark neigh inactive */
1081 ZEBRA_NEIGH_SET_INACTIVE(nbr
);
1084 } else if (is_old_mac_dup
&& !is_new_mac_dup
) {
1085 UNSET_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
);
1087 nbr
->detect_start_time
.tv_sec
= 0;
1088 nbr
->detect_start_time
.tv_usec
= 0;
1093 static void zebra_evpn_dad_ip_auto_recovery_exp(struct thread
*t
)
1095 struct zebra_vrf
*zvrf
= NULL
;
1096 struct zebra_neigh
*nbr
= NULL
;
1097 struct zebra_evpn
*zevpn
= NULL
;
1099 nbr
= THREAD_ARG(t
);
1101 /* since this is asynchronous we need sanity checks*/
1102 zvrf
= vrf_info_lookup(nbr
->zevpn
->vrf_id
);
1106 zevpn
= zebra_evpn_lookup(nbr
->zevpn
->vni
);
1110 nbr
= zebra_evpn_neigh_lookup(zevpn
, &nbr
->ip
);
1114 if (IS_ZEBRA_DEBUG_VXLAN
)
1116 "%s: duplicate addr MAC %pEA IP %pIA flags 0x%x learn count %u vni %u auto recovery expired",
1117 __func__
, &nbr
->emac
, &nbr
->ip
, nbr
->flags
,
1118 nbr
->dad_count
, zevpn
->vni
);
1120 UNSET_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
);
1122 nbr
->detect_start_time
.tv_sec
= 0;
1123 nbr
->detect_start_time
.tv_usec
= 0;
1124 nbr
->dad_dup_detect_time
= 0;
1125 nbr
->dad_ip_auto_recovery_timer
= NULL
;
1126 ZEBRA_NEIGH_SET_ACTIVE(nbr
);
1129 if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_LOCAL
)) {
1130 zebra_evpn_neigh_send_add_to_client(zevpn
->vni
, &nbr
->ip
,
1131 &nbr
->emac
, nbr
->mac
,
1132 nbr
->flags
, nbr
->loc_seq
);
1133 } else if (!!CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_REMOTE
)) {
1134 zebra_evpn_rem_neigh_install(zevpn
, nbr
, false /*was_static*/);
1138 static void zebra_evpn_dup_addr_detect_for_neigh(
1139 struct zebra_vrf
*zvrf
, struct zebra_neigh
*nbr
, struct in_addr vtep_ip
,
1140 bool do_dad
, bool *is_dup_detect
, bool is_local
)
1143 struct timeval elapsed
= {0, 0};
1144 bool reset_params
= false;
1146 if (!zebra_evpn_do_dup_addr_detect(zvrf
))
1149 /* IP is detected as duplicate or inherit dup
1150 * state, hold on to install as remote entry
1151 * only if freeze is enabled.
1153 if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
)) {
1154 if (IS_ZEBRA_DEBUG_VXLAN
)
1156 "%s: duplicate addr MAC %pEA IP %pIA flags 0x%x skip installing, learn count %u recover time %u",
1157 __func__
, &nbr
->emac
, &nbr
->ip
,
1158 nbr
->flags
, nbr
->dad_count
,
1159 zvrf
->dad_freeze_time
);
1161 if (zvrf
->dad_freeze
)
1162 *is_dup_detect
= true;
1164 /* warn-only action, neigh will be installed.
1165 * freeze action, it wil not be installed.
1173 /* Check if detection time (M-secs) expired.
1174 * Reset learn count and detection start time.
1175 * During remote mac add, count should already be 1
1176 * via local learning.
1178 monotime_since(&nbr
->detect_start_time
, &elapsed
);
1179 reset_params
= (elapsed
.tv_sec
> zvrf
->dad_time
);
1181 if (is_local
&& !reset_params
) {
1182 /* RFC-7432: A PE/VTEP that detects a MAC mobility
1183 * event via LOCAL learning starts an M-second timer.
1185 * NOTE: This is the START of the probe with count is
1186 * 0 during LOCAL learn event.
1188 reset_params
= !nbr
->dad_count
;
1192 if (IS_ZEBRA_DEBUG_VXLAN
)
1194 "%s: duplicate addr MAC %pEA IP %pIA flags 0x%x detection time passed, reset learn count %u",
1195 __func__
, &nbr
->emac
, &nbr
->ip
,
1196 nbr
->flags
, nbr
->dad_count
);
1197 /* Reset learn count but do not start detection
1198 * during REMOTE learn event.
1201 /* Start dup. addr detection (DAD) start time,
1202 * ONLY during LOCAL learn.
1205 monotime(&nbr
->detect_start_time
);
1207 } else if (!is_local
) {
1208 /* For REMOTE IP/Neigh, increment detection count
1209 * ONLY while in probe window, once window passed,
1210 * next local learn event should trigger DAD.
1215 /* For LOCAL IP/Neigh learn event, once count is reset above via either
1216 * initial/start detection time or passed the probe time, the count
1217 * needs to be incremented.
1222 if (nbr
->dad_count
>= zvrf
->dad_max_moves
) {
1224 EC_ZEBRA_DUP_IP_DETECTED
,
1225 "VNI %u: MAC %pEA IP %pIA detected as duplicate during %s VTEP %pI4",
1226 nbr
->zevpn
->vni
, &nbr
->emac
, &nbr
->ip
,
1227 is_local
? "local update, last" : "remote update, from",
1230 SET_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
);
1232 /* Capture Duplicate detection time */
1233 nbr
->dad_dup_detect_time
= monotime(NULL
);
1235 /* Start auto recovery timer for this IP */
1236 THREAD_OFF(nbr
->dad_ip_auto_recovery_timer
);
1237 if (zvrf
->dad_freeze
&& zvrf
->dad_freeze_time
) {
1238 if (IS_ZEBRA_DEBUG_VXLAN
)
1240 "%s: duplicate addr MAC %pEA IP %pIA flags 0x%x auto recovery time %u start",
1241 __func__
, &nbr
->emac
, &nbr
->ip
,
1242 nbr
->flags
, zvrf
->dad_freeze_time
);
1244 thread_add_timer(zrouter
.master
,
1245 zebra_evpn_dad_ip_auto_recovery_exp
,
1246 nbr
, zvrf
->dad_freeze_time
,
1247 &nbr
->dad_ip_auto_recovery_timer
);
1249 if (zvrf
->dad_freeze
)
1250 *is_dup_detect
= true;
1254 int zebra_evpn_local_neigh_update(struct zebra_evpn
*zevpn
,
1255 struct interface
*ifp
,
1256 const struct ipaddr
*ip
,
1257 const struct ethaddr
*macaddr
, bool is_router
,
1258 bool local_inactive
, bool dp_static
)
1260 struct zebra_vrf
*zvrf
;
1261 struct zebra_neigh
*n
= NULL
;
1262 struct zebra_mac
*zmac
= NULL
, *old_zmac
= NULL
;
1263 uint32_t old_mac_seq
= 0, mac_new_seq
= 0;
1264 bool upd_mac_seq
= false;
1265 bool neigh_mac_change
= false;
1266 bool neigh_on_hold
= false;
1267 bool neigh_was_remote
= false;
1268 bool do_dad
= false;
1269 struct in_addr vtep_ip
= {.s_addr
= 0};
1270 bool inform_dataplane
= false;
1271 bool created
= false;
1272 bool new_static
= false;
1273 bool old_bgp_ready
= false;
1276 /* Check if the MAC exists. */
1277 zmac
= zebra_evpn_mac_lookup(zevpn
, macaddr
);
1279 /* create a dummy MAC if the MAC is not already present */
1280 if (IS_ZEBRA_DEBUG_VXLAN
)
1281 zlog_debug("AUTO MAC %pEA created for neigh %pIA on VNI %u",
1282 macaddr
, ip
, zevpn
->vni
);
1284 zmac
= zebra_evpn_mac_add(zevpn
, macaddr
);
1285 zebra_evpn_mac_clear_fwd_info(zmac
);
1286 memset(&zmac
->flags
, 0, sizeof(uint32_t));
1287 SET_FLAG(zmac
->flags
, ZEBRA_MAC_AUTO
);
1289 if (CHECK_FLAG(zmac
->flags
, ZEBRA_MAC_REMOTE
)) {
1291 * We don't change the MAC to local upon a neighbor
1292 * learn event, we wait for the explicit local MAC
1293 * learn. However, we have to compute its sequence
1294 * number in preparation for when it actually turns
1301 zvrf
= zevpn
->vxlan_if
->vrf
->info
;
1303 if (IS_ZEBRA_DEBUG_VXLAN
)
1304 zlog_debug(" Unable to find vrf for: %d",
1305 zevpn
->vxlan_if
->vrf
->vrf_id
);
1309 /* Check if the neighbor exists. */
1310 n
= zebra_evpn_neigh_lookup(zevpn
, ip
);
1312 /* New neighbor - create */
1313 n
= zebra_evpn_neigh_add(zevpn
, ip
, macaddr
, zmac
, 0);
1315 /* Set "local" forwarding info. */
1316 SET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
);
1317 n
->ifindex
= ifp
->ifindex
;
1320 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
1323 bool old_local_inactive
;
1325 old_local_inactive
= !!CHECK_FLAG(
1326 n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
);
1328 old_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
1330 /* Note any changes and see if of interest to BGP. */
1331 mac_different
= !!memcmp(&n
->emac
, macaddr
, ETH_ALEN
);
1333 !!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
1334 new_static
= zebra_evpn_neigh_is_static(n
);
1335 if (!mac_different
&& is_router
== cur_is_router
1336 && old_local_inactive
== local_inactive
1337 && dp_static
!= new_static
) {
1338 if (IS_ZEBRA_DEBUG_VXLAN
)
1340 " Ignoring entry mac is the same and is_router == cur_is_router");
1341 n
->ifindex
= ifp
->ifindex
;
1346 if (!mac_different
) {
1347 /* XXX - cleanup this code duplication */
1348 bool is_neigh_freezed
= false;
1350 /* Only the router flag has changed. */
1353 ZEBRA_NEIGH_ROUTER_FLAG
);
1355 UNSET_FLAG(n
->flags
,
1356 ZEBRA_NEIGH_ROUTER_FLAG
);
1360 ZEBRA_NEIGH_LOCAL_INACTIVE
);
1362 UNSET_FLAG(n
->flags
,
1363 ZEBRA_NEIGH_LOCAL_INACTIVE
);
1365 zebra_evpn_neigh_is_ready_for_bgp(n
);
1367 if (dp_static
!= new_static
)
1368 inform_dataplane
= true;
1370 /* Neigh is in freeze state and freeze action
1371 * is enabled, do not send update to client.
1374 (zebra_evpn_do_dup_addr_detect(zvrf
)
1376 && CHECK_FLAG(n
->flags
,
1377 ZEBRA_NEIGH_DUPLICATE
));
1379 zebra_evpn_local_neigh_update_log(
1380 "local", n
, is_router
, local_inactive
,
1381 old_bgp_ready
, new_bgp_ready
, false,
1382 false, "flag-update");
1384 if (inform_dataplane
)
1385 zebra_evpn_sync_neigh_dp_install(
1386 n
, false /* set_inactive */,
1387 false /* force_clear_static */,
1390 /* if the neigh can no longer be advertised
1391 * remove it from bgp
1393 if (!is_neigh_freezed
) {
1394 zebra_evpn_neigh_send_add_del_to_client(
1398 if (IS_ZEBRA_DEBUG_VXLAN
1399 && IS_ZEBRA_NEIGH_ACTIVE(n
))
1401 " Neighbor active and frozen");
1406 /* The MAC has changed, need to issue a delete
1407 * first as this means a different MACIP route.
1408 * Also, need to do some unlinking/relinking.
1409 * We also need to update the MAC's sequence number
1410 * in different situations.
1412 if (old_bgp_ready
) {
1413 zebra_evpn_neigh_send_del_to_client(
1414 zevpn
->vni
, &n
->ip
, &n
->emac
, n
->flags
,
1415 n
->state
, false /*force*/);
1416 old_bgp_ready
= false;
1419 old_mac_seq
= CHECK_FLAG(old_zmac
->flags
,
1422 : old_zmac
->loc_seq
;
1423 neigh_mac_change
= upd_mac_seq
= true;
1424 zebra_evpn_local_neigh_deref_mac(
1425 n
, true /* send_mac_update */);
1428 /* if mac changes abandon peer flags and tell
1429 * dataplane to clear the static flag
1431 if (zebra_evpn_neigh_clear_sync_info(n
))
1432 inform_dataplane
= true;
1433 /* Update the forwarding info. */
1434 n
->ifindex
= ifp
->ifindex
;
1436 /* Link to new MAC */
1437 zebra_evpn_local_neigh_ref_mac(
1438 n
, macaddr
, zmac
, true /* send_mac_update */);
1439 } else if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)) {
1441 * Neighbor has moved from remote to local. Its
1442 * MAC could have also changed as part of the move.
1444 if (memcmp(n
->emac
.octet
, macaddr
->octet
, ETH_ALEN
)
1449 CHECK_FLAG(old_zmac
->flags
,
1452 : old_zmac
->loc_seq
;
1453 neigh_mac_change
= upd_mac_seq
= true;
1454 zebra_evpn_local_neigh_deref_mac(
1455 n
, true /* send_update */);
1458 /* Link to new MAC */
1459 zebra_evpn_local_neigh_ref_mac(
1460 n
, macaddr
, zmac
, true /*send_update*/);
1462 /* Based on Mobility event Scenario-B from the
1463 * draft, neigh's previous state was remote treat this
1466 neigh_was_remote
= true;
1467 vtep_ip
= n
->r_vtep_ip
;
1468 /* Mark appropriately */
1469 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
);
1470 n
->r_vtep_ip
.s_addr
= INADDR_ANY
;
1471 SET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
);
1472 n
->ifindex
= ifp
->ifindex
;
1476 /* If MAC was previously remote, or the neighbor had a different
1477 * MAC earlier, recompute the sequence number.
1480 uint32_t seq1
, seq2
;
1482 seq1
= CHECK_FLAG(zmac
->flags
, ZEBRA_MAC_REMOTE
)
1485 seq2
= neigh_mac_change
? old_mac_seq
+ 1 : 0;
1486 mac_new_seq
= zmac
->loc_seq
< MAX(seq1
, seq2
) ? MAX(seq1
, seq2
)
1491 SET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
);
1493 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
);
1495 /* Mark Router flag (R-bit) */
1497 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
1499 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
1501 /* if zebra and dataplane don't agree this is a sync entry
1502 * re-install in the dataplane */
1503 new_static
= zebra_evpn_neigh_is_static(n
);
1504 if (dp_static
!= new_static
)
1505 inform_dataplane
= true;
1507 /* Check old and/or new MAC detected as duplicate mark
1508 * the neigh as duplicate
1510 if (zebra_evpn_ip_inherit_dad_from_mac(zvrf
, old_zmac
, zmac
, n
)) {
1512 EC_ZEBRA_DUP_IP_INHERIT_DETECTED
,
1513 "VNI %u: MAC %pEA IP %pIA detected as duplicate during local update, inherit duplicate from MAC",
1514 zevpn
->vni
, macaddr
, &n
->ip
);
1517 /* For IP Duplicate Address Detection (DAD) is trigger,
1518 * when the event is extended mobility based on scenario-B
1519 * from the draft, IP/Neigh's MAC binding changed and
1520 * neigh's previous state was remote.
1522 if (neigh_mac_change
&& neigh_was_remote
)
1525 zebra_evpn_dup_addr_detect_for_neigh(zvrf
, n
, vtep_ip
, do_dad
,
1526 &neigh_on_hold
, true);
1528 if (inform_dataplane
)
1529 zebra_evpn_sync_neigh_dp_install(n
, false /* set_inactive */,
1530 false /* force_clear_static */,
1533 /* Before we program this in BGP, we need to check if MAC is locally
1534 * learnt. If not, force neighbor to be inactive and reset its seq.
1536 if (!CHECK_FLAG(zmac
->flags
, ZEBRA_MAC_LOCAL
)) {
1537 zebra_evpn_local_neigh_update_log(
1538 "local", n
, is_router
, local_inactive
, false, false,
1539 inform_dataplane
, false, "auto-mac");
1540 ZEBRA_NEIGH_SET_INACTIVE(n
);
1542 zmac
->loc_seq
= mac_new_seq
;
1546 zebra_evpn_local_neigh_update_log("local", n
, is_router
, local_inactive
,
1547 false, false, inform_dataplane
, true,
1548 created
? "created" : "updated");
1550 /* If the MAC's sequence number has changed, inform the MAC and all
1551 * neighbors associated with the MAC to BGP, else just inform this
1554 if (upd_mac_seq
&& zmac
->loc_seq
!= mac_new_seq
) {
1555 if (IS_ZEBRA_DEBUG_VXLAN
)
1557 "Seq changed for MAC %pEA VNI %u - old %u new %u",
1558 macaddr
, zevpn
->vni
,
1559 zmac
->loc_seq
, mac_new_seq
);
1560 zmac
->loc_seq
= mac_new_seq
;
1561 if (zebra_evpn_mac_send_add_to_client(zevpn
->vni
, macaddr
,
1563 zmac
->loc_seq
, zmac
->es
))
1565 zebra_evpn_process_neigh_on_local_mac_change(zevpn
, zmac
, 1,
1570 n
->loc_seq
= zmac
->loc_seq
;
1572 if (!neigh_on_hold
) {
1573 ZEBRA_NEIGH_SET_ACTIVE(n
);
1574 new_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
1575 zebra_evpn_neigh_send_add_del_to_client(n
, old_bgp_ready
,
1578 if (IS_ZEBRA_DEBUG_VXLAN
)
1579 zlog_debug(" Neighbor on hold not sending");
1584 int zebra_evpn_remote_neigh_update(struct zebra_evpn
*zevpn
,
1585 struct interface
*ifp
,
1586 const struct ipaddr
*ip
,
1587 const struct ethaddr
*macaddr
,
1590 struct zebra_neigh
*n
= NULL
;
1591 struct zebra_mac
*zmac
= NULL
;
1593 /* If the neighbor is unknown, there is no further action. */
1594 n
= zebra_evpn_neigh_lookup(zevpn
, ip
);
1598 /* If a remote entry, see if it needs to be refreshed */
1599 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)) {
1601 if (state
& NUD_STALE
)
1602 zebra_evpn_rem_neigh_install(zevpn
, n
,
1603 false /*was_static*/);
1606 /* We got a "remote" neighbor notification for an entry
1607 * we think is local. This can happen in a multihoming
1608 * scenario - but only if the MAC is already "remote".
1609 * Just mark our entry as "remote".
1611 zmac
= zebra_evpn_mac_lookup(zevpn
, macaddr
);
1612 if (!zmac
|| !CHECK_FLAG(zmac
->flags
, ZEBRA_MAC_REMOTE
)) {
1614 "Ignore remote neigh %pIA (MAC %pEA) on L2-VNI %u - MAC unknown or local",
1615 &n
->ip
, macaddr
, zevpn
->vni
);
1619 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ALL_LOCAL_FLAGS
);
1620 SET_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
);
1621 ZEBRA_NEIGH_SET_ACTIVE(n
);
1622 n
->r_vtep_ip
= zmac
->fwd_info
.r_vtep_ip
;
1628 /* Notify Neighbor entries to the Client, skips the GW entry */
1630 zebra_evpn_send_neigh_hash_entry_to_client(struct hash_bucket
*bucket
,
1633 struct mac_walk_ctx
*wctx
= arg
;
1634 struct zebra_neigh
*zn
= bucket
->data
;
1635 struct zebra_mac
*zmac
= NULL
;
1637 if (CHECK_FLAG(zn
->flags
, ZEBRA_NEIGH_DEF_GW
))
1640 if (CHECK_FLAG(zn
->flags
, ZEBRA_NEIGH_LOCAL
)
1641 && IS_ZEBRA_NEIGH_ACTIVE(zn
)) {
1642 zmac
= zebra_evpn_mac_lookup(wctx
->zevpn
, &zn
->emac
);
1646 zebra_evpn_neigh_send_add_to_client(wctx
->zevpn
->vni
, &zn
->ip
,
1648 zn
->flags
, zn
->loc_seq
);
1652 /* Iterator of a specific EVPN */
1653 void zebra_evpn_send_neigh_to_client(struct zebra_evpn
*zevpn
)
1655 struct neigh_walk_ctx wctx
;
1657 memset(&wctx
, 0, sizeof(struct neigh_walk_ctx
));
1660 hash_iterate(zevpn
->neigh_table
,
1661 zebra_evpn_send_neigh_hash_entry_to_client
, &wctx
);
1664 void zebra_evpn_clear_dup_neigh_hash(struct hash_bucket
*bucket
, void *ctxt
)
1666 struct neigh_walk_ctx
*wctx
= ctxt
;
1667 struct zebra_neigh
*nbr
;
1668 struct zebra_evpn
*zevpn
;
1669 char buf
[INET6_ADDRSTRLEN
];
1671 nbr
= (struct zebra_neigh
*)bucket
->data
;
1675 zevpn
= wctx
->zevpn
;
1677 if (!CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
))
1680 if (IS_ZEBRA_DEBUG_VXLAN
) {
1681 ipaddr2str(&nbr
->ip
, buf
, sizeof(buf
));
1682 zlog_debug("%s: clear neigh %s dup state, flags 0x%x seq %u",
1683 __func__
, buf
, nbr
->flags
, nbr
->loc_seq
);
1686 UNSET_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
);
1688 nbr
->detect_start_time
.tv_sec
= 0;
1689 nbr
->detect_start_time
.tv_usec
= 0;
1690 nbr
->dad_dup_detect_time
= 0;
1691 THREAD_OFF(nbr
->dad_ip_auto_recovery_timer
);
1693 if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_LOCAL
)) {
1694 zebra_evpn_neigh_send_add_to_client(zevpn
->vni
, &nbr
->ip
,
1695 &nbr
->emac
, nbr
->mac
,
1696 nbr
->flags
, nbr
->loc_seq
);
1697 } else if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_REMOTE
)) {
1698 zebra_evpn_rem_neigh_install(zevpn
, nbr
, false /*was_static*/);
1703 * Print a specific neighbor entry.
1705 void zebra_evpn_print_neigh(struct zebra_neigh
*n
, void *ctxt
,
1709 char buf1
[ETHER_ADDR_STRLEN
];
1710 char buf2
[INET6_ADDRSTRLEN
];
1711 const char *type_str
;
1712 const char *state_str
;
1713 bool flags_present
= false;
1714 struct zebra_vrf
*zvrf
= NULL
;
1715 struct timeval detect_start_time
= {0, 0};
1716 char timebuf
[MONOTIME_STRLEN
];
1717 char thread_buf
[THREAD_TIMER_STRLEN
];
1719 char up_str
[MONOTIME_STRLEN
];
1721 zvrf
= zebra_vrf_get_evpn();
1725 uptime
= monotime(NULL
);
1726 uptime
-= n
->uptime
;
1728 frrtime_to_interval(uptime
, up_str
, sizeof(up_str
));
1730 ipaddr2str(&n
->ip
, buf2
, sizeof(buf2
));
1731 prefix_mac2str(&n
->emac
, buf1
, sizeof(buf1
));
1732 type_str
= CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
) ? "local" : "remote";
1733 state_str
= IS_ZEBRA_NEIGH_ACTIVE(n
) ? "active" : "inactive";
1734 vty
= (struct vty
*)ctxt
;
1736 bool sync_info
= false;
1738 vty_out(vty
, "IP: %s\n",
1739 ipaddr2str(&n
->ip
, buf2
, sizeof(buf2
)));
1740 vty_out(vty
, " Type: %s\n", type_str
);
1741 vty_out(vty
, " State: %s\n", state_str
);
1742 vty_out(vty
, " Uptime: %s\n", up_str
);
1743 vty_out(vty
, " MAC: %s\n",
1744 prefix_mac2str(&n
->emac
, buf1
, sizeof(buf1
)));
1745 vty_out(vty
, " Sync-info:");
1746 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
)) {
1747 vty_out(vty
, " local-inactive");
1750 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_PROXY
)) {
1751 vty_out(vty
, " peer-proxy");
1754 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
)) {
1755 vty_out(vty
, " peer-active");
1758 if (n
->hold_timer
) {
1759 vty_out(vty
, " (ht: %s)",
1760 thread_timer_to_hhmmss(thread_buf
,
1769 json_object_string_add(json
, "uptime", up_str
);
1770 json_object_string_add(json
, "ip", buf2
);
1771 json_object_string_add(json
, "type", type_str
);
1772 json_object_string_add(json
, "state", state_str
);
1773 json_object_string_add(json
, "mac", buf1
);
1774 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
))
1775 json_object_boolean_true_add(json
, "localInactive");
1776 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_PROXY
))
1777 json_object_boolean_true_add(json
, "peerProxy");
1778 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ES_PEER_ACTIVE
))
1779 json_object_boolean_true_add(json
, "peerActive");
1781 json_object_string_add(
1782 json
, "peerActiveHold",
1783 thread_timer_to_hhmmss(thread_buf
,
1787 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)) {
1790 json_object_string_add(json
, "remoteEs",
1791 n
->mac
->es
->esi_str
);
1793 vty_out(vty
, " Remote ES: %s\n",
1794 n
->mac
->es
->esi_str
);
1797 json_object_string_addf(json
, "remoteVtep",
1798 "%pI4", &n
->r_vtep_ip
);
1800 vty_out(vty
, " Remote VTEP: %pI4\n",
1804 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DEF_GW
)) {
1806 vty_out(vty
, " Flags: Default-gateway");
1807 flags_present
= true;
1809 json_object_boolean_true_add(json
, "defaultGateway");
1811 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
)) {
1814 flags_present
? " ,Router" : " Flags: Router");
1815 flags_present
= true;
1821 vty_out(vty
, " Local Seq: %u Remote Seq: %u\n", n
->loc_seq
,
1824 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DUPLICATE
)) {
1825 vty_out(vty
, " Duplicate, detected at %s",
1826 time_to_string(n
->dad_dup_detect_time
,
1828 } else if (n
->dad_count
) {
1829 monotime_since(&n
->detect_start_time
,
1830 &detect_start_time
);
1831 if (detect_start_time
.tv_sec
<= zvrf
->dad_time
) {
1832 time_to_string(n
->detect_start_time
.tv_sec
,
1835 " Duplicate detection started at %s, detection count %u\n",
1836 timebuf
, n
->dad_count
);
1840 json_object_int_add(json
, "localSequence", n
->loc_seq
);
1841 json_object_int_add(json
, "remoteSequence", n
->rem_seq
);
1842 json_object_int_add(json
, "detectionCount", n
->dad_count
);
1843 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DUPLICATE
))
1844 json_object_boolean_true_add(json
, "isDuplicate");
1846 json_object_boolean_false_add(json
, "isDuplicate");
1850 void zebra_evpn_print_neigh_hdr(struct vty
*vty
, struct neigh_walk_ctx
*wctx
)
1852 vty_out(vty
, "Flags: I=local-inactive, P=peer-active, X=peer-proxy\n");
1853 vty_out(vty
, "%*s %-6s %-5s %-8s %-17s %-30s %s\n", -wctx
->addr_width
,
1854 "Neighbor", "Type", "Flags", "State", "MAC", "Remote ES/VTEP",
1858 static char *zebra_evpn_print_neigh_flags(struct zebra_neigh
*n
,
1860 uint32_t flags_buf_sz
)
1862 snprintf(flags_buf
, flags_buf_sz
, "%s%s%s",
1863 (n
->flags
& ZEBRA_NEIGH_ES_PEER_ACTIVE
) ?
1865 (n
->flags
& ZEBRA_NEIGH_ES_PEER_PROXY
) ?
1867 (n
->flags
& ZEBRA_NEIGH_LOCAL_INACTIVE
) ?
1874 * Print neighbor hash entry - called for display of all neighbors.
1876 void zebra_evpn_print_neigh_hash(struct hash_bucket
*bucket
, void *ctxt
)
1879 json_object
*json_evpn
= NULL
, *json_row
= NULL
;
1880 struct zebra_neigh
*n
;
1881 char buf1
[ETHER_ADDR_STRLEN
];
1882 char buf2
[INET6_ADDRSTRLEN
];
1883 char addr_buf
[PREFIX_STRLEN
];
1884 struct neigh_walk_ctx
*wctx
= ctxt
;
1885 const char *state_str
;
1889 json_evpn
= wctx
->json
;
1890 n
= (struct zebra_neigh
*)bucket
->data
;
1893 json_row
= json_object_new_object();
1895 prefix_mac2str(&n
->emac
, buf1
, sizeof(buf1
));
1896 ipaddr2str(&n
->ip
, buf2
, sizeof(buf2
));
1897 state_str
= IS_ZEBRA_NEIGH_ACTIVE(n
) ? "active" : "inactive";
1898 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
1899 if (wctx
->flags
& SHOW_REMOTE_NEIGH_FROM_VTEP
)
1902 if (json_evpn
== NULL
) {
1903 vty_out(vty
, "%*s %-6s %-5s %-8s %-17s %-30s %u/%u\n",
1904 -wctx
->addr_width
, buf2
, "local",
1905 zebra_evpn_print_neigh_flags(n
, flags_buf
,
1906 sizeof(flags_buf
)), state_str
, buf1
,
1907 "", n
->loc_seq
, n
->rem_seq
);
1909 json_object_string_add(json_row
, "type", "local");
1910 json_object_string_add(json_row
, "state", state_str
);
1911 json_object_string_add(json_row
, "mac", buf1
);
1912 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DEF_GW
))
1913 json_object_boolean_true_add(json_row
,
1915 json_object_int_add(json_row
, "localSequence",
1917 json_object_int_add(json_row
, "remoteSequence",
1919 json_object_int_add(json_row
, "detectionCount",
1921 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DUPLICATE
))
1922 json_object_boolean_true_add(json_row
,
1925 json_object_boolean_false_add(json_row
,
1929 } else if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)) {
1930 if ((wctx
->flags
& SHOW_REMOTE_NEIGH_FROM_VTEP
)
1931 && !IPV4_ADDR_SAME(&n
->r_vtep_ip
, &wctx
->r_vtep_ip
))
1934 if (json_evpn
== NULL
) {
1935 if ((wctx
->flags
& SHOW_REMOTE_NEIGH_FROM_VTEP
)
1936 && (wctx
->count
== 0))
1937 zebra_evpn_print_neigh_hdr(vty
, wctx
);
1939 if (n
->mac
->es
== NULL
)
1940 inet_ntop(AF_INET
, &n
->r_vtep_ip
,
1941 addr_buf
, sizeof(addr_buf
));
1943 vty_out(vty
, "%*s %-6s %-5s %-8s %-17s %-30s %u/%u\n",
1944 -wctx
->addr_width
, buf2
, "remote",
1945 zebra_evpn_print_neigh_flags(n
, flags_buf
,
1946 sizeof(flags_buf
)), state_str
, buf1
,
1947 n
->mac
->es
? n
->mac
->es
->esi_str
: addr_buf
,
1948 n
->loc_seq
, n
->rem_seq
);
1950 json_object_string_add(json_row
, "type", "remote");
1951 json_object_string_add(json_row
, "state", state_str
);
1952 json_object_string_add(json_row
, "mac", buf1
);
1954 json_object_string_add(json_row
, "remoteEs",
1955 n
->mac
->es
->esi_str
);
1957 json_object_string_addf(json_row
, "remoteVtep",
1958 "%pI4", &n
->r_vtep_ip
);
1959 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DEF_GW
))
1960 json_object_boolean_true_add(json_row
,
1962 json_object_int_add(json_row
, "localSequence",
1964 json_object_int_add(json_row
, "remoteSequence",
1966 json_object_int_add(json_row
, "detectionCount",
1968 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DUPLICATE
))
1969 json_object_boolean_true_add(json_row
,
1972 json_object_boolean_false_add(json_row
,
1979 json_object_object_add(json_evpn
, buf2
, json_row
);
1983 * Print neighbor hash entry in detail - called for display of all neighbors.
1985 void zebra_evpn_print_neigh_hash_detail(struct hash_bucket
*bucket
, void *ctxt
)
1988 json_object
*json_evpn
= NULL
, *json_row
= NULL
;
1989 struct zebra_neigh
*n
;
1990 char buf
[INET6_ADDRSTRLEN
];
1991 struct neigh_walk_ctx
*wctx
= ctxt
;
1994 json_evpn
= wctx
->json
;
1995 n
= (struct zebra_neigh
*)bucket
->data
;
1999 ipaddr2str(&n
->ip
, buf
, sizeof(buf
));
2001 json_row
= json_object_new_object();
2003 zebra_evpn_print_neigh(n
, vty
, json_row
);
2006 json_object_object_add(json_evpn
, buf
, json_row
);
2009 void zebra_evpn_print_dad_neigh_hash(struct hash_bucket
*bucket
, void *ctxt
)
2011 struct zebra_neigh
*nbr
;
2013 nbr
= (struct zebra_neigh
*)bucket
->data
;
2017 if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
))
2018 zebra_evpn_print_neigh_hash(bucket
, ctxt
);
2021 void zebra_evpn_print_dad_neigh_hash_detail(struct hash_bucket
*bucket
,
2024 struct zebra_neigh
*nbr
;
2026 nbr
= (struct zebra_neigh
*)bucket
->data
;
2030 if (CHECK_FLAG(nbr
->flags
, ZEBRA_NEIGH_DUPLICATE
))
2031 zebra_evpn_print_neigh_hash_detail(bucket
, ctxt
);
2034 void zebra_evpn_neigh_remote_macip_add(struct zebra_evpn
*zevpn
,
2035 struct zebra_vrf
*zvrf
,
2036 const struct ipaddr
*ipaddr
,
2037 struct zebra_mac
*mac
,
2038 struct in_addr vtep_ip
, uint8_t flags
,
2041 struct zebra_neigh
*n
;
2042 int update_neigh
= 0;
2043 struct zebra_mac
*old_mac
= NULL
;
2044 bool old_static
= false;
2045 bool do_dad
= false;
2046 bool is_dup_detect
= false;
2050 is_router
= !!CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
2052 /* Check if the remote neighbor itself is unknown or has a
2053 * change. If so, create or update and then install the entry.
2055 n
= zebra_evpn_neigh_lookup(zevpn
, ipaddr
);
2056 if (!n
|| !CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)
2057 || is_router
!= !!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
)
2058 || (memcmp(&n
->emac
, &mac
->macaddr
, sizeof(struct ethaddr
)) != 0)
2059 || !IPV4_ADDR_SAME(&n
->r_vtep_ip
, &vtep_ip
) || seq
!= n
->rem_seq
)
2064 n
= zebra_evpn_neigh_add(zevpn
, ipaddr
, &mac
->macaddr
,
2067 /* When host moves but changes its (MAC,IP)
2068 * binding, BGP may install a MACIP entry that
2069 * corresponds to "older" location of the host
2070 * in transient situations (because {IP1,M1}
2071 * is a different route from {IP1,M2}). Check
2072 * the sequence number and ignore this update
2076 if (!zebra_evpn_neigh_is_bgp_seq_ok(
2077 zevpn
, n
, &mac
->macaddr
, seq
, false))
2079 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
2080 old_static
= zebra_evpn_neigh_is_static(n
);
2081 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
2083 "sync->remote neigh vni %u ip %pIA mac %pEA seq %d f0x%x",
2084 n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
2086 if (IS_ZEBRA_NEIGH_ACTIVE(n
))
2087 zebra_evpn_neigh_send_del_to_client(
2088 zevpn
->vni
, &n
->ip
, &n
->emac
,
2091 zebra_evpn_neigh_clear_sync_info(n
);
2093 if (memcmp(&n
->emac
, &mac
->macaddr
,
2094 sizeof(struct ethaddr
))
2096 /* update neigh list for macs */
2098 zebra_evpn_mac_lookup(zevpn
, &n
->emac
);
2100 listnode_delete(old_mac
->neigh_list
, n
);
2102 zebra_evpn_deref_ip2mac(zevpn
, old_mac
);
2105 listnode_add_sort(mac
->neigh_list
, n
);
2106 memcpy(&n
->emac
, &mac
->macaddr
, ETH_ALEN
);
2108 /* Check Neigh's curent state is local
2109 * (this is the case where neigh/host has moved
2110 * from L->R) and check previous detction
2111 * started via local learning.
2113 * RFC-7432: A PE/VTEP that detects a MAC
2114 * mobilit event via local learning starts
2115 * an M-second timer.
2116 * VTEP-IP or seq. change along is not
2117 * considered for dup. detection.
2119 * Mobilty event scenario-B IP-MAC binding
2122 if ((!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
))
2128 /* Set "remote" forwarding info. */
2129 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ALL_LOCAL_FLAGS
);
2130 n
->r_vtep_ip
= vtep_ip
;
2131 SET_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
);
2133 /* Set router flag (R-bit) to this Neighbor entry */
2134 if (CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
))
2135 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
2137 UNSET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
2139 /* Check old or new MAC detected as duplicate,
2140 * inherit duplicate flag to this neigh.
2142 if (zebra_evpn_ip_inherit_dad_from_mac(zvrf
, old_mac
, mac
, n
)) {
2144 EC_ZEBRA_DUP_IP_INHERIT_DETECTED
,
2145 "VNI %u: MAC %pEA IP %pIA detected as duplicate during remote update, inherit duplicate from MAC",
2146 zevpn
->vni
, &mac
->macaddr
, &n
->ip
);
2149 /* Check duplicate address detection for IP */
2150 zebra_evpn_dup_addr_detect_for_neigh(
2151 zvrf
, n
, n
->r_vtep_ip
, do_dad
, &is_dup_detect
, false);
2152 /* Install the entry. */
2154 zebra_evpn_rem_neigh_install(zevpn
, n
, old_static
);
2157 /* Update seq number. */
2161 int zebra_evpn_neigh_gw_macip_add(struct interface
*ifp
,
2162 struct zebra_evpn
*zevpn
, struct ipaddr
*ip
,
2163 struct zebra_mac
*mac
)
2165 struct zebra_neigh
*n
;
2169 n
= zebra_evpn_neigh_lookup(zevpn
, ip
);
2171 n
= zebra_evpn_neigh_add(zevpn
, ip
, &mac
->macaddr
, mac
, 0);
2173 /* Set "local" forwarding info. */
2174 SET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
);
2175 ZEBRA_NEIGH_SET_ACTIVE(n
);
2176 memcpy(&n
->emac
, &mac
->macaddr
, ETH_ALEN
);
2177 n
->ifindex
= ifp
->ifindex
;
2179 /* Only advertise in BGP if the knob is enabled */
2180 if (advertise_gw_macip_enabled(zevpn
)) {
2182 SET_FLAG(n
->flags
, ZEBRA_NEIGH_DEF_GW
);
2183 /* Set Router flag (R-bit) */
2184 if (ip
->ipa_type
== IPADDR_V6
)
2185 SET_FLAG(n
->flags
, ZEBRA_NEIGH_ROUTER_FLAG
);
2187 if (IS_ZEBRA_DEBUG_VXLAN
)
2189 "SVI %s(%u) L2-VNI %u, sending GW MAC %pEA IP %pIA add to BGP with flags 0x%x",
2190 ifp
->name
, ifp
->ifindex
, zevpn
->vni
,
2191 &mac
->macaddr
, ip
, n
->flags
);
2193 zebra_evpn_neigh_send_add_to_client(
2194 zevpn
->vni
, ip
, &n
->emac
, n
->mac
, n
->flags
, n
->loc_seq
);
2195 } else if (advertise_svi_macip_enabled(zevpn
)) {
2197 SET_FLAG(n
->flags
, ZEBRA_NEIGH_SVI_IP
);
2198 if (IS_ZEBRA_DEBUG_VXLAN
)
2200 "SVI %s(%u) L2-VNI %u, sending SVI MAC %pEA IP %pIA add to BGP with flags 0x%x",
2201 ifp
->name
, ifp
->ifindex
, zevpn
->vni
,
2202 &mac
->macaddr
, ip
, n
->flags
);
2204 zebra_evpn_neigh_send_add_to_client(
2205 zevpn
->vni
, ip
, &n
->emac
, n
->mac
, n
->flags
, n
->loc_seq
);
2211 void zebra_evpn_neigh_remote_uninstall(struct zebra_evpn
*zevpn
,
2212 struct zebra_vrf
*zvrf
,
2213 struct zebra_neigh
*n
,
2214 struct zebra_mac
*mac
,
2215 const struct ipaddr
*ipaddr
)
2217 if (zvrf
->dad_freeze
&& CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DUPLICATE
)
2218 && CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)
2219 && (memcmp(n
->emac
.octet
, mac
->macaddr
.octet
, ETH_ALEN
) == 0)) {
2220 struct interface
*vlan_if
;
2222 vlan_if
= zevpn_map_to_svi(zevpn
);
2223 if (IS_ZEBRA_DEBUG_VXLAN
)
2225 "%s: IP %pIA (flags 0x%x intf %s) is remote and duplicate, read kernel for local entry",
2226 __func__
, ipaddr
, n
->flags
,
2227 vlan_if
? vlan_if
->name
: "Unknown");
2229 neigh_read_specific_ip(ipaddr
, vlan_if
);
2232 /* When the MAC changes for an IP, it is possible the
2233 * client may update the new MAC before trying to delete the
2234 * "old" neighbor (as these are two different MACIP routes).
2235 * Do the delete only if the MAC matches.
2237 if (!memcmp(n
->emac
.octet
, mac
->macaddr
.octet
, ETH_ALEN
)) {
2238 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL
)) {
2239 zebra_evpn_sync_neigh_del(n
);
2240 } else if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)) {
2241 zebra_evpn_neigh_uninstall(zevpn
, n
);
2242 zebra_evpn_neigh_del(zevpn
, n
);
2243 zebra_evpn_deref_ip2mac(zevpn
, mac
);
2248 int zebra_evpn_neigh_del_ip(struct zebra_evpn
*zevpn
, const struct ipaddr
*ip
)
2250 struct zebra_neigh
*n
;
2251 struct zebra_mac
*zmac
;
2254 struct zebra_vrf
*zvrf
;
2256 /* If entry doesn't exist, nothing to do. */
2257 n
= zebra_evpn_neigh_lookup(zevpn
, ip
);
2261 zmac
= zebra_evpn_mac_lookup(zevpn
, &n
->emac
);
2263 if (IS_ZEBRA_DEBUG_VXLAN
)
2265 "Trying to del a neigh %pIA without a mac %pEA on VNI %u",
2272 /* If it is a remote entry, the kernel has aged this out or someone has
2273 * deleted it, it needs to be re-installed as FRR is the owner.
2275 if (CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_REMOTE
)) {
2276 zebra_evpn_rem_neigh_install(zevpn
, n
, false /*was_static*/);
2280 /* if this is a sync entry it cannot be dropped re-install it in
2283 old_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
2284 if (zebra_evpn_neigh_is_static(n
)) {
2285 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
)
2286 zlog_debug("re-add sync neigh vni %u ip %pIA mac %pEA 0x%x",
2287 n
->zevpn
->vni
, &n
->ip
, &n
->emac
,
2290 if (!CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
))
2291 SET_FLAG(n
->flags
, ZEBRA_NEIGH_LOCAL_INACTIVE
);
2292 /* inform-bgp about change in local-activity if any */
2293 new_bgp_ready
= zebra_evpn_neigh_is_ready_for_bgp(n
);
2294 zebra_evpn_neigh_send_add_del_to_client(n
, old_bgp_ready
,
2297 /* re-install the entry in the kernel */
2298 zebra_evpn_sync_neigh_dp_install(n
, false /* set_inactive */,
2299 false /* force_clear_static */,
2305 zvrf
= zevpn
->vxlan_if
->vrf
->info
;
2307 zlog_debug("%s: VNI %u vrf lookup failed.", __func__
,
2312 /* In case of feeze action, if local neigh is in duplicate state,
2313 * Mark the Neigh as inactive before sending delete request to BGPd,
2314 * If BGPd has remote entry, it will re-install
2316 if (zvrf
->dad_freeze
&& CHECK_FLAG(n
->flags
, ZEBRA_NEIGH_DUPLICATE
))
2317 ZEBRA_NEIGH_SET_INACTIVE(n
);
2319 /* Remove neighbor from BGP. */
2320 zebra_evpn_neigh_send_del_to_client(zevpn
->vni
, &n
->ip
, &n
->emac
,
2324 /* Delete this neighbor entry. */
2325 zebra_evpn_neigh_del(zevpn
, n
);
2327 /* see if the AUTO mac needs to be deleted */
2328 if (CHECK_FLAG(zmac
->flags
, ZEBRA_MAC_AUTO
)
2329 && !zebra_evpn_mac_in_use(zmac
))
2330 zebra_evpn_mac_del(zevpn
, zmac
);