]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_vxlan.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lib: msg: refactor common connection code from mgmtd
[mirror_frr.git] / zebra / zebra_vxlan.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Zebra EVPN for VxLAN code
4 * Copyright (C) 2016, 2017 Cumulus Networks, Inc.
5 */
6
7 #include <zebra.h>
8
9 #include "hash.h"
10 #include "if.h"
11 #include "jhash.h"
12 #include "linklist.h"
13 #include "log.h"
14 #include "memory.h"
15 #include "prefix.h"
16 #include "stream.h"
17 #include "table.h"
18 #include "vlan.h"
19 #include "vxlan.h"
20 #ifdef GNU_LINUX
21 #include <linux/neighbour.h>
22 #endif
23 #include "lib/printfrr.h"
24
25 #include "zebra/zebra_router.h"
26 #include "zebra/debug.h"
27 #include "zebra/interface.h"
28 #include "zebra/rib.h"
29 #include "zebra/rt.h"
30 #include "zebra/rt_netlink.h"
31 #include "zebra/zebra_errors.h"
32 #include "zebra/zebra_l2.h"
33 #include "zebra/zebra_l2_bridge_if.h"
34 #include "zebra/zebra_ns.h"
35 #include "zebra/zebra_vrf.h"
36 #include "zebra/zebra_vxlan.h"
37 #include "zebra/zebra_vxlan_private.h"
38 #include "zebra/zebra_evpn.h"
39 #include "zebra/zebra_evpn_mac.h"
40 #include "zebra/zebra_evpn_neigh.h"
41 #include "zebra/zebra_evpn_mh.h"
42 #include "zebra/zebra_evpn_vxlan.h"
43 #include "zebra/zebra_router.h"
44
45 DEFINE_MTYPE_STATIC(ZEBRA, HOST_PREFIX, "host prefix");
46 DEFINE_MTYPE_STATIC(ZEBRA, ZL3VNI, "L3 VNI hash");
47 DEFINE_MTYPE_STATIC(ZEBRA, L3VNI_MAC, "EVPN L3VNI MAC");
48 DEFINE_MTYPE_STATIC(ZEBRA, L3NEIGH, "EVPN Neighbor");
49 DEFINE_MTYPE_STATIC(ZEBRA, ZVXLAN_SG, "zebra VxLAN multicast group");
50 DEFINE_MTYPE_STATIC(ZEBRA, EVPN_VTEP, "zebra VxLAN VTEP IP");
51
52 DEFINE_HOOK(zebra_rmac_update,
53 (struct zebra_mac * rmac, struct zebra_l3vni *zl3vni, bool delete,
54 const char *reason),
55 (rmac, zl3vni, delete, reason));
56
57 /* config knobs */
58 static bool accept_bgp_seq = true;
59
60 /* Single VXlan Device Global Neigh Table */
61 struct hash *svd_nh_table;
62
63 /* static function declarations */
64 static void zevpn_print_neigh_hash_all_evpn(struct hash_bucket *bucket,
65 void **args);
66 static void zl3vni_print_nh(struct zebra_neigh *n, struct vty *vty,
67 json_object *json);
68 static void zl3vni_print_rmac(struct zebra_mac *zrmac, struct vty *vty,
69 json_object *json);
70 static void zevpn_print_mac_hash_all_evpn(struct hash_bucket *bucket, void *ctxt);
71
72 /* l3-vni next-hop neigh related APIs */
73 static struct zebra_neigh *zl3vni_nh_lookup(struct zebra_l3vni *zl3vni,
74 const struct ipaddr *ip);
75 static void *zl3vni_nh_alloc(void *p);
76 static struct zebra_neigh *zl3vni_nh_add(struct zebra_l3vni *zl3vni,
77 const struct ipaddr *vtep_ip,
78 const struct ethaddr *rmac);
79 static int zl3vni_nh_del(struct zebra_l3vni *zl3vni, struct zebra_neigh *n);
80 static int zl3vni_nh_install(struct zebra_l3vni *zl3vni, struct zebra_neigh *n);
81 static int zl3vni_nh_uninstall(struct zebra_l3vni *zl3vni,
82 struct zebra_neigh *n);
83 static struct zebra_neigh *svd_nh_add(const struct ipaddr *vtep_ip,
84 const struct ethaddr *rmac);
85 static int svd_nh_del(struct zebra_neigh *n);
86 static int svd_nh_install(struct zebra_l3vni *zl3vni, struct zebra_neigh *n);
87 static int svd_nh_uninstall(struct zebra_l3vni *zl3vni, struct zebra_neigh *n);
88
89 /* l3-vni rmac related APIs */
90 static void zl3vni_print_rmac_hash(struct hash_bucket *, void *);
91 static struct zebra_mac *zl3vni_rmac_lookup(struct zebra_l3vni *zl3vni,
92 const struct ethaddr *rmac);
93 static void *zl3vni_rmac_alloc(void *p);
94 static struct zebra_mac *zl3vni_rmac_add(struct zebra_l3vni *zl3vni,
95 const struct ethaddr *rmac);
96 static int zl3vni_rmac_del(struct zebra_l3vni *zl3vni, struct zebra_mac *zrmac);
97 static int zl3vni_rmac_install(struct zebra_l3vni *zl3vni,
98 struct zebra_mac *zrmac);
99 static int zl3vni_rmac_uninstall(struct zebra_l3vni *zl3vni,
100 struct zebra_mac *zrmac);
101
102 /* l3-vni related APIs*/
103 static void *zl3vni_alloc(void *p);
104 static struct zebra_l3vni *zl3vni_add(vni_t vni, vrf_id_t vrf_id);
105 static int zl3vni_del(struct zebra_l3vni *zl3vni);
106
107 static void zevpn_build_hash_table(void);
108 static unsigned int zebra_vxlan_sg_hash_key_make(const void *p);
109 static bool zebra_vxlan_sg_hash_eq(const void *p1, const void *p2);
110 static void zebra_vxlan_sg_do_deref(struct zebra_vrf *zvrf,
111 struct in_addr sip, struct in_addr mcast_grp);
112 static struct zebra_vxlan_sg *zebra_vxlan_sg_do_ref(struct zebra_vrf *vrf,
113 struct in_addr sip,
114 struct in_addr mcast_grp);
115 static void zebra_vxlan_cleanup_sg_table(struct zebra_vrf *zvrf);
116
117 bool zebra_evpn_do_dup_addr_detect(struct zebra_vrf *zvrf)
118 {
119 return zvrf->dup_addr_detect && zebra_evpn_mh_do_dup_addr_detect();
120 }
121
122 /* Private functions */
123 static int host_rb_entry_compare(const struct host_rb_entry *hle1,
124 const struct host_rb_entry *hle2)
125 {
126 if (hle1->p.family < hle2->p.family)
127 return -1;
128
129 if (hle1->p.family > hle2->p.family)
130 return 1;
131
132 if (hle1->p.prefixlen < hle2->p.prefixlen)
133 return -1;
134
135 if (hle1->p.prefixlen > hle2->p.prefixlen)
136 return 1;
137
138 if (hle1->p.family == AF_INET) {
139 if (hle1->p.u.prefix4.s_addr < hle2->p.u.prefix4.s_addr)
140 return -1;
141
142 if (hle1->p.u.prefix4.s_addr > hle2->p.u.prefix4.s_addr)
143 return 1;
144
145 return 0;
146 } else if (hle1->p.family == AF_INET6) {
147 return memcmp(&hle1->p.u.prefix6, &hle2->p.u.prefix6,
148 IPV6_MAX_BYTELEN);
149 } else if (hle1->p.family == AF_EVPN) {
150 uint8_t family1;
151 uint8_t family2;
152
153 /* two (v4/v6) dummy prefixes of route_type BGP_EVPN_AD_ROUTE
154 * are used for all nexthops associated with a non-zero ESI
155 */
156 family1 = is_evpn_prefix_ipaddr_v4(
157 (const struct prefix_evpn *)&hle1->p)
158 ? AF_INET
159 : AF_INET6;
160 family2 = is_evpn_prefix_ipaddr_v4(
161 (const struct prefix_evpn *)&hle2->p)
162 ? AF_INET
163 : AF_INET6;
164
165
166 if (family1 < family2)
167 return -1;
168
169 if (family1 > family2)
170 return 1;
171
172 return 0;
173 } else {
174 zlog_debug("%s: Unexpected family type: %d", __func__,
175 hle1->p.family);
176 return 0;
177 }
178 }
179 RB_GENERATE(host_rb_tree_entry, host_rb_entry, hl_entry, host_rb_entry_compare);
180
181 static uint32_t rb_host_count(struct host_rb_tree_entry *hrbe)
182 {
183 struct host_rb_entry *hle;
184 uint32_t count = 0;
185
186 RB_FOREACH (hle, host_rb_tree_entry, hrbe)
187 count++;
188
189 return count;
190 }
191
192 static int l3vni_rmac_nh_list_cmp(void *p1, void *p2)
193 {
194 const struct ipaddr *vtep_ip1 = p1;
195 const struct ipaddr *vtep_ip2 = p2;
196
197 return !ipaddr_cmp(vtep_ip1, vtep_ip2);
198 }
199
200 static void l3vni_rmac_nh_free(struct ipaddr *vtep_ip)
201 {
202 XFREE(MTYPE_EVPN_VTEP, vtep_ip);
203 }
204
205 static void l3vni_rmac_nh_list_nh_delete(struct zebra_l3vni *zl3vni,
206 struct zebra_mac *zrmac,
207 struct ipaddr *vtep_ip)
208 {
209 struct listnode *node = NULL, *nnode = NULL;
210 struct ipaddr *vtep = NULL;
211
212 for (ALL_LIST_ELEMENTS(zrmac->nh_list, node, nnode, vtep)) {
213 if (ipaddr_cmp(vtep, vtep_ip) == 0)
214 break;
215 }
216
217 if (node) {
218 l3vni_rmac_nh_free(vtep);
219 list_delete_node(zrmac->nh_list, node);
220 }
221 }
222
223 /*
224 * Print neighbors for all EVPN.
225 */
226 static void zevpn_print_neigh_hash_all_evpn(struct hash_bucket *bucket,
227 void **args)
228 {
229 struct vty *vty;
230 json_object *json = NULL, *json_evpn = NULL;
231 struct zebra_evpn *zevpn;
232 uint32_t num_neigh;
233 struct neigh_walk_ctx wctx;
234 char vni_str[VNI_STR_LEN];
235 uint32_t print_dup;
236
237 vty = (struct vty *)args[0];
238 json = (json_object *)args[1];
239 print_dup = (uint32_t)(uintptr_t)args[2];
240
241 zevpn = (struct zebra_evpn *)bucket->data;
242
243 num_neigh = hashcount(zevpn->neigh_table);
244
245 if (print_dup)
246 num_neigh = num_dup_detected_neighs(zevpn);
247
248 if (json == NULL) {
249 vty_out(vty,
250 "\nVNI %u #ARP (IPv4 and IPv6, local and remote) %u\n\n",
251 zevpn->vni, num_neigh);
252 } else {
253 json_evpn = json_object_new_object();
254 json_object_int_add(json_evpn, "numArpNd", num_neigh);
255 snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
256 }
257
258 if (!num_neigh) {
259 if (json)
260 json_object_object_add(json, vni_str, json_evpn);
261 return;
262 }
263
264 /* Since we have IPv6 addresses to deal with which can vary widely in
265 * size, we try to be a bit more elegant in display by first computing
266 * the maximum width.
267 */
268 memset(&wctx, 0, sizeof(wctx));
269 wctx.zevpn = zevpn;
270 wctx.vty = vty;
271 wctx.addr_width = 15;
272 wctx.json = json_evpn;
273 hash_iterate(zevpn->neigh_table, zebra_evpn_find_neigh_addr_width,
274 &wctx);
275
276 if (json == NULL)
277 zebra_evpn_print_neigh_hdr(vty, &wctx);
278
279 if (print_dup)
280 hash_iterate(zevpn->neigh_table,
281 zebra_evpn_print_dad_neigh_hash, &wctx);
282 else
283 hash_iterate(zevpn->neigh_table, zebra_evpn_print_neigh_hash,
284 &wctx);
285
286 if (json)
287 json_object_object_add(json, vni_str, json_evpn);
288 }
289
290 /*
291 * Print neighbors for all EVPNs in detail.
292 */
293 static void zevpn_print_neigh_hash_all_evpn_detail(struct hash_bucket *bucket,
294 void **args)
295 {
296 struct vty *vty;
297 json_object *json = NULL, *json_evpn = NULL;
298 struct zebra_evpn *zevpn;
299 uint32_t num_neigh;
300 struct neigh_walk_ctx wctx;
301 char vni_str[VNI_STR_LEN];
302 uint32_t print_dup;
303
304 vty = (struct vty *)args[0];
305 json = (json_object *)args[1];
306 print_dup = (uint32_t)(uintptr_t)args[2];
307
308 zevpn = (struct zebra_evpn *)bucket->data;
309 if (!zevpn) {
310 if (json)
311 vty_out(vty, "{}\n");
312 return;
313 }
314 num_neigh = hashcount(zevpn->neigh_table);
315
316 if (print_dup && num_dup_detected_neighs(zevpn) == 0)
317 return;
318
319 if (json == NULL) {
320 vty_out(vty,
321 "\nVNI %u #ARP (IPv4 and IPv6, local and remote) %u\n\n",
322 zevpn->vni, num_neigh);
323 } else {
324 json_evpn = json_object_new_object();
325 json_object_int_add(json_evpn, "numArpNd", num_neigh);
326 snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
327 }
328 if (!num_neigh) {
329 if (json)
330 json_object_object_add(json, vni_str, json_evpn);
331 return;
332 }
333
334 memset(&wctx, 0, sizeof(wctx));
335 wctx.zevpn = zevpn;
336 wctx.vty = vty;
337 wctx.addr_width = 15;
338 wctx.json = json_evpn;
339
340 if (print_dup)
341 hash_iterate(zevpn->neigh_table,
342 zebra_evpn_print_dad_neigh_hash_detail, &wctx);
343 else
344 hash_iterate(zevpn->neigh_table,
345 zebra_evpn_print_neigh_hash_detail, &wctx);
346
347 if (json)
348 json_object_object_add(json, vni_str, json_evpn);
349 }
350
351 /* print a specific next hop for an l3vni */
352 static void zl3vni_print_nh(struct zebra_neigh *n, struct vty *vty,
353 json_object *json)
354 {
355 char buf1[ETHER_ADDR_STRLEN];
356 char buf2[INET6_ADDRSTRLEN];
357 json_object *json_hosts = NULL;
358 struct host_rb_entry *hle;
359
360 if (!json) {
361 vty_out(vty, "Ip: %s\n",
362 ipaddr2str(&n->ip, buf2, sizeof(buf2)));
363 vty_out(vty, " RMAC: %s\n",
364 prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
365 if (n->refcnt)
366 /* SVD neigh */
367 vty_out(vty, " Refcount: %u\n", n->refcnt);
368 else {
369 vty_out(vty, " Refcount: %d\n",
370 rb_host_count(&n->host_rb));
371 vty_out(vty, " Prefixes:\n");
372 RB_FOREACH (hle, host_rb_tree_entry, &n->host_rb)
373 vty_out(vty, " %pFX\n", &hle->p);
374 }
375 } else {
376 json_hosts = json_object_new_array();
377 json_object_string_add(
378 json, "ip", ipaddr2str(&(n->ip), buf2, sizeof(buf2)));
379 json_object_string_add(
380 json, "routerMac",
381 prefix_mac2str(&n->emac, buf2, sizeof(buf2)));
382 if (n->refcnt)
383 /* SVD neigh */
384 json_object_int_add(json, "refCount", n->refcnt);
385 else {
386 json_object_int_add(json, "refCount",
387 rb_host_count(&n->host_rb));
388 RB_FOREACH (hle, host_rb_tree_entry, &n->host_rb)
389 json_object_array_add(
390 json_hosts,
391 json_object_new_string(prefix2str(
392 &hle->p, buf2, sizeof(buf2))));
393 json_object_object_add(json, "prefixList", json_hosts);
394 }
395 }
396 }
397
398 /* Print a specific RMAC entry */
399 static void zl3vni_print_rmac(struct zebra_mac *zrmac, struct vty *vty,
400 json_object *json)
401 {
402 struct listnode *node = NULL;
403 struct ipaddr *vtep = NULL;
404 json_object *json_nhs = NULL;
405
406 if (!json) {
407 vty_out(vty, "MAC: %pEA\n", &zrmac->macaddr);
408 vty_out(vty, " Remote VTEP: %pI4\n",
409 &zrmac->fwd_info.r_vtep_ip);
410 } else {
411 json_nhs = json_object_new_array();
412 json_object_string_addf(json, "routerMac", "%pEA",
413 &zrmac->macaddr);
414 json_object_string_addf(json, "vtepIp", "%pI4",
415 &zrmac->fwd_info.r_vtep_ip);
416 for (ALL_LIST_ELEMENTS_RO(zrmac->nh_list, node, vtep)) {
417 json_object_array_add(json_nhs, json_object_new_stringf(
418 "%pIA", vtep));
419 }
420 json_object_object_add(json, "nexthops", json_nhs);
421 }
422 }
423
424 /*
425 * Print MACs for all EVPNs.
426 */
427 static void zevpn_print_mac_hash_all_evpn(struct hash_bucket *bucket, void *ctxt)
428 {
429 struct vty *vty;
430 json_object *json = NULL, *json_evpn = NULL;
431 json_object *json_mac = NULL;
432 struct zebra_evpn *zevpn;
433 uint32_t num_macs;
434 struct mac_walk_ctx *wctx = ctxt;
435 char vni_str[VNI_STR_LEN];
436
437 vty = wctx->vty;
438 json = wctx->json;
439
440 zevpn = (struct zebra_evpn *)bucket->data;
441 wctx->zevpn = zevpn;
442
443 /*We are iterating over a new VNI, set the count to 0*/
444 wctx->count = 0;
445
446 num_macs = num_valid_macs(zevpn);
447 if (!num_macs)
448 return;
449
450 if (wctx->print_dup)
451 num_macs = num_dup_detected_macs(zevpn);
452
453 if (json) {
454 json_evpn = json_object_new_object();
455 json_mac = json_object_new_object();
456 snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
457 }
458
459 if (!CHECK_FLAG(wctx->flags, SHOW_REMOTE_MAC_FROM_VTEP)) {
460 if (json == NULL) {
461 vty_out(vty, "\nVNI %u #MACs (local and remote) %u\n\n",
462 zevpn->vni, num_macs);
463 vty_out(vty,
464 "Flags: N=sync-neighs, I=local-inactive, P=peer-active, X=peer-proxy\n");
465 vty_out(vty, "%-17s %-6s %-5s %-30s %-5s %s\n", "MAC",
466 "Type", "Flags", "Intf/Remote ES/VTEP",
467 "VLAN", "Seq #'s");
468 } else
469 json_object_int_add(json_evpn, "numMacs", num_macs);
470 }
471
472 if (!num_macs) {
473 if (json) {
474 json_object_int_add(json_evpn, "numMacs", num_macs);
475 json_object_object_add(json, vni_str, json_evpn);
476 }
477 return;
478 }
479
480 /* assign per-evpn to wctx->json object to fill macs
481 * under the evpn. Re-assign primary json object to fill
482 * next evpn information.
483 */
484 wctx->json = json_mac;
485 if (wctx->print_dup)
486 hash_iterate(zevpn->mac_table, zebra_evpn_print_dad_mac_hash,
487 wctx);
488 else
489 hash_iterate(zevpn->mac_table, zebra_evpn_print_mac_hash, wctx);
490 wctx->json = json;
491 if (json) {
492 if (wctx->count)
493 json_object_object_add(json_evpn, "macs", json_mac);
494 json_object_object_add(json, vni_str, json_evpn);
495 }
496 }
497
498 /*
499 * Print MACs in detail for all EVPNs.
500 */
501 static void zevpn_print_mac_hash_all_evpn_detail(struct hash_bucket *bucket,
502 void *ctxt)
503 {
504 struct vty *vty;
505 json_object *json = NULL, *json_evpn = NULL;
506 json_object *json_mac = NULL;
507 struct zebra_evpn *zevpn;
508 uint32_t num_macs;
509 struct mac_walk_ctx *wctx = ctxt;
510 char vni_str[VNI_STR_LEN];
511
512 vty = wctx->vty;
513 json = wctx->json;
514
515 zevpn = (struct zebra_evpn *)bucket->data;
516 if (!zevpn) {
517 if (json)
518 vty_out(vty, "{}\n");
519 return;
520 }
521 wctx->zevpn = zevpn;
522
523 /*We are iterating over a new EVPN, set the count to 0*/
524 wctx->count = 0;
525
526 num_macs = num_valid_macs(zevpn);
527 if (!num_macs)
528 return;
529
530 if (wctx->print_dup && (num_dup_detected_macs(zevpn) == 0))
531 return;
532
533 if (json) {
534 json_evpn = json_object_new_object();
535 json_mac = json_object_new_object();
536 snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
537 }
538
539 if (!CHECK_FLAG(wctx->flags, SHOW_REMOTE_MAC_FROM_VTEP)) {
540 if (json == NULL) {
541 vty_out(vty, "\nVNI %u #MACs (local and remote) %u\n\n",
542 zevpn->vni, num_macs);
543 } else
544 json_object_int_add(json_evpn, "numMacs", num_macs);
545 }
546 /* assign per-evpn to wctx->json object to fill macs
547 * under the evpn. Re-assign primary json object to fill
548 * next evpn information.
549 */
550 wctx->json = json_mac;
551 if (wctx->print_dup)
552 hash_iterate(zevpn->mac_table,
553 zebra_evpn_print_dad_mac_hash_detail, wctx);
554 else
555 hash_iterate(zevpn->mac_table, zebra_evpn_print_mac_hash_detail,
556 wctx);
557 wctx->json = json;
558 if (json) {
559 if (wctx->count)
560 json_object_object_add(json_evpn, "macs", json_mac);
561 json_object_object_add(json, vni_str, json_evpn);
562 }
563 }
564
565 static void zl3vni_print_nh_hash(struct hash_bucket *bucket, void *ctx)
566 {
567 struct nh_walk_ctx *wctx = NULL;
568 struct vty *vty = NULL;
569 struct json_object *json_evpn = NULL;
570 struct json_object *json_nh = NULL;
571 struct zebra_neigh *n = NULL;
572 char buf1[ETHER_ADDR_STRLEN];
573 char buf2[INET6_ADDRSTRLEN];
574
575 wctx = (struct nh_walk_ctx *)ctx;
576 vty = wctx->vty;
577 json_evpn = wctx->json;
578 if (json_evpn)
579 json_nh = json_object_new_object();
580 n = (struct zebra_neigh *)bucket->data;
581
582 if (!json_evpn) {
583 vty_out(vty, "%-15s %-17s\n",
584 ipaddr2str(&(n->ip), buf2, sizeof(buf2)),
585 prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
586 } else {
587 json_object_string_add(json_nh, "nexthopIp",
588 ipaddr2str(&n->ip, buf2, sizeof(buf2)));
589 json_object_string_add(
590 json_nh, "routerMac",
591 prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
592 json_object_object_add(json_evpn,
593 ipaddr2str(&(n->ip), buf2, sizeof(buf2)),
594 json_nh);
595 }
596 }
597
598 static void zl3vni_print_nh_all_table(struct hash *nh_table, vni_t vni,
599 struct vty *vty, json_object *json)
600 {
601 uint32_t num_nh = 0;
602 struct nh_walk_ctx wctx;
603 char vni_str[VNI_STR_LEN];
604 json_object *json_evpn = NULL;
605 bool is_svd = false;
606 const char *svd_str = "Global SVD Table";
607
608 if (vni == 0)
609 is_svd = true;
610
611 num_nh = hashcount(nh_table);
612
613 if (!num_nh)
614 return;
615
616 if (json) {
617 json_evpn = json_object_new_object();
618
619 snprintf(vni_str, VNI_STR_LEN, "%u", vni);
620 }
621
622 if (json == NULL) {
623 if (is_svd)
624 vty_out(vty, "\n%s #Next-Hops %u\n\n", svd_str, num_nh);
625 else
626 vty_out(vty, "\nVNI %u #Next-Hops %u\n\n", vni, num_nh);
627
628 vty_out(vty, "%-15s %-17s\n", "IP", "RMAC");
629 } else
630 json_object_int_add(json_evpn, "numNextHops", num_nh);
631
632 memset(&wctx, 0, sizeof(wctx));
633 wctx.vty = vty;
634 wctx.json = json_evpn;
635 hash_iterate(nh_table, zl3vni_print_nh_hash, &wctx);
636 if (json)
637 json_object_object_add(json, vni_str, json_evpn);
638 }
639
640 static void zl3vni_print_nh_hash_all_vni(struct hash_bucket *bucket,
641 void **args)
642 {
643 struct vty *vty = NULL;
644 json_object *json = NULL;
645 struct zebra_l3vni *zl3vni = NULL;
646
647 vty = (struct vty *)args[0];
648 json = (struct json_object *)args[1];
649
650 zl3vni = (struct zebra_l3vni *)bucket->data;
651
652 zl3vni_print_nh_all_table(zl3vni->nh_table, zl3vni->vni, vty, json);
653 }
654
655 static void zl3vni_print_rmac_hash_all_vni(struct hash_bucket *bucket,
656 void **args)
657 {
658 struct vty *vty = NULL;
659 json_object *json = NULL;
660 json_object *json_evpn = NULL;
661 struct zebra_l3vni *zl3vni = NULL;
662 uint32_t num_rmacs;
663 struct rmac_walk_ctx wctx;
664 char vni_str[VNI_STR_LEN];
665
666 vty = (struct vty *)args[0];
667 json = (struct json_object *)args[1];
668
669 zl3vni = (struct zebra_l3vni *)bucket->data;
670
671 num_rmacs = hashcount(zl3vni->rmac_table);
672 if (!num_rmacs)
673 return;
674
675 if (json) {
676 json_evpn = json_object_new_object();
677 snprintf(vni_str, VNI_STR_LEN, "%u", zl3vni->vni);
678 }
679
680 if (json == NULL) {
681 vty_out(vty, "\nVNI %u #RMACs %u\n\n", zl3vni->vni, num_rmacs);
682 vty_out(vty, "%-17s %-21s\n", "RMAC", "Remote VTEP");
683 } else
684 json_object_int_add(json_evpn, "numRmacs", num_rmacs);
685
686 /* assign per-vni to wctx->json object to fill macs
687 * under the vni. Re-assign primary json object to fill
688 * next vni information.
689 */
690 memset(&wctx, 0, sizeof(wctx));
691 wctx.vty = vty;
692 wctx.json = json_evpn;
693 hash_iterate(zl3vni->rmac_table, zl3vni_print_rmac_hash, &wctx);
694 if (json)
695 json_object_object_add(json, vni_str, json_evpn);
696 }
697
698 static void zl3vni_print_rmac_hash(struct hash_bucket *bucket, void *ctx)
699 {
700 struct zebra_mac *zrmac = NULL;
701 struct rmac_walk_ctx *wctx = NULL;
702 struct vty *vty = NULL;
703 struct json_object *json = NULL;
704 struct json_object *json_rmac = NULL;
705 char buf[PREFIX_STRLEN];
706
707 wctx = (struct rmac_walk_ctx *)ctx;
708 vty = wctx->vty;
709 json = wctx->json;
710 if (json)
711 json_rmac = json_object_new_object();
712 zrmac = (struct zebra_mac *)bucket->data;
713
714 if (!json) {
715 vty_out(vty, "%-17s %-21pI4\n",
716 prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)),
717 &zrmac->fwd_info.r_vtep_ip);
718 } else {
719 json_object_string_add(
720 json_rmac, "routerMac",
721 prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)));
722 json_object_string_addf(json_rmac, "vtepIp", "%pI4",
723 &zrmac->fwd_info.r_vtep_ip);
724 json_object_object_add(
725 json, prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)),
726 json_rmac);
727 }
728 }
729
730 /* print a specific L3 VNI entry */
731 static void zl3vni_print(struct zebra_l3vni *zl3vni, void **ctx)
732 {
733 char buf[PREFIX_STRLEN];
734 struct vty *vty = NULL;
735 json_object *json = NULL;
736 struct zebra_evpn *zevpn = NULL;
737 json_object *json_evpn_list = NULL;
738 struct listnode *node = NULL, *nnode = NULL;
739
740 vty = ctx[0];
741 json = ctx[1];
742
743 if (!json) {
744 vty_out(vty, "VNI: %u\n", zl3vni->vni);
745 vty_out(vty, " Type: %s\n", "L3");
746 vty_out(vty, " Tenant VRF: %s\n", zl3vni_vrf_name(zl3vni));
747 vty_out(vty, " Vlan: %u\n", zl3vni->vid);
748 vty_out(vty, " Bridge: %s\n",
749 zl3vni->bridge_if ? zl3vni->bridge_if->name : "-");
750 vty_out(vty, " Local Vtep Ip: %pI4\n",
751 &zl3vni->local_vtep_ip);
752 vty_out(vty, " Vxlan-Intf: %s\n",
753 zl3vni_vxlan_if_name(zl3vni));
754 vty_out(vty, " SVI-If: %s\n", zl3vni_svi_if_name(zl3vni));
755 vty_out(vty, " State: %s\n", zl3vni_state2str(zl3vni));
756 vty_out(vty, " VNI Filter: %s\n",
757 CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
758 ? "prefix-routes-only"
759 : "none");
760 vty_out(vty, " System MAC: %s\n",
761 zl3vni_sysmac2str(zl3vni, buf, sizeof(buf)));
762 vty_out(vty, " Router MAC: %s\n",
763 zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
764 vty_out(vty, " L2 VNIs: ");
765 for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zevpn))
766 vty_out(vty, "%u ", zevpn->vni);
767 vty_out(vty, "\n");
768 } else {
769 json_evpn_list = json_object_new_array();
770 json_object_int_add(json, "vni", zl3vni->vni);
771 json_object_string_add(json, "type", "L3");
772 #if CONFDATE > 20240210
773 CPP_NOTICE("Drop `vrf` from JSON outputs")
774 #endif
775 json_object_string_add(json, "vrf", zl3vni_vrf_name(zl3vni));
776 json_object_string_add(json, "tenantVrf",
777 zl3vni_vrf_name(zl3vni));
778 json_object_string_addf(json, "localVtepIp", "%pI4",
779 &zl3vni->local_vtep_ip);
780 json_object_string_add(json, "vxlanIntf",
781 zl3vni_vxlan_if_name(zl3vni));
782 json_object_string_add(json, "sviIntf",
783 zl3vni_svi_if_name(zl3vni));
784 json_object_string_add(json, "state", zl3vni_state2str(zl3vni));
785 json_object_string_add(
786 json, "sysMac",
787 zl3vni_sysmac2str(zl3vni, buf, sizeof(buf)));
788 json_object_string_add(
789 json, "routerMac",
790 zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
791 json_object_string_add(
792 json, "vniFilter",
793 CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
794 ? "prefix-routes-only"
795 : "none");
796 for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zevpn)) {
797 json_object_array_add(json_evpn_list,
798 json_object_new_int(zevpn->vni));
799 }
800 json_object_object_add(json, "l2Vnis", json_evpn_list);
801 }
802 }
803
804 /* print a L3 VNI hash entry */
805 static void zl3vni_print_hash(struct hash_bucket *bucket, void *ctx[])
806 {
807 struct vty *vty = NULL;
808 json_object *json = NULL;
809 json_object *json_evpn = NULL;
810 struct zebra_l3vni *zl3vni = NULL;
811
812 vty = (struct vty *)ctx[0];
813 json = (json_object *)ctx[1];
814
815 zl3vni = (struct zebra_l3vni *)bucket->data;
816
817 if (!json) {
818 vty_out(vty, "%-10u %-4s %-21s %-8lu %-8lu %-15s %-37s\n",
819 zl3vni->vni, "L3", zl3vni_vxlan_if_name(zl3vni),
820 hashcount(zl3vni->rmac_table),
821 hashcount(zl3vni->nh_table), "n/a",
822 zl3vni_vrf_name(zl3vni));
823 } else {
824 char vni_str[VNI_STR_LEN];
825
826 snprintf(vni_str, VNI_STR_LEN, "%u", zl3vni->vni);
827 json_evpn = json_object_new_object();
828 json_object_int_add(json_evpn, "vni", zl3vni->vni);
829 json_object_string_add(json_evpn, "vxlanIf",
830 zl3vni_vxlan_if_name(zl3vni));
831 json_object_int_add(json_evpn, "numMacs",
832 hashcount(zl3vni->rmac_table));
833 json_object_int_add(json_evpn, "numArpNd",
834 hashcount(zl3vni->nh_table));
835 json_object_string_add(json_evpn, "numRemoteVteps", "n/a");
836 json_object_string_add(json_evpn, "type", "L3");
837 json_object_string_add(json_evpn, "tenantVrf",
838 zl3vni_vrf_name(zl3vni));
839 json_object_object_add(json, vni_str, json_evpn);
840 }
841 }
842
843 /* print a L3 VNI hash entry in detail*/
844 static void zl3vni_print_hash_detail(struct hash_bucket *bucket, void *data)
845 {
846 struct vty *vty = NULL;
847 struct zebra_l3vni *zl3vni = NULL;
848 json_object *json_array = NULL;
849 bool use_json = false;
850 struct zebra_evpn_show *zes = data;
851
852 vty = zes->vty;
853 json_array = zes->json;
854 use_json = zes->use_json;
855
856 zl3vni = (struct zebra_l3vni *)bucket->data;
857
858 zebra_vxlan_print_vni(vty, zes->zvrf, zl3vni->vni,
859 use_json, json_array);
860
861 if (!use_json)
862 vty_out(vty, "\n");
863 }
864
865 static int zvni_map_to_svi_ns(struct ns *ns,
866 void *_in_param,
867 void **_p_ifp)
868 {
869 struct zebra_ns *zns = ns->info;
870 struct route_node *rn;
871 struct zebra_from_svi_param *in_param =
872 (struct zebra_from_svi_param *)_in_param;
873 struct zebra_l2info_vlan *vl;
874 struct interface *tmp_if = NULL;
875 struct interface **p_ifp = (struct interface **)_p_ifp;
876 struct zebra_if *zif;
877
878 assert(in_param && p_ifp);
879
880 /* TODO: Optimize with a hash. */
881 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
882 tmp_if = (struct interface *)rn->info;
883 /* Check oper status of the SVI. */
884 if (!tmp_if || !if_is_operative(tmp_if))
885 continue;
886 zif = tmp_if->info;
887 if (!zif || zif->zif_type != ZEBRA_IF_VLAN
888 || zif->link != in_param->br_if)
889 continue;
890 vl = (struct zebra_l2info_vlan *)&zif->l2info.vl;
891
892 if (vl->vid == in_param->vid) {
893 *p_ifp = tmp_if;
894 return NS_WALK_STOP;
895 }
896 }
897 return NS_WALK_CONTINUE;
898 }
899
900 /* Map to SVI on bridge corresponding to specified VLAN. This can be one
901 * of two cases:
902 * (a) In the case of a VLAN-aware bridge, the SVI is a L3 VLAN interface
903 * linked to the bridge
904 * (b) In the case of a VLAN-unaware bridge, the SVI is the bridge interface
905 * itself
906 */
907 struct interface *zvni_map_to_svi(vlanid_t vid, struct interface *br_if)
908 {
909 struct interface *tmp_if = NULL;
910 struct zebra_if *zif;
911 struct zebra_from_svi_param in_param;
912 struct interface **p_ifp;
913 /* Defensive check, caller expected to invoke only with valid bridge. */
914 if (!br_if)
915 return NULL;
916
917 /* Determine if bridge is VLAN-aware or not */
918 zif = br_if->info;
919 assert(zif);
920 in_param.bridge_vlan_aware = IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(zif);
921 /* Check oper status of the SVI. */
922 if (!in_param.bridge_vlan_aware)
923 return if_is_operative(br_if) ? br_if : NULL;
924
925 in_param.vid = vid;
926 in_param.br_if = br_if;
927 in_param.zif = NULL;
928 p_ifp = &tmp_if;
929 /* Identify corresponding VLAN interface. */
930 ns_walk_func(zvni_map_to_svi_ns, (void *)&in_param,
931 (void **)p_ifp);
932 return tmp_if;
933 }
934
935 int zebra_evpn_vxlan_del(struct zebra_evpn *zevpn)
936 {
937 zevpn->vid = 0;
938 zevpn_vxlan_if_set(zevpn, zevpn->vxlan_if, false /* set */);
939 zevpn_bridge_if_set(zevpn, zevpn->bridge_if, false /* set */);
940
941 /* Remove references to the BUM mcast grp */
942 zebra_vxlan_sg_deref(zevpn->local_vtep_ip, zevpn->mcast_grp);
943
944 return zebra_evpn_del(zevpn);
945 }
946
947 static int zevpn_build_vni_hash_table(struct zebra_if *zif,
948 struct zebra_vxlan_vni *vnip, void *arg)
949 {
950 vni_t vni;
951 struct zebra_evpn *zevpn;
952 struct zebra_l3vni *zl3vni;
953 struct interface *ifp;
954 struct zebra_l2info_vxlan *vxl;
955 struct interface *br_if;
956
957 ifp = zif->ifp;
958 vxl = &zif->l2info.vxl;
959 vni = vnip->vni;
960
961 if (IS_ZEBRA_DEBUG_VXLAN)
962 zlog_debug("Build vni table for vni %u for Intf %s", vni,
963 ifp->name);
964
965 /* L3-VNI and L2-VNI are handled seperately */
966 zl3vni = zl3vni_lookup(vni);
967 if (zl3vni) {
968
969 if (IS_ZEBRA_DEBUG_VXLAN)
970 zlog_debug(
971 "create L3-VNI hash for Intf %s(%u) L3-VNI %u",
972 ifp->name, ifp->ifindex, vni);
973
974 /* associate with vxlan_if */
975 zl3vni->local_vtep_ip = vxl->vtep_ip;
976 zl3vni->vxlan_if = ifp;
977
978 /*
979 * we need to associate with SVI.
980 * we can associate with svi-if only after association
981 * with vxlan-intf is complete
982 */
983 zl3vni->svi_if = zl3vni_map_to_svi_if(zl3vni);
984
985 /* Associate l3vni to mac-vlan and extract VRR MAC */
986 zl3vni->mac_vlan_if = zl3vni_map_to_mac_vlan_if(zl3vni);
987
988 if (IS_ZEBRA_DEBUG_VXLAN)
989 zlog_debug(
990 "create l3vni %u svi_if %s mac_vlan_if %s", vni,
991 zl3vni->svi_if ? zl3vni->svi_if->name : "NIL",
992 zl3vni->mac_vlan_if ? zl3vni->mac_vlan_if->name
993 : "NIL");
994
995 if (is_l3vni_oper_up(zl3vni))
996 zebra_vxlan_process_l3vni_oper_up(zl3vni);
997
998 } else {
999 struct interface *vlan_if = NULL;
1000
1001 if (IS_ZEBRA_DEBUG_VXLAN)
1002 zlog_debug(
1003 "Create L2-VNI hash for intf %s(%u) L2-VNI %u local IP %pI4",
1004 ifp->name, ifp->ifindex, vni, &vxl->vtep_ip);
1005
1006 /*
1007 * EVPN hash entry is expected to exist, if the BGP process is
1008 * killed
1009 */
1010 zevpn = zebra_evpn_lookup(vni);
1011 if (zevpn) {
1012 zlog_debug(
1013 "EVPN hash already present for IF %s(%u) L2-VNI %u",
1014 ifp->name, ifp->ifindex, vni);
1015
1016 /*
1017 * Inform BGP if intf is up and mapped to
1018 * bridge.
1019 */
1020 if (if_is_operative(ifp) && zif->brslave_info.br_if)
1021 zebra_evpn_send_add_to_client(zevpn);
1022
1023 /* Send Local MAC-entries to client */
1024 zebra_evpn_send_mac_list_to_client(zevpn);
1025
1026 /* Send Loval Neighbor entries to client */
1027 zebra_evpn_send_neigh_to_client(zevpn);
1028 } else {
1029 zevpn = zebra_evpn_add(vni);
1030 if (!zevpn) {
1031 zlog_debug(
1032 "Failed to add EVPN hash, IF %s(%u) L2-VNI %u",
1033 ifp->name, ifp->ifindex, vni);
1034 return 0;
1035 }
1036
1037 if (zevpn->local_vtep_ip.s_addr !=
1038 vxl->vtep_ip.s_addr ||
1039 zevpn->mcast_grp.s_addr != vnip->mcast_grp.s_addr) {
1040 zebra_vxlan_sg_deref(zevpn->local_vtep_ip,
1041 zevpn->mcast_grp);
1042 zebra_vxlan_sg_ref(vxl->vtep_ip,
1043 vnip->mcast_grp);
1044 zevpn->local_vtep_ip = vxl->vtep_ip;
1045 zevpn->mcast_grp = vnip->mcast_grp;
1046 /* on local vtep-ip check if ES
1047 * orig-ip needs to be updated
1048 */
1049 zebra_evpn_es_set_base_evpn(zevpn);
1050 }
1051 zevpn_vxlan_if_set(zevpn, ifp, true /* set */);
1052 br_if = zif->brslave_info.br_if;
1053 zevpn_bridge_if_set(zevpn, br_if, true /* set */);
1054 vlan_if = zvni_map_to_svi(vnip->access_vlan, br_if);
1055 if (vlan_if) {
1056 zevpn->vid = vnip->access_vlan;
1057 zevpn->svi_if = vlan_if;
1058 zevpn->vrf_id = vlan_if->vrf->vrf_id;
1059 zl3vni = zl3vni_from_vrf(vlan_if->vrf->vrf_id);
1060 if (zl3vni)
1061 listnode_add_sort(zl3vni->l2vnis,
1062 zevpn);
1063 }
1064
1065 /*
1066 * Inform BGP if intf is up and mapped to
1067 * bridge.
1068 */
1069 if (if_is_operative(ifp) && zif->brslave_info.br_if)
1070 zebra_evpn_send_add_to_client(zevpn);
1071 }
1072 }
1073
1074 return 0;
1075 }
1076
1077 static int zevpn_build_hash_table_zns(struct ns *ns,
1078 void *param_in __attribute__((unused)),
1079 void **param_out __attribute__((unused)))
1080 {
1081 struct zebra_ns *zns = ns->info;
1082 struct route_node *rn;
1083 struct interface *ifp;
1084 struct zebra_vrf *zvrf;
1085
1086 zvrf = zebra_vrf_get_evpn();
1087
1088 /* Walk VxLAN interfaces and create EVPN hash. */
1089 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
1090 struct zebra_if *zif;
1091 struct zebra_l2info_vxlan *vxl;
1092
1093 ifp = (struct interface *)rn->info;
1094 if (!ifp)
1095 continue;
1096 zif = ifp->info;
1097 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
1098 continue;
1099
1100 vxl = &zif->l2info.vxl;
1101 /* link of VXLAN interface should be in zebra_evpn_vrf */
1102 if (zvrf->zns->ns_id != vxl->link_nsid) {
1103 if (IS_ZEBRA_DEBUG_VXLAN)
1104 zlog_debug(
1105 "Intf %s(%u) link not in same "
1106 "namespace than BGP EVPN core instance ",
1107 ifp->name, ifp->ifindex);
1108 continue;
1109 }
1110
1111 if (IS_ZEBRA_DEBUG_VXLAN)
1112 zlog_debug("Building vni table for %s-if %s",
1113 IS_ZEBRA_VXLAN_IF_VNI(zif) ? "vni" : "svd",
1114 ifp->name);
1115
1116 zebra_vxlan_if_vni_iterate(zif, zevpn_build_vni_hash_table,
1117 NULL);
1118 }
1119 return NS_WALK_CONTINUE;
1120 }
1121
1122 /*
1123 * Build the VNI hash table by going over the VxLAN interfaces. This
1124 * is called when EVPN (advertise-all-vni) is enabled.
1125 */
1126
1127 static void zevpn_build_hash_table(void)
1128 {
1129 ns_walk_func(zevpn_build_hash_table_zns, NULL, NULL);
1130 }
1131
1132 /*
1133 * Cleanup EVPN/VTEP and update kernel
1134 */
1135 static void zebra_evpn_vxlan_cleanup_all(struct hash_bucket *bucket, void *arg)
1136 {
1137 struct zebra_evpn *zevpn = NULL;
1138 struct zebra_l3vni *zl3vni = NULL;
1139
1140 zevpn = (struct zebra_evpn *)bucket->data;
1141
1142 /* remove l2vni from l2vni's tenant-vrf l3-vni list */
1143 zl3vni = zl3vni_from_vrf(zevpn->vrf_id);
1144 if (zl3vni)
1145 listnode_delete(zl3vni->l2vnis, zevpn);
1146
1147 zebra_evpn_cleanup_all(bucket, arg);
1148 }
1149
1150 /* cleanup L3VNI */
1151 static void zl3vni_cleanup_all(struct hash_bucket *bucket, void *args)
1152 {
1153 struct zebra_l3vni *zl3vni = NULL;
1154
1155 zl3vni = (struct zebra_l3vni *)bucket->data;
1156
1157 zebra_vxlan_process_l3vni_oper_down(zl3vni);
1158 }
1159
1160 static void rb_find_or_add_host(struct host_rb_tree_entry *hrbe,
1161 const struct prefix *host)
1162 {
1163 struct host_rb_entry lookup;
1164 struct host_rb_entry *hle;
1165
1166 memset(&lookup, 0, sizeof(lookup));
1167 memcpy(&lookup.p, host, sizeof(*host));
1168
1169 hle = RB_FIND(host_rb_tree_entry, hrbe, &lookup);
1170 if (hle)
1171 return;
1172
1173 hle = XCALLOC(MTYPE_HOST_PREFIX, sizeof(struct host_rb_entry));
1174 memcpy(hle, &lookup, sizeof(lookup));
1175
1176 RB_INSERT(host_rb_tree_entry, hrbe, hle);
1177 }
1178
1179 static void rb_delete_host(struct host_rb_tree_entry *hrbe, struct prefix *host)
1180 {
1181 struct host_rb_entry lookup;
1182 struct host_rb_entry *hle;
1183
1184 memset(&lookup, 0, sizeof(lookup));
1185 memcpy(&lookup.p, host, sizeof(*host));
1186
1187 hle = RB_FIND(host_rb_tree_entry, hrbe, &lookup);
1188 if (hle) {
1189 RB_REMOVE(host_rb_tree_entry, hrbe, hle);
1190 XFREE(MTYPE_HOST_PREFIX, hle);
1191 }
1192
1193 return;
1194 }
1195
1196 /*
1197 * Look up MAC hash entry.
1198 */
1199 static struct zebra_mac *zl3vni_rmac_lookup(struct zebra_l3vni *zl3vni,
1200 const struct ethaddr *rmac)
1201 {
1202 struct zebra_mac tmp;
1203 struct zebra_mac *pmac;
1204
1205 memset(&tmp, 0, sizeof(tmp));
1206 memcpy(&tmp.macaddr, rmac, ETH_ALEN);
1207 pmac = hash_lookup(zl3vni->rmac_table, &tmp);
1208
1209 return pmac;
1210 }
1211
1212 /*
1213 * Callback to allocate RMAC hash entry.
1214 */
1215 static void *zl3vni_rmac_alloc(void *p)
1216 {
1217 const struct zebra_mac *tmp_rmac = p;
1218 struct zebra_mac *zrmac;
1219
1220 zrmac = XCALLOC(MTYPE_L3VNI_MAC, sizeof(struct zebra_mac));
1221 *zrmac = *tmp_rmac;
1222
1223 return ((void *)zrmac);
1224 }
1225
1226 /*
1227 * Add RMAC entry to l3-vni
1228 */
1229 static struct zebra_mac *zl3vni_rmac_add(struct zebra_l3vni *zl3vni,
1230 const struct ethaddr *rmac)
1231 {
1232 struct zebra_mac tmp_rmac;
1233 struct zebra_mac *zrmac = NULL;
1234
1235 memset(&tmp_rmac, 0, sizeof(tmp_rmac));
1236 memcpy(&tmp_rmac.macaddr, rmac, ETH_ALEN);
1237 zrmac = hash_get(zl3vni->rmac_table, &tmp_rmac, zl3vni_rmac_alloc);
1238 zrmac->nh_list = list_new();
1239 zrmac->nh_list->cmp = (int (*)(void *, void *))l3vni_rmac_nh_list_cmp;
1240 zrmac->nh_list->del = (void (*)(void *))l3vni_rmac_nh_free;
1241
1242 SET_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE);
1243 SET_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC);
1244
1245 return zrmac;
1246 }
1247
1248 /*
1249 * Delete MAC entry.
1250 */
1251 static int zl3vni_rmac_del(struct zebra_l3vni *zl3vni, struct zebra_mac *zrmac)
1252 {
1253 struct zebra_mac *tmp_rmac;
1254
1255 /* free the list of nh list*/
1256 list_delete(&zrmac->nh_list);
1257
1258 tmp_rmac = hash_release(zl3vni->rmac_table, zrmac);
1259 XFREE(MTYPE_L3VNI_MAC, tmp_rmac);
1260
1261 return 0;
1262 }
1263
1264 /*
1265 * Install remote RMAC into the forwarding plane.
1266 */
1267 static int zl3vni_rmac_install(struct zebra_l3vni *zl3vni,
1268 struct zebra_mac *zrmac)
1269 {
1270 const struct zebra_if *zif = NULL, *br_zif = NULL;
1271 const struct zebra_vxlan_vni *vni;
1272 const struct interface *br_ifp;
1273 enum zebra_dplane_result res;
1274 vlanid_t vid;
1275
1276 if (!(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE))
1277 || !(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC)))
1278 return 0;
1279
1280 zif = zl3vni->vxlan_if->info;
1281 if (!zif)
1282 return -1;
1283
1284 br_ifp = zif->brslave_info.br_if;
1285 if (br_ifp == NULL)
1286 return -1;
1287
1288 vni = zebra_vxlan_if_vni_find(zif, zl3vni->vni);
1289
1290 br_zif = (const struct zebra_if *)br_ifp->info;
1291
1292 if (IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(br_zif))
1293 vid = vni->access_vlan;
1294 else
1295 vid = 0;
1296
1297 res = dplane_rem_mac_add(zl3vni->vxlan_if, br_ifp, vid, &zrmac->macaddr,
1298 vni->vni, zrmac->fwd_info.r_vtep_ip, 0, 0,
1299 false /*was_static*/);
1300 if (res != ZEBRA_DPLANE_REQUEST_FAILURE)
1301 return 0;
1302 else
1303 return -1;
1304 }
1305
1306 /*
1307 * Uninstall remote RMAC from the forwarding plane.
1308 */
1309 static int zl3vni_rmac_uninstall(struct zebra_l3vni *zl3vni,
1310 struct zebra_mac *zrmac)
1311 {
1312 const struct zebra_if *zif = NULL, *br_zif;
1313 const struct zebra_vxlan_vni *vni;
1314 const struct interface *br_ifp;
1315 vlanid_t vid;
1316 enum zebra_dplane_result res;
1317
1318 if (!(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE))
1319 || !(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC)))
1320 return 0;
1321
1322 if (!zl3vni->vxlan_if) {
1323 if (IS_ZEBRA_DEBUG_VXLAN)
1324 zlog_debug(
1325 "RMAC %pEA on L3-VNI %u hash %p couldn't be uninstalled - no vxlan_if",
1326 &zrmac->macaddr, zl3vni->vni, zl3vni);
1327 return -1;
1328 }
1329
1330 zif = zl3vni->vxlan_if->info;
1331 if (!zif)
1332 return -1;
1333
1334 br_ifp = zif->brslave_info.br_if;
1335 if (br_ifp == NULL)
1336 return -1;
1337
1338 vni = zebra_vxlan_if_vni_find(zif, zl3vni->vni);
1339
1340 br_zif = (const struct zebra_if *)br_ifp->info;
1341 if (IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(br_zif))
1342 vid = vni->access_vlan;
1343 else
1344 vid = 0;
1345
1346 res = dplane_rem_mac_del(zl3vni->vxlan_if, br_ifp, vid, &zrmac->macaddr,
1347 vni->vni, zrmac->fwd_info.r_vtep_ip);
1348 if (res != ZEBRA_DPLANE_REQUEST_FAILURE)
1349 return 0;
1350 else
1351 return -1;
1352 }
1353
1354 /* handle rmac add */
1355 static int zl3vni_remote_rmac_add(struct zebra_l3vni *zl3vni,
1356 const struct ethaddr *rmac,
1357 const struct ipaddr *vtep_ip)
1358 {
1359 struct zebra_mac *zrmac = NULL;
1360 struct ipaddr *vtep = NULL;
1361
1362 zrmac = zl3vni_rmac_lookup(zl3vni, rmac);
1363 if (!zrmac) {
1364
1365 /* Create the RMAC entry, or update its vtep, if necessary. */
1366 zrmac = zl3vni_rmac_add(zl3vni, rmac);
1367 if (!zrmac) {
1368 zlog_debug(
1369 "Failed to add RMAC %pEA L3VNI %u Remote VTEP %pIA",
1370 rmac, zl3vni->vni, vtep_ip);
1371 return -1;
1372 }
1373 memset(&zrmac->fwd_info, 0, sizeof(zrmac->fwd_info));
1374 zrmac->fwd_info.r_vtep_ip = vtep_ip->ipaddr_v4;
1375
1376 vtep = XCALLOC(MTYPE_EVPN_VTEP, sizeof(struct ipaddr));
1377 memcpy(vtep, vtep_ip, sizeof(struct ipaddr));
1378 if (!listnode_add_sort_nodup(zrmac->nh_list, (void *)vtep))
1379 XFREE(MTYPE_EVPN_VTEP, vtep);
1380
1381 /* Send RMAC for FPM processing */
1382 hook_call(zebra_rmac_update, zrmac, zl3vni, false,
1383 "new RMAC added");
1384
1385 /* install rmac in kernel */
1386 zl3vni_rmac_install(zl3vni, zrmac);
1387 } else if (!IPV4_ADDR_SAME(&zrmac->fwd_info.r_vtep_ip,
1388 &vtep_ip->ipaddr_v4)) {
1389 if (IS_ZEBRA_DEBUG_VXLAN)
1390 zlog_debug(
1391 "L3VNI %u Remote VTEP change(%pI4 -> %pIA) for RMAC %pEA",
1392 zl3vni->vni, &zrmac->fwd_info.r_vtep_ip,
1393 vtep_ip, rmac);
1394
1395 zrmac->fwd_info.r_vtep_ip = vtep_ip->ipaddr_v4;
1396
1397 vtep = XCALLOC(MTYPE_EVPN_VTEP, sizeof(struct ipaddr));
1398 memcpy(vtep, vtep_ip, sizeof(struct ipaddr));
1399 if (!listnode_add_sort_nodup(zrmac->nh_list, (void *)vtep))
1400 XFREE(MTYPE_EVPN_VTEP, vtep);
1401
1402 /* install rmac in kernel */
1403 zl3vni_rmac_install(zl3vni, zrmac);
1404 }
1405
1406 return 0;
1407 }
1408
1409
1410 /* handle rmac delete */
1411 static void zl3vni_remote_rmac_del(struct zebra_l3vni *zl3vni,
1412 struct zebra_mac *zrmac,
1413 struct ipaddr *vtep_ip)
1414 {
1415 struct ipaddr ipv4_vtep;
1416
1417 if (!zl3vni_nh_lookup(zl3vni, vtep_ip)) {
1418 memset(&ipv4_vtep, 0, sizeof(ipv4_vtep));
1419 ipv4_vtep.ipa_type = IPADDR_V4;
1420 if (vtep_ip->ipa_type == IPADDR_V6)
1421 ipv4_mapped_ipv6_to_ipv4(&vtep_ip->ipaddr_v6,
1422 &ipv4_vtep.ipaddr_v4);
1423 else
1424 memcpy(&(ipv4_vtep.ipaddr_v4), &vtep_ip->ipaddr_v4,
1425 sizeof(struct in_addr));
1426
1427 /* remove nh from rmac's list */
1428 l3vni_rmac_nh_list_nh_delete(zl3vni, zrmac, &ipv4_vtep);
1429 /* delete nh is same as current selected, fall back to
1430 * one present in the list
1431 */
1432 if (IPV4_ADDR_SAME(&zrmac->fwd_info.r_vtep_ip,
1433 &ipv4_vtep.ipaddr_v4) &&
1434 listcount(zrmac->nh_list)) {
1435 struct ipaddr *vtep;
1436
1437 vtep = listgetdata(listhead(zrmac->nh_list));
1438 zrmac->fwd_info.r_vtep_ip = vtep->ipaddr_v4;
1439 if (IS_ZEBRA_DEBUG_VXLAN)
1440 zlog_debug(
1441 "L3VNI %u Remote VTEP nh change(%pIA -> %pI4) for RMAC %pEA",
1442 zl3vni->vni, &ipv4_vtep,
1443 &zrmac->fwd_info.r_vtep_ip,
1444 &zrmac->macaddr);
1445
1446 /* install rmac in kernel */
1447 zl3vni_rmac_install(zl3vni, zrmac);
1448 }
1449
1450 if (!listcount(zrmac->nh_list)) {
1451 /* uninstall from kernel */
1452 zl3vni_rmac_uninstall(zl3vni, zrmac);
1453
1454 /* Send RMAC for FPM processing */
1455 hook_call(zebra_rmac_update, zrmac, zl3vni, true,
1456 "RMAC deleted");
1457
1458 if (IS_ZEBRA_DEBUG_VXLAN)
1459 zlog_debug(
1460 "L3VNI %u RMAC %pEA vtep_ip %pIA delete",
1461 zl3vni->vni, &zrmac->macaddr, vtep_ip);
1462
1463 /* del the rmac entry */
1464 zl3vni_rmac_del(zl3vni, zrmac);
1465 }
1466 }
1467 }
1468
1469 /*
1470 * Common code for look up of nh hash entry.
1471 */
1472 static struct zebra_neigh *_nh_lookup(struct zebra_l3vni *zl3vni,
1473 const struct ipaddr *ip)
1474 {
1475 struct zebra_neigh tmp;
1476 struct zebra_neigh *n;
1477
1478 memset(&tmp, 0, sizeof(tmp));
1479 memcpy(&tmp.ip, ip, sizeof(struct ipaddr));
1480
1481 if (zl3vni)
1482 n = hash_lookup(zl3vni->nh_table, &tmp);
1483 else
1484 n = hash_lookup(svd_nh_table, &tmp);
1485
1486 return n;
1487 }
1488
1489 /*
1490 * Look up nh hash entry on a l3-vni.
1491 */
1492 static struct zebra_neigh *zl3vni_nh_lookup(struct zebra_l3vni *zl3vni,
1493 const struct ipaddr *ip)
1494 {
1495 return _nh_lookup(zl3vni, ip);
1496 }
1497
1498 /*
1499 * Look up nh hash entry on a SVD.
1500 */
1501 static struct zebra_neigh *svd_nh_lookup(const struct ipaddr *ip)
1502 {
1503 return _nh_lookup(NULL, ip);
1504 }
1505
1506 /*
1507 * Callback to allocate NH hash entry on L3-VNI.
1508 */
1509 static void *zl3vni_nh_alloc(void *p)
1510 {
1511 const struct zebra_neigh *tmp_n = p;
1512 struct zebra_neigh *n;
1513
1514 n = XCALLOC(MTYPE_L3NEIGH, sizeof(struct zebra_neigh));
1515 *n = *tmp_n;
1516
1517 return ((void *)n);
1518 }
1519
1520 /*
1521 * Common code for neigh add.
1522 */
1523 static struct zebra_neigh *_nh_add(struct zebra_l3vni *zl3vni,
1524 const struct ipaddr *ip,
1525 const struct ethaddr *mac)
1526 {
1527 struct zebra_neigh tmp_n;
1528 struct zebra_neigh *n = NULL;
1529
1530 memset(&tmp_n, 0, sizeof(tmp_n));
1531 memcpy(&tmp_n.ip, ip, sizeof(struct ipaddr));
1532
1533 if (zl3vni)
1534 n = hash_get(zl3vni->nh_table, &tmp_n, zl3vni_nh_alloc);
1535 else
1536 n = hash_get(svd_nh_table, &tmp_n, zl3vni_nh_alloc);
1537
1538 assert(n);
1539
1540 RB_INIT(host_rb_tree_entry, &n->host_rb);
1541
1542 memcpy(&n->emac, mac, ETH_ALEN);
1543 SET_FLAG(n->flags, ZEBRA_NEIGH_REMOTE);
1544 SET_FLAG(n->flags, ZEBRA_NEIGH_REMOTE_NH);
1545
1546 return n;
1547 }
1548
1549 /*
1550 * Add neighbor entry.
1551 */
1552 static struct zebra_neigh *zl3vni_nh_add(struct zebra_l3vni *zl3vni,
1553 const struct ipaddr *ip,
1554 const struct ethaddr *mac)
1555 {
1556 return _nh_add(zl3vni, ip, mac);
1557 }
1558
1559 /*
1560 * Delete neighbor entry.
1561 */
1562 static int zl3vni_nh_del(struct zebra_l3vni *zl3vni, struct zebra_neigh *n)
1563 {
1564 struct zebra_neigh *tmp_n;
1565 struct host_rb_entry *hle;
1566
1567 while (!RB_EMPTY(host_rb_tree_entry, &n->host_rb)) {
1568 hle = RB_ROOT(host_rb_tree_entry, &n->host_rb);
1569
1570 RB_REMOVE(host_rb_tree_entry, &n->host_rb, hle);
1571 XFREE(MTYPE_HOST_PREFIX, hle);
1572 }
1573
1574 tmp_n = hash_release(zl3vni->nh_table, n);
1575 XFREE(MTYPE_L3NEIGH, tmp_n);
1576
1577 return 0;
1578 }
1579
1580 /*
1581 * Add Single VXlan Device neighbor entry.
1582 */
1583 static struct zebra_neigh *svd_nh_add(const struct ipaddr *ip,
1584 const struct ethaddr *mac)
1585 {
1586 return _nh_add(NULL, ip, mac);
1587 }
1588
1589 /*
1590 * Del Single VXlan Device neighbor entry.
1591 */
1592 static int svd_nh_del(struct zebra_neigh *n)
1593 {
1594 if (n->refcnt > 0)
1595 return -1;
1596
1597 hash_release(svd_nh_table, n);
1598 XFREE(MTYPE_L3NEIGH, n);
1599
1600 return 0;
1601 }
1602
1603 /*
1604 * Common code to install remote nh as neigh into the kernel.
1605 */
1606 static int _nh_install(struct zebra_l3vni *zl3vni, struct interface *ifp,
1607 struct zebra_neigh *n)
1608 {
1609 uint8_t flags;
1610 int ret = 0;
1611
1612 if (zl3vni && !is_l3vni_oper_up(zl3vni))
1613 return -1;
1614
1615 if (!(n->flags & ZEBRA_NEIGH_REMOTE)
1616 || !(n->flags & ZEBRA_NEIGH_REMOTE_NH))
1617 return 0;
1618
1619 flags = DPLANE_NTF_EXT_LEARNED;
1620 if (n->flags & ZEBRA_NEIGH_ROUTER_FLAG)
1621 flags |= DPLANE_NTF_ROUTER;
1622
1623 dplane_rem_neigh_add(ifp, &n->ip, &n->emac, flags,
1624 false /*was_static*/);
1625
1626 return ret;
1627 }
1628
1629 /*
1630 * Common code to uninstall remote nh from the kernel.
1631 */
1632 static int _nh_uninstall(struct interface *ifp, struct zebra_neigh *n)
1633 {
1634 if (!(n->flags & ZEBRA_NEIGH_REMOTE)
1635 || !(n->flags & ZEBRA_NEIGH_REMOTE_NH))
1636 return 0;
1637
1638 if (!ifp || !if_is_operative(ifp))
1639 return 0;
1640
1641 dplane_rem_neigh_delete(ifp, &n->ip);
1642
1643 return 0;
1644 }
1645
1646 /*
1647 * Install remote nh as neigh into the kernel.
1648 */
1649 static int zl3vni_nh_install(struct zebra_l3vni *zl3vni, struct zebra_neigh *n)
1650 {
1651 return _nh_install(zl3vni, zl3vni->svi_if, n);
1652 }
1653
1654 /*
1655 * Uninstall remote nh from the kernel.
1656 */
1657 static int zl3vni_nh_uninstall(struct zebra_l3vni *zl3vni,
1658 struct zebra_neigh *n)
1659 {
1660 return _nh_uninstall(zl3vni->svi_if, n);
1661 }
1662
1663 /*
1664 * Install SVD remote nh as neigh into the kernel.
1665 */
1666 static int svd_nh_install(struct zebra_l3vni *zl3vni, struct zebra_neigh *n)
1667 {
1668 return _nh_install(zl3vni, zl3vni->vxlan_if, n);
1669 }
1670
1671 /*
1672 * Uninstall SVD remote nh from the kernel.
1673 */
1674 static int svd_nh_uninstall(struct zebra_l3vni *zl3vni, struct zebra_neigh *n)
1675 {
1676 return _nh_uninstall(zl3vni->vxlan_if, n);
1677 }
1678
1679 /* Add remote vtep as a neigh entry */
1680 static int zl3vni_remote_nh_add(struct zebra_l3vni *zl3vni,
1681 const struct ipaddr *vtep_ip,
1682 const struct ethaddr *rmac,
1683 const struct prefix *host_prefix)
1684 {
1685 struct zebra_neigh *nh = NULL;
1686
1687 /* Create the next hop entry, or update its mac, if necessary. */
1688 nh = zl3vni_nh_lookup(zl3vni, vtep_ip);
1689 if (!nh) {
1690 nh = zl3vni_nh_add(zl3vni, vtep_ip, rmac);
1691 if (!nh) {
1692 zlog_debug(
1693 "Failed to add NH %pIA as Neigh (RMAC %pEA L3-VNI %u prefix %pFX)",
1694 vtep_ip, rmac, zl3vni->vni, host_prefix);
1695 return -1;
1696 }
1697
1698 /* install the nh neigh in kernel */
1699 zl3vni_nh_install(zl3vni, nh);
1700 } else if (memcmp(&nh->emac, rmac, ETH_ALEN) != 0) {
1701 if (IS_ZEBRA_DEBUG_VXLAN)
1702 zlog_debug(
1703 "L3VNI %u RMAC change(%pEA --> %pEA) for nexthop %pIA, prefix %pFX",
1704 zl3vni->vni, &nh->emac, rmac, vtep_ip,
1705 host_prefix);
1706
1707 memcpy(&nh->emac, rmac, ETH_ALEN);
1708 /* install (update) the nh neigh in kernel */
1709 zl3vni_nh_install(zl3vni, nh);
1710 }
1711
1712 rb_find_or_add_host(&nh->host_rb, host_prefix);
1713
1714 return 0;
1715 }
1716
1717 /* Del remote vtep as a neigh entry */
1718 static void zl3vni_remote_nh_del(struct zebra_l3vni *zl3vni,
1719 struct zebra_neigh *nh,
1720 struct prefix *host_prefix)
1721 {
1722 rb_delete_host(&nh->host_rb, host_prefix);
1723
1724 if (RB_EMPTY(host_rb_tree_entry, &nh->host_rb)) {
1725 /* uninstall from kernel */
1726 zl3vni_nh_uninstall(zl3vni, nh);
1727
1728 /* delete the nh entry */
1729 zl3vni_nh_del(zl3vni, nh);
1730 }
1731 }
1732
1733 /* Add remote vtep as a SVD neigh entry */
1734 static int svd_remote_nh_add(struct zebra_l3vni *zl3vni,
1735 const struct ipaddr *vtep_ip,
1736 const struct ethaddr *rmac,
1737 const struct prefix *host_prefix)
1738 {
1739 struct zebra_neigh *nh = NULL;
1740
1741 /* SVD backed VNI check */
1742 if (!IS_ZL3VNI_SVD_BACKED(zl3vni))
1743 return 0;
1744
1745 /* Create the SVD next hop entry, or update its mac, if necessary. */
1746 nh = svd_nh_lookup(vtep_ip);
1747 if (!nh) {
1748 nh = svd_nh_add(vtep_ip, rmac);
1749 if (!nh) {
1750 zlog_debug(
1751 "Failed to add NH %pIA as SVD Neigh (RMAC %pEA prefix %pFX)",
1752 vtep_ip, rmac, host_prefix);
1753 return -1;
1754 }
1755
1756 } else if (memcmp(&nh->emac, rmac, ETH_ALEN) != 0) {
1757 if (IS_ZEBRA_DEBUG_VXLAN)
1758 zlog_debug(
1759 "SVD RMAC change(%pEA --> %pEA) for nexthop %pIA, prefix %pFX",
1760 &nh->emac, rmac, vtep_ip, host_prefix);
1761
1762 memcpy(&nh->emac, rmac, ETH_ALEN);
1763 /* install (update) the nh neigh in kernel */
1764 svd_nh_install(zl3vni, nh);
1765
1766 /* Don't increment refcnt change */
1767 return 0;
1768 }
1769
1770 nh->refcnt++;
1771
1772 if (IS_ZEBRA_DEBUG_VXLAN)
1773 zlog_debug("SVD NH ADD refcnt (%u) for nexthop %pIA",
1774 nh->refcnt, vtep_ip);
1775
1776 /*
1777 * Install the nh neigh in kernel if this is the first time we
1778 * have seen it.
1779 */
1780 if (nh->refcnt == 1)
1781 svd_nh_install(zl3vni, nh);
1782
1783 return 0;
1784 }
1785
1786 /* Del remote vtep as a SVD neigh entry */
1787 static int svd_remote_nh_del(struct zebra_l3vni *zl3vni,
1788 const struct ipaddr *vtep_ip)
1789 {
1790 struct zebra_neigh *nh;
1791
1792 /* SVD backed VNI check */
1793 if (!IS_ZL3VNI_SVD_BACKED(zl3vni))
1794 return 0;
1795
1796 nh = svd_nh_lookup(vtep_ip);
1797 if (!nh) {
1798 zlog_debug("Failed to del NH %pIA as SVD Neigh", vtep_ip);
1799
1800 return -1;
1801 }
1802
1803 nh->refcnt--;
1804
1805 if (IS_ZEBRA_DEBUG_VXLAN)
1806 zlog_debug("SVD NH Del refcnt (%u) for nexthop %pIA",
1807 nh->refcnt, vtep_ip);
1808
1809 /* Last refcnt on NH, remove it completely. */
1810 if (nh->refcnt == 0) {
1811 svd_nh_uninstall(zl3vni, nh);
1812 svd_nh_del(nh);
1813 }
1814
1815 return 0;
1816 }
1817
1818 /* handle neigh update from kernel - the only thing of interest is to
1819 * readd stale entries.
1820 */
1821 static int zl3vni_local_nh_add_update(struct zebra_l3vni *zl3vni,
1822 struct ipaddr *ip, uint16_t state)
1823 {
1824 #ifdef GNU_LINUX
1825 struct zebra_neigh *n = NULL;
1826
1827 n = zl3vni_nh_lookup(zl3vni, ip);
1828 if (!n)
1829 return 0;
1830
1831 /* all next hop neigh are remote and installed by frr.
1832 * If the kernel has aged this entry, re-install.
1833 */
1834 if (state & NUD_STALE)
1835 zl3vni_nh_install(zl3vni, n);
1836 #endif
1837 return 0;
1838 }
1839
1840 /* handle neigh delete from kernel */
1841 static int zl3vni_local_nh_del(struct zebra_l3vni *zl3vni, struct ipaddr *ip)
1842 {
1843 struct zebra_neigh *n = NULL;
1844
1845 n = zl3vni_nh_lookup(zl3vni, ip);
1846 if (!n)
1847 return 0;
1848
1849 /* all next hop neigh are remote and installed by frr.
1850 * If we get an age out notification for these neigh entries, we have to
1851 * install it back
1852 */
1853 zl3vni_nh_install(zl3vni, n);
1854
1855 return 0;
1856 }
1857
1858 /*
1859 * Hash function for L3 VNI.
1860 */
1861 static unsigned int l3vni_hash_keymake(const void *p)
1862 {
1863 const struct zebra_l3vni *zl3vni = p;
1864
1865 return jhash_1word(zl3vni->vni, 0);
1866 }
1867
1868 /*
1869 * Compare 2 L3 VNI hash entries.
1870 */
1871 static bool l3vni_hash_cmp(const void *p1, const void *p2)
1872 {
1873 const struct zebra_l3vni *zl3vni1 = p1;
1874 const struct zebra_l3vni *zl3vni2 = p2;
1875
1876 return (zl3vni1->vni == zl3vni2->vni);
1877 }
1878
1879 /*
1880 * Callback to allocate L3 VNI hash entry.
1881 */
1882 static void *zl3vni_alloc(void *p)
1883 {
1884 struct zebra_l3vni *zl3vni = NULL;
1885 const struct zebra_l3vni *tmp_l3vni = p;
1886
1887 zl3vni = XCALLOC(MTYPE_ZL3VNI, sizeof(struct zebra_l3vni));
1888 zl3vni->vni = tmp_l3vni->vni;
1889 return ((void *)zl3vni);
1890 }
1891
1892 /*
1893 * Look up L3 VNI hash entry.
1894 */
1895 struct zebra_l3vni *zl3vni_lookup(vni_t vni)
1896 {
1897 struct zebra_l3vni tmp_l3vni;
1898 struct zebra_l3vni *zl3vni = NULL;
1899
1900 memset(&tmp_l3vni, 0, sizeof(tmp_l3vni));
1901 tmp_l3vni.vni = vni;
1902 zl3vni = hash_lookup(zrouter.l3vni_table, &tmp_l3vni);
1903
1904 return zl3vni;
1905 }
1906
1907 /*
1908 * Add L3 VNI hash entry.
1909 */
1910 static struct zebra_l3vni *zl3vni_add(vni_t vni, vrf_id_t vrf_id)
1911 {
1912 struct zebra_l3vni tmp_zl3vni;
1913 struct zebra_l3vni *zl3vni = NULL;
1914
1915 memset(&tmp_zl3vni, 0, sizeof(tmp_zl3vni));
1916 tmp_zl3vni.vni = vni;
1917
1918 zl3vni = hash_get(zrouter.l3vni_table, &tmp_zl3vni, zl3vni_alloc);
1919
1920 zl3vni->vrf_id = vrf_id;
1921 zl3vni->svi_if = NULL;
1922 zl3vni->vxlan_if = NULL;
1923 zl3vni->l2vnis = list_new();
1924 zl3vni->l2vnis->cmp = zebra_evpn_list_cmp;
1925
1926 /* Create hash table for remote RMAC */
1927 zl3vni->rmac_table = zebra_mac_db_create("Zebra L3-VNI RMAC-Table");
1928
1929 /* Create hash table for neighbors */
1930 zl3vni->nh_table = zebra_neigh_db_create("Zebra L3-VNI next-hop table");
1931
1932 return zl3vni;
1933 }
1934
1935 /*
1936 * Delete L3 VNI hash entry.
1937 */
1938 static int zl3vni_del(struct zebra_l3vni *zl3vni)
1939 {
1940 struct zebra_l3vni *tmp_zl3vni;
1941
1942 /* free the list of l2vnis */
1943 list_delete(&zl3vni->l2vnis);
1944 zl3vni->l2vnis = NULL;
1945
1946 /* Free the rmac table */
1947 hash_free(zl3vni->rmac_table);
1948 zl3vni->rmac_table = NULL;
1949
1950 /* Free the nh table */
1951 hash_free(zl3vni->nh_table);
1952 zl3vni->nh_table = NULL;
1953
1954 /* Free the VNI hash entry and allocated memory. */
1955 tmp_zl3vni = hash_release(zrouter.l3vni_table, zl3vni);
1956 XFREE(MTYPE_ZL3VNI, tmp_zl3vni);
1957
1958 return 0;
1959 }
1960
1961 static int zl3vni_map_to_vxlan_if_ns(struct ns *ns,
1962 void *_zl3vni,
1963 void **_pifp)
1964 {
1965 struct zebra_ns *zns = ns->info;
1966 struct zebra_l3vni *zl3vni = (struct zebra_l3vni *)_zl3vni;
1967 struct route_node *rn = NULL;
1968 struct interface *ifp = NULL;
1969 struct zebra_vrf *zvrf;
1970
1971 zvrf = zebra_vrf_get_evpn();
1972
1973 assert(_pifp);
1974
1975 /* loop through all vxlan-interface */
1976 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
1977
1978 struct zebra_if *zif = NULL;
1979 struct zebra_l2info_vxlan *vxl;
1980 struct zebra_vxlan_vni *vni = NULL;
1981
1982 ifp = (struct interface *)rn->info;
1983 if (!ifp)
1984 continue;
1985
1986 zif = ifp->info;
1987 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
1988 continue;
1989
1990 vxl = &zif->l2info.vxl;
1991 vni = zebra_vxlan_if_vni_find(zif, zl3vni->vni);
1992 if (!vni || vni->vni != zl3vni->vni)
1993 continue;
1994
1995 /* link of VXLAN interface should be in zebra_evpn_vrf */
1996 if (zvrf->zns->ns_id != vxl->link_nsid) {
1997 if (IS_ZEBRA_DEBUG_VXLAN)
1998 zlog_debug(
1999 "Intf %s(%u) VNI %u, link not in same "
2000 "namespace than BGP EVPN core instance ",
2001 ifp->name, ifp->ifindex, vni->vni);
2002 continue;
2003 }
2004
2005
2006 zl3vni->local_vtep_ip = zif->l2info.vxl.vtep_ip;
2007 *_pifp = (void *)ifp;
2008 return NS_WALK_STOP;
2009 }
2010
2011 return NS_WALK_CONTINUE;
2012 }
2013
2014 struct interface *zl3vni_map_to_vxlan_if(struct zebra_l3vni *zl3vni)
2015 {
2016 struct interface **p_ifp;
2017 struct interface *ifp = NULL;
2018
2019 p_ifp = &ifp;
2020
2021 ns_walk_func(zl3vni_map_to_vxlan_if_ns,
2022 (void *)zl3vni, (void **)p_ifp);
2023 return ifp;
2024 }
2025
2026 struct interface *zl3vni_map_to_svi_if(struct zebra_l3vni *zl3vni)
2027 {
2028 struct zebra_if *zif = NULL; /* zebra_if for vxlan_if */
2029 struct zebra_vxlan_vni *vni = NULL; /* vni info in vxlan_if */
2030
2031 if (!zl3vni)
2032 return NULL;
2033
2034 if (!zl3vni->vxlan_if)
2035 return NULL;
2036
2037 zif = zl3vni->vxlan_if->info;
2038 if (!zif)
2039 return NULL;
2040
2041 vni = zebra_vxlan_if_vni_find(zif, zl3vni->vni);
2042 if (!vni)
2043 return NULL;
2044
2045 return zvni_map_to_svi(vni->access_vlan, zif->brslave_info.br_if);
2046 }
2047
2048 struct interface *zl3vni_map_to_mac_vlan_if(struct zebra_l3vni *zl3vni)
2049 {
2050 struct zebra_if *zif = NULL; /* zebra_if for vxlan_if */
2051
2052 if (!zl3vni)
2053 return NULL;
2054
2055 if (!zl3vni->vxlan_if)
2056 return NULL;
2057
2058 zif = zl3vni->vxlan_if->info;
2059 if (!zif)
2060 return NULL;
2061
2062 return zebra_evpn_map_to_macvlan(zif->brslave_info.br_if,
2063 zl3vni->svi_if);
2064 }
2065
2066
2067 struct zebra_l3vni *zl3vni_from_vrf(vrf_id_t vrf_id)
2068 {
2069 struct zebra_vrf *zvrf = NULL;
2070
2071 zvrf = zebra_vrf_lookup_by_id(vrf_id);
2072 if (!zvrf)
2073 return NULL;
2074
2075 return zl3vni_lookup(zvrf->l3vni);
2076 }
2077
2078 static int zl3vni_from_svi_ns(struct ns *ns, void *_in_param, void **_p_zl3vni)
2079 {
2080 int found = 0;
2081 vni_t vni_id = 0;
2082 struct zebra_ns *zns = ns->info;
2083 struct zebra_l3vni **p_zl3vni = (struct zebra_l3vni **)_p_zl3vni;
2084 struct zebra_from_svi_param *in_param =
2085 (struct zebra_from_svi_param *)_in_param;
2086 struct route_node *rn = NULL;
2087 struct interface *tmp_if = NULL;
2088 struct zebra_if *zif = NULL;
2089 struct zebra_if *br_zif = NULL;
2090
2091 assert(in_param && p_zl3vni);
2092
2093 br_zif = in_param->br_if->info;
2094 assert(br_zif);
2095
2096 if (in_param->bridge_vlan_aware) {
2097 vni_id = zebra_l2_bridge_if_vni_find(br_zif, in_param->vid);
2098 if (vni_id)
2099 found = 1;
2100 } else {
2101 /* loop through all vxlan-interface */
2102 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
2103 tmp_if = (struct interface *)rn->info;
2104 if (!tmp_if)
2105 continue;
2106 zif = tmp_if->info;
2107 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
2108 continue;
2109 if (!if_is_operative(tmp_if))
2110 continue;
2111
2112 if (zif->brslave_info.br_if != in_param->br_if)
2113 continue;
2114
2115 vni_id = zebra_vxlan_if_access_vlan_vni_find(
2116 zif, in_param->br_if);
2117 if (vni_id) {
2118 found = 1;
2119 break;
2120 }
2121 }
2122 }
2123
2124 if (!found)
2125 return NS_WALK_CONTINUE;
2126
2127 *p_zl3vni = zl3vni_lookup(vni_id);
2128 return NS_WALK_STOP;
2129 }
2130
2131 /*
2132 * Map SVI and associated bridge to a VNI. This is invoked upon getting
2133 * neighbor notifications, to see if they are of interest.
2134 */
2135 static struct zebra_l3vni *zl3vni_from_svi(struct interface *ifp,
2136 struct interface *br_if)
2137 {
2138 struct zebra_l3vni *zl3vni = NULL;
2139 struct zebra_if *zif = NULL;
2140 struct zebra_from_svi_param in_param = {};
2141 struct zebra_l3vni **p_zl3vni;
2142
2143 if (!br_if)
2144 return NULL;
2145
2146 /* Make sure the linked interface is a bridge. */
2147 if (!IS_ZEBRA_IF_BRIDGE(br_if))
2148 return NULL;
2149 in_param.br_if = br_if;
2150
2151 /* Determine if bridge is VLAN-aware or not */
2152 zif = br_if->info;
2153 assert(zif);
2154 in_param.bridge_vlan_aware = IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(zif);
2155 if (in_param.bridge_vlan_aware) {
2156 struct zebra_l2info_vlan *vl;
2157
2158 if (!IS_ZEBRA_IF_VLAN(ifp))
2159 return NULL;
2160
2161 zif = ifp->info;
2162 assert(zif);
2163 vl = &zif->l2info.vl;
2164 in_param.vid = vl->vid;
2165 }
2166
2167 /* See if this interface (or interface plus VLAN Id) maps to a VxLAN */
2168 /* TODO: Optimize with a hash. */
2169
2170 p_zl3vni = &zl3vni;
2171
2172 ns_walk_func(zl3vni_from_svi_ns, (void *)&in_param, (void **)p_zl3vni);
2173 return zl3vni;
2174 }
2175
2176 vni_t vni_id_from_svi(struct interface *ifp, struct interface *br_if)
2177 {
2178 vni_t vni = 0;
2179 struct zebra_evpn *zevpn = NULL;
2180 struct zebra_l3vni *zl3vni = NULL;
2181
2182 /* Check if an L3VNI belongs to this SVI interface.
2183 * If not, check if an L2VNI belongs to this SVI interface.
2184 */
2185 zl3vni = zl3vni_from_svi(ifp, br_if);
2186 if (zl3vni)
2187 vni = zl3vni->vni;
2188 else {
2189 zevpn = zebra_evpn_from_svi(ifp, br_if);
2190 if (zevpn)
2191 vni = zevpn->vni;
2192 }
2193
2194 return vni;
2195 }
2196
2197 static inline void zl3vni_get_vrr_rmac(struct zebra_l3vni *zl3vni,
2198 struct ethaddr *rmac)
2199 {
2200 if (!zl3vni)
2201 return;
2202
2203 if (!is_l3vni_oper_up(zl3vni))
2204 return;
2205
2206 if (zl3vni->mac_vlan_if && if_is_operative(zl3vni->mac_vlan_if))
2207 memcpy(rmac->octet, zl3vni->mac_vlan_if->hw_addr, ETH_ALEN);
2208 }
2209
2210 /*
2211 * Inform BGP about l3-vni.
2212 */
2213 static int zl3vni_send_add_to_client(struct zebra_l3vni *zl3vni)
2214 {
2215 struct stream *s = NULL;
2216 struct zserv *client = NULL;
2217 struct ethaddr svi_rmac, vrr_rmac = {.octet = {0} };
2218 struct zebra_vrf *zvrf;
2219 bool is_anycast_mac = true;
2220
2221 client = zserv_find_client(ZEBRA_ROUTE_BGP, 0);
2222 /* BGP may not be running. */
2223 if (!client)
2224 return 0;
2225
2226 zvrf = zebra_vrf_lookup_by_id(zl3vni->vrf_id);
2227 assert(zvrf);
2228
2229 /* get the svi and vrr rmac values */
2230 memset(&svi_rmac, 0, sizeof(svi_rmac));
2231 zl3vni_get_svi_rmac(zl3vni, &svi_rmac);
2232 zl3vni_get_vrr_rmac(zl3vni, &vrr_rmac);
2233
2234 /* In absence of vrr mac use svi mac as anycast MAC value */
2235 if (is_zero_mac(&vrr_rmac)) {
2236 memcpy(&vrr_rmac, &svi_rmac, ETH_ALEN);
2237 is_anycast_mac = false;
2238 }
2239
2240 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
2241
2242 /* The message is used for both vni add and/or update like
2243 * vrr mac is added for l3vni SVI.
2244 */
2245 zclient_create_header(s, ZEBRA_L3VNI_ADD, zl3vni_vrf_id(zl3vni));
2246 stream_putl(s, zl3vni->vni);
2247 stream_put(s, &svi_rmac, sizeof(struct ethaddr));
2248 stream_put_in_addr(s, &zl3vni->local_vtep_ip);
2249 stream_put(s, &zl3vni->filter, sizeof(int));
2250 stream_putl(s, zl3vni->svi_if->ifindex);
2251 stream_put(s, &vrr_rmac, sizeof(struct ethaddr));
2252 stream_putl(s, is_anycast_mac);
2253
2254 /* Write packet size. */
2255 stream_putw_at(s, 0, stream_get_endp(s));
2256
2257 if (IS_ZEBRA_DEBUG_VXLAN)
2258 zlog_debug(
2259 "Send L3_VNI_ADD %u VRF %s RMAC %pEA VRR %pEA local-ip %pI4 filter %s to %s",
2260 zl3vni->vni, vrf_id_to_name(zl3vni_vrf_id(zl3vni)),
2261 &svi_rmac, &vrr_rmac, &zl3vni->local_vtep_ip,
2262 CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
2263 ? "prefix-routes-only"
2264 : "none",
2265 zebra_route_string(client->proto));
2266
2267 client->l3vniadd_cnt++;
2268 return zserv_send_message(client, s);
2269 }
2270
2271 /*
2272 * Inform BGP about local l3-VNI deletion.
2273 */
2274 static int zl3vni_send_del_to_client(struct zebra_l3vni *zl3vni)
2275 {
2276 struct stream *s = NULL;
2277 struct zserv *client = NULL;
2278
2279 client = zserv_find_client(ZEBRA_ROUTE_BGP, 0);
2280 /* BGP may not be running. */
2281 if (!client)
2282 return 0;
2283
2284 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
2285
2286 zclient_create_header(s, ZEBRA_L3VNI_DEL, zl3vni_vrf_id(zl3vni));
2287 stream_putl(s, zl3vni->vni);
2288
2289 /* Write packet size. */
2290 stream_putw_at(s, 0, stream_get_endp(s));
2291
2292 if (IS_ZEBRA_DEBUG_VXLAN)
2293 zlog_debug("Send L3_VNI_DEL %u VRF %s to %s", zl3vni->vni,
2294 vrf_id_to_name(zl3vni_vrf_id(zl3vni)),
2295 zebra_route_string(client->proto));
2296
2297 client->l3vnidel_cnt++;
2298 return zserv_send_message(client, s);
2299 }
2300
2301 void zebra_vxlan_process_l3vni_oper_up(struct zebra_l3vni *zl3vni)
2302 {
2303 if (!zl3vni)
2304 return;
2305
2306 /* send l3vni add to BGP */
2307 zl3vni_send_add_to_client(zl3vni);
2308 }
2309
2310 void zebra_vxlan_process_l3vni_oper_down(struct zebra_l3vni *zl3vni)
2311 {
2312 if (!zl3vni)
2313 return;
2314
2315 /* send l3-vni del to BGP*/
2316 zl3vni_send_del_to_client(zl3vni);
2317 }
2318
2319 static void zevpn_add_to_l3vni_list(struct hash_bucket *bucket, void *ctxt)
2320 {
2321 struct zebra_evpn *zevpn = (struct zebra_evpn *)bucket->data;
2322 struct zebra_l3vni *zl3vni = (struct zebra_l3vni *)ctxt;
2323
2324 if (zevpn->vrf_id == zl3vni_vrf_id(zl3vni))
2325 listnode_add_sort(zl3vni->l2vnis, zevpn);
2326 }
2327
2328 /*
2329 * Handle transition of vni from l2 to l3 and vice versa.
2330 * This function handles only the L2VNI add/delete part of
2331 * the above transition.
2332 * L3VNI add/delete is handled by the calling functions.
2333 */
2334 static int zebra_vxlan_handle_vni_transition(struct zebra_vrf *zvrf, vni_t vni,
2335 int add)
2336 {
2337 struct zebra_evpn *zevpn = NULL;
2338 struct zebra_l3vni *zl3vni = NULL;
2339
2340 /* There is a possibility that VNI notification was already received
2341 * from kernel and we programmed it as L2-VNI
2342 * In such a case we need to delete this L2-VNI first, so
2343 * that it can be reprogrammed as L3-VNI in the system. It is also
2344 * possible that the vrf-vni mapping is removed from FRR while the vxlan
2345 * interface is still present in kernel. In this case to keep it
2346 * symmetric, we will delete the l3-vni and reprogram it as l2-vni
2347 */
2348 if (add) {
2349 /* Locate hash entry */
2350 zevpn = zebra_evpn_lookup(vni);
2351 if (!zevpn)
2352 return 0;
2353
2354 if (IS_ZEBRA_DEBUG_VXLAN)
2355 zlog_debug("Del L2-VNI %u - transition to L3-VNI", vni);
2356
2357 /* Delete EVPN from BGP. */
2358 zebra_evpn_send_del_to_client(zevpn);
2359
2360 zebra_evpn_neigh_del_all(zevpn, 0, 0, DEL_ALL_NEIGH);
2361 zebra_evpn_mac_del_all(zevpn, 0, 0, DEL_ALL_MAC);
2362
2363 /* Free up all remote VTEPs, if any. */
2364 zebra_evpn_vtep_del_all(zevpn, 1);
2365
2366 zl3vni = zl3vni_from_vrf(zevpn->vrf_id);
2367 if (zl3vni)
2368 listnode_delete(zl3vni->l2vnis, zevpn);
2369
2370 /* Delete the hash entry. */
2371 if (zebra_evpn_vxlan_del(zevpn)) {
2372 flog_err(EC_ZEBRA_VNI_DEL_FAILED,
2373 "Failed to del EVPN hash %p, VNI %u", zevpn,
2374 zevpn->vni);
2375 return -1;
2376 }
2377 } else {
2378 struct zebra_ns *zns;
2379 struct route_node *rn;
2380 struct interface *ifp;
2381 struct zebra_if *zif;
2382 struct zebra_vxlan_vni *vnip;
2383 struct zebra_l2info_vxlan *vxl;
2384 struct interface *vlan_if;
2385 bool found = false;
2386
2387 if (IS_ZEBRA_DEBUG_VXLAN)
2388 zlog_debug("Adding L2-VNI %u - transition from L3-VNI",
2389 vni);
2390
2391 /* Find VxLAN interface for this VNI. */
2392 zns = zebra_ns_lookup(NS_DEFAULT);
2393 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
2394 ifp = (struct interface *)rn->info;
2395 if (!ifp)
2396 continue;
2397 zif = ifp->info;
2398 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
2399 continue;
2400
2401 vxl = &zif->l2info.vxl;
2402 vnip = zebra_vxlan_if_vni_find(zif, vni);
2403 if (vnip) {
2404 found = true;
2405 break;
2406 }
2407 }
2408
2409 if (!found) {
2410 if (IS_ZEBRA_DEBUG_VXLAN)
2411 zlog_err(
2412 "Adding L2-VNI - Failed to find VxLAN interface for VNI %u",
2413 vni);
2414 return -1;
2415 }
2416
2417 /* Create VNI hash entry for L2VNI */
2418 zevpn = zebra_evpn_lookup(vni);
2419 if (zevpn)
2420 return 0;
2421
2422 zevpn = zebra_evpn_add(vni);
2423
2424 /* Find bridge interface for the VNI */
2425 vlan_if = zvni_map_to_svi(vnip->access_vlan,
2426 zif->brslave_info.br_if);
2427 if (vlan_if) {
2428 zevpn->vrf_id = vlan_if->vrf->vrf_id;
2429 zl3vni = zl3vni_from_vrf(vlan_if->vrf->vrf_id);
2430 if (zl3vni)
2431 listnode_add_sort_nodup(zl3vni->l2vnis, zevpn);
2432 }
2433
2434 zevpn->vxlan_if = ifp;
2435 zevpn->local_vtep_ip = vxl->vtep_ip;
2436
2437 /* Inform BGP if the VNI is up and mapped to a bridge. */
2438 if (if_is_operative(ifp) && zif->brslave_info.br_if) {
2439 zebra_evpn_send_add_to_client(zevpn);
2440 zebra_evpn_read_mac_neigh(zevpn, ifp);
2441 }
2442 }
2443
2444 return 0;
2445 }
2446
2447 /* delete and uninstall rmac hash entry */
2448 static void zl3vni_del_rmac_hash_entry(struct hash_bucket *bucket, void *ctx)
2449 {
2450 struct zebra_mac *zrmac = NULL;
2451 struct zebra_l3vni *zl3vni = NULL;
2452
2453 zrmac = (struct zebra_mac *)bucket->data;
2454 zl3vni = (struct zebra_l3vni *)ctx;
2455 zl3vni_rmac_uninstall(zl3vni, zrmac);
2456
2457 /* Send RMAC for FPM processing */
2458 hook_call(zebra_rmac_update, zrmac, zl3vni, true, "RMAC deleted");
2459
2460 zl3vni_rmac_del(zl3vni, zrmac);
2461 }
2462
2463 /* delete and uninstall nh hash entry */
2464 static void zl3vni_del_nh_hash_entry(struct hash_bucket *bucket, void *ctx)
2465 {
2466 struct zebra_neigh *n = NULL;
2467 struct zebra_l3vni *zl3vni = NULL;
2468
2469 n = (struct zebra_neigh *)bucket->data;
2470 zl3vni = (struct zebra_l3vni *)ctx;
2471 zl3vni_nh_uninstall(zl3vni, n);
2472 zl3vni_nh_del(zl3vni, n);
2473 }
2474
2475 /* re-add remote rmac if needed */
2476 static int zebra_vxlan_readd_remote_rmac(struct zebra_l3vni *zl3vni,
2477 struct ethaddr *rmac)
2478 {
2479 struct zebra_mac *zrmac = NULL;
2480
2481 zrmac = zl3vni_rmac_lookup(zl3vni, rmac);
2482 if (!zrmac)
2483 return 0;
2484
2485 if (IS_ZEBRA_DEBUG_VXLAN)
2486 zlog_debug("Del remote RMAC %pEA L3VNI %u - readd",
2487 rmac, zl3vni->vni);
2488
2489 zl3vni_rmac_install(zl3vni, zrmac);
2490 return 0;
2491 }
2492
2493 /* Public functions */
2494
2495 int is_l3vni_for_prefix_routes_only(vni_t vni)
2496 {
2497 struct zebra_l3vni *zl3vni = NULL;
2498
2499 zl3vni = zl3vni_lookup(vni);
2500 if (!zl3vni)
2501 return 0;
2502
2503 return CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY) ? 1 : 0;
2504 }
2505
2506 /* handle evpn route in vrf table */
2507 void zebra_vxlan_evpn_vrf_route_add(vrf_id_t vrf_id, const struct ethaddr *rmac,
2508 const struct ipaddr *vtep_ip,
2509 const struct prefix *host_prefix)
2510 {
2511 struct zebra_l3vni *zl3vni = NULL;
2512 struct ipaddr ipv4_vtep;
2513
2514 zl3vni = zl3vni_from_vrf(vrf_id);
2515 if (!zl3vni || !is_l3vni_oper_up(zl3vni))
2516 return;
2517
2518 /*
2519 * add the next hop neighbor -
2520 * neigh to be installed is the ipv6 nexthop neigh
2521 */
2522 zl3vni_remote_nh_add(zl3vni, vtep_ip, rmac, host_prefix);
2523
2524 /* Add SVD next hop neighbor */
2525 svd_remote_nh_add(zl3vni, vtep_ip, rmac, host_prefix);
2526
2527 /*
2528 * if the remote vtep is a ipv4 mapped ipv6 address convert it to ipv4
2529 * address. Rmac is programmed against the ipv4 vtep because we only
2530 * support ipv4 tunnels in the h/w right now
2531 */
2532 memset(&ipv4_vtep, 0, sizeof(ipv4_vtep));
2533 ipv4_vtep.ipa_type = IPADDR_V4;
2534 if (vtep_ip->ipa_type == IPADDR_V6)
2535 ipv4_mapped_ipv6_to_ipv4(&vtep_ip->ipaddr_v6,
2536 &(ipv4_vtep.ipaddr_v4));
2537 else
2538 memcpy(&(ipv4_vtep.ipaddr_v4), &vtep_ip->ipaddr_v4,
2539 sizeof(struct in_addr));
2540
2541 /*
2542 * add the rmac - remote rmac to be installed is against the ipv4
2543 * nexthop address
2544 */
2545 zl3vni_remote_rmac_add(zl3vni, rmac, &ipv4_vtep);
2546 }
2547
2548 /* handle evpn vrf route delete */
2549 void zebra_vxlan_evpn_vrf_route_del(vrf_id_t vrf_id,
2550 struct ipaddr *vtep_ip,
2551 struct prefix *host_prefix)
2552 {
2553 struct zebra_l3vni *zl3vni = NULL;
2554 struct zebra_neigh *nh = NULL;
2555 struct zebra_mac *zrmac = NULL;
2556
2557 zl3vni = zl3vni_from_vrf(vrf_id);
2558 if (!zl3vni)
2559 return;
2560
2561 /* find the next hop entry and rmac entry */
2562 nh = zl3vni_nh_lookup(zl3vni, vtep_ip);
2563 if (!nh)
2564 return;
2565 zrmac = zl3vni_rmac_lookup(zl3vni, &nh->emac);
2566
2567 /* delete the next hop entry */
2568 zl3vni_remote_nh_del(zl3vni, nh, host_prefix);
2569
2570 /* Delete SVD next hop entry */
2571 svd_remote_nh_del(zl3vni, vtep_ip);
2572
2573 /* delete the rmac entry */
2574 if (zrmac)
2575 zl3vni_remote_rmac_del(zl3vni, zrmac, vtep_ip);
2576 }
2577
2578 void zebra_vxlan_print_specific_rmac_l3vni(struct vty *vty, vni_t l3vni,
2579 struct ethaddr *rmac, bool use_json)
2580 {
2581 struct zebra_l3vni *zl3vni = NULL;
2582 struct zebra_mac *zrmac = NULL;
2583 json_object *json = NULL;
2584
2585 if (use_json)
2586 json = json_object_new_object();
2587
2588 if (!is_evpn_enabled()) {
2589 vty_json(vty, json);
2590 return;
2591 }
2592
2593 zl3vni = zl3vni_lookup(l3vni);
2594 if (!zl3vni) {
2595 if (use_json)
2596 vty_json(vty, json);
2597 else
2598 vty_out(vty, "%% L3-VNI %u doesn't exist\n", l3vni);
2599 return;
2600 }
2601
2602 zrmac = zl3vni_rmac_lookup(zl3vni, rmac);
2603 if (!zrmac) {
2604 if (use_json)
2605 vty_json(vty, json);
2606 else
2607 vty_out(vty,
2608 "%% Requested RMAC doesn't exist in L3-VNI %u\n",
2609 l3vni);
2610 return;
2611 }
2612
2613 zl3vni_print_rmac(zrmac, vty, json);
2614
2615 if (use_json)
2616 vty_json(vty, json);
2617 }
2618
2619 void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t l3vni, bool use_json)
2620 {
2621 struct zebra_l3vni *zl3vni;
2622 uint32_t num_rmacs;
2623 struct rmac_walk_ctx wctx;
2624 json_object *json = NULL;
2625
2626 if (use_json)
2627 json = json_object_new_object();
2628
2629 if (!is_evpn_enabled()) {
2630 vty_json(vty, json);
2631 return;
2632 }
2633
2634 zl3vni = zl3vni_lookup(l3vni);
2635 if (!zl3vni) {
2636 if (use_json)
2637 vty_json(vty, json);
2638 else
2639 vty_out(vty, "%% L3-VNI %u does not exist\n", l3vni);
2640 return;
2641 }
2642 num_rmacs = hashcount(zl3vni->rmac_table);
2643 if (!num_rmacs)
2644 return;
2645
2646 memset(&wctx, 0, sizeof(wctx));
2647 wctx.vty = vty;
2648 wctx.json = json;
2649 if (!use_json) {
2650 vty_out(vty, "Number of Remote RMACs known for this VNI: %u\n",
2651 num_rmacs);
2652 vty_out(vty, "%-17s %-21s\n", "MAC", "Remote VTEP");
2653 } else
2654 json_object_int_add(json, "numRmacs", num_rmacs);
2655
2656 hash_iterate(zl3vni->rmac_table, zl3vni_print_rmac_hash, &wctx);
2657
2658 if (use_json)
2659 vty_json(vty, json);
2660 }
2661
2662 void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, bool use_json)
2663 {
2664 json_object *json = NULL;
2665 void *args[2];
2666
2667 if (use_json)
2668 json = json_object_new_object();
2669
2670 if (!is_evpn_enabled()) {
2671 vty_json(vty, json);
2672 return;
2673 }
2674
2675 args[0] = vty;
2676 args[1] = json;
2677 hash_iterate(zrouter.l3vni_table,
2678 (void (*)(struct hash_bucket *,
2679 void *))zl3vni_print_rmac_hash_all_vni,
2680 args);
2681
2682 if (use_json)
2683 vty_json(vty, json);
2684 }
2685
2686 void zebra_vxlan_print_specific_nh_l3vni(struct vty *vty, vni_t l3vni,
2687 struct ipaddr *ip, bool use_json)
2688 {
2689 struct zebra_l3vni *zl3vni = NULL;
2690 struct zebra_neigh *n = NULL;
2691 json_object *json = NULL;
2692
2693 if (use_json)
2694 json = json_object_new_object();
2695
2696 if (!is_evpn_enabled()) {
2697 vty_json(vty, json);
2698 return;
2699 }
2700
2701 /* If vni=0 passed, assume svd lookup */
2702 if (!l3vni)
2703 n = svd_nh_lookup(ip);
2704 else {
2705 zl3vni = zl3vni_lookup(l3vni);
2706 if (!zl3vni) {
2707 if (use_json)
2708 vty_out(vty, "{}\n");
2709 else
2710 vty_out(vty, "%% L3-VNI %u does not exist\n",
2711 l3vni);
2712 return;
2713 }
2714
2715 n = zl3vni_nh_lookup(zl3vni, ip);
2716 }
2717
2718 if (!n) {
2719 if (use_json)
2720 vty_out(vty, "{}\n");
2721 else
2722 vty_out(vty,
2723 "%% Requested next-hop not present for L3-VNI %u\n",
2724 l3vni);
2725 return;
2726 }
2727
2728 zl3vni_print_nh(n, vty, json);
2729
2730 if (use_json)
2731 vty_json(vty, json);
2732 }
2733
2734 static void l3vni_print_nh_table(struct hash *nh_table, struct vty *vty,
2735 bool use_json)
2736 {
2737 uint32_t num_nh;
2738 struct nh_walk_ctx wctx;
2739 json_object *json = NULL;
2740
2741 num_nh = hashcount(nh_table);
2742 if (!num_nh)
2743 return;
2744
2745 if (use_json)
2746 json = json_object_new_object();
2747
2748 wctx.vty = vty;
2749 wctx.json = json;
2750 if (!use_json) {
2751 vty_out(vty, "Number of NH Neighbors known for this VNI: %u\n",
2752 num_nh);
2753 vty_out(vty, "%-15s %-17s\n", "IP", "RMAC");
2754 } else
2755 json_object_int_add(json, "numNextHops", num_nh);
2756
2757 hash_iterate(nh_table, zl3vni_print_nh_hash, &wctx);
2758
2759 if (use_json)
2760 vty_json(vty, json);
2761 }
2762
2763 void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t l3vni, bool use_json)
2764 {
2765 struct zebra_l3vni *zl3vni = NULL;
2766
2767 if (!is_evpn_enabled()) {
2768 if (use_json)
2769 vty_out(vty, "{}\n");
2770 return;
2771 }
2772
2773 zl3vni = zl3vni_lookup(l3vni);
2774 if (!zl3vni) {
2775 if (use_json)
2776 vty_out(vty, "{}\n");
2777 else
2778 vty_out(vty, "%% L3-VNI %u does not exist\n", l3vni);
2779 return;
2780 }
2781
2782 l3vni_print_nh_table(zl3vni->nh_table, vty, use_json);
2783 }
2784
2785 void zebra_vxlan_print_nh_svd(struct vty *vty, bool use_json)
2786 {
2787 if (!is_evpn_enabled()) {
2788 if (use_json)
2789 vty_out(vty, "{}\n");
2790 return;
2791 }
2792
2793 l3vni_print_nh_table(svd_nh_table, vty, use_json);
2794 }
2795
2796 void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, bool use_json)
2797 {
2798 json_object *json = NULL;
2799 void *args[2];
2800
2801 if (use_json)
2802 json = json_object_new_object();
2803
2804 if (!is_evpn_enabled()) {
2805 vty_json(vty, json);
2806 return;
2807 }
2808
2809 args[0] = vty;
2810 args[1] = json;
2811 hash_iterate(zrouter.l3vni_table,
2812 (void (*)(struct hash_bucket *,
2813 void *))zl3vni_print_nh_hash_all_vni,
2814 args);
2815
2816 if (use_json)
2817 vty_json(vty, json);
2818 }
2819
2820 /*
2821 * Display L3 VNI information (VTY command handler).
2822 */
2823 void zebra_vxlan_print_l3vni(struct vty *vty, vni_t vni, bool use_json)
2824 {
2825 void *args[2];
2826 json_object *json = NULL;
2827 struct zebra_l3vni *zl3vni = NULL;
2828
2829 if (use_json)
2830 json = json_object_new_object();
2831
2832 if (!is_evpn_enabled()) {
2833 vty_json(vty, json);
2834 return;
2835 }
2836
2837 zl3vni = zl3vni_lookup(vni);
2838 if (!zl3vni) {
2839 if (use_json)
2840 vty_json(vty, json);
2841 else
2842 vty_out(vty, "%% VNI %u does not exist\n", vni);
2843 return;
2844 }
2845
2846 args[0] = vty;
2847 args[1] = json;
2848 zl3vni_print(zl3vni, (void *)args);
2849
2850 if (use_json)
2851 vty_json(vty, json);
2852 }
2853
2854 void zebra_vxlan_print_vrf_vni(struct vty *vty, struct zebra_vrf *zvrf,
2855 json_object *json_vrfs)
2856 {
2857 char buf[ETHER_ADDR_STRLEN];
2858 struct zebra_l3vni *zl3vni = NULL;
2859
2860 zl3vni = zl3vni_lookup(zvrf->l3vni);
2861 if (!zl3vni)
2862 return;
2863
2864 if (!json_vrfs) {
2865 vty_out(vty, "%-37s %-10u %-20s %-20s %-5s %-18s\n",
2866 zvrf_name(zvrf), zl3vni->vni,
2867 zl3vni_vxlan_if_name(zl3vni),
2868 zl3vni_svi_if_name(zl3vni), zl3vni_state2str(zl3vni),
2869 zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
2870 } else {
2871 json_object *json_vrf = NULL;
2872
2873 json_vrf = json_object_new_object();
2874 json_object_string_add(json_vrf, "vrf", zvrf_name(zvrf));
2875 json_object_int_add(json_vrf, "vni", zl3vni->vni);
2876 json_object_string_add(json_vrf, "vxlanIntf",
2877 zl3vni_vxlan_if_name(zl3vni));
2878 json_object_string_add(json_vrf, "sviIntf",
2879 zl3vni_svi_if_name(zl3vni));
2880 json_object_string_add(json_vrf, "state",
2881 zl3vni_state2str(zl3vni));
2882 json_object_string_add(
2883 json_vrf, "routerMac",
2884 zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
2885 json_object_array_add(json_vrfs, json_vrf);
2886 }
2887 }
2888
2889 /*
2890 * Display Neighbors for a VNI (VTY command handler).
2891 */
2892 void zebra_vxlan_print_neigh_vni(struct vty *vty, struct zebra_vrf *zvrf,
2893 vni_t vni, bool use_json)
2894 {
2895 struct zebra_evpn *zevpn;
2896 uint32_t num_neigh;
2897 struct neigh_walk_ctx wctx;
2898 json_object *json = NULL;
2899
2900 if (use_json)
2901 json = json_object_new_object();
2902
2903 if (!is_evpn_enabled()) {
2904 vty_json(vty, json);
2905 return;
2906 }
2907
2908 zevpn = zebra_evpn_lookup(vni);
2909 if (!zevpn) {
2910 if (use_json)
2911 vty_json(vty, json);
2912 else
2913 vty_out(vty, "%% VNI %u does not exist\n", vni);
2914 return;
2915 }
2916 num_neigh = hashcount(zevpn->neigh_table);
2917 if (!num_neigh)
2918 return;
2919
2920 /* Since we have IPv6 addresses to deal with which can vary widely in
2921 * size, we try to be a bit more elegant in display by first computing
2922 * the maximum width.
2923 */
2924 memset(&wctx, 0, sizeof(wctx));
2925 wctx.zevpn = zevpn;
2926 wctx.vty = vty;
2927 wctx.addr_width = 15;
2928 wctx.json = json;
2929 hash_iterate(zevpn->neigh_table, zebra_evpn_find_neigh_addr_width,
2930 &wctx);
2931
2932 if (!use_json) {
2933 vty_out(vty,
2934 "Number of ARPs (local and remote) known for this VNI: %u\n",
2935 num_neigh);
2936 zebra_evpn_print_neigh_hdr(vty, &wctx);
2937 } else
2938 json_object_int_add(json, "numArpNd", num_neigh);
2939
2940 hash_iterate(zevpn->neigh_table, zebra_evpn_print_neigh_hash, &wctx);
2941 if (use_json)
2942 vty_json(vty, json);
2943 }
2944
2945 /*
2946 * Display neighbors across all VNIs (VTY command handler).
2947 */
2948 void zebra_vxlan_print_neigh_all_vni(struct vty *vty, struct zebra_vrf *zvrf,
2949 bool print_dup, bool use_json)
2950 {
2951 json_object *json = NULL;
2952 void *args[3];
2953
2954 if (use_json)
2955 json = json_object_new_object();
2956
2957 if (!is_evpn_enabled()) {
2958 vty_json(vty, json);
2959 return;
2960 }
2961
2962 args[0] = vty;
2963 args[1] = json;
2964 args[2] = (void *)(ptrdiff_t)print_dup;
2965
2966 hash_iterate(zvrf->evpn_table,
2967 (void (*)(struct hash_bucket *,
2968 void *))zevpn_print_neigh_hash_all_evpn,
2969 args);
2970 if (use_json)
2971 vty_json(vty, json);
2972 }
2973
2974 /*
2975 * Display neighbors across all VNIs in detail(VTY command handler).
2976 */
2977 void zebra_vxlan_print_neigh_all_vni_detail(struct vty *vty,
2978 struct zebra_vrf *zvrf,
2979 bool print_dup, bool use_json)
2980 {
2981 json_object *json = NULL;
2982 void *args[3];
2983
2984 if (use_json)
2985 json = json_object_new_object();
2986
2987 if (!is_evpn_enabled()) {
2988 vty_json(vty, json);
2989 return;
2990 }
2991
2992 args[0] = vty;
2993 args[1] = json;
2994 args[2] = (void *)(ptrdiff_t)print_dup;
2995
2996 hash_iterate(zvrf->evpn_table,
2997 (void (*)(struct hash_bucket *,
2998 void *))zevpn_print_neigh_hash_all_evpn_detail,
2999 args);
3000 if (use_json)
3001 vty_json(vty, json);
3002 }
3003
3004 /*
3005 * Display specific neighbor for a VNI, if present (VTY command handler).
3006 */
3007 void zebra_vxlan_print_specific_neigh_vni(struct vty *vty,
3008 struct zebra_vrf *zvrf, vni_t vni,
3009 struct ipaddr *ip, bool use_json)
3010 {
3011 struct zebra_evpn *zevpn;
3012 struct zebra_neigh *n;
3013 json_object *json = NULL;
3014
3015 if (use_json)
3016 json = json_object_new_object();
3017
3018 if (!is_evpn_enabled()) {
3019 vty_json(vty, json);
3020 return;
3021 }
3022
3023 zevpn = zebra_evpn_lookup(vni);
3024 if (!zevpn) {
3025 if (use_json)
3026 vty_json(vty, json);
3027 else
3028 vty_out(vty, "%% VNI %u does not exist\n", vni);
3029 return;
3030 }
3031 n = zebra_evpn_neigh_lookup(zevpn, ip);
3032 if (!n) {
3033 if (!use_json)
3034 vty_out(vty,
3035 "%% Requested neighbor does not exist in VNI %u\n",
3036 vni);
3037 return;
3038 }
3039
3040 zebra_evpn_print_neigh(n, vty, json);
3041
3042 if (use_json)
3043 vty_json(vty, json);
3044 }
3045
3046 /*
3047 * Display neighbors for a VNI from specific VTEP (VTY command handler).
3048 * By definition, these are remote neighbors.
3049 */
3050 void zebra_vxlan_print_neigh_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
3051 vni_t vni, struct in_addr vtep_ip,
3052 bool use_json)
3053 {
3054 struct zebra_evpn *zevpn;
3055 uint32_t num_neigh;
3056 struct neigh_walk_ctx wctx;
3057 json_object *json = NULL;
3058
3059 if (use_json)
3060 json = json_object_new_object();
3061
3062 if (!is_evpn_enabled()) {
3063 vty_json(vty, json);
3064 return;
3065 }
3066
3067 zevpn = zebra_evpn_lookup(vni);
3068 if (!zevpn) {
3069 if (use_json)
3070 vty_json(vty, json);
3071 else
3072 vty_out(vty, "%% VNI %u does not exist\n", vni);
3073 return;
3074 }
3075 num_neigh = hashcount(zevpn->neigh_table);
3076 if (!num_neigh)
3077 return;
3078
3079 memset(&wctx, 0, sizeof(wctx));
3080 wctx.zevpn = zevpn;
3081 wctx.vty = vty;
3082 wctx.addr_width = 15;
3083 wctx.flags = SHOW_REMOTE_NEIGH_FROM_VTEP;
3084 wctx.r_vtep_ip = vtep_ip;
3085 wctx.json = json;
3086 hash_iterate(zevpn->neigh_table, zebra_evpn_find_neigh_addr_width,
3087 &wctx);
3088 hash_iterate(zevpn->neigh_table, zebra_evpn_print_neigh_hash, &wctx);
3089
3090 if (use_json)
3091 vty_json(vty, json);
3092 }
3093
3094 /*
3095 * Display Duplicate detected Neighbors for a VNI
3096 * (VTY command handler).
3097 */
3098 void zebra_vxlan_print_neigh_vni_dad(struct vty *vty,
3099 struct zebra_vrf *zvrf,
3100 vni_t vni,
3101 bool use_json)
3102 {
3103 struct zebra_evpn *zevpn;
3104 uint32_t num_neigh;
3105 struct neigh_walk_ctx wctx;
3106 json_object *json = NULL;
3107
3108 if (use_json)
3109 json = json_object_new_object();
3110
3111 if (!is_evpn_enabled()) {
3112 vty_json(vty, json);
3113 return;
3114 }
3115
3116 zevpn = zebra_evpn_lookup(vni);
3117 if (!zevpn) {
3118 if (use_json)
3119 vty_json(vty, json);
3120 else
3121 vty_out(vty, "%% VNI %u does not exist\n", vni);
3122 return;
3123 }
3124
3125 num_neigh = hashcount(zevpn->neigh_table);
3126 if (!num_neigh)
3127 return;
3128
3129 num_neigh = num_dup_detected_neighs(zevpn);
3130 if (!num_neigh)
3131 return;
3132
3133 /* Since we have IPv6 addresses to deal with which can vary widely in
3134 * size, we try to be a bit more elegant in display by first computing
3135 * the maximum width.
3136 */
3137 memset(&wctx, 0, sizeof(wctx));
3138 wctx.zevpn = zevpn;
3139 wctx.vty = vty;
3140 wctx.addr_width = 15;
3141 wctx.json = json;
3142 hash_iterate(zevpn->neigh_table, zebra_evpn_find_neigh_addr_width,
3143 &wctx);
3144
3145 if (!use_json) {
3146 vty_out(vty,
3147 "Number of ARPs (local and remote) known for this VNI: %u\n",
3148 num_neigh);
3149 vty_out(vty, "%*s %-6s %-8s %-17s %-30s\n",
3150 -wctx.addr_width, "IP", "Type",
3151 "State", "MAC", "Remote ES/VTEP");
3152 } else
3153 json_object_int_add(json, "numArpNd", num_neigh);
3154
3155 hash_iterate(zevpn->neigh_table, zebra_evpn_print_dad_neigh_hash,
3156 &wctx);
3157
3158 if (use_json)
3159 vty_json(vty, json);
3160 }
3161
3162 /*
3163 * Display MACs for a VNI (VTY command handler).
3164 */
3165 void zebra_vxlan_print_macs_vni(struct vty *vty, struct zebra_vrf *zvrf,
3166 vni_t vni, bool use_json, bool detail)
3167 {
3168 struct zebra_evpn *zevpn;
3169 uint32_t num_macs;
3170 struct mac_walk_ctx wctx;
3171 json_object *json = NULL;
3172 json_object *json_mac = NULL;
3173
3174 if (!is_evpn_enabled()) {
3175 if (use_json)
3176 vty_out(vty, "{}\n");
3177 return;
3178 }
3179
3180 zevpn = zebra_evpn_lookup(vni);
3181 if (!zevpn) {
3182 if (use_json)
3183 vty_out(vty, "{}\n");
3184 else
3185 vty_out(vty, "%% VNI %u does not exist\n", vni);
3186 return;
3187 }
3188 num_macs = num_valid_macs(zevpn);
3189 if (!num_macs)
3190 return;
3191
3192 if (use_json) {
3193 json = json_object_new_object();
3194 json_mac = json_object_new_object();
3195 }
3196
3197 memset(&wctx, 0, sizeof(wctx));
3198 wctx.zevpn = zevpn;
3199 wctx.vty = vty;
3200 wctx.json = json_mac;
3201
3202 if (!use_json) {
3203 if (detail) {
3204 vty_out(vty, "\nVNI %u #MACs (local and remote) %u\n\n",
3205 zevpn->vni, num_macs);
3206 } else {
3207 vty_out(vty,
3208 "Number of MACs (local and remote) known for this VNI: %u\n",
3209 num_macs);
3210 vty_out(vty,
3211 "Flags: N=sync-neighs, I=local-inactive, P=peer-active, X=peer-proxy\n");
3212 vty_out(vty, "%-17s %-6s %-5s %-30s %-5s %s\n", "MAC",
3213 "Type", "Flags", "Intf/Remote ES/VTEP", "VLAN",
3214 "Seq #'s");
3215 }
3216 } else
3217 json_object_int_add(json, "numMacs", num_macs);
3218
3219 if (detail)
3220 hash_iterate(zevpn->mac_table, zebra_evpn_print_mac_hash_detail,
3221 &wctx);
3222 else
3223 hash_iterate(zevpn->mac_table, zebra_evpn_print_mac_hash,
3224 &wctx);
3225
3226 if (use_json) {
3227 json_object_object_add(json, "macs", json_mac);
3228 vty_json(vty, json);
3229 }
3230 }
3231
3232 /*
3233 * Display MACs for all VNIs (VTY command handler).
3234 */
3235 void zebra_vxlan_print_macs_all_vni(struct vty *vty, struct zebra_vrf *zvrf,
3236 bool print_dup, bool use_json)
3237 {
3238 struct mac_walk_ctx wctx;
3239 json_object *json = NULL;
3240
3241 if (use_json)
3242 json = json_object_new_object();
3243
3244 if (!is_evpn_enabled()) {
3245 vty_json(vty, json);
3246 return;
3247 }
3248
3249 memset(&wctx, 0, sizeof(wctx));
3250 wctx.vty = vty;
3251 wctx.json = json;
3252 wctx.print_dup = print_dup;
3253 hash_iterate(zvrf->evpn_table, zevpn_print_mac_hash_all_evpn, &wctx);
3254
3255 if (use_json)
3256 vty_json(vty, json);
3257 }
3258
3259 /*
3260 * Display MACs in detail for all VNIs (VTY command handler).
3261 */
3262 void zebra_vxlan_print_macs_all_vni_detail(struct vty *vty,
3263 struct zebra_vrf *zvrf,
3264 bool print_dup, bool use_json)
3265 {
3266 struct mac_walk_ctx wctx;
3267 json_object *json = NULL;
3268
3269 if (use_json)
3270 json = json_object_new_object();
3271
3272 if (!is_evpn_enabled()) {
3273 vty_json(vty, json);
3274 return;
3275 }
3276
3277 memset(&wctx, 0, sizeof(wctx));
3278 wctx.vty = vty;
3279 wctx.json = json;
3280 wctx.print_dup = print_dup;
3281 hash_iterate(zvrf->evpn_table, zevpn_print_mac_hash_all_evpn_detail,
3282 &wctx);
3283
3284 if (use_json)
3285 vty_json(vty, json);
3286 }
3287
3288 /*
3289 * Display MACs for all VNIs (VTY command handler).
3290 */
3291 void zebra_vxlan_print_macs_all_vni_vtep(struct vty *vty,
3292 struct zebra_vrf *zvrf,
3293 struct in_addr vtep_ip, bool use_json)
3294 {
3295 struct mac_walk_ctx wctx;
3296 json_object *json = NULL;
3297
3298 if (use_json)
3299 json = json_object_new_object();
3300
3301 if (!is_evpn_enabled()) {
3302 vty_json(vty, json);
3303 return;
3304 }
3305
3306 memset(&wctx, 0, sizeof(wctx));
3307 wctx.vty = vty;
3308 wctx.flags = SHOW_REMOTE_MAC_FROM_VTEP;
3309 wctx.r_vtep_ip = vtep_ip;
3310 wctx.json = json;
3311 hash_iterate(zvrf->evpn_table, zevpn_print_mac_hash_all_evpn, &wctx);
3312
3313 if (use_json)
3314 vty_json(vty, json);
3315 }
3316
3317 /*
3318 * Display specific MAC for a VNI, if present (VTY command handler).
3319 */
3320 void zebra_vxlan_print_specific_mac_vni(struct vty *vty, struct zebra_vrf *zvrf,
3321 vni_t vni, struct ethaddr *macaddr,
3322 bool use_json)
3323 {
3324 struct zebra_evpn *zevpn;
3325 struct zebra_mac *mac;
3326 json_object *json = NULL;
3327
3328 if (use_json)
3329 json = json_object_new_object();
3330
3331 if (!is_evpn_enabled()) {
3332 vty_json(vty, json);
3333 return;
3334 }
3335
3336 zevpn = zebra_evpn_lookup(vni);
3337 if (!zevpn) {
3338 if (use_json)
3339 vty_json(vty, json);
3340 else
3341 vty_out(vty, "%% VNI %u does not exist\n", vni);
3342 return;
3343 }
3344 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
3345 if (!mac) {
3346 if (use_json)
3347 vty_json(vty, json);
3348 else
3349 vty_out(vty,
3350 "%% Requested MAC does not exist in VNI %u\n",
3351 vni);
3352 return;
3353 }
3354
3355 zebra_evpn_print_mac(mac, vty, json);
3356
3357 if (use_json)
3358 vty_json(vty, json);
3359 }
3360
3361 /* Print Duplicate MACs per VNI */
3362 void zebra_vxlan_print_macs_vni_dad(struct vty *vty,
3363 struct zebra_vrf *zvrf,
3364 vni_t vni, bool use_json)
3365 {
3366 struct zebra_evpn *zevpn;
3367 struct mac_walk_ctx wctx;
3368 uint32_t num_macs;
3369 json_object *json = NULL;
3370 json_object *json_mac = NULL;
3371
3372 if (!is_evpn_enabled())
3373 return;
3374
3375 zevpn = zebra_evpn_lookup(vni);
3376 if (!zevpn) {
3377 vty_out(vty, "%% VNI %u does not exist\n", vni);
3378 return;
3379 }
3380
3381 num_macs = num_valid_macs(zevpn);
3382 if (!num_macs)
3383 return;
3384
3385 num_macs = num_dup_detected_macs(zevpn);
3386 if (!num_macs)
3387 return;
3388
3389 if (use_json) {
3390 json = json_object_new_object();
3391 json_mac = json_object_new_object();
3392 }
3393
3394 memset(&wctx, 0, sizeof(wctx));
3395 wctx.zevpn = zevpn;
3396 wctx.vty = vty;
3397 wctx.json = json_mac;
3398
3399 if (!use_json) {
3400 vty_out(vty,
3401 "Number of MACs (local and remote) known for this VNI: %u\n",
3402 num_macs);
3403 vty_out(vty, "%-17s %-6s %-5s %-30s %-5s\n", "MAC", "Type",
3404 "Flags", "Intf/Remote ES/VTEP", "VLAN");
3405 } else
3406 json_object_int_add(json, "numMacs", num_macs);
3407
3408 hash_iterate(zevpn->mac_table, zebra_evpn_print_dad_mac_hash, &wctx);
3409
3410 if (use_json) {
3411 json_object_object_add(json, "macs", json_mac);
3412 vty_json(vty, json);
3413 }
3414
3415 }
3416
3417 int zebra_vxlan_clear_dup_detect_vni_mac(struct zebra_vrf *zvrf, vni_t vni,
3418 struct ethaddr *macaddr, char *errmsg,
3419 size_t errmsg_len)
3420 {
3421 struct zebra_evpn *zevpn;
3422 struct zebra_mac *mac;
3423 struct listnode *node = NULL;
3424 struct zebra_neigh *nbr = NULL;
3425
3426 if (!is_evpn_enabled())
3427 return 0;
3428
3429 zevpn = zebra_evpn_lookup(vni);
3430 if (!zevpn) {
3431 snprintfrr(errmsg, errmsg_len, "VNI %u does not exist", vni);
3432 return -1;
3433 }
3434
3435 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
3436 if (!mac) {
3437 snprintf(errmsg, errmsg_len,
3438 "Requested MAC does not exist in VNI %u\n", vni);
3439 return -1;
3440 }
3441
3442 if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE)) {
3443 snprintfrr(errmsg, errmsg_len,
3444 "Requested MAC is not duplicate detected\n");
3445 return -1;
3446 }
3447
3448 /* Remove all IPs as duplicate associcated with this MAC */
3449 for (ALL_LIST_ELEMENTS_RO(mac->neigh_list, node, nbr)) {
3450 /* For local neigh mark inactive so MACIP update is generated
3451 * to BGP. This is a scenario where MAC update received
3452 * and detected as duplicate which marked neigh as duplicate.
3453 * Later local neigh update did not get a chance to relay
3454 * to BGP. Similarly remote macip update, neigh needs to be
3455 * installed locally.
3456 */
3457 if (zvrf->dad_freeze &&
3458 CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE)) {
3459 if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL))
3460 ZEBRA_NEIGH_SET_INACTIVE(nbr);
3461 else if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE))
3462 zebra_evpn_rem_neigh_install(
3463 zevpn, nbr, false /*was_static*/);
3464 }
3465
3466 UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
3467 nbr->dad_count = 0;
3468 nbr->detect_start_time.tv_sec = 0;
3469 nbr->dad_dup_detect_time = 0;
3470 }
3471
3472 UNSET_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE);
3473 mac->dad_count = 0;
3474 mac->detect_start_time.tv_sec = 0;
3475 mac->detect_start_time.tv_usec = 0;
3476 mac->dad_dup_detect_time = 0;
3477 EVENT_OFF(mac->dad_mac_auto_recovery_timer);
3478
3479 /* warn-only action return */
3480 if (!zvrf->dad_freeze)
3481 return 0;
3482
3483 /* Local: Notify Peer VTEPs, Remote: Install the entry */
3484 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
3485 /* Inform to BGP */
3486 if (zebra_evpn_mac_send_add_to_client(zevpn->vni, &mac->macaddr,
3487 mac->flags, mac->loc_seq,
3488 mac->es))
3489 return 0;
3490
3491 /* Process all neighbors associated with this MAC. */
3492 zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
3493 0 /*es_change*/);
3494
3495 } else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
3496 zebra_evpn_process_neigh_on_remote_mac_add(zevpn, mac);
3497
3498 /* Install the entry. */
3499 zebra_evpn_rem_mac_install(zevpn, mac, false /* was_static */);
3500 }
3501
3502 return 0;
3503 }
3504
3505 int zebra_vxlan_clear_dup_detect_vni_ip(struct zebra_vrf *zvrf, vni_t vni,
3506 struct ipaddr *ip, char *errmsg,
3507 size_t errmsg_len)
3508 {
3509 struct zebra_evpn *zevpn;
3510 struct zebra_neigh *nbr;
3511 struct zebra_mac *mac;
3512 char buf[INET6_ADDRSTRLEN];
3513 char buf2[ETHER_ADDR_STRLEN];
3514
3515 if (!is_evpn_enabled())
3516 return 0;
3517
3518 zevpn = zebra_evpn_lookup(vni);
3519 if (!zevpn) {
3520 snprintfrr(errmsg, errmsg_len, "VNI %u does not exist\n", vni);
3521 return -1;
3522 }
3523
3524 nbr = zebra_evpn_neigh_lookup(zevpn, ip);
3525 if (!nbr) {
3526 snprintfrr(errmsg, errmsg_len,
3527 "Requested host IP does not exist in VNI %u\n", vni);
3528 return -1;
3529 }
3530
3531 ipaddr2str(&nbr->ip, buf, sizeof(buf));
3532
3533 if (!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE)) {
3534 snprintfrr(errmsg, errmsg_len,
3535 "Requested host IP %s is not duplicate detected\n",
3536 buf);
3537 return -1;
3538 }
3539
3540 mac = zebra_evpn_mac_lookup(zevpn, &nbr->emac);
3541
3542 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE)) {
3543 snprintfrr(
3544 errmsg, errmsg_len,
3545 "Requested IP's associated MAC %s is still in duplicate state\n",
3546 prefix_mac2str(&nbr->emac, buf2, sizeof(buf2)));
3547 return -1;
3548 }
3549
3550 if (IS_ZEBRA_DEBUG_VXLAN)
3551 zlog_debug("%s: clear neigh %s in dup state, flags 0x%x seq %u",
3552 __func__, buf, nbr->flags, nbr->loc_seq);
3553
3554 UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
3555 nbr->dad_count = 0;
3556 nbr->detect_start_time.tv_sec = 0;
3557 nbr->detect_start_time.tv_usec = 0;
3558 nbr->dad_dup_detect_time = 0;
3559 EVENT_OFF(nbr->dad_ip_auto_recovery_timer);
3560
3561 if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)) {
3562 zebra_evpn_neigh_send_add_to_client(zevpn->vni, ip, &nbr->emac,
3563 nbr->mac, nbr->flags,
3564 nbr->loc_seq);
3565 } else if (!!CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_REMOTE)) {
3566 zebra_evpn_rem_neigh_install(zevpn, nbr, false /*was_static*/);
3567 }
3568
3569 return 0;
3570 }
3571
3572 static void zevpn_clear_dup_mac_hash(struct hash_bucket *bucket, void *ctxt)
3573 {
3574 struct mac_walk_ctx *wctx = ctxt;
3575 struct zebra_mac *mac;
3576 struct zebra_evpn *zevpn;
3577 struct listnode *node = NULL;
3578 struct zebra_neigh *nbr = NULL;
3579
3580 mac = (struct zebra_mac *)bucket->data;
3581 if (!mac)
3582 return;
3583
3584 zevpn = wctx->zevpn;
3585
3586 if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE))
3587 return;
3588
3589 UNSET_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE);
3590 mac->dad_count = 0;
3591 mac->detect_start_time.tv_sec = 0;
3592 mac->detect_start_time.tv_usec = 0;
3593 mac->dad_dup_detect_time = 0;
3594 EVENT_OFF(mac->dad_mac_auto_recovery_timer);
3595
3596 /* Remove all IPs as duplicate associcated with this MAC */
3597 for (ALL_LIST_ELEMENTS_RO(mac->neigh_list, node, nbr)) {
3598 if (CHECK_FLAG(nbr->flags, ZEBRA_NEIGH_LOCAL)
3599 && nbr->dad_count)
3600 ZEBRA_NEIGH_SET_INACTIVE(nbr);
3601
3602 UNSET_FLAG(nbr->flags, ZEBRA_NEIGH_DUPLICATE);
3603 nbr->dad_count = 0;
3604 nbr->detect_start_time.tv_sec = 0;
3605 nbr->dad_dup_detect_time = 0;
3606 }
3607
3608 /* Local: Notify Peer VTEPs, Remote: Install the entry */
3609 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
3610 /* Inform to BGP */
3611 if (zebra_evpn_mac_send_add_to_client(zevpn->vni, &mac->macaddr,
3612 mac->flags, mac->loc_seq,
3613 mac->es))
3614 return;
3615
3616 /* Process all neighbors associated with this MAC. */
3617 zebra_evpn_process_neigh_on_local_mac_change(zevpn, mac, 0,
3618 0 /*es_change*/);
3619
3620 } else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
3621 zebra_evpn_process_neigh_on_remote_mac_add(zevpn, mac);
3622
3623 /* Install the entry. */
3624 zebra_evpn_rem_mac_install(zevpn, mac, false /* was_static */);
3625 }
3626 }
3627
3628 static void zevpn_clear_dup_detect_hash_vni_all(struct hash_bucket *bucket,
3629 void **args)
3630 {
3631 struct zebra_evpn *zevpn;
3632 struct zebra_vrf *zvrf;
3633 struct mac_walk_ctx m_wctx;
3634 struct neigh_walk_ctx n_wctx;
3635
3636 zevpn = (struct zebra_evpn *)bucket->data;
3637 if (!zevpn)
3638 return;
3639
3640 zvrf = (struct zebra_vrf *)args[0];
3641
3642 if (hashcount(zevpn->neigh_table)) {
3643 memset(&n_wctx, 0, sizeof(n_wctx));
3644 n_wctx.zevpn = zevpn;
3645 n_wctx.zvrf = zvrf;
3646 hash_iterate(zevpn->neigh_table,
3647 zebra_evpn_clear_dup_neigh_hash, &n_wctx);
3648 }
3649
3650 if (num_valid_macs(zevpn)) {
3651 memset(&m_wctx, 0, sizeof(m_wctx));
3652 m_wctx.zevpn = zevpn;
3653 m_wctx.zvrf = zvrf;
3654 hash_iterate(zevpn->mac_table, zevpn_clear_dup_mac_hash, &m_wctx);
3655 }
3656
3657 }
3658
3659 int zebra_vxlan_clear_dup_detect_vni_all(struct zebra_vrf *zvrf)
3660 {
3661 void *args[1];
3662
3663 if (!is_evpn_enabled())
3664 return 0;
3665
3666 args[0] = zvrf;
3667
3668 hash_iterate(zvrf->evpn_table,
3669 (void (*)(struct hash_bucket *, void *))
3670 zevpn_clear_dup_detect_hash_vni_all, args);
3671
3672 return 0;
3673 }
3674
3675 int zebra_vxlan_clear_dup_detect_vni(struct zebra_vrf *zvrf, vni_t vni)
3676 {
3677 struct zebra_evpn *zevpn;
3678 struct mac_walk_ctx m_wctx;
3679 struct neigh_walk_ctx n_wctx;
3680
3681 if (!is_evpn_enabled())
3682 return 0;
3683
3684 zevpn = zebra_evpn_lookup(vni);
3685 if (!zevpn) {
3686 zlog_warn("VNI %u does not exist", vni);
3687 return CMD_WARNING;
3688 }
3689
3690 if (hashcount(zevpn->neigh_table)) {
3691 memset(&n_wctx, 0, sizeof(n_wctx));
3692 n_wctx.zevpn = zevpn;
3693 n_wctx.zvrf = zvrf;
3694 hash_iterate(zevpn->neigh_table,
3695 zebra_evpn_clear_dup_neigh_hash, &n_wctx);
3696 }
3697
3698 if (num_valid_macs(zevpn)) {
3699 memset(&m_wctx, 0, sizeof(m_wctx));
3700 m_wctx.zevpn = zevpn;
3701 m_wctx.zvrf = zvrf;
3702 hash_iterate(zevpn->mac_table, zevpn_clear_dup_mac_hash, &m_wctx);
3703 }
3704
3705 return 0;
3706 }
3707
3708 /*
3709 * Display MACs for a VNI from specific VTEP (VTY command handler).
3710 */
3711 void zebra_vxlan_print_macs_vni_vtep(struct vty *vty, struct zebra_vrf *zvrf,
3712 vni_t vni, struct in_addr vtep_ip,
3713 bool use_json)
3714 {
3715 struct zebra_evpn *zevpn;
3716 uint32_t num_macs;
3717 struct mac_walk_ctx wctx;
3718 json_object *json = NULL;
3719 json_object *json_mac = NULL;
3720
3721 if (!is_evpn_enabled()) {
3722 vty_json(vty, json);
3723 return;
3724 }
3725
3726 zevpn = zebra_evpn_lookup(vni);
3727 if (!zevpn) {
3728 if (use_json)
3729 vty_out(vty, "{}\n");
3730 else
3731 vty_out(vty, "%% VNI %u does not exist\n", vni);
3732 return;
3733 }
3734 num_macs = num_valid_macs(zevpn);
3735 if (!num_macs)
3736 return;
3737
3738 if (use_json) {
3739 json = json_object_new_object();
3740 json_mac = json_object_new_object();
3741 }
3742
3743 memset(&wctx, 0, sizeof(wctx));
3744 wctx.zevpn = zevpn;
3745 wctx.vty = vty;
3746 wctx.flags = SHOW_REMOTE_MAC_FROM_VTEP;
3747 wctx.r_vtep_ip = vtep_ip;
3748 wctx.json = json_mac;
3749 hash_iterate(zevpn->mac_table, zebra_evpn_print_mac_hash, &wctx);
3750
3751 if (use_json) {
3752 json_object_int_add(json, "numMacs", wctx.count);
3753 if (wctx.count)
3754 json_object_object_add(json, "macs", json_mac);
3755 vty_json(vty, json);
3756 }
3757 }
3758
3759
3760 /*
3761 * Display VNI information (VTY command handler).
3762 *
3763 * use_json flag indicates that output should be in JSON format.
3764 * json_array is non NULL when JSON output needs to be aggregated (by the
3765 * caller) and then printed, otherwise, JSON evpn vni info is printed
3766 * right away.
3767 */
3768 void zebra_vxlan_print_vni(struct vty *vty, struct zebra_vrf *zvrf, vni_t vni,
3769 bool use_json, json_object *json_array)
3770 {
3771 json_object *json = NULL;
3772 void *args[2];
3773 struct zebra_l3vni *zl3vni = NULL;
3774 struct zebra_evpn *zevpn = NULL;
3775
3776 if (use_json)
3777 json = json_object_new_object();
3778
3779 if (!is_evpn_enabled()) {
3780 vty_json(vty, json);
3781 return;
3782 }
3783
3784 args[0] = vty;
3785 args[1] = json;
3786
3787 zl3vni = zl3vni_lookup(vni);
3788 if (zl3vni) {
3789 zl3vni_print(zl3vni, (void *)args);
3790 } else {
3791 zevpn = zebra_evpn_lookup(vni);
3792 if (zevpn)
3793 zebra_evpn_print(zevpn, (void *)args);
3794 else if (!json)
3795 vty_out(vty, "%% VNI %u does not exist\n", vni);
3796 }
3797
3798 if (use_json) {
3799 /*
3800 * Each "json" object contains info about 1 VNI.
3801 * When "json_array" is non-null, we aggreggate the json output
3802 * into json_array and print it as a JSON array.
3803 */
3804 if (json_array)
3805 json_object_array_add(json_array, json);
3806 else
3807 vty_json(vty, json);
3808 }
3809 }
3810
3811 /* Display all global details for EVPN */
3812 void zebra_vxlan_print_evpn(struct vty *vty, bool uj)
3813 {
3814 int num_l2vnis = 0;
3815 int num_l3vnis = 0;
3816 int num_vnis = 0;
3817 json_object *json = NULL;
3818 struct zebra_vrf *zvrf = NULL;
3819
3820 if (uj)
3821 json = json_object_new_object();
3822
3823 if (!is_evpn_enabled()) {
3824 vty_json(vty, json);
3825 return;
3826 }
3827
3828 zvrf = zebra_vrf_get_evpn();
3829
3830 num_l3vnis = hashcount(zrouter.l3vni_table);
3831 num_l2vnis = hashcount(zvrf->evpn_table);
3832 num_vnis = num_l2vnis + num_l3vnis;
3833
3834 if (uj) {
3835 json_object_string_add(json, "advertiseGatewayMacip",
3836 zvrf->advertise_gw_macip ? "Yes" : "No");
3837 json_object_string_add(json, "advertiseSviMacip",
3838 zvrf->advertise_svi_macip ? "Yes"
3839 : "No");
3840 json_object_string_add(json, "advertiseSviMac",
3841 zebra_evpn_mh_do_adv_svi_mac() ? "Yes"
3842 : "No");
3843 json_object_int_add(json, "numVnis", num_vnis);
3844 json_object_int_add(json, "numL2Vnis", num_l2vnis);
3845 json_object_int_add(json, "numL3Vnis", num_l3vnis);
3846 if (zebra_evpn_do_dup_addr_detect(zvrf))
3847 json_object_boolean_true_add(json,
3848 "isDuplicateAddrDetection");
3849 else
3850 json_object_boolean_false_add(json,
3851 "isDuplicateAddrDetection");
3852 json_object_int_add(json, "maxMoves", zvrf->dad_max_moves);
3853 json_object_int_add(json, "detectionTime", zvrf->dad_time);
3854 json_object_int_add(json, "detectionFreezeTime",
3855 zvrf->dad_freeze_time);
3856 json_object_boolean_add(json, "isDetectionFreeze",
3857 zvrf->dad_freeze);
3858 zebra_evpn_mh_json(json);
3859 } else {
3860 vty_out(vty, "L2 VNIs: %u\n", num_l2vnis);
3861 vty_out(vty, "L3 VNIs: %u\n", num_l3vnis);
3862 vty_out(vty, "Advertise gateway mac-ip: %s\n",
3863 zvrf->advertise_gw_macip ? "Yes" : "No");
3864 vty_out(vty, "Advertise svi mac-ip: %s\n",
3865 zvrf->advertise_svi_macip ? "Yes" : "No");
3866 vty_out(vty, "Advertise svi mac: %s\n",
3867 zebra_evpn_mh_do_adv_svi_mac() ? "Yes" : "No");
3868 vty_out(vty, "Duplicate address detection: %s\n",
3869 zebra_evpn_do_dup_addr_detect(zvrf) ? "Enable"
3870 : "Disable");
3871 vty_out(vty, " Detection max-moves %u, time %d\n",
3872 zvrf->dad_max_moves, zvrf->dad_time);
3873 if (zvrf->dad_freeze) {
3874 if (zvrf->dad_freeze_time)
3875 vty_out(vty, " Detection freeze %u\n",
3876 zvrf->dad_freeze_time);
3877 else
3878 vty_out(vty, " Detection freeze %s\n",
3879 "permanent");
3880 }
3881 zebra_evpn_mh_print(vty);
3882 }
3883
3884 if (uj)
3885 vty_json(vty, json);
3886 }
3887
3888 /*
3889 * Display VNI hash table (VTY command handler).
3890 */
3891 void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf,
3892 bool use_json)
3893 {
3894 json_object *json = NULL;
3895 void *args[2];
3896
3897 if (use_json)
3898 json = json_object_new_object();
3899
3900 if (!is_evpn_enabled()) {
3901 vty_json(vty, json);
3902 return;
3903 }
3904
3905 if (!use_json)
3906 vty_out(vty, "%-10s %-4s %-21s %-8s %-8s %-15s %-37s\n", "VNI",
3907 "Type", "VxLAN IF", "# MACs", "# ARPs",
3908 "# Remote VTEPs", "Tenant VRF");
3909
3910 args[0] = vty;
3911 args[1] = json;
3912
3913 /* Display all L2-VNIs */
3914 hash_iterate(
3915 zvrf->evpn_table,
3916 (void (*)(struct hash_bucket *, void *))zebra_evpn_print_hash,
3917 args);
3918
3919 /* Display all L3-VNIs */
3920 hash_iterate(zrouter.l3vni_table,
3921 (void (*)(struct hash_bucket *, void *))zl3vni_print_hash,
3922 args);
3923
3924 if (use_json)
3925 vty_json(vty, json);
3926 }
3927
3928 void zebra_vxlan_dup_addr_detection(ZAPI_HANDLER_ARGS)
3929 {
3930 struct stream *s;
3931 int time = 0;
3932 uint32_t max_moves = 0;
3933 uint32_t freeze_time = 0;
3934 bool dup_addr_detect = false;
3935 bool freeze = false;
3936 bool old_addr_detect;
3937
3938 s = msg;
3939 STREAM_GETL(s, dup_addr_detect);
3940 STREAM_GETL(s, time);
3941 STREAM_GETL(s, max_moves);
3942 STREAM_GETL(s, freeze);
3943 STREAM_GETL(s, freeze_time);
3944
3945 old_addr_detect = zebra_evpn_do_dup_addr_detect(zvrf);
3946 zvrf->dup_addr_detect = dup_addr_detect;
3947 dup_addr_detect = zebra_evpn_do_dup_addr_detect(zvrf);
3948
3949 /* DAD previous state was enabled, and new state is disable,
3950 * clear all duplicate detected addresses.
3951 */
3952 if (old_addr_detect && !dup_addr_detect)
3953 zebra_vxlan_clear_dup_detect_vni_all(zvrf);
3954
3955 zvrf->dad_time = time;
3956 zvrf->dad_max_moves = max_moves;
3957 zvrf->dad_freeze = freeze;
3958 zvrf->dad_freeze_time = freeze_time;
3959
3960 if (IS_ZEBRA_DEBUG_VXLAN)
3961 zlog_debug(
3962 "VRF %s duplicate detect %s max_moves %u timeout %u freeze %s freeze_time %u",
3963 vrf_id_to_name(zvrf->vrf->vrf_id),
3964 dup_addr_detect ? "enable" : "disable",
3965 zvrf->dad_max_moves, zvrf->dad_time,
3966 zvrf->dad_freeze ? "enable" : "disable",
3967 zvrf->dad_freeze_time);
3968
3969 stream_failure:
3970 return;
3971 }
3972
3973 /*
3974 * Display VNI hash table in detail(VTY command handler).
3975 */
3976 void zebra_vxlan_print_vnis_detail(struct vty *vty, struct zebra_vrf *zvrf,
3977 bool use_json)
3978 {
3979 json_object *json_array = NULL;
3980 struct zebra_ns *zns = NULL;
3981 struct zebra_evpn_show zes;
3982
3983 if (!is_evpn_enabled()) {
3984 if (use_json)
3985 vty_out(vty, "{}\n");
3986 return;
3987 }
3988
3989 zns = zebra_ns_lookup(NS_DEFAULT);
3990 if (!zns)
3991 return;
3992
3993 if (use_json)
3994 json_array = json_object_new_array();
3995
3996 zes.vty = vty;
3997 zes.json = json_array;
3998 zes.zvrf = zvrf;
3999 zes.use_json = use_json;
4000
4001 /* Display all L2-VNIs */
4002 hash_iterate(zvrf->evpn_table,
4003 (void (*)(struct hash_bucket *,
4004 void *))zebra_evpn_print_hash_detail,
4005 &zes);
4006
4007 /* Display all L3-VNIs */
4008 hash_iterate(zrouter.l3vni_table,
4009 (void (*)(struct hash_bucket *,
4010 void *))zl3vni_print_hash_detail,
4011 &zes);
4012
4013 if (use_json)
4014 vty_json(vty, json_array);
4015 }
4016
4017 /*
4018 * Handle neighbor delete notification from the kernel (on a VLAN device
4019 * / L3 interface). This may result in either the neighbor getting deleted
4020 * from our database or being re-added to the kernel (if it is a valid
4021 * remote neighbor).
4022 */
4023 int zebra_vxlan_handle_kernel_neigh_del(struct interface *ifp,
4024 struct interface *link_if,
4025 struct ipaddr *ip)
4026 {
4027 struct zebra_evpn *zevpn = NULL;
4028 struct zebra_l3vni *zl3vni = NULL;
4029
4030 /* check if this is a remote neigh entry corresponding to remote
4031 * next-hop
4032 */
4033 zl3vni = zl3vni_from_svi(ifp, link_if);
4034 if (zl3vni)
4035 return zl3vni_local_nh_del(zl3vni, ip);
4036
4037 /* We are only interested in neighbors on an SVI that resides on top
4038 * of a VxLAN bridge.
4039 */
4040 zevpn = zebra_evpn_from_svi(ifp, link_if);
4041 if (!zevpn) {
4042 if (IS_ZEBRA_DEBUG_VXLAN)
4043 zlog_debug(
4044 "%s: Del neighbor %pIA EVPN is not present for interface %s",
4045 __func__, ip, ifp->name);
4046 return 0;
4047 }
4048
4049 if (!zevpn->vxlan_if) {
4050 zlog_debug(
4051 "VNI %u hash %p doesn't have intf upon local neighbor DEL",
4052 zevpn->vni, zevpn);
4053 return -1;
4054 }
4055
4056 if (IS_ZEBRA_DEBUG_VXLAN)
4057 zlog_debug("Del neighbor %pIA intf %s(%u) -> L2-VNI %u",
4058 ip, ifp->name, ifp->ifindex, zevpn->vni);
4059
4060 return zebra_evpn_neigh_del_ip(zevpn, ip);
4061 }
4062
4063 /*
4064 * Handle neighbor add or update notification from the kernel (on a VLAN
4065 * device / L3 interface). This is typically for a local neighbor but can
4066 * also be for a remote neighbor (e.g., ageout notification). It could
4067 * also be a "move" scenario.
4068 */
4069 int zebra_vxlan_handle_kernel_neigh_update(struct interface *ifp,
4070 struct interface *link_if,
4071 struct ipaddr *ip,
4072 struct ethaddr *macaddr,
4073 uint16_t state,
4074 bool is_ext,
4075 bool is_router,
4076 bool local_inactive, bool dp_static)
4077 {
4078 struct zebra_evpn *zevpn = NULL;
4079 struct zebra_l3vni *zl3vni = NULL;
4080
4081 /* check if this is a remote neigh entry corresponding to remote
4082 * next-hop
4083 */
4084 zl3vni = zl3vni_from_svi(ifp, link_if);
4085 if (zl3vni)
4086 return zl3vni_local_nh_add_update(zl3vni, ip, state);
4087
4088 /* We are only interested in neighbors on an SVI that resides on top
4089 * of a VxLAN bridge.
4090 */
4091 zevpn = zebra_evpn_from_svi(ifp, link_if);
4092 if (!zevpn)
4093 return 0;
4094
4095 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
4096 zlog_debug(
4097 "Add/Update neighbor %pIA MAC %pEA intf %s(%u) state 0x%x %s%s%s%s-> L2-VNI %u",
4098 ip, macaddr, ifp->name,
4099 ifp->ifindex, state, is_ext ? "ext-learned " : "",
4100 is_router ? "router " : "",
4101 local_inactive ? "local_inactive " : "",
4102 dp_static ? "peer_sync " : "", zevpn->vni);
4103
4104 /* Is this about a local neighbor or a remote one? */
4105 if (!is_ext)
4106 return zebra_evpn_local_neigh_update(zevpn, ifp, ip, macaddr,
4107 is_router, local_inactive,
4108 dp_static);
4109
4110 return zebra_evpn_remote_neigh_update(zevpn, ifp, ip, macaddr, state);
4111 }
4112
4113 static int32_t
4114 zebra_vxlan_remote_macip_helper(bool add, struct stream *s, vni_t *vni,
4115 struct ethaddr *macaddr, uint16_t *ipa_len,
4116 struct ipaddr *ip, struct in_addr *vtep_ip,
4117 uint8_t *flags, uint32_t *seq, esi_t *esi)
4118 {
4119 uint16_t l = 0;
4120
4121 /*
4122 * Obtain each remote MACIP and process.
4123 * Message contains VNI, followed by MAC followed by IP (if any)
4124 * followed by remote VTEP IP.
4125 */
4126 memset(ip, 0, sizeof(*ip));
4127 STREAM_GETL(s, *vni);
4128 STREAM_GET(macaddr->octet, s, ETH_ALEN);
4129 STREAM_GETW(s, *ipa_len);
4130
4131 if (*ipa_len) {
4132 if (*ipa_len == IPV4_MAX_BYTELEN)
4133 ip->ipa_type = IPADDR_V4;
4134 else if (*ipa_len == IPV6_MAX_BYTELEN)
4135 ip->ipa_type = IPADDR_V6;
4136 else {
4137 if (IS_ZEBRA_DEBUG_VXLAN)
4138 zlog_debug(
4139 "ipa_len *must* be %d or %d bytes in length not %d",
4140 IPV4_MAX_BYTELEN, IPV6_MAX_BYTELEN,
4141 *ipa_len);
4142 goto stream_failure;
4143 }
4144
4145 STREAM_GET(&ip->ip.addr, s, *ipa_len);
4146 }
4147 l += 4 + ETH_ALEN + 4 + *ipa_len;
4148 STREAM_GET(&vtep_ip->s_addr, s, IPV4_MAX_BYTELEN);
4149 l += IPV4_MAX_BYTELEN;
4150
4151 if (add) {
4152 STREAM_GETC(s, *flags);
4153 STREAM_GETL(s, *seq);
4154 l += 5;
4155 STREAM_GET(esi, s, sizeof(esi_t));
4156 l += sizeof(esi_t);
4157 }
4158
4159 return l;
4160
4161 stream_failure:
4162 return -1;
4163 }
4164
4165 /*
4166 * Handle message from client to delete a remote MACIP for a VNI.
4167 */
4168 void zebra_vxlan_remote_macip_del(ZAPI_HANDLER_ARGS)
4169 {
4170 struct stream *s;
4171 vni_t vni;
4172 struct ethaddr macaddr;
4173 struct ipaddr ip;
4174 struct in_addr vtep_ip;
4175 uint16_t l = 0, ipa_len;
4176 char buf1[INET6_ADDRSTRLEN];
4177
4178 s = msg;
4179
4180 while (l < hdr->length) {
4181 int res_length = zebra_vxlan_remote_macip_helper(
4182 false, s, &vni, &macaddr, &ipa_len, &ip, &vtep_ip, NULL,
4183 NULL, NULL);
4184
4185 if (res_length == -1)
4186 goto stream_failure;
4187
4188 l += res_length;
4189 if (IS_ZEBRA_DEBUG_VXLAN)
4190 zlog_debug(
4191 "Recv MACIP DEL VNI %u MAC %pEA%s%s Remote VTEP %pI4 from %s",
4192 vni, &macaddr,
4193 ipa_len ? " IP " : "",
4194 ipa_len ?
4195 ipaddr2str(&ip, buf1, sizeof(buf1)) : "",
4196 &vtep_ip, zebra_route_string(client->proto));
4197
4198 /* Enqueue to workqueue for processing */
4199 zebra_rib_queue_evpn_rem_macip_del(vni, &macaddr, &ip, vtep_ip);
4200 }
4201
4202 stream_failure:
4203 return;
4204 }
4205
4206 /*
4207 * Handle message from client to add a remote MACIP for a VNI. This
4208 * could be just the add of a MAC address or the add of a neighbor
4209 * (IP+MAC).
4210 */
4211 void zebra_vxlan_remote_macip_add(ZAPI_HANDLER_ARGS)
4212 {
4213 struct stream *s;
4214 vni_t vni;
4215 struct ethaddr macaddr;
4216 struct ipaddr ip;
4217 struct in_addr vtep_ip;
4218 uint16_t l = 0, ipa_len;
4219 uint8_t flags = 0;
4220 uint32_t seq;
4221 char buf1[INET6_ADDRSTRLEN];
4222 esi_t esi;
4223 char esi_buf[ESI_STR_LEN];
4224
4225 if (!EVPN_ENABLED(zvrf)) {
4226 zlog_debug("EVPN not enabled, ignoring remote MACIP ADD");
4227 return;
4228 }
4229
4230 s = msg;
4231
4232 while (l < hdr->length) {
4233
4234 int res_length = zebra_vxlan_remote_macip_helper(
4235 true, s, &vni, &macaddr, &ipa_len, &ip, &vtep_ip,
4236 &flags, &seq, &esi);
4237
4238 if (res_length == -1)
4239 goto stream_failure;
4240
4241 l += res_length;
4242 if (IS_ZEBRA_DEBUG_VXLAN) {
4243 if (memcmp(&esi, zero_esi, sizeof(esi_t)))
4244 esi_to_str(&esi, esi_buf, sizeof(esi_buf));
4245 else
4246 strlcpy(esi_buf, "-", ESI_STR_LEN);
4247 zlog_debug(
4248 "Recv %sMACIP ADD VNI %u MAC %pEA%s%s flags 0x%x seq %u VTEP %pI4 ESI %s from %s",
4249 (flags & ZEBRA_MACIP_TYPE_SYNC_PATH) ?
4250 "sync-" : "",
4251 vni, &macaddr,
4252 ipa_len ? " IP " : "",
4253 ipa_len ?
4254 ipaddr2str(&ip, buf1, sizeof(buf1)) : "",
4255 flags, seq, &vtep_ip, esi_buf,
4256 zebra_route_string(client->proto));
4257 }
4258
4259 /* Enqueue to workqueue for processing */
4260 zebra_rib_queue_evpn_rem_macip_add(vni, &macaddr, &ip, flags,
4261 seq, vtep_ip, &esi);
4262 }
4263
4264 stream_failure:
4265 return;
4266 }
4267
4268 /*
4269 * Handle remote vtep delete by kernel; re-add the vtep if we have it
4270 */
4271 int zebra_vxlan_check_readd_vtep(struct interface *ifp, vni_t vni,
4272 struct in_addr vtep_ip)
4273 {
4274 struct zebra_if *zif;
4275 struct zebra_vrf *zvrf = NULL;
4276 struct zebra_evpn *zevpn = NULL;
4277 struct zebra_vtep *zvtep = NULL;
4278 struct zebra_vxlan_vni *vnip;
4279
4280 zif = ifp->info;
4281 assert(zif);
4282
4283 /* If EVPN is not enabled, nothing to do. */
4284 if (!is_evpn_enabled())
4285 return 0;
4286
4287 /* Locate VRF corresponding to interface. */
4288 zvrf = ifp->vrf->info;
4289 if (!zvrf)
4290 return -1;
4291
4292 vnip = zebra_vxlan_if_vni_find(zif, vni);
4293 if (!vnip)
4294 return 0;
4295
4296 /* Locate hash entry; it is expected to exist. */
4297 zevpn = zebra_evpn_lookup(vni);
4298 if (!zevpn)
4299 return 0;
4300
4301 /* If the remote vtep entry doesn't exists nothing to do */
4302 zvtep = zebra_evpn_vtep_find(zevpn, &vtep_ip);
4303 if (!zvtep)
4304 return 0;
4305
4306 if (IS_ZEBRA_DEBUG_VXLAN)
4307 zlog_debug(
4308 "Del MAC for remote VTEP %pI4 intf %s(%u) VNI %u - readd",
4309 &vtep_ip, ifp->name, ifp->ifindex, vni);
4310
4311 zebra_evpn_vtep_install(zevpn, zvtep);
4312 return 0;
4313 }
4314
4315 /*
4316 * Handle notification of MAC add/update over VxLAN. If the kernel is notifying
4317 * us, this must involve a multihoming scenario. Treat this as implicit delete
4318 * of any prior local MAC.
4319 */
4320 static int zebra_vxlan_check_del_local_mac(struct interface *ifp,
4321 struct interface *br_if,
4322 struct ethaddr *macaddr,
4323 vlanid_t vid, vni_t vni)
4324 {
4325 struct zebra_if *zif;
4326 struct zebra_evpn *zevpn;
4327 struct zebra_mac *mac;
4328
4329 zif = ifp->info;
4330 assert(zif);
4331
4332 /* Check if EVPN is enabled. */
4333 if (!is_evpn_enabled())
4334 return 0;
4335
4336 /* Locate hash entry; it is expected to exist. */
4337 zevpn = zebra_evpn_lookup(vni);
4338 if (!zevpn)
4339 return 0;
4340
4341 /* If entry doesn't exist, nothing to do. */
4342 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
4343 if (!mac)
4344 return 0;
4345
4346 /* Is it a local entry? */
4347 if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL))
4348 return 0;
4349
4350 if (IS_ZEBRA_DEBUG_VXLAN)
4351 zlog_debug(
4352 "Add/update remote MAC %pEA intf %s(%u) VNI %u flags 0x%x - del local",
4353 macaddr, ifp->name, ifp->ifindex, vni, mac->flags);
4354
4355 /* Remove MAC from BGP. */
4356 zebra_evpn_mac_send_del_to_client(zevpn->vni, macaddr, mac->flags,
4357 false /* force */);
4358
4359 /*
4360 * If there are no neigh associated with the mac delete the mac
4361 * else mark it as AUTO for forward reference
4362 */
4363 if (!listcount(mac->neigh_list)) {
4364 zebra_evpn_mac_del(zevpn, mac);
4365 } else {
4366 zebra_evpn_mac_clear_fwd_info(mac);
4367 UNSET_FLAG(mac->flags, ZEBRA_MAC_ALL_LOCAL_FLAGS);
4368 UNSET_FLAG(mac->flags, ZEBRA_MAC_STICKY);
4369 SET_FLAG(mac->flags, ZEBRA_MAC_AUTO);
4370 }
4371
4372 return 0;
4373 }
4374
4375 /* MAC notification from the dataplane with a network dest port -
4376 * 1. This can be a local MAC on a down ES (if fast-failover is not possible
4377 * 2. Or it can be a remote MAC
4378 */
4379 int zebra_vxlan_dp_network_mac_add(struct interface *ifp,
4380 struct interface *br_if,
4381 struct ethaddr *macaddr, vlanid_t vid,
4382 vni_t vni, uint32_t nhg_id, bool sticky,
4383 bool dp_static)
4384 {
4385 struct zebra_evpn_es *es;
4386 struct interface *acc_ifp;
4387
4388 /* If netlink message is with vid, it will have no nexthop.
4389 * So skip it.
4390 */
4391 if (vid) {
4392 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
4393 zlog_debug("dpAdd MAC %pEA VID %u - ignore as no nhid",
4394 macaddr, vid);
4395 return 0;
4396 }
4397
4398 /* Get vxlan's vid for netlink message has no it. */
4399 vid = ((struct zebra_if *)ifp->info)
4400 ->l2info.vxl.vni_info.vni.access_vlan;
4401
4402 /* if remote mac delete the local entry */
4403 if (!nhg_id || !zebra_evpn_nhg_is_local_es(nhg_id, &es)
4404 || !zebra_evpn_es_local_mac_via_network_port(es)) {
4405 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
4406 zlog_debug("dpAdd remote MAC %pEA VID %u", macaddr,
4407 vid);
4408 return zebra_vxlan_check_del_local_mac(ifp, br_if, macaddr, vid,
4409 vni);
4410 }
4411
4412 /* If local MAC on a down local ES translate the network-mac-add
4413 * to a local-active-mac-add
4414 */
4415 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
4416 zlog_debug("dpAdd local-nw-MAC %pEA VID %u", macaddr, vid);
4417 acc_ifp = es->zif->ifp;
4418 return zebra_vxlan_local_mac_add_update(
4419 acc_ifp, br_if, macaddr, vid, sticky,
4420 false /* local_inactive */, dp_static);
4421 }
4422
4423 /*
4424 * Handle network MAC delete by kernel -
4425 * 1. readd the remote MAC if we have it
4426 * 2. local MAC with does ES may also need to be re-installed
4427 */
4428 int zebra_vxlan_dp_network_mac_del(struct interface *ifp,
4429 struct interface *br_if,
4430 struct ethaddr *macaddr, vlanid_t vid,
4431 vni_t vni)
4432 {
4433 struct zebra_if *zif = NULL;
4434 struct zebra_evpn *zevpn = NULL;
4435 struct zebra_l3vni *zl3vni = NULL;
4436 struct zebra_mac *mac = NULL;
4437
4438 zif = ifp->info;
4439 assert(zif);
4440
4441 /* Check if EVPN is enabled. */
4442 if (!is_evpn_enabled())
4443 return 0;
4444
4445 /* check if this is a remote RMAC and readd simillar to remote macs */
4446 zl3vni = zl3vni_lookup(vni);
4447 if (zl3vni)
4448 return zebra_vxlan_readd_remote_rmac(zl3vni, macaddr);
4449
4450 /* Locate hash entry; it is expected to exist. */
4451 zevpn = zebra_evpn_lookup(vni);
4452 if (!zevpn)
4453 return 0;
4454
4455 /* If entry doesn't exist, nothing to do. */
4456 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
4457 if (!mac)
4458 return 0;
4459
4460 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
4461 /* If remote entry simply re-install */
4462 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
4463 zlog_debug(
4464 "dpDel remote MAC %pEA intf %s(%u) VNI %u - readd",
4465 macaddr, ifp->name, ifp->ifindex, vni);
4466 zebra_evpn_rem_mac_install(zevpn, mac, false /* was_static */);
4467 } else if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL) && mac->es
4468 && zebra_evpn_es_local_mac_via_network_port(mac->es)) {
4469 /* If local entry via nw-port call local-del which will
4470 * re-install entry in the dataplane is needed
4471 */
4472 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
4473 zlog_debug("dpDel local-nw-MAC %pEA VNI %u", macaddr,
4474 vni);
4475
4476 zebra_evpn_del_local_mac(zevpn, mac, false);
4477 }
4478
4479 return 0;
4480 }
4481
4482 /*
4483 * Handle local MAC delete (on a port or VLAN corresponding to this VNI).
4484 */
4485 int zebra_vxlan_local_mac_del(struct interface *ifp, struct interface *br_if,
4486 struct ethaddr *macaddr, vlanid_t vid)
4487 {
4488 struct zebra_evpn *zevpn;
4489 struct zebra_mac *mac;
4490
4491 /* We are interested in MACs only on ports or (port, VLAN) that
4492 * map to a VNI.
4493 */
4494 zevpn = zebra_evpn_map_vlan(ifp, br_if, vid);
4495 if (!zevpn)
4496 return 0;
4497 if (!zevpn->vxlan_if) {
4498 zlog_debug(
4499 "VNI %u hash %p doesn't have intf upon local MAC DEL",
4500 zevpn->vni, zevpn);
4501 return -1;
4502 }
4503
4504 /* If entry doesn't exist, nothing to do. */
4505 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
4506 if (!mac)
4507 return 0;
4508
4509 /* Is it a local entry? */
4510 if (!CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL))
4511 return 0;
4512
4513 return zebra_evpn_del_local_mac(zevpn, mac, false);
4514 }
4515
4516 /*
4517 * Handle local MAC add (on a port or VLAN corresponding to this VNI).
4518 */
4519 int zebra_vxlan_local_mac_add_update(struct interface *ifp,
4520 struct interface *br_if,
4521 struct ethaddr *macaddr, vlanid_t vid,
4522 bool sticky, bool local_inactive,
4523 bool dp_static)
4524 {
4525 struct zebra_evpn *zevpn;
4526 struct zebra_vrf *zvrf;
4527
4528 assert(ifp);
4529
4530 /* We are interested in MACs only on ports or (port, VLAN) that
4531 * map to an EVPN.
4532 */
4533 zevpn = zebra_evpn_map_vlan(ifp, br_if, vid);
4534 if (!zevpn) {
4535 if (IS_ZEBRA_DEBUG_VXLAN)
4536 zlog_debug(
4537 " Add/Update %sMAC %pEA intf %s(%u) VID %u, could not find EVPN",
4538 sticky ? "sticky " : "", macaddr,
4539 ifp->name, ifp->ifindex, vid);
4540 return 0;
4541 }
4542
4543 if (!zevpn->vxlan_if) {
4544 if (IS_ZEBRA_DEBUG_VXLAN)
4545 zlog_debug(
4546 " VNI %u hash %p doesn't have intf upon local MAC ADD",
4547 zevpn->vni, zevpn);
4548 return -1;
4549 }
4550
4551 zvrf = zebra_vrf_get_evpn();
4552 return zebra_evpn_add_update_local_mac(zvrf, zevpn, ifp, macaddr, vid,
4553 sticky, local_inactive,
4554 dp_static, NULL);
4555 }
4556
4557 /*
4558 * Handle message from client to delete a remote VTEP for an EVPN.
4559 */
4560 void zebra_vxlan_remote_vtep_del_zapi(ZAPI_HANDLER_ARGS)
4561 {
4562 struct stream *s;
4563 unsigned short l = 0;
4564 vni_t vni;
4565 struct in_addr vtep_ip;
4566
4567 if (!is_evpn_enabled()) {
4568 zlog_debug(
4569 "%s: EVPN is not enabled yet we have received a VTEP DEL msg",
4570 __func__);
4571 return;
4572 }
4573
4574 if (!EVPN_ENABLED(zvrf)) {
4575 zlog_debug("Recv VTEP DEL zapi for non-EVPN VRF %u",
4576 zvrf_id(zvrf));
4577 return;
4578 }
4579
4580 s = msg;
4581
4582 while (l < hdr->length) {
4583 int flood_control __attribute__((unused));
4584
4585 /* Obtain each remote VTEP and process. */
4586 STREAM_GETL(s, vni);
4587 l += 4;
4588 STREAM_GET(&vtep_ip.s_addr, s, IPV4_MAX_BYTELEN);
4589 l += IPV4_MAX_BYTELEN;
4590
4591 /* Flood control is intentionally ignored right now */
4592 STREAM_GETL(s, flood_control);
4593 l += 4;
4594
4595 if (IS_ZEBRA_DEBUG_VXLAN)
4596 zlog_debug("Recv VTEP DEL %pI4 VNI %u from %s",
4597 &vtep_ip, vni,
4598 zebra_route_string(client->proto));
4599
4600 /* Enqueue for processing */
4601 zebra_rib_queue_evpn_rem_vtep_del(zvrf_id(zvrf), vni, vtep_ip);
4602 }
4603
4604 stream_failure:
4605 return;
4606 }
4607
4608 /*
4609 * Handle message from client to delete a remote VTEP for an EVPN.
4610 */
4611 void zebra_vxlan_remote_vtep_del(vrf_id_t vrf_id, vni_t vni,
4612 struct in_addr vtep_ip)
4613 {
4614 struct zebra_evpn *zevpn;
4615 struct zebra_vtep *zvtep;
4616 struct interface *ifp;
4617 struct zebra_if *zif;
4618 struct zebra_vrf *zvrf;
4619
4620 if (!is_evpn_enabled()) {
4621 zlog_debug("%s: Can't process vtep del: EVPN is not enabled",
4622 __func__);
4623 return;
4624 }
4625
4626 zvrf = zebra_vrf_lookup_by_id(vrf_id);
4627 if (!zvrf)
4628 return;
4629
4630 if (!EVPN_ENABLED(zvrf)) {
4631 zlog_debug("Can't process VTEP DEL for non-EVPN VRF %u",
4632 zvrf_id(zvrf));
4633 return;
4634 }
4635
4636 /* Locate VNI hash entry - expected to exist. */
4637 zevpn = zebra_evpn_lookup(vni);
4638 if (!zevpn) {
4639 if (IS_ZEBRA_DEBUG_VXLAN)
4640 zlog_debug(
4641 "Failed to locate VNI hash for remote VTEP DEL, VNI %u",
4642 vni);
4643 return;
4644 }
4645
4646 ifp = zevpn->vxlan_if;
4647 if (!ifp) {
4648 zlog_debug(
4649 "VNI %u hash %p doesn't have intf upon remote VTEP DEL",
4650 zevpn->vni, zevpn);
4651 return;
4652 }
4653 zif = ifp->info;
4654
4655 /* If down or not mapped to a bridge, we're done. */
4656 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
4657 return;
4658
4659 /* If the remote VTEP does not exist, there's nothing more to
4660 * do.
4661 * Otherwise, uninstall any remote MACs pointing to this VTEP
4662 * and then, the VTEP entry itself and remove it.
4663 */
4664 zvtep = zebra_evpn_vtep_find(zevpn, &vtep_ip);
4665 if (!zvtep)
4666 return;
4667
4668 zebra_evpn_vtep_uninstall(zevpn, &vtep_ip);
4669 zebra_evpn_vtep_del(zevpn, zvtep);
4670 }
4671
4672 /*
4673 * Handle message from client to add a remote VTEP for an EVPN.
4674 */
4675 void zebra_vxlan_remote_vtep_add(vrf_id_t vrf_id, vni_t vni,
4676 struct in_addr vtep_ip, int flood_control)
4677 {
4678 struct zebra_evpn *zevpn;
4679 struct interface *ifp;
4680 struct zebra_if *zif;
4681 struct zebra_vtep *zvtep;
4682 struct zebra_vrf *zvrf;
4683
4684 if (!is_evpn_enabled()) {
4685 zlog_debug("%s: EVPN not enabled: can't process a VTEP ADD",
4686 __func__);
4687 return;
4688 }
4689
4690 zvrf = zebra_vrf_lookup_by_id(vrf_id);
4691 if (!zvrf)
4692 return;
4693
4694 if (!EVPN_ENABLED(zvrf)) {
4695 zlog_debug("Can't process VTEP ADD for non-EVPN VRF %u",
4696 zvrf_id(zvrf));
4697 return;
4698 }
4699
4700 /* Locate VNI hash entry - expected to exist. */
4701 zevpn = zebra_evpn_lookup(vni);
4702 if (!zevpn) {
4703 flog_err(
4704 EC_ZEBRA_VTEP_ADD_FAILED,
4705 "Failed to locate EVPN hash upon remote VTEP ADD, VNI %u",
4706 vni);
4707 return;
4708 }
4709
4710 ifp = zevpn->vxlan_if;
4711 if (!ifp) {
4712 flog_err(
4713 EC_ZEBRA_VTEP_ADD_FAILED,
4714 "VNI %u hash %p doesn't have intf upon remote VTEP ADD",
4715 zevpn->vni, zevpn);
4716 return;
4717 }
4718
4719 zif = ifp->info;
4720
4721 /* If down or not mapped to a bridge, we're done. */
4722 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
4723 return;
4724
4725 zvtep = zebra_evpn_vtep_find(zevpn, &vtep_ip);
4726 if (zvtep) {
4727 /* If the remote VTEP already exists check if
4728 * the flood mode has changed
4729 */
4730 if (zvtep->flood_control != flood_control) {
4731 if (zvtep->flood_control == VXLAN_FLOOD_DISABLED)
4732 /* old mode was head-end-replication but
4733 * is no longer; get rid of the HER fdb
4734 * entry installed before
4735 */
4736 zebra_evpn_vtep_uninstall(zevpn, &vtep_ip);
4737 zvtep->flood_control = flood_control;
4738 zebra_evpn_vtep_install(zevpn, zvtep);
4739 }
4740 } else {
4741 zvtep = zebra_evpn_vtep_add(zevpn, &vtep_ip, flood_control);
4742 if (zvtep)
4743 zebra_evpn_vtep_install(zevpn, zvtep);
4744 else
4745 flog_err(EC_ZEBRA_VTEP_ADD_FAILED,
4746 "Failed to add remote VTEP, VNI %u zevpn %p",
4747 vni, zevpn);
4748 }
4749 }
4750
4751 /*
4752 * Handle message from client to add a remote VTEP for an EVPN.
4753 */
4754 void zebra_vxlan_remote_vtep_add_zapi(ZAPI_HANDLER_ARGS)
4755 {
4756 struct stream *s;
4757 unsigned short l = 0;
4758 vni_t vni;
4759 struct in_addr vtep_ip;
4760 int flood_control;
4761
4762 if (!is_evpn_enabled()) {
4763 zlog_debug(
4764 "%s: EVPN not enabled yet we received a VTEP ADD zapi msg",
4765 __func__);
4766 return;
4767 }
4768
4769 if (!EVPN_ENABLED(zvrf)) {
4770 zlog_debug("Recv VTEP ADD zapi for non-EVPN VRF %u",
4771 zvrf_id(zvrf));
4772 return;
4773 }
4774
4775 s = msg;
4776
4777 while (l < hdr->length) {
4778 /* Obtain each remote VTEP and process. */
4779 STREAM_GETL(s, vni);
4780 l += 4;
4781 STREAM_GET(&vtep_ip.s_addr, s, IPV4_MAX_BYTELEN);
4782 STREAM_GETL(s, flood_control);
4783 l += IPV4_MAX_BYTELEN + 4;
4784
4785 if (IS_ZEBRA_DEBUG_VXLAN)
4786 zlog_debug("Recv VTEP ADD %pI4 VNI %u flood %d from %s",
4787 &vtep_ip, vni, flood_control,
4788 zebra_route_string(client->proto));
4789
4790 /* Enqueue for processing */
4791 zebra_rib_queue_evpn_rem_vtep_add(zvrf_id(zvrf), vni, vtep_ip,
4792 flood_control);
4793 }
4794
4795 stream_failure:
4796 return;
4797 }
4798
4799 /*
4800 * Add/Del gateway macip to evpn
4801 * g/w can be:
4802 * 1. SVI interface on a vlan aware bridge
4803 * 2. SVI interface on a vlan unaware bridge
4804 * 3. vrr interface (MACVLAN) associated to a SVI
4805 * We advertise macip routes for an interface if it is associated to VxLan vlan
4806 */
4807 int zebra_vxlan_add_del_gw_macip(struct interface *ifp, const struct prefix *p,
4808 int add)
4809 {
4810 struct ipaddr ip;
4811 struct ethaddr macaddr;
4812 struct zebra_evpn *zevpn = NULL;
4813
4814 memset(&ip, 0, sizeof(ip));
4815 memset(&macaddr, 0, sizeof(macaddr));
4816
4817 /* Check if EVPN is enabled. */
4818 if (!is_evpn_enabled())
4819 return 0;
4820
4821 if (IS_ZEBRA_IF_MACVLAN(ifp)) {
4822 struct interface *svi_if =
4823 NULL; /* SVI corresponding to the MACVLAN */
4824 struct zebra_if *ifp_zif =
4825 NULL; /* Zebra daemon specific info for MACVLAN */
4826 struct zebra_if *svi_if_zif =
4827 NULL; /* Zebra daemon specific info for SVI*/
4828
4829 ifp_zif = ifp->info;
4830 if (!ifp_zif)
4831 return -1;
4832
4833 /*
4834 * for a MACVLAN interface the link represents the svi_if
4835 */
4836 svi_if = if_lookup_by_index_per_ns(zebra_ns_lookup(NS_DEFAULT),
4837 ifp_zif->link_ifindex);
4838 if (!svi_if) {
4839 zlog_debug("MACVLAN %s(%u) without link information",
4840 ifp->name, ifp->ifindex);
4841 return -1;
4842 }
4843
4844 if (IS_ZEBRA_IF_VLAN(svi_if)) {
4845 /*
4846 * If it is a vlan aware bridge then the link gives the
4847 * bridge information
4848 */
4849 struct interface *svi_if_link = NULL;
4850
4851 svi_if_zif = svi_if->info;
4852 if (svi_if_zif) {
4853 svi_if_link = if_lookup_by_index_per_ns(
4854 zebra_ns_lookup(NS_DEFAULT),
4855 svi_if_zif->link_ifindex);
4856 zevpn = zebra_evpn_from_svi(svi_if,
4857 svi_if_link);
4858 }
4859 } else if (IS_ZEBRA_IF_BRIDGE(svi_if)) {
4860 /*
4861 * If it is a vlan unaware bridge then svi is the bridge
4862 * itself
4863 */
4864 zevpn = zebra_evpn_from_svi(svi_if, svi_if);
4865 }
4866 } else if (IS_ZEBRA_IF_VLAN(ifp)) {
4867 struct zebra_if *svi_if_zif =
4868 NULL; /* Zebra daemon specific info for SVI */
4869 struct interface *svi_if_link =
4870 NULL; /* link info for the SVI = bridge info */
4871
4872 svi_if_zif = ifp->info;
4873 if (svi_if_zif) {
4874 svi_if_link = if_lookup_by_index_per_ns(
4875 zebra_ns_lookup(NS_DEFAULT),
4876 svi_if_zif->link_ifindex);
4877 if (svi_if_link)
4878 zevpn = zebra_evpn_from_svi(ifp, svi_if_link);
4879 }
4880 } else if (IS_ZEBRA_IF_BRIDGE(ifp)) {
4881 zevpn = zebra_evpn_from_svi(ifp, ifp);
4882 }
4883
4884 if (!zevpn)
4885 return 0;
4886
4887 if (!zevpn->vxlan_if) {
4888 zlog_debug("VNI %u hash %p doesn't have intf upon MACVLAN up",
4889 zevpn->vni, zevpn);
4890 return -1;
4891 }
4892
4893 /* VRR IP is advertised only if gw-macip-adv-enabled */
4894 if (IS_ZEBRA_IF_MACVLAN(ifp)) {
4895 if (!advertise_gw_macip_enabled(zevpn))
4896 return 0;
4897 } else {
4898 /* SVI IP is advertised if gw or svi macip-adv-enabled */
4899 if (!advertise_svi_macip_enabled(zevpn)
4900 && !advertise_gw_macip_enabled(zevpn))
4901 return 0;
4902 }
4903
4904 memcpy(&macaddr.octet, ifp->hw_addr, ETH_ALEN);
4905
4906 if (p->family == AF_INET) {
4907 ip.ipa_type = IPADDR_V4;
4908 memcpy(&(ip.ipaddr_v4), &(p->u.prefix4),
4909 sizeof(struct in_addr));
4910 } else if (p->family == AF_INET6) {
4911 ip.ipa_type = IPADDR_V6;
4912 memcpy(&(ip.ipaddr_v6), &(p->u.prefix6),
4913 sizeof(struct in6_addr));
4914 }
4915
4916
4917 if (add)
4918 zebra_evpn_gw_macip_add(ifp, zevpn, &macaddr, &ip);
4919 else
4920 zebra_evpn_gw_macip_del(ifp, zevpn, &ip);
4921
4922 return 0;
4923 }
4924
4925 /*
4926 * Handle SVI interface going down.
4927 * SVI can be associated to either L3-VNI or L2-VNI.
4928 * For L2-VNI: At this point, this is a NOP since
4929 * the kernel deletes the neighbor entries on this SVI (if any).
4930 * We only need to update the vrf corresponding to zevpn.
4931 * For L3-VNI: L3-VNI is operationally down, update mac-ip routes and delete
4932 * from bgp
4933 */
4934 int zebra_vxlan_svi_down(struct interface *ifp, struct interface *link_if)
4935 {
4936 struct zebra_l3vni *zl3vni = NULL;
4937
4938 zl3vni = zl3vni_from_svi(ifp, link_if);
4939 if (zl3vni) {
4940
4941 /* process l3-vni down */
4942 zebra_vxlan_process_l3vni_oper_down(zl3vni);
4943
4944 /* remove association with svi-if */
4945 zl3vni->svi_if = NULL;
4946 } else {
4947 struct zebra_evpn *zevpn = NULL;
4948
4949 /* Unlink the SVI from the access VLAN */
4950 zebra_evpn_acc_bd_svi_set(ifp->info, link_if->info, false);
4951
4952 /* since we dont have svi corresponding to zevpn, we associate it
4953 * to default vrf. Note: the corresponding neigh entries on the
4954 * SVI would have already been deleted */
4955 zevpn = zebra_evpn_from_svi(ifp, link_if);
4956
4957 if (zevpn) {
4958 /* remove from l3-vni list */
4959 zl3vni = zl3vni_from_vrf(zevpn->vrf_id);
4960 if (zl3vni)
4961 listnode_delete(zl3vni->l2vnis, zevpn);
4962
4963 zevpn->svi_if = NULL;
4964 zevpn->vrf_id = VRF_DEFAULT;
4965
4966 /* update the tenant vrf in BGP */
4967 if (if_is_operative(zevpn->vxlan_if))
4968 zebra_evpn_send_add_to_client(zevpn);
4969 }
4970 }
4971 return 0;
4972 }
4973
4974 /*
4975 * Handle SVI interface coming up.
4976 * SVI can be associated to L3-VNI (l3vni vxlan interface) or L2-VNI (l2-vni
4977 * vxlan intf).
4978 * For L2-VNI: we need to install any remote neighbors entried (used for
4979 * arp-suppression)
4980 * For L3-VNI: SVI will be used to get the rmac to be used with L3-VNI
4981 */
4982 int zebra_vxlan_svi_up(struct interface *ifp, struct interface *link_if)
4983 {
4984 struct zebra_evpn *zevpn = NULL;
4985 struct zebra_l3vni *zl3vni = NULL;
4986
4987 zl3vni = zl3vni_from_svi(ifp, link_if);
4988 if (zl3vni) {
4989
4990 /* associate with svi */
4991 zl3vni->svi_if = ifp;
4992
4993 /* process oper-up */
4994 if (is_l3vni_oper_up(zl3vni))
4995 zebra_vxlan_process_l3vni_oper_up(zl3vni);
4996 } else {
4997
4998 /* process SVI up for l2-vni */
4999 struct neigh_walk_ctx n_wctx;
5000
5001 zevpn = zebra_evpn_from_svi(ifp, link_if);
5002 if (!zevpn)
5003 return 0;
5004
5005 if (!zevpn->vxlan_if) {
5006 zlog_debug(
5007 "VNI %u hash %p doesn't have intf upon SVI up",
5008 zevpn->vni, zevpn);
5009 return -1;
5010 }
5011
5012 if (IS_ZEBRA_DEBUG_VXLAN)
5013 zlog_debug(
5014 "SVI %s(%u) VNI %u VRF %s is UP, installing neighbors",
5015 ifp->name, ifp->ifindex, zevpn->vni,
5016 ifp->vrf->name);
5017
5018 /* update the vrf information for l2-vni and inform bgp */
5019 zevpn->svi_if = ifp;
5020 zevpn->vrf_id = ifp->vrf->vrf_id;
5021
5022 zl3vni = zl3vni_from_vrf(zevpn->vrf_id);
5023 if (zl3vni)
5024 listnode_add_sort_nodup(zl3vni->l2vnis, zevpn);
5025
5026 if (if_is_operative(zevpn->vxlan_if))
5027 zebra_evpn_send_add_to_client(zevpn);
5028
5029 /* Install any remote neighbors for this VNI. */
5030 memset(&n_wctx, 0, sizeof(n_wctx));
5031 n_wctx.zevpn = zevpn;
5032 hash_iterate(zevpn->neigh_table, zebra_evpn_install_neigh_hash,
5033 &n_wctx);
5034
5035 /* Link the SVI from the access VLAN */
5036 zebra_evpn_acc_bd_svi_set(ifp->info, link_if->info, true);
5037
5038 /* Update MACIP routes created by advertise-svi-ip */
5039 if (advertise_svi_macip_enabled(zevpn)) {
5040 zebra_evpn_del_macip_for_intf(ifp, zevpn);
5041 zebra_evpn_add_macip_for_intf(ifp, zevpn);
5042 }
5043 }
5044
5045 return 0;
5046 }
5047
5048 /*
5049 * Handle MAC-VLAN interface going down.
5050 * L3VNI: When MAC-VLAN interface goes down,
5051 * find its associated SVI and update type2/type-5 routes
5052 * with SVI as RMAC
5053 */
5054 void zebra_vxlan_macvlan_down(struct interface *ifp)
5055 {
5056 struct zebra_l3vni *zl3vni = NULL;
5057 struct zebra_if *zif, *link_zif;
5058 struct interface *link_ifp, *link_if;
5059
5060 zif = ifp->info;
5061 assert(zif);
5062 link_ifp = zif->link;
5063 if (!link_ifp) {
5064 if (IS_ZEBRA_DEBUG_VXLAN)
5065 zlog_debug(
5066 "macvlan parent link is not found. Parent index %d ifp %s",
5067 zif->link_ifindex,
5068 ifindex2ifname(zif->link_ifindex,
5069 ifp->vrf->vrf_id));
5070 return;
5071 }
5072 link_zif = link_ifp->info;
5073 assert(link_zif);
5074
5075 link_if = if_lookup_by_index_per_ns(zebra_ns_lookup(NS_DEFAULT),
5076 link_zif->link_ifindex);
5077
5078 zl3vni = zl3vni_from_svi(link_ifp, link_if);
5079 if (zl3vni) {
5080 zl3vni->mac_vlan_if = NULL;
5081 if (is_l3vni_oper_up(zl3vni))
5082 zebra_vxlan_process_l3vni_oper_up(zl3vni);
5083 }
5084 }
5085
5086 /*
5087 * Handle MAC-VLAN interface going up.
5088 * L3VNI: When MAC-VLAN interface comes up,
5089 * find its associated SVI and update type-2 routes
5090 * with MAC-VLAN's MAC as RMAC and for type-5 routes
5091 * use SVI's MAC as RMAC.
5092 */
5093 void zebra_vxlan_macvlan_up(struct interface *ifp)
5094 {
5095 struct zebra_l3vni *zl3vni = NULL;
5096 struct zebra_if *zif, *link_zif;
5097 struct interface *link_ifp, *link_if;
5098
5099 zif = ifp->info;
5100 assert(zif);
5101 link_ifp = zif->link;
5102 link_zif = link_ifp->info;
5103 assert(link_zif);
5104
5105 link_if = if_lookup_by_index_per_ns(zebra_ns_lookup(NS_DEFAULT),
5106 link_zif->link_ifindex);
5107 zl3vni = zl3vni_from_svi(link_ifp, link_if);
5108 if (zl3vni) {
5109 /* associate with macvlan (VRR) interface */
5110 zl3vni->mac_vlan_if = ifp;
5111
5112 /* process oper-up */
5113 if (is_l3vni_oper_up(zl3vni))
5114 zebra_vxlan_process_l3vni_oper_up(zl3vni);
5115 }
5116 }
5117
5118 int zebra_vxlan_process_vrf_vni_cmd(struct zebra_vrf *zvrf, vni_t vni,
5119 char *err, int err_str_sz, int filter,
5120 int add)
5121 {
5122 struct zebra_l3vni *zl3vni = NULL;
5123 struct zebra_vrf *zvrf_evpn = NULL;
5124
5125 zvrf_evpn = zebra_vrf_get_evpn();
5126
5127 if (IS_ZEBRA_DEBUG_VXLAN)
5128 zlog_debug("vrf %s vni %u %s", zvrf_name(zvrf), vni,
5129 add ? "ADD" : "DEL");
5130
5131 if (add) {
5132 /* check if the vni is already present under zvrf */
5133 if (zvrf->l3vni) {
5134 snprintf(err, err_str_sz,
5135 "VNI is already configured under the vrf");
5136 return -1;
5137 }
5138
5139 /* check if this VNI is already present in the system */
5140 zl3vni = zl3vni_lookup(vni);
5141 if (zl3vni) {
5142 snprintf(err, err_str_sz,
5143 "VNI is already configured as L3-VNI");
5144 return -1;
5145 }
5146
5147 /* Remove L2VNI if present */
5148 zebra_vxlan_handle_vni_transition(zvrf, vni, add);
5149
5150 /* add the L3-VNI to the global table */
5151 zl3vni = zl3vni_add(vni, zvrf_id(zvrf));
5152
5153 /* associate the vrf with vni */
5154 zvrf->l3vni = vni;
5155
5156 /* set the filter in l3vni to denote if we are using l3vni only
5157 * for prefix routes
5158 */
5159 if (filter)
5160 SET_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY);
5161
5162 /* associate with vxlan-intf;
5163 * we need to associate with the vxlan-intf first
5164 */
5165 zl3vni->vxlan_if = zl3vni_map_to_vxlan_if(zl3vni);
5166
5167 /* associate with corresponding SVI interface, we can associate
5168 * with svi-if only after vxlan interface association is
5169 * complete
5170 */
5171 zl3vni->svi_if = zl3vni_map_to_svi_if(zl3vni);
5172
5173 zl3vni->mac_vlan_if = zl3vni_map_to_mac_vlan_if(zl3vni);
5174
5175 if (IS_ZEBRA_DEBUG_VXLAN)
5176 zlog_debug(
5177 "%s: l3vni %u svi_if %s mac_vlan_if %s",
5178 __func__, vni,
5179 zl3vni->svi_if ? zl3vni->svi_if->name : "NIL",
5180 zl3vni->mac_vlan_if ? zl3vni->mac_vlan_if->name
5181 : "NIL");
5182
5183 /* formulate l2vni list */
5184 hash_iterate(zvrf_evpn->evpn_table, zevpn_add_to_l3vni_list,
5185 zl3vni);
5186
5187 if (is_l3vni_oper_up(zl3vni))
5188 zebra_vxlan_process_l3vni_oper_up(zl3vni);
5189
5190 } else {
5191 zl3vni = zl3vni_lookup(vni);
5192 if (!zl3vni) {
5193 snprintf(err, err_str_sz, "VNI doesn't exist");
5194 return -1;
5195 }
5196
5197 if (zvrf->l3vni != vni) {
5198 snprintf(err, err_str_sz,
5199 "VNI %d doesn't exist in VRF: %s",
5200 vni, zvrf->vrf->name);
5201 return -1;
5202 }
5203
5204 if (filter && !CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)) {
5205 snprintf(err, ERR_STR_SZ,
5206 "prefix-routes-only is not set for the vni");
5207 return -1;
5208 }
5209
5210 zebra_vxlan_process_l3vni_oper_down(zl3vni);
5211
5212 /* delete and uninstall all rmacs */
5213 hash_iterate(zl3vni->rmac_table, zl3vni_del_rmac_hash_entry,
5214 zl3vni);
5215
5216 /* delete and uninstall all next-hops */
5217 hash_iterate(zl3vni->nh_table, zl3vni_del_nh_hash_entry,
5218 zl3vni);
5219
5220 zvrf->l3vni = 0;
5221 zl3vni_del(zl3vni);
5222
5223 /* Add L2VNI for this VNI */
5224 zebra_vxlan_handle_vni_transition(zvrf, vni, add);
5225 }
5226 return 0;
5227 }
5228
5229 int zebra_vxlan_vrf_enable(struct zebra_vrf *zvrf)
5230 {
5231 struct zebra_l3vni *zl3vni = NULL;
5232
5233 if (zvrf->l3vni)
5234 zl3vni = zl3vni_lookup(zvrf->l3vni);
5235 if (!zl3vni)
5236 return 0;
5237
5238 zl3vni->vrf_id = zvrf_id(zvrf);
5239 if (is_l3vni_oper_up(zl3vni))
5240 zebra_vxlan_process_l3vni_oper_up(zl3vni);
5241 return 0;
5242 }
5243
5244 int zebra_vxlan_vrf_disable(struct zebra_vrf *zvrf)
5245 {
5246 struct zebra_l3vni *zl3vni = NULL;
5247
5248 if (zvrf->l3vni)
5249 zl3vni = zl3vni_lookup(zvrf->l3vni);
5250 if (!zl3vni)
5251 return 0;
5252
5253 zebra_vxlan_process_l3vni_oper_down(zl3vni);
5254
5255 /* delete and uninstall all rmacs */
5256 hash_iterate(zl3vni->rmac_table, zl3vni_del_rmac_hash_entry, zl3vni);
5257 /* delete and uninstall all next-hops */
5258 hash_iterate(zl3vni->nh_table, zl3vni_del_nh_hash_entry, zl3vni);
5259
5260 zl3vni->vrf_id = VRF_UNKNOWN;
5261
5262 return 0;
5263 }
5264
5265 int zebra_vxlan_vrf_delete(struct zebra_vrf *zvrf)
5266 {
5267 struct zebra_l3vni *zl3vni = NULL;
5268 vni_t vni;
5269
5270 if (zvrf->l3vni)
5271 zl3vni = zl3vni_lookup(zvrf->l3vni);
5272 if (!zl3vni)
5273 return 0;
5274
5275 vni = zl3vni->vni;
5276 zl3vni_del(zl3vni);
5277 zebra_vxlan_handle_vni_transition(zvrf, vni, 0);
5278
5279 return 0;
5280 }
5281
5282 /*
5283 * Handle message from client to specify the flooding mechanism for
5284 * BUM packets. The default is to do head-end (ingress) replication
5285 * and the other supported option is to disable it. This applies to
5286 * all BUM traffic and disabling it applies to both the transmit and
5287 * receive direction.
5288 */
5289 void zebra_vxlan_flood_control(ZAPI_HANDLER_ARGS)
5290 {
5291 struct stream *s;
5292 enum vxlan_flood_control flood_ctrl;
5293
5294 if (!EVPN_ENABLED(zvrf)) {
5295 zlog_err("EVPN flood control for non-EVPN VRF %u",
5296 zvrf_id(zvrf));
5297 return;
5298 }
5299
5300 s = msg;
5301 STREAM_GETC(s, flood_ctrl);
5302
5303 if (IS_ZEBRA_DEBUG_VXLAN)
5304 zlog_debug("EVPN flood control %u, currently %u",
5305 flood_ctrl, zvrf->vxlan_flood_ctrl);
5306
5307 if (zvrf->vxlan_flood_ctrl == flood_ctrl)
5308 return;
5309
5310 zvrf->vxlan_flood_ctrl = flood_ctrl;
5311
5312 /* Install or uninstall flood entries corresponding to
5313 * remote VTEPs.
5314 */
5315 hash_iterate(zvrf->evpn_table, zebra_evpn_handle_flooding_remote_vteps,
5316 zvrf);
5317
5318 stream_failure:
5319 return;
5320 }
5321
5322 /*
5323 * Handle message from client to enable/disable advertisement of svi macip
5324 * routes
5325 */
5326 void zebra_vxlan_advertise_svi_macip(ZAPI_HANDLER_ARGS)
5327 {
5328 struct stream *s;
5329 int advertise;
5330 vni_t vni = 0;
5331 struct zebra_evpn *zevpn = NULL;
5332 struct interface *ifp = NULL;
5333
5334 if (!EVPN_ENABLED(zvrf)) {
5335 zlog_debug("EVPN SVI-MACIP Adv for non-EVPN VRF %u",
5336 zvrf_id(zvrf));
5337 return;
5338 }
5339
5340 s = msg;
5341 STREAM_GETC(s, advertise);
5342 STREAM_GETL(s, vni);
5343
5344 if (!vni) {
5345 if (IS_ZEBRA_DEBUG_VXLAN)
5346 zlog_debug("EVPN SVI-MACIP Adv %s, currently %s",
5347 advertise ? "enabled" : "disabled",
5348 advertise_svi_macip_enabled(NULL)
5349 ? "enabled"
5350 : "disabled");
5351
5352 if (zvrf->advertise_svi_macip == advertise)
5353 return;
5354
5355
5356 if (advertise) {
5357 zvrf->advertise_svi_macip = advertise;
5358 hash_iterate(zvrf->evpn_table,
5359 zebra_evpn_gw_macip_add_for_evpn_hash,
5360 NULL);
5361 } else {
5362 hash_iterate(zvrf->evpn_table,
5363 zebra_evpn_svi_macip_del_for_evpn_hash,
5364 NULL);
5365 zvrf->advertise_svi_macip = advertise;
5366 }
5367
5368 } else {
5369 struct zebra_if *zif = NULL;
5370 struct interface *vlan_if = NULL;
5371 struct zebra_vxlan_vni *zl2_info_vni;
5372 int old_advertise;
5373
5374 zevpn = zebra_evpn_lookup(vni);
5375 if (!zevpn)
5376 return;
5377
5378 if (IS_ZEBRA_DEBUG_VXLAN)
5379 zlog_debug(
5380 "EVPN SVI macip Adv %s on VNI %d, currently %s",
5381 advertise ? "enabled" : "disabled", vni,
5382 advertise_svi_macip_enabled(zevpn)
5383 ? "enabled"
5384 : "disabled");
5385
5386 old_advertise = advertise_svi_macip_enabled(zevpn);
5387
5388 /* Store flag even though SVI is not present.
5389 * Once SVI comes up triggers self MAC-IP route add.
5390 */
5391 zevpn->advertise_svi_macip = advertise;
5392 if (advertise_svi_macip_enabled(zevpn) == old_advertise)
5393 return;
5394
5395 ifp = zevpn->vxlan_if;
5396 if (!ifp)
5397 return;
5398
5399 zif = ifp->info;
5400
5401 /* If down or not mapped to a bridge, we're done. */
5402 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
5403 return;
5404
5405 zl2_info_vni = zebra_vxlan_if_vni_find(zif, vni);
5406 if (!zl2_info_vni)
5407 return;
5408
5409 vlan_if = zvni_map_to_svi(zl2_info_vni->access_vlan,
5410 zif->brslave_info.br_if);
5411 if (!vlan_if)
5412 return;
5413
5414 if (advertise) {
5415 /* Add primary SVI MAC-IP */
5416 zebra_evpn_add_macip_for_intf(vlan_if, zevpn);
5417 } else {
5418 /* Del primary SVI MAC-IP */
5419 zebra_evpn_del_macip_for_intf(vlan_if, zevpn);
5420 }
5421 }
5422
5423 stream_failure:
5424 return;
5425 }
5426
5427 /*
5428 * Handle message from client to enable/disable advertisement of g/w macip
5429 * routes
5430 */
5431 void zebra_vxlan_advertise_subnet(ZAPI_HANDLER_ARGS)
5432 {
5433 struct stream *s;
5434 int advertise;
5435 vni_t vni = 0;
5436 struct zebra_evpn *zevpn = NULL;
5437 struct interface *ifp = NULL;
5438 struct zebra_if *zif = NULL;
5439 struct interface *vlan_if = NULL;
5440 struct zebra_vxlan_vni *zl2_info_vni = NULL;
5441
5442 if (!EVPN_ENABLED(zvrf)) {
5443 zlog_debug("EVPN GW-MACIP Adv for non-EVPN VRF %u",
5444 zvrf_id(zvrf));
5445 return;
5446 }
5447
5448 s = msg;
5449 STREAM_GETC(s, advertise);
5450 STREAM_GET(&vni, s, 3);
5451
5452 zevpn = zebra_evpn_lookup(vni);
5453 if (!zevpn)
5454 return;
5455
5456 if (zevpn->advertise_subnet == advertise)
5457 return;
5458
5459 if (IS_ZEBRA_DEBUG_VXLAN)
5460 zlog_debug("EVPN subnet Adv %s on VNI %d, currently %s",
5461 advertise ? "enabled" : "disabled", vni,
5462 zevpn->advertise_subnet ? "enabled" : "disabled");
5463
5464
5465 zevpn->advertise_subnet = advertise;
5466
5467 ifp = zevpn->vxlan_if;
5468 if (!ifp)
5469 return;
5470
5471 zif = ifp->info;
5472
5473 /* If down or not mapped to a bridge, we're done. */
5474 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
5475 return;
5476
5477 zl2_info_vni = zebra_vxlan_if_vni_find(zif, vni);
5478 if (!zl2_info_vni)
5479 return;
5480
5481 vlan_if = zvni_map_to_svi(zl2_info_vni->access_vlan,
5482 zif->brslave_info.br_if);
5483 if (!vlan_if)
5484 return;
5485
5486 if (zevpn->advertise_subnet)
5487 zebra_evpn_advertise_subnet(zevpn, vlan_if, 1);
5488 else
5489 zebra_evpn_advertise_subnet(zevpn, vlan_if, 0);
5490
5491 stream_failure:
5492 return;
5493 }
5494
5495 /*
5496 * Handle message from client to enable/disable advertisement of g/w macip
5497 * routes
5498 */
5499 void zebra_vxlan_advertise_gw_macip(ZAPI_HANDLER_ARGS)
5500 {
5501 struct stream *s;
5502 int advertise;
5503 vni_t vni = 0;
5504 struct zebra_evpn *zevpn = NULL;
5505 struct interface *ifp = NULL;
5506
5507 if (!EVPN_ENABLED(zvrf)) {
5508 zlog_debug("EVPN GW-MACIP Adv for non-EVPN VRF %u",
5509 zvrf_id(zvrf));
5510 return;
5511 }
5512
5513 s = msg;
5514 STREAM_GETC(s, advertise);
5515 STREAM_GETL(s, vni);
5516
5517 if (!vni) {
5518 if (IS_ZEBRA_DEBUG_VXLAN)
5519 zlog_debug("EVPN gateway macip Adv %s, currently %s",
5520 advertise ? "enabled" : "disabled",
5521 advertise_gw_macip_enabled(NULL)
5522 ? "enabled"
5523 : "disabled");
5524
5525 if (zvrf->advertise_gw_macip == advertise)
5526 return;
5527
5528 zvrf->advertise_gw_macip = advertise;
5529
5530 if (advertise_gw_macip_enabled(zevpn))
5531 hash_iterate(zvrf->evpn_table,
5532 zebra_evpn_gw_macip_add_for_evpn_hash,
5533 NULL);
5534 else
5535 hash_iterate(zvrf->evpn_table,
5536 zebra_evpn_gw_macip_del_for_evpn_hash,
5537 NULL);
5538
5539 } else {
5540 struct zebra_if *zif = NULL;
5541 struct interface *vlan_if = NULL;
5542 struct interface *vrr_if = NULL;
5543 struct zebra_vxlan_vni *zl2_info_vni = NULL;
5544 int old_advertise;
5545
5546 zevpn = zebra_evpn_lookup(vni);
5547 if (!zevpn)
5548 return;
5549
5550 if (IS_ZEBRA_DEBUG_VXLAN)
5551 zlog_debug(
5552 "EVPN gateway macip Adv %s on VNI %d, currently %s",
5553 advertise ? "enabled" : "disabled", vni,
5554 advertise_gw_macip_enabled(zevpn) ? "enabled"
5555 : "disabled");
5556
5557 old_advertise = advertise_gw_macip_enabled(zevpn);
5558
5559 zevpn->advertise_gw_macip = advertise;
5560 if (advertise_gw_macip_enabled(zevpn) == old_advertise)
5561 return;
5562
5563 ifp = zevpn->vxlan_if;
5564 if (!ifp)
5565 return;
5566
5567 zif = ifp->info;
5568
5569 /* If down or not mapped to a bridge, we're done. */
5570 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
5571 return;
5572
5573 zl2_info_vni = zebra_vxlan_if_vni_find(zif, vni);
5574 if (!zl2_info_vni)
5575 return;
5576
5577 vlan_if = zvni_map_to_svi(zl2_info_vni->access_vlan,
5578 zif->brslave_info.br_if);
5579 if (!vlan_if)
5580 return;
5581
5582 if (advertise_gw_macip_enabled(zevpn)) {
5583 /* Add primary SVI MAC-IP */
5584 zebra_evpn_add_macip_for_intf(vlan_if, zevpn);
5585
5586 /* Add VRR MAC-IP - if any*/
5587 vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
5588 if (vrr_if)
5589 zebra_evpn_add_macip_for_intf(vrr_if, zevpn);
5590 } else {
5591 /* Del primary MAC-IP */
5592 zebra_evpn_del_macip_for_intf(vlan_if, zevpn);
5593
5594 /* Del VRR MAC-IP - if any*/
5595 vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
5596 if (vrr_if)
5597 zebra_evpn_del_macip_for_intf(vrr_if, zevpn);
5598 }
5599 }
5600
5601 stream_failure:
5602 return;
5603 }
5604
5605 static int macfdb_read_ns(struct ns *ns,
5606 void *_in_param __attribute__((unused)),
5607 void **out_param __attribute__((unused)))
5608 {
5609 struct zebra_ns *zns = ns->info;
5610
5611 macfdb_read(zns);
5612 return NS_WALK_CONTINUE;
5613 }
5614
5615 static int neigh_read_ns(struct ns *ns,
5616 void *_in_param __attribute__((unused)),
5617 void **out_param __attribute__((unused)))
5618 {
5619 struct zebra_ns *zns = ns->info;
5620
5621 neigh_read(zns);
5622 return NS_WALK_CONTINUE;
5623 }
5624
5625 /*
5626 * Handle message from client to learn (or stop learning) about VNIs and MACs.
5627 * When enabled, the VNI hash table will be built and MAC FDB table read;
5628 * when disabled, the entries should be deleted and remote VTEPs and MACs
5629 * uninstalled from the kernel.
5630 * This also informs the setting for BUM handling at the time this change
5631 * occurs; it is relevant only when specifying "learn".
5632 */
5633 void zebra_vxlan_advertise_all_vni(ZAPI_HANDLER_ARGS)
5634 {
5635 struct stream *s = NULL;
5636 int advertise = 0;
5637 enum vxlan_flood_control flood_ctrl;
5638
5639 /* Mismatch between EVPN VRF and current VRF (should be prevented by
5640 * bgpd's cli) */
5641 if (is_evpn_enabled() && !EVPN_ENABLED(zvrf))
5642 return;
5643
5644 s = msg;
5645 STREAM_GETC(s, advertise);
5646 STREAM_GETC(s, flood_ctrl);
5647
5648 if (IS_ZEBRA_DEBUG_VXLAN)
5649 zlog_debug("EVPN VRF %s(%u) VNI Adv %s, currently %s, flood control %u",
5650 zvrf_name(zvrf), zvrf_id(zvrf),
5651 advertise ? "enabled" : "disabled",
5652 is_evpn_enabled() ? "enabled" : "disabled",
5653 flood_ctrl);
5654
5655 if (zvrf->advertise_all_vni == advertise)
5656 return;
5657
5658 zvrf->advertise_all_vni = advertise;
5659 if (EVPN_ENABLED(zvrf)) {
5660 zrouter.evpn_vrf = zvrf;
5661
5662 /* Note BUM handling */
5663 zvrf->vxlan_flood_ctrl = flood_ctrl;
5664
5665 /* Replay all ESs */
5666 zebra_evpn_es_send_all_to_client(true /* add */);
5667
5668 /* Build EVPN hash table and inform BGP. */
5669 zevpn_build_hash_table();
5670
5671 /* Add all SVI (L3 GW) MACs to BGP*/
5672 hash_iterate(zvrf->evpn_table,
5673 zebra_evpn_gw_macip_add_for_evpn_hash, NULL);
5674
5675 /* Read the MAC FDB */
5676 ns_walk_func(macfdb_read_ns, NULL, NULL);
5677
5678 /* Read neighbors */
5679 ns_walk_func(neigh_read_ns, NULL, NULL);
5680 } else {
5681 /* Cleanup VTEPs for all EVPNs - uninstall from
5682 * kernel and free entries.
5683 */
5684 hash_iterate(zvrf->evpn_table, zebra_evpn_vxlan_cleanup_all,
5685 zvrf);
5686
5687 /* Delete all ESs in BGP */
5688 zebra_evpn_es_send_all_to_client(false /* add */);
5689
5690 /* cleanup all l3vnis */
5691 hash_iterate(zrouter.l3vni_table, zl3vni_cleanup_all, NULL);
5692
5693 /* Mark as "no EVPN VRF" */
5694 zrouter.evpn_vrf = NULL;
5695 }
5696
5697 stream_failure:
5698 return;
5699 }
5700
5701 /*
5702 * Allocate EVPN hash table for this VRF and do other initialization.
5703 * NOTE: Currently supported only for default VRF.
5704 */
5705 void zebra_vxlan_init_tables(struct zebra_vrf *zvrf)
5706 {
5707 char buffer[80];
5708
5709 if (!zvrf)
5710 return;
5711
5712 snprintf(buffer, sizeof(buffer), "Zebra VRF EVPN Table: %s",
5713 zvrf->vrf->name);
5714 zvrf->evpn_table = hash_create_size(8, zebra_evpn_hash_keymake,
5715 zebra_evpn_hash_cmp, buffer);
5716
5717 snprintf(buffer, sizeof(buffer), "Zebra VxLAN SG Table: %s",
5718 zvrf->vrf->name);
5719 zvrf->vxlan_sg_table = hash_create_size(8, zebra_vxlan_sg_hash_key_make,
5720 zebra_vxlan_sg_hash_eq, buffer);
5721 }
5722
5723 /* Cleanup EVPN info, but don't free the table. */
5724 void zebra_vxlan_cleanup_tables(struct zebra_vrf *zvrf)
5725 {
5726 struct zebra_vrf *evpn_zvrf = zebra_vrf_get_evpn();
5727
5728 hash_iterate(zvrf->evpn_table, zebra_evpn_vxlan_cleanup_all, zvrf);
5729 zebra_vxlan_cleanup_sg_table(zvrf);
5730
5731 if (zvrf == evpn_zvrf)
5732 zebra_evpn_es_cleanup();
5733 }
5734
5735 /* Close all EVPN handling */
5736 void zebra_vxlan_close_tables(struct zebra_vrf *zvrf)
5737 {
5738 if (!zvrf)
5739 return;
5740 hash_iterate(zvrf->evpn_table, zebra_evpn_vxlan_cleanup_all, zvrf);
5741 hash_free(zvrf->evpn_table);
5742 if (zvrf->vxlan_sg_table) {
5743 zebra_vxlan_cleanup_sg_table(zvrf);
5744 hash_free(zvrf->vxlan_sg_table);
5745 zvrf->vxlan_sg_table = NULL;
5746 }
5747 }
5748
5749 /* init the l3vni table */
5750 void zebra_vxlan_init(void)
5751 {
5752 zrouter.l3vni_table = hash_create(l3vni_hash_keymake, l3vni_hash_cmp,
5753 "Zebra VRF L3 VNI table");
5754
5755 svd_nh_table = zebra_neigh_db_create("Zebra SVD next-hop table");
5756
5757 zrouter.evpn_vrf = NULL;
5758 zebra_evpn_mh_init();
5759 }
5760
5761 /* free l3vni table */
5762 void zebra_vxlan_disable(void)
5763 {
5764 hash_free(zrouter.l3vni_table);
5765 zebra_evpn_mh_terminate();
5766 }
5767
5768 /* get the l3vni svi ifindex */
5769 ifindex_t get_l3vni_svi_ifindex(vrf_id_t vrf_id)
5770 {
5771 struct zebra_l3vni *zl3vni = NULL;
5772
5773 zl3vni = zl3vni_from_vrf(vrf_id);
5774 if (!zl3vni || !is_l3vni_oper_up(zl3vni))
5775 return 0;
5776
5777 return zl3vni->svi_if->ifindex;
5778 }
5779
5780 /* get the l3vni vxlan ifindex */
5781 ifindex_t get_l3vni_vxlan_ifindex(vrf_id_t vrf_id)
5782 {
5783 struct zebra_l3vni *zl3vni = NULL;
5784
5785 zl3vni = zl3vni_from_vrf(vrf_id);
5786 if (!zl3vni || !is_l3vni_oper_up(zl3vni))
5787 return 0;
5788
5789 return zl3vni->vxlan_if->ifindex;
5790 }
5791
5792 /* get the l3vni vni */
5793 vni_t get_l3vni_vni(vrf_id_t vrf_id)
5794 {
5795 struct zebra_l3vni *zl3vni = NULL;
5796
5797 zl3vni = zl3vni_from_vrf(vrf_id);
5798 if (!zl3vni || !is_l3vni_oper_up(zl3vni))
5799 return 0;
5800
5801 return zl3vni->vni;
5802 }
5803
5804 /* is the vrf l3vni SVD backed? */
5805 bool is_vrf_l3vni_svd_backed(vrf_id_t vrf_id)
5806 {
5807 struct zebra_l3vni *zl3vni = NULL;
5808
5809 zl3vni = zl3vni_from_vrf(vrf_id);
5810 if (!zl3vni || !is_l3vni_oper_up(zl3vni))
5811 return false;
5812
5813 return IS_ZL3VNI_SVD_BACKED(zl3vni);
5814 }
5815
5816 /************************** vxlan SG cache management ************************/
5817 /* Inform PIM about the mcast group */
5818 static int zebra_vxlan_sg_send(struct zebra_vrf *zvrf,
5819 struct prefix_sg *sg,
5820 char *sg_str, uint16_t cmd)
5821 {
5822 struct zserv *client = NULL;
5823 struct stream *s = NULL;
5824
5825 client = zserv_find_client(ZEBRA_ROUTE_PIM, 0);
5826 if (!client)
5827 return 0;
5828
5829 if (!CHECK_FLAG(zvrf->flags, ZEBRA_PIM_SEND_VXLAN_SG))
5830 return 0;
5831
5832 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
5833
5834 zclient_create_header(s, cmd, VRF_DEFAULT);
5835 stream_putl(s, IPV4_MAX_BYTELEN);
5836 stream_put(s, &sg->src.s_addr, IPV4_MAX_BYTELEN);
5837 stream_put(s, &sg->grp.s_addr, IPV4_MAX_BYTELEN);
5838
5839 /* Write packet size. */
5840 stream_putw_at(s, 0, stream_get_endp(s));
5841
5842 if (IS_ZEBRA_DEBUG_VXLAN)
5843 zlog_debug(
5844 "Send %s %s to %s",
5845 (cmd == ZEBRA_VXLAN_SG_ADD) ? "add" : "del", sg_str,
5846 zebra_route_string(client->proto));
5847
5848 if (cmd == ZEBRA_VXLAN_SG_ADD)
5849 client->vxlan_sg_add_cnt++;
5850 else
5851 client->vxlan_sg_del_cnt++;
5852
5853 return zserv_send_message(client, s);
5854 }
5855
5856 static unsigned int zebra_vxlan_sg_hash_key_make(const void *p)
5857 {
5858 const struct zebra_vxlan_sg *vxlan_sg = p;
5859
5860 return (jhash_2words(vxlan_sg->sg.src.s_addr,
5861 vxlan_sg->sg.grp.s_addr, 0));
5862 }
5863
5864 static bool zebra_vxlan_sg_hash_eq(const void *p1, const void *p2)
5865 {
5866 const struct zebra_vxlan_sg *sg1 = p1;
5867 const struct zebra_vxlan_sg *sg2 = p2;
5868
5869 return ((sg1->sg.src.s_addr == sg2->sg.src.s_addr)
5870 && (sg1->sg.grp.s_addr == sg2->sg.grp.s_addr));
5871 }
5872
5873 static struct zebra_vxlan_sg *zebra_vxlan_sg_new(struct zebra_vrf *zvrf,
5874 struct prefix_sg *sg)
5875 {
5876 struct zebra_vxlan_sg *vxlan_sg;
5877
5878 vxlan_sg = XCALLOC(MTYPE_ZVXLAN_SG, sizeof(*vxlan_sg));
5879
5880 vxlan_sg->zvrf = zvrf;
5881 vxlan_sg->sg = *sg;
5882 prefix_sg2str(sg, vxlan_sg->sg_str);
5883
5884 vxlan_sg = hash_get(zvrf->vxlan_sg_table, vxlan_sg, hash_alloc_intern);
5885
5886 if (IS_ZEBRA_DEBUG_VXLAN)
5887 zlog_debug("vxlan SG %s created", vxlan_sg->sg_str);
5888
5889 return vxlan_sg;
5890 }
5891
5892 static struct zebra_vxlan_sg *zebra_vxlan_sg_find(struct zebra_vrf *zvrf,
5893 struct prefix_sg *sg)
5894 {
5895 struct zebra_vxlan_sg lookup;
5896
5897 lookup.sg = *sg;
5898 return hash_lookup(zvrf->vxlan_sg_table, &lookup);
5899 }
5900
5901 static struct zebra_vxlan_sg *zebra_vxlan_sg_add(struct zebra_vrf *zvrf,
5902 struct prefix_sg *sg)
5903 {
5904 struct zebra_vxlan_sg *vxlan_sg;
5905 struct zebra_vxlan_sg *parent = NULL;
5906 struct in_addr sip;
5907
5908 vxlan_sg = zebra_vxlan_sg_find(zvrf, sg);
5909 if (vxlan_sg)
5910 return vxlan_sg;
5911
5912 /* create a *G entry for every BUM group implicitly -
5913 * 1. The SG entry is used by pimd to setup the vxlan-origination-mroute
5914 * 2. the XG entry is used by pimd to setup the
5915 * vxlan-termination-mroute
5916 */
5917 if (sg->src.s_addr != INADDR_ANY) {
5918 memset(&sip, 0, sizeof(sip));
5919 parent = zebra_vxlan_sg_do_ref(zvrf, sip, sg->grp);
5920 if (!parent)
5921 return NULL;
5922 }
5923
5924 vxlan_sg = zebra_vxlan_sg_new(zvrf, sg);
5925
5926 zebra_vxlan_sg_send(zvrf, sg, vxlan_sg->sg_str,
5927 ZEBRA_VXLAN_SG_ADD);
5928
5929 return vxlan_sg;
5930 }
5931
5932 static void zebra_vxlan_sg_del(struct zebra_vxlan_sg *vxlan_sg)
5933 {
5934 struct in_addr sip;
5935 struct zebra_vrf *zvrf;
5936
5937 zvrf = vrf_info_lookup(VRF_DEFAULT);
5938 if (!zvrf)
5939 return;
5940
5941 /* On SG entry deletion remove the reference to its parent XG
5942 * entry
5943 */
5944 if (vxlan_sg->sg.src.s_addr != INADDR_ANY) {
5945 memset(&sip, 0, sizeof(sip));
5946 zebra_vxlan_sg_do_deref(zvrf, sip, vxlan_sg->sg.grp);
5947 }
5948
5949 zebra_vxlan_sg_send(zvrf, &vxlan_sg->sg,
5950 vxlan_sg->sg_str, ZEBRA_VXLAN_SG_DEL);
5951
5952 hash_release(vxlan_sg->zvrf->vxlan_sg_table, vxlan_sg);
5953
5954 if (IS_ZEBRA_DEBUG_VXLAN)
5955 zlog_debug("VXLAN SG %s deleted", vxlan_sg->sg_str);
5956
5957 XFREE(MTYPE_ZVXLAN_SG, vxlan_sg);
5958 }
5959
5960 static void zebra_vxlan_sg_do_deref(struct zebra_vrf *zvrf,
5961 struct in_addr sip, struct in_addr mcast_grp)
5962 {
5963 struct zebra_vxlan_sg *vxlan_sg;
5964 struct prefix_sg sg;
5965
5966 sg.family = AF_INET;
5967 sg.prefixlen = IPV4_MAX_BYTELEN;
5968 sg.src = sip;
5969 sg.grp = mcast_grp;
5970 vxlan_sg = zebra_vxlan_sg_find(zvrf, &sg);
5971 if (!vxlan_sg)
5972 return;
5973
5974 if (vxlan_sg->ref_cnt)
5975 --vxlan_sg->ref_cnt;
5976
5977 if (!vxlan_sg->ref_cnt)
5978 zebra_vxlan_sg_del(vxlan_sg);
5979 }
5980
5981 static struct zebra_vxlan_sg *zebra_vxlan_sg_do_ref(struct zebra_vrf *zvrf,
5982 struct in_addr sip,
5983 struct in_addr mcast_grp)
5984 {
5985 struct zebra_vxlan_sg *vxlan_sg;
5986 struct prefix_sg sg;
5987
5988 sg.family = AF_INET;
5989 sg.prefixlen = IPV4_MAX_BYTELEN;
5990 sg.src = sip;
5991 sg.grp = mcast_grp;
5992 vxlan_sg = zebra_vxlan_sg_add(zvrf, &sg);
5993 if (vxlan_sg)
5994 ++vxlan_sg->ref_cnt;
5995
5996 return vxlan_sg;
5997 }
5998
5999 void zebra_vxlan_sg_deref(struct in_addr local_vtep_ip,
6000 struct in_addr mcast_grp)
6001 {
6002 struct zebra_vrf *zvrf;
6003
6004 if (local_vtep_ip.s_addr == INADDR_ANY
6005 || mcast_grp.s_addr == INADDR_ANY)
6006 return;
6007
6008 zvrf = vrf_info_lookup(VRF_DEFAULT);
6009 if (!zvrf)
6010 return;
6011
6012 zebra_vxlan_sg_do_deref(zvrf, local_vtep_ip, mcast_grp);
6013 }
6014
6015 void zebra_vxlan_sg_ref(struct in_addr local_vtep_ip, struct in_addr mcast_grp)
6016 {
6017 struct zebra_vrf *zvrf;
6018
6019 if (local_vtep_ip.s_addr == INADDR_ANY
6020 || mcast_grp.s_addr == INADDR_ANY)
6021 return;
6022
6023 zvrf = vrf_info_lookup(VRF_DEFAULT);
6024 if (!zvrf)
6025 return;
6026 zebra_vxlan_sg_do_ref(zvrf, local_vtep_ip, mcast_grp);
6027 }
6028
6029 static void zebra_vxlan_xg_pre_cleanup(struct hash_bucket *bucket, void *arg)
6030 {
6031 struct zebra_vxlan_sg *vxlan_sg = (struct zebra_vxlan_sg *)bucket->data;
6032
6033 /* increment the ref count against (*,G) to prevent them from being
6034 * deleted
6035 */
6036 if (vxlan_sg->sg.src.s_addr == INADDR_ANY)
6037 ++vxlan_sg->ref_cnt;
6038 }
6039
6040 static void zebra_vxlan_xg_post_cleanup(struct hash_bucket *bucket, void *arg)
6041 {
6042 struct zebra_vxlan_sg *vxlan_sg = (struct zebra_vxlan_sg *)bucket->data;
6043
6044 /* decrement the dummy ref count against (*,G) to delete them */
6045 if (vxlan_sg->sg.src.s_addr == INADDR_ANY) {
6046 if (vxlan_sg->ref_cnt)
6047 --vxlan_sg->ref_cnt;
6048 if (!vxlan_sg->ref_cnt)
6049 zebra_vxlan_sg_del(vxlan_sg);
6050 }
6051 }
6052
6053 static void zebra_vxlan_sg_cleanup(struct hash_bucket *bucket, void *arg)
6054 {
6055 struct zebra_vxlan_sg *vxlan_sg = (struct zebra_vxlan_sg *)bucket->data;
6056
6057 zebra_vxlan_sg_del(vxlan_sg);
6058 }
6059
6060 static void zebra_vxlan_cleanup_sg_table(struct zebra_vrf *zvrf)
6061 {
6062 /* increment the ref count against (*,G) to prevent them from being
6063 * deleted
6064 */
6065 hash_iterate(zvrf->vxlan_sg_table, zebra_vxlan_xg_pre_cleanup, NULL);
6066
6067 hash_iterate(zvrf->vxlan_sg_table, zebra_vxlan_sg_cleanup, NULL);
6068
6069 /* decrement the dummy ref count against the XG entries */
6070 hash_iterate(zvrf->vxlan_sg_table, zebra_vxlan_xg_post_cleanup, NULL);
6071 }
6072
6073 static void zebra_vxlan_sg_replay_send(struct hash_bucket *bucket, void *arg)
6074 {
6075 struct zebra_vxlan_sg *vxlan_sg = (struct zebra_vxlan_sg *)bucket->data;
6076
6077 zebra_vxlan_sg_send(vxlan_sg->zvrf, &vxlan_sg->sg,
6078 vxlan_sg->sg_str, ZEBRA_VXLAN_SG_ADD);
6079 }
6080
6081 /* Handle message from client to replay vxlan SG entries */
6082 void zebra_vxlan_sg_replay(ZAPI_HANDLER_ARGS)
6083 {
6084 if (IS_ZEBRA_DEBUG_VXLAN)
6085 zlog_debug("VxLAN SG updates to PIM, start");
6086
6087 SET_FLAG(zvrf->flags, ZEBRA_PIM_SEND_VXLAN_SG);
6088
6089 if (!EVPN_ENABLED(zvrf)) {
6090 if (IS_ZEBRA_DEBUG_VXLAN)
6091 zlog_debug("VxLAN SG replay request on unexpected vrf %d",
6092 zvrf->vrf->vrf_id);
6093 return;
6094 }
6095
6096 hash_iterate(zvrf->vxlan_sg_table, zebra_vxlan_sg_replay_send, NULL);
6097 }
6098
6099
6100 /* Cleanup EVPN configuration of a specific VRF */
6101 static void zebra_evpn_vrf_cfg_cleanup(struct zebra_vrf *zvrf)
6102 {
6103 struct zebra_l3vni *zl3vni = NULL;
6104
6105 zvrf->advertise_all_vni = 0;
6106 zvrf->advertise_gw_macip = 0;
6107 zvrf->advertise_svi_macip = 0;
6108 zvrf->vxlan_flood_ctrl = VXLAN_FLOOD_HEAD_END_REPL;
6109
6110 hash_iterate(zvrf->evpn_table, zebra_evpn_cfg_cleanup, NULL);
6111
6112 if (zvrf->l3vni)
6113 zl3vni = zl3vni_lookup(zvrf->l3vni);
6114 if (zl3vni) {
6115 /* delete and uninstall all rmacs */
6116 hash_iterate(zl3vni->rmac_table, zl3vni_del_rmac_hash_entry,
6117 zl3vni);
6118 /* delete and uninstall all next-hops */
6119 hash_iterate(zl3vni->nh_table, zl3vni_del_nh_hash_entry,
6120 zl3vni);
6121 }
6122 }
6123
6124 /* Cleanup BGP EVPN configuration upon client disconnect */
6125 static int zebra_evpn_bgp_cfg_clean_up(struct zserv *client)
6126 {
6127 struct vrf *vrf;
6128 struct zebra_vrf *zvrf;
6129
6130 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
6131 zvrf = vrf->info;
6132 if (zvrf)
6133 zebra_evpn_vrf_cfg_cleanup(zvrf);
6134 }
6135
6136 return 0;
6137 }
6138
6139 static int zebra_evpn_pim_cfg_clean_up(struct zserv *client)
6140 {
6141 struct zebra_vrf *zvrf = zebra_vrf_get_evpn();
6142
6143 if (CHECK_FLAG(zvrf->flags, ZEBRA_PIM_SEND_VXLAN_SG)) {
6144 if (IS_ZEBRA_DEBUG_VXLAN)
6145 zlog_debug("VxLAN SG updates to PIM, stop");
6146 UNSET_FLAG(zvrf->flags, ZEBRA_PIM_SEND_VXLAN_SG);
6147 }
6148
6149 return 0;
6150 }
6151
6152 static int zebra_evpn_cfg_clean_up(struct zserv *client)
6153 {
6154 if (client->proto == ZEBRA_ROUTE_BGP)
6155 return zebra_evpn_bgp_cfg_clean_up(client);
6156
6157 if (client->proto == ZEBRA_ROUTE_PIM)
6158 return zebra_evpn_pim_cfg_clean_up(client);
6159
6160 return 0;
6161 }
6162
6163 /*
6164 * Handle results for vxlan dataplane operations.
6165 */
6166 extern void zebra_vxlan_handle_result(struct zebra_dplane_ctx *ctx)
6167 {
6168 return;
6169 }
6170
6171 /* Config knob for accepting lower sequence numbers */
6172 void zebra_vxlan_set_accept_bgp_seq(bool set)
6173 {
6174 accept_bgp_seq = set;
6175 }
6176
6177 bool zebra_vxlan_get_accept_bgp_seq(void)
6178 {
6179 return accept_bgp_seq;
6180 }
6181
6182 /* Cleanup BGP EVPN configuration upon client disconnect */
6183 extern void zebra_evpn_init(void)
6184 {
6185 hook_register(zserv_client_close, zebra_evpn_cfg_clean_up);
6186 }
FRRouting mirror