]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_evpn_neigh.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #10719 from opensourcerouting/nb-show-fixes
[mirror_frr.git] / zebra / zebra_evpn_neigh.c
1 /*
2 * Zebra EVPN Neighbor code
3 * Copyright (C) 2016, 2017 Cumulus Networks, Inc.
4 *
5 * This file is part of FRR.
6 *
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
10 * later version.
11 *
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.
16 *
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
20 * 02111-1307, USA.
21 */
22
23 #include <zebra.h>
24
25 #include "hash.h"
26 #include "interface.h"
27 #include "jhash.h"
28 #include "memory.h"
29 #include "prefix.h"
30 #include "vlan.h"
31 #include "json.h"
32
33 #include "zebra/zserv.h"
34 #include "zebra/debug.h"
35 #include "zebra/zebra_router.h"
36 #include "zebra/rt.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"
43
44 DEFINE_MTYPE_STATIC(ZEBRA, NEIGH, "EVI Neighbor");
45
46 /*
47 * Make hash key for neighbors.
48 */
49 static unsigned int neigh_hash_keymake(const void *p)
50 {
51 const struct zebra_neigh *n = p;
52 const struct ipaddr *ip = &n->ip;
53
54 if (IS_IPADDR_V4(ip))
55 return jhash_1word(ip->ipaddr_v4.s_addr, 0);
56
57 return jhash2(ip->ipaddr_v6.s6_addr32,
58 array_size(ip->ipaddr_v6.s6_addr32), 0);
59 }
60
61 /*
62 * Compare two neighbor hash structures.
63 */
64 static bool neigh_cmp(const void *p1, const void *p2)
65 {
66 const struct zebra_neigh *n1 = p1;
67 const struct zebra_neigh *n2 = p2;
68
69 if (n1 == NULL && n2 == NULL)
70 return true;
71
72 if (n1 == NULL || n2 == NULL)
73 return false;
74
75 return ipaddr_cmp(&n1->ip, &n2->ip) == 0;
76 }
77
78 int neigh_list_cmp(void *p1, void *p2)
79 {
80 const struct zebra_neigh *n1 = p1;
81 const struct zebra_neigh *n2 = p2;
82
83 return ipaddr_cmp(&n1->ip, &n2->ip);
84 }
85
86 struct hash *zebra_neigh_db_create(const char *desc)
87 {
88 return hash_create_size(8, neigh_hash_keymake, neigh_cmp, desc);
89 }
90
91 uint32_t num_dup_detected_neighs(struct zebra_evpn *zevpn)
92 {
93 unsigned int i;
94 uint32_t num_neighs = 0;
95 struct hash *hash;
96 struct hash_bucket *hb;
97 struct zebra_neigh *nbr;
98
99 hash = zevpn->neigh_table;
100 if (!hash)
101 return num_neighs;
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))
106 num_neighs++;
107 }
108 }
109
110 return num_neighs;
111 }
112
113 /*
114 * Helper function to determine maximum width of neighbor IP address for
115 * display - just because we're dealing with IPv6 addresses that can
116 * widely vary.
117 */
118 void zebra_evpn_find_neigh_addr_width(struct hash_bucket *bucket, void *ctxt)
119 {
120 struct zebra_neigh *n;
121 char buf[INET6_ADDRSTRLEN];
122 struct neigh_walk_ctx *wctx = ctxt;
123 int width;
124
125 n = (struct zebra_neigh *)bucket->data;
126
127 ipaddr2str(&n->ip, buf, sizeof(buf));
128 width = strlen(buf);
129 if (width > wctx->addr_width)
130 wctx->addr_width = width;
131 }
132
133 /*
134 * Count of remote neighbors referencing this MAC.
135 */
136 int remote_neigh_count(struct zebra_mac *zmac)
137 {
138 struct zebra_neigh *n = NULL;
139 struct listnode *node = NULL;
140 int count = 0;
141
142 for (ALL_LIST_ELEMENTS_RO(zmac->neigh_list, node, n)) {
143 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE))
144 count++;
145 }
146
147 return count;
148 }
149
150 /*
151 * Install remote neighbor into the kernel.
152 */
153 int zebra_evpn_rem_neigh_install(struct zebra_evpn *zevpn,
154 struct zebra_neigh *n, bool was_static)
155 {
156 struct interface *vlan_if;
157 int flags;
158 int ret = 0;
159
160 if (!(n->flags & ZEBRA_NEIGH_REMOTE))
161 return 0;
162
163 vlan_if = zevpn_map_to_svi(zevpn);
164 if (!vlan_if)
165 return -1;
166
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);
171
172 dplane_rem_neigh_add(vlan_if, &n->ip, &n->emac, flags, was_static);
173
174 return ret;
175 }
176
177 /*
178 * Install neighbor hash entry - called upon access VLAN change.
179 */
180 void zebra_evpn_install_neigh_hash(struct hash_bucket *bucket, void *ctxt)
181 {
182 struct zebra_neigh *n;
183 struct neigh_walk_ctx *wctx = ctxt;
184
185 n = (struct zebra_neigh *)bucket->data;
186
187 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE))
188 zebra_evpn_rem_neigh_install(wctx->zevpn, n,
189 false /*was_static*/);
190 }
191
192 /*
193 * Callback to allocate neighbor hash entry.
194 */
195 static void *zebra_evpn_neigh_alloc(void *p)
196 {
197 const struct zebra_neigh *tmp_n = p;
198 struct zebra_neigh *n;
199
200 n = XCALLOC(MTYPE_NEIGH, sizeof(struct zebra_neigh));
201 *n = *tmp_n;
202
203 return ((void *)n);
204 }
205
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)
210 {
211 bool old_static;
212 bool new_static;
213
214 memcpy(&n->emac, macaddr, ETH_ALEN);
215 n->mac = mac;
216
217 /* Link to new MAC */
218 if (!mac)
219 return;
220
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)
227 zlog_debug(
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__);
236 }
237 }
238
239 /* sync-path that is active on an ES peer */
240 static void zebra_evpn_sync_neigh_dp_install(struct zebra_neigh *n,
241 bool set_inactive,
242 bool force_clear_static,
243 const char *caller)
244 {
245 struct zebra_ns *zns;
246 struct interface *ifp;
247 bool set_static;
248 bool set_router;
249
250 zns = zebra_ns_lookup(NS_DEFAULT);
251 ifp = if_lookup_by_index_per_ns(zns, n->ifindex);
252 if (!ifp) {
253 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
254 zlog_debug(
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);
258 return;
259 }
260
261 if (force_clear_static)
262 set_static = false;
263 else
264 set_static = zebra_evpn_neigh_is_static(n);
265
266 set_router = !!CHECK_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG);
267
268 /* XXX - this will change post integration with the new kernel */
269 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_LOCAL_INACTIVE))
270 set_inactive = true;
271
272 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
273 zlog_debug(
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,
281 set_inactive);
282 }
283
284 /*
285 * Inform BGP about local neighbor addition.
286 */
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)
291 {
292 uint8_t flags = 0;
293
294 if (CHECK_FLAG(neigh_flags, ZEBRA_NEIGH_LOCAL_INACTIVE)) {
295 /* host reachability has not been verified locally */
296
297 /* if no ES peer is claiming reachability we can't advertise
298 * the entry
299 */
300 if (!CHECK_FLAG(neigh_flags, ZEBRA_NEIGH_ES_PEER_ACTIVE))
301 return 0;
302
303 /* ES peers are claiming reachability; we will
304 * advertise the entry but with a proxy flag
305 */
306 SET_FLAG(flags, ZEBRA_MACIP_TYPE_PROXY_ADVERT);
307 }
308
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);
316
317 return zebra_evpn_macip_send_msg_to_client(vni, macaddr, ip, flags, seq,
318 ZEBRA_NEIGH_ACTIVE, zmac->es,
319 ZEBRA_MACIP_ADD);
320 }
321
322 /*
323 * Inform BGP about local neighbor deletion.
324 */
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)
328 {
329 if (!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 */
333 return 0;
334 }
335
336 return zebra_evpn_macip_send_msg_to_client(
337 vni, macaddr, ip, flags, 0, state, NULL, ZEBRA_MACIP_DEL);
338 }
339
340 static void zebra_evpn_neigh_send_add_del_to_client(struct zebra_neigh *n,
341 bool old_bgp_ready,
342 bool new_bgp_ready)
343 {
344 if (new_bgp_ready)
345 zebra_evpn_neigh_send_add_to_client(n->zevpn->vni, &n->ip,
346 &n->emac, n->mac, n->flags,
347 n->loc_seq);
348 else if (old_bgp_ready)
349 zebra_evpn_neigh_send_del_to_client(n->zevpn->vni, &n->ip,
350 &n->emac, n->flags,
351 n->state, true /*force*/);
352 }
353
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.
357 */
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)
361 {
362 struct zebra_mac *mac = n->mac;
363 bool old_mac_static;
364 bool new_mac_static;
365
366 if (old_n_static == new_n_static)
367 return;
368
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
372 */
373 if (!defer_n_dp)
374 zebra_evpn_sync_neigh_dp_install(n, false /* set_inactive */,
375 false /* force_clear_static */,
376 __func__);
377
378 if (!mac)
379 return;
380
381 /* update the mac sync ref cnt */
382 old_mac_static = zebra_evpn_mac_is_static(mac);
383 if (new_n_static) {
384 ++mac->sync_neigh_cnt;
385 } else if (old_n_static) {
386 if (mac->sync_neigh_cnt)
387 --mac->sync_neigh_cnt;
388 }
389 new_mac_static = zebra_evpn_mac_is_static(mac);
390
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 */,
395 __func__);
396
397 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
398 zlog_debug(
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,
401 mac->sync_neigh_cnt,
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);
406 }
407
408 /* Neigh hold timer is used to age out peer-active flag.
409 *
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.
413 */
414 static void zebra_evpn_neigh_hold_exp_cb(struct thread *t)
415 {
416 struct zebra_neigh *n;
417 bool old_bgp_ready;
418 bool new_bgp_ready;
419 bool old_n_static;
420 bool new_n_static;
421
422 n = THREAD_ARG(t);
423 /* the purpose of the hold timer is to age out the peer-active
424 * flag
425 */
426 if (!CHECK_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_ACTIVE))
427 return;
428
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);
434
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);
438
439 /* re-program the local neigh in the dataplane if the neigh is no
440 * longer static
441 */
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__);
446
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,
450 new_bgp_ready);
451 }
452
453 static inline void zebra_evpn_neigh_start_hold_timer(struct zebra_neigh *n)
454 {
455 if (n->hold_timer)
456 return;
457
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);
463 }
464
465 static void zebra_evpn_local_neigh_deref_mac(struct zebra_neigh *n,
466 bool send_mac_update)
467 {
468 struct zebra_mac *mac = n->mac;
469 struct zebra_evpn *zevpn = n->zevpn;
470 bool old_static;
471 bool new_static;
472
473 n->mac = NULL;
474 if (!mac)
475 return;
476
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)
482 zlog_debug(
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__);
491 }
492
493 listnode_delete(mac->neigh_list, n);
494 zebra_evpn_deref_ip2mac(zevpn, mac);
495 }
496
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,
500 bool sync)
501 {
502 uint32_t tmp_seq;
503 const char *n_type;
504
505 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_LOCAL)) {
506 tmp_seq = n->loc_seq;
507 n_type = "local";
508 } else {
509 tmp_seq = n->rem_seq;
510 n_type = "remote";
511 }
512
513 if (seq < tmp_seq) {
514 /* if the neigh was never advertised to bgp we must accept
515 * whatever sequence number bgp sends
516 * XXX - check with Vivek
517 */
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)
522 zlog_debug(
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,
526 tmp_seq, n->flags);
527 return true;
528 }
529
530 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH || IS_ZEBRA_DEBUG_VXLAN)
531 zlog_debug(
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);
535 return false;
536 }
537
538 return true;
539 }
540
541 /*
542 * Add neighbor entry.
543 */
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,
548 uint32_t n_flags)
549 {
550 struct zebra_neigh tmp_n;
551 struct zebra_neigh *n = NULL;
552
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);
556 assert(n);
557
558 n->state = ZEBRA_NEIGH_INACTIVE;
559 n->zevpn = zevpn;
560 n->dad_ip_auto_recovery_timer = NULL;
561 n->flags = n_flags;
562 n->uptime = monotime(NULL);
563
564 if (!zmac)
565 zmac = zebra_evpn_mac_lookup(zevpn, mac);
566 zebra_evpn_local_neigh_ref_mac(n, mac, zmac,
567 false /* send_mac_update */);
568
569 return n;
570 }
571
572 /*
573 * Delete neighbor entry.
574 */
575 int zebra_evpn_neigh_del(struct zebra_evpn *zevpn, struct zebra_neigh *n)
576 {
577 struct zebra_neigh *tmp_n;
578
579 if (n->mac)
580 listnode_delete(n->mac->neigh_list, n);
581
582 /* Cancel auto recovery */
583 THREAD_OFF(n->dad_ip_auto_recovery_timer);
584
585 /* Cancel proxy hold timer */
586 zebra_evpn_neigh_stop_hold_timer(n);
587
588 /* Free the VNI hash entry and allocated memory. */
589 tmp_n = hash_release(zevpn->neigh_table, n);
590 XFREE(MTYPE_NEIGH, tmp_n);
591
592 return 0;
593 }
594
595 void zebra_evpn_sync_neigh_del(struct zebra_neigh *n)
596 {
597 bool old_n_static;
598 bool new_n_static;
599
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);
603
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);
609
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__);
614 }
615
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)
620 {
621 struct interface *ifp = NULL;
622 bool is_router;
623 struct zebra_mac *mac = ctx->mac;
624 uint32_t tmp_seq;
625 bool old_router = false;
626 bool old_bgp_ready = false;
627 bool new_bgp_ready;
628 bool inform_dataplane = false;
629 bool inform_bgp = false;
630 bool old_mac_static;
631 bool new_mac_static;
632 bool set_dp_inactive = false;
633 bool created;
634 ifindex_t ifindex = 0;
635
636 /* locate l3-svi */
637 ifp = zevpn_map_to_svi(zevpn);
638 if (ifp)
639 ifindex = ifp->ifindex;
640
641 is_router = !!CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_ROUTER_FLAG);
642 old_mac_static = zebra_evpn_mac_is_static(mac);
643
644 if (!n) {
645 uint32_t n_flags = 0;
646
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);
651 else
652 SET_FLAG(n_flags, ZEBRA_NEIGH_ES_PEER_ACTIVE);
653 SET_FLAG(n_flags, ZEBRA_NEIGH_LOCAL_INACTIVE);
654
655 n = zebra_evpn_neigh_add(zevpn, ipaddr, &mac->macaddr, mac,
656 n_flags);
657 n->ifindex = ifindex;
658 ZEBRA_NEIGH_SET_ACTIVE(n);
659
660 created = true;
661 inform_dataplane = true;
662 inform_bgp = true;
663 set_dp_inactive = true;
664 } else {
665 bool mac_change;
666 uint32_t old_flags = n->flags;
667 bool old_n_static;
668 bool new_n_static;
669
670 created = false;
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);
674
675 mac_change = !!memcmp(&n->emac, &mac->macaddr, ETH_ALEN);
676
677 /* deref and clear old info */
678 if (mac_change) {
679 if (old_bgp_ready) {
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;
684 }
685 zebra_evpn_local_neigh_deref_mac(n,
686 false /*send_mac_update*/);
687 }
688 /* clear old fwd info */
689 n->rem_seq = 0;
690 n->r_vtep_ip.s_addr = 0;
691
692 /* setup new flags */
693 n->flags = 0;
694 SET_FLAG(n->flags, ZEBRA_NEIGH_LOCAL);
695 /* retain activity flag if the neigh was
696 * previously local
697 */
698 if (old_flags & ZEBRA_NEIGH_LOCAL) {
699 n->flags |= (old_flags & ZEBRA_NEIGH_LOCAL_INACTIVE);
700 } else {
701 inform_dataplane = true;
702 set_dp_inactive = true;
703 n->flags |= ZEBRA_NEIGH_LOCAL_INACTIVE;
704 }
705
706 if (CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_PROXY_ADVERT))
707 SET_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_PROXY);
708 else
709 SET_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_ACTIVE);
710
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.
717 */
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);
721 }
722 } else {
723 SET_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_ACTIVE);
724 /* stop hold timer if a peer has verified
725 * reachability
726 */
727 zebra_evpn_neigh_stop_hold_timer(n);
728 }
729 ZEBRA_NEIGH_SET_ACTIVE(n);
730
731 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH && (old_flags != n->flags))
732 zlog_debug(
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);
736
737 new_n_static = zebra_evpn_neigh_is_static(n);
738 if (mac_change) {
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
749 * the existing mac
750 */
751 zebra_evpn_sync_neigh_static_chg(
752 n, old_n_static, new_n_static,
753 true /*defer_dp*/, true /*defer_mac_dp*/,
754 __func__);
755 }
756
757 /* Update the forwarding info. */
758 if (n->ifindex != ifindex) {
759 n->ifindex = ifindex;
760 inform_dataplane = true;
761 }
762
763 n->uptime = monotime(NULL);
764 }
765
766 /* update the neigh seq. we don't bother with the mac seq as
767 * sync_mac_update already took care of that
768 */
769 tmp_seq = MAX(n->loc_seq, seq);
770 if (tmp_seq != n->loc_seq) {
771 n->loc_seq = tmp_seq;
772 inform_bgp = true;
773 }
774
775 /* Mark Router flag (R-bit) */
776 if (is_router)
777 SET_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG);
778 else
779 UNSET_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG);
780
781 if (old_router != is_router)
782 inform_dataplane = true;
783
784 new_bgp_ready = zebra_evpn_neigh_is_ready_for_bgp(n);
785 if (old_bgp_ready != new_bgp_ready)
786 inform_bgp = true;
787
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 */,
792 __func__);
793
794 if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
795 zlog_debug(
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,
798 &n->ip, &n->emac,
799 ifp ? ifp->name : "", ifindex, n->loc_seq, n->flags,
800 inform_bgp ? " inform_bgp" : "",
801 inform_dataplane ? " inform_dp" : "");
802
803 if (inform_dataplane)
804 zebra_evpn_sync_neigh_dp_install(n, set_dp_inactive,
805 false /* force_clear_static */,
806 __func__);
807
808 if (inform_bgp)
809 zebra_evpn_neigh_send_add_del_to_client(n, old_bgp_ready,
810 new_bgp_ready);
811
812 return n;
813 }
814
815 /*
816 * Uninstall remote neighbor from the kernel.
817 */
818 static int zebra_evpn_neigh_uninstall(struct zebra_evpn *zevpn,
819 struct zebra_neigh *n)
820 {
821 struct interface *vlan_if;
822
823 if (!(n->flags & ZEBRA_NEIGH_REMOTE))
824 return 0;
825
826 vlan_if = zevpn_map_to_svi(zevpn);
827 if (!vlan_if)
828 return -1;
829
830 ZEBRA_NEIGH_SET_INACTIVE(n);
831 n->loc_seq = 0;
832
833 dplane_rem_neigh_delete(vlan_if, &n->ip);
834
835 return 0;
836 }
837
838 /*
839 * Free neighbor hash entry (callback)
840 */
841 static void zebra_evpn_neigh_del_hash_entry(struct hash_bucket *bucket,
842 void *arg)
843 {
844 struct neigh_walk_ctx *wctx = arg;
845 struct zebra_neigh *n = bucket->data;
846
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*/);
857
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 */,
863 __func__);
864 if ((n->flags & ZEBRA_NEIGH_REMOTE))
865 zebra_evpn_neigh_uninstall(wctx->zevpn, n);
866 }
867
868 zebra_evpn_neigh_del(wctx->zevpn, n);
869 }
870
871 return;
872 }
873
874 /*
875 * Delete all neighbor entries for this EVPN.
876 */
877 void zebra_evpn_neigh_del_all(struct zebra_evpn *zevpn, int uninstall,
878 int upd_client, uint32_t flags)
879 {
880 struct neigh_walk_ctx wctx;
881
882 if (!zevpn->neigh_table)
883 return;
884
885 memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
886 wctx.zevpn = zevpn;
887 wctx.uninstall = uninstall;
888 wctx.upd_client = upd_client;
889 wctx.flags = flags;
890
891 hash_iterate(zevpn->neigh_table, zebra_evpn_neigh_del_hash_entry,
892 &wctx);
893 }
894
895 /*
896 * Look up neighbor hash entry.
897 */
898 struct zebra_neigh *zebra_evpn_neigh_lookup(struct zebra_evpn *zevpn,
899 const struct ipaddr *ip)
900 {
901 struct zebra_neigh tmp;
902 struct zebra_neigh *n;
903
904 memset(&tmp, 0, sizeof(tmp));
905 memcpy(&tmp.ip, ip, sizeof(struct ipaddr));
906 n = hash_lookup(zevpn->neigh_table, &tmp);
907
908 return n;
909 }
910
911 /*
912 * Process all neighbors associated with a MAC upon the MAC being learnt
913 * locally or undergoing any other change (such as sequence number).
914 */
915 void zebra_evpn_process_neigh_on_local_mac_change(struct zebra_evpn *zevpn,
916 struct zebra_mac *zmac,
917 bool seq_change,
918 bool es_change)
919 {
920 struct zebra_neigh *n = NULL;
921 struct listnode *node = NULL;
922 struct zebra_vrf *zvrf = NULL;
923
924 zvrf = zevpn->vxlan_if->vrf->info;
925
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",
929 zevpn->vni);
930
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.
936 */
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
940 || es_change) {
941 ZEBRA_NEIGH_SET_ACTIVE(n);
942 n->loc_seq = zmac->loc_seq;
943 if (!(zebra_evpn_do_dup_addr_detect(zvrf)
944 && zvrf->dad_freeze
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);
950 }
951 }
952 }
953 }
954
955 /*
956 * Process all neighbors associated with a local MAC upon the MAC being
957 * deleted.
958 */
959 void zebra_evpn_process_neigh_on_local_mac_del(struct zebra_evpn *zevpn,
960 struct zebra_mac *zmac)
961 {
962 struct zebra_neigh *n = NULL;
963 struct listnode *node = NULL;
964
965 if (IS_ZEBRA_DEBUG_VXLAN)
966 zlog_debug("Processing neighbors on local MAC %pEA DEL, VNI %u",
967 &zmac->macaddr, zevpn->vni);
968
969 /* Walk all local neighbors and mark as inactive and inform
970 * BGP, if needed.
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?
974 */
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);
979 n->loc_seq = 0;
980 zebra_evpn_neigh_send_del_to_client(
981 zevpn->vni, &n->ip, &n->emac, n->flags,
982 ZEBRA_NEIGH_ACTIVE, false /*force*/);
983 }
984 }
985 }
986 }
987
988 /*
989 * Process all neighbors associated with a MAC upon the MAC being remotely
990 * learnt.
991 */
992 void zebra_evpn_process_neigh_on_remote_mac_add(struct zebra_evpn *zevpn,
993 struct zebra_mac *zmac)
994 {
995 struct zebra_neigh *n = NULL;
996 struct listnode *node = NULL;
997
998 if (IS_ZEBRA_DEBUG_VXLAN)
999 zlog_debug("Processing neighbors on remote MAC %pEA ADD, VNI %u",
1000 &zmac->macaddr, zevpn->vni);
1001
1002 /* Walk all local neighbors and mark as inactive and inform
1003 * BGP, if needed.
1004 */
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);
1009 n->loc_seq = 0;
1010 zebra_evpn_neigh_send_del_to_client(
1011 zevpn->vni, &n->ip, &n->emac, n->flags,
1012 ZEBRA_NEIGH_ACTIVE, false /* force */);
1013 }
1014 }
1015 }
1016 }
1017
1018 /*
1019 * Process all neighbors associated with a remote MAC upon the MAC being
1020 * deleted.
1021 */
1022 void zebra_evpn_process_neigh_on_remote_mac_del(struct zebra_evpn *zevpn,
1023 struct zebra_mac *zmac)
1024 {
1025 /* NOTE: Currently a NO-OP. */
1026 }
1027
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)
1032 {
1033 if (!IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
1034 return;
1035
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);
1044 }
1045
1046 /* As part Duplicate Address Detection (DAD) for IP mobility
1047 * MAC binding changes, ensure to inherit duplicate flag
1048 * from MAC.
1049 */
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)
1054 {
1055 bool is_old_mac_dup = false;
1056 bool is_new_mac_dup = false;
1057
1058 if (!zebra_evpn_do_dup_addr_detect(zvrf))
1059 return 0;
1060 /* Check old or new MAC is detected as duplicate
1061 * mark this neigh as duplicate
1062 */
1063 if (old_zmac)
1064 is_old_mac_dup =
1065 CHECK_FLAG(old_zmac->flags, ZEBRA_MAC_DUPLICATE);
1066 if (new_zmac)
1067 is_new_mac_dup =
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.
1075 */
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);
1082
1083 return 1;
1084 } else if (is_old_mac_dup && !is_new_mac_dup) {
1085 UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
1086 nbr->dad_count = 0;
1087 nbr->detect_start_time.tv_sec = 0;
1088 nbr->detect_start_time.tv_usec = 0;
1089 }
1090 return 0;
1091 }
1092
1093 static void zebra_evpn_dad_ip_auto_recovery_exp(struct thread *t)
1094 {
1095 struct zebra_vrf *zvrf = NULL;
1096 struct zebra_neigh *nbr = NULL;
1097 struct zebra_evpn *zevpn = NULL;
1098
1099 nbr = THREAD_ARG(t);
1100
1101 /* since this is asynchronous we need sanity checks*/
1102 zvrf = vrf_info_lookup(nbr->zevpn->vrf_id);
1103 if (!zvrf)
1104 return;
1105
1106 zevpn = zebra_evpn_lookup(nbr->zevpn->vni);
1107 if (!zevpn)
1108 return;
1109
1110 nbr = zebra_evpn_neigh_lookup(zevpn, &nbr->ip);
1111 if (!nbr)
1112 return;
1113
1114 if (IS_ZEBRA_DEBUG_VXLAN)
1115 zlog_debug(
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);
1119
1120 UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
1121 nbr->dad_count = 0;
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);
1127
1128 /* Send to BGP */
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*/);
1135 }
1136 }
1137
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)
1141 {
1142
1143 struct timeval elapsed = {0, 0};
1144 bool reset_params = false;
1145
1146 if (!zebra_evpn_do_dup_addr_detect(zvrf))
1147 return;
1148
1149 /* IP is detected as duplicate or inherit dup
1150 * state, hold on to install as remote entry
1151 * only if freeze is enabled.
1152 */
1153 if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE)) {
1154 if (IS_ZEBRA_DEBUG_VXLAN)
1155 zlog_debug(
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);
1160
1161 if (zvrf->dad_freeze)
1162 *is_dup_detect = true;
1163
1164 /* warn-only action, neigh will be installed.
1165 * freeze action, it wil not be installed.
1166 */
1167 return;
1168 }
1169
1170 if (!do_dad)
1171 return;
1172
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.
1177 */
1178 monotime_since(&nbr->detect_start_time, &elapsed);
1179 reset_params = (elapsed.tv_sec > zvrf->dad_time);
1180
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.
1184 *
1185 * NOTE: This is the START of the probe with count is
1186 * 0 during LOCAL learn event.
1187 */
1188 reset_params = !nbr->dad_count;
1189 }
1190
1191 if (reset_params) {
1192 if (IS_ZEBRA_DEBUG_VXLAN)
1193 zlog_debug(
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.
1199 */
1200 nbr->dad_count = 0;
1201 /* Start dup. addr detection (DAD) start time,
1202 * ONLY during LOCAL learn.
1203 */
1204 if (is_local)
1205 monotime(&nbr->detect_start_time);
1206
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.
1211 */
1212 nbr->dad_count++;
1213 }
1214
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.
1218 */
1219 if (is_local)
1220 nbr->dad_count++;
1221
1222 if (nbr->dad_count >= zvrf->dad_max_moves) {
1223 flog_warn(
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",
1228 &vtep_ip);
1229
1230 SET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
1231
1232 /* Capture Duplicate detection time */
1233 nbr->dad_dup_detect_time = monotime(NULL);
1234
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)
1239 zlog_debug(
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);
1243
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);
1248 }
1249 if (zvrf->dad_freeze)
1250 *is_dup_detect = true;
1251 }
1252 }
1253
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)
1259 {
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;
1274 bool new_bgp_ready;
1275
1276 /* Check if the MAC exists. */
1277 zmac = zebra_evpn_mac_lookup(zevpn, macaddr);
1278 if (!zmac) {
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);
1283
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);
1288 } else {
1289 if (CHECK_FLAG(zmac->flags, ZEBRA_MAC_REMOTE)) {
1290 /*
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
1295 * local.
1296 */
1297 upd_mac_seq = true;
1298 }
1299 }
1300
1301 zvrf = zevpn->vxlan_if->vrf->info;
1302 if (!zvrf) {
1303 if (IS_ZEBRA_DEBUG_VXLAN)
1304 zlog_debug(" Unable to find vrf for: %d",
1305 zevpn->vxlan_if->vrf->vrf_id);
1306 return -1;
1307 }
1308
1309 /* Check if the neighbor exists. */
1310 n = zebra_evpn_neigh_lookup(zevpn, ip);
1311 if (!n) {
1312 /* New neighbor - create */
1313 n = zebra_evpn_neigh_add(zevpn, ip, macaddr, zmac, 0);
1314
1315 /* Set "local" forwarding info. */
1316 SET_FLAG(n->flags, ZEBRA_NEIGH_LOCAL);
1317 n->ifindex = ifp->ifindex;
1318 created = true;
1319 } else {
1320 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_LOCAL)) {
1321 bool mac_different;
1322 bool cur_is_router;
1323 bool old_local_inactive;
1324
1325 old_local_inactive = !!CHECK_FLAG(
1326 n->flags, ZEBRA_NEIGH_LOCAL_INACTIVE);
1327
1328 old_bgp_ready = zebra_evpn_neigh_is_ready_for_bgp(n);
1329
1330 /* Note any changes and see if of interest to BGP. */
1331 mac_different = !!memcmp(&n->emac, macaddr, ETH_ALEN);
1332 cur_is_router =
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)
1339 zlog_debug(
1340 " Ignoring entry mac is the same and is_router == cur_is_router");
1341 n->ifindex = ifp->ifindex;
1342 return 0;
1343 }
1344
1345 old_zmac = n->mac;
1346 if (!mac_different) {
1347 /* XXX - cleanup this code duplication */
1348 bool is_neigh_freezed = false;
1349
1350 /* Only the router flag has changed. */
1351 if (is_router)
1352 SET_FLAG(n->flags,
1353 ZEBRA_NEIGH_ROUTER_FLAG);
1354 else
1355 UNSET_FLAG(n->flags,
1356 ZEBRA_NEIGH_ROUTER_FLAG);
1357
1358 if (local_inactive)
1359 SET_FLAG(n->flags,
1360 ZEBRA_NEIGH_LOCAL_INACTIVE);
1361 else
1362 UNSET_FLAG(n->flags,
1363 ZEBRA_NEIGH_LOCAL_INACTIVE);
1364 new_bgp_ready =
1365 zebra_evpn_neigh_is_ready_for_bgp(n);
1366
1367 if (dp_static != new_static)
1368 inform_dataplane = true;
1369
1370 /* Neigh is in freeze state and freeze action
1371 * is enabled, do not send update to client.
1372 */
1373 is_neigh_freezed =
1374 (zebra_evpn_do_dup_addr_detect(zvrf)
1375 && zvrf->dad_freeze
1376 && CHECK_FLAG(n->flags,
1377 ZEBRA_NEIGH_DUPLICATE));
1378
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");
1383
1384 if (inform_dataplane)
1385 zebra_evpn_sync_neigh_dp_install(
1386 n, false /* set_inactive */,
1387 false /* force_clear_static */,
1388 __func__);
1389
1390 /* if the neigh can no longer be advertised
1391 * remove it from bgp
1392 */
1393 if (!is_neigh_freezed) {
1394 zebra_evpn_neigh_send_add_del_to_client(
1395 n, old_bgp_ready,
1396 new_bgp_ready);
1397 } else {
1398 if (IS_ZEBRA_DEBUG_VXLAN
1399 && IS_ZEBRA_NEIGH_ACTIVE(n))
1400 zlog_debug(
1401 " Neighbor active and frozen");
1402 }
1403 return 0;
1404 }
1405
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.
1411 */
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;
1417 }
1418 if (old_zmac) {
1419 old_mac_seq = CHECK_FLAG(old_zmac->flags,
1420 ZEBRA_MAC_REMOTE)
1421 ? old_zmac->rem_seq
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 */);
1426 }
1427
1428 /* if mac changes abandon peer flags and tell
1429 * dataplane to clear the static flag
1430 */
1431 if (zebra_evpn_neigh_clear_sync_info(n))
1432 inform_dataplane = true;
1433 /* Update the forwarding info. */
1434 n->ifindex = ifp->ifindex;
1435
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)) {
1440 /*
1441 * Neighbor has moved from remote to local. Its
1442 * MAC could have also changed as part of the move.
1443 */
1444 if (memcmp(n->emac.octet, macaddr->octet, ETH_ALEN)
1445 != 0) {
1446 old_zmac = n->mac;
1447 if (old_zmac) {
1448 old_mac_seq =
1449 CHECK_FLAG(old_zmac->flags,
1450 ZEBRA_MAC_REMOTE)
1451 ? old_zmac->rem_seq
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 */);
1456 }
1457
1458 /* Link to new MAC */
1459 zebra_evpn_local_neigh_ref_mac(
1460 n, macaddr, zmac, true /*send_update*/);
1461 }
1462 /* Based on Mobility event Scenario-B from the
1463 * draft, neigh's previous state was remote treat this
1464 * event for DAD.
1465 */
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;
1473 }
1474 }
1475
1476 /* If MAC was previously remote, or the neighbor had a different
1477 * MAC earlier, recompute the sequence number.
1478 */
1479 if (upd_mac_seq) {
1480 uint32_t seq1, seq2;
1481
1482 seq1 = CHECK_FLAG(zmac->flags, ZEBRA_MAC_REMOTE)
1483 ? zmac->rem_seq + 1
1484 : zmac->loc_seq;
1485 seq2 = neigh_mac_change ? old_mac_seq + 1 : 0;
1486 mac_new_seq = zmac->loc_seq < MAX(seq1, seq2) ? MAX(seq1, seq2)
1487 : zmac->loc_seq;
1488 }
1489
1490 if (local_inactive)
1491 SET_FLAG(n->flags, ZEBRA_NEIGH_LOCAL_INACTIVE);
1492 else
1493 UNSET_FLAG(n->flags, ZEBRA_NEIGH_LOCAL_INACTIVE);
1494
1495 /* Mark Router flag (R-bit) */
1496 if (is_router)
1497 SET_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG);
1498 else
1499 UNSET_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG);
1500
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;
1506
1507 /* Check old and/or new MAC detected as duplicate mark
1508 * the neigh as duplicate
1509 */
1510 if (zebra_evpn_ip_inherit_dad_from_mac(zvrf, old_zmac, zmac, n)) {
1511 flog_warn(
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);
1515 }
1516
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.
1521 */
1522 if (neigh_mac_change && neigh_was_remote)
1523 do_dad = true;
1524
1525 zebra_evpn_dup_addr_detect_for_neigh(zvrf, n, vtep_ip, do_dad,
1526 &neigh_on_hold, true);
1527
1528 if (inform_dataplane)
1529 zebra_evpn_sync_neigh_dp_install(n, false /* set_inactive */,
1530 false /* force_clear_static */,
1531 __func__);
1532
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.
1535 */
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);
1541 n->loc_seq = 0;
1542 zmac->loc_seq = mac_new_seq;
1543 return 0;
1544 }
1545
1546 zebra_evpn_local_neigh_update_log("local", n, is_router, local_inactive,
1547 false, false, inform_dataplane, true,
1548 created ? "created" : "updated");
1549
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
1552 * neighbor.
1553 */
1554 if (upd_mac_seq && zmac->loc_seq != mac_new_seq) {
1555 if (IS_ZEBRA_DEBUG_VXLAN)
1556 zlog_debug(
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,
1562 zmac->flags,
1563 zmac->loc_seq, zmac->es))
1564 return -1;
1565 zebra_evpn_process_neigh_on_local_mac_change(zevpn, zmac, 1,
1566 0 /*es_change*/);
1567 return 0;
1568 }
1569
1570 n->loc_seq = zmac->loc_seq;
1571
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,
1576 new_bgp_ready);
1577 } else {
1578 if (IS_ZEBRA_DEBUG_VXLAN)
1579 zlog_debug(" Neighbor on hold not sending");
1580 }
1581 return 0;
1582 }
1583
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,
1588 uint16_t state)
1589 {
1590 struct zebra_neigh *n = NULL;
1591 struct zebra_mac *zmac = NULL;
1592
1593 /* If the neighbor is unknown, there is no further action. */
1594 n = zebra_evpn_neigh_lookup(zevpn, ip);
1595 if (!n)
1596 return 0;
1597
1598 /* If a remote entry, see if it needs to be refreshed */
1599 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
1600 #ifdef GNU_LINUX
1601 if (state & NUD_STALE)
1602 zebra_evpn_rem_neigh_install(zevpn, n,
1603 false /*was_static*/);
1604 #endif
1605 } else {
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".
1610 */
1611 zmac = zebra_evpn_mac_lookup(zevpn, macaddr);
1612 if (!zmac || !CHECK_FLAG(zmac->flags, ZEBRA_MAC_REMOTE)) {
1613 zlog_debug(
1614 "Ignore remote neigh %pIA (MAC %pEA) on L2-VNI %u - MAC unknown or local",
1615 &n->ip, macaddr, zevpn->vni);
1616 return -1;
1617 }
1618
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;
1623 }
1624
1625 return 0;
1626 }
1627
1628 /* Notify Neighbor entries to the Client, skips the GW entry */
1629 static void
1630 zebra_evpn_send_neigh_hash_entry_to_client(struct hash_bucket *bucket,
1631 void *arg)
1632 {
1633 struct mac_walk_ctx *wctx = arg;
1634 struct zebra_neigh *zn = bucket->data;
1635 struct zebra_mac *zmac = NULL;
1636
1637 if (CHECK_FLAG(zn->flags, ZEBRA_NEIGH_DEF_GW))
1638 return;
1639
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);
1643 if (!zmac)
1644 return;
1645
1646 zebra_evpn_neigh_send_add_to_client(wctx->zevpn->vni, &zn->ip,
1647 &zn->emac, zn->mac,
1648 zn->flags, zn->loc_seq);
1649 }
1650 }
1651
1652 /* Iterator of a specific EVPN */
1653 void zebra_evpn_send_neigh_to_client(struct zebra_evpn *zevpn)
1654 {
1655 struct neigh_walk_ctx wctx;
1656
1657 memset(&wctx, 0, sizeof(struct neigh_walk_ctx));
1658 wctx.zevpn = zevpn;
1659
1660 hash_iterate(zevpn->neigh_table,
1661 zebra_evpn_send_neigh_hash_entry_to_client, &wctx);
1662 }
1663
1664 void zebra_evpn_clear_dup_neigh_hash(struct hash_bucket *bucket, void *ctxt)
1665 {
1666 struct neigh_walk_ctx *wctx = ctxt;
1667 struct zebra_neigh *nbr;
1668 struct zebra_evpn *zevpn;
1669 char buf[INET6_ADDRSTRLEN];
1670
1671 nbr = (struct zebra_neigh *)bucket->data;
1672 if (!nbr)
1673 return;
1674
1675 zevpn = wctx->zevpn;
1676
1677 if (!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
1678 return;
1679
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);
1684 }
1685
1686 UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
1687 nbr->dad_count = 0;
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);
1692
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*/);
1699 }
1700 }
1701
1702 /*
1703 * Print a specific neighbor entry.
1704 */
1705 void zebra_evpn_print_neigh(struct zebra_neigh *n, void *ctxt,
1706 json_object *json)
1707 {
1708 struct vty *vty;
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];
1718 time_t uptime;
1719 char up_str[MONOTIME_STRLEN];
1720
1721 zvrf = zebra_vrf_get_evpn();
1722 if (!zvrf)
1723 return;
1724
1725 uptime = monotime(NULL);
1726 uptime -= n->uptime;
1727
1728 frrtime_to_interval(uptime, up_str, sizeof(up_str));
1729
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;
1735 if (json == NULL) {
1736 bool sync_info = false;
1737
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");
1748 sync_info = true;
1749 }
1750 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_PROXY)) {
1751 vty_out(vty, " peer-proxy");
1752 sync_info = true;
1753 }
1754 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_ES_PEER_ACTIVE)) {
1755 vty_out(vty, " peer-active");
1756 sync_info = true;
1757 }
1758 if (n->hold_timer) {
1759 vty_out(vty, " (ht: %s)",
1760 thread_timer_to_hhmmss(thread_buf,
1761 sizeof(thread_buf),
1762 n->hold_timer));
1763 sync_info = true;
1764 }
1765 if (!sync_info)
1766 vty_out(vty, " -");
1767 vty_out(vty, "\n");
1768 } else {
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");
1780 if (n->hold_timer)
1781 json_object_string_add(
1782 json, "peerActiveHold",
1783 thread_timer_to_hhmmss(thread_buf,
1784 sizeof(thread_buf),
1785 n->hold_timer));
1786 }
1787 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
1788 if (n->mac->es) {
1789 if (json)
1790 json_object_string_add(json, "remoteEs",
1791 n->mac->es->esi_str);
1792 else
1793 vty_out(vty, " Remote ES: %s\n",
1794 n->mac->es->esi_str);
1795 } else {
1796 if (json)
1797 json_object_string_addf(json, "remoteVtep",
1798 "%pI4", &n->r_vtep_ip);
1799 else
1800 vty_out(vty, " Remote VTEP: %pI4\n",
1801 &n->r_vtep_ip);
1802 }
1803 }
1804 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_DEF_GW)) {
1805 if (!json) {
1806 vty_out(vty, " Flags: Default-gateway");
1807 flags_present = true;
1808 } else
1809 json_object_boolean_true_add(json, "defaultGateway");
1810 }
1811 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG)) {
1812 if (!json) {
1813 vty_out(vty,
1814 flags_present ? " ,Router" : " Flags: Router");
1815 flags_present = true;
1816 }
1817 }
1818 if (json == NULL) {
1819 if (flags_present)
1820 vty_out(vty, "\n");
1821 vty_out(vty, " Local Seq: %u Remote Seq: %u\n", n->loc_seq,
1822 n->rem_seq);
1823
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,
1827 timebuf));
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,
1833 timebuf);
1834 vty_out(vty,
1835 " Duplicate detection started at %s, detection count %u\n",
1836 timebuf, n->dad_count);
1837 }
1838 }
1839 } else {
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");
1845 else
1846 json_object_boolean_false_add(json, "isDuplicate");
1847 }
1848 }
1849
1850 void zebra_evpn_print_neigh_hdr(struct vty *vty, struct neigh_walk_ctx *wctx)
1851 {
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",
1855 "Seq #'s");
1856 }
1857
1858 static char *zebra_evpn_print_neigh_flags(struct zebra_neigh *n,
1859 char *flags_buf,
1860 uint32_t flags_buf_sz)
1861 {
1862 snprintf(flags_buf, flags_buf_sz, "%s%s%s",
1863 (n->flags & ZEBRA_NEIGH_ES_PEER_ACTIVE) ?
1864 "P" : "",
1865 (n->flags & ZEBRA_NEIGH_ES_PEER_PROXY) ?
1866 "X" : "",
1867 (n->flags & ZEBRA_NEIGH_LOCAL_INACTIVE) ?
1868 "I" : "");
1869
1870 return flags_buf;
1871 }
1872
1873 /*
1874 * Print neighbor hash entry - called for display of all neighbors.
1875 */
1876 void zebra_evpn_print_neigh_hash(struct hash_bucket *bucket, void *ctxt)
1877 {
1878 struct vty *vty;
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;
1886 char flags_buf[6];
1887
1888 vty = wctx->vty;
1889 json_evpn = wctx->json;
1890 n = (struct zebra_neigh *)bucket->data;
1891
1892 if (json_evpn)
1893 json_row = json_object_new_object();
1894
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)
1900 return;
1901
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);
1908 } else {
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,
1914 "defaultGateway");
1915 json_object_int_add(json_row, "localSequence",
1916 n->loc_seq);
1917 json_object_int_add(json_row, "remoteSequence",
1918 n->rem_seq);
1919 json_object_int_add(json_row, "detectionCount",
1920 n->dad_count);
1921 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_DUPLICATE))
1922 json_object_boolean_true_add(json_row,
1923 "isDuplicate");
1924 else
1925 json_object_boolean_false_add(json_row,
1926 "isDuplicate");
1927 }
1928 wctx->count++;
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))
1932 return;
1933
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);
1938
1939 if (n->mac->es == NULL)
1940 inet_ntop(AF_INET, &n->r_vtep_ip,
1941 addr_buf, sizeof(addr_buf));
1942
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);
1949 } else {
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);
1953 if (n->mac->es)
1954 json_object_string_add(json_row, "remoteEs",
1955 n->mac->es->esi_str);
1956 else
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,
1961 "defaultGateway");
1962 json_object_int_add(json_row, "localSequence",
1963 n->loc_seq);
1964 json_object_int_add(json_row, "remoteSequence",
1965 n->rem_seq);
1966 json_object_int_add(json_row, "detectionCount",
1967 n->dad_count);
1968 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_DUPLICATE))
1969 json_object_boolean_true_add(json_row,
1970 "isDuplicate");
1971 else
1972 json_object_boolean_false_add(json_row,
1973 "isDuplicate");
1974 }
1975 wctx->count++;
1976 }
1977
1978 if (json_evpn)
1979 json_object_object_add(json_evpn, buf2, json_row);
1980 }
1981
1982 /*
1983 * Print neighbor hash entry in detail - called for display of all neighbors.
1984 */
1985 void zebra_evpn_print_neigh_hash_detail(struct hash_bucket *bucket, void *ctxt)
1986 {
1987 struct vty *vty;
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;
1992
1993 vty = wctx->vty;
1994 json_evpn = wctx->json;
1995 n = (struct zebra_neigh *)bucket->data;
1996 if (!n)
1997 return;
1998
1999 ipaddr2str(&n->ip, buf, sizeof(buf));
2000 if (json_evpn)
2001 json_row = json_object_new_object();
2002
2003 zebra_evpn_print_neigh(n, vty, json_row);
2004
2005 if (json_evpn)
2006 json_object_object_add(json_evpn, buf, json_row);
2007 }
2008
2009 void zebra_evpn_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt)
2010 {
2011 struct zebra_neigh *nbr;
2012
2013 nbr = (struct zebra_neigh *)bucket->data;
2014 if (!nbr)
2015 return;
2016
2017 if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
2018 zebra_evpn_print_neigh_hash(bucket, ctxt);
2019 }
2020
2021 void zebra_evpn_print_dad_neigh_hash_detail(struct hash_bucket *bucket,
2022 void *ctxt)
2023 {
2024 struct zebra_neigh *nbr;
2025
2026 nbr = (struct zebra_neigh *)bucket->data;
2027 if (!nbr)
2028 return;
2029
2030 if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE))
2031 zebra_evpn_print_neigh_hash_detail(bucket, ctxt);
2032 }
2033
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,
2039 uint32_t seq)
2040 {
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;
2047 bool is_router;
2048
2049 assert(mac);
2050 is_router = !!CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_ROUTER_FLAG);
2051
2052 /* Check if the remote neighbor itself is unknown or has a
2053 * change. If so, create or update and then install the entry.
2054 */
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)
2060 update_neigh = 1;
2061
2062 if (update_neigh) {
2063 if (!n) {
2064 n = zebra_evpn_neigh_add(zevpn, ipaddr, &mac->macaddr,
2065 mac, 0);
2066 } else {
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
2073 * if appropriate.
2074 */
2075
2076 if (!zebra_evpn_neigh_is_bgp_seq_ok(
2077 zevpn, n, &mac->macaddr, seq, false))
2078 return;
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)
2082 zlog_debug(
2083 "sync->remote neigh vni %u ip %pIA mac %pEA seq %d f0x%x",
2084 n->zevpn->vni, &n->ip, &n->emac,
2085 seq, n->flags);
2086 if (IS_ZEBRA_NEIGH_ACTIVE(n))
2087 zebra_evpn_neigh_send_del_to_client(
2088 zevpn->vni, &n->ip, &n->emac,
2089 n->flags, n->state,
2090 false /*force*/);
2091 zebra_evpn_neigh_clear_sync_info(n);
2092 }
2093 if (memcmp(&n->emac, &mac->macaddr,
2094 sizeof(struct ethaddr))
2095 != 0) {
2096 /* update neigh list for macs */
2097 old_mac =
2098 zebra_evpn_mac_lookup(zevpn, &n->emac);
2099 if (old_mac) {
2100 listnode_delete(old_mac->neigh_list, n);
2101 n->mac = NULL;
2102 zebra_evpn_deref_ip2mac(zevpn, old_mac);
2103 }
2104 n->mac = mac;
2105 listnode_add_sort(mac->neigh_list, n);
2106 memcpy(&n->emac, &mac->macaddr, ETH_ALEN);
2107
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.
2112 *
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.
2118 *
2119 * Mobilty event scenario-B IP-MAC binding
2120 * changed.
2121 */
2122 if ((!CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE))
2123 && n->dad_count)
2124 do_dad = true;
2125 }
2126 }
2127
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);
2132
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);
2136 else
2137 UNSET_FLAG(n->flags, ZEBRA_NEIGH_ROUTER_FLAG);
2138
2139 /* Check old or new MAC detected as duplicate,
2140 * inherit duplicate flag to this neigh.
2141 */
2142 if (zebra_evpn_ip_inherit_dad_from_mac(zvrf, old_mac, mac, n)) {
2143 flog_warn(
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);
2147 }
2148
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. */
2153 if (!is_dup_detect)
2154 zebra_evpn_rem_neigh_install(zevpn, n, old_static);
2155 }
2156
2157 /* Update seq number. */
2158 n->rem_seq = seq;
2159 }
2160
2161 int zebra_evpn_neigh_gw_macip_add(struct interface *ifp,
2162 struct zebra_evpn *zevpn, struct ipaddr *ip,
2163 struct zebra_mac *mac)
2164 {
2165 struct zebra_neigh *n;
2166
2167 assert(mac);
2168
2169 n = zebra_evpn_neigh_lookup(zevpn, ip);
2170 if (!n)
2171 n = zebra_evpn_neigh_add(zevpn, ip, &mac->macaddr, mac, 0);
2172
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;
2178
2179 /* Only advertise in BGP if the knob is enabled */
2180 if (advertise_gw_macip_enabled(zevpn)) {
2181
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);
2186
2187 if (IS_ZEBRA_DEBUG_VXLAN)
2188 zlog_debug(
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);
2192
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)) {
2196
2197 SET_FLAG(n->flags, ZEBRA_NEIGH_SVI_IP);
2198 if (IS_ZEBRA_DEBUG_VXLAN)
2199 zlog_debug(
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);
2203
2204 zebra_evpn_neigh_send_add_to_client(
2205 zevpn->vni, ip, &n->emac, n->mac, n->flags, n->loc_seq);
2206 }
2207
2208 return 0;
2209 }
2210
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)
2216 {
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;
2221
2222 vlan_if = zevpn_map_to_svi(zevpn);
2223 if (IS_ZEBRA_DEBUG_VXLAN)
2224 zlog_debug(
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");
2228 if (vlan_if)
2229 neigh_read_specific_ip(ipaddr, vlan_if);
2230 }
2231
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.
2236 */
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);
2244 }
2245 }
2246 }
2247
2248 int zebra_evpn_neigh_del_ip(struct zebra_evpn *zevpn, const struct ipaddr *ip)
2249 {
2250 struct zebra_neigh *n;
2251 struct zebra_mac *zmac;
2252 bool old_bgp_ready;
2253 bool new_bgp_ready;
2254 struct zebra_vrf *zvrf;
2255
2256 /* If entry doesn't exist, nothing to do. */
2257 n = zebra_evpn_neigh_lookup(zevpn, ip);
2258 if (!n)
2259 return 0;
2260
2261 zmac = zebra_evpn_mac_lookup(zevpn, &n->emac);
2262 if (!zmac) {
2263 if (IS_ZEBRA_DEBUG_VXLAN)
2264 zlog_debug(
2265 "Trying to del a neigh %pIA without a mac %pEA on VNI %u",
2266 ip, &n->emac,
2267 zevpn->vni);
2268
2269 return 0;
2270 }
2271
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.
2274 */
2275 if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
2276 zebra_evpn_rem_neigh_install(zevpn, n, false /*was_static*/);
2277 return 0;
2278 }
2279
2280 /* if this is a sync entry it cannot be dropped re-install it in
2281 * the dataplane
2282 */
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,
2288 n->flags);
2289
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,
2295 new_bgp_ready);
2296
2297 /* re-install the entry in the kernel */
2298 zebra_evpn_sync_neigh_dp_install(n, false /* set_inactive */,
2299 false /* force_clear_static */,
2300 __func__);
2301
2302 return 0;
2303 }
2304
2305 zvrf = zevpn->vxlan_if->vrf->info;
2306 if (!zvrf) {
2307 zlog_debug("%s: VNI %u vrf lookup failed.", __func__,
2308 zevpn->vni);
2309 return -1;
2310 }
2311
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
2315 */
2316 if (zvrf->dad_freeze && CHECK_FLAG(n->flags, ZEBRA_NEIGH_DUPLICATE))
2317 ZEBRA_NEIGH_SET_INACTIVE(n);
2318
2319 /* Remove neighbor from BGP. */
2320 zebra_evpn_neigh_send_del_to_client(zevpn->vni, &n->ip, &n->emac,
2321 n->flags, n->state,
2322 false /* force */);
2323
2324 /* Delete this neighbor entry. */
2325 zebra_evpn_neigh_del(zevpn, n);
2326
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);
2331
2332 return 0;
2333 }
FRRouting mirror