]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_evpn.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
zebra: Handle vni determination for non-vlan-aware bridges
[mirror_frr.git] / zebra / zebra_evpn.c
1 /*
2 * Zebra EVPN for VxLAN code
3 * Copyright (C) 2016, 2017 Cumulus Networks, Inc.
4 *
5 * This file is part of FRR.
6 *
7 * FRR is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * FRR is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with FRR; see the file COPYING. If not, write to the Free
19 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 * 02111-1307, USA.
21 */
22 #include <zebra.h>
23
24 #include "hash.h"
25 #include "if.h"
26 #include "jhash.h"
27 #include "linklist.h"
28 #include "log.h"
29 #include "memory.h"
30 #include "prefix.h"
31 #include "stream.h"
32 #include "table.h"
33 #include "vlan.h"
34 #include "vxlan.h"
35 #ifdef GNU_LINUX
36 #include <linux/neighbour.h>
37 #endif
38
39 #include "zebra/zebra_router.h"
40 #include "zebra/debug.h"
41 #include "zebra/interface.h"
42 #include "zebra/rib.h"
43 #include "zebra/rt.h"
44 #include "zebra/rt_netlink.h"
45 #include "zebra/zebra_errors.h"
46 #include "zebra/zebra_l2.h"
47 #include "zebra/zebra_l2_bridge_if.h"
48 #include "zebra/zebra_ns.h"
49 #include "zebra/zebra_vrf.h"
50 #include "zebra/zebra_vxlan.h"
51 #include "zebra/zebra_vxlan_private.h"
52 #include "zebra/zebra_evpn.h"
53 #include "zebra/zebra_evpn_mac.h"
54 #include "zebra/zebra_evpn_neigh.h"
55 #include "zebra/zebra_evpn_mh.h"
56 #include "zebra/zebra_evpn_vxlan.h"
57 #include "zebra/zebra_router.h"
58
59 DEFINE_MTYPE_STATIC(ZEBRA, ZEVPN, "VNI hash");
60 DEFINE_MTYPE_STATIC(ZEBRA, ZEVPN_VTEP, "VNI remote VTEP");
61
62 /* PMSI strings. */
63 #define VXLAN_FLOOD_STR_NO_INFO "-"
64 #define VXLAN_FLOOD_STR_DEFAULT VXLAN_FLOOD_STR_NO_INFO
65 static const struct message zvtep_flood_str[] = {
66 {VXLAN_FLOOD_DISABLED, VXLAN_FLOOD_STR_NO_INFO},
67 {VXLAN_FLOOD_PIM_SM, "PIM-SM"},
68 {VXLAN_FLOOD_HEAD_END_REPL, "HER"},
69 {0}
70 };
71
72 int advertise_gw_macip_enabled(struct zebra_evpn *zevpn)
73 {
74 struct zebra_vrf *zvrf;
75
76 zvrf = zebra_vrf_get_evpn();
77 if (zvrf->advertise_gw_macip)
78 return 1;
79
80 if (zevpn && zevpn->advertise_gw_macip)
81 return 1;
82
83 return 0;
84 }
85
86 int advertise_svi_macip_enabled(struct zebra_evpn *zevpn)
87 {
88 struct zebra_vrf *zvrf;
89
90 zvrf = zebra_vrf_get_evpn();
91 if (zvrf->advertise_svi_macip)
92 return 1;
93
94 if (zevpn && zevpn->advertise_svi_macip)
95 return 1;
96
97 return 0;
98 }
99
100 /*
101 * Print a specific EVPN entry.
102 */
103 void zebra_evpn_print(struct zebra_evpn *zevpn, void **ctxt)
104 {
105
106 struct vty *vty = NULL;
107 struct zebra_vtep *zvtep = NULL;
108 uint32_t num_macs = 0;
109 uint32_t num_neigh = 0;
110 uint32_t num_vteps = 0;
111 json_object *json = NULL;
112 json_object *json_vtep_list = NULL;
113 json_object *json_vtep = NULL;
114
115 vty = ctxt[0];
116 json = ctxt[1];
117
118 if (json == NULL) {
119 vty_out(vty, "VNI: %u\n", zevpn->vni);
120 vty_out(vty, " Type: %s\n", "L2");
121 vty_out(vty, " Vlan: %u\n", zevpn->vid);
122 vty_out(vty, " Bridge: %s\n",
123 zevpn->bridge_if ? zevpn->bridge_if->name : "-");
124 vty_out(vty, " Tenant VRF: %s\n", vrf_id_to_name(zevpn->vrf_id));
125 } else {
126 json_object_int_add(json, "vni", zevpn->vni);
127 json_object_string_add(json, "type", "L2");
128 #if CONFDATE > 20240210
129 CPP_NOTICE("Drop `vrf` from JSON output")
130 #endif
131 json_object_string_add(json, "vrf",
132 vrf_id_to_name(zevpn->vrf_id));
133 json_object_string_add(json, "tenantVrf",
134 vrf_id_to_name(zevpn->vrf_id));
135 }
136
137 if (!zevpn->vxlan_if) { // unexpected
138 if (json == NULL)
139 vty_out(vty, " VxLAN interface: unknown\n");
140 else
141 json_object_string_add(json, "vxlanInterface",
142 "unknown");
143 return;
144 }
145 num_macs = num_valid_macs(zevpn);
146 num_neigh = hashcount(zevpn->neigh_table);
147 if (json == NULL) {
148 vty_out(vty, " VxLAN interface: %s\n", zevpn->vxlan_if->name);
149 vty_out(vty, " VxLAN ifIndex: %u\n", zevpn->vxlan_if->ifindex);
150 vty_out(vty, " SVI interface: %s\n",
151 (zevpn->svi_if ? zevpn->svi_if->name : ""));
152 vty_out(vty, " SVI ifIndex: %u\n",
153 (zevpn->svi_if ? zevpn->svi_if->ifindex : 0));
154 vty_out(vty, " Local VTEP IP: %pI4\n",
155 &zevpn->local_vtep_ip);
156 vty_out(vty, " Mcast group: %pI4\n",
157 &zevpn->mcast_grp);
158 } else {
159 json_object_string_add(json, "vxlanInterface",
160 zevpn->vxlan_if->name);
161 #if CONFDATE > 20240210
162 CPP_NOTICE("Drop `ifindex` from JSON output")
163 #endif
164 json_object_int_add(json, "ifindex", zevpn->vxlan_if->ifindex);
165 json_object_int_add(json, "vxlanIfindex",
166 zevpn->vxlan_if->ifindex);
167 if (zevpn->svi_if) {
168 json_object_string_add(json, "sviInterface",
169 zevpn->svi_if->name);
170 json_object_int_add(json, "sviIfindex",
171 zevpn->svi_if->ifindex);
172 }
173 json_object_string_addf(json, "vtepIp", "%pI4",
174 &zevpn->local_vtep_ip);
175 json_object_string_addf(json, "mcastGroup", "%pI4",
176 &zevpn->mcast_grp);
177 json_object_string_add(json, "advertiseGatewayMacip",
178 zevpn->advertise_gw_macip ? "Yes"
179 : "No");
180 json_object_string_add(json, "advertiseSviMacip",
181 zevpn->advertise_svi_macip ? "Yes"
182 : "No");
183 json_object_int_add(json, "numMacs", num_macs);
184 json_object_int_add(json, "numArpNd", num_neigh);
185 }
186 if (!zevpn->vteps) {
187 if (json == NULL)
188 vty_out(vty, " No remote VTEPs known for this VNI\n");
189 else
190 json_object_int_add(json, "numRemoteVteps", num_vteps);
191 } else {
192 if (json == NULL)
193 vty_out(vty, " Remote VTEPs for this VNI:\n");
194 else
195 json_vtep_list = json_object_new_array();
196 for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
197 const char *flood_str = lookup_msg(
198 zvtep_flood_str, zvtep->flood_control,
199 VXLAN_FLOOD_STR_DEFAULT);
200
201 if (json == NULL) {
202 vty_out(vty, " %pI4 flood: %s\n",
203 &zvtep->vtep_ip,
204 flood_str);
205 } else {
206 json_vtep = json_object_new_object();
207 json_object_string_addf(json_vtep, "ip", "%pI4",
208 &zvtep->vtep_ip);
209 json_object_string_add(json_vtep, "flood",
210 flood_str);
211 json_object_array_add(json_vtep_list,
212 json_vtep);
213 }
214 num_vteps++;
215 }
216 if (json) {
217 json_object_int_add(json, "numRemoteVteps", num_vteps);
218 json_object_object_add(json, "remoteVteps",
219 json_vtep_list);
220 }
221 }
222 if (json == NULL) {
223 vty_out(vty,
224 " Number of MACs (local and remote) known for this VNI: %u\n",
225 num_macs);
226 vty_out(vty,
227 " Number of ARPs (IPv4 and IPv6, local and remote) "
228 "known for this VNI: %u\n",
229 num_neigh);
230 vty_out(vty, " Advertise-gw-macip: %s\n",
231 zevpn->advertise_gw_macip ? "Yes" : "No");
232 vty_out(vty, " Advertise-svi-macip: %s\n",
233 zevpn->advertise_svi_macip ? "Yes" : "No");
234 }
235 }
236
237 /*
238 * Print an EVPN hash entry - called for display of all VNIs.
239 */
240 void zebra_evpn_print_hash(struct hash_bucket *bucket, void *ctxt[])
241 {
242 struct vty *vty;
243 struct zebra_evpn *zevpn;
244 struct zebra_vtep *zvtep;
245 uint32_t num_vteps = 0;
246 uint32_t num_macs = 0;
247 uint32_t num_neigh = 0;
248 json_object *json = NULL;
249 json_object *json_evpn = NULL;
250 json_object *json_ip_str = NULL;
251 json_object *json_vtep_list = NULL;
252 char buf[PREFIX_STRLEN];
253
254 vty = ctxt[0];
255 json = ctxt[1];
256
257 zevpn = (struct zebra_evpn *)bucket->data;
258
259 zvtep = zevpn->vteps;
260 while (zvtep) {
261 num_vteps++;
262 zvtep = zvtep->next;
263 }
264
265 num_macs = num_valid_macs(zevpn);
266 num_neigh = hashcount(zevpn->neigh_table);
267 if (json == NULL)
268 vty_out(vty, "%-10u %-4s %-21s %-8u %-8u %-15u %-37s\n",
269 zevpn->vni, "L2",
270 zevpn->vxlan_if ? zevpn->vxlan_if->name : "unknown",
271 num_macs, num_neigh, num_vteps,
272 vrf_id_to_name(zevpn->vrf_id));
273 else {
274 char vni_str[VNI_STR_LEN];
275 snprintf(vni_str, VNI_STR_LEN, "%u", zevpn->vni);
276 json_evpn = json_object_new_object();
277 json_object_int_add(json_evpn, "vni", zevpn->vni);
278 json_object_string_add(json_evpn, "type", "L2");
279 json_object_string_add(json_evpn, "vxlanIf",
280 zevpn->vxlan_if ? zevpn->vxlan_if->name
281 : "unknown");
282 json_object_int_add(json_evpn, "numMacs", num_macs);
283 json_object_int_add(json_evpn, "numArpNd", num_neigh);
284 json_object_int_add(json_evpn, "numRemoteVteps", num_vteps);
285 json_object_string_add(json_evpn, "tenantVrf",
286 vrf_id_to_name(zevpn->vrf_id));
287 if (num_vteps) {
288 json_vtep_list = json_object_new_array();
289 for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
290 json_ip_str = json_object_new_string(
291 inet_ntop(AF_INET, &zvtep->vtep_ip, buf,
292 sizeof(buf)));
293 json_object_array_add(json_vtep_list,
294 json_ip_str);
295 }
296 json_object_object_add(json_evpn, "remoteVteps",
297 json_vtep_list);
298 }
299 json_object_object_add(json, vni_str, json_evpn);
300 }
301 }
302
303 /*
304 * Print an EVPN hash entry in detail - called for display of all EVPNs.
305 */
306 void zebra_evpn_print_hash_detail(struct hash_bucket *bucket, void *data)
307 {
308 struct vty *vty;
309 struct zebra_evpn *zevpn;
310 json_object *json_array = NULL;
311 bool use_json = false;
312 struct zebra_evpn_show *zes = data;
313
314 vty = zes->vty;
315 json_array = zes->json;
316 use_json = zes->use_json;
317
318 zevpn = (struct zebra_evpn *)bucket->data;
319
320 zebra_vxlan_print_vni(vty, zes->zvrf, zevpn->vni, use_json, json_array);
321
322 if (!use_json)
323 vty_out(vty, "\n");
324 }
325
326 int zebra_evpn_del_macip_for_intf(struct interface *ifp,
327 struct zebra_evpn *zevpn)
328 {
329 struct listnode *cnode = NULL, *cnnode = NULL;
330 struct connected *c = NULL;
331 struct ethaddr macaddr;
332
333 memcpy(&macaddr.octet, ifp->hw_addr, ETH_ALEN);
334
335 for (ALL_LIST_ELEMENTS(ifp->connected, cnode, cnnode, c)) {
336 struct ipaddr ip;
337
338 memset(&ip, 0, sizeof(struct ipaddr));
339 if (!CHECK_FLAG(c->conf, ZEBRA_IFC_REAL))
340 continue;
341
342 if (c->address->family == AF_INET) {
343 ip.ipa_type = IPADDR_V4;
344 memcpy(&(ip.ipaddr_v4), &(c->address->u.prefix4),
345 sizeof(struct in_addr));
346 } else if (c->address->family == AF_INET6) {
347 ip.ipa_type = IPADDR_V6;
348 memcpy(&(ip.ipaddr_v6), &(c->address->u.prefix6),
349 sizeof(struct in6_addr));
350 } else {
351 continue;
352 }
353
354 zebra_evpn_gw_macip_del(ifp, zevpn, &ip);
355 }
356
357 return 0;
358 }
359
360 int zebra_evpn_add_macip_for_intf(struct interface *ifp,
361 struct zebra_evpn *zevpn)
362 {
363 struct listnode *cnode = NULL, *cnnode = NULL;
364 struct connected *c = NULL;
365 struct ethaddr macaddr;
366
367 memcpy(&macaddr.octet, ifp->hw_addr, ETH_ALEN);
368
369 for (ALL_LIST_ELEMENTS(ifp->connected, cnode, cnnode, c)) {
370 struct ipaddr ip;
371
372 if (!CHECK_FLAG(c->conf, ZEBRA_IFC_REAL))
373 continue;
374
375 memset(&ip, 0, sizeof(struct ipaddr));
376 if (c->address->family == AF_INET) {
377 ip.ipa_type = IPADDR_V4;
378 memcpy(&(ip.ipaddr_v4), &(c->address->u.prefix4),
379 sizeof(struct in_addr));
380 } else if (c->address->family == AF_INET6) {
381 ip.ipa_type = IPADDR_V6;
382 memcpy(&(ip.ipaddr_v6), &(c->address->u.prefix6),
383 sizeof(struct in6_addr));
384 } else {
385 continue;
386 }
387
388 zebra_evpn_gw_macip_add(ifp, zevpn, &macaddr, &ip);
389 }
390 return 0;
391 }
392
393 static int ip_prefix_send_to_client(vrf_id_t vrf_id, struct prefix *p,
394 uint16_t cmd)
395 {
396 struct zserv *client = NULL;
397 struct stream *s = NULL;
398
399 client = zserv_find_client(ZEBRA_ROUTE_BGP, 0);
400 /* BGP may not be running. */
401 if (!client)
402 return 0;
403
404 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
405
406 zclient_create_header(s, cmd, vrf_id);
407 stream_put(s, p, sizeof(struct prefix));
408
409 /* Write packet size. */
410 stream_putw_at(s, 0, stream_get_endp(s));
411
412 if (IS_ZEBRA_DEBUG_VXLAN)
413 zlog_debug("Send ip prefix %pFX %s on vrf %s", p,
414 (cmd == ZEBRA_IP_PREFIX_ROUTE_ADD) ? "ADD" : "DEL",
415 vrf_id_to_name(vrf_id));
416
417 if (cmd == ZEBRA_IP_PREFIX_ROUTE_ADD)
418 client->prefixadd_cnt++;
419 else
420 client->prefixdel_cnt++;
421
422 return zserv_send_message(client, s);
423 }
424
425 int zebra_evpn_advertise_subnet(struct zebra_evpn *zevpn, struct interface *ifp,
426 int advertise)
427 {
428 struct listnode *cnode = NULL, *cnnode = NULL;
429 struct connected *c = NULL;
430 struct ethaddr macaddr;
431
432 memcpy(&macaddr.octet, ifp->hw_addr, ETH_ALEN);
433
434 for (ALL_LIST_ELEMENTS(ifp->connected, cnode, cnnode, c)) {
435 struct prefix p;
436
437 memcpy(&p, c->address, sizeof(struct prefix));
438
439 /* skip link local address */
440 if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
441 continue;
442
443 apply_mask(&p);
444 if (advertise)
445 ip_prefix_send_to_client(ifp->vrf->vrf_id, &p,
446 ZEBRA_IP_PREFIX_ROUTE_ADD);
447 else
448 ip_prefix_send_to_client(ifp->vrf->vrf_id, &p,
449 ZEBRA_IP_PREFIX_ROUTE_DEL);
450 }
451 return 0;
452 }
453
454 /*
455 * zebra_evpn_gw_macip_add_to_client
456 */
457 int zebra_evpn_gw_macip_add(struct interface *ifp, struct zebra_evpn *zevpn,
458 struct ethaddr *macaddr, struct ipaddr *ip)
459 {
460 struct zebra_mac *mac = NULL;
461 struct zebra_if *zif = NULL;
462 struct zebra_vxlan_vni *vni;
463
464 zif = zevpn->vxlan_if->info;
465 if (!zif)
466 return -1;
467
468 vni = zebra_vxlan_if_vni_find(zif, zevpn->vni);
469
470 zebra_evpn_mac_gw_macip_add(ifp, zevpn, ip, &mac, macaddr,
471 vni->access_vlan, true);
472
473 return zebra_evpn_neigh_gw_macip_add(ifp, zevpn, ip, mac);
474 }
475
476 /*
477 * zebra_evpn_gw_macip_del_from_client
478 */
479 int zebra_evpn_gw_macip_del(struct interface *ifp, struct zebra_evpn *zevpn,
480 struct ipaddr *ip)
481 {
482 struct zebra_neigh *n = NULL;
483 struct zebra_mac *mac = NULL;
484
485 /* If the neigh entry is not present nothing to do*/
486 n = zebra_evpn_neigh_lookup(zevpn, ip);
487 if (!n)
488 return 0;
489
490 /* mac entry should be present */
491 mac = zebra_evpn_mac_lookup(zevpn, &n->emac);
492 if (!mac) {
493 if (IS_ZEBRA_DEBUG_VXLAN)
494 zlog_debug("MAC %pEA doesn't exist for neigh %pIA on VNI %u",
495 &n->emac, ip, zevpn->vni);
496 return -1;
497 }
498
499 /* If the entry is not local nothing to do*/
500 if (!CHECK_FLAG(n->flags, ZEBRA_NEIGH_LOCAL))
501 return -1;
502
503 /* only need to delete the entry from bgp if we sent it before */
504 if (IS_ZEBRA_DEBUG_VXLAN)
505 zlog_debug(
506 "%u:SVI %s(%u) VNI %u, sending GW MAC %pEA IP %pIA del to BGP",
507 ifp->vrf->vrf_id, ifp->name, ifp->ifindex, zevpn->vni,
508 &n->emac, ip);
509
510 /* Remove neighbor from BGP. */
511 zebra_evpn_neigh_send_del_to_client(zevpn->vni, &n->ip, &n->emac,
512 n->flags, ZEBRA_NEIGH_ACTIVE,
513 false /*force*/);
514
515 /* Delete this neighbor entry. */
516 zebra_evpn_neigh_del(zevpn, n);
517
518 /* see if the mac needs to be deleted as well*/
519 if (mac)
520 zebra_evpn_deref_ip2mac(zevpn, mac);
521
522 return 0;
523 }
524
525 void zebra_evpn_gw_macip_del_for_evpn_hash(struct hash_bucket *bucket,
526 void *ctxt)
527 {
528 struct zebra_evpn *zevpn = NULL;
529 struct zebra_if *zif = NULL;
530 struct zebra_vxlan_vni *vni = NULL;
531 struct interface *vlan_if = NULL;
532 struct interface *vrr_if = NULL;
533 struct interface *ifp;
534
535 /* Add primary SVI MAC*/
536 zevpn = (struct zebra_evpn *)bucket->data;
537
538 /* Global (Zvrf) advertise-default-gw is disabled,
539 * but zevpn advertise-default-gw is enabled
540 */
541 if (zevpn->advertise_gw_macip) {
542 if (IS_ZEBRA_DEBUG_VXLAN)
543 zlog_debug("VNI: %u GW-MACIP enabled, retain gw-macip",
544 zevpn->vni);
545 return;
546 }
547
548 ifp = zevpn->vxlan_if;
549 if (!ifp)
550 return;
551 zif = ifp->info;
552
553 /* If down or not mapped to a bridge, we're done. */
554 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
555 return;
556
557 vni = zebra_vxlan_if_vni_find(zif, zevpn->vni);
558 if (!vni)
559 return;
560
561 vlan_if = zvni_map_to_svi(vni->access_vlan, zif->brslave_info.br_if);
562 if (!vlan_if)
563 return;
564
565 /* Del primary MAC-IP */
566 zebra_evpn_del_macip_for_intf(vlan_if, zevpn);
567
568 /* Del VRR MAC-IP - if any*/
569 vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
570 if (vrr_if)
571 zebra_evpn_del_macip_for_intf(vrr_if, zevpn);
572
573 return;
574 }
575
576 void zebra_evpn_gw_macip_add_for_evpn_hash(struct hash_bucket *bucket,
577 void *ctxt)
578 {
579 struct zebra_evpn *zevpn = NULL;
580 struct zebra_if *zif = NULL;
581 struct interface *vlan_if = NULL;
582 struct interface *vrr_if = NULL;
583 struct interface *ifp = NULL;
584 struct zebra_vxlan_vni *vni = NULL;
585
586 zevpn = (struct zebra_evpn *)bucket->data;
587
588 ifp = zevpn->vxlan_if;
589 if (!ifp)
590 return;
591 zif = ifp->info;
592
593 /* If down or not mapped to a bridge, we're done. */
594 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
595 return;
596 vni = zebra_vxlan_if_vni_find(zif, zevpn->vni);
597 if (!vni)
598 return;
599
600 vlan_if = zvni_map_to_svi(vni->access_vlan, zif->brslave_info.br_if);
601 if (!vlan_if)
602 return;
603
604 /* Add primary SVI MAC-IP */
605 if (advertise_svi_macip_enabled(zevpn)
606 || advertise_gw_macip_enabled(zevpn))
607 zebra_evpn_add_macip_for_intf(vlan_if, zevpn);
608
609 if (advertise_gw_macip_enabled(zevpn)) {
610 /* Add VRR MAC-IP - if any*/
611 vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
612 if (vrr_if)
613 zebra_evpn_add_macip_for_intf(vrr_if, zevpn);
614 }
615
616 return;
617 }
618
619 void zebra_evpn_svi_macip_del_for_evpn_hash(struct hash_bucket *bucket,
620 void *ctxt)
621 {
622 struct zebra_evpn *zevpn = NULL;
623 struct zebra_if *zif = NULL;
624 struct interface *vlan_if = NULL;
625 struct zebra_vxlan_vni *vni = NULL;
626 struct interface *ifp;
627
628 /* Add primary SVI MAC*/
629 zevpn = (struct zebra_evpn *)bucket->data;
630 if (!zevpn)
631 return;
632
633 /* Global(vrf) advertise-svi-ip disabled, but zevpn advertise-svi-ip
634 * enabled
635 */
636 if (zevpn->advertise_svi_macip) {
637 if (IS_ZEBRA_DEBUG_VXLAN)
638 zlog_debug("VNI: %u SVI-MACIP enabled, retain svi-macip",
639 zevpn->vni);
640 return;
641 }
642
643 ifp = zevpn->vxlan_if;
644 if (!ifp)
645 return;
646 zif = ifp->info;
647
648 /* If down or not mapped to a bridge, we're done. */
649 if (!if_is_operative(ifp) || !zif->brslave_info.br_if)
650 return;
651
652 vni = zebra_vxlan_if_vni_find(zif, zevpn->vni);
653 if (!vni)
654 return;
655
656 vlan_if = zvni_map_to_svi(vni->access_vlan, zif->brslave_info.br_if);
657 if (!vlan_if)
658 return;
659
660 /* Del primary MAC-IP */
661 zebra_evpn_del_macip_for_intf(vlan_if, zevpn);
662
663 return;
664 }
665
666 static int zebra_evpn_map_vlan_ns(struct ns *ns,
667 void *_in_param,
668 void **_p_zevpn)
669 {
670 int found = 0;
671 struct zebra_ns *zns = ns->info;
672 struct route_node *rn;
673 struct interface *br_if;
674 struct zebra_evpn **p_zevpn = (struct zebra_evpn **)_p_zevpn;
675 struct zebra_evpn *zevpn;
676 struct interface *tmp_if = NULL;
677 struct zebra_if *zif;
678 struct zebra_from_svi_param *in_param =
679 (struct zebra_from_svi_param *)_in_param;
680 vlanid_t vid;
681 vni_t vni_id = 0;
682 uint8_t bridge_vlan_aware;
683
684 assert(p_zevpn && in_param);
685
686 br_if = in_param->br_if;
687 assert(br_if);
688 zif = in_param->zif;
689 assert(zif);
690 vid = in_param->vid;
691 bridge_vlan_aware = in_param->bridge_vlan_aware;
692
693 if (bridge_vlan_aware) {
694 vni_id = zebra_l2_bridge_if_vni_find(zif, vid);
695 if (vni_id)
696 found = 1;
697 } else {
698 /* See if this interface (or interface plus VLAN Id) maps to a
699 * VxLAN */
700 /* TODO: Optimize with a hash. */
701 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
702 tmp_if = (struct interface *)rn->info;
703 if (!tmp_if)
704 continue;
705 zif = tmp_if->info;
706 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
707 continue;
708 if (!if_is_operative(tmp_if))
709 continue;
710
711 if (zif->brslave_info.br_if != br_if)
712 continue;
713
714 vni_id =
715 zebra_vxlan_if_access_vlan_vni_find(zif, br_if);
716 if (vni_id) {
717 found = 1;
718 break;
719 }
720 }
721 }
722
723 if (!found)
724 return NS_WALK_CONTINUE;
725
726 zevpn = zebra_evpn_lookup(vni_id);
727 *p_zevpn = zevpn;
728 return NS_WALK_STOP;
729 }
730
731 /*
732 * Map port or (port, VLAN) to an EVPN. This is invoked upon getting MAC
733 * notifications, to see if they are of interest.
734 */
735 struct zebra_evpn *zebra_evpn_map_vlan(struct interface *ifp,
736 struct interface *br_if, vlanid_t vid)
737 {
738 struct zebra_if *zif;
739 struct zebra_evpn **p_zevpn;
740 struct zebra_evpn *zevpn = NULL;
741 struct zebra_from_svi_param in_param;
742
743 /* Determine if bridge is VLAN-aware or not */
744 zif = br_if->info;
745 assert(zif);
746 in_param.bridge_vlan_aware = IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(zif);
747 in_param.vid = vid;
748 in_param.br_if = br_if;
749 in_param.zif = zif;
750 p_zevpn = &zevpn;
751
752 ns_walk_func(zebra_evpn_map_vlan_ns,
753 (void *)&in_param,
754 (void **)p_zevpn);
755 return zevpn;
756 }
757
758 static int zebra_evpn_from_svi_ns(struct ns *ns,
759 void *_in_param,
760 void **_p_zevpn)
761 {
762 struct zebra_ns *zns = ns->info;
763 struct route_node *rn;
764 struct interface *br_if;
765 struct zebra_evpn **p_zevpn = (struct zebra_evpn **)_p_zevpn;
766 struct zebra_evpn *zevpn;
767 struct interface *tmp_if = NULL;
768 struct zebra_if *zif;
769 struct zebra_if *br_zif;
770 struct zebra_l2_bridge_vlan *bvlan;
771 struct zebra_from_svi_param *in_param =
772 (struct zebra_from_svi_param *)_in_param;
773 int found = 0;
774 vni_t vni_id = 0;
775 vlanid_t vid = 0;
776 uint8_t bridge_vlan_aware;
777
778 if (!in_param)
779 return NS_WALK_STOP;
780
781 br_if = in_param->br_if;
782 zif = in_param->zif;
783 assert(zif);
784 bridge_vlan_aware = in_param->bridge_vlan_aware;
785 vid = in_param->vid;
786 br_zif = br_if->info;
787 assert(br_zif);
788
789 if (bridge_vlan_aware) {
790 bvlan = zebra_l2_bridge_if_vlan_find(br_zif, vid);
791 if (bvlan && bvlan->access_bd && bvlan->access_bd->vni) {
792 found = 1;
793 vni_id = bvlan->access_bd->vni;
794 }
795 } else {
796 /* TODO: Optimize with a hash. */
797 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
798 tmp_if = (struct interface *)rn->info;
799 if (!tmp_if)
800 continue;
801 zif = tmp_if->info;
802 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
803 continue;
804 if (!if_is_operative(tmp_if))
805 continue;
806
807 if (zif->brslave_info.br_if != br_if)
808 continue;
809
810 vni_id =
811 zebra_vxlan_if_access_vlan_vni_find(zif, br_if);
812 if (vni_id) {
813 found = 1;
814 break;
815 }
816 }
817 }
818
819 if (!found)
820 return NS_WALK_CONTINUE;
821
822 zevpn = zebra_evpn_lookup(vni_id);
823 if (p_zevpn)
824 *p_zevpn = zevpn;
825 return NS_WALK_STOP;
826 }
827
828 /*
829 * Map SVI and associated bridge to an EVPN. This is invoked upon getting
830 * neighbor notifications, to see if they are of interest.
831 */
832 struct zebra_evpn *zebra_evpn_from_svi(struct interface *ifp,
833 struct interface *br_if)
834 {
835 struct zebra_evpn *zevpn = NULL;
836 struct zebra_evpn **p_zevpn;
837 struct zebra_if *zif;
838 struct zebra_from_svi_param in_param;
839
840 if (!br_if)
841 return NULL;
842
843 /* Make sure the linked interface is a bridge. */
844 if (!IS_ZEBRA_IF_BRIDGE(br_if))
845 return NULL;
846
847 /* Determine if bridge is VLAN-aware or not */
848 zif = br_if->info;
849 assert(zif);
850 in_param.bridge_vlan_aware = IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(zif);
851 in_param.vid = 0;
852
853 if (in_param.bridge_vlan_aware) {
854 struct zebra_l2info_vlan *vl;
855
856 if (!IS_ZEBRA_IF_VLAN(ifp))
857 return NULL;
858
859 zif = ifp->info;
860 assert(zif);
861 vl = &zif->l2info.vl;
862 in_param.vid = vl->vid;
863 }
864
865 in_param.br_if = br_if;
866 in_param.zif = zif;
867 p_zevpn = &zevpn;
868 /* See if this interface (or interface plus VLAN Id) maps to a VxLAN */
869 ns_walk_func(zebra_evpn_from_svi_ns, (void *)&in_param,
870 (void **)p_zevpn);
871 return zevpn;
872 }
873
874 static int zvni_map_to_macvlan_ns(struct ns *ns,
875 void *_in_param,
876 void **_p_ifp)
877 {
878 struct zebra_ns *zns = ns->info;
879 struct zebra_from_svi_param *in_param =
880 (struct zebra_from_svi_param *)_in_param;
881 struct interface **p_ifp = (struct interface **)_p_ifp;
882 struct route_node *rn;
883 struct interface *tmp_if = NULL;
884 struct zebra_if *zif;
885
886 assert(in_param && p_ifp);
887
888 /* Identify corresponding VLAN interface. */
889 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
890 tmp_if = (struct interface *)rn->info;
891 /* Check oper status of the SVI. */
892 if (!tmp_if || !if_is_operative(tmp_if))
893 continue;
894 zif = tmp_if->info;
895
896 if (!zif || zif->zif_type != ZEBRA_IF_MACVLAN)
897 continue;
898
899 if (zif->link == in_param->svi_if) {
900 *p_ifp = tmp_if;
901 return NS_WALK_STOP;
902 }
903 }
904
905 return NS_WALK_CONTINUE;
906 }
907
908 /* Map to MAC-VLAN interface corresponding to specified SVI interface.
909 */
910 struct interface *zebra_evpn_map_to_macvlan(struct interface *br_if,
911 struct interface *svi_if)
912 {
913 struct interface *tmp_if = NULL;
914 struct zebra_if *zif;
915 struct interface **p_ifp;
916 struct zebra_from_svi_param in_param;
917
918 /* Defensive check, caller expected to invoke only with valid bridge. */
919 if (!br_if)
920 return NULL;
921
922 if (!svi_if) {
923 zlog_debug("svi_if is not passed.");
924 return NULL;
925 }
926
927 /* Determine if bridge is VLAN-aware or not */
928 zif = br_if->info;
929 assert(zif);
930
931 in_param.vid = 0;
932 in_param.br_if = br_if;
933 in_param.zif = NULL;
934 in_param.svi_if = svi_if;
935 p_ifp = &tmp_if;
936
937 /* Identify corresponding VLAN interface. */
938 ns_walk_func(zvni_map_to_macvlan_ns,
939 (void *)&in_param,
940 (void **)p_ifp);
941 return tmp_if;
942 }
943
944 /*
945 * Install MAC hash entry - called upon access VLAN change.
946 */
947 void zebra_evpn_install_mac_hash(struct hash_bucket *bucket, void *ctxt)
948 {
949 struct zebra_mac *mac;
950 struct mac_walk_ctx *wctx = ctxt;
951
952 mac = (struct zebra_mac *)bucket->data;
953
954 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE))
955 zebra_evpn_rem_mac_install(wctx->zevpn, mac, false);
956 }
957
958 /*
959 * Read and populate local MACs and neighbors corresponding to this EVPN.
960 */
961 void zebra_evpn_read_mac_neigh(struct zebra_evpn *zevpn, struct interface *ifp)
962 {
963 struct zebra_ns *zns;
964 struct zebra_vrf *zvrf;
965 struct zebra_if *zif;
966 struct interface *vlan_if;
967 struct zebra_vxlan_vni *vni;
968 struct interface *vrr_if;
969
970 zif = ifp->info;
971 vni = zebra_vxlan_if_vni_find(zif, zevpn->vni);
972 zvrf = zebra_vrf_lookup_by_id(zevpn->vrf_id);
973 if (!zvrf || !zvrf->zns)
974 return;
975 zns = zvrf->zns;
976
977 if (IS_ZEBRA_DEBUG_VXLAN)
978 zlog_debug(
979 "Reading MAC FDB and Neighbors for intf %s(%u) VNI %u master %u",
980 ifp->name, ifp->ifindex, zevpn->vni,
981 zif->brslave_info.bridge_ifindex);
982
983 macfdb_read_for_bridge(zns, ifp, zif->brslave_info.br_if,
984 vni->access_vlan);
985 vlan_if = zvni_map_to_svi(vni->access_vlan, zif->brslave_info.br_if);
986 if (vlan_if) {
987 /* Add SVI MAC */
988 zebra_evpn_acc_bd_svi_mac_add(vlan_if);
989
990 /* Add SVI MAC-IP */
991 if (advertise_svi_macip_enabled(zevpn)
992 || advertise_gw_macip_enabled(zevpn))
993 zebra_evpn_add_macip_for_intf(vlan_if, zevpn);
994
995 /* Add VRR MAC-IP - if any*/
996 if (advertise_gw_macip_enabled(zevpn)) {
997 vrr_if = zebra_get_vrr_intf_for_svi(vlan_if);
998 if (vrr_if)
999 zebra_evpn_add_macip_for_intf(vrr_if, zevpn);
1000 }
1001
1002 neigh_read_for_vlan(zns, vlan_if);
1003 }
1004 }
1005
1006 /*
1007 * Hash function for EVPN.
1008 */
1009 unsigned int zebra_evpn_hash_keymake(const void *p)
1010 {
1011 const struct zebra_evpn *zevpn = p;
1012
1013 return (jhash_1word(zevpn->vni, 0));
1014 }
1015
1016 /*
1017 * Compare 2 evpn hash entries.
1018 */
1019 bool zebra_evpn_hash_cmp(const void *p1, const void *p2)
1020 {
1021 const struct zebra_evpn *zevpn1 = p1;
1022 const struct zebra_evpn *zevpn2 = p2;
1023
1024 return (zevpn1->vni == zevpn2->vni);
1025 }
1026
1027 int zebra_evpn_list_cmp(void *p1, void *p2)
1028 {
1029 const struct zebra_evpn *zevpn1 = p1;
1030 const struct zebra_evpn *zevpn2 = p2;
1031
1032 if (zevpn1->vni == zevpn2->vni)
1033 return 0;
1034 return (zevpn1->vni < zevpn2->vni) ? -1 : 1;
1035 }
1036
1037 /*
1038 * Callback to allocate VNI hash entry.
1039 */
1040 void *zebra_evpn_alloc(void *p)
1041 {
1042 const struct zebra_evpn *tmp_vni = p;
1043 struct zebra_evpn *zevpn;
1044
1045 zevpn = XCALLOC(MTYPE_ZEVPN, sizeof(struct zebra_evpn));
1046 zevpn->vni = tmp_vni->vni;
1047 return ((void *)zevpn);
1048 }
1049
1050 /*
1051 * Look up EVPN hash entry.
1052 */
1053 struct zebra_evpn *zebra_evpn_lookup(vni_t vni)
1054 {
1055 struct zebra_vrf *zvrf;
1056 struct zebra_evpn tmp_vni;
1057 struct zebra_evpn *zevpn = NULL;
1058
1059 zvrf = zebra_vrf_get_evpn();
1060 memset(&tmp_vni, 0, sizeof(tmp_vni));
1061 tmp_vni.vni = vni;
1062 zevpn = hash_lookup(zvrf->evpn_table, &tmp_vni);
1063
1064 return zevpn;
1065 }
1066
1067 /*
1068 * Add EVPN hash entry.
1069 */
1070 struct zebra_evpn *zebra_evpn_add(vni_t vni)
1071 {
1072 char buffer[80];
1073 struct zebra_vrf *zvrf;
1074 struct zebra_evpn tmp_zevpn;
1075 struct zebra_evpn *zevpn = NULL;
1076
1077 zvrf = zebra_vrf_get_evpn();
1078 memset(&tmp_zevpn, 0, sizeof(tmp_zevpn));
1079 tmp_zevpn.vni = vni;
1080 zevpn = hash_get(zvrf->evpn_table, &tmp_zevpn, zebra_evpn_alloc);
1081
1082 zebra_evpn_es_evi_init(zevpn);
1083
1084 snprintf(buffer, sizeof(buffer), "Zebra EVPN MAC Table vni: %u", vni);
1085 /* Create hash table for MAC */
1086 zevpn->mac_table = zebra_mac_db_create(buffer);
1087
1088 snprintf(buffer, sizeof(buffer), "Zebra EVPN Neighbor Table vni: %u",
1089 vni);
1090 /* Create hash table for neighbors */
1091 zevpn->neigh_table = zebra_neigh_db_create(buffer);
1092
1093 return zevpn;
1094 }
1095
1096 /*
1097 * Delete EVPN hash entry.
1098 */
1099 int zebra_evpn_del(struct zebra_evpn *zevpn)
1100 {
1101 struct zebra_vrf *zvrf;
1102 struct zebra_evpn *tmp_zevpn;
1103
1104 zvrf = zebra_vrf_get_evpn();
1105
1106 zevpn->svi_if = NULL;
1107
1108 /* Free the neighbor hash table. */
1109 hash_free(zevpn->neigh_table);
1110 zevpn->neigh_table = NULL;
1111
1112 /* Free the MAC hash table. */
1113 hash_free(zevpn->mac_table);
1114 zevpn->mac_table = NULL;
1115
1116 /* Remove references to the zevpn in the MH databases */
1117 if (zevpn->vxlan_if)
1118 zebra_evpn_vxl_evpn_set(zevpn->vxlan_if->info, zevpn, false);
1119 zebra_evpn_es_evi_cleanup(zevpn);
1120
1121 /* Free the EVPN hash entry and allocated memory. */
1122 tmp_zevpn = hash_release(zvrf->evpn_table, zevpn);
1123 XFREE(MTYPE_ZEVPN, tmp_zevpn);
1124
1125 return 0;
1126 }
1127
1128 /*
1129 * Inform BGP about local EVPN addition.
1130 */
1131 int zebra_evpn_send_add_to_client(struct zebra_evpn *zevpn)
1132 {
1133 struct zserv *client;
1134 struct stream *s;
1135 ifindex_t svi_index;
1136 int rc;
1137
1138 client = zserv_find_client(ZEBRA_ROUTE_BGP, 0);
1139 /* BGP may not be running. */
1140 if (!client)
1141 return 0;
1142
1143 svi_index = zevpn->svi_if ? zevpn->svi_if->ifindex : 0;
1144
1145 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
1146
1147 zclient_create_header(s, ZEBRA_VNI_ADD, zebra_vrf_get_evpn_id());
1148 stream_putl(s, zevpn->vni);
1149 stream_put_in_addr(s, &zevpn->local_vtep_ip);
1150 stream_put(s, &zevpn->vrf_id, sizeof(vrf_id_t)); /* tenant vrf */
1151 stream_put_in_addr(s, &zevpn->mcast_grp);
1152 stream_put(s, &svi_index, sizeof(ifindex_t));
1153
1154 /* Write packet size. */
1155 stream_putw_at(s, 0, stream_get_endp(s));
1156
1157 if (IS_ZEBRA_DEBUG_VXLAN)
1158 zlog_debug(
1159 "Send EVPN_ADD %u %pI4 tenant vrf %s(%u) SVI index %u to %s",
1160 zevpn->vni, &zevpn->local_vtep_ip,
1161 vrf_id_to_name(zevpn->vrf_id), zevpn->vrf_id,
1162 (zevpn->svi_if ? zevpn->svi_if->ifindex : 0),
1163 zebra_route_string(client->proto));
1164
1165 client->vniadd_cnt++;
1166 rc = zserv_send_message(client, s);
1167
1168 if (!(zevpn->flags & ZEVPN_READY_FOR_BGP)) {
1169 zevpn->flags |= ZEVPN_READY_FOR_BGP;
1170 /* once the EVPN is sent the ES-EVIs can also be replayed
1171 * to BGP
1172 */
1173 zebra_evpn_update_all_es(zevpn);
1174 }
1175 return rc;
1176 }
1177
1178 /*
1179 * Inform BGP about local EVPN deletion.
1180 */
1181 int zebra_evpn_send_del_to_client(struct zebra_evpn *zevpn)
1182 {
1183 struct zserv *client;
1184 struct stream *s;
1185
1186 client = zserv_find_client(ZEBRA_ROUTE_BGP, 0);
1187 /* BGP may not be running. */
1188 if (!client)
1189 return 0;
1190
1191 if (zevpn->flags & ZEVPN_READY_FOR_BGP) {
1192 zevpn->flags &= ~ZEVPN_READY_FOR_BGP;
1193 /* the ES-EVIs must be removed from BGP before the EVPN is */
1194 zebra_evpn_update_all_es(zevpn);
1195 }
1196
1197 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
1198 stream_reset(s);
1199
1200 zclient_create_header(s, ZEBRA_VNI_DEL, zebra_vrf_get_evpn_id());
1201 stream_putl(s, zevpn->vni);
1202
1203 /* Write packet size. */
1204 stream_putw_at(s, 0, stream_get_endp(s));
1205
1206 if (IS_ZEBRA_DEBUG_VXLAN)
1207 zlog_debug("Send EVPN_DEL %u to %s", zevpn->vni,
1208 zebra_route_string(client->proto));
1209
1210 client->vnidel_cnt++;
1211 return zserv_send_message(client, s);
1212 }
1213
1214 /*
1215 * See if remote VTEP matches with prefix.
1216 */
1217 static int zebra_evpn_vtep_match(struct in_addr *vtep_ip,
1218 struct zebra_vtep *zvtep)
1219 {
1220 return (IPV4_ADDR_SAME(vtep_ip, &zvtep->vtep_ip));
1221 }
1222
1223 /*
1224 * Locate remote VTEP in EVPN hash table.
1225 */
1226 struct zebra_vtep *zebra_evpn_vtep_find(struct zebra_evpn *zevpn,
1227 struct in_addr *vtep_ip)
1228 {
1229 struct zebra_vtep *zvtep;
1230
1231 if (!zevpn)
1232 return NULL;
1233
1234 for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
1235 if (zebra_evpn_vtep_match(vtep_ip, zvtep))
1236 break;
1237 }
1238
1239 return zvtep;
1240 }
1241
1242 /*
1243 * Add remote VTEP to EVPN hash table.
1244 */
1245 struct zebra_vtep *zebra_evpn_vtep_add(struct zebra_evpn *zevpn,
1246 struct in_addr *vtep_ip,
1247 int flood_control)
1248
1249 {
1250 struct zebra_vtep *zvtep;
1251
1252 zvtep = XCALLOC(MTYPE_ZEVPN_VTEP, sizeof(struct zebra_vtep));
1253
1254 zvtep->vtep_ip = *vtep_ip;
1255 zvtep->flood_control = flood_control;
1256
1257 if (zevpn->vteps)
1258 zevpn->vteps->prev = zvtep;
1259 zvtep->next = zevpn->vteps;
1260 zevpn->vteps = zvtep;
1261
1262 return zvtep;
1263 }
1264
1265 /*
1266 * Remove remote VTEP from EVPN hash table.
1267 */
1268 int zebra_evpn_vtep_del(struct zebra_evpn *zevpn, struct zebra_vtep *zvtep)
1269 {
1270 if (zvtep->next)
1271 zvtep->next->prev = zvtep->prev;
1272 if (zvtep->prev)
1273 zvtep->prev->next = zvtep->next;
1274 else
1275 zevpn->vteps = zvtep->next;
1276
1277 zvtep->prev = zvtep->next = NULL;
1278 XFREE(MTYPE_ZEVPN_VTEP, zvtep);
1279
1280 return 0;
1281 }
1282
1283 /*
1284 * Delete all remote VTEPs for this EVPN (upon VNI delete). Also
1285 * uninstall from kernel if asked to.
1286 */
1287 int zebra_evpn_vtep_del_all(struct zebra_evpn *zevpn, int uninstall)
1288 {
1289 struct zebra_vtep *zvtep, *zvtep_next;
1290
1291 if (!zevpn)
1292 return -1;
1293
1294 for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep_next) {
1295 zvtep_next = zvtep->next;
1296 if (uninstall)
1297 zebra_evpn_vtep_uninstall(zevpn, &zvtep->vtep_ip);
1298 zebra_evpn_vtep_del(zevpn, zvtep);
1299 }
1300
1301 return 0;
1302 }
1303
1304 /*
1305 * Install remote VTEP into the kernel if the remote VTEP has asked
1306 * for head-end-replication.
1307 */
1308 int zebra_evpn_vtep_install(struct zebra_evpn *zevpn, struct zebra_vtep *zvtep)
1309 {
1310 if (is_vxlan_flooding_head_end() &&
1311 (zvtep->flood_control == VXLAN_FLOOD_HEAD_END_REPL)) {
1312 if (ZEBRA_DPLANE_REQUEST_FAILURE ==
1313 dplane_vtep_add(zevpn->vxlan_if,
1314 &zvtep->vtep_ip, zevpn->vni))
1315 return -1;
1316 }
1317
1318 return 0;
1319 }
1320
1321 /*
1322 * Uninstall remote VTEP from the kernel.
1323 */
1324 int zebra_evpn_vtep_uninstall(struct zebra_evpn *zevpn, struct in_addr *vtep_ip)
1325 {
1326 if (!zevpn->vxlan_if) {
1327 zlog_debug("VNI %u hash %p couldn't be uninstalled - no intf",
1328 zevpn->vni, zevpn);
1329 return -1;
1330 }
1331
1332 if (ZEBRA_DPLANE_REQUEST_FAILURE ==
1333 dplane_vtep_delete(zevpn->vxlan_if, vtep_ip, zevpn->vni))
1334 return -1;
1335
1336 return 0;
1337 }
1338
1339 /*
1340 * Install or uninstall flood entries in the kernel corresponding to
1341 * remote VTEPs. This is invoked upon change to BUM handling.
1342 */
1343 void zebra_evpn_handle_flooding_remote_vteps(struct hash_bucket *bucket,
1344 void *zvrf)
1345 {
1346 struct zebra_evpn *zevpn;
1347 struct zebra_vtep *zvtep;
1348
1349 zevpn = (struct zebra_evpn *)bucket->data;
1350 if (!zevpn)
1351 return;
1352
1353 for (zvtep = zevpn->vteps; zvtep; zvtep = zvtep->next) {
1354 if (is_vxlan_flooding_head_end())
1355 zebra_evpn_vtep_install(zevpn, zvtep);
1356 else
1357 zebra_evpn_vtep_uninstall(zevpn, &zvtep->vtep_ip);
1358 }
1359 }
1360
1361 /*
1362 * Cleanup EVPN/VTEP and update kernel
1363 */
1364 void zebra_evpn_cleanup_all(struct hash_bucket *bucket, void *arg)
1365 {
1366 struct zebra_evpn *zevpn = NULL;
1367
1368 zevpn = (struct zebra_evpn *)bucket->data;
1369
1370 /* Free up all neighbors and MACs, if any. */
1371 zebra_evpn_neigh_del_all(zevpn, 1, 0, DEL_ALL_NEIGH);
1372 zebra_evpn_mac_del_all(zevpn, 1, 0, DEL_ALL_MAC);
1373
1374 /* Free up all remote VTEPs, if any. */
1375 zebra_evpn_vtep_del_all(zevpn, 1);
1376
1377 /* Delete the hash entry. */
1378 zebra_evpn_del(zevpn);
1379 }
1380
1381 static void zebra_evpn_process_sync_macip_add(struct zebra_evpn *zevpn,
1382 const struct ethaddr *macaddr,
1383 uint16_t ipa_len,
1384 const struct ipaddr *ipaddr,
1385 uint8_t flags, uint32_t seq,
1386 const esi_t *esi)
1387 {
1388 char ipbuf[INET6_ADDRSTRLEN];
1389 bool sticky;
1390 bool remote_gw;
1391 struct zebra_neigh *n = NULL;
1392 struct zebra_mac *mac = NULL;
1393
1394 sticky = !!CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY);
1395 remote_gw = !!CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
1396 /* if sticky or remote-gw ignore updates from the peer */
1397 if (sticky || remote_gw) {
1398 if (IS_ZEBRA_DEBUG_VXLAN || IS_ZEBRA_DEBUG_EVPN_MH_NEIGH
1399 || IS_ZEBRA_DEBUG_EVPN_MH_MAC)
1400 zlog_debug(
1401 "Ignore sync-macip vni %u mac %pEA%s%s%s%s",
1402 zevpn->vni,
1403 macaddr,
1404 ipa_len ? " IP " : "",
1405 ipa_len ? ipaddr2str(ipaddr, ipbuf,
1406 sizeof(ipbuf))
1407 : "",
1408 sticky ? " sticky" : "",
1409 remote_gw ? " remote_gw" : "");
1410 return;
1411 }
1412
1413 if (!ipa_len) {
1414 /* MAC update */
1415 (void)zebra_evpn_proc_sync_mac_update(zevpn, macaddr, ipa_len,
1416 ipaddr, flags, seq, esi);
1417 } else {
1418 /* MAC-IP update */
1419 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
1420 if (!mac) {
1421 mac = zebra_evpn_proc_sync_mac_update(zevpn, macaddr,
1422 ipa_len, ipaddr,
1423 flags, seq, esi);
1424 }
1425 if (!mac)
1426 return;
1427
1428 n = zebra_evpn_neigh_lookup(zevpn, ipaddr);
1429 if (n
1430 && !zebra_evpn_neigh_is_bgp_seq_ok(zevpn, n, macaddr, seq,
1431 true))
1432 return;
1433
1434 zebra_evpn_proc_sync_neigh_update(zevpn, n, ipa_len, ipaddr,
1435 flags, seq, esi, mac);
1436 }
1437 }
1438
1439 /************************** remote mac-ip handling **************************/
1440 /* Process a remote MACIP add from BGP. */
1441 void zebra_evpn_rem_macip_add(vni_t vni, const struct ethaddr *macaddr,
1442 uint16_t ipa_len, const struct ipaddr *ipaddr,
1443 uint8_t flags, uint32_t seq,
1444 struct in_addr vtep_ip, const esi_t *esi)
1445 {
1446 struct zebra_evpn *zevpn;
1447 struct zebra_vtep *zvtep;
1448 struct zebra_mac *mac = NULL;
1449 struct interface *ifp = NULL;
1450 struct zebra_if *zif = NULL;
1451 struct zebra_vrf *zvrf;
1452
1453 /* Locate EVPN hash entry - expected to exist. */
1454 zevpn = zebra_evpn_lookup(vni);
1455 if (!zevpn) {
1456 if (IS_ZEBRA_DEBUG_VXLAN)
1457 zlog_debug("Unknown VNI %u upon remote MACIP ADD", vni);
1458 return;
1459 }
1460
1461 ifp = zevpn->vxlan_if;
1462 if (ifp)
1463 zif = ifp->info;
1464 if (!ifp || !if_is_operative(ifp) || !zif || !zif->brslave_info.br_if) {
1465 if (IS_ZEBRA_DEBUG_VXLAN)
1466 zlog_debug(
1467 "Ignoring remote MACIP ADD VNI %u, invalid interface state or info",
1468 vni);
1469 return;
1470 }
1471
1472 /* Type-2 routes from another PE can be interpreted as remote or
1473 * SYNC based on the destination ES -
1474 * SYNC - if ES is local
1475 * REMOTE - if ES is not local
1476 */
1477 if (flags & ZEBRA_MACIP_TYPE_SYNC_PATH) {
1478 struct zebra_evpn_es *es;
1479
1480 es = zebra_evpn_es_find(esi);
1481 if (es && (es->flags & ZEBRA_EVPNES_READY_FOR_BGP)) {
1482 zebra_evpn_process_sync_macip_add(zevpn, macaddr,
1483 ipa_len, ipaddr,
1484 flags, seq, esi);
1485 } else {
1486 if (IS_ZEBRA_DEBUG_EVPN_MH_ES) {
1487 char esi_str[ESI_STR_LEN];
1488
1489 esi_to_str(esi, esi_str, sizeof(esi_str));
1490 zlog_debug(
1491 "Ignore sync-macip add; ES %s is not ready",
1492 esi_str);
1493 }
1494 }
1495
1496 return;
1497 }
1498
1499 /* The remote VTEP specified should normally exist, but it is
1500 * possible that when peering comes up, peer may advertise MACIP
1501 * routes before advertising type-3 routes.
1502 */
1503 if (vtep_ip.s_addr) {
1504 zvtep = zebra_evpn_vtep_find(zevpn, &vtep_ip);
1505 if (!zvtep) {
1506 zvtep = zebra_evpn_vtep_add(zevpn, &vtep_ip,
1507 VXLAN_FLOOD_DISABLED);
1508 if (!zvtep) {
1509 flog_err(
1510 EC_ZEBRA_VTEP_ADD_FAILED,
1511 "Failed to add remote VTEP, VNI %u zevpn %p upon remote MACIP ADD",
1512 vni, zevpn);
1513 return;
1514 }
1515
1516 zebra_evpn_vtep_install(zevpn, zvtep);
1517 }
1518 }
1519
1520 zvrf = zebra_vrf_get_evpn();
1521 if (!zvrf)
1522 return;
1523
1524 if (!ipa_len) {
1525 /* MAC update */
1526 zebra_evpn_mac_remote_macip_add(zevpn, zvrf, macaddr, vtep_ip,
1527 flags, seq, esi);
1528 } else {
1529 /* MAC-IP update
1530 * Add auto MAC if it doesn't exist.
1531 */
1532 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
1533 if (!mac) {
1534 mac = zebra_evpn_mac_add_auto(zevpn, macaddr);
1535
1536 if (IS_ZEBRA_DEBUG_VXLAN)
1537 zlog_debug(
1538 "Neigh %pIA: MAC %pEA not found, Auto MAC created",
1539 ipaddr, macaddr);
1540 }
1541
1542 zebra_evpn_neigh_remote_macip_add(zevpn, zvrf, ipaddr, mac,
1543 vtep_ip, flags, seq);
1544 }
1545 }
1546
1547 /* Process a remote MACIP delete from BGP. */
1548 void zebra_evpn_rem_macip_del(vni_t vni, const struct ethaddr *macaddr,
1549 uint16_t ipa_len, const struct ipaddr *ipaddr,
1550 struct in_addr vtep_ip)
1551 {
1552 struct zebra_evpn *zevpn;
1553 struct zebra_mac *mac = NULL;
1554 struct zebra_neigh *n = NULL;
1555 struct interface *ifp = NULL;
1556 struct zebra_if *zif = NULL;
1557 struct zebra_ns *zns;
1558 struct zebra_vxlan_vni *vnip;
1559 struct zebra_vrf *zvrf;
1560 char buf1[INET6_ADDRSTRLEN];
1561
1562 /* Locate EVPN hash entry - expected to exist. */
1563 zevpn = zebra_evpn_lookup(vni);
1564 if (!zevpn) {
1565 if (IS_ZEBRA_DEBUG_VXLAN)
1566 zlog_debug("Unknown VNI %u upon remote MACIP DEL", vni);
1567 return;
1568 }
1569
1570 ifp = zevpn->vxlan_if;
1571 if (ifp)
1572 zif = ifp->info;
1573 if (!ifp || !if_is_operative(ifp) || !zif || !zif->brslave_info.br_if) {
1574 if (IS_ZEBRA_DEBUG_VXLAN)
1575 zlog_debug(
1576 "Ignoring remote MACIP DEL VNI %u, invalid interface state or info",
1577 vni);
1578 return;
1579 }
1580 zns = zebra_ns_lookup(NS_DEFAULT);
1581 vnip = zebra_vxlan_if_vni_find(zif, vni);
1582 if (!vnip) {
1583 if (IS_ZEBRA_DEBUG_VXLAN)
1584 zlog_debug(
1585 "VNI %u not in interface upon remote MACIP DEL",
1586 vni);
1587 return;
1588 }
1589
1590 mac = zebra_evpn_mac_lookup(zevpn, macaddr);
1591 if (ipa_len)
1592 n = zebra_evpn_neigh_lookup(zevpn, ipaddr);
1593
1594 if (n && !mac) {
1595 zlog_warn(
1596 "Failed to locate MAC %pEA for Neigh %pIA VNI %u upon remote MACIP DEL",
1597 macaddr, ipaddr, vni);
1598 return;
1599 }
1600
1601 /* If the remote mac or neighbor doesn't exist there is nothing
1602 * more to do. Otherwise, uninstall the entry and then remove it.
1603 */
1604 if (!mac && !n) {
1605 if (IS_ZEBRA_DEBUG_VXLAN)
1606 zlog_debug(
1607 "Failed to locate MAC %pEA & Neigh %pIA VNI %u upon remote MACIP DEL",
1608 macaddr, ipaddr, vni);
1609 return;
1610 }
1611
1612 zvrf = zevpn->vxlan_if->vrf->info;
1613
1614 /* Ignore the delete if this mac is a gateway mac-ip */
1615 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)
1616 && CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW)) {
1617 zlog_warn(
1618 "Ignore remote MACIP DEL VNI %u MAC %pEA%s%s as MAC is already configured as gateway MAC",
1619 vni, macaddr,
1620 ipa_len ? " IP " : "",
1621 ipa_len ? ipaddr2str(ipaddr, buf1, sizeof(buf1)) : "");
1622 return;
1623 }
1624
1625 /* Uninstall remote neighbor or MAC. */
1626 if (n)
1627 zebra_evpn_neigh_remote_uninstall(zevpn, zvrf, n, mac, ipaddr);
1628 else {
1629 /* DAD: when MAC is freeze state as remote learn event,
1630 * remote mac-ip delete event is received will result in freeze
1631 * entry removal, first fetch kernel for the same entry present
1632 * as LOCAL and reachable, avoid deleting this entry instead
1633 * use kerenel local entry to update during unfreeze time.
1634 */
1635 if (zvrf->dad_freeze
1636 && CHECK_FLAG(mac->flags, ZEBRA_MAC_DUPLICATE)
1637 && CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
1638 if (IS_ZEBRA_DEBUG_VXLAN)
1639 zlog_debug(
1640 "%s: MAC %pEA (flags 0x%x) is remote and duplicate, read kernel for local entry",
1641 __func__, macaddr, mac->flags);
1642 macfdb_read_specific_mac(zns, zif->brslave_info.br_if,
1643 macaddr, vnip->access_vlan);
1644 }
1645
1646 if (CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)) {
1647 if (!ipa_len)
1648 zebra_evpn_sync_mac_del(mac);
1649 } else if (CHECK_FLAG(mac->flags, ZEBRA_NEIGH_REMOTE)) {
1650 zebra_evpn_rem_mac_del(zevpn, mac);
1651 }
1652 }
1653 }
1654
1655 /************************** EVPN BGP config management ************************/
1656 void zebra_evpn_cfg_cleanup(struct hash_bucket *bucket, void *ctxt)
1657 {
1658 struct zebra_evpn *zevpn = NULL;
1659
1660 zevpn = (struct zebra_evpn *)bucket->data;
1661 zevpn->advertise_gw_macip = 0;
1662 zevpn->advertise_svi_macip = 0;
1663 zevpn->advertise_subnet = 0;
1664
1665 zebra_evpn_neigh_del_all(zevpn, 1, 0,
1666 DEL_REMOTE_NEIGH | DEL_REMOTE_NEIGH_FROM_VTEP);
1667 zebra_evpn_mac_del_all(zevpn, 1, 0,
1668 DEL_REMOTE_MAC | DEL_REMOTE_MAC_FROM_VTEP);
1669 zebra_evpn_vtep_del_all(zevpn, 1);
1670 }
FRRouting mirror