1 /* Ethernet-VPN Packet and vty Processing File
2 * Copyright (C) 2016 6WIND
3 * Copyright (C) 2017 Cumulus Networks, Inc.
5 * This file is part of FRR.
7 * FRRouting is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * FRRouting is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "bgpd/bgp_attr_evpn.h"
35 #include "bgpd/bgpd.h"
36 #include "bgpd/bgp_table.h"
37 #include "bgpd/bgp_route.h"
38 #include "bgpd/bgp_attr.h"
39 #include "bgpd/bgp_mplsvpn.h"
40 #include "bgpd/bgp_label.h"
41 #include "bgpd/bgp_evpn.h"
42 #include "bgpd/bgp_evpn_private.h"
43 #include "bgpd/bgp_ecommunity.h"
44 #include "bgpd/bgp_encap_types.h"
45 #include "bgpd/bgp_debug.h"
46 #include "bgpd/bgp_errors.h"
47 #include "bgpd/bgp_aspath.h"
48 #include "bgpd/bgp_zebra.h"
49 #include "bgpd/bgp_nexthop.h"
50 #include "bgpd/bgp_addpath.h"
53 * Definitions and external declarations.
55 extern struct zclient
*zclient
;
57 DEFINE_QOBJ_TYPE(bgpevpn
)
58 DEFINE_QOBJ_TYPE(evpnes
)
62 * Static function declarations
64 static void delete_evpn_route_entry(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
66 struct bgp_path_info
**pi
);
67 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
);
73 /* compare two IPV4 VTEP IPs */
74 static int evpn_vtep_ip_cmp(void *p1
, void *p2
)
76 const struct in_addr
*ip1
= p1
;
77 const struct in_addr
*ip2
= p2
;
79 return ip1
->s_addr
- ip2
->s_addr
;
83 * Make hash key for ESI.
85 static unsigned int esi_hash_keymake(void *p
)
87 struct evpnes
*pes
= p
;
88 const void *pnt
= (void *)pes
->esi
.val
;
90 return jhash(pnt
, ESI_BYTES
, 0xa5a5a55a);
96 static bool esi_cmp(const void *p1
, const void *p2
)
98 const struct evpnes
*pes1
= p1
;
99 const struct evpnes
*pes2
= p2
;
101 if (pes1
== NULL
&& pes2
== NULL
)
104 if (pes1
== NULL
|| pes2
== NULL
)
107 return (memcmp(pes1
->esi
.val
, pes2
->esi
.val
, ESI_BYTES
) == 0);
113 static unsigned int vni_hash_key_make(void *p
)
115 struct bgpevpn
*vpn
= p
;
116 return (jhash_1word(vpn
->vni
, 0));
120 * Comparison function for vni hash
122 static bool vni_hash_cmp(const void *p1
, const void *p2
)
124 const struct bgpevpn
*vpn1
= p1
;
125 const struct bgpevpn
*vpn2
= p2
;
131 return (vpn1
->vni
== vpn2
->vni
);
134 static int vni_list_cmp(void *p1
, void *p2
)
136 const struct bgpevpn
*vpn1
= p1
;
137 const struct bgpevpn
*vpn2
= p2
;
139 return vpn1
->vni
- vpn2
->vni
;
143 * Make vrf import route target hash key.
145 static unsigned int vrf_import_rt_hash_key_make(void *p
)
147 struct vrf_irt_node
*irt
= p
;
148 char *pnt
= irt
->rt
.val
;
150 return jhash(pnt
, 8, 0x5abc1234);
154 * Comparison function for vrf import rt hash
156 static bool vrf_import_rt_hash_cmp(const void *p1
, const void *p2
)
158 const struct vrf_irt_node
*irt1
= p1
;
159 const struct vrf_irt_node
*irt2
= p2
;
161 if (irt1
== NULL
&& irt2
== NULL
)
164 if (irt1
== NULL
|| irt2
== NULL
)
167 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
171 * Create a new vrf import_rt in default instance
173 static struct vrf_irt_node
*vrf_import_rt_new(struct ecommunity_val
*rt
)
175 struct bgp
*bgp_def
= NULL
;
176 struct vrf_irt_node
*irt
;
178 bgp_def
= bgp_get_default();
180 flog_err(EC_BGP_NO_DFLT
,
181 "vrf import rt new - def instance not created yet");
185 irt
= XCALLOC(MTYPE_BGP_EVPN_VRF_IMPORT_RT
,
186 sizeof(struct vrf_irt_node
));
191 irt
->vrfs
= list_new();
194 if (!hash_get(bgp_def
->vrf_import_rt_hash
, irt
, hash_alloc_intern
)) {
195 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
203 * Free the vrf import rt node
205 static void vrf_import_rt_free(struct vrf_irt_node
*irt
)
207 struct bgp
*bgp_def
= NULL
;
209 bgp_def
= bgp_get_default();
211 flog_err(EC_BGP_NO_DFLT
,
212 "vrf import rt free - def instance not created yet");
216 hash_release(bgp_def
->vrf_import_rt_hash
, irt
);
217 list_delete(&irt
->vrfs
);
218 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
222 * Function to lookup Import RT node - used to map a RT to set of
223 * VNIs importing routes with that RT.
225 static struct vrf_irt_node
*lookup_vrf_import_rt(struct ecommunity_val
*rt
)
227 struct bgp
*bgp_def
= NULL
;
228 struct vrf_irt_node
*irt
;
229 struct vrf_irt_node tmp
;
231 bgp_def
= bgp_get_default();
233 flog_err(EC_BGP_NO_DFLT
,
234 "vrf import rt lookup - def instance not created yet");
238 memset(&tmp
, 0, sizeof(struct vrf_irt_node
));
239 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
240 irt
= hash_lookup(bgp_def
->vrf_import_rt_hash
, &tmp
);
245 * Is specified VRF present on the RT's list of "importing" VRFs?
247 static int is_vrf_present_in_irt_vrfs(struct list
*vrfs
, struct bgp
*bgp_vrf
)
249 struct listnode
*node
= NULL
, *nnode
= NULL
;
250 struct bgp
*tmp_bgp_vrf
= NULL
;
252 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
253 if (tmp_bgp_vrf
== bgp_vrf
)
260 * Make import route target hash key.
262 static unsigned int import_rt_hash_key_make(void *p
)
264 struct irt_node
*irt
= p
;
265 char *pnt
= irt
->rt
.val
;
267 return jhash(pnt
, 8, 0xdeadbeef);
271 * Comparison function for import rt hash
273 static bool import_rt_hash_cmp(const void *p1
, const void *p2
)
275 const struct irt_node
*irt1
= p1
;
276 const struct irt_node
*irt2
= p2
;
278 if (irt1
== NULL
&& irt2
== NULL
)
281 if (irt1
== NULL
|| irt2
== NULL
)
284 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
288 * Create a new import_rt
290 static struct irt_node
*import_rt_new(struct bgp
*bgp
,
291 struct ecommunity_val
*rt
)
293 struct irt_node
*irt
;
298 irt
= XCALLOC(MTYPE_BGP_EVPN_IMPORT_RT
, sizeof(struct irt_node
));
303 irt
->vnis
= list_new();
306 if (!hash_get(bgp
->import_rt_hash
, irt
, hash_alloc_intern
)) {
307 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
315 * Free the import rt node
317 static void import_rt_free(struct bgp
*bgp
, struct irt_node
*irt
)
319 hash_release(bgp
->import_rt_hash
, irt
);
320 list_delete(&irt
->vnis
);
321 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
325 * Function to lookup Import RT node - used to map a RT to set of
326 * VNIs importing routes with that RT.
328 static struct irt_node
*lookup_import_rt(struct bgp
*bgp
,
329 struct ecommunity_val
*rt
)
331 struct irt_node
*irt
;
334 memset(&tmp
, 0, sizeof(struct irt_node
));
335 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
336 irt
= hash_lookup(bgp
->import_rt_hash
, &tmp
);
341 * Is specified VNI present on the RT's list of "importing" VNIs?
343 static int is_vni_present_in_irt_vnis(struct list
*vnis
, struct bgpevpn
*vpn
)
345 struct listnode
*node
, *nnode
;
346 struct bgpevpn
*tmp_vpn
;
348 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, tmp_vpn
)) {
357 * Compare Route Targets.
359 static int evpn_route_target_cmp(struct ecommunity
*ecom1
,
360 struct ecommunity
*ecom2
)
368 if (!ecom1
&& !ecom2
)
371 if (ecom1
->str
&& !ecom2
->str
)
374 if (!ecom1
->str
&& ecom2
->str
)
377 if (!ecom1
->str
&& !ecom2
->str
)
380 return strcmp(ecom1
->str
, ecom2
->str
);
383 static void evpn_xxport_delete_ecomm(void *val
)
385 struct ecommunity
*ecomm
= val
;
386 ecommunity_free(&ecomm
);
390 * Mask off global-admin field of specified extended community (RT),
391 * just retain the local-admin field.
393 static inline void mask_ecom_global_admin(struct ecommunity_val
*dst
,
394 struct ecommunity_val
*src
)
400 if (type
== ECOMMUNITY_ENCODE_AS
) {
401 dst
->val
[2] = dst
->val
[3] = 0;
402 } else if (type
== ECOMMUNITY_ENCODE_AS4
403 || type
== ECOMMUNITY_ENCODE_IP
) {
404 dst
->val
[2] = dst
->val
[3] = 0;
405 dst
->val
[4] = dst
->val
[5] = 0;
410 * Map one RT to specified VRF.
411 * bgp_vrf = BGP vrf instance
413 static void map_vrf_to_rt(struct bgp
*bgp_vrf
, struct ecommunity_val
*eval
)
415 struct vrf_irt_node
*irt
= NULL
;
416 struct ecommunity_val eval_tmp
;
418 /* If using "automatic" RT,
419 * we only care about the local-admin sub-field.
420 * This is to facilitate using L3VNI(VRF-VNI)
421 * as the RT for EBGP peering too.
423 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
424 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
425 mask_ecom_global_admin(&eval_tmp
, eval
);
427 irt
= lookup_vrf_import_rt(&eval_tmp
);
428 if (irt
&& is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
429 /* Already mapped. */
433 irt
= vrf_import_rt_new(&eval_tmp
);
435 /* Add VRF to the list for this RT. */
436 listnode_add(irt
->vrfs
, bgp_vrf
);
440 * Unmap specified VRF from specified RT. If there are no other
441 * VRFs for this RT, then the RT hash is deleted.
442 * bgp_vrf: BGP VRF specific instance
444 static void unmap_vrf_from_rt(struct bgp
*bgp_vrf
, struct vrf_irt_node
*irt
)
446 /* Delete VRF from list for this RT. */
447 listnode_delete(irt
->vrfs
, bgp_vrf
);
448 if (!listnode_head(irt
->vrfs
)) {
449 vrf_import_rt_free(irt
);
454 * Map one RT to specified VNI.
456 static void map_vni_to_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
457 struct ecommunity_val
*eval
)
459 struct irt_node
*irt
;
460 struct ecommunity_val eval_tmp
;
462 /* If using "automatic" RT, we only care about the local-admin
464 * This is to facilitate using VNI as the RT for EBGP peering too.
466 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
467 if (!is_import_rt_configured(vpn
))
468 mask_ecom_global_admin(&eval_tmp
, eval
);
470 irt
= lookup_import_rt(bgp
, &eval_tmp
);
472 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
473 /* Already mapped. */
477 irt
= import_rt_new(bgp
, &eval_tmp
);
481 /* Add VNI to the hash list for this RT. */
482 listnode_add(irt
->vnis
, vpn
);
486 * Unmap specified VNI from specified RT. If there are no other
487 * VNIs for this RT, then the RT hash is deleted.
489 static void unmap_vni_from_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
490 struct irt_node
*irt
)
492 /* Delete VNI from hash list for this RT. */
493 listnode_delete(irt
->vnis
, vpn
);
494 if (!listnode_head(irt
->vnis
)) {
495 import_rt_free(bgp
, irt
);
500 * Create RT extended community automatically from passed information:
501 * of the form AS:VNI.
502 * NOTE: We use only the lower 16 bits of the AS. This is sufficient as
503 * the need is to get a RT value that will be unique across different
504 * VNIs but the same across routers (in the same AS) for a particular
507 static void form_auto_rt(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
509 struct ecommunity_val eval
;
510 struct ecommunity
*ecomadd
;
512 if (bgp
->advertise_autort_rfc8365
)
513 vni
|= EVPN_AUTORT_VXLAN
;
514 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
516 ecomadd
= ecommunity_new();
517 ecommunity_add_val(ecomadd
, &eval
);
518 listnode_add_sort(rtl
, ecomadd
);
522 * Derive RD and RT for a VNI automatically. Invoked at the time of
525 static void derive_rd_rt_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
527 bgp_evpn_derive_auto_rd(bgp
, vpn
);
528 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
529 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
533 * Convert nexthop (remote VTEP IP) into an IPv6 address.
535 static void evpn_convert_nexthop_to_ipv6(struct attr
*attr
)
537 if (BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
539 ipv4_to_ipv4_mapped_ipv6(&attr
->mp_nexthop_global
, attr
->nexthop
);
540 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
544 * Add (update) or delete MACIP from zebra.
546 static int bgp_zebra_send_remote_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
547 struct prefix_evpn
*p
,
548 struct in_addr remote_vtep_ip
, int add
,
549 uint8_t flags
, uint32_t seq
)
553 char buf1
[ETHER_ADDR_STRLEN
];
554 char buf2
[INET6_ADDRSTRLEN
];
555 char buf3
[INET6_ADDRSTRLEN
];
558 if (!zclient
|| zclient
->sock
< 0)
561 /* Don't try to register if Zebra doesn't know of this instance. */
562 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
563 if (BGP_DEBUG(zebra
, ZEBRA
))
564 zlog_debug("%s: No zebra instance to talk to, not installing remote macip",
565 __PRETTY_FUNCTION__
);
571 zclient_create_header(
572 s
, add
? ZEBRA_REMOTE_MACIP_ADD
: ZEBRA_REMOTE_MACIP_DEL
,
574 stream_putl(s
, vpn
->vni
);
575 stream_put(s
, &p
->prefix
.macip_addr
.mac
.octet
, ETH_ALEN
); /* Mac Addr */
576 /* IP address length and IP address, if any. */
577 if (is_evpn_prefix_ipaddr_none(p
))
580 ipa_len
= is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BYTELEN
582 stream_putl(s
, ipa_len
);
583 stream_put(s
, &p
->prefix
.macip_addr
.ip
.ip
.addr
, ipa_len
);
585 stream_put_in_addr(s
, &remote_vtep_ip
);
587 /* TX flags - MAC sticky status and/or gateway mac */
588 /* Also TX the sequence number of the best route. */
590 stream_putc(s
, flags
);
594 stream_putw_at(s
, 0, stream_get_endp(s
));
596 if (bgp_debug_zebra(NULL
))
598 "Tx %s MACIP, VNI %u MAC %s IP %s flags 0x%x seq %u remote VTEP %s",
599 add
? "ADD" : "DEL", vpn
->vni
,
600 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
602 ipaddr2str(&p
->prefix
.macip_addr
.ip
,
603 buf3
, sizeof(buf3
)), flags
, seq
,
604 inet_ntop(AF_INET
, &remote_vtep_ip
, buf2
,
607 return zclient_send_message(zclient
);
611 * Add (update) or delete remote VTEP from zebra.
613 static int bgp_zebra_send_remote_vtep(struct bgp
*bgp
, struct bgpevpn
*vpn
,
614 struct prefix_evpn
*p
, int add
)
619 if (!zclient
|| zclient
->sock
< 0)
622 /* Don't try to register if Zebra doesn't know of this instance. */
623 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
)) {
624 if (BGP_DEBUG(zebra
, ZEBRA
))
625 zlog_debug("%s: No zebra instance to talk to, not installing remote vtep",
626 __PRETTY_FUNCTION__
);
633 zclient_create_header(
634 s
, add
? ZEBRA_REMOTE_VTEP_ADD
: ZEBRA_REMOTE_VTEP_DEL
,
636 stream_putl(s
, vpn
->vni
);
637 if (is_evpn_prefix_ipaddr_v4(p
))
638 stream_put_in_addr(s
, &p
->prefix
.imet_addr
.ip
.ipaddr_v4
);
639 else if (is_evpn_prefix_ipaddr_v6(p
)) {
642 "Bad remote IP when trying to %s remote VTEP for VNI %u",
643 add
? "ADD" : "DEL", vpn
->vni
);
647 stream_putw_at(s
, 0, stream_get_endp(s
));
649 if (bgp_debug_zebra(NULL
))
650 zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s",
651 add
? "ADD" : "DEL", vpn
->vni
,
652 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
654 return zclient_send_message(zclient
);
658 * Build extended community for EVPN ES (type-4) route
660 static void build_evpn_type4_route_extcomm(struct evpnes
*es
,
663 struct ecommunity ecom_encap
;
664 struct ecommunity ecom_es_rt
;
665 struct ecommunity_val eval
;
666 struct ecommunity_val eval_es_rt
;
667 bgp_encap_types tnl_type
;
671 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
672 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
673 encode_encap_extcomm(tnl_type
, &eval
);
675 ecom_encap
.val
= (uint8_t *)eval
.val
;
676 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
679 memset(&mac
, 0, sizeof(struct ethaddr
));
680 memset(&ecom_es_rt
, 0, sizeof(ecom_es_rt
));
681 es_get_system_mac(&es
->esi
, &mac
);
682 encode_es_rt_extcomm(&eval_es_rt
, &mac
);
684 ecom_es_rt
.val
= (uint8_t *)eval_es_rt
.val
;
686 ecommunity_merge(attr
->ecommunity
, &ecom_es_rt
);
688 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
692 * Build extended communities for EVPN prefix route.
694 static void build_evpn_type5_route_extcomm(struct bgp
*bgp_vrf
,
697 struct ecommunity ecom_encap
;
698 struct ecommunity ecom_rmac
;
699 struct ecommunity_val eval
;
700 struct ecommunity_val eval_rmac
;
701 bgp_encap_types tnl_type
;
702 struct listnode
*node
, *nnode
;
703 struct ecommunity
*ecom
;
704 struct list
*vrf_export_rtl
= NULL
;
707 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
708 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
709 encode_encap_extcomm(tnl_type
, &eval
);
711 ecom_encap
.val
= (uint8_t *)eval
.val
;
714 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
716 /* Add the export RTs for L3VNI/VRF */
717 vrf_export_rtl
= bgp_vrf
->vrf_export_rtl
;
718 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
, ecom
))
720 ecommunity_merge(attr
->ecommunity
, ecom
);
722 /* add the router mac extended community */
723 if (!is_zero_mac(&attr
->rmac
)) {
724 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
725 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
727 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
729 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
732 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
736 * Build extended communities for EVPN route.
737 * This function is applicable for type-2 and type-3 routes. The layer-2 RT
738 * and ENCAP extended communities are applicable for all routes.
739 * The default gateway extended community and MAC mobility (sticky) extended
740 * community are added as needed based on passed settings - only for type-2
741 * routes. Likewise, the layer-3 RT and Router MAC extended communities are
742 * added, if present, based on passed settings - only for non-link-local
745 static void build_evpn_route_extcomm(struct bgpevpn
*vpn
, struct attr
*attr
,
748 struct ecommunity ecom_encap
;
749 struct ecommunity ecom_sticky
;
750 struct ecommunity ecom_default_gw
;
751 struct ecommunity ecom_rmac
;
752 struct ecommunity ecom_na
;
753 struct ecommunity_val eval
;
754 struct ecommunity_val eval_sticky
;
755 struct ecommunity_val eval_default_gw
;
756 struct ecommunity_val eval_rmac
;
757 struct ecommunity_val eval_na
;
759 bgp_encap_types tnl_type
;
760 struct listnode
*node
, *nnode
;
761 struct ecommunity
*ecom
;
763 struct list
*vrf_export_rtl
= NULL
;
766 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
767 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
768 encode_encap_extcomm(tnl_type
, &eval
);
770 ecom_encap
.val
= (uint8_t *)eval
.val
;
773 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
775 /* Add the export RTs for L2VNI */
776 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
))
777 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
, ecom
);
779 /* Add the export RTs for L3VNI if told to - caller determines
780 * when this should be done.
783 vrf_export_rtl
= bgpevpn_get_vrf_export_rtl(vpn
);
784 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
785 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
,
787 attr
->ecommunity
= ecommunity_merge(
788 attr
->ecommunity
, ecom
);
792 /* Add MAC mobility (sticky) if needed. */
795 memset(&ecom_sticky
, 0, sizeof(ecom_sticky
));
796 encode_mac_mobility_extcomm(1, seqnum
, &eval_sticky
);
797 ecom_sticky
.size
= 1;
798 ecom_sticky
.val
= (uint8_t *)eval_sticky
.val
;
800 ecommunity_merge(attr
->ecommunity
, &ecom_sticky
);
803 /* Add RMAC, if told to. */
805 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
806 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
808 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
810 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
813 /* Add default gateway, if needed. */
814 if (attr
->default_gw
) {
815 memset(&ecom_default_gw
, 0, sizeof(ecom_default_gw
));
816 encode_default_gw_extcomm(&eval_default_gw
);
817 ecom_default_gw
.size
= 1;
818 ecom_default_gw
.val
= (uint8_t *)eval_default_gw
.val
;
820 ecommunity_merge(attr
->ecommunity
, &ecom_default_gw
);
823 if (attr
->router_flag
) {
824 memset(&ecom_na
, 0, sizeof(ecom_na
));
825 encode_na_flag_extcomm(&eval_na
, attr
->router_flag
);
827 ecom_na
.val
= (uint8_t *)eval_na
.val
;
828 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
832 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
836 * Add MAC mobility extended community to attribute.
838 static void add_mac_mobility_to_attr(uint32_t seq_num
, struct attr
*attr
)
840 struct ecommunity ecom_tmp
;
841 struct ecommunity_val eval
;
842 uint8_t *ecom_val_ptr
;
849 encode_mac_mobility_extcomm(0, seq_num
, &eval
);
851 /* Find current MM ecommunity */
854 if (attr
->ecommunity
) {
855 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
856 pnt
= attr
->ecommunity
->val
+ (i
* 8);
860 if (type
== ECOMMUNITY_ENCODE_EVPN
862 == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY
) {
863 ecom_val_ptr
= (uint8_t *)(attr
->ecommunity
->val
870 /* Update the existing MM ecommunity */
872 memcpy(ecom_val_ptr
, eval
.val
, sizeof(char) * ECOMMUNITY_SIZE
);
874 /* Add MM to existing */
876 memset(&ecom_tmp
, 0, sizeof(ecom_tmp
));
878 ecom_tmp
.val
= (uint8_t *)eval
.val
;
880 if (attr
->ecommunity
)
882 ecommunity_merge(attr
->ecommunity
, &ecom_tmp
);
884 attr
->ecommunity
= ecommunity_dup(&ecom_tmp
);
888 /* Install EVPN route into zebra. */
889 static int evpn_zebra_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
890 struct prefix_evpn
*p
,
891 struct in_addr remote_vtep_ip
, uint8_t flags
,
896 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
897 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
900 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 1);
905 /* Uninstall EVPN route from zebra. */
906 static int evpn_zebra_uninstall(struct bgp
*bgp
, struct bgpevpn
*vpn
,
907 struct prefix_evpn
*p
,
908 struct in_addr remote_vtep_ip
)
912 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
913 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
916 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 0);
922 * Due to MAC mobility, the prior "local" best route has been supplanted
923 * by a "remote" best route. The prior route has to be deleted and withdrawn
926 static void evpn_delete_old_local_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
928 struct bgp_path_info
*old_local
)
930 struct bgp_node
*global_rn
;
931 struct bgp_path_info
*pi
;
932 afi_t afi
= AFI_L2VPN
;
933 safi_t safi
= SAFI_EVPN
;
935 /* Locate route node in the global EVPN routing table. Note that
936 * this table is a 2-level tree (RD-level + Prefix-level) similar to
939 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
940 (struct prefix
*)&rn
->p
, &vpn
->prd
);
942 /* Delete route entry in the global EVPN table. */
943 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
945 /* Schedule for processing - withdraws to peers happen from
949 bgp_process(bgp
, global_rn
, afi
, safi
);
950 bgp_unlock_node(global_rn
);
953 /* Delete route entry in the VNI route table, caller to remove. */
954 bgp_path_info_delete(rn
, old_local
);
957 static struct in_addr
*es_vtep_new(struct in_addr vtep
)
961 ip
= XCALLOC(MTYPE_BGP_EVPN_ES_VTEP
, sizeof(struct in_addr
));
965 ip
->s_addr
= vtep
.s_addr
;
969 static void es_vtep_free(struct in_addr
*ip
)
971 XFREE(MTYPE_BGP_EVPN_ES_VTEP
, ip
);
974 /* check if VTEP is already part of the list */
975 static int is_vtep_present_in_list(struct list
*list
,
978 struct listnode
*node
= NULL
;
981 for (ALL_LIST_ELEMENTS_RO(list
, node
, tmp
)) {
982 if (tmp
->s_addr
== vtep
.s_addr
)
989 * Best path for ES route was changed,
990 * update the list of VTEPs for this ES
992 static int evpn_es_install_vtep(struct bgp
*bgp
,
994 struct prefix_evpn
*p
,
995 struct in_addr rvtep
)
997 struct in_addr
*vtep_ip
;
999 if (is_vtep_present_in_list(es
->vtep_list
, rvtep
))
1003 vtep_ip
= es_vtep_new(rvtep
);
1005 listnode_add_sort(es
->vtep_list
, vtep_ip
);
1010 * Best path for ES route was changed,
1011 * update the list of VTEPs for this ES
1013 static int evpn_es_uninstall_vtep(struct bgp
*bgp
,
1015 struct prefix_evpn
*p
,
1016 struct in_addr rvtep
)
1018 struct listnode
*node
, *nnode
, *node_to_del
= NULL
;
1019 struct in_addr
*tmp
;
1021 for (ALL_LIST_ELEMENTS(es
->vtep_list
, node
, nnode
, tmp
)) {
1022 if (tmp
->s_addr
== rvtep
.s_addr
) {
1029 list_delete_node(es
->vtep_list
, node_to_del
);
1035 * Calculate the best path for a ES(type-4) route.
1037 static int evpn_es_route_select_install(struct bgp
*bgp
,
1039 struct bgp_node
*rn
)
1042 afi_t afi
= AFI_L2VPN
;
1043 safi_t safi
= SAFI_EVPN
;
1044 struct bgp_path_info
*old_select
; /* old best */
1045 struct bgp_path_info
*new_select
; /* new best */
1046 struct bgp_path_info_pair old_and_new
;
1048 /* Compute the best path. */
1049 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
],
1050 &old_and_new
, afi
, safi
);
1051 old_select
= old_and_new
.old
;
1052 new_select
= old_and_new
.new;
1055 * If the best path hasn't changed - see if something needs to be
1058 if (old_select
&& old_select
== new_select
1059 && old_select
->type
== ZEBRA_ROUTE_BGP
1060 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1061 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1062 && !CHECK_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
)
1063 && !bgp_addpath_is_addpath_used(&bgp
->tx_addpath
, afi
, safi
)) {
1064 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1065 ret
= evpn_es_install_vtep(bgp
, es
,
1066 (struct prefix_evpn
*)&rn
->p
,
1067 old_select
->attr
->nexthop
);
1069 UNSET_FLAG(old_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1070 bgp_zebra_clear_route_change_flags(rn
);
1074 /* If the user did a "clear" this flag will be set */
1075 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1078 * bestpath has changed; update relevant fields and install or uninstall
1079 * into the zebra RIB.
1081 if (old_select
|| new_select
)
1082 bgp_bump_version(rn
);
1085 bgp_path_info_unset_flag(rn
, old_select
, BGP_PATH_SELECTED
);
1087 bgp_path_info_set_flag(rn
, new_select
, BGP_PATH_SELECTED
);
1088 bgp_path_info_unset_flag(rn
, new_select
, BGP_PATH_ATTR_CHANGED
);
1089 UNSET_FLAG(new_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1092 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1093 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1094 ret
= evpn_es_install_vtep(bgp
, es
,
1095 (struct prefix_evpn
*)&rn
->p
,
1096 new_select
->attr
->nexthop
);
1098 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1099 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1100 ret
= evpn_es_uninstall_vtep(
1101 bgp
, es
, (struct prefix_evpn
*)&rn
->p
,
1102 old_select
->attr
->nexthop
);
1105 /* Clear any route change flags. */
1106 bgp_zebra_clear_route_change_flags(rn
);
1108 /* Reap old select bgp_path_info, if it has been removed */
1109 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_PATH_REMOVED
))
1110 bgp_path_info_reap(rn
, old_select
);
1116 * Calculate the best path for an EVPN route. Install/update best path in zebra,
1119 static int evpn_route_select_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1120 struct bgp_node
*rn
)
1122 struct bgp_path_info
*old_select
, *new_select
;
1123 struct bgp_path_info_pair old_and_new
;
1124 struct prefix_evpn
*evp
;
1125 afi_t afi
= AFI_L2VPN
;
1126 safi_t safi
= SAFI_EVPN
;
1130 /* Compute the best path. */
1131 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
], &old_and_new
,
1133 old_select
= old_and_new
.old
;
1134 new_select
= old_and_new
.new;
1136 evp
= (struct prefix_evpn
*)&rn
->p
;
1137 /* If the best path hasn't changed - see if there is still something to
1141 if (old_select
&& old_select
== new_select
1142 && old_select
->type
== ZEBRA_ROUTE_BGP
1143 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1144 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1145 && !CHECK_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
)
1146 && !bgp_addpath_is_addpath_used(&bgp
->tx_addpath
, afi
, safi
)) {
1147 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1148 if (old_select
->attr
->sticky
)
1149 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1150 if (old_select
->attr
->default_gw
)
1151 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1152 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1153 old_select
->attr
->router_flag
)
1154 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1156 ret
= evpn_zebra_install(
1157 bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1158 old_select
->attr
->nexthop
, flags
,
1159 mac_mobility_seqnum(old_select
->attr
));
1161 UNSET_FLAG(old_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1162 bgp_zebra_clear_route_change_flags(rn
);
1166 /* If the user did a "clear" this flag will be set */
1167 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1169 /* bestpath has changed; update relevant fields and install or uninstall
1170 * into the zebra RIB.
1172 if (old_select
|| new_select
)
1173 bgp_bump_version(rn
);
1176 bgp_path_info_unset_flag(rn
, old_select
, BGP_PATH_SELECTED
);
1178 bgp_path_info_set_flag(rn
, new_select
, BGP_PATH_SELECTED
);
1179 bgp_path_info_unset_flag(rn
, new_select
, BGP_PATH_ATTR_CHANGED
);
1180 UNSET_FLAG(new_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1183 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1184 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1186 if (new_select
->attr
->sticky
)
1187 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1188 if (new_select
->attr
->default_gw
)
1189 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1190 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1191 new_select
->attr
->router_flag
)
1192 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1194 ret
= evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1195 new_select
->attr
->nexthop
, flags
,
1196 mac_mobility_seqnum(new_select
->attr
));
1197 /* If an old best existed and it was a "local" route, the only
1199 * it would be supplanted is due to MAC mobility procedures. So,
1201 * need to do an implicit delete and withdraw that route from
1204 if (old_select
&& old_select
->peer
== bgp
->peer_self
1205 && old_select
->type
== ZEBRA_ROUTE_BGP
1206 && old_select
->sub_type
== BGP_ROUTE_STATIC
)
1207 evpn_delete_old_local_route(bgp
, vpn
, rn
, old_select
);
1209 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1210 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1211 ret
= evpn_zebra_uninstall(bgp
, vpn
,
1212 (struct prefix_evpn
*)&rn
->p
,
1213 old_select
->attr
->nexthop
);
1216 /* Clear any route change flags. */
1217 bgp_zebra_clear_route_change_flags(rn
);
1219 /* Reap old select bgp_path_info, if it has been removed */
1220 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_PATH_REMOVED
))
1221 bgp_path_info_reap(rn
, old_select
);
1227 * Return true if the local ri for this rn is of type gateway mac
1229 static int evpn_route_is_def_gw(struct bgp
*bgp
, struct bgp_node
*rn
)
1231 struct bgp_path_info
*tmp_pi
= NULL
;
1232 struct bgp_path_info
*local_pi
= NULL
;
1235 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1236 if (tmp_pi
->peer
== bgp
->peer_self
1237 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1238 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1245 return local_pi
->attr
->default_gw
;
1250 * Return true if the local ri for this rn has sticky set
1252 static int evpn_route_is_sticky(struct bgp
*bgp
, struct bgp_node
*rn
)
1254 struct bgp_path_info
*tmp_pi
;
1255 struct bgp_path_info
*local_pi
;
1258 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1259 if (tmp_pi
->peer
== bgp
->peer_self
1260 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1261 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1268 return local_pi
->attr
->sticky
;
1272 * create or update EVPN type4 route entry.
1273 * This could be in the ES table or the global table.
1274 * TODO: handle remote ES (type4) routes as well
1276 static int update_evpn_type4_route_entry(struct bgp
*bgp
, struct evpnes
*es
,
1277 afi_t afi
, safi_t safi
,
1278 struct bgp_node
*rn
, struct attr
*attr
,
1279 int add
, struct bgp_path_info
**ri
,
1282 char buf
[ESI_STR_LEN
];
1283 char buf1
[INET6_ADDRSTRLEN
];
1284 struct bgp_path_info
*tmp_pi
= NULL
;
1285 struct bgp_path_info
*local_pi
= NULL
; /* local route entry if any */
1286 struct bgp_path_info
*remote_pi
= NULL
; /* remote route entry if any */
1287 struct attr
*attr_new
= NULL
;
1288 struct prefix_evpn
*evp
= NULL
;
1292 evp
= (struct prefix_evpn
*)&rn
->p
;
1294 /* locate the local and remote entries if any */
1295 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1296 if (tmp_pi
->peer
== bgp
->peer_self
1297 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1298 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1300 if (tmp_pi
->type
== ZEBRA_ROUTE_BGP
1301 && tmp_pi
->sub_type
== BGP_ROUTE_IMPORTED
1302 && CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_VALID
))
1306 /* we don't expect to see a remote_pi at this point.
1307 * An ES route has esi + vtep_ip as the key,
1308 * We shouldn't see the same route from any other vtep.
1313 "%u ERROR: local es route for ESI: %s Vtep %s also learnt from remote",
1315 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1316 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1320 if (!local_pi
&& !add
)
1323 /* create or update the entry */
1326 /* Add or update attribute to hash */
1327 attr_new
= bgp_attr_intern(attr
);
1329 /* Create new route with its attribute. */
1330 tmp_pi
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1331 bgp
->peer_self
, attr_new
, rn
);
1332 SET_FLAG(tmp_pi
->flags
, BGP_PATH_VALID
);
1334 /* add the newly created path to the route-node */
1335 bgp_path_info_add(rn
, tmp_pi
);
1338 if (attrhash_cmp(tmp_pi
->attr
, attr
)
1339 && !CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1342 /* The attribute has changed.
1343 * Add (or update) attribute to hash. */
1344 attr_new
= bgp_attr_intern(attr
);
1345 bgp_path_info_set_flag(rn
, tmp_pi
,
1346 BGP_PATH_ATTR_CHANGED
);
1348 /* Restore route, if needed. */
1349 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1350 bgp_path_info_restore(rn
, tmp_pi
);
1352 /* Unintern existing, set to new. */
1353 bgp_attr_unintern(&tmp_pi
->attr
);
1354 tmp_pi
->attr
= attr_new
;
1355 tmp_pi
->uptime
= bgp_clock();
1359 /* Return back the route entry. */
1364 /* update evpn es (type-4) route */
1365 static int update_evpn_type4_route(struct bgp
*bgp
,
1367 struct prefix_evpn
*p
)
1370 int route_changed
= 0;
1371 char buf
[ESI_STR_LEN
];
1372 char buf1
[INET6_ADDRSTRLEN
];
1373 afi_t afi
= AFI_L2VPN
;
1374 safi_t safi
= SAFI_EVPN
;
1376 struct attr
*attr_new
= NULL
;
1377 struct bgp_node
*rn
= NULL
;
1378 struct bgp_path_info
*pi
= NULL
;
1380 memset(&attr
, 0, sizeof(struct attr
));
1382 /* Build path-attribute for this route. */
1383 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1384 attr
.nexthop
= es
->originator_ip
.ipaddr_v4
;
1385 attr
.mp_nexthop_global_in
= es
->originator_ip
.ipaddr_v4
;
1386 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1388 /* Set up extended community. */
1389 build_evpn_type4_route_extcomm(es
, &attr
);
1391 /* First, create (or fetch) route node within the ESI. */
1392 /* NOTE: There is no RD here. */
1393 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
1395 /* Create or update route entry. */
1396 ret
= update_evpn_type4_route_entry(bgp
, es
, afi
, safi
, rn
, &attr
, 1,
1397 &pi
, &route_changed
);
1399 flog_err(EC_BGP_ES_INVALID
,
1400 "%u ERROR: Failed to updated ES route ESI: %s VTEP %s",
1402 esi_to_str(&p
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1403 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1407 attr_new
= pi
->attr
;
1409 /* Perform route selection;
1410 * this is just to set the flags correctly
1411 * as local route in the ES always wins.
1413 evpn_es_route_select_install(bgp
, es
, rn
);
1414 bgp_unlock_node(rn
);
1416 /* If this is a new route or some attribute has changed, export the
1417 * route to the global table. The route will be advertised to peers
1418 * from there. Note that this table is a 2-level tree (RD-level +
1419 * Prefix-level) similar to L3VPN routes.
1421 if (route_changed
) {
1422 struct bgp_path_info
*global_pi
;
1424 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1425 (struct prefix
*)p
, &es
->prd
);
1426 update_evpn_type4_route_entry(bgp
, es
, afi
, safi
, rn
, attr_new
,
1427 1, &global_pi
, &route_changed
);
1429 /* Schedule for processing and unlock node. */
1430 bgp_process(bgp
, rn
, afi
, safi
);
1431 bgp_unlock_node(rn
);
1434 /* Unintern temporary. */
1435 aspath_unintern(&attr
.aspath
);
1439 static int update_evpn_type5_route_entry(struct bgp
*bgp_def
,
1440 struct bgp
*bgp_vrf
, afi_t afi
,
1441 safi_t safi
, struct bgp_node
*rn
,
1442 struct attr
*attr
, int *route_changed
)
1444 struct attr
*attr_new
= NULL
;
1445 struct bgp_path_info
*pi
= NULL
;
1446 mpls_label_t label
= MPLS_INVALID_LABEL
;
1447 struct bgp_path_info
*local_pi
= NULL
;
1448 struct bgp_path_info
*tmp_pi
= NULL
;
1451 /* locate the local route entry if any */
1452 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1453 if (tmp_pi
->peer
== bgp_def
->peer_self
1454 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1455 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1460 * create a new route entry if one doesn't exist.
1461 * Otherwise see if route attr has changed
1465 /* route has changed as this is the first entry */
1468 /* Add (or update) attribute to hash. */
1469 attr_new
= bgp_attr_intern(attr
);
1471 /* create the route info from attribute */
1472 pi
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1473 bgp_def
->peer_self
, attr_new
, rn
);
1474 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
1476 /* Type-5 routes advertise the L3-VNI */
1477 bgp_path_info_extra_get(pi
);
1478 vni2label(bgp_vrf
->l3vni
, &label
);
1479 memcpy(&pi
->extra
->label
, &label
, sizeof(label
));
1480 pi
->extra
->num_labels
= 1;
1482 /* add the route entry to route node*/
1483 bgp_path_info_add(rn
, pi
);
1487 if (!attrhash_cmp(tmp_pi
->attr
, attr
)) {
1489 /* attribute changed */
1492 /* The attribute has changed. */
1493 /* Add (or update) attribute to hash. */
1494 attr_new
= bgp_attr_intern(attr
);
1495 bgp_path_info_set_flag(rn
, tmp_pi
,
1496 BGP_PATH_ATTR_CHANGED
);
1498 /* Restore route, if needed. */
1499 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1500 bgp_path_info_restore(rn
, tmp_pi
);
1502 /* Unintern existing, set to new. */
1503 bgp_attr_unintern(&tmp_pi
->attr
);
1504 tmp_pi
->attr
= attr_new
;
1505 tmp_pi
->uptime
= bgp_clock();
1511 /* update evpn type-5 route entry */
1512 static int update_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
,
1513 struct attr
*src_attr
)
1515 afi_t afi
= AFI_L2VPN
;
1516 safi_t safi
= SAFI_EVPN
;
1518 struct bgp_node
*rn
= NULL
;
1519 struct bgp
*bgp_def
= NULL
;
1520 int route_changed
= 0;
1522 bgp_def
= bgp_get_default();
1526 /* Build path attribute for this route - use the source attr, if
1527 * present, else treat as locally originated.
1530 bgp_attr_dup(&attr
, src_attr
);
1532 memset(&attr
, 0, sizeof(struct attr
));
1533 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1535 /* Set nexthop to ourselves and fill in the Router MAC. */
1536 attr
.nexthop
= bgp_vrf
->originator_ip
;
1537 attr
.mp_nexthop_global_in
= bgp_vrf
->originator_ip
;
1538 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1539 memcpy(&attr
.rmac
, &bgp_vrf
->rmac
, sizeof(struct ethaddr
));
1541 /* Setup RT and encap extended community */
1542 build_evpn_type5_route_extcomm(bgp_vrf
, &attr
);
1544 /* get the route node in global table */
1545 rn
= bgp_afi_node_get(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1546 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1549 /* create or update the route entry within the route node */
1550 update_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &attr
,
1553 /* schedule for processing and unlock node */
1554 if (route_changed
) {
1555 bgp_process(bgp_def
, rn
, afi
, safi
);
1556 bgp_unlock_node(rn
);
1559 /* uninten temporary */
1561 aspath_unintern(&attr
.aspath
);
1566 * Create or update EVPN route entry. This could be in the VNI route table
1567 * or the global route table.
1569 static int update_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1570 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1571 struct attr
*attr
, int add
,
1572 struct bgp_path_info
**pi
, uint8_t flags
,
1575 struct bgp_path_info
*tmp_pi
;
1576 struct bgp_path_info
*local_pi
;
1577 struct attr
*attr_new
;
1578 mpls_label_t label
[BGP_MAX_LABELS
];
1579 uint32_t num_labels
= 1;
1580 int route_change
= 1;
1582 struct prefix_evpn
*evp
;
1585 evp
= (struct prefix_evpn
*)&rn
->p
;
1586 memset(&label
, 0, sizeof(label
));
1588 /* See if this is an update of an existing route, or a new add. */
1590 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1591 if (tmp_pi
->peer
== bgp
->peer_self
1592 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1593 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1597 /* If route doesn't exist already, create a new one, if told to.
1598 * Otherwise act based on whether the attributes of the route have
1601 if (!local_pi
&& !add
)
1604 /* For non-GW MACs, update MAC mobility seq number, if needed. */
1605 if (seq
&& !CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
))
1606 add_mac_mobility_to_attr(seq
, attr
);
1609 /* Add (or update) attribute to hash. */
1610 attr_new
= bgp_attr_intern(attr
);
1612 /* Extract MAC mobility sequence number, if any. */
1613 attr_new
->mm_seqnum
=
1614 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1615 attr_new
->sticky
= sticky
;
1617 /* Create new route with its attribute. */
1618 tmp_pi
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1619 bgp
->peer_self
, attr_new
, rn
);
1620 SET_FLAG(tmp_pi
->flags
, BGP_PATH_VALID
);
1621 bgp_path_info_extra_get(tmp_pi
);
1623 /* The VNI goes into the 'label' field of the route */
1624 vni2label(vpn
->vni
, &label
[0]);
1626 /* Type-2 routes may carry a second VNI - the L3-VNI.
1627 * Only attach second label if we are advertising two labels for
1630 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1631 && CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
)) {
1634 l3vni
= bgpevpn_get_l3vni(vpn
);
1636 vni2label(l3vni
, &label
[1]);
1641 memcpy(&tmp_pi
->extra
->label
, label
, sizeof(label
));
1642 tmp_pi
->extra
->num_labels
= num_labels
;
1643 bgp_path_info_add(rn
, tmp_pi
);
1646 if (attrhash_cmp(tmp_pi
->attr
, attr
)
1647 && !CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1651 * The attributes have changed, type-2 routes needs to
1652 * be advertised with right labels.
1654 vni2label(vpn
->vni
, &label
[0]);
1655 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1656 && CHECK_FLAG(vpn
->flags
,
1657 VNI_FLAG_USE_TWO_LABELS
)) {
1660 l3vni
= bgpevpn_get_l3vni(vpn
);
1662 vni2label(l3vni
, &label
[1]);
1666 memcpy(&tmp_pi
->extra
->label
, label
, sizeof(label
));
1667 tmp_pi
->extra
->num_labels
= num_labels
;
1669 /* The attribute has changed. */
1670 /* Add (or update) attribute to hash. */
1671 attr_new
= bgp_attr_intern(attr
);
1672 bgp_path_info_set_flag(rn
, tmp_pi
,
1673 BGP_PATH_ATTR_CHANGED
);
1675 /* Extract MAC mobility sequence number, if any. */
1676 attr_new
->mm_seqnum
=
1677 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1678 attr_new
->sticky
= sticky
;
1680 /* Restore route, if needed. */
1681 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1682 bgp_path_info_restore(rn
, tmp_pi
);
1684 /* Unintern existing, set to new. */
1685 bgp_attr_unintern(&tmp_pi
->attr
);
1686 tmp_pi
->attr
= attr_new
;
1687 tmp_pi
->uptime
= bgp_clock();
1691 /* Return back the route entry. */
1693 return route_change
;
1697 * If the local route was not selected evict it and tell zebra to re-add
1698 * the best remote dest.
1700 * Typically a local path added by zebra is expected to be selected as
1701 * best. In which case when a remote path wins as best (later)
1702 * evpn_route_select_install itself evicts the older-local-best path.
1704 * However if bgp's add and zebra's add cross paths (race condition) it
1705 * is possible that the local path is no longer the "older" best path.
1706 * It is a path that was never designated as best and hence requires
1707 * additional handling to prevent bgp from injecting and holding on to a
1708 * non-best local path.
1710 static void evpn_cleanup_local_non_best_route(struct bgp
*bgp
,
1711 struct bgpevpn
*vpn
,
1712 struct bgp_node
*rn
,
1713 struct bgp_path_info
*local_pi
)
1715 struct bgp_path_info
*tmp_pi
;
1716 struct bgp_path_info
*curr_select
= NULL
;
1718 char buf
[PREFIX_STRLEN
];
1720 /* local path was not picked as the winner; kick it out */
1721 if (bgp_debug_zebra(NULL
)) {
1722 zlog_debug("evicting local evpn prefix %s as remote won",
1723 prefix2str(&rn
->p
, buf
, sizeof(buf
)));
1725 evpn_delete_old_local_route(bgp
, vpn
, rn
, local_pi
);
1726 bgp_path_info_reap(rn
, local_pi
);
1728 /* tell zebra to re-add the best remote path */
1729 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1730 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_SELECTED
)) {
1731 curr_select
= tmp_pi
;
1736 curr_select
->type
== ZEBRA_ROUTE_BGP
1737 && curr_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1738 if (curr_select
->attr
->sticky
)
1739 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1740 if (curr_select
->attr
->default_gw
)
1741 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1742 evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1743 curr_select
->attr
->nexthop
, flags
,
1744 mac_mobility_seqnum(curr_select
->attr
));
1749 * Create or update EVPN route (of type based on prefix) for specified VNI
1750 * and schedule for processing.
1752 static int update_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1753 struct prefix_evpn
*p
, uint8_t flags
,
1756 struct bgp_node
*rn
;
1758 struct attr
*attr_new
;
1759 int add_l3_ecomm
= 0;
1760 struct bgp_path_info
*pi
;
1761 afi_t afi
= AFI_L2VPN
;
1762 safi_t safi
= SAFI_EVPN
;
1765 memset(&attr
, 0, sizeof(struct attr
));
1767 /* Build path-attribute for this route. */
1768 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1769 attr
.nexthop
= vpn
->originator_ip
;
1770 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1771 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1772 attr
.sticky
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
) ? 1 : 0;
1773 attr
.default_gw
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
) ? 1 : 0;
1774 attr
.router_flag
= CHECK_FLAG(flags
,
1775 ZEBRA_MACIP_TYPE_ROUTER_FLAG
) ? 1 : 0;
1777 /* PMSI is only needed for type-3 routes */
1778 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
)
1779 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
1781 /* router mac is only needed for type-2 routes here. */
1782 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1783 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1784 vni2label(vpn
->vni
, &(attr
.label
));
1786 /* Include L3 VNI related RTs and RMAC for type-2 routes, if they're
1787 * IPv4 or IPv6 global addresses and we're advertising L3VNI with
1790 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
&&
1791 (is_evpn_prefix_ipaddr_v4(p
) ||
1792 !IN6_IS_ADDR_LINKLOCAL(&p
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
1793 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
1794 bgpevpn_get_l3vni(vpn
))
1797 /* Set up extended community. */
1798 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
1800 /* First, create (or fetch) route node within the VNI. */
1801 /* NOTE: There is no RD here. */
1802 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1804 /* Create or update route entry. */
1805 route_change
= update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
,
1806 1, &pi
, flags
, seq
);
1808 attr_new
= pi
->attr
;
1810 /* lock ri to prevent freeing in evpn_route_select_install */
1811 bgp_path_info_lock(pi
);
1812 /* Perform route selection; this is just to set the flags correctly
1813 * as local route in the VNI always wins.
1815 evpn_route_select_install(bgp
, vpn
, rn
);
1817 * If the new local route was not selected evict it and tell zebra
1818 * to re-add the best remote dest. BGP doesn't retain non-best local
1821 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)) {
1823 evpn_cleanup_local_non_best_route(bgp
, vpn
, rn
, pi
);
1825 bgp_path_info_unlock(pi
);
1827 bgp_unlock_node(rn
);
1829 /* If this is a new route or some attribute has changed, export the
1830 * route to the global table. The route will be advertised to peers
1831 * from there. Note that this table is a 2-level tree (RD-level +
1832 * Prefix-level) similar to L3VPN routes.
1835 struct bgp_path_info
*global_pi
;
1837 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1838 (struct prefix
*)p
, &vpn
->prd
);
1839 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, attr_new
, 1,
1840 &global_pi
, flags
, seq
);
1842 /* Schedule for processing and unlock node. */
1843 bgp_process(bgp
, rn
, afi
, safi
);
1844 bgp_unlock_node(rn
);
1847 /* Unintern temporary. */
1848 aspath_unintern(&attr
.aspath
);
1854 * Delete EVPN route entry.
1855 * The entry can be in ESI/VNI table or the global table.
1857 static void delete_evpn_route_entry(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1858 struct bgp_node
*rn
,
1859 struct bgp_path_info
**pi
)
1861 struct bgp_path_info
*tmp_pi
;
1865 /* Now, find matching route. */
1866 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
)
1867 if (tmp_pi
->peer
== bgp
->peer_self
1868 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1869 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1874 /* Mark route for delete. */
1876 bgp_path_info_delete(rn
, tmp_pi
);
1881 /* Delete EVPN ES (type-4) route */
1882 static int delete_evpn_type4_route(struct bgp
*bgp
,
1884 struct prefix_evpn
*p
)
1886 afi_t afi
= AFI_L2VPN
;
1887 safi_t safi
= SAFI_EVPN
;
1888 struct bgp_path_info
*pi
;
1889 struct bgp_node
*rn
= NULL
; /* rn in esi table */
1890 struct bgp_node
*global_rn
= NULL
; /* rn in global table */
1892 /* First, locate the route node within the ESI.
1893 * If it doesn't exist, ther is nothing to do.
1894 * Note: there is no RD here.
1896 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
1900 /* Next, locate route node in the global EVPN routing table.
1901 * Note that this table is a 2-level tree (RD-level + Prefix-level)
1903 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1904 (struct prefix
*)p
, &es
->prd
);
1907 /* Delete route entry in the global EVPN table. */
1908 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
1910 /* Schedule for processing - withdraws to peers happen from
1914 bgp_process(bgp
, global_rn
, afi
, safi
);
1915 bgp_unlock_node(global_rn
);
1919 * Delete route entry in the ESI route table.
1920 * This can just be removed.
1922 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
1924 bgp_path_info_reap(rn
, pi
);
1925 bgp_unlock_node(rn
);
1929 /* Delete EVPN type5 route */
1930 static int delete_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
)
1932 afi_t afi
= AFI_L2VPN
;
1933 safi_t safi
= SAFI_EVPN
;
1934 struct bgp_node
*rn
= NULL
;
1935 struct bgp_path_info
*pi
= NULL
;
1936 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
1938 bgp_def
= bgp_get_default();
1942 /* locate the global route entry for this type-5 prefix */
1943 rn
= bgp_afi_node_lookup(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1944 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1948 delete_evpn_route_entry(bgp_def
, afi
, safi
, rn
, &pi
);
1950 bgp_process(bgp_def
, rn
, afi
, safi
);
1951 bgp_unlock_node(rn
);
1956 * Delete EVPN route (of type based on prefix) for specified VNI and
1957 * schedule for processing.
1959 static int delete_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1960 struct prefix_evpn
*p
)
1962 struct bgp_node
*rn
, *global_rn
;
1963 struct bgp_path_info
*pi
;
1964 afi_t afi
= AFI_L2VPN
;
1965 safi_t safi
= SAFI_EVPN
;
1967 /* First, locate the route node within the VNI. If it doesn't exist,
1969 * is nothing further to do.
1971 /* NOTE: There is no RD here. */
1972 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1976 /* Next, locate route node in the global EVPN routing table. Note that
1977 * this table is a 2-level tree (RD-level + Prefix-level) similar to
1980 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1981 (struct prefix
*)p
, &vpn
->prd
);
1983 /* Delete route entry in the global EVPN table. */
1984 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
1986 /* Schedule for processing - withdraws to peers happen from
1990 bgp_process(bgp
, global_rn
, afi
, safi
);
1991 bgp_unlock_node(global_rn
);
1994 /* Delete route entry in the VNI route table. This can just be removed.
1996 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
1998 bgp_path_info_reap(rn
, pi
);
1999 evpn_route_select_install(bgp
, vpn
, rn
);
2001 bgp_unlock_node(rn
);
2007 * Update all type-2 (MACIP) local routes for this VNI - these should also
2008 * be scheduled for advertise to peers.
2010 static int update_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2014 struct bgp_node
*rn
;
2015 struct bgp_path_info
*pi
, *tmp_pi
;
2017 struct attr
*attr_new
;
2019 int add_l3_ecomm
= 0;
2024 /* Walk this VNI's route table and update local type-2 routes. For any
2025 * routes updated, update corresponding entry in the global table too.
2027 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2028 rn
= bgp_route_next(rn
)) {
2029 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2030 struct bgp_node
*rd_rn
;
2031 struct bgp_path_info
*global_pi
;
2033 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2036 /* Identify local route. */
2037 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
2038 if (tmp_pi
->peer
== bgp
->peer_self
2039 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
2040 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
2048 * Build attribute per local route as the MAC mobility and
2049 * some other values could differ for different routes. The
2050 * attributes will be shared in the hash table.
2052 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
2053 attr
.nexthop
= vpn
->originator_ip
;
2054 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
2055 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
2056 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
2058 if (evpn_route_is_sticky(bgp
, rn
))
2060 else if (evpn_route_is_def_gw(bgp
, rn
)) {
2061 attr
.default_gw
= 1;
2062 if (is_evpn_prefix_ipaddr_v6(evp
))
2063 attr
.router_flag
= 1;
2066 /* Add L3 VNI RTs and RMAC for non IPv6 link-local if
2067 * using L3 VNI for type-2 routes also.
2069 if ((is_evpn_prefix_ipaddr_v4(evp
) ||
2070 !IN6_IS_ADDR_LINKLOCAL(
2071 &evp
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
2072 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
2073 bgpevpn_get_l3vni(vpn
))
2076 /* Set up extended community. */
2077 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
2079 seq
= mac_mobility_seqnum(tmp_pi
->attr
);
2081 /* Update the route entry. */
2082 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
, 0, &pi
,
2085 /* Perform route selection; this is just to set the flags
2086 * correctly as local route in the VNI always wins.
2088 evpn_route_select_install(bgp
, vpn
, rn
);
2090 attr_new
= pi
->attr
;
2092 /* Update route in global routing table. */
2093 rd_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2094 (struct prefix
*)evp
, &vpn
->prd
);
2096 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rd_rn
, attr_new
, 0,
2098 mac_mobility_seqnum(attr_new
));
2100 /* Schedule for processing and unlock node. */
2101 bgp_process(bgp
, rd_rn
, afi
, safi
);
2102 bgp_unlock_node(rd_rn
);
2104 /* Unintern temporary. */
2105 aspath_unintern(&attr
.aspath
);
2113 * Delete all type-2 (MACIP) local routes for this VNI - only from the
2114 * global routing table. These are also scheduled for withdraw from peers.
2116 static int delete_global_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2120 struct bgp_node
*rdrn
, *rn
;
2121 struct bgp_table
*table
;
2122 struct bgp_path_info
*pi
;
2127 rdrn
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)&vpn
->prd
);
2128 if (rdrn
&& rdrn
->info
) {
2129 table
= (struct bgp_table
*)rdrn
->info
;
2130 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2131 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2133 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2136 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
2138 bgp_process(bgp
, rn
, afi
, safi
);
2142 /* Unlock RD node. */
2144 bgp_unlock_node(rdrn
);
2150 * Delete all type-2 (MACIP) local routes for this VNI - from the global
2151 * table as well as the per-VNI route table.
2153 static int delete_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2157 struct bgp_node
*rn
;
2158 struct bgp_path_info
*pi
;
2163 /* First, walk the global route table for this VNI's type-2 local
2165 * EVPN routes are a 2-level table, first get the RD table.
2167 delete_global_type2_routes(bgp
, vpn
);
2169 /* Next, walk this VNI's route table and delete local type-2 routes. */
2170 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2171 rn
= bgp_route_next(rn
)) {
2172 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2174 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2177 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
2179 /* Route entry in local table gets deleted immediately. */
2181 bgp_path_info_reap(rn
, pi
);
2188 * Delete all routes in per ES route-table
2190 static int delete_all_es_routes(struct bgp
*bgp
, struct evpnes
*es
)
2192 struct bgp_node
*rn
;
2193 struct bgp_path_info
*pi
, *nextpi
;
2195 /* Walk this ES's route table and delete all routes. */
2196 for (rn
= bgp_table_top(es
->route_table
); rn
;
2197 rn
= bgp_route_next(rn
)) {
2198 for (pi
= rn
->info
; (pi
!= NULL
) && (nextpi
= pi
->next
, 1);
2200 bgp_path_info_delete(rn
, pi
);
2201 bgp_path_info_reap(rn
, pi
);
2209 * Delete all routes in the per-VNI route table.
2211 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2213 struct bgp_node
*rn
;
2214 struct bgp_path_info
*pi
, *nextpi
;
2216 /* Walk this VNI's route table and delete all routes. */
2217 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2218 rn
= bgp_route_next(rn
)) {
2219 for (pi
= rn
->info
; (pi
!= NULL
) && (nextpi
= pi
->next
, 1);
2221 bgp_path_info_delete(rn
, pi
);
2222 bgp_path_info_reap(rn
, pi
);
2230 * Update (and advertise) local routes for a VNI. Invoked upon the VNI
2231 * export RT getting modified or change to tunnel IP. Note that these
2232 * situations need the route in the per-VNI table as well as the global
2233 * table to be updated (as attributes change).
2235 static int update_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2238 struct prefix_evpn p
;
2240 /* Update and advertise the type-3 route (only one) followed by the
2241 * locally learnt type-2 routes (MACIP) - for this VNI.
2243 * RT-3 only if doing head-end replication
2245 if (bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_HEAD_END_REPL
) {
2246 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2247 ret
= update_evpn_route(bgp
, vpn
, &p
, 0, 0);
2252 return update_all_type2_routes(bgp
, vpn
);
2255 /* Delete (and withdraw) local routes for specified ES from global and ES table.
2256 * Also remove all other routes from the per ES table.
2257 * Invoked when ES is deleted.
2259 static int delete_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
2262 char buf
[ESI_STR_LEN
];
2263 struct prefix_evpn p
;
2265 /* Delete and withdraw locally learnt ES route */
2266 build_evpn_type4_prefix(&p
, &es
->esi
, es
->originator_ip
.ipaddr_v4
);
2267 ret
= delete_evpn_type4_route(bgp
, es
, &p
);
2269 flog_err(EC_BGP_EVPN_ROUTE_DELETE
,
2270 "%u failed to delete type-4 route for ESI %s",
2271 bgp
->vrf_id
, esi_to_str(&es
->esi
, buf
, sizeof(buf
)));
2274 /* Delete all routes from per ES table */
2275 return delete_all_es_routes(bgp
, es
);
2279 * Delete (and withdraw) local routes for specified VNI from the global
2280 * table and per-VNI table. After this, remove all other routes from
2281 * the per-VNI table. Invoked upon the VNI being deleted or EVPN
2282 * (advertise-all-vni) being disabled.
2284 static int delete_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2287 struct prefix_evpn p
;
2289 /* Delete and withdraw locally learnt type-2 routes (MACIP)
2290 * followed by type-3 routes (only one) - for this VNI.
2292 ret
= delete_all_type2_routes(bgp
, vpn
);
2296 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2297 ret
= delete_evpn_route(bgp
, vpn
, &p
);
2301 /* Delete all routes from the per-VNI table. */
2302 return delete_all_vni_routes(bgp
, vpn
);
2306 * There is a tunnel endpoint IP address change for this VNI, delete
2307 * prior type-3 route (if needed) and update.
2308 * Note: Route re-advertisement happens elsewhere after other processing
2311 static int handle_tunnel_ip_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2312 struct in_addr originator_ip
)
2314 struct prefix_evpn p
;
2316 /* If VNI is not live, we only need to update the originator ip */
2317 if (!is_vni_live(vpn
)) {
2318 vpn
->originator_ip
= originator_ip
;
2322 /* Update the tunnel-ip hash */
2323 bgp_tip_del(bgp
, &vpn
->originator_ip
);
2324 bgp_tip_add(bgp
, &originator_ip
);
2326 /* filter routes as martian nexthop db has changed */
2327 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
2329 /* Need to withdraw type-3 route as the originator IP is part
2332 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2333 delete_evpn_route(bgp
, vpn
, &p
);
2335 /* Update the tunnel IP and re-advertise all routes for this VNI. */
2336 vpn
->originator_ip
= originator_ip
;
2340 /* Install EVPN route entry in ES */
2341 static int install_evpn_route_entry_in_es(struct bgp
*bgp
, struct evpnes
*es
,
2342 struct prefix_evpn
*p
,
2343 struct bgp_path_info
*parent_pi
)
2346 struct bgp_node
*rn
= NULL
;
2347 struct bgp_path_info
*pi
= NULL
;
2348 struct attr
*attr_new
= NULL
;
2350 /* Create (or fetch) route within the VNI.
2351 * NOTE: There is no RD here.
2353 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
2355 /* Check if route entry is already present. */
2356 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2358 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2362 /* Add (or update) attribute to hash. */
2363 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2365 /* Create new route with its attribute. */
2366 pi
= info_make(parent_pi
->type
, BGP_ROUTE_IMPORTED
, 0,
2367 parent_pi
->peer
, attr_new
, rn
);
2368 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
2369 bgp_path_info_extra_get(pi
);
2370 pi
->extra
->parent
= parent_pi
;
2371 bgp_path_info_add(rn
, pi
);
2373 if (attrhash_cmp(pi
->attr
, parent_pi
->attr
)
2374 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
2375 bgp_unlock_node(rn
);
2378 /* The attribute has changed. */
2379 /* Add (or update) attribute to hash. */
2380 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2382 /* Restore route, if needed. */
2383 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
2384 bgp_path_info_restore(rn
, pi
);
2386 /* Mark if nexthop has changed. */
2387 if (!IPV4_ADDR_SAME(&pi
->attr
->nexthop
, &attr_new
->nexthop
))
2388 SET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2390 /* Unintern existing, set to new. */
2391 bgp_attr_unintern(&pi
->attr
);
2392 pi
->attr
= attr_new
;
2393 pi
->uptime
= bgp_clock();
2396 /* Perform route selection and update zebra, if required. */
2397 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2402 * Install route entry into the VRF routing table and invoke route selection.
2404 static int install_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2405 struct prefix_evpn
*evp
,
2406 struct bgp_path_info
*parent_pi
)
2408 struct bgp_node
*rn
;
2409 struct bgp_path_info
*pi
;
2411 struct attr
*attr_new
;
2414 struct prefix
*pp
= &p
;
2417 char buf
[PREFIX_STRLEN
];
2418 char buf1
[PREFIX_STRLEN
];
2420 memset(pp
, 0, sizeof(struct prefix
));
2421 ip_prefix_from_evpn_prefix(evp
, pp
);
2423 if (bgp_debug_zebra(NULL
)) {
2425 "installing evpn prefix %s as ip prefix %s in vrf %s",
2426 prefix2str(evp
, buf
, sizeof(buf
)),
2427 prefix2str(pp
, buf1
, sizeof(buf
)),
2428 vrf_id_to_name(bgp_vrf
->vrf_id
));
2431 /* Create (or fetch) route within the VRF. */
2432 /* NOTE: There is no RD here. */
2433 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2435 safi
= SAFI_UNICAST
;
2436 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2437 } else if (is_evpn_prefix_ipaddr_v6(evp
)) {
2439 safi
= SAFI_UNICAST
;
2440 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2444 /* EVPN routes currently only support a IPv4 next hop which corresponds
2445 * to the remote VTEP. When importing into a VRF, if it is IPv6 host
2446 * or prefix route, we have to convert the next hop to an IPv4-mapped
2447 * address for the rest of the code to flow through. In the case of IPv4,
2448 * make sure to set the flag for next hop attribute.
2450 bgp_attr_dup(&attr
, parent_pi
->attr
);
2452 evpn_convert_nexthop_to_ipv6(&attr
);
2454 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
2456 /* Check if route entry is already present. */
2457 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2459 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2463 /* Add (or update) attribute to hash. */
2464 attr_new
= bgp_attr_intern(&attr
);
2466 /* Create new route with its attribute. */
2467 pi
= info_make(parent_pi
->type
, BGP_ROUTE_IMPORTED
, 0,
2468 parent_pi
->peer
, attr_new
, rn
);
2469 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
2470 bgp_path_info_extra_get(pi
);
2471 pi
->extra
->parent
= bgp_path_info_lock(parent_pi
);
2472 bgp_lock_node((struct bgp_node
*)parent_pi
->net
);
2473 if (parent_pi
->extra
) {
2474 memcpy(&pi
->extra
->label
, &parent_pi
->extra
->label
,
2475 sizeof(pi
->extra
->label
));
2476 pi
->extra
->num_labels
= parent_pi
->extra
->num_labels
;
2478 bgp_path_info_add(rn
, pi
);
2480 if (attrhash_cmp(pi
->attr
, &attr
)
2481 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
2482 bgp_unlock_node(rn
);
2485 /* The attribute has changed. */
2486 /* Add (or update) attribute to hash. */
2487 attr_new
= bgp_attr_intern(&attr
);
2489 /* Restore route, if needed. */
2490 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
2491 bgp_path_info_restore(rn
, pi
);
2493 /* Mark if nexthop has changed. */
2495 && !IPV4_ADDR_SAME(&pi
->attr
->nexthop
, &attr_new
->nexthop
))
2497 && !IPV6_ADDR_SAME(&pi
->attr
->mp_nexthop_global
,
2498 &attr_new
->mp_nexthop_global
)))
2499 SET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2501 /* Unintern existing, set to new. */
2502 bgp_attr_unintern(&pi
->attr
);
2503 pi
->attr
= attr_new
;
2504 pi
->uptime
= bgp_clock();
2507 bgp_aggregate_increment(bgp_vrf
, &rn
->p
, pi
, afi
, safi
);
2509 /* Perform route selection and update zebra, if required. */
2510 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2516 * Install route entry into the VNI routing table and invoke route selection.
2518 static int install_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2519 struct prefix_evpn
*p
,
2520 struct bgp_path_info
*parent_pi
)
2522 struct bgp_node
*rn
;
2523 struct bgp_path_info
*pi
;
2524 struct attr
*attr_new
;
2527 /* Create (or fetch) route within the VNI. */
2528 /* NOTE: There is no RD here. */
2529 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
2531 /* Check if route entry is already present. */
2532 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2534 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2538 /* Add (or update) attribute to hash. */
2539 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2541 /* Create new route with its attribute. */
2542 pi
= info_make(parent_pi
->type
, BGP_ROUTE_IMPORTED
, 0,
2543 parent_pi
->peer
, attr_new
, rn
);
2544 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
2545 bgp_path_info_extra_get(pi
);
2546 pi
->extra
->parent
= bgp_path_info_lock(parent_pi
);
2547 bgp_lock_node((struct bgp_node
*)parent_pi
->net
);
2548 if (parent_pi
->extra
) {
2549 memcpy(&pi
->extra
->label
, &parent_pi
->extra
->label
,
2550 sizeof(pi
->extra
->label
));
2551 pi
->extra
->num_labels
= parent_pi
->extra
->num_labels
;
2553 bgp_path_info_add(rn
, pi
);
2555 if (attrhash_cmp(pi
->attr
, parent_pi
->attr
)
2556 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
2557 bgp_unlock_node(rn
);
2560 /* The attribute has changed. */
2561 /* Add (or update) attribute to hash. */
2562 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2564 /* Restore route, if needed. */
2565 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
2566 bgp_path_info_restore(rn
, pi
);
2568 /* Mark if nexthop has changed. */
2569 if (!IPV4_ADDR_SAME(&pi
->attr
->nexthop
, &attr_new
->nexthop
))
2570 SET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2572 /* Unintern existing, set to new. */
2573 bgp_attr_unintern(&pi
->attr
);
2574 pi
->attr
= attr_new
;
2575 pi
->uptime
= bgp_clock();
2578 /* Perform route selection and update zebra, if required. */
2579 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2584 /* Uninstall EVPN route entry from ES route table */
2585 static int uninstall_evpn_route_entry_in_es(struct bgp
*bgp
, struct evpnes
*es
,
2586 struct prefix_evpn
*p
,
2587 struct bgp_path_info
*parent_pi
)
2590 struct bgp_node
*rn
;
2591 struct bgp_path_info
*pi
;
2593 if (!es
->route_table
)
2596 /* Locate route within the ESI.
2597 * NOTE: There is no RD here.
2599 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
2603 /* Find matching route entry. */
2604 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2606 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2612 /* Mark entry for deletion */
2613 bgp_path_info_delete(rn
, pi
);
2615 /* Perform route selection and update zebra, if required. */
2616 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2618 /* Unlock route node. */
2619 bgp_unlock_node(rn
);
2625 * Uninstall route entry from the VRF routing table and send message
2626 * to zebra, if appropriate.
2628 static int uninstall_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2629 struct prefix_evpn
*evp
,
2630 struct bgp_path_info
*parent_pi
)
2632 struct bgp_node
*rn
;
2633 struct bgp_path_info
*pi
;
2636 struct prefix
*pp
= &p
;
2639 char buf
[PREFIX_STRLEN
];
2640 char buf1
[PREFIX_STRLEN
];
2642 memset(pp
, 0, sizeof(struct prefix
));
2643 ip_prefix_from_evpn_prefix(evp
, pp
);
2645 if (bgp_debug_zebra(NULL
)) {
2647 "uninstalling evpn prefix %s as ip prefix %s in vrf %s",
2648 prefix2str(evp
, buf
, sizeof(buf
)),
2649 prefix2str(pp
, buf1
, sizeof(buf
)),
2650 vrf_id_to_name(bgp_vrf
->vrf_id
));
2653 /* Locate route within the VRF. */
2654 /* NOTE: There is no RD here. */
2655 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2657 safi
= SAFI_UNICAST
;
2658 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2661 safi
= SAFI_UNICAST
;
2662 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2668 /* Find matching route entry. */
2669 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2671 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2677 bgp_aggregate_decrement(bgp_vrf
, &rn
->p
, pi
, afi
, safi
);
2679 /* Mark entry for deletion */
2680 bgp_path_info_delete(rn
, pi
);
2682 /* Perform route selection and update zebra, if required. */
2683 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2685 /* Unlock route node. */
2686 bgp_unlock_node(rn
);
2692 * Uninstall route entry from the VNI routing table and send message
2693 * to zebra, if appropriate.
2695 static int uninstall_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2696 struct prefix_evpn
*p
,
2697 struct bgp_path_info
*parent_pi
)
2699 struct bgp_node
*rn
;
2700 struct bgp_path_info
*pi
;
2703 /* Locate route within the VNI. */
2704 /* NOTE: There is no RD here. */
2705 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
2709 /* Find matching route entry. */
2710 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2712 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2718 /* Mark entry for deletion */
2719 bgp_path_info_delete(rn
, pi
);
2721 /* Perform route selection and update zebra, if required. */
2722 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2724 /* Unlock route node. */
2725 bgp_unlock_node(rn
);
2731 * Given a prefix, see if it belongs to ES.
2733 static int is_prefix_matching_for_es(struct prefix_evpn
*p
,
2736 /* if not an ES route return false */
2737 if (p
->prefix
.route_type
!= BGP_EVPN_ES_ROUTE
)
2740 if (memcmp(&p
->prefix
.es_addr
.esi
, &es
->esi
, sizeof(esi_t
)) == 0)
2747 * Given a route entry and a VRF, see if this route entry should be
2748 * imported into the VRF i.e., RTs match.
2750 static int is_route_matching_for_vrf(struct bgp
*bgp_vrf
,
2751 struct bgp_path_info
*pi
)
2753 struct attr
*attr
= pi
->attr
;
2754 struct ecommunity
*ecom
;
2758 /* Route should have valid RT to be even considered. */
2759 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2762 ecom
= attr
->ecommunity
;
2763 if (!ecom
|| !ecom
->size
)
2766 /* For each extended community RT, see if it matches this VNI. If any RT
2767 * matches, we're done.
2769 for (i
= 0; i
< ecom
->size
; i
++) {
2771 uint8_t type
, sub_type
;
2772 struct ecommunity_val
*eval
;
2773 struct ecommunity_val eval_tmp
;
2774 struct vrf_irt_node
*irt
;
2776 /* Only deal with RTs */
2777 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2778 eval
= (struct ecommunity_val
*)(ecom
->val
2779 + (i
* ECOMMUNITY_SIZE
));
2782 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2785 /* See if this RT matches specified VNIs import RTs */
2786 irt
= lookup_vrf_import_rt(eval
);
2788 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2791 /* Also check for non-exact match. In this, we mask out the AS
2793 * only check on the local-admin sub-field. This is to
2795 * VNI as the RT for EBGP peering too.
2798 if (type
== ECOMMUNITY_ENCODE_AS
2799 || type
== ECOMMUNITY_ENCODE_AS4
2800 || type
== ECOMMUNITY_ENCODE_IP
) {
2801 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2802 mask_ecom_global_admin(&eval_tmp
, eval
);
2803 irt
= lookup_vrf_import_rt(&eval_tmp
);
2806 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2814 * Given a route entry and a VNI, see if this route entry should be
2815 * imported into the VNI i.e., RTs match.
2817 static int is_route_matching_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2818 struct bgp_path_info
*pi
)
2820 struct attr
*attr
= pi
->attr
;
2821 struct ecommunity
*ecom
;
2825 /* Route should have valid RT to be even considered. */
2826 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2829 ecom
= attr
->ecommunity
;
2830 if (!ecom
|| !ecom
->size
)
2833 /* For each extended community RT, see if it matches this VNI. If any RT
2834 * matches, we're done.
2836 for (i
= 0; i
< ecom
->size
; i
++) {
2838 uint8_t type
, sub_type
;
2839 struct ecommunity_val
*eval
;
2840 struct ecommunity_val eval_tmp
;
2841 struct irt_node
*irt
;
2843 /* Only deal with RTs */
2844 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2845 eval
= (struct ecommunity_val
*)(ecom
->val
2846 + (i
* ECOMMUNITY_SIZE
));
2849 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2852 /* See if this RT matches specified VNIs import RTs */
2853 irt
= lookup_import_rt(bgp
, eval
);
2855 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2858 /* Also check for non-exact match. In this, we mask out the AS
2860 * only check on the local-admin sub-field. This is to
2862 * VNI as the RT for EBGP peering too.
2865 if (type
== ECOMMUNITY_ENCODE_AS
2866 || type
== ECOMMUNITY_ENCODE_AS4
2867 || type
== ECOMMUNITY_ENCODE_IP
) {
2868 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2869 mask_ecom_global_admin(&eval_tmp
, eval
);
2870 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2873 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2880 static int install_uninstall_routes_for_es(struct bgp
*bgp
,
2887 char buf
[PREFIX_STRLEN
];
2888 char buf1
[ESI_STR_LEN
];
2889 struct bgp_node
*rd_rn
, *rn
;
2890 struct bgp_table
*table
;
2891 struct bgp_path_info
*pi
;
2897 * Walk entire global routing table and evaluate routes which could be
2898 * imported into this VRF. Note that we need to loop through all global
2899 * routes to determine which route matches the import rt on vrf
2901 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2902 rd_rn
= bgp_route_next(rd_rn
)) {
2903 table
= (struct bgp_table
*)(rd_rn
->info
);
2907 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2908 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2910 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
2912 * Consider "valid" remote routes applicable for
2915 if (!(CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
2916 && pi
->type
== ZEBRA_ROUTE_BGP
2917 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
2920 if (!is_prefix_matching_for_es(evp
, es
))
2924 ret
= install_evpn_route_entry_in_es(
2927 ret
= uninstall_evpn_route_entry_in_es(
2933 "Failed to %s EVPN %s route in ESI %s",
2936 prefix2str(evp
, buf
,
2938 esi_to_str(&es
->esi
, buf1
,
2949 * Install or uninstall mac-ip routes are appropriate for this
2952 static int install_uninstall_routes_for_vrf(struct bgp
*bgp_vrf
, int install
)
2956 struct bgp_node
*rd_rn
, *rn
;
2957 struct bgp_table
*table
;
2958 struct bgp_path_info
*pi
;
2960 char buf
[PREFIX_STRLEN
];
2961 struct bgp
*bgp_def
= NULL
;
2965 bgp_def
= bgp_get_default();
2969 /* Walk entire global routing table and evaluate routes which could be
2970 * imported into this VRF. Note that we need to loop through all global
2971 * routes to determine which route matches the import rt on vrf
2973 for (rd_rn
= bgp_table_top(bgp_def
->rib
[afi
][safi
]); rd_rn
;
2974 rd_rn
= bgp_route_next(rd_rn
)) {
2975 table
= (struct bgp_table
*)(rd_rn
->info
);
2979 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2980 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2982 /* if not mac-ip route skip this route */
2983 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2984 || evp
->prefix
.route_type
2985 == BGP_EVPN_IP_PREFIX_ROUTE
))
2988 /* if not a mac+ip route skip this route */
2989 if (!(is_evpn_prefix_ipaddr_v4(evp
)
2990 || is_evpn_prefix_ipaddr_v6(evp
)))
2993 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
2994 /* Consider "valid" remote routes applicable for
2997 if (!(CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
2998 && pi
->type
== ZEBRA_ROUTE_BGP
2999 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
3002 if (is_route_matching_for_vrf(bgp_vrf
, pi
)) {
3004 ret
= install_evpn_route_entry_in_vrf(
3007 ret
= uninstall_evpn_route_entry_in_vrf(
3013 "Failed to %s EVPN %s route in VRF %s",
3016 prefix2str(evp
, buf
,
3031 * Install or uninstall routes of specified type that are appropriate for this
3034 static int install_uninstall_routes_for_vni(struct bgp
*bgp
,
3035 struct bgpevpn
*vpn
,
3036 bgp_evpn_route_type rtype
,
3041 struct bgp_node
*rd_rn
, *rn
;
3042 struct bgp_table
*table
;
3043 struct bgp_path_info
*pi
;
3049 /* Walk entire global routing table and evaluate routes which could be
3050 * imported into this VPN. Note that we cannot just look at the routes
3052 * the VNI's RD - remote routes applicable for this VNI could have any
3055 /* EVPN routes are a 2-level table. */
3056 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
3057 rd_rn
= bgp_route_next(rd_rn
)) {
3058 table
= (struct bgp_table
*)(rd_rn
->info
);
3062 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
3063 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
3065 if (evp
->prefix
.route_type
!= rtype
)
3068 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
3069 /* Consider "valid" remote routes applicable for
3071 if (!(CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
3072 && pi
->type
== ZEBRA_ROUTE_BGP
3073 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
3076 if (is_route_matching_for_vni(bgp
, vpn
, pi
)) {
3078 ret
= install_evpn_route_entry(
3081 ret
= uninstall_evpn_route_entry(
3087 "%u: Failed to %s EVPN %s route in VNI %u",
3091 rtype
== BGP_EVPN_MAC_IP_ROUTE
3105 /* Install any existing remote ES routes applicable for this ES into its routing
3106 * table. This is invoked when ES comes up.
3108 static int install_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
3110 return install_uninstall_routes_for_es(bgp
, es
, 1);
3114 /* Install any existing remote routes applicable for this VRF into VRF RIB. This
3115 * is invoked upon l3vni-add or l3vni import rt change
3117 static int install_routes_for_vrf(struct bgp
*bgp_vrf
)
3119 install_uninstall_routes_for_vrf(bgp_vrf
, 1);
3124 * Install any existing remote routes applicable for this VNI into its
3125 * routing table. This is invoked when a VNI becomes "live" or its Import
3128 static int install_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3132 /* Install type-3 routes followed by type-2 routes - the ones applicable
3135 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3140 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3144 /* uninstall routes from l3vni vrf. */
3145 static int uninstall_routes_for_vrf(struct bgp
*bgp_vrf
)
3147 install_uninstall_routes_for_vrf(bgp_vrf
, 0);
3152 * Uninstall any existing remote routes for this VNI. One scenario in which
3153 * this is invoked is upon an import RT change.
3155 static int uninstall_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3159 /* Uninstall type-2 routes followed by type-3 routes - the ones
3163 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3168 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3172 /* Install or unistall route in ES */
3173 static int install_uninstall_route_in_es(struct bgp
*bgp
, struct evpnes
*es
,
3174 afi_t afi
, safi_t safi
,
3175 struct prefix_evpn
*evp
,
3176 struct bgp_path_info
*pi
, int install
)
3179 char buf
[ESI_STR_LEN
];
3182 ret
= install_evpn_route_entry_in_es(bgp
, es
, evp
, pi
);
3184 ret
= uninstall_evpn_route_entry_in_es(bgp
, es
, evp
, pi
);
3189 "%u: Failed to %s EVPN %s route in ESI %s", bgp
->vrf_id
,
3190 install
? "install" : "uninstall", "ES",
3191 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)));
3198 * Install or uninstall route in matching VRFs (list).
3200 static int install_uninstall_route_in_vrfs(struct bgp
*bgp_def
, afi_t afi
,
3201 safi_t safi
, struct prefix_evpn
*evp
,
3202 struct bgp_path_info
*pi
,
3203 struct list
*vrfs
, int install
)
3205 char buf
[PREFIX2STR_BUFFER
];
3206 struct bgp
*bgp_vrf
;
3207 struct listnode
*node
, *nnode
;
3209 /* Only type-2/type-5 routes go into a VRF */
3210 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3211 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3214 /* if it is type-2 route and not a mac+ip route skip this route */
3215 if ((evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
3216 && !(is_evpn_prefix_ipaddr_v4(evp
)
3217 || is_evpn_prefix_ipaddr_v6(evp
)))
3220 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, bgp_vrf
)) {
3224 ret
= install_evpn_route_entry_in_vrf(bgp_vrf
, evp
, pi
);
3226 ret
= uninstall_evpn_route_entry_in_vrf(bgp_vrf
, evp
,
3230 flog_err(EC_BGP_EVPN_FAIL
,
3231 "%u: Failed to %s prefix %s in VRF %s",
3233 install
? "install" : "uninstall",
3234 prefix2str(evp
, buf
, sizeof(buf
)),
3235 vrf_id_to_name(bgp_vrf
->vrf_id
));
3244 * Install or uninstall route in matching VNIs (list).
3246 static int install_uninstall_route_in_vnis(struct bgp
*bgp
, afi_t afi
,
3247 safi_t safi
, struct prefix_evpn
*evp
,
3248 struct bgp_path_info
*pi
,
3249 struct list
*vnis
, int install
)
3251 struct bgpevpn
*vpn
;
3252 struct listnode
*node
, *nnode
;
3254 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, vpn
)) {
3257 if (!is_vni_live(vpn
))
3261 ret
= install_evpn_route_entry(bgp
, vpn
, evp
, pi
);
3263 ret
= uninstall_evpn_route_entry(bgp
, vpn
, evp
, pi
);
3266 flog_err(EC_BGP_EVPN_FAIL
,
3267 "%u: Failed to %s EVPN %s route in VNI %u",
3268 bgp
->vrf_id
, install
? "install" : "uninstall",
3269 evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3281 * Install or uninstall route for appropriate VNIs/ESIs.
3283 static int install_uninstall_evpn_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
3285 struct bgp_path_info
*pi
, int import
)
3287 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
3288 struct attr
*attr
= pi
->attr
;
3289 struct ecommunity
*ecom
;
3294 /* Only type-2, type-3, type-4 and type-5 are supported currently */
3295 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3296 || evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
3297 || evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
3298 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3301 /* If we don't have Route Target, nothing much to do. */
3302 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
3305 ecom
= attr
->ecommunity
;
3306 if (!ecom
|| !ecom
->size
)
3309 /* An EVPN route belongs to a VNI or a VRF or an ESI based on the RTs
3310 * attached to the route */
3311 for (i
= 0; i
< ecom
->size
; i
++) {
3313 uint8_t type
, sub_type
;
3314 struct ecommunity_val
*eval
;
3315 struct ecommunity_val eval_tmp
;
3316 struct irt_node
*irt
; /* import rt for l2vni */
3317 struct vrf_irt_node
*vrf_irt
; /* import rt for l3vni */
3320 /* Only deal with RTs */
3321 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3322 eval
= (struct ecommunity_val
*)(ecom
->val
3323 + (i
* ECOMMUNITY_SIZE
));
3326 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
3330 * macip routes (type-2) are imported into VNI and VRF tables.
3331 * IMET route is imported into VNI table.
3332 * prefix routes are imported into VRF table.
3334 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
||
3335 evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
||
3336 evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
3338 irt
= lookup_import_rt(bgp
, eval
);
3340 install_uninstall_route_in_vnis(
3341 bgp
, afi
, safi
, evp
, pi
, irt
->vnis
,
3344 vrf_irt
= lookup_vrf_import_rt(eval
);
3346 install_uninstall_route_in_vrfs(
3347 bgp
, afi
, safi
, evp
, pi
, vrf_irt
->vrfs
,
3350 /* Also check for non-exact match.
3351 * In this, we mask out the AS and
3352 * only check on the local-admin sub-field.
3353 * This is to facilitate using
3354 * VNI as the RT for EBGP peering too.
3358 if (type
== ECOMMUNITY_ENCODE_AS
3359 || type
== ECOMMUNITY_ENCODE_AS4
3360 || type
== ECOMMUNITY_ENCODE_IP
) {
3361 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3362 mask_ecom_global_admin(&eval_tmp
, eval
);
3363 irt
= lookup_import_rt(bgp
, &eval_tmp
);
3364 vrf_irt
= lookup_vrf_import_rt(&eval_tmp
);
3368 install_uninstall_route_in_vnis(
3369 bgp
, afi
, safi
, evp
, pi
, irt
->vnis
,
3372 install_uninstall_route_in_vrfs(
3373 bgp
, afi
, safi
, evp
, pi
, vrf_irt
->vrfs
,
3377 /* es route is imported into the es table */
3378 if (evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
3380 /* we will match based on the entire esi to avoid
3381 * imoort of an es route for esi2 into esi1
3383 es
= bgp_evpn_lookup_es(bgp
, &evp
->prefix
.es_addr
.esi
);
3384 if (es
&& is_es_local(es
))
3385 install_uninstall_route_in_es(
3386 bgp
, es
, afi
, safi
, evp
, pi
, import
);
3394 * delete and withdraw all ipv4 and ipv6 routes in the vrf table as type-5
3397 static void delete_withdraw_vrf_routes(struct bgp
*bgp_vrf
)
3399 /* delete all ipv4 routes and withdraw from peers */
3400 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3401 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3403 /* delete all ipv6 routes and withdraw from peers */
3404 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3405 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3409 * update and advertise all ipv4 and ipv6 routes in thr vrf table as type-5
3412 static void update_advertise_vrf_routes(struct bgp
*bgp_vrf
)
3414 /* update all ipv4 routes */
3415 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3416 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3418 /* update all ipv6 routes */
3419 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3420 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3424 * update and advertise local routes for a VRF as type-5 routes.
3425 * This is invoked upon RD change for a VRF. Note taht the processing is only
3426 * done in the global route table using the routes which already exist in the
3429 static void update_router_id_vrf(struct bgp
*bgp_vrf
)
3431 /* skip if the RD is configured */
3432 if (is_vrf_rd_configured(bgp_vrf
))
3435 /* derive the RD for the VRF based on new router-id */
3436 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
3438 /* update advertise ipv4|ipv6 routes as type-5 routes */
3439 update_advertise_vrf_routes(bgp_vrf
);
3443 * Delete and withdraw all type-5 routes for the RD corresponding to VRF.
3444 * This is invoked upon VRF RD change. The processing is done only from global
3447 static void withdraw_router_id_vrf(struct bgp
*bgp_vrf
)
3449 /* skip if the RD is configured */
3450 if (is_vrf_rd_configured(bgp_vrf
))
3453 /* delete/withdraw ipv4|ipv6 routes as type-5 routes */
3454 delete_withdraw_vrf_routes(bgp_vrf
);
3458 * Update and advertise local routes for a VNI. Invoked upon router-id
3459 * change. Note that the processing is done only on the global route table
3460 * using routes that already exist in the per-VNI table.
3462 static int update_advertise_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3464 struct prefix_evpn p
;
3465 struct bgp_node
*rn
, *global_rn
;
3466 struct bgp_path_info
*pi
, *global_pi
;
3468 afi_t afi
= AFI_L2VPN
;
3469 safi_t safi
= SAFI_EVPN
;
3471 /* Locate type-3 route for VNI in the per-VNI table and use its
3472 * attributes to create and advertise the type-3 route for this VNI
3473 * in the global table.
3475 * RT-3 only if doing head-end replication
3477 if (bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_HEAD_END_REPL
) {
3478 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3479 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)&p
);
3480 if (!rn
) /* unexpected */
3482 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
3483 if (pi
->peer
== bgp
->peer_self
&&
3484 pi
->type
== ZEBRA_ROUTE_BGP
3485 && pi
->sub_type
== BGP_ROUTE_STATIC
)
3487 if (!pi
) /* unexpected */
3491 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3492 (struct prefix
*)&p
, &vpn
->prd
);
3493 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
,
3494 1, &pi
, 0, mac_mobility_seqnum(attr
));
3496 /* Schedule for processing and unlock node. */
3497 bgp_process(bgp
, global_rn
, afi
, safi
);
3498 bgp_unlock_node(global_rn
);
3501 /* Now, walk this VNI's route table and use the route and its attribute
3502 * to create and schedule route in global table.
3504 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
3505 rn
= bgp_route_next(rn
)) {
3506 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
3508 /* Identify MAC-IP local routes. */
3509 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
3512 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
3513 if (pi
->peer
== bgp
->peer_self
3514 && pi
->type
== ZEBRA_ROUTE_BGP
3515 && pi
->sub_type
== BGP_ROUTE_STATIC
)
3520 /* Create route in global routing table using this route entry's
3524 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3525 (struct prefix
*)evp
, &vpn
->prd
);
3527 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1,
3529 mac_mobility_seqnum(attr
));
3531 /* Schedule for processing and unlock node. */
3532 bgp_process(bgp
, global_rn
, afi
, safi
);
3533 bgp_unlock_node(global_rn
);
3540 * Delete (and withdraw) local routes for a VNI - only from the global
3541 * table. Invoked upon router-id change.
3543 static int delete_withdraw_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3546 struct prefix_evpn p
;
3547 struct bgp_node
*global_rn
;
3548 struct bgp_path_info
*pi
;
3549 afi_t afi
= AFI_L2VPN
;
3550 safi_t safi
= SAFI_EVPN
;
3552 /* Delete and withdraw locally learnt type-2 routes (MACIP)
3553 * for this VNI - from the global table.
3555 ret
= delete_global_type2_routes(bgp
, vpn
);
3559 /* Remove type-3 route for this VNI from global table. */
3560 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3561 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
3562 (struct prefix
*)&p
, &vpn
->prd
);
3564 /* Delete route entry in the global EVPN table. */
3565 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
3567 /* Schedule for processing - withdraws to peers happen from
3571 bgp_process(bgp
, global_rn
, afi
, safi
);
3572 bgp_unlock_node(global_rn
);
3579 * Handle router-id change. Update and advertise local routes corresponding
3580 * to this VNI from peers. Note that this is invoked after updating the
3581 * router-id. The routes in the per-VNI table are used to create routes in
3582 * the global table and schedule them.
3584 static void update_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3586 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3588 /* Skip VNIs with configured RD. */
3589 if (is_rd_configured(vpn
))
3592 bgp_evpn_derive_auto_rd(bgp
, vpn
);
3593 update_advertise_vni_routes(bgp
, vpn
);
3597 * Handle router-id change. Delete and withdraw local routes corresponding
3598 * to this VNI from peers. Note that this is invoked prior to updating
3599 * the router-id and is done only on the global route table, the routes
3600 * are needed in the per-VNI table to re-advertise with new router id.
3602 static void withdraw_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3604 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3606 /* Skip VNIs with configured RD. */
3607 if (is_rd_configured(vpn
))
3610 delete_withdraw_vni_routes(bgp
, vpn
);
3614 * Create RT-3 for a VNI and schedule for processing and advertisement.
3615 * This is invoked upon flooding mode changing to head-end replication.
3617 static void create_advertise_type3(struct hash_backet
*backet
, void *data
)
3619 struct bgpevpn
*vpn
= backet
->data
;
3620 struct bgp
*bgp
= data
;
3621 struct prefix_evpn p
;
3623 if (!vpn
|| !is_vni_live(vpn
))
3626 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3627 if (update_evpn_route(bgp
, vpn
, &p
, 0, 0))
3628 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
3629 "Type3 route creation failure for VNI %u", vpn
->vni
);
3633 * Delete RT-3 for a VNI and schedule for processing and withdrawal.
3634 * This is invoked upon flooding mode changing to drop BUM packets.
3636 static void delete_withdraw_type3(struct hash_backet
*backet
, void *data
)
3638 struct bgpevpn
*vpn
= backet
->data
;
3639 struct bgp
*bgp
= data
;
3640 struct prefix_evpn p
;
3642 if (!vpn
|| !is_vni_live(vpn
))
3645 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3646 delete_evpn_route(bgp
, vpn
, &p
);
3650 * Process received EVPN type-2 route (advertise or withdraw).
3652 static int process_type2_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3653 struct attr
*attr
, uint8_t *pfx
, int psize
,
3654 uint32_t addpath_id
)
3656 struct prefix_rd prd
;
3657 struct prefix_evpn p
;
3658 struct bgp_route_evpn evpn
;
3660 uint8_t macaddr_len
;
3661 mpls_label_t label
[BGP_MAX_LABELS
]; /* holds the VNI(s) as in packet */
3662 uint32_t num_labels
= 0;
3666 /* Type-2 route should be either 33, 37 or 49 bytes or an
3667 * additional 3 bytes if there is a second label (VNI):
3668 * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1),
3669 * MAC Addr (6), IP len (1), IP (0, 4 or 16),
3670 * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3)
3672 if (psize
!= 33 && psize
!= 37 && psize
!= 49 && psize
!= 36
3673 && psize
!= 40 && psize
!= 52) {
3674 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3675 "%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
3676 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3680 memset(&evpn
, 0, sizeof(evpn
));
3682 /* Make prefix_rd */
3683 prd
.family
= AF_UNSPEC
;
3685 memcpy(&prd
.val
, pfx
, 8);
3688 /* Make EVPN prefix. */
3689 memset(&p
, 0, sizeof(struct prefix_evpn
));
3691 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3692 p
.prefix
.route_type
= BGP_EVPN_MAC_IP_ROUTE
;
3694 /* Copy Ethernet Seg Identifier */
3695 memcpy(&evpn
.eth_s_id
.val
, pfx
, ESI_LEN
);
3698 /* Copy Ethernet Tag */
3699 memcpy(ð_tag
, pfx
, 4);
3700 p
.prefix
.macip_addr
.eth_tag
= ntohl(eth_tag
);
3703 /* Get the MAC Addr len */
3704 macaddr_len
= *pfx
++;
3706 /* Get the MAC Addr */
3707 if (macaddr_len
== (ETH_ALEN
* 8)) {
3708 memcpy(&p
.prefix
.macip_addr
.mac
.octet
, pfx
, ETH_ALEN
);
3712 EC_BGP_EVPN_ROUTE_INVALID
,
3713 "%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
3714 peer
->bgp
->vrf_id
, peer
->host
, macaddr_len
);
3720 ipaddr_len
= *pfx
++;
3721 if (ipaddr_len
!= 0 && ipaddr_len
!= IPV4_MAX_BITLEN
3722 && ipaddr_len
!= IPV6_MAX_BITLEN
) {
3724 EC_BGP_EVPN_ROUTE_INVALID
,
3725 "%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
3726 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3731 ipaddr_len
/= 8; /* Convert to bytes. */
3732 p
.prefix
.macip_addr
.ip
.ipa_type
= (ipaddr_len
== IPV4_MAX_BYTELEN
)
3735 memcpy(&p
.prefix
.macip_addr
.ip
.ip
.addr
, pfx
, ipaddr_len
);
3739 /* Get the VNI(s). Stored as bytes here. */
3741 memset(label
, 0, sizeof(label
));
3742 memcpy(&label
[0], pfx
, BGP_LABEL_BYTES
);
3743 pfx
+= BGP_LABEL_BYTES
;
3744 psize
-= (33 + ipaddr_len
);
3745 /* Do we have a second VNI? */
3748 memcpy(&label
[1], pfx
, BGP_LABEL_BYTES
);
3750 * If in future, we are required to access additional fields,
3751 * we MUST increment pfx by BGP_LABEL_BYTES in before reading
3756 /* Process the route. */
3758 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3759 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3760 &prd
, &label
[0], num_labels
, 0, &evpn
);
3762 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3763 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3764 &prd
, &label
[0], num_labels
, &evpn
);
3769 * Process received EVPN type-3 route (advertise or withdraw).
3771 static int process_type3_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3772 struct attr
*attr
, uint8_t *pfx
, int psize
,
3773 uint32_t addpath_id
)
3775 struct prefix_rd prd
;
3776 struct prefix_evpn p
;
3781 /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
3782 * IP len (1) and IP (4 or 16).
3784 if (psize
!= 17 && psize
!= 29) {
3785 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3786 "%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
3787 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3791 /* If PMSI is present, log if it is anything other than IR.
3792 * Note: We just simply ignore the values as it is not clear if
3793 * doing anything else is better.
3796 (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
))) {
3797 if (attr
->pmsi_tnl_type
!= PMSI_TNLTYPE_INGR_REPL
) {
3799 EC_BGP_EVPN_PMSI_PRESENT
,
3800 "%u:%s - Rx EVPN Type-3 NLRI with unsupported PTA %d",
3801 peer
->bgp
->vrf_id
, peer
->host
,
3802 attr
->pmsi_tnl_type
);
3806 /* Make prefix_rd */
3807 prd
.family
= AF_UNSPEC
;
3809 memcpy(&prd
.val
, pfx
, 8);
3812 /* Make EVPN prefix. */
3813 memset(&p
, 0, sizeof(struct prefix_evpn
));
3815 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3816 p
.prefix
.route_type
= BGP_EVPN_IMET_ROUTE
;
3818 /* Copy Ethernet Tag */
3819 memcpy(ð_tag
, pfx
, 4);
3820 p
.prefix
.imet_addr
.eth_tag
= ntohl(eth_tag
);
3824 ipaddr_len
= *pfx
++;
3825 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3826 p
.prefix
.imet_addr
.ip
.ipa_type
= IPADDR_V4
;
3827 memcpy(&p
.prefix
.imet_addr
.ip
.ip
.addr
, pfx
, IPV4_MAX_BYTELEN
);
3830 EC_BGP_EVPN_ROUTE_INVALID
,
3831 "%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
3832 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3836 /* Process the route. */
3838 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3839 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3840 &prd
, NULL
, 0, 0, NULL
);
3842 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3843 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3844 &prd
, NULL
, 0, NULL
);
3849 * Process received EVPN type-4 route (advertise or withdraw).
3851 static int process_type4_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3852 struct attr
*attr
, uint8_t *pfx
, int psize
,
3853 uint32_t addpath_id
)
3858 struct in_addr vtep_ip
;
3859 struct prefix_rd prd
;
3860 struct prefix_evpn p
;
3862 /* Type-4 route should be either 23 or 35 bytes
3863 * RD (8), ESI (10), ip-len (1), ip (4 or 16)
3865 if (psize
!= 23 && psize
!= 35) {
3866 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3867 "%u:%s - Rx EVPN Type-4 NLRI with invalid length %d",
3868 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3872 /* Make prefix_rd */
3873 prd
.family
= AF_UNSPEC
;
3875 memcpy(&prd
.val
, pfx
, 8);
3879 memcpy(&esi
, pfx
, ESI_BYTES
);
3884 ipaddr_len
= *pfx
++;
3885 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3886 memcpy(&vtep_ip
, pfx
, IPV4_MAX_BYTELEN
);
3889 EC_BGP_EVPN_ROUTE_INVALID
,
3890 "%u:%s - Rx EVPN Type-4 NLRI with unsupported IP address length %d",
3891 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3895 build_evpn_type4_prefix(&p
, &esi
, vtep_ip
);
3896 /* Process the route. */
3898 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3899 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3900 &prd
, NULL
, 0, 0, NULL
);
3902 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3903 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3904 &prd
, NULL
, 0, NULL
);
3911 * Process received EVPN type-5 route (advertise or withdraw).
3913 static int process_type5_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3914 struct attr
*attr
, uint8_t *pfx
, int psize
,
3915 uint32_t addpath_id
, int withdraw
)
3917 struct prefix_rd prd
;
3918 struct prefix_evpn p
;
3919 struct bgp_route_evpn evpn
;
3922 mpls_label_t label
; /* holds the VNI as in the packet */
3925 /* Type-5 route should be 34 or 58 bytes:
3926 * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16),
3927 * GW (4 or 16) and VNI (3).
3928 * Note that the IP and GW should both be IPv4 or both IPv6.
3930 if (psize
!= 34 && psize
!= 58) {
3931 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3932 "%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
3933 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3937 /* Make prefix_rd */
3938 prd
.family
= AF_UNSPEC
;
3940 memcpy(&prd
.val
, pfx
, 8);
3943 /* Make EVPN prefix. */
3944 memset(&p
, 0, sizeof(struct prefix_evpn
));
3946 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3947 p
.prefix
.route_type
= BGP_EVPN_IP_PREFIX_ROUTE
;
3949 /* Additional information outside of prefix - ESI and GW IP */
3950 memset(&evpn
, 0, sizeof(evpn
));
3953 memcpy(&evpn
.eth_s_id
.val
, pfx
, 10);
3956 /* Fetch Ethernet Tag. */
3957 memcpy(ð_tag
, pfx
, 4);
3958 p
.prefix
.prefix_addr
.eth_tag
= ntohl(eth_tag
);
3961 /* Fetch IP prefix length. */
3963 if (ippfx_len
> IPV6_MAX_BITLEN
) {
3965 EC_BGP_EVPN_ROUTE_INVALID
,
3966 "%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
3967 peer
->bgp
->vrf_id
, peer
->host
, ippfx_len
);
3970 p
.prefix
.prefix_addr
.ip_prefix_length
= ippfx_len
;
3972 /* Determine IPv4 or IPv6 prefix */
3973 /* Since the address and GW are from the same family, this just becomes
3974 * a simple check on the total size.
3977 SET_IPADDR_V4(&p
.prefix
.prefix_addr
.ip
);
3978 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v4
, pfx
, 4);
3980 memcpy(&evpn
.gw_ip
.ipv4
, pfx
, 4);
3983 SET_IPADDR_V6(&p
.prefix
.prefix_addr
.ip
);
3984 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v6
, pfx
, 16);
3986 memcpy(&evpn
.gw_ip
.ipv6
, pfx
, 16);
3990 /* Get the VNI (in MPLS label field). Stored as bytes here. */
3991 memset(&label
, 0, sizeof(label
));
3992 memcpy(&label
, pfx
, BGP_LABEL_BYTES
);
3995 * If in future, we are required to access additional fields,
3996 * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next
4000 /* Process the route. */
4002 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
4003 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
4004 &prd
, &label
, 1, 0, &evpn
);
4006 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
4007 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
4008 &prd
, &label
, 1, &evpn
);
4013 static void evpn_mpattr_encode_type5(struct stream
*s
, struct prefix
*p
,
4014 struct prefix_rd
*prd
, mpls_label_t
*label
,
4015 uint32_t num_labels
, struct attr
*attr
)
4019 struct evpn_addr
*p_evpn_p
;
4021 memset(&temp
, 0, 16);
4022 if (p
->family
!= AF_EVPN
)
4024 p_evpn_p
= &(p
->u
.prefix_evpn
);
4026 /* len denites the total len of IP and GW-IP in the route
4027 IP and GW-IP have to be both ipv4 or ipv6
4029 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
4030 len
= 8; /* IP and GWIP are both ipv4 */
4032 len
= 32; /* IP and GWIP are both ipv6 */
4033 /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */
4034 stream_putc(s
, 8 + 10 + 4 + 1 + len
+ 3);
4035 stream_put(s
, prd
->val
, 8);
4037 stream_put(s
, &(attr
->evpn_overlay
.eth_s_id
), 10);
4039 stream_put(s
, &temp
, 10);
4040 stream_putl(s
, p_evpn_p
->prefix_addr
.eth_tag
);
4041 stream_putc(s
, p_evpn_p
->prefix_addr
.ip_prefix_length
);
4042 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
4043 stream_put_ipv4(s
, p_evpn_p
->prefix_addr
.ip
.ipaddr_v4
.s_addr
);
4045 stream_put(s
, &p_evpn_p
->prefix_addr
.ip
.ipaddr_v6
, 16);
4047 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
4049 attr
->evpn_overlay
.gw_ip
.ipv4
.s_addr
);
4051 stream_put(s
, &(attr
->evpn_overlay
.gw_ip
.ipv6
), 16);
4053 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
4054 stream_put_ipv4(s
, 0);
4056 stream_put(s
, &temp
, 16);
4060 stream_put(s
, label
, 3);
4066 * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
4068 static void cleanup_vni_on_disable(struct hash_backet
*backet
, struct bgp
*bgp
)
4070 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
4072 /* Remove EVPN routes and schedule for processing. */
4073 delete_routes_for_vni(bgp
, vpn
);
4075 /* Clear "live" flag and see if hash needs to be freed. */
4076 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
4077 if (!is_vni_configured(vpn
))
4078 bgp_evpn_free(bgp
, vpn
);
4082 * Free a VNI entry; iterator function called during cleanup.
4084 static void free_vni_entry(struct hash_backet
*backet
, struct bgp
*bgp
)
4086 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
4088 delete_all_vni_routes(bgp
, vpn
);
4089 bgp_evpn_free(bgp
, vpn
);
4093 * Derive AUTO import RT for BGP VRF - L3VNI
4095 static void evpn_auto_rt_import_add_for_vrf(struct bgp
*bgp_vrf
)
4097 struct bgp
*bgp_def
= NULL
;
4099 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
4100 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4103 bgp_def
= bgp_get_default();
4106 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4110 * Delete AUTO import RT from BGP VRF - L3VNI
4112 static void evpn_auto_rt_import_delete_for_vrf(struct bgp
*bgp_vrf
)
4114 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
4118 * Derive AUTO export RT for BGP VRF - L3VNI
4120 static void evpn_auto_rt_export_add_for_vrf(struct bgp
*bgp_vrf
)
4122 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4123 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4127 * Delete AUTO export RT from BGP VRF - L3VNI
4129 static void evpn_auto_rt_export_delete_for_vrf(struct bgp
*bgp_vrf
)
4131 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4134 static void bgp_evpn_handle_export_rt_change_for_vrf(struct bgp
*bgp_vrf
)
4136 struct bgp
*bgp_def
= NULL
;
4137 struct listnode
*node
= NULL
;
4138 struct bgpevpn
*vpn
= NULL
;
4140 bgp_def
= bgp_get_default();
4144 /* update all type-5 routes */
4145 update_advertise_vrf_routes(bgp_vrf
);
4147 /* update all type-2 routes */
4148 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4149 update_routes_for_vni(bgp_def
, vpn
);
4153 * Handle autort change for a given VNI.
4155 static void update_autort_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
4157 struct bgpevpn
*vpn
= backet
->data
;
4159 if (!is_import_rt_configured(vpn
)) {
4160 if (is_vni_live(vpn
))
4161 bgp_evpn_uninstall_routes(bgp
, vpn
);
4162 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4163 list_delete_all_node(vpn
->import_rtl
);
4164 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
4165 if (is_vni_live(vpn
))
4166 bgp_evpn_install_routes(bgp
, vpn
);
4168 if (!is_export_rt_configured(vpn
)) {
4169 list_delete_all_node(vpn
->export_rtl
);
4170 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
4171 if (is_vni_live(vpn
))
4172 bgp_evpn_handle_export_rt_change(bgp
, vpn
);
4180 /* withdraw type-5 route corresponding to ip prefix */
4181 void bgp_evpn_withdraw_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4182 afi_t afi
, safi_t safi
)
4185 struct prefix_evpn evp
;
4186 char buf
[PREFIX_STRLEN
];
4188 build_type5_prefix_from_ip_prefix(&evp
, p
);
4189 ret
= delete_evpn_type5_route(bgp_vrf
, &evp
);
4192 EC_BGP_EVPN_ROUTE_DELETE
,
4193 "%u failed to delete type-5 route for prefix %s in vrf %s",
4194 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)),
4195 vrf_id_to_name(bgp_vrf
->vrf_id
));
4199 /* withdraw all type-5 routes for an address family */
4200 void bgp_evpn_withdraw_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
, safi_t safi
)
4202 struct bgp_table
*table
= NULL
;
4203 struct bgp_node
*rn
= NULL
;
4204 struct bgp_path_info
*pi
;
4206 table
= bgp_vrf
->rib
[afi
][safi
];
4207 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4208 /* Only care about "selected" routes - non-imported. */
4209 /* TODO: Support for AddPath for EVPN. */
4210 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
4211 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)
4212 && (!pi
->extra
|| !pi
->extra
->parent
)) {
4213 bgp_evpn_withdraw_type5_route(bgp_vrf
, &rn
->p
,
4222 * Advertise IP prefix as type-5 route. The afi/safi and src_attr passed
4223 * to this function correspond to those of the source IP prefix (best
4224 * path in the case of the attr. In the case of a local prefix (when we
4225 * are advertising local subnets), the src_attr will be NULL.
4227 void bgp_evpn_advertise_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4228 struct attr
*src_attr
, afi_t afi
,
4232 struct prefix_evpn evp
;
4233 char buf
[PREFIX_STRLEN
];
4235 build_type5_prefix_from_ip_prefix(&evp
, p
);
4236 ret
= update_evpn_type5_route(bgp_vrf
, &evp
, src_attr
);
4238 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
4239 "%u: Failed to create type-5 route for prefix %s",
4240 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)));
4243 /* Inject all prefixes of a particular address-family (currently, IPv4 or
4244 * IPv6 unicast) into EVPN as type-5 routes. This is invoked when the
4245 * advertisement is enabled.
4247 void bgp_evpn_advertise_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
,
4250 struct bgp_table
*table
= NULL
;
4251 struct bgp_node
*rn
= NULL
;
4252 struct bgp_path_info
*pi
;
4254 table
= bgp_vrf
->rib
[afi
][safi
];
4255 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4256 /* Need to identify the "selected" route entry to use its
4257 * attribute. Also, we only consider "non-imported" routes.
4258 * TODO: Support for AddPath for EVPN.
4260 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
4261 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)
4262 && (!pi
->extra
|| !pi
->extra
->parent
)) {
4264 /* apply the route-map */
4265 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
) {
4268 ret
= route_map_apply(
4269 bgp_vrf
->adv_cmd_rmap
[afi
][safi
]
4271 &rn
->p
, RMAP_BGP
, pi
);
4272 if (ret
== RMAP_DENYMATCH
)
4275 bgp_evpn_advertise_type5_route(
4276 bgp_vrf
, &rn
->p
, pi
->attr
, afi
, safi
);
4283 void evpn_rt_delete_auto(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
4285 struct listnode
*node
, *nnode
, *node_to_del
;
4286 struct ecommunity
*ecom
, *ecom_auto
;
4287 struct ecommunity_val eval
;
4289 if (bgp
->advertise_autort_rfc8365
)
4290 vni
|= EVPN_AUTORT_VXLAN
;
4291 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
4293 ecom_auto
= ecommunity_new();
4294 ecommunity_add_val(ecom_auto
, &eval
);
4297 for (ALL_LIST_ELEMENTS(rtl
, node
, nnode
, ecom
)) {
4298 if (ecommunity_match(ecom
, ecom_auto
)) {
4299 ecommunity_free(&ecom
);
4305 list_delete_node(rtl
, node_to_del
);
4307 ecommunity_free(&ecom_auto
);
4310 void bgp_evpn_configure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4311 struct ecommunity
*ecomadd
)
4313 /* uninstall routes from vrf */
4314 uninstall_routes_for_vrf(bgp_vrf
);
4316 /* Cleanup the RT to VRF mapping */
4317 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4319 /* Remove auto generated RT */
4320 evpn_auto_rt_import_delete_for_vrf(bgp_vrf
);
4322 /* Add the newly configured RT to RT list */
4323 listnode_add_sort(bgp_vrf
->vrf_import_rtl
, ecomadd
);
4324 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4326 /* map VRF to its RTs */
4327 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4329 /* install routes matching the new VRF */
4330 install_routes_for_vrf(bgp_vrf
);
4333 void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4334 struct ecommunity
*ecomdel
)
4336 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4337 struct ecommunity
*ecom
= NULL
;
4339 /* uninstall routes from vrf */
4340 uninstall_routes_for_vrf(bgp_vrf
);
4342 /* Cleanup the RT to VRF mapping */
4343 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4345 /* remove the RT from the RT list */
4346 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4347 if (ecommunity_match(ecom
, ecomdel
)) {
4348 ecommunity_free(&ecom
);
4355 list_delete_node(bgp_vrf
->vrf_import_rtl
, node_to_del
);
4357 assert(bgp_vrf
->vrf_import_rtl
);
4358 /* fallback to auto import rt, if this was the last RT */
4359 if (bgp_vrf
->vrf_import_rtl
&& list_isempty(bgp_vrf
->vrf_import_rtl
)) {
4360 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4361 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
4364 /* map VRFs to its RTs */
4365 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4367 /* install routes matching this new RT */
4368 install_routes_for_vrf(bgp_vrf
);
4371 void bgp_evpn_configure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4372 struct ecommunity
*ecomadd
)
4374 /* remove auto-generated RT */
4375 evpn_auto_rt_export_delete_for_vrf(bgp_vrf
);
4377 /* Add the new RT to the RT list */
4378 listnode_add_sort(bgp_vrf
->vrf_export_rtl
, ecomadd
);
4379 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4381 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4384 void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4385 struct ecommunity
*ecomdel
)
4387 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4388 struct ecommunity
*ecom
= NULL
;
4390 /* Remove the RT from the RT list */
4391 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, ecom
)) {
4392 if (ecommunity_match(ecom
, ecomdel
)) {
4393 ecommunity_free(&ecom
);
4400 list_delete_node(bgp_vrf
->vrf_export_rtl
, node_to_del
);
4403 * Temporary assert to make SA happy.
4404 * The ALL_LIST_ELEMENTS macro above has a NULL check
4405 * which means that SA is going to complain about
4406 * the list_isempty call, which doesn't NULL check.
4407 * So until we get this situation cleaned up, here
4410 assert(bgp_vrf
->vrf_export_rtl
);
4412 /* fall back to auto-generated RT if this was the last RT */
4413 if (list_isempty(bgp_vrf
->vrf_export_rtl
)) {
4414 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4415 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
4418 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4422 * Handle change to BGP router id. This is invoked twice by the change
4423 * handler, first before the router id has been changed and then after
4424 * the router id has been changed. The first invocation will result in
4425 * local routes for all VNIs/VRF being deleted and withdrawn and the next
4426 * will result in the routes being re-advertised.
4428 void bgp_evpn_handle_router_id_update(struct bgp
*bgp
, int withdraw
)
4432 /* delete and withdraw all the type-5 routes
4433 stored in the global table for this vrf
4435 withdraw_router_id_vrf(bgp
);
4437 /* delete all the VNI routes (type-2/type-3) routes for all the
4440 hash_iterate(bgp
->vnihash
,
4441 (void (*)(struct hash_backet
*,
4442 void *))withdraw_router_id_vni
,
4446 /* advertise all routes in the vrf as type-5 routes with the new
4449 update_router_id_vrf(bgp
);
4451 /* advertise all the VNI routes (type-2/type-3) routes with the
4454 hash_iterate(bgp
->vnihash
,
4455 (void (*)(struct hash_backet
*,
4456 void *))update_router_id_vni
,
4462 * Handle change to auto-RT algorithm - update and advertise local routes.
4464 void bgp_evpn_handle_autort_change(struct bgp
*bgp
)
4466 hash_iterate(bgp
->vnihash
,
4467 (void (*)(struct hash_backet
*,
4468 void*))update_autort_vni
,
4473 * Handle change to export RT - update and advertise local routes.
4475 int bgp_evpn_handle_export_rt_change(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4477 return update_routes_for_vni(bgp
, vpn
);
4480 void bgp_evpn_handle_vrf_rd_change(struct bgp
*bgp_vrf
, int withdraw
)
4483 delete_withdraw_vrf_routes(bgp_vrf
);
4485 update_advertise_vrf_routes(bgp_vrf
);
4489 * Handle change to RD. This is invoked twice by the change handler,
4490 * first before the RD has been changed and then after the RD has
4491 * been changed. The first invocation will result in local routes
4492 * of this VNI being deleted and withdrawn and the next will result
4493 * in the routes being re-advertised.
4495 void bgp_evpn_handle_rd_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
4499 delete_withdraw_vni_routes(bgp
, vpn
);
4501 update_advertise_vni_routes(bgp
, vpn
);
4505 * Install routes for this VNI. Invoked upon change to Import RT.
4507 int bgp_evpn_install_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4509 return install_routes_for_vni(bgp
, vpn
);
4513 * Uninstall all routes installed for this VNI. Invoked upon change
4516 int bgp_evpn_uninstall_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4518 return uninstall_routes_for_vni(bgp
, vpn
);
4522 * TODO: Hardcoded for a maximum of 2 VNIs right now
4524 char *bgp_evpn_label2str(mpls_label_t
*label
, uint32_t num_labels
, char *buf
,
4529 vni1
= label2vni(label
);
4530 if (num_labels
== 2) {
4531 vni2
= label2vni(label
+ 1);
4532 snprintf(buf
, len
, "%u/%u", vni1
, vni2
);
4534 snprintf(buf
, len
, "%u", vni1
);
4539 * Function to convert evpn route to json format.
4540 * NOTE: We don't use prefix2str as the output here is a bit different.
4542 void bgp_evpn_route2json(struct prefix_evpn
*p
, json_object
*json
)
4544 char buf1
[ETHER_ADDR_STRLEN
];
4545 char buf2
[PREFIX2STR_BUFFER
];
4550 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4551 json_object_int_add(json
, "routeType", p
->prefix
.route_type
);
4552 json_object_int_add(json
, "ethTag",
4553 p
->prefix
.imet_addr
.eth_tag
);
4554 json_object_int_add(json
, "ipLen",
4555 is_evpn_prefix_ipaddr_v4(p
)
4558 json_object_string_add(json
, "ip",
4559 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4560 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4561 if (is_evpn_prefix_ipaddr_none(p
)) {
4562 json_object_int_add(json
, "routeType",
4563 p
->prefix
.route_type
);
4564 json_object_int_add(json
, "ethTag",
4565 p
->prefix
.macip_addr
.eth_tag
);
4566 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4567 json_object_string_add(json
, "mac",
4568 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4574 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4577 json_object_int_add(json
, "routeType",
4578 p
->prefix
.route_type
);
4579 json_object_int_add(json
, "ethTag",
4580 p
->prefix
.macip_addr
.eth_tag
);
4581 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4582 json_object_string_add(json
, "mac",
4583 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4586 json_object_int_add(json
, "ipLen",
4587 is_evpn_prefix_ipaddr_v4(p
)
4590 json_object_string_add(
4593 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4595 PREFIX2STR_BUFFER
));
4598 /* Currently, this is to cater to other AF_ETHERNET code. */
4603 * Function to convert evpn route to string.
4604 * NOTE: We don't use prefix2str as the output here is a bit different.
4606 char *bgp_evpn_route2str(struct prefix_evpn
*p
, char *buf
, int len
)
4608 char buf1
[ETHER_ADDR_STRLEN
];
4609 char buf2
[PREFIX2STR_BUFFER
];
4610 char buf3
[ESI_STR_LEN
];
4612 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4613 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]", p
->prefix
.route_type
,
4614 p
->prefix
.imet_addr
.eth_tag
,
4615 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4617 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4618 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4619 if (is_evpn_prefix_ipaddr_none(p
))
4620 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4621 p
->prefix
.route_type
,
4622 p
->prefix
.macip_addr
.eth_tag
,
4624 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4629 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4631 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]:[%d]:[%s]",
4632 p
->prefix
.route_type
,
4633 p
->prefix
.macip_addr
.eth_tag
,
4635 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4637 family
== AF_INET
? IPV4_MAX_BITLEN
4640 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4642 PREFIX2STR_BUFFER
));
4644 } else if (p
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
4645 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4646 p
->prefix
.route_type
,
4647 p
->prefix
.prefix_addr
.eth_tag
,
4648 p
->prefix
.prefix_addr
.ip_prefix_length
,
4649 is_evpn_prefix_ipaddr_v4(p
)
4650 ? inet_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v4
)
4651 : inet6_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v6
));
4652 } else if (p
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
4653 snprintf(buf
, len
, "[%d]:[%s]:[%d]:[%s]",
4654 p
->prefix
.route_type
,
4655 esi_to_str(&p
->prefix
.es_addr
.esi
, buf3
, sizeof(buf3
)),
4656 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4658 inet_ntoa(p
->prefix
.es_addr
.ip
.ipaddr_v4
));
4660 /* For EVPN route types not supported yet. */
4661 snprintf(buf
, len
, "(unsupported route type %d)",
4662 p
->prefix
.route_type
);
4669 * Encode EVPN prefix in Update (MP_REACH)
4671 void bgp_evpn_encode_prefix(struct stream
*s
, struct prefix
*p
,
4672 struct prefix_rd
*prd
, mpls_label_t
*label
,
4673 uint32_t num_labels
, struct attr
*attr
,
4674 int addpath_encode
, uint32_t addpath_tx_id
)
4676 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
4677 int len
, ipa_len
= 0;
4680 stream_putl(s
, addpath_tx_id
);
4683 stream_putc(s
, evp
->prefix
.route_type
);
4685 switch (evp
->prefix
.route_type
) {
4686 case BGP_EVPN_MAC_IP_ROUTE
:
4687 if (is_evpn_prefix_ipaddr_v4(evp
))
4688 ipa_len
= IPV4_MAX_BYTELEN
;
4689 else if (is_evpn_prefix_ipaddr_v6(evp
))
4690 ipa_len
= IPV6_MAX_BYTELEN
;
4691 /* RD, ESI, EthTag, MAC+len, IP len, [IP], 1 VNI */
4692 len
= 8 + 10 + 4 + 1 + 6 + 1 + ipa_len
+ 3;
4693 if (ipa_len
&& num_labels
> 1) /* There are 2 VNIs */
4695 stream_putc(s
, len
);
4696 stream_put(s
, prd
->val
, 8); /* RD */
4698 stream_put(s
, &attr
->evpn_overlay
.eth_s_id
, ESI_LEN
);
4700 stream_put(s
, 0, 10);
4701 stream_putl(s
, evp
->prefix
.macip_addr
.eth_tag
); /* Ethernet Tag ID */
4702 stream_putc(s
, 8 * ETH_ALEN
); /* Mac Addr Len - bits */
4703 stream_put(s
, evp
->prefix
.macip_addr
.mac
.octet
, 6); /* Mac Addr */
4704 stream_putc(s
, 8 * ipa_len
); /* IP address Length */
4705 if (ipa_len
) /* IP */
4706 stream_put(s
, &evp
->prefix
.macip_addr
.ip
.ip
.addr
,
4708 /* 1st label is the L2 VNI */
4709 stream_put(s
, label
, BGP_LABEL_BYTES
);
4710 /* Include 2nd label (L3 VNI) if advertising MAC+IP */
4711 if (ipa_len
&& num_labels
> 1)
4712 stream_put(s
, label
+ 1, BGP_LABEL_BYTES
);
4715 case BGP_EVPN_IMET_ROUTE
:
4716 stream_putc(s
, 17); // TODO: length - assumes IPv4 address
4717 stream_put(s
, prd
->val
, 8); /* RD */
4718 stream_putl(s
, evp
->prefix
.imet_addr
.eth_tag
); /* Ethernet Tag ID */
4719 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4720 /* Originating Router's IP Addr */
4721 stream_put_in_addr(s
, &evp
->prefix
.imet_addr
.ip
.ipaddr_v4
);
4724 case BGP_EVPN_ES_ROUTE
:
4725 stream_putc(s
, 23); /* TODO: length: assumes ipv4 VTEP */
4726 stream_put(s
, prd
->val
, 8); /* RD */
4727 stream_put(s
, evp
->prefix
.es_addr
.esi
.val
, 10); /* ESI */
4728 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4730 stream_put_in_addr(s
, &evp
->prefix
.es_addr
.ip
.ipaddr_v4
);
4733 case BGP_EVPN_IP_PREFIX_ROUTE
:
4734 /* TODO: AddPath support. */
4735 evpn_mpattr_encode_type5(s
, p
, prd
, label
, num_labels
, attr
);
4743 int bgp_nlri_parse_evpn(struct peer
*peer
, struct attr
*attr
,
4744 struct bgp_nlri
*packet
, int withdraw
)
4750 uint32_t addpath_id
;
4751 int addpath_encoded
;
4756 /* Start processing the NLRI - there may be multiple in the MP_REACH */
4758 lim
= pnt
+ packet
->length
;
4760 safi
= packet
->safi
;
4764 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
4765 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
4766 PEER_CAP_ADDPATH_AF_TX_RCV
));
4768 for (; pnt
< lim
; pnt
+= psize
) {
4769 /* Clear prefix structure. */
4770 memset(&p
, 0, sizeof(struct prefix
));
4772 /* Deal with path-id if AddPath is supported. */
4773 if (addpath_encoded
) {
4774 /* When packet overflow occurs return immediately. */
4775 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
4778 addpath_id
= ntohl(*((uint32_t *)pnt
));
4779 pnt
+= BGP_ADDPATH_ID_LEN
;
4782 /* All EVPN NLRI types start with type and length. */
4789 /* When packet overflow occur return immediately. */
4790 if (pnt
+ psize
> lim
)
4794 case BGP_EVPN_MAC_IP_ROUTE
:
4795 if (process_type2_route(peer
, afi
, safi
,
4796 withdraw
? NULL
: attr
, pnt
,
4797 psize
, addpath_id
)) {
4800 "%u:%s - Error in processing EVPN type-2 NLRI size %d",
4801 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4806 case BGP_EVPN_IMET_ROUTE
:
4807 if (process_type3_route(peer
, afi
, safi
,
4808 withdraw
? NULL
: attr
, pnt
,
4809 psize
, addpath_id
)) {
4812 "%u:%s - Error in processing EVPN type-3 NLRI size %d",
4813 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4818 case BGP_EVPN_ES_ROUTE
:
4819 if (process_type4_route(peer
, afi
, safi
,
4820 withdraw
? NULL
: attr
, pnt
,
4821 psize
, addpath_id
)) {
4824 "%u:%s - Error in processing EVPN type-4 NLRI size %d",
4825 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4830 case BGP_EVPN_IP_PREFIX_ROUTE
:
4831 if (process_type5_route(peer
, afi
, safi
, attr
, pnt
,
4832 psize
, addpath_id
, withdraw
)) {
4835 "%u:%s - Error in processing EVPN type-5 NLRI size %d",
4836 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4846 /* Packet length consistency check. */
4854 * Map the RTs (configured or automatically derived) of a VRF to the VRF.
4855 * The mapping will be used during route processing.
4856 * bgp_def: default bgp instance
4857 * bgp_vrf: specific bgp vrf instance on which RT is configured
4859 void bgp_evpn_map_vrf_to_its_rts(struct bgp
*bgp_vrf
)
4862 struct ecommunity_val
*eval
= NULL
;
4863 struct listnode
*node
= NULL
, *nnode
= NULL
;
4864 struct ecommunity
*ecom
= NULL
;
4866 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4867 for (i
= 0; i
< ecom
->size
; i
++) {
4868 eval
= (struct ecommunity_val
*)(ecom
->val
4870 * ECOMMUNITY_SIZE
));
4871 map_vrf_to_rt(bgp_vrf
, eval
);
4877 * Unmap the RTs (configured or automatically derived) of a VRF from the VRF.
4879 void bgp_evpn_unmap_vrf_from_its_rts(struct bgp
*bgp_vrf
)
4882 struct ecommunity_val
*eval
;
4883 struct listnode
*node
, *nnode
;
4884 struct ecommunity
*ecom
;
4886 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4887 for (i
= 0; i
< ecom
->size
; i
++) {
4888 struct vrf_irt_node
*irt
;
4889 struct ecommunity_val eval_tmp
;
4891 eval
= (struct ecommunity_val
*)(ecom
->val
4893 * ECOMMUNITY_SIZE
));
4894 /* If using "automatic" RT, we only care about the
4895 * local-admin sub-field.
4896 * This is to facilitate using VNI as the RT for EBGP
4899 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4900 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
4901 BGP_VRF_IMPORT_RT_CFGD
))
4902 mask_ecom_global_admin(&eval_tmp
, eval
);
4904 irt
= lookup_vrf_import_rt(&eval_tmp
);
4906 unmap_vrf_from_rt(bgp_vrf
, irt
);
4913 * Map the RTs (configured or automatically derived) of a VNI to the VNI.
4914 * The mapping will be used during route processing.
4916 void bgp_evpn_map_vni_to_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4919 struct ecommunity_val
*eval
;
4920 struct listnode
*node
, *nnode
;
4921 struct ecommunity
*ecom
;
4923 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4924 for (i
= 0; i
< ecom
->size
; i
++) {
4925 eval
= (struct ecommunity_val
*)(ecom
->val
4927 * ECOMMUNITY_SIZE
));
4928 map_vni_to_rt(bgp
, vpn
, eval
);
4934 * Unmap the RTs (configured or automatically derived) of a VNI from the VNI.
4936 void bgp_evpn_unmap_vni_from_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4939 struct ecommunity_val
*eval
;
4940 struct listnode
*node
, *nnode
;
4941 struct ecommunity
*ecom
;
4943 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4944 for (i
= 0; i
< ecom
->size
; i
++) {
4945 struct irt_node
*irt
;
4946 struct ecommunity_val eval_tmp
;
4948 eval
= (struct ecommunity_val
*)(ecom
->val
4950 * ECOMMUNITY_SIZE
));
4951 /* If using "automatic" RT, we only care about the
4952 * local-admin sub-field.
4953 * This is to facilitate using VNI as the RT for EBGP
4956 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4957 if (!is_import_rt_configured(vpn
))
4958 mask_ecom_global_admin(&eval_tmp
, eval
);
4960 irt
= lookup_import_rt(bgp
, &eval_tmp
);
4962 unmap_vni_from_rt(bgp
, vpn
, irt
);
4968 * Derive Import RT automatically for VNI and map VNI to RT.
4969 * The mapping will be used during route processing.
4971 void bgp_evpn_derive_auto_rt_import(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4973 form_auto_rt(bgp
, vpn
->vni
, vpn
->import_rtl
);
4974 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
4977 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
4981 * Derive Export RT automatically for VNI.
4983 void bgp_evpn_derive_auto_rt_export(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4985 form_auto_rt(bgp
, vpn
->vni
, vpn
->export_rtl
);
4986 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
4990 * Derive RD automatically for VNI using passed information - it
4991 * is of the form RouterId:unique-id-for-vni.
4993 void bgp_evpn_derive_auto_rd_for_vrf(struct bgp
*bgp
)
4995 form_auto_rd(bgp
->router_id
, bgp
->vrf_rd_id
, &bgp
->vrf_prd
);
4999 * Derive RD automatically for VNI using passed information - it
5000 * is of the form RouterId:unique-id-for-vni.
5002 void bgp_evpn_derive_auto_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
5006 vpn
->prd
.family
= AF_UNSPEC
;
5007 vpn
->prd
.prefixlen
= 64;
5008 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), vpn
->rd_id
);
5009 (void)str2prefix_rd(buf
, &vpn
->prd
);
5010 UNSET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
5016 bool bgp_evpn_lookup_l3vni_l2vni_table(vni_t vni
)
5018 struct list
*inst
= bm
->bgp
;
5019 struct listnode
*node
;
5020 struct bgp
*bgp_vrf
;
5022 for (ALL_LIST_ELEMENTS_RO(inst
, node
, bgp_vrf
)) {
5023 if (bgp_vrf
->l3vni
== vni
)
5033 struct bgpevpn
*bgp_evpn_lookup_vni(struct bgp
*bgp
, vni_t vni
)
5035 struct bgpevpn
*vpn
;
5038 memset(&tmp
, 0, sizeof(struct bgpevpn
));
5040 vpn
= hash_lookup(bgp
->vnihash
, &tmp
);
5045 * Create a new vpn - invoked upon configuration or zebra notification.
5047 struct bgpevpn
*bgp_evpn_new(struct bgp
*bgp
, vni_t vni
,
5048 struct in_addr originator_ip
,
5049 vrf_id_t tenant_vrf_id
)
5051 struct bgpevpn
*vpn
;
5056 vpn
= XCALLOC(MTYPE_BGP_EVPN
, sizeof(struct bgpevpn
));
5060 /* Set values - RD and RT set to defaults. */
5062 vpn
->originator_ip
= originator_ip
;
5063 vpn
->tenant_vrf_id
= tenant_vrf_id
;
5065 /* Initialize route-target import and export lists */
5066 vpn
->import_rtl
= list_new();
5067 vpn
->import_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
5068 vpn
->import_rtl
->del
= evpn_xxport_delete_ecomm
;
5069 vpn
->export_rtl
= list_new();
5070 vpn
->export_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
5071 vpn
->export_rtl
->del
= evpn_xxport_delete_ecomm
;
5072 bf_assign_index(bm
->rd_idspace
, vpn
->rd_id
);
5073 derive_rd_rt_for_vni(bgp
, vpn
);
5075 /* Initialize EVPN route table. */
5076 vpn
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
5079 if (!hash_get(bgp
->vnihash
, vpn
, hash_alloc_intern
)) {
5080 XFREE(MTYPE_BGP_EVPN
, vpn
);
5084 /* add to l2vni list on corresponding vrf */
5085 bgpevpn_link_to_l3vni(vpn
);
5087 QOBJ_REG(vpn
, bgpevpn
);
5092 * Free a given VPN - called in multiple scenarios such as zebra
5093 * notification, configuration being deleted, advertise-all-vni disabled etc.
5094 * This just frees appropriate memory, caller should have taken other
5097 void bgp_evpn_free(struct bgp
*bgp
, struct bgpevpn
*vpn
)
5099 bgpevpn_unlink_from_l3vni(vpn
);
5100 bgp_table_unlock(vpn
->route_table
);
5101 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
5102 list_delete(&vpn
->import_rtl
);
5103 list_delete(&vpn
->export_rtl
);
5104 bf_release_index(bm
->rd_idspace
, vpn
->rd_id
);
5105 hash_release(bgp
->vnihash
, vpn
);
5107 XFREE(MTYPE_BGP_EVPN
, vpn
);
5113 struct evpnes
*bgp_evpn_lookup_es(struct bgp
*bgp
, esi_t
*esi
)
5118 memset(&tmp
, 0, sizeof(struct evpnes
));
5119 memcpy(&tmp
.esi
, esi
, sizeof(esi_t
));
5120 es
= hash_lookup(bgp
->esihash
, &tmp
);
5125 * Create a new local es - invoked upon zebra notification.
5127 struct evpnes
*bgp_evpn_es_new(struct bgp
*bgp
,
5129 struct ipaddr
*originator_ip
)
5137 es
= XCALLOC(MTYPE_BGP_EVPN_ES
, sizeof(struct evpnes
));
5141 /* set the ESI and originator_ip */
5142 memcpy(&es
->esi
, esi
, sizeof(esi_t
));
5143 memcpy(&es
->originator_ip
, originator_ip
, sizeof(struct ipaddr
));
5145 /* Initialise the VTEP list */
5146 es
->vtep_list
= list_new();
5147 es
->vtep_list
->cmp
= evpn_vtep_ip_cmp
;
5149 /* auto derive RD for this es */
5150 bf_assign_index(bm
->rd_idspace
, es
->rd_id
);
5151 es
->prd
.family
= AF_UNSPEC
;
5152 es
->prd
.prefixlen
= 64;
5153 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), es
->rd_id
);
5154 (void)str2prefix_rd(buf
, &es
->prd
);
5156 /* Initialize the ES route table */
5157 es
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
5160 if (!hash_get(bgp
->esihash
, es
, hash_alloc_intern
)) {
5161 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5165 QOBJ_REG(es
, evpnes
);
5171 * This just frees appropriate memory, caller should have taken other
5174 void bgp_evpn_es_free(struct bgp
*bgp
, struct evpnes
*es
)
5176 list_delete(&es
->vtep_list
);
5177 bgp_table_unlock(es
->route_table
);
5178 bf_release_index(bm
->rd_idspace
, es
->rd_id
);
5179 hash_release(bgp
->esihash
, es
);
5181 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5185 * Import evpn route from global table to VNI/VRF/ESI.
5187 int bgp_evpn_import_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5188 struct prefix
*p
, struct bgp_path_info
*pi
)
5190 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, pi
, 1);
5194 * Unimport evpn route from VNI/VRF/ESI.
5196 int bgp_evpn_unimport_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5197 struct prefix
*p
, struct bgp_path_info
*pi
)
5199 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, pi
, 0);
5202 /* filter routes which have martian next hops */
5203 int bgp_filter_evpn_routes_upon_martian_nh_change(struct bgp
*bgp
)
5207 struct bgp_node
*rd_rn
, *rn
;
5208 struct bgp_table
*table
;
5209 struct bgp_path_info
*pi
;
5214 /* Walk entire global routing table and evaluate routes which could be
5215 * imported into this VPN. Note that we cannot just look at the routes
5216 * for the VNI's RD -
5217 * remote routes applicable for this VNI could have any RD.
5219 /* EVPN routes are a 2-level table. */
5220 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
5221 rd_rn
= bgp_route_next(rd_rn
)) {
5222 table
= (struct bgp_table
*)(rd_rn
->info
);
5226 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
5228 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
5230 /* Consider "valid" remote routes applicable for
5232 if (!(pi
->type
== ZEBRA_ROUTE_BGP
5233 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
5236 if (bgp_nexthop_self(bgp
, pi
->attr
->nexthop
)) {
5238 char attr_str
[BUFSIZ
];
5239 char pbuf
[PREFIX_STRLEN
];
5241 bgp_dump_attr(pi
->attr
, attr_str
,
5244 if (bgp_debug_update(pi
->peer
, &rn
->p
,
5247 "%u: prefix %s with attr %s - DENIED due to martian or self nexthop",
5254 bgp_evpn_unimport_route(bgp
, afi
, safi
,
5257 bgp_rib_remove(rn
, pi
, pi
->peer
, afi
,
5268 * Handle del of a local MACIP.
5270 int bgp_evpn_local_macip_del(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5273 struct bgpevpn
*vpn
;
5274 struct prefix_evpn p
;
5276 /* Lookup VNI hash - should exist. */
5277 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5278 if (!vpn
|| !is_vni_live(vpn
)) {
5279 flog_warn(EC_BGP_EVPN_VPN_VNI
,
5280 "%u: VNI hash entry for VNI %u %s at MACIP DEL",
5281 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5285 /* Remove EVPN type-2 route and schedule for processing. */
5286 build_evpn_type2_prefix(&p
, mac
, ip
);
5287 delete_evpn_route(bgp
, vpn
, &p
);
5293 * Handle add of a local MACIP.
5295 int bgp_evpn_local_macip_add(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5296 struct ipaddr
*ip
, uint8_t flags
, uint32_t seq
)
5298 struct bgpevpn
*vpn
;
5299 struct prefix_evpn p
;
5301 /* Lookup VNI hash - should exist. */
5302 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5303 if (!vpn
|| !is_vni_live(vpn
)) {
5304 flog_warn(EC_BGP_EVPN_VPN_VNI
,
5305 "%u: VNI hash entry for VNI %u %s at MACIP ADD",
5306 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5310 /* Create EVPN type-2 route and schedule for processing. */
5311 build_evpn_type2_prefix(&p
, mac
, ip
);
5312 if (update_evpn_route(bgp
, vpn
, &p
, flags
, seq
)) {
5313 char buf
[ETHER_ADDR_STRLEN
];
5314 char buf2
[INET6_ADDRSTRLEN
];
5317 EC_BGP_EVPN_ROUTE_CREATE
,
5318 "%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
5319 bgp
->vrf_id
, vpn
->vni
,
5320 CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
)
5323 prefix_mac2str(mac
, buf
, sizeof(buf
)),
5324 ipaddr2str(ip
, buf2
, sizeof(buf2
)), flags
);
5331 static void link_l2vni_hash_to_l3vni(struct hash_backet
*backet
,
5332 struct bgp
*bgp_vrf
)
5334 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
5335 struct bgp
*bgp_def
= NULL
;
5337 bgp_def
= bgp_get_default();
5340 if (vpn
->tenant_vrf_id
== bgp_vrf
->vrf_id
)
5341 bgpevpn_link_to_l3vni(vpn
);
5344 int bgp_evpn_local_l3vni_add(vni_t l3vni
, vrf_id_t vrf_id
, struct ethaddr
*rmac
,
5345 struct in_addr originator_ip
, int filter
)
5347 struct bgp
*bgp_vrf
= NULL
; /* bgp VRF instance */
5348 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5349 struct listnode
*node
= NULL
;
5350 struct bgpevpn
*vpn
= NULL
;
5353 /* get the default instance - required to get the AS number for VRF
5356 bgp_def
= bgp_get_default();
5360 "Cannot process L3VNI %u ADD - default BGP instance not yet created",
5366 /* if the BGP vrf instance doesn't exist - create one */
5367 bgp_vrf
= bgp_lookup_by_name(vrf_id_to_name(vrf_id
));
5372 ret
= bgp_get(&bgp_vrf
, &as
, vrf_id_to_name(vrf_id
),
5373 BGP_INSTANCE_TYPE_VRF
);
5375 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
:
5376 flog_err(EC_BGP_MULTI_INSTANCE
,
5377 "'bgp multiple-instance' not present\n");
5379 case BGP_ERR_AS_MISMATCH
:
5380 flog_err(EC_BGP_EVPN_AS_MISMATCH
,
5381 "BGP is already running; AS is %u\n", as
);
5383 case BGP_ERR_INSTANCE_MISMATCH
:
5384 flog_err(EC_BGP_EVPN_INSTANCE_MISMATCH
,
5385 "BGP instance name and AS number mismatch\n");
5389 /* mark as auto created */
5390 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
);
5393 /* associate with l3vni */
5394 bgp_vrf
->l3vni
= l3vni
;
5396 /* set the router mac - to be used in mac-ip routes for this vrf */
5397 memcpy(&bgp_vrf
->rmac
, rmac
, sizeof(struct ethaddr
));
5399 /* set the originator ip */
5400 bgp_vrf
->originator_ip
= originator_ip
;
5402 /* set the right filter - are we using l3vni only for prefix routes? */
5404 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
);
5406 /* auto derive RD/RT */
5407 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
5408 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
5409 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
))
5410 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
5411 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
5413 /* link all corresponding l2vnis */
5414 hash_iterate(bgp_def
->vnihash
,
5415 (void (*)(struct hash_backet
*,
5416 void *))link_l2vni_hash_to_l3vni
,
5419 /* Only update all corresponding type-2 routes if we are advertising two
5420 * labels along with type-2 routes
5423 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
5424 update_routes_for_vni(bgp_def
, vpn
);
5426 /* advertise type-5 routes if needed */
5427 update_advertise_vrf_routes(bgp_vrf
);
5429 /* install all remote routes belonging to this l3vni into correspondng
5431 install_routes_for_vrf(bgp_vrf
);
5436 int bgp_evpn_local_l3vni_del(vni_t l3vni
, vrf_id_t vrf_id
)
5438 struct bgp
*bgp_vrf
= NULL
; /* bgp vrf instance */
5439 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5440 struct listnode
*node
= NULL
;
5441 struct listnode
*next
= NULL
;
5442 struct bgpevpn
*vpn
= NULL
;
5444 bgp_vrf
= bgp_lookup_by_vrf_id(vrf_id
);
5448 "Cannot process L3VNI %u Del - Could not find BGP instance",
5453 bgp_def
= bgp_get_default();
5457 "Cannot process L3VNI %u Del - Could not find default BGP instance",
5462 /* Remove remote routes from BGT VRF even if BGP_VRF_AUTO is configured,
5463 * bgp_delete would not remove/decrement bgp_path_info of the ip_prefix
5464 * routes. This will uninstalling the routes from zebra and decremnt the
5467 uninstall_routes_for_vrf(bgp_vrf
);
5469 /* delete/withdraw all type-5 routes */
5470 delete_withdraw_vrf_routes(bgp_vrf
);
5472 /* remove the l3vni from vrf instance */
5475 /* remove the Rmac from the BGP vrf */
5476 memset(&bgp_vrf
->rmac
, 0, sizeof(struct ethaddr
));
5479 if (!list_isempty(bgp_vrf
->vrf_import_rtl
)) {
5480 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
5481 list_delete_all_node(bgp_vrf
->vrf_import_rtl
);
5483 if (!list_isempty(bgp_vrf
->vrf_export_rtl
)) {
5484 list_delete_all_node(bgp_vrf
->vrf_export_rtl
);
5487 /* update all corresponding local mac-ip routes */
5488 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)) {
5489 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
)) {
5490 UNSET_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
);
5491 update_routes_for_vni(bgp_def
, vpn
);
5495 /* If any L2VNIs point to this instance, unlink them. */
5496 for (ALL_LIST_ELEMENTS(bgp_vrf
->l2vnis
, node
, next
, vpn
))
5497 bgpevpn_unlink_from_l3vni(vpn
);
5499 /* Delete the instance if it was autocreated */
5500 if (CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
5501 bgp_delete(bgp_vrf
);
5507 * Handle del of a local VNI.
5509 int bgp_evpn_local_vni_del(struct bgp
*bgp
, vni_t vni
)
5511 struct bgpevpn
*vpn
;
5513 /* Locate VNI hash */
5514 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5516 if (bgp_debug_zebra(NULL
))
5518 EC_BGP_EVPN_VPN_VNI
,
5519 "%u: VNI hash entry for VNI %u not found at DEL",
5524 /* Remove all local EVPN routes and schedule for processing (to
5525 * withdraw from peers).
5527 delete_routes_for_vni(bgp
, vpn
);
5530 * tunnel is no longer active, del tunnel ip address from tip_hash
5532 bgp_tip_del(bgp
, &vpn
->originator_ip
);
5534 /* Clear "live" flag and see if hash needs to be freed. */
5535 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5536 if (!is_vni_configured(vpn
))
5537 bgp_evpn_free(bgp
, vpn
);
5543 * Handle add (or update) of a local VNI. The VNI changes we care
5544 * about are for the local-tunnel-ip and the (tenant) VRF.
5546 int bgp_evpn_local_vni_add(struct bgp
*bgp
, vni_t vni
,
5547 struct in_addr originator_ip
, vrf_id_t tenant_vrf_id
)
5549 struct bgpevpn
*vpn
;
5550 struct prefix_evpn p
;
5552 /* Lookup VNI. If present and no change, exit. */
5553 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5556 if (is_vni_live(vpn
)
5557 && IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
)
5558 && vpn
->tenant_vrf_id
== tenant_vrf_id
)
5559 /* Probably some other param has changed that we don't
5563 /* Update tenant_vrf_id if it has changed. */
5564 if (vpn
->tenant_vrf_id
!= tenant_vrf_id
) {
5565 bgpevpn_unlink_from_l3vni(vpn
);
5566 vpn
->tenant_vrf_id
= tenant_vrf_id
;
5567 bgpevpn_link_to_l3vni(vpn
);
5570 /* If tunnel endpoint IP has changed, update (and delete prior
5571 * type-3 route, if needed.)
5573 if (!IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
))
5574 handle_tunnel_ip_change(bgp
, vpn
, originator_ip
);
5576 /* Update all routes with new endpoint IP and/or export RT
5579 if (is_vni_live(vpn
))
5580 update_routes_for_vni(bgp
, vpn
);
5583 /* Create or update as appropriate. */
5585 vpn
= bgp_evpn_new(bgp
, vni
, originator_ip
, tenant_vrf_id
);
5589 "%u: Failed to allocate VNI entry for VNI %u - at Add",
5595 /* if the VNI is live already, there is nothing more to do */
5596 if (is_vni_live(vpn
))
5599 /* Mark as "live" */
5600 SET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5602 /* tunnel is now active, add tunnel-ip to db */
5603 bgp_tip_add(bgp
, &originator_ip
);
5605 /* filter routes as nexthop database has changed */
5606 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
5609 * Create EVPN type-3 route and schedule for processing.
5611 * RT-3 only if doing head-end replication
5613 if (bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_HEAD_END_REPL
) {
5614 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
5615 if (update_evpn_route(bgp
, vpn
, &p
, 0, 0)) {
5616 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
5617 "%u: Type3 route creation failure for VNI %u",
5623 /* If we have learnt and retained remote routes (VTEPs, MACs) for this
5627 install_routes_for_vni(bgp
, vpn
);
5629 /* If we are advertising gateway mac-ip
5630 It needs to be conveyed again to zebra */
5631 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
, vpn
->vni
);
5637 * bgp_evpn_local_es_del
5639 int bgp_evpn_local_es_del(struct bgp
*bgp
,
5641 struct ipaddr
*originator_ip
)
5643 char buf
[ESI_STR_LEN
];
5644 struct evpnes
*es
= NULL
;
5646 if (!bgp
->esihash
) {
5647 flog_err(EC_BGP_ES_CREATE
, "%u: ESI hash not yet created",
5652 /* Lookup ESI hash - should exist. */
5653 es
= bgp_evpn_lookup_es(bgp
, esi
);
5655 flog_warn(EC_BGP_EVPN_ESI
,
5656 "%u: ESI hash entry for ESI %s at Local ES DEL",
5657 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5661 /* Delete all local EVPN ES routes from ESI table
5662 * and schedule for processing (to withdraw from peers))
5664 delete_routes_for_es(bgp
, es
);
5666 /* free the hash entry */
5667 bgp_evpn_es_free(bgp
, es
);
5673 * bgp_evpn_local_es_add
5675 int bgp_evpn_local_es_add(struct bgp
*bgp
,
5677 struct ipaddr
*originator_ip
)
5679 char buf
[ESI_STR_LEN
];
5680 struct evpnes
*es
= NULL
;
5681 struct prefix_evpn p
;
5683 if (!bgp
->esihash
) {
5684 flog_err(EC_BGP_ES_CREATE
, "%u: ESI hash not yet created",
5689 /* create the new es */
5690 es
= bgp_evpn_lookup_es(bgp
, esi
);
5692 es
= bgp_evpn_es_new(bgp
, esi
, originator_ip
);
5696 "%u: Failed to allocate ES entry for ESI %s - at Local ES Add",
5697 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5701 UNSET_FLAG(es
->flags
, EVPNES_REMOTE
);
5702 SET_FLAG(es
->flags
, EVPNES_LOCAL
);
5704 build_evpn_type4_prefix(&p
, esi
, originator_ip
->ipaddr_v4
);
5705 if (update_evpn_type4_route(bgp
, es
, &p
)) {
5706 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
5707 "%u: Type4 route creation failure for ESI %s",
5708 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5712 /* import all remote ES routes in th ES table */
5713 install_routes_for_es(bgp
, es
);
5719 * Handle change in setting for BUM handling. The supported values
5720 * are head-end replication and dropping all BUM packets. Any change
5721 * should be registered with zebra. Also, if doing head-end replication,
5722 * need to advertise local VNIs as EVPN RT-3 wheras, if BUM packets are
5723 * to be dropped, the RT-3s must be withdrawn.
5725 void bgp_evpn_flood_control_change(struct bgp
*bgp
)
5727 zlog_info("L2VPN EVPN BUM handling is %s",
5728 bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_HEAD_END_REPL
?
5729 "Flooding" : "Flooding Disabled");
5731 bgp_zebra_vxlan_flood_control(bgp
, bgp
->vxlan_flood_ctrl
);
5732 if (bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_HEAD_END_REPL
)
5733 hash_iterate(bgp
->vnihash
, create_advertise_type3
, bgp
);
5734 else if (bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_DISABLED
)
5735 hash_iterate(bgp
->vnihash
, delete_withdraw_type3
, bgp
);
5739 * Cleanup EVPN information on disable - Need to delete and withdraw
5740 * EVPN routes from peers.
5742 void bgp_evpn_cleanup_on_disable(struct bgp
*bgp
)
5744 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
5745 void *))cleanup_vni_on_disable
,
5750 * Cleanup EVPN information - invoked at the time of bgpd exit or when the
5751 * BGP instance (default) is being freed.
5753 void bgp_evpn_cleanup(struct bgp
*bgp
)
5755 hash_iterate(bgp
->vnihash
,
5756 (void (*)(struct hash_backet
*, void *))free_vni_entry
,
5759 hash_free(bgp
->import_rt_hash
);
5760 bgp
->import_rt_hash
= NULL
;
5762 hash_free(bgp
->vrf_import_rt_hash
);
5763 bgp
->vrf_import_rt_hash
= NULL
;
5765 hash_free(bgp
->vnihash
);
5766 bgp
->vnihash
= NULL
;
5768 hash_free(bgp
->esihash
);
5769 bgp
->esihash
= NULL
;
5771 list_delete(&bgp
->vrf_import_rtl
);
5772 list_delete(&bgp
->vrf_export_rtl
);
5773 list_delete(&bgp
->l2vnis
);
5777 * Initialization for EVPN
5780 * hash for RT to VNI
5782 void bgp_evpn_init(struct bgp
*bgp
)
5785 hash_create(vni_hash_key_make
, vni_hash_cmp
, "BGP VNI Hash");
5787 hash_create(esi_hash_keymake
, esi_cmp
,
5788 "BGP EVPN Local ESI Hash");
5789 bgp
->import_rt_hash
=
5790 hash_create(import_rt_hash_key_make
, import_rt_hash_cmp
,
5791 "BGP Import RT Hash");
5792 bgp
->vrf_import_rt_hash
=
5793 hash_create(vrf_import_rt_hash_key_make
, vrf_import_rt_hash_cmp
,
5794 "BGP VRF Import RT Hash");
5795 bgp
->vrf_import_rtl
= list_new();
5796 bgp
->vrf_import_rtl
->cmp
=
5797 (int (*)(void *, void *))evpn_route_target_cmp
;
5798 bgp
->vrf_import_rtl
->del
= evpn_xxport_delete_ecomm
;
5799 bgp
->vrf_export_rtl
= list_new();
5800 bgp
->vrf_export_rtl
->cmp
=
5801 (int (*)(void *, void *))evpn_route_target_cmp
;
5802 bgp
->vrf_export_rtl
->del
= evpn_xxport_delete_ecomm
;
5803 bgp
->l2vnis
= list_new();
5804 bgp
->l2vnis
->cmp
= vni_list_cmp
;
5805 /* By default Duplicate Address Dection is enabled.
5806 * Max-moves (N) 5, detection time (M) 180
5807 * default action is warning-only
5808 * freeze action permanently freezes address,
5809 * and freeze time (auto-recovery) is disabled.
5811 if (bgp
->evpn_info
) {
5812 bgp
->evpn_info
->dup_addr_detect
= true;
5813 bgp
->evpn_info
->dad_time
= EVPN_DAD_DEFAULT_TIME
;
5814 bgp
->evpn_info
->dad_max_moves
= EVPN_DAD_DEFAULT_MAX_MOVES
;
5815 bgp
->evpn_info
->dad_freeze
= false;
5816 bgp
->evpn_info
->dad_freeze_time
= 0;
5817 /* Initialize zebra vxlan */
5818 bgp_zebra_dup_addr_detection(bgp
);
5821 /* Default BUM handling is to do head-end replication. */
5822 bgp
->vxlan_flood_ctrl
= VXLAN_FLOOD_HEAD_END_REPL
;
5825 void bgp_evpn_vrf_delete(struct bgp
*bgp_vrf
)
5827 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);