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"
52 * Definitions and external declarations.
54 extern struct zclient
*zclient
;
56 DEFINE_QOBJ_TYPE(bgpevpn
)
57 DEFINE_QOBJ_TYPE(evpnes
)
61 * Static function declarations
63 static void delete_evpn_route_entry(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
65 struct bgp_path_info
**pi
);
66 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
);
72 /* compare two IPV4 VTEP IPs */
73 static int evpn_vtep_ip_cmp(const void *p1
, const void *p2
)
75 const struct in_addr
*ip1
= p1
;
76 const struct in_addr
*ip2
= p2
;
82 return (ip1
->s_addr
== ip2
->s_addr
);
86 * Make hash key for ESI.
88 static unsigned int esi_hash_keymake(void *p
)
90 struct evpnes
*pes
= p
;
91 const void *pnt
= (void *)pes
->esi
.val
;
93 return jhash(pnt
, ESI_BYTES
, 0xa5a5a55a);
99 static int esi_cmp(const void *p1
, const void *p2
)
101 const struct evpnes
*pes1
= p1
;
102 const struct evpnes
*pes2
= p2
;
104 if (pes1
== NULL
&& pes2
== NULL
)
107 if (pes1
== NULL
|| pes2
== NULL
)
110 return (memcmp(pes1
->esi
.val
, pes2
->esi
.val
, ESI_BYTES
) == 0);
116 static unsigned int vni_hash_key_make(void *p
)
118 struct bgpevpn
*vpn
= p
;
119 return (jhash_1word(vpn
->vni
, 0));
123 * Comparison function for vni hash
125 static int vni_hash_cmp(const void *p1
, const void *p2
)
127 const struct bgpevpn
*vpn1
= p1
;
128 const struct bgpevpn
*vpn2
= p2
;
134 return (vpn1
->vni
== vpn2
->vni
);
138 * Make vrf import route target hash key.
140 static unsigned int vrf_import_rt_hash_key_make(void *p
)
142 struct vrf_irt_node
*irt
= p
;
143 char *pnt
= irt
->rt
.val
;
145 return jhash(pnt
, 8, 0x5abc1234);
149 * Comparison function for vrf import rt hash
151 static int vrf_import_rt_hash_cmp(const void *p1
, const void *p2
)
153 const struct vrf_irt_node
*irt1
= p1
;
154 const struct vrf_irt_node
*irt2
= p2
;
156 if (irt1
== NULL
&& irt2
== NULL
)
159 if (irt1
== NULL
|| irt2
== NULL
)
162 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
166 * Create a new vrf import_rt in default instance
168 static struct vrf_irt_node
*vrf_import_rt_new(struct ecommunity_val
*rt
)
170 struct bgp
*bgp_def
= NULL
;
171 struct vrf_irt_node
*irt
;
173 bgp_def
= bgp_get_default();
175 flog_err(EC_BGP_NO_DFLT
,
176 "vrf import rt new - def instance not created yet");
180 irt
= XCALLOC(MTYPE_BGP_EVPN_VRF_IMPORT_RT
,
181 sizeof(struct vrf_irt_node
));
186 irt
->vrfs
= list_new();
189 if (!hash_get(bgp_def
->vrf_import_rt_hash
, irt
, hash_alloc_intern
)) {
190 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
198 * Free the vrf import rt node
200 static void vrf_import_rt_free(struct vrf_irt_node
*irt
)
202 struct bgp
*bgp_def
= NULL
;
204 bgp_def
= bgp_get_default();
206 flog_err(EC_BGP_NO_DFLT
,
207 "vrf import rt free - def instance not created yet");
211 hash_release(bgp_def
->vrf_import_rt_hash
, irt
);
212 list_delete(&irt
->vrfs
);
213 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
217 * Function to lookup Import RT node - used to map a RT to set of
218 * VNIs importing routes with that RT.
220 static struct vrf_irt_node
*lookup_vrf_import_rt(struct ecommunity_val
*rt
)
222 struct bgp
*bgp_def
= NULL
;
223 struct vrf_irt_node
*irt
;
224 struct vrf_irt_node tmp
;
226 bgp_def
= bgp_get_default();
228 flog_err(EC_BGP_NO_DFLT
,
229 "vrf import rt lookup - def instance not created yet");
233 memset(&tmp
, 0, sizeof(struct vrf_irt_node
));
234 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
235 irt
= hash_lookup(bgp_def
->vrf_import_rt_hash
, &tmp
);
240 * Is specified VRF present on the RT's list of "importing" VRFs?
242 static int is_vrf_present_in_irt_vrfs(struct list
*vrfs
, struct bgp
*bgp_vrf
)
244 struct listnode
*node
= NULL
, *nnode
= NULL
;
245 struct bgp
*tmp_bgp_vrf
= NULL
;
247 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
248 if (tmp_bgp_vrf
== bgp_vrf
)
255 * Make import route target hash key.
257 static unsigned int import_rt_hash_key_make(void *p
)
259 struct irt_node
*irt
= p
;
260 char *pnt
= irt
->rt
.val
;
262 return jhash(pnt
, 8, 0xdeadbeef);
266 * Comparison function for import rt hash
268 static int import_rt_hash_cmp(const void *p1
, const void *p2
)
270 const struct irt_node
*irt1
= p1
;
271 const struct irt_node
*irt2
= p2
;
273 if (irt1
== NULL
&& irt2
== NULL
)
276 if (irt1
== NULL
|| irt2
== NULL
)
279 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
283 * Create a new import_rt
285 static struct irt_node
*import_rt_new(struct bgp
*bgp
,
286 struct ecommunity_val
*rt
)
288 struct irt_node
*irt
;
293 irt
= XCALLOC(MTYPE_BGP_EVPN_IMPORT_RT
, sizeof(struct irt_node
));
298 irt
->vnis
= list_new();
301 if (!hash_get(bgp
->import_rt_hash
, irt
, hash_alloc_intern
)) {
302 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
310 * Free the import rt node
312 static void import_rt_free(struct bgp
*bgp
, struct irt_node
*irt
)
314 hash_release(bgp
->import_rt_hash
, irt
);
315 list_delete(&irt
->vnis
);
316 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
320 * Function to lookup Import RT node - used to map a RT to set of
321 * VNIs importing routes with that RT.
323 static struct irt_node
*lookup_import_rt(struct bgp
*bgp
,
324 struct ecommunity_val
*rt
)
326 struct irt_node
*irt
;
329 memset(&tmp
, 0, sizeof(struct irt_node
));
330 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
331 irt
= hash_lookup(bgp
->import_rt_hash
, &tmp
);
336 * Is specified VNI present on the RT's list of "importing" VNIs?
338 static int is_vni_present_in_irt_vnis(struct list
*vnis
, struct bgpevpn
*vpn
)
340 struct listnode
*node
, *nnode
;
341 struct bgpevpn
*tmp_vpn
;
343 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, tmp_vpn
)) {
352 * Compare Route Targets.
354 static int evpn_route_target_cmp(struct ecommunity
*ecom1
,
355 struct ecommunity
*ecom2
)
363 if (!ecom1
&& !ecom2
)
366 if (ecom1
->str
&& !ecom2
->str
)
369 if (!ecom1
->str
&& ecom2
->str
)
372 if (!ecom1
->str
&& !ecom2
->str
)
375 return strcmp(ecom1
->str
, ecom2
->str
);
378 static void evpn_xxport_delete_ecomm(void *val
)
380 struct ecommunity
*ecomm
= val
;
381 ecommunity_free(&ecomm
);
385 * Mask off global-admin field of specified extended community (RT),
386 * just retain the local-admin field.
388 static inline void mask_ecom_global_admin(struct ecommunity_val
*dst
,
389 struct ecommunity_val
*src
)
395 if (type
== ECOMMUNITY_ENCODE_AS
) {
396 dst
->val
[2] = dst
->val
[3] = 0;
397 } else if (type
== ECOMMUNITY_ENCODE_AS4
398 || type
== ECOMMUNITY_ENCODE_IP
) {
399 dst
->val
[2] = dst
->val
[3] = 0;
400 dst
->val
[4] = dst
->val
[5] = 0;
405 * Map one RT to specified VRF.
406 * bgp_vrf = BGP vrf instance
408 static void map_vrf_to_rt(struct bgp
*bgp_vrf
, struct ecommunity_val
*eval
)
410 struct vrf_irt_node
*irt
= NULL
;
411 struct ecommunity_val eval_tmp
;
413 /* If using "automatic" RT,
414 * we only care about the local-admin sub-field.
415 * This is to facilitate using L3VNI(VRF-VNI)
416 * as the RT for EBGP peering too.
418 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
419 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
420 mask_ecom_global_admin(&eval_tmp
, eval
);
422 irt
= lookup_vrf_import_rt(&eval_tmp
);
423 if (irt
&& is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
424 /* Already mapped. */
428 irt
= vrf_import_rt_new(&eval_tmp
);
430 /* Add VRF to the list for this RT. */
431 listnode_add(irt
->vrfs
, bgp_vrf
);
435 * Unmap specified VRF from specified RT. If there are no other
436 * VRFs for this RT, then the RT hash is deleted.
437 * bgp_vrf: BGP VRF specific instance
439 static void unmap_vrf_from_rt(struct bgp
*bgp_vrf
, struct vrf_irt_node
*irt
)
441 /* Delete VRF from list for this RT. */
442 listnode_delete(irt
->vrfs
, bgp_vrf
);
443 if (!listnode_head(irt
->vrfs
)) {
444 vrf_import_rt_free(irt
);
449 * Map one RT to specified VNI.
451 static void map_vni_to_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
452 struct ecommunity_val
*eval
)
454 struct irt_node
*irt
;
455 struct ecommunity_val eval_tmp
;
457 /* If using "automatic" RT, we only care about the local-admin
459 * This is to facilitate using VNI as the RT for EBGP peering too.
461 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
462 if (!is_import_rt_configured(vpn
))
463 mask_ecom_global_admin(&eval_tmp
, eval
);
465 irt
= lookup_import_rt(bgp
, &eval_tmp
);
467 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
468 /* Already mapped. */
472 irt
= import_rt_new(bgp
, &eval_tmp
);
476 /* Add VNI to the hash list for this RT. */
477 listnode_add(irt
->vnis
, vpn
);
481 * Unmap specified VNI from specified RT. If there are no other
482 * VNIs for this RT, then the RT hash is deleted.
484 static void unmap_vni_from_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
485 struct irt_node
*irt
)
487 /* Delete VNI from hash list for this RT. */
488 listnode_delete(irt
->vnis
, vpn
);
489 if (!listnode_head(irt
->vnis
)) {
490 import_rt_free(bgp
, irt
);
495 * Create RT extended community automatically from passed information:
496 * of the form AS:VNI.
497 * NOTE: We use only the lower 16 bits of the AS. This is sufficient as
498 * the need is to get a RT value that will be unique across different
499 * VNIs but the same across routers (in the same AS) for a particular
502 static void form_auto_rt(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
504 struct ecommunity_val eval
;
505 struct ecommunity
*ecomadd
;
507 if (bgp
->advertise_autort_rfc8365
)
508 vni
|= EVPN_AUTORT_VXLAN
;
509 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
511 ecomadd
= ecommunity_new();
512 ecommunity_add_val(ecomadd
, &eval
);
513 listnode_add_sort(rtl
, ecomadd
);
517 * Derive RD and RT for a VNI automatically. Invoked at the time of
520 static void derive_rd_rt_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
522 bgp_evpn_derive_auto_rd(bgp
, vpn
);
523 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
524 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
528 * Convert nexthop (remote VTEP IP) into an IPv6 address.
530 static void evpn_convert_nexthop_to_ipv6(struct attr
*attr
)
532 if (BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
534 ipv4_to_ipv4_mapped_ipv6(&attr
->mp_nexthop_global
, attr
->nexthop
);
535 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
539 * Add (update) or delete MACIP from zebra.
541 static int bgp_zebra_send_remote_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
542 struct prefix_evpn
*p
,
543 struct in_addr remote_vtep_ip
, int add
,
544 uint8_t flags
, uint32_t seq
)
548 char buf1
[ETHER_ADDR_STRLEN
];
549 char buf2
[INET6_ADDRSTRLEN
];
550 char buf3
[INET6_ADDRSTRLEN
];
553 if (!zclient
|| zclient
->sock
< 0)
556 /* Don't try to register if Zebra doesn't know of this instance. */
557 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
563 zclient_create_header(
564 s
, add
? ZEBRA_REMOTE_MACIP_ADD
: ZEBRA_REMOTE_MACIP_DEL
,
566 stream_putl(s
, vpn
->vni
);
567 stream_put(s
, &p
->prefix
.macip_addr
.mac
.octet
, ETH_ALEN
); /* Mac Addr */
568 /* IP address length and IP address, if any. */
569 if (is_evpn_prefix_ipaddr_none(p
))
572 ipa_len
= is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BYTELEN
574 stream_putl(s
, ipa_len
);
575 stream_put(s
, &p
->prefix
.macip_addr
.ip
.ip
.addr
, ipa_len
);
577 stream_put_in_addr(s
, &remote_vtep_ip
);
579 /* TX flags - MAC sticky status and/or gateway mac */
580 /* Also TX the sequence number of the best route. */
582 stream_putc(s
, flags
);
586 stream_putw_at(s
, 0, stream_get_endp(s
));
588 if (bgp_debug_zebra(NULL
))
590 "Tx %s MACIP, VNI %u MAC %s IP %s flags 0x%x seq %u remote VTEP %s",
591 add
? "ADD" : "DEL", vpn
->vni
,
592 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
594 ipaddr2str(&p
->prefix
.macip_addr
.ip
,
595 buf3
, sizeof(buf3
)), flags
, seq
,
596 inet_ntop(AF_INET
, &remote_vtep_ip
, buf2
,
599 return zclient_send_message(zclient
);
603 * Add (update) or delete remote VTEP from zebra.
605 static int bgp_zebra_send_remote_vtep(struct bgp
*bgp
, struct bgpevpn
*vpn
,
606 struct prefix_evpn
*p
, int add
)
611 if (!zclient
|| zclient
->sock
< 0)
614 /* Don't try to register if Zebra doesn't know of this instance. */
615 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
621 zclient_create_header(
622 s
, add
? ZEBRA_REMOTE_VTEP_ADD
: ZEBRA_REMOTE_VTEP_DEL
,
624 stream_putl(s
, vpn
->vni
);
625 if (is_evpn_prefix_ipaddr_v4(p
))
626 stream_put_in_addr(s
, &p
->prefix
.imet_addr
.ip
.ipaddr_v4
);
627 else if (is_evpn_prefix_ipaddr_v6(p
)) {
630 "Bad remote IP when trying to %s remote VTEP for VNI %u",
631 add
? "ADD" : "DEL", vpn
->vni
);
635 stream_putw_at(s
, 0, stream_get_endp(s
));
637 if (bgp_debug_zebra(NULL
))
638 zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s",
639 add
? "ADD" : "DEL", vpn
->vni
,
640 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
642 return zclient_send_message(zclient
);
646 * Build extended community for EVPN ES (type-4) route
648 static void build_evpn_type4_route_extcomm(struct evpnes
*es
,
651 struct ecommunity ecom_encap
;
652 struct ecommunity ecom_es_rt
;
653 struct ecommunity_val eval
;
654 struct ecommunity_val eval_es_rt
;
655 bgp_encap_types tnl_type
;
659 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
660 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
661 encode_encap_extcomm(tnl_type
, &eval
);
663 ecom_encap
.val
= (uint8_t *)eval
.val
;
664 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
667 memset(&mac
, 0, sizeof(struct ethaddr
));
668 memset(&ecom_es_rt
, 0, sizeof(ecom_es_rt
));
669 es_get_system_mac(&es
->esi
, &mac
);
670 encode_es_rt_extcomm(&eval_es_rt
, &mac
);
672 ecom_es_rt
.val
= (uint8_t *)eval_es_rt
.val
;
674 ecommunity_merge(attr
->ecommunity
, &ecom_es_rt
);
676 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
680 * Build extended communities for EVPN prefix route.
682 static void build_evpn_type5_route_extcomm(struct bgp
*bgp_vrf
,
685 struct ecommunity ecom_encap
;
686 struct ecommunity ecom_rmac
;
687 struct ecommunity_val eval
;
688 struct ecommunity_val eval_rmac
;
689 bgp_encap_types tnl_type
;
690 struct listnode
*node
, *nnode
;
691 struct ecommunity
*ecom
;
692 struct list
*vrf_export_rtl
= NULL
;
695 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
696 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
697 encode_encap_extcomm(tnl_type
, &eval
);
699 ecom_encap
.val
= (uint8_t *)eval
.val
;
702 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
704 /* Add the export RTs for L3VNI/VRF */
705 vrf_export_rtl
= bgp_vrf
->vrf_export_rtl
;
706 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
, ecom
))
708 ecommunity_merge(attr
->ecommunity
, ecom
);
710 /* add the router mac extended community */
711 if (!is_zero_mac(&attr
->rmac
)) {
712 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
713 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
715 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
717 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
720 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
724 * Build extended communities for EVPN route.
725 * This function is applicable for type-2 and type-3 routes. The layer-2 RT
726 * and ENCAP extended communities are applicable for all routes.
727 * The default gateway extended community and MAC mobility (sticky) extended
728 * community are added as needed based on passed settings - only for type-2
729 * routes. Likewise, the layer-3 RT and Router MAC extended communities are
730 * added, if present, based on passed settings - only for non-link-local
733 static void build_evpn_route_extcomm(struct bgpevpn
*vpn
, struct attr
*attr
,
736 struct ecommunity ecom_encap
;
737 struct ecommunity ecom_sticky
;
738 struct ecommunity ecom_default_gw
;
739 struct ecommunity ecom_rmac
;
740 struct ecommunity ecom_na
;
741 struct ecommunity_val eval
;
742 struct ecommunity_val eval_sticky
;
743 struct ecommunity_val eval_default_gw
;
744 struct ecommunity_val eval_rmac
;
745 struct ecommunity_val eval_na
;
747 bgp_encap_types tnl_type
;
748 struct listnode
*node
, *nnode
;
749 struct ecommunity
*ecom
;
751 struct list
*vrf_export_rtl
= NULL
;
754 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
755 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
756 encode_encap_extcomm(tnl_type
, &eval
);
758 ecom_encap
.val
= (uint8_t *)eval
.val
;
761 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
763 /* Add the export RTs for L2VNI */
764 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
))
765 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
, ecom
);
767 /* Add the export RTs for L3VNI if told to - caller determines
768 * when this should be done.
771 vrf_export_rtl
= bgpevpn_get_vrf_export_rtl(vpn
);
772 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
773 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
,
775 attr
->ecommunity
= ecommunity_merge(
776 attr
->ecommunity
, ecom
);
780 /* Add MAC mobility (sticky) if needed. */
783 memset(&ecom_sticky
, 0, sizeof(ecom_sticky
));
784 encode_mac_mobility_extcomm(1, seqnum
, &eval_sticky
);
785 ecom_sticky
.size
= 1;
786 ecom_sticky
.val
= (uint8_t *)eval_sticky
.val
;
788 ecommunity_merge(attr
->ecommunity
, &ecom_sticky
);
791 /* Add RMAC, if told to. */
793 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
794 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
796 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
798 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
801 /* Add default gateway, if needed. */
802 if (attr
->default_gw
) {
803 memset(&ecom_default_gw
, 0, sizeof(ecom_default_gw
));
804 encode_default_gw_extcomm(&eval_default_gw
);
805 ecom_default_gw
.size
= 1;
806 ecom_default_gw
.val
= (uint8_t *)eval_default_gw
.val
;
808 ecommunity_merge(attr
->ecommunity
, &ecom_default_gw
);
811 if (attr
->router_flag
) {
812 memset(&ecom_na
, 0, sizeof(ecom_na
));
813 encode_na_flag_extcomm(&eval_na
, attr
->router_flag
);
815 ecom_na
.val
= (uint8_t *)eval_na
.val
;
816 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
820 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
824 * Add MAC mobility extended community to attribute.
826 static void add_mac_mobility_to_attr(uint32_t seq_num
, struct attr
*attr
)
828 struct ecommunity ecom_tmp
;
829 struct ecommunity_val eval
;
830 uint8_t *ecom_val_ptr
;
837 encode_mac_mobility_extcomm(0, seq_num
, &eval
);
839 /* Find current MM ecommunity */
842 if (attr
->ecommunity
) {
843 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
844 pnt
= attr
->ecommunity
->val
+ (i
* 8);
848 if (type
== ECOMMUNITY_ENCODE_EVPN
850 == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY
) {
851 ecom_val_ptr
= (uint8_t *)(attr
->ecommunity
->val
858 /* Update the existing MM ecommunity */
860 memcpy(ecom_val_ptr
, eval
.val
, sizeof(char) * ECOMMUNITY_SIZE
);
862 /* Add MM to existing */
864 memset(&ecom_tmp
, 0, sizeof(ecom_tmp
));
866 ecom_tmp
.val
= (uint8_t *)eval
.val
;
868 if (attr
->ecommunity
)
870 ecommunity_merge(attr
->ecommunity
, &ecom_tmp
);
872 attr
->ecommunity
= ecommunity_dup(&ecom_tmp
);
876 /* Install EVPN route into zebra. */
877 static int evpn_zebra_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
878 struct prefix_evpn
*p
,
879 struct in_addr remote_vtep_ip
, uint8_t flags
,
884 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
885 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
888 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 1);
893 /* Uninstall EVPN route from zebra. */
894 static int evpn_zebra_uninstall(struct bgp
*bgp
, struct bgpevpn
*vpn
,
895 struct prefix_evpn
*p
,
896 struct in_addr remote_vtep_ip
)
900 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
901 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
904 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 0);
910 * Due to MAC mobility, the prior "local" best route has been supplanted
911 * by a "remote" best route. The prior route has to be deleted and withdrawn
914 static void evpn_delete_old_local_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
916 struct bgp_path_info
*old_local
)
918 struct bgp_node
*global_rn
;
919 struct bgp_path_info
*pi
;
920 afi_t afi
= AFI_L2VPN
;
921 safi_t safi
= SAFI_EVPN
;
923 /* Locate route node in the global EVPN routing table. Note that
924 * this table is a 2-level tree (RD-level + Prefix-level) similar to
927 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
928 (struct prefix
*)&rn
->p
, &vpn
->prd
);
930 /* Delete route entry in the global EVPN table. */
931 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
933 /* Schedule for processing - withdraws to peers happen from
937 bgp_process(bgp
, global_rn
, afi
, safi
);
938 bgp_unlock_node(global_rn
);
941 /* Delete route entry in the VNI route table, caller to remove. */
942 bgp_path_info_delete(rn
, old_local
);
945 static struct in_addr
*es_vtep_new(struct in_addr vtep
)
949 ip
= XCALLOC(MTYPE_BGP_EVPN_ES_VTEP
, sizeof(struct in_addr
));
953 ip
->s_addr
= vtep
.s_addr
;
957 static void es_vtep_free(struct in_addr
*ip
)
959 XFREE(MTYPE_BGP_EVPN_ES_VTEP
, ip
);
962 /* check if VTEP is already part of the list */
963 static int is_vtep_present_in_list(struct list
*list
,
966 struct listnode
*node
= NULL
;
969 for (ALL_LIST_ELEMENTS_RO(list
, node
, tmp
)) {
970 if (tmp
->s_addr
== vtep
.s_addr
)
977 * Best path for ES route was changed,
978 * update the list of VTEPs for this ES
980 static int evpn_es_install_vtep(struct bgp
*bgp
,
982 struct prefix_evpn
*p
,
983 struct in_addr rvtep
)
985 struct in_addr
*vtep_ip
;
987 if (is_vtep_present_in_list(es
->vtep_list
, rvtep
))
991 vtep_ip
= es_vtep_new(rvtep
);
993 listnode_add_sort(es
->vtep_list
, vtep_ip
);
998 * Best path for ES route was changed,
999 * update the list of VTEPs for this ES
1001 static int evpn_es_uninstall_vtep(struct bgp
*bgp
,
1003 struct prefix_evpn
*p
,
1004 struct in_addr rvtep
)
1006 struct listnode
*node
, *nnode
, *node_to_del
= NULL
;
1007 struct in_addr
*tmp
;
1009 for (ALL_LIST_ELEMENTS(es
->vtep_list
, node
, nnode
, tmp
)) {
1010 if (tmp
->s_addr
== rvtep
.s_addr
) {
1017 list_delete_node(es
->vtep_list
, node_to_del
);
1023 * Calculate the best path for a ES(type-4) route.
1025 static int evpn_es_route_select_install(struct bgp
*bgp
,
1027 struct bgp_node
*rn
)
1030 afi_t afi
= AFI_L2VPN
;
1031 safi_t safi
= SAFI_EVPN
;
1032 struct bgp_path_info
*old_select
; /* old best */
1033 struct bgp_path_info
*new_select
; /* new best */
1034 struct bgp_path_info_pair old_and_new
;
1036 /* Compute the best path. */
1037 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
],
1038 &old_and_new
, afi
, safi
);
1039 old_select
= old_and_new
.old
;
1040 new_select
= old_and_new
.new;
1043 * If the best path hasn't changed - see if something needs to be
1046 if (old_select
&& old_select
== new_select
1047 && old_select
->type
== ZEBRA_ROUTE_BGP
1048 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1049 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1050 && !CHECK_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
)
1051 && !bgp
->addpath_tx_used
[afi
][safi
]) {
1052 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1053 ret
= evpn_es_install_vtep(bgp
, es
,
1054 (struct prefix_evpn
*)&rn
->p
,
1055 old_select
->attr
->nexthop
);
1057 UNSET_FLAG(old_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1058 bgp_zebra_clear_route_change_flags(rn
);
1062 /* If the user did a "clear" this flag will be set */
1063 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1066 * bestpath has changed; update relevant fields and install or uninstall
1067 * into the zebra RIB.
1069 if (old_select
|| new_select
)
1070 bgp_bump_version(rn
);
1073 bgp_path_info_unset_flag(rn
, old_select
, BGP_PATH_SELECTED
);
1075 bgp_path_info_set_flag(rn
, new_select
, BGP_PATH_SELECTED
);
1076 bgp_path_info_unset_flag(rn
, new_select
, BGP_PATH_ATTR_CHANGED
);
1077 UNSET_FLAG(new_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1080 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1081 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1082 ret
= evpn_es_install_vtep(bgp
, es
,
1083 (struct prefix_evpn
*)&rn
->p
,
1084 new_select
->attr
->nexthop
);
1086 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1087 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1088 ret
= evpn_es_uninstall_vtep(
1089 bgp
, es
, (struct prefix_evpn
*)&rn
->p
,
1090 old_select
->attr
->nexthop
);
1093 /* Clear any route change flags. */
1094 bgp_zebra_clear_route_change_flags(rn
);
1096 /* Reap old select bgp_path_info, if it has been removed */
1097 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_PATH_REMOVED
))
1098 bgp_path_info_reap(rn
, old_select
);
1104 * Calculate the best path for an EVPN route. Install/update best path in zebra,
1107 static int evpn_route_select_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1108 struct bgp_node
*rn
)
1110 struct bgp_path_info
*old_select
, *new_select
;
1111 struct bgp_path_info_pair old_and_new
;
1112 struct prefix_evpn
*evp
;
1113 afi_t afi
= AFI_L2VPN
;
1114 safi_t safi
= SAFI_EVPN
;
1118 /* Compute the best path. */
1119 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
], &old_and_new
,
1121 old_select
= old_and_new
.old
;
1122 new_select
= old_and_new
.new;
1124 evp
= (struct prefix_evpn
*)&rn
->p
;
1125 /* If the best path hasn't changed - see if there is still something to
1129 if (old_select
&& old_select
== new_select
1130 && old_select
->type
== ZEBRA_ROUTE_BGP
1131 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1132 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1133 && !CHECK_FLAG(old_select
->flags
, BGP_PATH_ATTR_CHANGED
)
1134 && !bgp
->addpath_tx_used
[afi
][safi
]) {
1135 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1136 if (old_select
->attr
->sticky
)
1137 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1138 if (old_select
->attr
->default_gw
)
1139 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1140 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1141 old_select
->attr
->router_flag
)
1142 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1144 ret
= evpn_zebra_install(
1145 bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1146 old_select
->attr
->nexthop
, flags
,
1147 mac_mobility_seqnum(old_select
->attr
));
1149 UNSET_FLAG(old_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1150 bgp_zebra_clear_route_change_flags(rn
);
1154 /* If the user did a "clear" this flag will be set */
1155 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1157 /* bestpath has changed; update relevant fields and install or uninstall
1158 * into the zebra RIB.
1160 if (old_select
|| new_select
)
1161 bgp_bump_version(rn
);
1164 bgp_path_info_unset_flag(rn
, old_select
, BGP_PATH_SELECTED
);
1166 bgp_path_info_set_flag(rn
, new_select
, BGP_PATH_SELECTED
);
1167 bgp_path_info_unset_flag(rn
, new_select
, BGP_PATH_ATTR_CHANGED
);
1168 UNSET_FLAG(new_select
->flags
, BGP_PATH_MULTIPATH_CHG
);
1171 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1172 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1174 if (new_select
->attr
->sticky
)
1175 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1176 if (new_select
->attr
->default_gw
)
1177 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1178 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1179 new_select
->attr
->router_flag
)
1180 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1182 ret
= evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1183 new_select
->attr
->nexthop
, flags
,
1184 mac_mobility_seqnum(new_select
->attr
));
1185 /* If an old best existed and it was a "local" route, the only
1187 * it would be supplanted is due to MAC mobility procedures. So,
1189 * need to do an implicit delete and withdraw that route from
1192 if (old_select
&& old_select
->peer
== bgp
->peer_self
1193 && old_select
->type
== ZEBRA_ROUTE_BGP
1194 && old_select
->sub_type
== BGP_ROUTE_STATIC
)
1195 evpn_delete_old_local_route(bgp
, vpn
, rn
, old_select
);
1197 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1198 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1199 ret
= evpn_zebra_uninstall(bgp
, vpn
,
1200 (struct prefix_evpn
*)&rn
->p
,
1201 old_select
->attr
->nexthop
);
1204 /* Clear any route change flags. */
1205 bgp_zebra_clear_route_change_flags(rn
);
1207 /* Reap old select bgp_path_info, if it has been removed */
1208 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_PATH_REMOVED
))
1209 bgp_path_info_reap(rn
, old_select
);
1215 * Return true if the local ri for this rn is of type gateway mac
1217 static int evpn_route_is_def_gw(struct bgp
*bgp
, struct bgp_node
*rn
)
1219 struct bgp_path_info
*tmp_pi
= NULL
;
1220 struct bgp_path_info
*local_pi
= NULL
;
1223 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1224 if (tmp_pi
->peer
== bgp
->peer_self
1225 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1226 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1233 return local_pi
->attr
->default_gw
;
1238 * Return true if the local ri for this rn has sticky set
1240 static int evpn_route_is_sticky(struct bgp
*bgp
, struct bgp_node
*rn
)
1242 struct bgp_path_info
*tmp_pi
;
1243 struct bgp_path_info
*local_pi
;
1246 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1247 if (tmp_pi
->peer
== bgp
->peer_self
1248 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1249 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1256 return local_pi
->attr
->sticky
;
1260 * create or update EVPN type4 route entry.
1261 * This could be in the ES table or the global table.
1262 * TODO: handle remote ES (type4) routes as well
1264 static int update_evpn_type4_route_entry(struct bgp
*bgp
, struct evpnes
*es
,
1265 afi_t afi
, safi_t safi
,
1266 struct bgp_node
*rn
, struct attr
*attr
,
1267 int add
, struct bgp_path_info
**ri
,
1270 char buf
[ESI_STR_LEN
];
1271 char buf1
[INET6_ADDRSTRLEN
];
1272 struct bgp_path_info
*tmp_pi
= NULL
;
1273 struct bgp_path_info
*local_pi
= NULL
; /* local route entry if any */
1274 struct bgp_path_info
*remote_pi
= NULL
; /* remote route entry if any */
1275 struct attr
*attr_new
= NULL
;
1276 struct prefix_evpn
*evp
= NULL
;
1280 evp
= (struct prefix_evpn
*)&rn
->p
;
1282 /* locate the local and remote entries if any */
1283 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1284 if (tmp_pi
->peer
== bgp
->peer_self
1285 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1286 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1288 if (tmp_pi
->type
== ZEBRA_ROUTE_BGP
1289 && tmp_pi
->sub_type
== BGP_ROUTE_IMPORTED
1290 && CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_VALID
))
1294 /* we don't expect to see a remote_pi at this point.
1295 * An ES route has esi + vtep_ip as the key,
1296 * We shouldn't see the same route from any other vtep.
1301 "%u ERROR: local es route for ESI: %s Vtep %s also learnt from remote",
1303 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1304 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1308 if (!local_pi
&& !add
)
1311 /* create or update the entry */
1314 /* Add or update attribute to hash */
1315 attr_new
= bgp_attr_intern(attr
);
1317 /* Create new route with its attribute. */
1318 tmp_pi
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1319 bgp
->peer_self
, attr_new
, rn
);
1320 SET_FLAG(tmp_pi
->flags
, BGP_PATH_VALID
);
1322 /* add the newly created path to the route-node */
1323 bgp_path_info_add(rn
, tmp_pi
);
1326 if (attrhash_cmp(tmp_pi
->attr
, attr
)
1327 && !CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1330 /* The attribute has changed.
1331 * Add (or update) attribute to hash. */
1332 attr_new
= bgp_attr_intern(attr
);
1333 bgp_path_info_set_flag(rn
, tmp_pi
,
1334 BGP_PATH_ATTR_CHANGED
);
1336 /* Restore route, if needed. */
1337 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1338 bgp_path_info_restore(rn
, tmp_pi
);
1340 /* Unintern existing, set to new. */
1341 bgp_attr_unintern(&tmp_pi
->attr
);
1342 tmp_pi
->attr
= attr_new
;
1343 tmp_pi
->uptime
= bgp_clock();
1347 /* Return back the route entry. */
1352 /* update evpn es (type-4) route */
1353 static int update_evpn_type4_route(struct bgp
*bgp
,
1355 struct prefix_evpn
*p
)
1358 int route_changed
= 0;
1359 char buf
[ESI_STR_LEN
];
1360 char buf1
[INET6_ADDRSTRLEN
];
1361 afi_t afi
= AFI_L2VPN
;
1362 safi_t safi
= SAFI_EVPN
;
1364 struct attr
*attr_new
= NULL
;
1365 struct bgp_node
*rn
= NULL
;
1366 struct bgp_path_info
*pi
= NULL
;
1368 memset(&attr
, 0, sizeof(struct attr
));
1370 /* Build path-attribute for this route. */
1371 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1372 attr
.nexthop
= es
->originator_ip
.ipaddr_v4
;
1373 attr
.mp_nexthop_global_in
= es
->originator_ip
.ipaddr_v4
;
1374 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1376 /* Set up extended community. */
1377 build_evpn_type4_route_extcomm(es
, &attr
);
1379 /* First, create (or fetch) route node within the ESI. */
1380 /* NOTE: There is no RD here. */
1381 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
1383 /* Create or update route entry. */
1384 ret
= update_evpn_type4_route_entry(bgp
, es
, afi
, safi
, rn
, &attr
, 1,
1385 &pi
, &route_changed
);
1387 flog_err(EC_BGP_ES_INVALID
,
1388 "%u ERROR: Failed to updated ES route ESI: %s VTEP %s",
1390 esi_to_str(&p
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1391 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1395 attr_new
= pi
->attr
;
1397 /* Perform route selection;
1398 * this is just to set the flags correctly
1399 * as local route in the ES always wins.
1401 evpn_es_route_select_install(bgp
, es
, rn
);
1402 bgp_unlock_node(rn
);
1404 /* If this is a new route or some attribute has changed, export the
1405 * route to the global table. The route will be advertised to peers
1406 * from there. Note that this table is a 2-level tree (RD-level +
1407 * Prefix-level) similar to L3VPN routes.
1409 if (route_changed
) {
1410 struct bgp_path_info
*global_pi
;
1412 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1413 (struct prefix
*)p
, &es
->prd
);
1414 update_evpn_type4_route_entry(bgp
, es
, afi
, safi
, rn
, attr_new
,
1415 1, &global_pi
, &route_changed
);
1417 /* Schedule for processing and unlock node. */
1418 bgp_process(bgp
, rn
, afi
, safi
);
1419 bgp_unlock_node(rn
);
1422 /* Unintern temporary. */
1423 aspath_unintern(&attr
.aspath
);
1427 static int update_evpn_type5_route_entry(struct bgp
*bgp_def
,
1428 struct bgp
*bgp_vrf
, afi_t afi
,
1429 safi_t safi
, struct bgp_node
*rn
,
1430 struct attr
*attr
, int *route_changed
)
1432 struct attr
*attr_new
= NULL
;
1433 struct bgp_path_info
*pi
= NULL
;
1434 mpls_label_t label
= MPLS_INVALID_LABEL
;
1435 struct bgp_path_info
*local_pi
= NULL
;
1436 struct bgp_path_info
*tmp_pi
= NULL
;
1439 /* locate the local route entry if any */
1440 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1441 if (tmp_pi
->peer
== bgp_def
->peer_self
1442 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1443 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1448 * create a new route entry if one doesnt exist.
1449 * Otherwise see if route attr has changed
1453 /* route has changed as this is the first entry */
1456 /* Add (or update) attribute to hash. */
1457 attr_new
= bgp_attr_intern(attr
);
1459 /* create the route info from attribute */
1460 pi
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1461 bgp_def
->peer_self
, attr_new
, rn
);
1462 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
1464 /* Type-5 routes advertise the L3-VNI */
1465 bgp_path_info_extra_get(pi
);
1466 vni2label(bgp_vrf
->l3vni
, &label
);
1467 memcpy(&pi
->extra
->label
, &label
, sizeof(label
));
1468 pi
->extra
->num_labels
= 1;
1470 /* add the route entry to route node*/
1471 bgp_path_info_add(rn
, pi
);
1475 if (!attrhash_cmp(tmp_pi
->attr
, attr
)) {
1477 /* attribute changed */
1480 /* The attribute has changed. */
1481 /* Add (or update) attribute to hash. */
1482 attr_new
= bgp_attr_intern(attr
);
1483 bgp_path_info_set_flag(rn
, tmp_pi
,
1484 BGP_PATH_ATTR_CHANGED
);
1486 /* Restore route, if needed. */
1487 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1488 bgp_path_info_restore(rn
, tmp_pi
);
1490 /* Unintern existing, set to new. */
1491 bgp_attr_unintern(&tmp_pi
->attr
);
1492 tmp_pi
->attr
= attr_new
;
1493 tmp_pi
->uptime
= bgp_clock();
1499 /* update evpn type-5 route entry */
1500 static int update_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
,
1501 struct attr
*src_attr
)
1503 afi_t afi
= AFI_L2VPN
;
1504 safi_t safi
= SAFI_EVPN
;
1506 struct bgp_node
*rn
= NULL
;
1507 struct bgp
*bgp_def
= NULL
;
1508 int route_changed
= 0;
1510 bgp_def
= bgp_get_default();
1514 /* Build path attribute for this route - use the source attr, if
1515 * present, else treat as locally originated.
1518 bgp_attr_dup(&attr
, src_attr
);
1520 memset(&attr
, 0, sizeof(struct attr
));
1521 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1523 /* Set nexthop to ourselves and fill in the Router MAC. */
1524 attr
.nexthop
= bgp_vrf
->originator_ip
;
1525 attr
.mp_nexthop_global_in
= bgp_vrf
->originator_ip
;
1526 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1527 memcpy(&attr
.rmac
, &bgp_vrf
->rmac
, sizeof(struct ethaddr
));
1529 /* Setup RT and encap extended community */
1530 build_evpn_type5_route_extcomm(bgp_vrf
, &attr
);
1532 /* get the route node in global table */
1533 rn
= bgp_afi_node_get(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1534 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1537 /* create or update the route entry within the route node */
1538 update_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &attr
,
1541 /* schedule for processing and unlock node */
1542 if (route_changed
) {
1543 bgp_process(bgp_def
, rn
, afi
, safi
);
1544 bgp_unlock_node(rn
);
1547 /* uninten temporary */
1549 aspath_unintern(&attr
.aspath
);
1554 * Create or update EVPN route entry. This could be in the VNI route table
1555 * or the global route table.
1557 static int update_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1558 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1559 struct attr
*attr
, int add
,
1560 struct bgp_path_info
**pi
, uint8_t flags
,
1563 struct bgp_path_info
*tmp_pi
;
1564 struct bgp_path_info
*local_pi
;
1565 struct attr
*attr_new
;
1566 mpls_label_t label
[BGP_MAX_LABELS
];
1567 uint32_t num_labels
= 1;
1568 int route_change
= 1;
1570 struct prefix_evpn
*evp
;
1573 evp
= (struct prefix_evpn
*)&rn
->p
;
1574 memset(&label
, 0, sizeof(label
));
1576 /* See if this is an update of an existing route, or a new add. */
1578 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1579 if (tmp_pi
->peer
== bgp
->peer_self
1580 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1581 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1585 /* If route doesn't exist already, create a new one, if told to.
1586 * Otherwise act based on whether the attributes of the route have
1589 if (!local_pi
&& !add
)
1592 /* For non-GW MACs, update MAC mobility seq number, if needed. */
1593 if (seq
&& !CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
))
1594 add_mac_mobility_to_attr(seq
, attr
);
1597 /* Add (or update) attribute to hash. */
1598 attr_new
= bgp_attr_intern(attr
);
1600 /* Extract MAC mobility sequence number, if any. */
1601 attr_new
->mm_seqnum
=
1602 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1603 attr_new
->sticky
= sticky
;
1605 /* Create new route with its attribute. */
1606 tmp_pi
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1607 bgp
->peer_self
, attr_new
, rn
);
1608 SET_FLAG(tmp_pi
->flags
, BGP_PATH_VALID
);
1609 bgp_path_info_extra_get(tmp_pi
);
1611 /* The VNI goes into the 'label' field of the route */
1612 vni2label(vpn
->vni
, &label
[0]);
1614 /* Type-2 routes may carry a second VNI - the L3-VNI.
1615 * Only attach second label if we are advertising two labels for
1618 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1619 && CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
)) {
1622 l3vni
= bgpevpn_get_l3vni(vpn
);
1624 vni2label(l3vni
, &label
[1]);
1629 memcpy(&tmp_pi
->extra
->label
, label
, sizeof(label
));
1630 tmp_pi
->extra
->num_labels
= num_labels
;
1631 bgp_path_info_add(rn
, tmp_pi
);
1634 if (attrhash_cmp(tmp_pi
->attr
, attr
)
1635 && !CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1639 * The attributes have changed, type-2 routes needs to
1640 * be advertised with right labels.
1642 vni2label(vpn
->vni
, &label
[0]);
1643 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1644 && CHECK_FLAG(vpn
->flags
,
1645 VNI_FLAG_USE_TWO_LABELS
)) {
1648 l3vni
= bgpevpn_get_l3vni(vpn
);
1650 vni2label(l3vni
, &label
[1]);
1654 memcpy(&tmp_pi
->extra
->label
, label
, sizeof(label
));
1655 tmp_pi
->extra
->num_labels
= num_labels
;
1657 /* The attribute has changed. */
1658 /* Add (or update) attribute to hash. */
1659 attr_new
= bgp_attr_intern(attr
);
1660 bgp_path_info_set_flag(rn
, tmp_pi
,
1661 BGP_PATH_ATTR_CHANGED
);
1663 /* Extract MAC mobility sequence number, if any. */
1664 attr_new
->mm_seqnum
=
1665 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1666 attr_new
->sticky
= sticky
;
1668 /* Restore route, if needed. */
1669 if (CHECK_FLAG(tmp_pi
->flags
, BGP_PATH_REMOVED
))
1670 bgp_path_info_restore(rn
, tmp_pi
);
1672 /* Unintern existing, set to new. */
1673 bgp_attr_unintern(&tmp_pi
->attr
);
1674 tmp_pi
->attr
= attr_new
;
1675 tmp_pi
->uptime
= bgp_clock();
1679 /* Return back the route entry. */
1681 return route_change
;
1685 * Create or update EVPN route (of type based on prefix) for specified VNI
1686 * and schedule for processing.
1688 static int update_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1689 struct prefix_evpn
*p
, uint8_t flags
,
1692 struct bgp_node
*rn
;
1694 struct attr
*attr_new
;
1695 int add_l3_ecomm
= 0;
1696 struct bgp_path_info
*pi
;
1697 afi_t afi
= AFI_L2VPN
;
1698 safi_t safi
= SAFI_EVPN
;
1701 memset(&attr
, 0, sizeof(struct attr
));
1703 /* Build path-attribute for this route. */
1704 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1705 attr
.nexthop
= vpn
->originator_ip
;
1706 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1707 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1708 attr
.sticky
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
) ? 1 : 0;
1709 attr
.default_gw
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
) ? 1 : 0;
1710 attr
.router_flag
= CHECK_FLAG(flags
,
1711 ZEBRA_MACIP_TYPE_ROUTER_FLAG
) ? 1 : 0;
1713 /* PMSI is only needed for type-3 routes */
1714 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
)
1715 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
1717 /* router mac is only needed for type-2 routes here. */
1718 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1719 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1720 vni2label(vpn
->vni
, &(attr
.label
));
1722 /* Include L3 VNI related RTs and RMAC for type-2 routes, if they're
1723 * IPv4 or IPv6 global addresses and we're advertising L3VNI with
1726 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
&&
1727 (is_evpn_prefix_ipaddr_v4(p
) ||
1728 !IN6_IS_ADDR_LINKLOCAL(&p
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
1729 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
1730 bgpevpn_get_l3vni(vpn
))
1733 /* Set up extended community. */
1734 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
1736 /* First, create (or fetch) route node within the VNI. */
1737 /* NOTE: There is no RD here. */
1738 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1740 /* Create or update route entry. */
1741 route_change
= update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
,
1742 1, &pi
, flags
, seq
);
1744 attr_new
= pi
->attr
;
1746 /* Perform route selection; this is just to set the flags correctly
1747 * as local route in the VNI always wins.
1749 evpn_route_select_install(bgp
, vpn
, rn
);
1750 bgp_unlock_node(rn
);
1752 /* If this is a new route or some attribute has changed, export the
1753 * route to the global table. The route will be advertised to peers
1754 * from there. Note that this table is a 2-level tree (RD-level +
1755 * Prefix-level) similar to L3VPN routes.
1758 struct bgp_path_info
*global_pi
;
1760 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1761 (struct prefix
*)p
, &vpn
->prd
);
1762 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, attr_new
, 1,
1763 &global_pi
, flags
, seq
);
1765 /* Schedule for processing and unlock node. */
1766 bgp_process(bgp
, rn
, afi
, safi
);
1767 bgp_unlock_node(rn
);
1770 /* Unintern temporary. */
1771 aspath_unintern(&attr
.aspath
);
1777 * Delete EVPN route entry.
1778 * The entry can be in ESI/VNI table or the global table.
1780 static void delete_evpn_route_entry(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1781 struct bgp_node
*rn
,
1782 struct bgp_path_info
**pi
)
1784 struct bgp_path_info
*tmp_pi
;
1788 /* Now, find matching route. */
1789 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
)
1790 if (tmp_pi
->peer
== bgp
->peer_self
1791 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1792 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1797 /* Mark route for delete. */
1799 bgp_path_info_delete(rn
, tmp_pi
);
1804 /* Delete EVPN ES (type-4) route */
1805 static int delete_evpn_type4_route(struct bgp
*bgp
,
1807 struct prefix_evpn
*p
)
1809 afi_t afi
= AFI_L2VPN
;
1810 safi_t safi
= SAFI_EVPN
;
1811 struct bgp_path_info
*pi
;
1812 struct bgp_node
*rn
= NULL
; /* rn in esi table */
1813 struct bgp_node
*global_rn
= NULL
; /* rn in global table */
1815 /* First, locate the route node within the ESI.
1816 * If it doesn't exist, ther is nothing to do.
1817 * Note: there is no RD here.
1819 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
1823 /* Next, locate route node in the global EVPN routing table.
1824 * Note that this table is a 2-level tree (RD-level + Prefix-level)
1826 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1827 (struct prefix
*)p
, &es
->prd
);
1830 /* Delete route entry in the global EVPN table. */
1831 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
1833 /* Schedule for processing - withdraws to peers happen from
1837 bgp_process(bgp
, global_rn
, afi
, safi
);
1838 bgp_unlock_node(global_rn
);
1842 * Delete route entry in the ESI route table.
1843 * This can just be removed.
1845 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
1847 bgp_path_info_reap(rn
, pi
);
1848 bgp_unlock_node(rn
);
1852 /* Delete EVPN type5 route */
1853 static int delete_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
)
1855 afi_t afi
= AFI_L2VPN
;
1856 safi_t safi
= SAFI_EVPN
;
1857 struct bgp_node
*rn
= NULL
;
1858 struct bgp_path_info
*pi
= NULL
;
1859 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
1861 bgp_def
= bgp_get_default();
1865 /* locate the global route entry for this type-5 prefix */
1866 rn
= bgp_afi_node_lookup(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1867 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1871 delete_evpn_route_entry(bgp_def
, afi
, safi
, rn
, &pi
);
1873 bgp_process(bgp_def
, rn
, afi
, safi
);
1874 bgp_unlock_node(rn
);
1879 * Delete EVPN route (of type based on prefix) for specified VNI and
1880 * schedule for processing.
1882 static int delete_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1883 struct prefix_evpn
*p
)
1885 struct bgp_node
*rn
, *global_rn
;
1886 struct bgp_path_info
*pi
;
1887 afi_t afi
= AFI_L2VPN
;
1888 safi_t safi
= SAFI_EVPN
;
1890 /* First, locate the route node within the VNI. If it doesn't exist,
1892 * is nothing further to do.
1894 /* NOTE: There is no RD here. */
1895 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1899 /* Next, locate route node in the global EVPN routing table. Note that
1900 * this table is a 2-level tree (RD-level + Prefix-level) similar to
1903 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1904 (struct prefix
*)p
, &vpn
->prd
);
1906 /* Delete route entry in the global EVPN table. */
1907 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
1909 /* Schedule for processing - withdraws to peers happen from
1913 bgp_process(bgp
, global_rn
, afi
, safi
);
1914 bgp_unlock_node(global_rn
);
1917 /* Delete route entry in the VNI route table. This can just be removed.
1919 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
1921 bgp_path_info_reap(rn
, pi
);
1922 bgp_unlock_node(rn
);
1928 * Update all type-2 (MACIP) local routes for this VNI - these should also
1929 * be scheduled for advertise to peers.
1931 static int update_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1935 struct bgp_node
*rn
;
1936 struct bgp_path_info
*pi
, *tmp_pi
;
1938 struct attr
*attr_new
;
1940 int add_l3_ecomm
= 0;
1945 /* Walk this VNI's route table and update local type-2 routes. For any
1946 * routes updated, update corresponding entry in the global table too.
1948 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1949 rn
= bgp_route_next(rn
)) {
1950 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1951 struct bgp_node
*rd_rn
;
1952 struct bgp_path_info
*global_pi
;
1954 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1957 /* Identify local route. */
1958 for (tmp_pi
= rn
->info
; tmp_pi
; tmp_pi
= tmp_pi
->next
) {
1959 if (tmp_pi
->peer
== bgp
->peer_self
1960 && tmp_pi
->type
== ZEBRA_ROUTE_BGP
1961 && tmp_pi
->sub_type
== BGP_ROUTE_STATIC
)
1969 * Build attribute per local route as the MAC mobility and
1970 * some other values could differ for different routes. The
1971 * attributes will be shared in the hash table.
1973 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1974 attr
.nexthop
= vpn
->originator_ip
;
1975 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1976 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1977 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1979 if (evpn_route_is_sticky(bgp
, rn
))
1981 else if (evpn_route_is_def_gw(bgp
, rn
)) {
1982 attr
.default_gw
= 1;
1983 if (is_evpn_prefix_ipaddr_v6(evp
))
1984 attr
.router_flag
= 1;
1987 /* Add L3 VNI RTs and RMAC for non IPv6 link-local if
1988 * using L3 VNI for type-2 routes also.
1990 if ((is_evpn_prefix_ipaddr_v4(evp
) ||
1991 !IN6_IS_ADDR_LINKLOCAL(
1992 &evp
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
1993 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
1994 bgpevpn_get_l3vni(vpn
))
1997 /* Set up extended community. */
1998 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
2000 seq
= mac_mobility_seqnum(tmp_pi
->attr
);
2002 /* Update the route entry. */
2003 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
, 0, &pi
,
2006 /* Perform route selection; this is just to set the flags
2007 * correctly as local route in the VNI always wins.
2009 evpn_route_select_install(bgp
, vpn
, rn
);
2011 attr_new
= pi
->attr
;
2013 /* Update route in global routing table. */
2014 rd_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2015 (struct prefix
*)evp
, &vpn
->prd
);
2017 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rd_rn
, attr_new
, 0,
2019 mac_mobility_seqnum(attr_new
));
2021 /* Schedule for processing and unlock node. */
2022 bgp_process(bgp
, rd_rn
, afi
, safi
);
2023 bgp_unlock_node(rd_rn
);
2025 /* Unintern temporary. */
2026 aspath_unintern(&attr
.aspath
);
2034 * Delete all type-2 (MACIP) local routes for this VNI - only from the
2035 * global routing table. These are also scheduled for withdraw from peers.
2037 static int delete_global_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2041 struct bgp_node
*rdrn
, *rn
;
2042 struct bgp_table
*table
;
2043 struct bgp_path_info
*pi
;
2048 rdrn
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)&vpn
->prd
);
2049 if (rdrn
&& rdrn
->info
) {
2050 table
= (struct bgp_table
*)rdrn
->info
;
2051 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2052 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2054 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2057 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
2059 bgp_process(bgp
, rn
, afi
, safi
);
2063 /* Unlock RD node. */
2065 bgp_unlock_node(rdrn
);
2071 * Delete all type-2 (MACIP) local routes for this VNI - from the global
2072 * table as well as the per-VNI route table.
2074 static int delete_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2078 struct bgp_node
*rn
;
2079 struct bgp_path_info
*pi
;
2084 /* First, walk the global route table for this VNI's type-2 local
2086 * EVPN routes are a 2-level table, first get the RD table.
2088 delete_global_type2_routes(bgp
, vpn
);
2090 /* Next, walk this VNI's route table and delete local type-2 routes. */
2091 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2092 rn
= bgp_route_next(rn
)) {
2093 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2095 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2098 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &pi
);
2100 /* Route entry in local table gets deleted immediately. */
2102 bgp_path_info_reap(rn
, pi
);
2109 * Delete all routes in per ES route-table
2111 static int delete_all_es_routes(struct bgp
*bgp
, struct evpnes
*es
)
2113 struct bgp_node
*rn
;
2114 struct bgp_path_info
*pi
, *nextpi
;
2116 /* Walk this ES's route table and delete all routes. */
2117 for (rn
= bgp_table_top(es
->route_table
); rn
;
2118 rn
= bgp_route_next(rn
)) {
2119 for (pi
= rn
->info
; (pi
!= NULL
) && (nextpi
= pi
->next
, 1);
2121 bgp_path_info_delete(rn
, pi
);
2122 bgp_path_info_reap(rn
, pi
);
2130 * Delete all routes in the per-VNI route table.
2132 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2134 struct bgp_node
*rn
;
2135 struct bgp_path_info
*pi
, *nextpi
;
2137 /* Walk this VNI's route table and delete all routes. */
2138 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2139 rn
= bgp_route_next(rn
)) {
2140 for (pi
= rn
->info
; (pi
!= NULL
) && (nextpi
= pi
->next
, 1);
2142 bgp_path_info_delete(rn
, pi
);
2143 bgp_path_info_reap(rn
, pi
);
2151 * Update (and advertise) local routes for a VNI. Invoked upon the VNI
2152 * export RT getting modified or change to tunnel IP. Note that these
2153 * situations need the route in the per-VNI table as well as the global
2154 * table to be updated (as attributes change).
2156 static int update_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2159 struct prefix_evpn p
;
2161 /* Update and advertise the type-3 route (only one) followed by the
2162 * locally learnt type-2 routes (MACIP) - for this VNI.
2164 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2165 ret
= update_evpn_route(bgp
, vpn
, &p
, 0, 0);
2169 return update_all_type2_routes(bgp
, vpn
);
2172 /* Delete (and withdraw) local routes for specified ES from global and ES table.
2173 * Also remove all other routes from the per ES table.
2174 * Invoked when ES is deleted.
2176 static int delete_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
2179 char buf
[ESI_STR_LEN
];
2180 struct prefix_evpn p
;
2182 /* Delete and withdraw locally learnt ES route */
2183 build_evpn_type4_prefix(&p
, &es
->esi
, es
->originator_ip
.ipaddr_v4
);
2184 ret
= delete_evpn_type4_route(bgp
, es
, &p
);
2186 flog_err(EC_BGP_EVPN_ROUTE_DELETE
,
2187 "%u failed to delete type-4 route for ESI %s",
2188 bgp
->vrf_id
, esi_to_str(&es
->esi
, buf
, sizeof(buf
)));
2191 /* Delete all routes from per ES table */
2192 return delete_all_es_routes(bgp
, es
);
2196 * Delete (and withdraw) local routes for specified VNI from the global
2197 * table and per-VNI table. After this, remove all other routes from
2198 * the per-VNI table. Invoked upon the VNI being deleted or EVPN
2199 * (advertise-all-vni) being disabled.
2201 static int delete_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2204 struct prefix_evpn p
;
2206 /* Delete and withdraw locally learnt type-2 routes (MACIP)
2207 * followed by type-3 routes (only one) - for this VNI.
2209 ret
= delete_all_type2_routes(bgp
, vpn
);
2213 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2214 ret
= delete_evpn_route(bgp
, vpn
, &p
);
2218 /* Delete all routes from the per-VNI table. */
2219 return delete_all_vni_routes(bgp
, vpn
);
2223 * There is a tunnel endpoint IP address change for this VNI, delete
2224 * prior type-3 route (if needed) and update.
2225 * Note: Route re-advertisement happens elsewhere after other processing
2228 static int handle_tunnel_ip_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2229 struct in_addr originator_ip
)
2231 struct prefix_evpn p
;
2233 /* If VNI is not live, we only need to update the originator ip */
2234 if (!is_vni_live(vpn
)) {
2235 vpn
->originator_ip
= originator_ip
;
2239 /* Update the tunnel-ip hash */
2240 bgp_tip_del(bgp
, &vpn
->originator_ip
);
2241 bgp_tip_add(bgp
, &originator_ip
);
2243 /* filter routes as martian nexthop db has changed */
2244 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
2246 /* Need to withdraw type-3 route as the originator IP is part
2249 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2250 delete_evpn_route(bgp
, vpn
, &p
);
2252 /* Update the tunnel IP and re-advertise all routes for this VNI. */
2253 vpn
->originator_ip
= originator_ip
;
2257 /* Install EVPN route entry in ES */
2258 static int install_evpn_route_entry_in_es(struct bgp
*bgp
, struct evpnes
*es
,
2259 struct prefix_evpn
*p
,
2260 struct bgp_path_info
*parent_pi
)
2263 struct bgp_node
*rn
= NULL
;
2264 struct bgp_path_info
*pi
= NULL
;
2265 struct attr
*attr_new
= NULL
;
2267 /* Create (or fetch) route within the VNI.
2268 * NOTE: There is no RD here.
2270 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
2272 /* Check if route entry is already present. */
2273 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2275 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2279 /* Add (or update) attribute to hash. */
2280 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2282 /* Create new route with its attribute. */
2283 pi
= info_make(parent_pi
->type
, BGP_ROUTE_IMPORTED
, 0,
2284 parent_pi
->peer
, attr_new
, rn
);
2285 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
2286 bgp_path_info_extra_get(pi
);
2287 pi
->extra
->parent
= parent_pi
;
2288 bgp_path_info_add(rn
, pi
);
2290 if (attrhash_cmp(pi
->attr
, parent_pi
->attr
)
2291 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
2292 bgp_unlock_node(rn
);
2295 /* The attribute has changed. */
2296 /* Add (or update) attribute to hash. */
2297 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2299 /* Restore route, if needed. */
2300 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
2301 bgp_path_info_restore(rn
, pi
);
2303 /* Mark if nexthop has changed. */
2304 if (!IPV4_ADDR_SAME(&pi
->attr
->nexthop
, &attr_new
->nexthop
))
2305 SET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2307 /* Unintern existing, set to new. */
2308 bgp_attr_unintern(&pi
->attr
);
2309 pi
->attr
= attr_new
;
2310 pi
->uptime
= bgp_clock();
2313 /* Perform route selection and update zebra, if required. */
2314 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2319 * Install route entry into the VRF routing table and invoke route selection.
2321 static int install_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2322 struct prefix_evpn
*evp
,
2323 struct bgp_path_info
*parent_pi
)
2325 struct bgp_node
*rn
;
2326 struct bgp_path_info
*pi
;
2328 struct attr
*attr_new
;
2331 struct prefix
*pp
= &p
;
2334 char buf
[PREFIX_STRLEN
];
2335 char buf1
[PREFIX_STRLEN
];
2337 memset(pp
, 0, sizeof(struct prefix
));
2338 ip_prefix_from_evpn_prefix(evp
, pp
);
2340 if (bgp_debug_zebra(NULL
)) {
2342 "installing evpn prefix %s as ip prefix %s in vrf %s",
2343 prefix2str(evp
, buf
, sizeof(buf
)),
2344 prefix2str(pp
, buf1
, sizeof(buf
)),
2345 vrf_id_to_name(bgp_vrf
->vrf_id
));
2348 /* Create (or fetch) route within the VRF. */
2349 /* NOTE: There is no RD here. */
2350 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2352 safi
= SAFI_UNICAST
;
2353 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2354 } else if (is_evpn_prefix_ipaddr_v6(evp
)) {
2356 safi
= SAFI_UNICAST
;
2357 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2361 /* EVPN routes currently only support a IPv4 next hop which corresponds
2362 * to the remote VTEP. When importing into a VRF, if it is IPv6 host
2363 * or prefix route, we have to convert the next hop to an IPv4-mapped
2364 * address for the rest of the code to flow through. In the case of IPv4,
2365 * make sure to set the flag for next hop attribute.
2367 bgp_attr_dup(&attr
, parent_pi
->attr
);
2369 evpn_convert_nexthop_to_ipv6(&attr
);
2371 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
2373 /* Check if route entry is already present. */
2374 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2376 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2380 /* Add (or update) attribute to hash. */
2381 attr_new
= bgp_attr_intern(&attr
);
2383 /* Create new route with its attribute. */
2384 pi
= info_make(parent_pi
->type
, BGP_ROUTE_IMPORTED
, 0,
2385 parent_pi
->peer
, attr_new
, rn
);
2386 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
2387 bgp_path_info_extra_get(pi
);
2388 pi
->extra
->parent
= bgp_path_info_lock(parent_pi
);
2389 bgp_lock_node((struct bgp_node
*)parent_pi
->net
);
2390 if (parent_pi
->extra
) {
2391 memcpy(&pi
->extra
->label
, &parent_pi
->extra
->label
,
2392 sizeof(pi
->extra
->label
));
2393 pi
->extra
->num_labels
= parent_pi
->extra
->num_labels
;
2395 bgp_path_info_add(rn
, pi
);
2397 if (attrhash_cmp(pi
->attr
, &attr
)
2398 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
2399 bgp_unlock_node(rn
);
2402 /* The attribute has changed. */
2403 /* Add (or update) attribute to hash. */
2404 attr_new
= bgp_attr_intern(&attr
);
2406 /* Restore route, if needed. */
2407 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
2408 bgp_path_info_restore(rn
, pi
);
2410 /* Mark if nexthop has changed. */
2412 && !IPV4_ADDR_SAME(&pi
->attr
->nexthop
, &attr_new
->nexthop
))
2414 && !IPV6_ADDR_SAME(&pi
->attr
->mp_nexthop_global
,
2415 &attr_new
->mp_nexthop_global
)))
2416 SET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2418 /* Unintern existing, set to new. */
2419 bgp_attr_unintern(&pi
->attr
);
2420 pi
->attr
= attr_new
;
2421 pi
->uptime
= bgp_clock();
2424 bgp_aggregate_increment(bgp_vrf
, &rn
->p
, pi
, afi
, safi
);
2426 /* Perform route selection and update zebra, if required. */
2427 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2433 * Install route entry into the VNI routing table and invoke route selection.
2435 static int install_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2436 struct prefix_evpn
*p
,
2437 struct bgp_path_info
*parent_pi
)
2439 struct bgp_node
*rn
;
2440 struct bgp_path_info
*pi
;
2441 struct attr
*attr_new
;
2444 /* Create (or fetch) route within the VNI. */
2445 /* NOTE: There is no RD here. */
2446 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
2448 /* Check if route entry is already present. */
2449 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2451 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2455 /* Add (or update) attribute to hash. */
2456 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2458 /* Create new route with its attribute. */
2459 pi
= info_make(parent_pi
->type
, BGP_ROUTE_IMPORTED
, 0,
2460 parent_pi
->peer
, attr_new
, rn
);
2461 SET_FLAG(pi
->flags
, BGP_PATH_VALID
);
2462 bgp_path_info_extra_get(pi
);
2463 pi
->extra
->parent
= bgp_path_info_lock(parent_pi
);
2464 bgp_lock_node((struct bgp_node
*)parent_pi
->net
);
2465 if (parent_pi
->extra
) {
2466 memcpy(&pi
->extra
->label
, &parent_pi
->extra
->label
,
2467 sizeof(pi
->extra
->label
));
2468 pi
->extra
->num_labels
= parent_pi
->extra
->num_labels
;
2470 bgp_path_info_add(rn
, pi
);
2472 if (attrhash_cmp(pi
->attr
, parent_pi
->attr
)
2473 && !CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
)) {
2474 bgp_unlock_node(rn
);
2477 /* The attribute has changed. */
2478 /* Add (or update) attribute to hash. */
2479 attr_new
= bgp_attr_intern(parent_pi
->attr
);
2481 /* Restore route, if needed. */
2482 if (CHECK_FLAG(pi
->flags
, BGP_PATH_REMOVED
))
2483 bgp_path_info_restore(rn
, pi
);
2485 /* Mark if nexthop has changed. */
2486 if (!IPV4_ADDR_SAME(&pi
->attr
->nexthop
, &attr_new
->nexthop
))
2487 SET_FLAG(pi
->flags
, BGP_PATH_IGP_CHANGED
);
2489 /* Unintern existing, set to new. */
2490 bgp_attr_unintern(&pi
->attr
);
2491 pi
->attr
= attr_new
;
2492 pi
->uptime
= bgp_clock();
2495 /* Perform route selection and update zebra, if required. */
2496 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2501 /* Uninstall EVPN route entry from ES route table */
2502 static int uninstall_evpn_route_entry_in_es(struct bgp
*bgp
, struct evpnes
*es
,
2503 struct prefix_evpn
*p
,
2504 struct bgp_path_info
*parent_pi
)
2507 struct bgp_node
*rn
;
2508 struct bgp_path_info
*pi
;
2510 if (!es
->route_table
)
2513 /* Locate route within the ESI.
2514 * NOTE: There is no RD here.
2516 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
2520 /* Find matching route entry. */
2521 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2523 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2529 /* Mark entry for deletion */
2530 bgp_path_info_delete(rn
, pi
);
2532 /* Perform route selection and update zebra, if required. */
2533 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2535 /* Unlock route node. */
2536 bgp_unlock_node(rn
);
2542 * Uninstall route entry from the VRF routing table and send message
2543 * to zebra, if appropriate.
2545 static int uninstall_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2546 struct prefix_evpn
*evp
,
2547 struct bgp_path_info
*parent_pi
)
2549 struct bgp_node
*rn
;
2550 struct bgp_path_info
*pi
;
2553 struct prefix
*pp
= &p
;
2556 char buf
[PREFIX_STRLEN
];
2557 char buf1
[PREFIX_STRLEN
];
2559 memset(pp
, 0, sizeof(struct prefix
));
2560 ip_prefix_from_evpn_prefix(evp
, pp
);
2562 if (bgp_debug_zebra(NULL
)) {
2564 "uninstalling evpn prefix %s as ip prefix %s in vrf %s",
2565 prefix2str(evp
, buf
, sizeof(buf
)),
2566 prefix2str(pp
, buf1
, sizeof(buf
)),
2567 vrf_id_to_name(bgp_vrf
->vrf_id
));
2570 /* Locate route within the VRF. */
2571 /* NOTE: There is no RD here. */
2572 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2574 safi
= SAFI_UNICAST
;
2575 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2578 safi
= SAFI_UNICAST
;
2579 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2585 /* Find matching route entry. */
2586 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2588 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2594 bgp_aggregate_decrement(bgp_vrf
, &rn
->p
, pi
, afi
, safi
);
2596 /* Mark entry for deletion */
2597 bgp_path_info_delete(rn
, pi
);
2599 /* Perform route selection and update zebra, if required. */
2600 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2602 /* Unlock route node. */
2603 bgp_unlock_node(rn
);
2609 * Uninstall route entry from the VNI routing table and send message
2610 * to zebra, if appropriate.
2612 static int uninstall_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2613 struct prefix_evpn
*p
,
2614 struct bgp_path_info
*parent_pi
)
2616 struct bgp_node
*rn
;
2617 struct bgp_path_info
*pi
;
2620 /* Locate route within the VNI. */
2621 /* NOTE: There is no RD here. */
2622 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
2626 /* Find matching route entry. */
2627 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
2629 && (struct bgp_path_info
*)pi
->extra
->parent
== parent_pi
)
2635 /* Mark entry for deletion */
2636 bgp_path_info_delete(rn
, pi
);
2638 /* Perform route selection and update zebra, if required. */
2639 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2641 /* Unlock route node. */
2642 bgp_unlock_node(rn
);
2648 * Given a prefix, see if it belongs to ES.
2650 static int is_prefix_matching_for_es(struct prefix_evpn
*p
,
2653 /* if not an ES route return false */
2654 if (p
->prefix
.route_type
!= BGP_EVPN_ES_ROUTE
)
2657 if (memcmp(&p
->prefix
.es_addr
.esi
, &es
->esi
, sizeof(esi_t
)) == 0)
2664 * Given a route entry and a VRF, see if this route entry should be
2665 * imported into the VRF i.e., RTs match.
2667 static int is_route_matching_for_vrf(struct bgp
*bgp_vrf
,
2668 struct bgp_path_info
*pi
)
2670 struct attr
*attr
= pi
->attr
;
2671 struct ecommunity
*ecom
;
2675 /* Route should have valid RT to be even considered. */
2676 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2679 ecom
= attr
->ecommunity
;
2680 if (!ecom
|| !ecom
->size
)
2683 /* For each extended community RT, see if it matches this VNI. If any RT
2684 * matches, we're done.
2686 for (i
= 0; i
< ecom
->size
; i
++) {
2688 uint8_t type
, sub_type
;
2689 struct ecommunity_val
*eval
;
2690 struct ecommunity_val eval_tmp
;
2691 struct vrf_irt_node
*irt
;
2693 /* Only deal with RTs */
2694 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2695 eval
= (struct ecommunity_val
*)(ecom
->val
2696 + (i
* ECOMMUNITY_SIZE
));
2699 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2702 /* See if this RT matches specified VNIs import RTs */
2703 irt
= lookup_vrf_import_rt(eval
);
2705 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2708 /* Also check for non-exact match. In this, we mask out the AS
2710 * only check on the local-admin sub-field. This is to
2712 * VNI as the RT for EBGP peering too.
2715 if (type
== ECOMMUNITY_ENCODE_AS
2716 || type
== ECOMMUNITY_ENCODE_AS4
2717 || type
== ECOMMUNITY_ENCODE_IP
) {
2718 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2719 mask_ecom_global_admin(&eval_tmp
, eval
);
2720 irt
= lookup_vrf_import_rt(&eval_tmp
);
2723 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2731 * Given a route entry and a VNI, see if this route entry should be
2732 * imported into the VNI i.e., RTs match.
2734 static int is_route_matching_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2735 struct bgp_path_info
*pi
)
2737 struct attr
*attr
= pi
->attr
;
2738 struct ecommunity
*ecom
;
2742 /* Route should have valid RT to be even considered. */
2743 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2746 ecom
= attr
->ecommunity
;
2747 if (!ecom
|| !ecom
->size
)
2750 /* For each extended community RT, see if it matches this VNI. If any RT
2751 * matches, we're done.
2753 for (i
= 0; i
< ecom
->size
; i
++) {
2755 uint8_t type
, sub_type
;
2756 struct ecommunity_val
*eval
;
2757 struct ecommunity_val eval_tmp
;
2758 struct irt_node
*irt
;
2760 /* Only deal with RTs */
2761 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2762 eval
= (struct ecommunity_val
*)(ecom
->val
2763 + (i
* ECOMMUNITY_SIZE
));
2766 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2769 /* See if this RT matches specified VNIs import RTs */
2770 irt
= lookup_import_rt(bgp
, eval
);
2772 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2775 /* Also check for non-exact match. In this, we mask out the AS
2777 * only check on the local-admin sub-field. This is to
2779 * VNI as the RT for EBGP peering too.
2782 if (type
== ECOMMUNITY_ENCODE_AS
2783 || type
== ECOMMUNITY_ENCODE_AS4
2784 || type
== ECOMMUNITY_ENCODE_IP
) {
2785 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2786 mask_ecom_global_admin(&eval_tmp
, eval
);
2787 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2790 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2797 static int install_uninstall_routes_for_es(struct bgp
*bgp
,
2804 char buf
[PREFIX_STRLEN
];
2805 char buf1
[ESI_STR_LEN
];
2806 struct bgp_node
*rd_rn
, *rn
;
2807 struct bgp_table
*table
;
2808 struct bgp_path_info
*pi
;
2814 * Walk entire global routing table and evaluate routes which could be
2815 * imported into this VRF. Note that we need to loop through all global
2816 * routes to determine which route matches the import rt on vrf
2818 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2819 rd_rn
= bgp_route_next(rd_rn
)) {
2820 table
= (struct bgp_table
*)(rd_rn
->info
);
2824 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2825 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2827 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
2829 * Consider "valid" remote routes applicable for
2832 if (!(CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
2833 && pi
->type
== ZEBRA_ROUTE_BGP
2834 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
2837 if (!is_prefix_matching_for_es(evp
, es
))
2841 ret
= install_evpn_route_entry_in_es(
2844 ret
= uninstall_evpn_route_entry_in_es(
2850 "Failed to %s EVPN %s route in ESI %s",
2853 prefix2str(evp
, buf
,
2855 esi_to_str(&es
->esi
, buf1
,
2866 * Install or uninstall mac-ip routes are appropriate for this
2869 static int install_uninstall_routes_for_vrf(struct bgp
*bgp_vrf
, int install
)
2873 struct bgp_node
*rd_rn
, *rn
;
2874 struct bgp_table
*table
;
2875 struct bgp_path_info
*pi
;
2877 char buf
[PREFIX_STRLEN
];
2878 struct bgp
*bgp_def
= NULL
;
2882 bgp_def
= bgp_get_default();
2886 /* Walk entire global routing table and evaluate routes which could be
2887 * imported into this VRF. Note that we need to loop through all global
2888 * routes to determine which route matches the import rt on vrf
2890 for (rd_rn
= bgp_table_top(bgp_def
->rib
[afi
][safi
]); rd_rn
;
2891 rd_rn
= bgp_route_next(rd_rn
)) {
2892 table
= (struct bgp_table
*)(rd_rn
->info
);
2896 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2897 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2899 /* if not mac-ip route skip this route */
2900 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2901 || evp
->prefix
.route_type
2902 == BGP_EVPN_IP_PREFIX_ROUTE
))
2905 /* if not a mac+ip route skip this route */
2906 if (!(is_evpn_prefix_ipaddr_v4(evp
)
2907 || is_evpn_prefix_ipaddr_v6(evp
)))
2910 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
2911 /* Consider "valid" remote routes applicable for
2914 if (!(CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
2915 && pi
->type
== ZEBRA_ROUTE_BGP
2916 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
2919 if (is_route_matching_for_vrf(bgp_vrf
, pi
)) {
2921 ret
= install_evpn_route_entry_in_vrf(
2924 ret
= uninstall_evpn_route_entry_in_vrf(
2930 "Failed to %s EVPN %s route in VRF %s",
2933 prefix2str(evp
, buf
,
2948 * Install or uninstall routes of specified type that are appropriate for this
2951 static int install_uninstall_routes_for_vni(struct bgp
*bgp
,
2952 struct bgpevpn
*vpn
,
2953 bgp_evpn_route_type rtype
,
2958 struct bgp_node
*rd_rn
, *rn
;
2959 struct bgp_table
*table
;
2960 struct bgp_path_info
*pi
;
2966 /* Walk entire global routing table and evaluate routes which could be
2967 * imported into this VPN. Note that we cannot just look at the routes
2969 * the VNI's RD - remote routes applicable for this VNI could have any
2972 /* EVPN routes are a 2-level table. */
2973 for (rd_rn
= bgp_table_top(bgp
->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 (evp
->prefix
.route_type
!= rtype
)
2985 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
2986 /* Consider "valid" remote routes applicable for
2988 if (!(CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
)
2989 && pi
->type
== ZEBRA_ROUTE_BGP
2990 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
2993 if (is_route_matching_for_vni(bgp
, vpn
, pi
)) {
2995 ret
= install_evpn_route_entry(
2998 ret
= uninstall_evpn_route_entry(
3004 "%u: Failed to %s EVPN %s route in VNI %u",
3008 rtype
== BGP_EVPN_MAC_IP_ROUTE
3022 /* Install any existing remote ES routes applicable for this ES into its routing
3023 * table. This is invoked when ES comes up.
3025 static int install_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
3027 return install_uninstall_routes_for_es(bgp
, es
, 1);
3031 /* Install any existing remote routes applicable for this VRF into VRF RIB. This
3032 * is invoked upon l3vni-add or l3vni import rt change
3034 static int install_routes_for_vrf(struct bgp
*bgp_vrf
)
3036 install_uninstall_routes_for_vrf(bgp_vrf
, 1);
3041 * Install any existing remote routes applicable for this VNI into its
3042 * routing table. This is invoked when a VNI becomes "live" or its Import
3045 static int install_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3049 /* Install type-3 routes followed by type-2 routes - the ones applicable
3052 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3057 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3061 /* uninstall routes from l3vni vrf. */
3062 static int uninstall_routes_for_vrf(struct bgp
*bgp_vrf
)
3064 install_uninstall_routes_for_vrf(bgp_vrf
, 0);
3069 * Uninstall any existing remote routes for this VNI. One scenario in which
3070 * this is invoked is upon an import RT change.
3072 static int uninstall_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3076 /* Uninstall type-2 routes followed by type-3 routes - the ones
3080 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3085 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3089 /* Install or unistall route in ES */
3090 static int install_uninstall_route_in_es(struct bgp
*bgp
, struct evpnes
*es
,
3091 afi_t afi
, safi_t safi
,
3092 struct prefix_evpn
*evp
,
3093 struct bgp_path_info
*pi
, int install
)
3096 char buf
[ESI_STR_LEN
];
3099 ret
= install_evpn_route_entry_in_es(bgp
, es
, evp
, pi
);
3101 ret
= uninstall_evpn_route_entry_in_es(bgp
, es
, evp
, pi
);
3106 "%u: Failed to %s EVPN %s route in ESI %s", bgp
->vrf_id
,
3107 install
? "install" : "uninstall", "ES",
3108 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)));
3115 * Install or uninstall route in matching VRFs (list).
3117 static int install_uninstall_route_in_vrfs(struct bgp
*bgp_def
, afi_t afi
,
3118 safi_t safi
, struct prefix_evpn
*evp
,
3119 struct bgp_path_info
*pi
,
3120 struct list
*vrfs
, int install
)
3122 char buf
[PREFIX2STR_BUFFER
];
3123 struct bgp
*bgp_vrf
;
3124 struct listnode
*node
, *nnode
;
3126 /* Only type-2/type-5 routes go into a VRF */
3127 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3128 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3131 /* if it is type-2 route and not a mac+ip route skip this route */
3132 if ((evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
3133 && !(is_evpn_prefix_ipaddr_v4(evp
)
3134 || is_evpn_prefix_ipaddr_v6(evp
)))
3137 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, bgp_vrf
)) {
3141 ret
= install_evpn_route_entry_in_vrf(bgp_vrf
, evp
, pi
);
3143 ret
= uninstall_evpn_route_entry_in_vrf(bgp_vrf
, evp
,
3147 flog_err(EC_BGP_EVPN_FAIL
,
3148 "%u: Failed to %s prefix %s in VRF %s",
3150 install
? "install" : "uninstall",
3151 prefix2str(evp
, buf
, sizeof(buf
)),
3152 vrf_id_to_name(bgp_vrf
->vrf_id
));
3161 * Install or uninstall route in matching VNIs (list).
3163 static int install_uninstall_route_in_vnis(struct bgp
*bgp
, afi_t afi
,
3164 safi_t safi
, struct prefix_evpn
*evp
,
3165 struct bgp_path_info
*pi
,
3166 struct list
*vnis
, int install
)
3168 struct bgpevpn
*vpn
;
3169 struct listnode
*node
, *nnode
;
3171 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, vpn
)) {
3174 if (!is_vni_live(vpn
))
3178 ret
= install_evpn_route_entry(bgp
, vpn
, evp
, pi
);
3180 ret
= uninstall_evpn_route_entry(bgp
, vpn
, evp
, pi
);
3183 flog_err(EC_BGP_EVPN_FAIL
,
3184 "%u: Failed to %s EVPN %s route in VNI %u",
3185 bgp
->vrf_id
, install
? "install" : "uninstall",
3186 evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3198 * Install or uninstall route for appropriate VNIs/ESIs.
3200 static int install_uninstall_evpn_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
3202 struct bgp_path_info
*pi
, int import
)
3204 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
3205 struct attr
*attr
= pi
->attr
;
3206 struct ecommunity
*ecom
;
3211 /* Only type-2, type-3, type-4 and type-5 are supported currently */
3212 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3213 || evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
3214 || evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
3215 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3218 /* If we don't have Route Target, nothing much to do. */
3219 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
3222 ecom
= attr
->ecommunity
;
3223 if (!ecom
|| !ecom
->size
)
3226 /* An EVPN route belongs to a VNI or a VRF or an ESI based on the RTs
3227 * attached to the route */
3228 for (i
= 0; i
< ecom
->size
; i
++) {
3230 uint8_t type
, sub_type
;
3231 struct ecommunity_val
*eval
;
3232 struct ecommunity_val eval_tmp
;
3233 struct irt_node
*irt
; /* import rt for l2vni */
3234 struct vrf_irt_node
*vrf_irt
; /* import rt for l3vni */
3237 /* Only deal with RTs */
3238 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3239 eval
= (struct ecommunity_val
*)(ecom
->val
3240 + (i
* ECOMMUNITY_SIZE
));
3243 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
3247 * macip routes (type-2) are imported into VNI and VRF tables.
3248 * IMET route is imported into VNI table.
3249 * prefix routes are imported into VRF table.
3251 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
||
3252 evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
||
3253 evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
3255 irt
= lookup_import_rt(bgp
, eval
);
3257 install_uninstall_route_in_vnis(
3258 bgp
, afi
, safi
, evp
, pi
, irt
->vnis
,
3261 vrf_irt
= lookup_vrf_import_rt(eval
);
3263 install_uninstall_route_in_vrfs(
3264 bgp
, afi
, safi
, evp
, pi
, vrf_irt
->vrfs
,
3267 /* Also check for non-exact match.
3268 * In this, we mask out the AS and
3269 * only check on the local-admin sub-field.
3270 * This is to facilitate using
3271 * VNI as the RT for EBGP peering too.
3275 if (type
== ECOMMUNITY_ENCODE_AS
3276 || type
== ECOMMUNITY_ENCODE_AS4
3277 || type
== ECOMMUNITY_ENCODE_IP
) {
3278 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3279 mask_ecom_global_admin(&eval_tmp
, eval
);
3280 irt
= lookup_import_rt(bgp
, &eval_tmp
);
3281 vrf_irt
= lookup_vrf_import_rt(&eval_tmp
);
3285 install_uninstall_route_in_vnis(
3286 bgp
, afi
, safi
, evp
, pi
, irt
->vnis
,
3289 install_uninstall_route_in_vrfs(
3290 bgp
, afi
, safi
, evp
, pi
, vrf_irt
->vrfs
,
3294 /* es route is imported into the es table */
3295 if (evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
3297 /* we will match based on the entire esi to avoid
3298 * imoort of an es route for esi2 into esi1
3300 es
= bgp_evpn_lookup_es(bgp
, &evp
->prefix
.es_addr
.esi
);
3301 if (es
&& is_es_local(es
))
3302 install_uninstall_route_in_es(
3303 bgp
, es
, afi
, safi
, evp
, pi
, import
);
3311 * delete and withdraw all ipv4 and ipv6 routes in the vrf table as type-5
3314 static void delete_withdraw_vrf_routes(struct bgp
*bgp_vrf
)
3316 /* delete all ipv4 routes and withdraw from peers */
3317 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3318 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3320 /* delete all ipv6 routes and withdraw from peers */
3321 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3322 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3326 * update and advertise all ipv4 and ipv6 routes in thr vrf table as type-5
3329 static void update_advertise_vrf_routes(struct bgp
*bgp_vrf
)
3331 /* update all ipv4 routes */
3332 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3333 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3335 /* update all ipv6 routes */
3336 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3337 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3341 * update and advertise local routes for a VRF as type-5 routes.
3342 * This is invoked upon RD change for a VRF. Note taht the processing is only
3343 * done in the global route table using the routes which already exist in the
3346 static void update_router_id_vrf(struct bgp
*bgp_vrf
)
3348 /* skip if the RD is configured */
3349 if (is_vrf_rd_configured(bgp_vrf
))
3352 /* derive the RD for the VRF based on new router-id */
3353 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
3355 /* update advertise ipv4|ipv6 routes as type-5 routes */
3356 update_advertise_vrf_routes(bgp_vrf
);
3360 * Delete and withdraw all type-5 routes for the RD corresponding to VRF.
3361 * This is invoked upon VRF RD change. The processing is done only from global
3364 static void withdraw_router_id_vrf(struct bgp
*bgp_vrf
)
3366 /* skip if the RD is configured */
3367 if (is_vrf_rd_configured(bgp_vrf
))
3370 /* delete/withdraw ipv4|ipv6 routes as type-5 routes */
3371 delete_withdraw_vrf_routes(bgp_vrf
);
3375 * Update and advertise local routes for a VNI. Invoked upon router-id
3376 * change. Note that the processing is done only on the global route table
3377 * using routes that already exist in the per-VNI table.
3379 static int update_advertise_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3381 struct prefix_evpn p
;
3382 struct bgp_node
*rn
, *global_rn
;
3383 struct bgp_path_info
*pi
, *global_pi
;
3385 afi_t afi
= AFI_L2VPN
;
3386 safi_t safi
= SAFI_EVPN
;
3388 /* Locate type-3 route for VNI in the per-VNI table and use its
3389 * attributes to create and advertise the type-3 route for this VNI
3390 * in the global table.
3392 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3393 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)&p
);
3394 if (!rn
) /* unexpected */
3396 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
3397 if (pi
->peer
== bgp
->peer_self
&& pi
->type
== ZEBRA_ROUTE_BGP
3398 && pi
->sub_type
== BGP_ROUTE_STATIC
)
3400 if (!pi
) /* unexpected */
3404 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3405 (struct prefix
*)&p
, &vpn
->prd
);
3406 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1, &pi
, 0,
3407 mac_mobility_seqnum(attr
));
3409 /* Schedule for processing and unlock node. */
3410 bgp_process(bgp
, global_rn
, afi
, safi
);
3411 bgp_unlock_node(global_rn
);
3413 /* Now, walk this VNI's route table and use the route and its attribute
3414 * to create and schedule route in global table.
3416 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
3417 rn
= bgp_route_next(rn
)) {
3418 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
3420 /* Identify MAC-IP local routes. */
3421 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
3424 for (pi
= rn
->info
; pi
; pi
= pi
->next
)
3425 if (pi
->peer
== bgp
->peer_self
3426 && pi
->type
== ZEBRA_ROUTE_BGP
3427 && pi
->sub_type
== BGP_ROUTE_STATIC
)
3432 /* Create route in global routing table using this route entry's
3436 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3437 (struct prefix
*)evp
, &vpn
->prd
);
3439 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1,
3441 mac_mobility_seqnum(attr
));
3443 /* Schedule for processing and unlock node. */
3444 bgp_process(bgp
, global_rn
, afi
, safi
);
3445 bgp_unlock_node(global_rn
);
3452 * Delete (and withdraw) local routes for a VNI - only from the global
3453 * table. Invoked upon router-id change.
3455 static int delete_withdraw_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3458 struct prefix_evpn p
;
3459 struct bgp_node
*global_rn
;
3460 struct bgp_path_info
*pi
;
3461 afi_t afi
= AFI_L2VPN
;
3462 safi_t safi
= SAFI_EVPN
;
3464 /* Delete and withdraw locally learnt type-2 routes (MACIP)
3465 * for this VNI - from the global table.
3467 ret
= delete_global_type2_routes(bgp
, vpn
);
3471 /* Remove type-3 route for this VNI from global table. */
3472 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3473 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
3474 (struct prefix
*)&p
, &vpn
->prd
);
3476 /* Delete route entry in the global EVPN table. */
3477 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &pi
);
3479 /* Schedule for processing - withdraws to peers happen from
3483 bgp_process(bgp
, global_rn
, afi
, safi
);
3484 bgp_unlock_node(global_rn
);
3491 * Handle router-id change. Update and advertise local routes corresponding
3492 * to this VNI from peers. Note that this is invoked after updating the
3493 * router-id. The routes in the per-VNI table are used to create routes in
3494 * the global table and schedule them.
3496 static void update_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3498 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3500 /* Skip VNIs with configured RD. */
3501 if (is_rd_configured(vpn
))
3504 bgp_evpn_derive_auto_rd(bgp
, vpn
);
3505 update_advertise_vni_routes(bgp
, vpn
);
3509 * Handle router-id change. Delete and withdraw local routes corresponding
3510 * to this VNI from peers. Note that this is invoked prior to updating
3511 * the router-id and is done only on the global route table, the routes
3512 * are needed in the per-VNI table to re-advertise with new router id.
3514 static void withdraw_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3516 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3518 /* Skip VNIs with configured RD. */
3519 if (is_rd_configured(vpn
))
3522 delete_withdraw_vni_routes(bgp
, vpn
);
3526 * Process received EVPN type-2 route (advertise or withdraw).
3528 static int process_type2_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3529 struct attr
*attr
, uint8_t *pfx
, int psize
,
3530 uint32_t addpath_id
)
3532 struct prefix_rd prd
;
3533 struct prefix_evpn p
;
3534 struct bgp_route_evpn evpn
;
3536 uint8_t macaddr_len
;
3537 mpls_label_t label
[BGP_MAX_LABELS
]; /* holds the VNI(s) as in packet */
3538 uint32_t num_labels
= 0;
3542 /* Type-2 route should be either 33, 37 or 49 bytes or an
3543 * additional 3 bytes if there is a second label (VNI):
3544 * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1),
3545 * MAC Addr (6), IP len (1), IP (0, 4 or 16),
3546 * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3)
3548 if (psize
!= 33 && psize
!= 37 && psize
!= 49 && psize
!= 36
3549 && psize
!= 40 && psize
!= 52) {
3550 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3551 "%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
3552 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3556 memset(&evpn
, 0, sizeof(evpn
));
3558 /* Make prefix_rd */
3559 prd
.family
= AF_UNSPEC
;
3561 memcpy(&prd
.val
, pfx
, 8);
3564 /* Make EVPN prefix. */
3565 memset(&p
, 0, sizeof(struct prefix_evpn
));
3567 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3568 p
.prefix
.route_type
= BGP_EVPN_MAC_IP_ROUTE
;
3570 /* Copy Ethernet Seg Identifier */
3571 memcpy(&evpn
.eth_s_id
.val
, pfx
, ESI_LEN
);
3574 /* Copy Ethernet Tag */
3575 memcpy(ð_tag
, pfx
, 4);
3576 p
.prefix
.macip_addr
.eth_tag
= ntohl(eth_tag
);
3579 /* Get the MAC Addr len */
3580 macaddr_len
= *pfx
++;
3582 /* Get the MAC Addr */
3583 if (macaddr_len
== (ETH_ALEN
* 8)) {
3584 memcpy(&p
.prefix
.macip_addr
.mac
.octet
, pfx
, ETH_ALEN
);
3588 EC_BGP_EVPN_ROUTE_INVALID
,
3589 "%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
3590 peer
->bgp
->vrf_id
, peer
->host
, macaddr_len
);
3596 ipaddr_len
= *pfx
++;
3597 if (ipaddr_len
!= 0 && ipaddr_len
!= IPV4_MAX_BITLEN
3598 && ipaddr_len
!= IPV6_MAX_BITLEN
) {
3600 EC_BGP_EVPN_ROUTE_INVALID
,
3601 "%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
3602 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3607 ipaddr_len
/= 8; /* Convert to bytes. */
3608 p
.prefix
.macip_addr
.ip
.ipa_type
= (ipaddr_len
== IPV4_MAX_BYTELEN
)
3611 memcpy(&p
.prefix
.macip_addr
.ip
.ip
.addr
, pfx
, ipaddr_len
);
3615 /* Get the VNI(s). Stored as bytes here. */
3617 memset(label
, 0, sizeof(label
));
3618 memcpy(&label
[0], pfx
, BGP_LABEL_BYTES
);
3619 pfx
+= BGP_LABEL_BYTES
;
3620 psize
-= (33 + ipaddr_len
);
3621 /* Do we have a second VNI? */
3624 memcpy(&label
[1], pfx
, BGP_LABEL_BYTES
);
3626 * If in future, we are required to access additional fields,
3627 * we MUST increment pfx by BGP_LABEL_BYTES in before reading
3632 /* Process the route. */
3634 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3635 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3636 &prd
, &label
[0], num_labels
, 0, &evpn
);
3638 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3639 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3640 &prd
, &label
[0], num_labels
, &evpn
);
3645 * Process received EVPN type-3 route (advertise or withdraw).
3647 static int process_type3_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3648 struct attr
*attr
, uint8_t *pfx
, int psize
,
3649 uint32_t addpath_id
)
3651 struct prefix_rd prd
;
3652 struct prefix_evpn p
;
3657 /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
3658 * IP len (1) and IP (4 or 16).
3660 if (psize
!= 17 && psize
!= 29) {
3661 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3662 "%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
3663 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3667 /* If PMSI is present, log if it is anything other than IR.
3668 * Note: We just simply ignore the values as it is not clear if
3669 * doing anything else is better.
3672 (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
))) {
3673 if (attr
->pmsi_tnl_type
!= PMSI_TNLTYPE_INGR_REPL
) {
3675 EC_BGP_EVPN_PMSI_PRESENT
,
3676 "%u:%s - Rx EVPN Type-3 NLRI with unsupported PTA %d",
3677 peer
->bgp
->vrf_id
, peer
->host
,
3678 attr
->pmsi_tnl_type
);
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_IMET_ROUTE
;
3694 /* Copy Ethernet Tag */
3695 memcpy(ð_tag
, pfx
, 4);
3696 p
.prefix
.imet_addr
.eth_tag
= ntohl(eth_tag
);
3700 ipaddr_len
= *pfx
++;
3701 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3702 p
.prefix
.imet_addr
.ip
.ipa_type
= IPADDR_V4
;
3703 memcpy(&p
.prefix
.imet_addr
.ip
.ip
.addr
, pfx
, IPV4_MAX_BYTELEN
);
3706 EC_BGP_EVPN_ROUTE_INVALID
,
3707 "%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
3708 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3712 /* Process the route. */
3714 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3715 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3716 &prd
, NULL
, 0, 0, NULL
);
3718 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3719 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3720 &prd
, NULL
, 0, NULL
);
3725 * Process received EVPN type-4 route (advertise or withdraw).
3727 static int process_type4_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3728 struct attr
*attr
, uint8_t *pfx
, int psize
,
3729 uint32_t addpath_id
)
3734 struct in_addr vtep_ip
;
3735 struct prefix_rd prd
;
3736 struct prefix_evpn p
;
3738 /* Type-4 route should be either 23 or 35 bytes
3739 * RD (8), ESI (10), ip-len (1), ip (4 or 16)
3741 if (psize
!= 23 && psize
!= 35) {
3742 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3743 "%u:%s - Rx EVPN Type-4 NLRI with invalid length %d",
3744 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3748 /* Make prefix_rd */
3749 prd
.family
= AF_UNSPEC
;
3751 memcpy(&prd
.val
, pfx
, 8);
3755 memcpy(&esi
, pfx
, ESI_BYTES
);
3760 ipaddr_len
= *pfx
++;
3761 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3762 memcpy(&vtep_ip
, pfx
, IPV4_MAX_BYTELEN
);
3765 EC_BGP_EVPN_ROUTE_INVALID
,
3766 "%u:%s - Rx EVPN Type-4 NLRI with unsupported IP address length %d",
3767 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3771 build_evpn_type4_prefix(&p
, &esi
, vtep_ip
);
3772 /* Process the route. */
3774 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3775 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3776 &prd
, NULL
, 0, 0, NULL
);
3778 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3779 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3780 &prd
, NULL
, 0, NULL
);
3787 * Process received EVPN type-5 route (advertise or withdraw).
3789 static int process_type5_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3790 struct attr
*attr
, uint8_t *pfx
, int psize
,
3791 uint32_t addpath_id
, int withdraw
)
3793 struct prefix_rd prd
;
3794 struct prefix_evpn p
;
3795 struct bgp_route_evpn evpn
;
3798 mpls_label_t label
; /* holds the VNI as in the packet */
3801 /* Type-5 route should be 34 or 58 bytes:
3802 * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16),
3803 * GW (4 or 16) and VNI (3).
3804 * Note that the IP and GW should both be IPv4 or both IPv6.
3806 if (psize
!= 34 && psize
!= 58) {
3807 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3808 "%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
3809 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3813 /* Make prefix_rd */
3814 prd
.family
= AF_UNSPEC
;
3816 memcpy(&prd
.val
, pfx
, 8);
3819 /* Make EVPN prefix. */
3820 memset(&p
, 0, sizeof(struct prefix_evpn
));
3822 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3823 p
.prefix
.route_type
= BGP_EVPN_IP_PREFIX_ROUTE
;
3825 /* Additional information outside of prefix - ESI and GW IP */
3826 memset(&evpn
, 0, sizeof(evpn
));
3829 memcpy(&evpn
.eth_s_id
.val
, pfx
, 10);
3832 /* Fetch Ethernet Tag. */
3833 memcpy(ð_tag
, pfx
, 4);
3834 p
.prefix
.prefix_addr
.eth_tag
= ntohl(eth_tag
);
3837 /* Fetch IP prefix length. */
3839 if (ippfx_len
> IPV6_MAX_BITLEN
) {
3841 EC_BGP_EVPN_ROUTE_INVALID
,
3842 "%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
3843 peer
->bgp
->vrf_id
, peer
->host
, ippfx_len
);
3846 p
.prefix
.prefix_addr
.ip_prefix_length
= ippfx_len
;
3848 /* Determine IPv4 or IPv6 prefix */
3849 /* Since the address and GW are from the same family, this just becomes
3850 * a simple check on the total size.
3853 SET_IPADDR_V4(&p
.prefix
.prefix_addr
.ip
);
3854 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v4
, pfx
, 4);
3856 memcpy(&evpn
.gw_ip
.ipv4
, pfx
, 4);
3859 SET_IPADDR_V6(&p
.prefix
.prefix_addr
.ip
);
3860 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v6
, pfx
, 16);
3862 memcpy(&evpn
.gw_ip
.ipv6
, pfx
, 16);
3866 /* Get the VNI (in MPLS label field). Stored as bytes here. */
3867 memset(&label
, 0, sizeof(label
));
3868 memcpy(&label
, pfx
, BGP_LABEL_BYTES
);
3871 * If in future, we are required to access additional fields,
3872 * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next
3876 /* Process the route. */
3878 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3879 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3880 &prd
, &label
, 1, 0, &evpn
);
3882 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3883 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3884 &prd
, &label
, 1, &evpn
);
3889 static void evpn_mpattr_encode_type5(struct stream
*s
, struct prefix
*p
,
3890 struct prefix_rd
*prd
, mpls_label_t
*label
,
3891 uint32_t num_labels
, struct attr
*attr
)
3895 struct evpn_addr
*p_evpn_p
;
3897 memset(&temp
, 0, 16);
3898 if (p
->family
!= AF_EVPN
)
3900 p_evpn_p
= &(p
->u
.prefix_evpn
);
3902 /* len denites the total len of IP and GW-IP in the route
3903 IP and GW-IP have to be both ipv4 or ipv6
3905 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3906 len
= 8; /* IP and GWIP are both ipv4 */
3908 len
= 32; /* IP and GWIP are both ipv6 */
3909 /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */
3910 stream_putc(s
, 8 + 10 + 4 + 1 + len
+ 3);
3911 stream_put(s
, prd
->val
, 8);
3913 stream_put(s
, &(attr
->evpn_overlay
.eth_s_id
), 10);
3915 stream_put(s
, &temp
, 10);
3916 stream_putl(s
, p_evpn_p
->prefix_addr
.eth_tag
);
3917 stream_putc(s
, p_evpn_p
->prefix_addr
.ip_prefix_length
);
3918 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3919 stream_put_ipv4(s
, p_evpn_p
->prefix_addr
.ip
.ipaddr_v4
.s_addr
);
3921 stream_put(s
, &p_evpn_p
->prefix_addr
.ip
.ipaddr_v6
, 16);
3923 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3925 attr
->evpn_overlay
.gw_ip
.ipv4
.s_addr
);
3927 stream_put(s
, &(attr
->evpn_overlay
.gw_ip
.ipv6
), 16);
3929 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3930 stream_put_ipv4(s
, 0);
3932 stream_put(s
, &temp
, 16);
3936 stream_put(s
, label
, 3);
3942 * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
3944 static void cleanup_vni_on_disable(struct hash_backet
*backet
, struct bgp
*bgp
)
3946 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3948 /* Remove EVPN routes and schedule for processing. */
3949 delete_routes_for_vni(bgp
, vpn
);
3951 /* Clear "live" flag and see if hash needs to be freed. */
3952 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
3953 if (!is_vni_configured(vpn
))
3954 bgp_evpn_free(bgp
, vpn
);
3958 * Free a VNI entry; iterator function called during cleanup.
3960 static void free_vni_entry(struct hash_backet
*backet
, struct bgp
*bgp
)
3962 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3964 delete_all_vni_routes(bgp
, vpn
);
3965 bgp_evpn_free(bgp
, vpn
);
3969 * Derive AUTO import RT for BGP VRF - L3VNI
3971 static void evpn_auto_rt_import_add_for_vrf(struct bgp
*bgp_vrf
)
3973 struct bgp
*bgp_def
= NULL
;
3975 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3976 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3979 bgp_def
= bgp_get_default();
3982 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3986 * Delete AUTO import RT from BGP VRF - L3VNI
3988 static void evpn_auto_rt_import_delete_for_vrf(struct bgp
*bgp_vrf
)
3990 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3994 * Derive AUTO export RT for BGP VRF - L3VNI
3996 static void evpn_auto_rt_export_add_for_vrf(struct bgp
*bgp_vrf
)
3998 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3999 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4003 * Delete AUTO export RT from BGP VRF - L3VNI
4005 static void evpn_auto_rt_export_delete_for_vrf(struct bgp
*bgp_vrf
)
4007 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4010 static void bgp_evpn_handle_export_rt_change_for_vrf(struct bgp
*bgp_vrf
)
4012 struct bgp
*bgp_def
= NULL
;
4013 struct listnode
*node
= NULL
;
4014 struct bgpevpn
*vpn
= NULL
;
4016 bgp_def
= bgp_get_default();
4020 /* update all type-5 routes */
4021 update_advertise_vrf_routes(bgp_vrf
);
4023 /* update all type-2 routes */
4024 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4025 update_routes_for_vni(bgp_def
, vpn
);
4029 * Handle autort change for a given VNI.
4031 static void update_autort_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
4033 struct bgpevpn
*vpn
= backet
->data
;
4035 if (!is_import_rt_configured(vpn
)) {
4036 if (is_vni_live(vpn
))
4037 bgp_evpn_uninstall_routes(bgp
, vpn
);
4038 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4039 list_delete_all_node(vpn
->import_rtl
);
4040 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
4041 if (is_vni_live(vpn
))
4042 bgp_evpn_install_routes(bgp
, vpn
);
4044 if (!is_export_rt_configured(vpn
)) {
4045 list_delete_all_node(vpn
->export_rtl
);
4046 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
4047 if (is_vni_live(vpn
))
4048 bgp_evpn_handle_export_rt_change(bgp
, vpn
);
4056 /* withdraw type-5 route corresponding to ip prefix */
4057 void bgp_evpn_withdraw_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4058 afi_t afi
, safi_t safi
)
4061 struct prefix_evpn evp
;
4062 char buf
[PREFIX_STRLEN
];
4064 build_type5_prefix_from_ip_prefix(&evp
, p
);
4065 ret
= delete_evpn_type5_route(bgp_vrf
, &evp
);
4068 EC_BGP_EVPN_ROUTE_DELETE
,
4069 "%u failed to delete type-5 route for prefix %s in vrf %s",
4070 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)),
4071 vrf_id_to_name(bgp_vrf
->vrf_id
));
4075 /* withdraw all type-5 routes for an address family */
4076 void bgp_evpn_withdraw_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
, safi_t safi
)
4078 struct bgp_table
*table
= NULL
;
4079 struct bgp_node
*rn
= NULL
;
4080 struct bgp_path_info
*pi
;
4082 table
= bgp_vrf
->rib
[afi
][safi
];
4083 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4084 /* Only care about "selected" routes - non-imported. */
4085 /* TODO: Support for AddPath for EVPN. */
4086 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
4087 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)
4088 && (!pi
->extra
|| !pi
->extra
->parent
)) {
4089 bgp_evpn_withdraw_type5_route(bgp_vrf
, &rn
->p
,
4098 * Advertise IP prefix as type-5 route. The afi/safi and src_attr passed
4099 * to this function correspond to those of the source IP prefix (best
4100 * path in the case of the attr. In the case of a local prefix (when we
4101 * are advertising local subnets), the src_attr will be NULL.
4103 void bgp_evpn_advertise_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4104 struct attr
*src_attr
, afi_t afi
,
4108 struct prefix_evpn evp
;
4109 char buf
[PREFIX_STRLEN
];
4111 build_type5_prefix_from_ip_prefix(&evp
, p
);
4112 ret
= update_evpn_type5_route(bgp_vrf
, &evp
, src_attr
);
4114 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
4115 "%u: Failed to create type-5 route for prefix %s",
4116 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)));
4119 /* Inject all prefixes of a particular address-family (currently, IPv4 or
4120 * IPv6 unicast) into EVPN as type-5 routes. This is invoked when the
4121 * advertisement is enabled.
4123 void bgp_evpn_advertise_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
,
4126 struct bgp_table
*table
= NULL
;
4127 struct bgp_node
*rn
= NULL
;
4128 struct bgp_path_info
*pi
;
4130 table
= bgp_vrf
->rib
[afi
][safi
];
4131 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4132 /* Need to identify the "selected" route entry to use its
4133 * attribute. Also, we only consider "non-imported" routes.
4134 * TODO: Support for AddPath for EVPN.
4136 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
4137 if (CHECK_FLAG(pi
->flags
, BGP_PATH_SELECTED
)
4138 && (!pi
->extra
|| !pi
->extra
->parent
)) {
4140 /* apply the route-map */
4141 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
) {
4144 ret
= route_map_apply(
4145 bgp_vrf
->adv_cmd_rmap
[afi
][safi
]
4147 &rn
->p
, RMAP_BGP
, pi
);
4148 if (ret
== RMAP_DENYMATCH
)
4151 bgp_evpn_advertise_type5_route(
4152 bgp_vrf
, &rn
->p
, pi
->attr
, afi
, safi
);
4159 void evpn_rt_delete_auto(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
4161 struct listnode
*node
, *nnode
, *node_to_del
;
4162 struct ecommunity
*ecom
, *ecom_auto
;
4163 struct ecommunity_val eval
;
4165 if (bgp
->advertise_autort_rfc8365
)
4166 vni
|= EVPN_AUTORT_VXLAN
;
4167 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
4169 ecom_auto
= ecommunity_new();
4170 ecommunity_add_val(ecom_auto
, &eval
);
4173 for (ALL_LIST_ELEMENTS(rtl
, node
, nnode
, ecom
)) {
4174 if (ecommunity_match(ecom
, ecom_auto
)) {
4175 ecommunity_free(&ecom
);
4181 list_delete_node(rtl
, node_to_del
);
4183 ecommunity_free(&ecom_auto
);
4186 void bgp_evpn_configure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4187 struct ecommunity
*ecomadd
)
4189 /* uninstall routes from vrf */
4190 uninstall_routes_for_vrf(bgp_vrf
);
4192 /* Cleanup the RT to VRF mapping */
4193 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4195 /* Remove auto generated RT */
4196 evpn_auto_rt_import_delete_for_vrf(bgp_vrf
);
4198 /* Add the newly configured RT to RT list */
4199 listnode_add_sort(bgp_vrf
->vrf_import_rtl
, ecomadd
);
4200 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4202 /* map VRF to its RTs */
4203 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4205 /* install routes matching the new VRF */
4206 install_routes_for_vrf(bgp_vrf
);
4209 void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4210 struct ecommunity
*ecomdel
)
4212 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4213 struct ecommunity
*ecom
= NULL
;
4215 /* uninstall routes from vrf */
4216 uninstall_routes_for_vrf(bgp_vrf
);
4218 /* Cleanup the RT to VRF mapping */
4219 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4221 /* remove the RT from the RT list */
4222 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4223 if (ecommunity_match(ecom
, ecomdel
)) {
4224 ecommunity_free(&ecom
);
4231 list_delete_node(bgp_vrf
->vrf_import_rtl
, node_to_del
);
4233 assert(bgp_vrf
->vrf_import_rtl
);
4234 /* fallback to auto import rt, if this was the last RT */
4235 if (bgp_vrf
->vrf_import_rtl
&& list_isempty(bgp_vrf
->vrf_import_rtl
)) {
4236 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4237 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
4240 /* map VRFs to its RTs */
4241 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4243 /* install routes matching this new RT */
4244 install_routes_for_vrf(bgp_vrf
);
4247 void bgp_evpn_configure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4248 struct ecommunity
*ecomadd
)
4250 /* remove auto-generated RT */
4251 evpn_auto_rt_export_delete_for_vrf(bgp_vrf
);
4253 /* Add the new RT to the RT list */
4254 listnode_add_sort(bgp_vrf
->vrf_export_rtl
, ecomadd
);
4255 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4257 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4260 void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4261 struct ecommunity
*ecomdel
)
4263 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4264 struct ecommunity
*ecom
= NULL
;
4266 /* Remove the RT from the RT list */
4267 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, ecom
)) {
4268 if (ecommunity_match(ecom
, ecomdel
)) {
4269 ecommunity_free(&ecom
);
4276 list_delete_node(bgp_vrf
->vrf_export_rtl
, node_to_del
);
4279 * Temporary assert to make SA happy.
4280 * The ALL_LIST_ELEMENTS macro above has a NULL check
4281 * which means that SA is going to complain about
4282 * the list_isempty call, which doesn't NULL check.
4283 * So until we get this situation cleaned up, here
4286 assert(bgp_vrf
->vrf_export_rtl
);
4288 /* fall back to auto-generated RT if this was the last RT */
4289 if (list_isempty(bgp_vrf
->vrf_export_rtl
)) {
4290 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4291 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
4294 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4298 * Handle change to BGP router id. This is invoked twice by the change
4299 * handler, first before the router id has been changed and then after
4300 * the router id has been changed. The first invocation will result in
4301 * local routes for all VNIs/VRF being deleted and withdrawn and the next
4302 * will result in the routes being re-advertised.
4304 void bgp_evpn_handle_router_id_update(struct bgp
*bgp
, int withdraw
)
4308 /* delete and withdraw all the type-5 routes
4309 stored in the global table for this vrf
4311 withdraw_router_id_vrf(bgp
);
4313 /* delete all the VNI routes (type-2/type-3) routes for all the
4316 hash_iterate(bgp
->vnihash
,
4317 (void (*)(struct hash_backet
*,
4318 void *))withdraw_router_id_vni
,
4322 /* advertise all routes in the vrf as type-5 routes with the new
4325 update_router_id_vrf(bgp
);
4327 /* advertise all the VNI routes (type-2/type-3) routes with the
4330 hash_iterate(bgp
->vnihash
,
4331 (void (*)(struct hash_backet
*,
4332 void *))update_router_id_vni
,
4338 * Handle change to auto-RT algorithm - update and advertise local routes.
4340 void bgp_evpn_handle_autort_change(struct bgp
*bgp
)
4342 hash_iterate(bgp
->vnihash
,
4343 (void (*)(struct hash_backet
*,
4344 void*))update_autort_vni
,
4349 * Handle change to export RT - update and advertise local routes.
4351 int bgp_evpn_handle_export_rt_change(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4353 return update_routes_for_vni(bgp
, vpn
);
4356 void bgp_evpn_handle_vrf_rd_change(struct bgp
*bgp_vrf
, int withdraw
)
4359 delete_withdraw_vrf_routes(bgp_vrf
);
4361 update_advertise_vrf_routes(bgp_vrf
);
4365 * Handle change to RD. This is invoked twice by the change handler,
4366 * first before the RD has been changed and then after the RD has
4367 * been changed. The first invocation will result in local routes
4368 * of this VNI being deleted and withdrawn and the next will result
4369 * in the routes being re-advertised.
4371 void bgp_evpn_handle_rd_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
4375 delete_withdraw_vni_routes(bgp
, vpn
);
4377 update_advertise_vni_routes(bgp
, vpn
);
4381 * Install routes for this VNI. Invoked upon change to Import RT.
4383 int bgp_evpn_install_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4385 return install_routes_for_vni(bgp
, vpn
);
4389 * Uninstall all routes installed for this VNI. Invoked upon change
4392 int bgp_evpn_uninstall_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4394 return uninstall_routes_for_vni(bgp
, vpn
);
4398 * TODO: Hardcoded for a maximum of 2 VNIs right now
4400 char *bgp_evpn_label2str(mpls_label_t
*label
, uint32_t num_labels
, char *buf
,
4405 vni1
= label2vni(label
);
4406 if (num_labels
== 2) {
4407 vni2
= label2vni(label
+ 1);
4408 snprintf(buf
, len
, "%u/%u", vni1
, vni2
);
4410 snprintf(buf
, len
, "%u", vni1
);
4415 * Function to convert evpn route to json format.
4416 * NOTE: We don't use prefix2str as the output here is a bit different.
4418 void bgp_evpn_route2json(struct prefix_evpn
*p
, json_object
*json
)
4420 char buf1
[ETHER_ADDR_STRLEN
];
4421 char buf2
[PREFIX2STR_BUFFER
];
4426 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4427 json_object_int_add(json
, "routeType", p
->prefix
.route_type
);
4428 json_object_int_add(json
, "ethTag",
4429 p
->prefix
.imet_addr
.eth_tag
);
4430 json_object_int_add(json
, "ipLen",
4431 is_evpn_prefix_ipaddr_v4(p
)
4434 json_object_string_add(json
, "ip",
4435 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4436 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4437 if (is_evpn_prefix_ipaddr_none(p
)) {
4438 json_object_int_add(json
, "routeType",
4439 p
->prefix
.route_type
);
4440 json_object_int_add(json
, "ethTag",
4441 p
->prefix
.macip_addr
.eth_tag
);
4442 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4443 json_object_string_add(json
, "mac",
4444 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4450 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4453 json_object_int_add(json
, "routeType",
4454 p
->prefix
.route_type
);
4455 json_object_int_add(json
, "ethTag",
4456 p
->prefix
.macip_addr
.eth_tag
);
4457 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4458 json_object_string_add(json
, "mac",
4459 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4462 json_object_int_add(json
, "ipLen",
4463 is_evpn_prefix_ipaddr_v4(p
)
4466 json_object_string_add(
4469 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4471 PREFIX2STR_BUFFER
));
4474 /* Currently, this is to cater to other AF_ETHERNET code. */
4479 * Function to convert evpn route to string.
4480 * NOTE: We don't use prefix2str as the output here is a bit different.
4482 char *bgp_evpn_route2str(struct prefix_evpn
*p
, char *buf
, int len
)
4484 char buf1
[ETHER_ADDR_STRLEN
];
4485 char buf2
[PREFIX2STR_BUFFER
];
4486 char buf3
[ESI_STR_LEN
];
4488 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4489 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]", p
->prefix
.route_type
,
4490 p
->prefix
.imet_addr
.eth_tag
,
4491 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4493 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4494 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4495 if (is_evpn_prefix_ipaddr_none(p
))
4496 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4497 p
->prefix
.route_type
,
4498 p
->prefix
.macip_addr
.eth_tag
,
4500 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4505 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4507 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]:[%d]:[%s]",
4508 p
->prefix
.route_type
,
4509 p
->prefix
.macip_addr
.eth_tag
,
4511 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4513 family
== AF_INET
? IPV4_MAX_BITLEN
4516 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4518 PREFIX2STR_BUFFER
));
4520 } else if (p
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
4521 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4522 p
->prefix
.route_type
,
4523 p
->prefix
.prefix_addr
.eth_tag
,
4524 p
->prefix
.prefix_addr
.ip_prefix_length
,
4525 is_evpn_prefix_ipaddr_v4(p
)
4526 ? inet_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v4
)
4527 : inet6_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v6
));
4528 } else if (p
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
4529 snprintf(buf
, len
, "[%d]:[%s]:[%d]:[%s]",
4530 p
->prefix
.route_type
,
4531 esi_to_str(&p
->prefix
.es_addr
.esi
, buf3
, sizeof(buf3
)),
4532 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4534 inet_ntoa(p
->prefix
.es_addr
.ip
.ipaddr_v4
));
4536 /* For EVPN route types not supported yet. */
4537 snprintf(buf
, len
, "(unsupported route type %d)",
4538 p
->prefix
.route_type
);
4545 * Encode EVPN prefix in Update (MP_REACH)
4547 void bgp_evpn_encode_prefix(struct stream
*s
, struct prefix
*p
,
4548 struct prefix_rd
*prd
, mpls_label_t
*label
,
4549 uint32_t num_labels
, struct attr
*attr
,
4550 int addpath_encode
, uint32_t addpath_tx_id
)
4552 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
4553 int len
, ipa_len
= 0;
4556 stream_putl(s
, addpath_tx_id
);
4559 stream_putc(s
, evp
->prefix
.route_type
);
4561 switch (evp
->prefix
.route_type
) {
4562 case BGP_EVPN_MAC_IP_ROUTE
:
4563 if (is_evpn_prefix_ipaddr_v4(evp
))
4564 ipa_len
= IPV4_MAX_BYTELEN
;
4565 else if (is_evpn_prefix_ipaddr_v6(evp
))
4566 ipa_len
= IPV6_MAX_BYTELEN
;
4567 /* RD, ESI, EthTag, MAC+len, IP len, [IP], 1 VNI */
4568 len
= 8 + 10 + 4 + 1 + 6 + 1 + ipa_len
+ 3;
4569 if (ipa_len
&& num_labels
> 1) /* There are 2 VNIs */
4571 stream_putc(s
, len
);
4572 stream_put(s
, prd
->val
, 8); /* RD */
4574 stream_put(s
, &attr
->evpn_overlay
.eth_s_id
, ESI_LEN
);
4576 stream_put(s
, 0, 10);
4577 stream_putl(s
, evp
->prefix
.macip_addr
.eth_tag
); /* Ethernet Tag ID */
4578 stream_putc(s
, 8 * ETH_ALEN
); /* Mac Addr Len - bits */
4579 stream_put(s
, evp
->prefix
.macip_addr
.mac
.octet
, 6); /* Mac Addr */
4580 stream_putc(s
, 8 * ipa_len
); /* IP address Length */
4581 if (ipa_len
) /* IP */
4582 stream_put(s
, &evp
->prefix
.macip_addr
.ip
.ip
.addr
,
4584 /* 1st label is the L2 VNI */
4585 stream_put(s
, label
, BGP_LABEL_BYTES
);
4586 /* Include 2nd label (L3 VNI) if advertising MAC+IP */
4587 if (ipa_len
&& num_labels
> 1)
4588 stream_put(s
, label
+ 1, BGP_LABEL_BYTES
);
4591 case BGP_EVPN_IMET_ROUTE
:
4592 stream_putc(s
, 17); // TODO: length - assumes IPv4 address
4593 stream_put(s
, prd
->val
, 8); /* RD */
4594 stream_putl(s
, evp
->prefix
.imet_addr
.eth_tag
); /* Ethernet Tag ID */
4595 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4596 /* Originating Router's IP Addr */
4597 stream_put_in_addr(s
, &evp
->prefix
.imet_addr
.ip
.ipaddr_v4
);
4600 case BGP_EVPN_ES_ROUTE
:
4601 stream_putc(s
, 23); /* TODO: length: assumes ipv4 VTEP */
4602 stream_put(s
, prd
->val
, 8); /* RD */
4603 stream_put(s
, evp
->prefix
.es_addr
.esi
.val
, 10); /* ESI */
4604 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4606 stream_put_in_addr(s
, &evp
->prefix
.es_addr
.ip
.ipaddr_v4
);
4609 case BGP_EVPN_IP_PREFIX_ROUTE
:
4610 /* TODO: AddPath support. */
4611 evpn_mpattr_encode_type5(s
, p
, prd
, label
, num_labels
, attr
);
4619 int bgp_nlri_parse_evpn(struct peer
*peer
, struct attr
*attr
,
4620 struct bgp_nlri
*packet
, int withdraw
)
4626 uint32_t addpath_id
;
4627 int addpath_encoded
;
4632 /* Start processing the NLRI - there may be multiple in the MP_REACH */
4634 lim
= pnt
+ packet
->length
;
4636 safi
= packet
->safi
;
4640 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
4641 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
4642 PEER_CAP_ADDPATH_AF_TX_RCV
));
4644 for (; pnt
< lim
; pnt
+= psize
) {
4645 /* Clear prefix structure. */
4646 memset(&p
, 0, sizeof(struct prefix
));
4648 /* Deal with path-id if AddPath is supported. */
4649 if (addpath_encoded
) {
4650 /* When packet overflow occurs return immediately. */
4651 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
4654 addpath_id
= ntohl(*((uint32_t *)pnt
));
4655 pnt
+= BGP_ADDPATH_ID_LEN
;
4658 /* All EVPN NLRI types start with type and length. */
4665 /* When packet overflow occur return immediately. */
4666 if (pnt
+ psize
> lim
)
4670 case BGP_EVPN_MAC_IP_ROUTE
:
4671 if (process_type2_route(peer
, afi
, safi
,
4672 withdraw
? NULL
: attr
, pnt
,
4673 psize
, addpath_id
)) {
4676 "%u:%s - Error in processing EVPN type-2 NLRI size %d",
4677 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4682 case BGP_EVPN_IMET_ROUTE
:
4683 if (process_type3_route(peer
, afi
, safi
,
4684 withdraw
? NULL
: attr
, pnt
,
4685 psize
, addpath_id
)) {
4688 "%u:%s - Error in processing EVPN type-3 NLRI size %d",
4689 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4694 case BGP_EVPN_ES_ROUTE
:
4695 if (process_type4_route(peer
, afi
, safi
,
4696 withdraw
? NULL
: attr
, pnt
,
4697 psize
, addpath_id
)) {
4700 "%u:%s - Error in processing EVPN type-4 NLRI size %d",
4701 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4706 case BGP_EVPN_IP_PREFIX_ROUTE
:
4707 if (process_type5_route(peer
, afi
, safi
, attr
, pnt
,
4708 psize
, addpath_id
, withdraw
)) {
4711 "%u:%s - Error in processing EVPN type-5 NLRI size %d",
4712 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4722 /* Packet length consistency check. */
4730 * Map the RTs (configured or automatically derived) of a VRF to the VRF.
4731 * The mapping will be used during route processing.
4732 * bgp_def: default bgp instance
4733 * bgp_vrf: specific bgp vrf instance on which RT is configured
4735 void bgp_evpn_map_vrf_to_its_rts(struct bgp
*bgp_vrf
)
4738 struct ecommunity_val
*eval
= NULL
;
4739 struct listnode
*node
= NULL
, *nnode
= NULL
;
4740 struct ecommunity
*ecom
= NULL
;
4742 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4743 for (i
= 0; i
< ecom
->size
; i
++) {
4744 eval
= (struct ecommunity_val
*)(ecom
->val
4746 * ECOMMUNITY_SIZE
));
4747 map_vrf_to_rt(bgp_vrf
, eval
);
4753 * Unmap the RTs (configured or automatically derived) of a VRF from the VRF.
4755 void bgp_evpn_unmap_vrf_from_its_rts(struct bgp
*bgp_vrf
)
4758 struct ecommunity_val
*eval
;
4759 struct listnode
*node
, *nnode
;
4760 struct ecommunity
*ecom
;
4762 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4763 for (i
= 0; i
< ecom
->size
; i
++) {
4764 struct vrf_irt_node
*irt
;
4765 struct ecommunity_val eval_tmp
;
4767 eval
= (struct ecommunity_val
*)(ecom
->val
4769 * ECOMMUNITY_SIZE
));
4770 /* If using "automatic" RT, we only care about the
4771 * local-admin sub-field.
4772 * This is to facilitate using VNI as the RT for EBGP
4775 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4776 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
4777 BGP_VRF_IMPORT_RT_CFGD
))
4778 mask_ecom_global_admin(&eval_tmp
, eval
);
4780 irt
= lookup_vrf_import_rt(&eval_tmp
);
4782 unmap_vrf_from_rt(bgp_vrf
, irt
);
4789 * Map the RTs (configured or automatically derived) of a VNI to the VNI.
4790 * The mapping will be used during route processing.
4792 void bgp_evpn_map_vni_to_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4795 struct ecommunity_val
*eval
;
4796 struct listnode
*node
, *nnode
;
4797 struct ecommunity
*ecom
;
4799 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4800 for (i
= 0; i
< ecom
->size
; i
++) {
4801 eval
= (struct ecommunity_val
*)(ecom
->val
4803 * ECOMMUNITY_SIZE
));
4804 map_vni_to_rt(bgp
, vpn
, eval
);
4810 * Unmap the RTs (configured or automatically derived) of a VNI from the VNI.
4812 void bgp_evpn_unmap_vni_from_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4815 struct ecommunity_val
*eval
;
4816 struct listnode
*node
, *nnode
;
4817 struct ecommunity
*ecom
;
4819 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4820 for (i
= 0; i
< ecom
->size
; i
++) {
4821 struct irt_node
*irt
;
4822 struct ecommunity_val eval_tmp
;
4824 eval
= (struct ecommunity_val
*)(ecom
->val
4826 * ECOMMUNITY_SIZE
));
4827 /* If using "automatic" RT, we only care about the
4828 * local-admin sub-field.
4829 * This is to facilitate using VNI as the RT for EBGP
4832 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4833 if (!is_import_rt_configured(vpn
))
4834 mask_ecom_global_admin(&eval_tmp
, eval
);
4836 irt
= lookup_import_rt(bgp
, &eval_tmp
);
4838 unmap_vni_from_rt(bgp
, vpn
, irt
);
4844 * Derive Import RT automatically for VNI and map VNI to RT.
4845 * The mapping will be used during route processing.
4847 void bgp_evpn_derive_auto_rt_import(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4849 form_auto_rt(bgp
, vpn
->vni
, vpn
->import_rtl
);
4850 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
4853 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
4857 * Derive Export RT automatically for VNI.
4859 void bgp_evpn_derive_auto_rt_export(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4861 form_auto_rt(bgp
, vpn
->vni
, vpn
->export_rtl
);
4862 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
4866 * Derive RD automatically for VNI using passed information - it
4867 * is of the form RouterId:unique-id-for-vni.
4869 void bgp_evpn_derive_auto_rd_for_vrf(struct bgp
*bgp
)
4871 form_auto_rd(bgp
->router_id
, bgp
->vrf_rd_id
, &bgp
->vrf_prd
);
4875 * Derive RD automatically for VNI using passed information - it
4876 * is of the form RouterId:unique-id-for-vni.
4878 void bgp_evpn_derive_auto_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4882 vpn
->prd
.family
= AF_UNSPEC
;
4883 vpn
->prd
.prefixlen
= 64;
4884 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), vpn
->rd_id
);
4885 (void)str2prefix_rd(buf
, &vpn
->prd
);
4886 UNSET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
4892 bool bgp_evpn_lookup_l3vni_l2vni_table(vni_t vni
)
4894 struct list
*inst
= bm
->bgp
;
4895 struct listnode
*node
;
4896 struct bgp
*bgp_vrf
;
4898 for (ALL_LIST_ELEMENTS_RO(inst
, node
, bgp_vrf
)) {
4899 if (bgp_vrf
->l3vni
== vni
)
4909 struct bgpevpn
*bgp_evpn_lookup_vni(struct bgp
*bgp
, vni_t vni
)
4911 struct bgpevpn
*vpn
;
4914 memset(&tmp
, 0, sizeof(struct bgpevpn
));
4916 vpn
= hash_lookup(bgp
->vnihash
, &tmp
);
4921 * Create a new vpn - invoked upon configuration or zebra notification.
4923 struct bgpevpn
*bgp_evpn_new(struct bgp
*bgp
, vni_t vni
,
4924 struct in_addr originator_ip
,
4925 vrf_id_t tenant_vrf_id
)
4927 struct bgpevpn
*vpn
;
4932 vpn
= XCALLOC(MTYPE_BGP_EVPN
, sizeof(struct bgpevpn
));
4936 /* Set values - RD and RT set to defaults. */
4938 vpn
->originator_ip
= originator_ip
;
4939 vpn
->tenant_vrf_id
= tenant_vrf_id
;
4941 /* Initialize route-target import and export lists */
4942 vpn
->import_rtl
= list_new();
4943 vpn
->import_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4944 vpn
->import_rtl
->del
= evpn_xxport_delete_ecomm
;
4945 vpn
->export_rtl
= list_new();
4946 vpn
->export_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4947 vpn
->export_rtl
->del
= evpn_xxport_delete_ecomm
;
4948 bf_assign_index(bm
->rd_idspace
, vpn
->rd_id
);
4949 derive_rd_rt_for_vni(bgp
, vpn
);
4951 /* Initialize EVPN route table. */
4952 vpn
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
4955 if (!hash_get(bgp
->vnihash
, vpn
, hash_alloc_intern
)) {
4956 XFREE(MTYPE_BGP_EVPN
, vpn
);
4960 /* add to l2vni list on corresponding vrf */
4961 bgpevpn_link_to_l3vni(vpn
);
4963 QOBJ_REG(vpn
, bgpevpn
);
4968 * Free a given VPN - called in multiple scenarios such as zebra
4969 * notification, configuration being deleted, advertise-all-vni disabled etc.
4970 * This just frees appropriate memory, caller should have taken other
4973 void bgp_evpn_free(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4975 bgpevpn_unlink_from_l3vni(vpn
);
4976 bgp_table_unlock(vpn
->route_table
);
4977 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4978 list_delete(&vpn
->import_rtl
);
4979 list_delete(&vpn
->export_rtl
);
4980 bf_release_index(bm
->rd_idspace
, vpn
->rd_id
);
4981 hash_release(bgp
->vnihash
, vpn
);
4983 XFREE(MTYPE_BGP_EVPN
, vpn
);
4989 struct evpnes
*bgp_evpn_lookup_es(struct bgp
*bgp
, esi_t
*esi
)
4994 memset(&tmp
, 0, sizeof(struct evpnes
));
4995 memcpy(&tmp
.esi
, esi
, sizeof(esi_t
));
4996 es
= hash_lookup(bgp
->esihash
, &tmp
);
5001 * Create a new local es - invoked upon zebra notification.
5003 struct evpnes
*bgp_evpn_es_new(struct bgp
*bgp
,
5005 struct ipaddr
*originator_ip
)
5013 es
= XCALLOC(MTYPE_BGP_EVPN_ES
, sizeof(struct evpnes
));
5017 /* set the ESI and originator_ip */
5018 memcpy(&es
->esi
, esi
, sizeof(esi_t
));
5019 memcpy(&es
->originator_ip
, originator_ip
, sizeof(struct ipaddr
));
5021 /* Initialise the VTEP list */
5022 es
->vtep_list
= list_new();
5023 es
->vtep_list
->cmp
= (int (*)(void *, void *))evpn_vtep_ip_cmp
;
5025 /* auto derive RD for this es */
5026 bf_assign_index(bm
->rd_idspace
, es
->rd_id
);
5027 es
->prd
.family
= AF_UNSPEC
;
5028 es
->prd
.prefixlen
= 64;
5029 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), es
->rd_id
);
5030 (void)str2prefix_rd(buf
, &es
->prd
);
5032 /* Initialize the ES route table */
5033 es
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
5036 if (!hash_get(bgp
->esihash
, es
, hash_alloc_intern
)) {
5037 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5041 QOBJ_REG(es
, evpnes
);
5047 * This just frees appropriate memory, caller should have taken other
5050 void bgp_evpn_es_free(struct bgp
*bgp
, struct evpnes
*es
)
5052 list_delete(&es
->vtep_list
);
5053 bgp_table_unlock(es
->route_table
);
5054 bf_release_index(bm
->rd_idspace
, es
->rd_id
);
5055 hash_release(bgp
->esihash
, es
);
5057 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5061 * Import evpn route from global table to VNI/VRF/ESI.
5063 int bgp_evpn_import_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5064 struct prefix
*p
, struct bgp_path_info
*pi
)
5066 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, pi
, 1);
5070 * Unimport evpn route from VNI/VRF/ESI.
5072 int bgp_evpn_unimport_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5073 struct prefix
*p
, struct bgp_path_info
*pi
)
5075 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, pi
, 0);
5078 /* filter routes which have martian next hops */
5079 int bgp_filter_evpn_routes_upon_martian_nh_change(struct bgp
*bgp
)
5083 struct bgp_node
*rd_rn
, *rn
;
5084 struct bgp_table
*table
;
5085 struct bgp_path_info
*pi
;
5090 /* Walk entire global routing table and evaluate routes which could be
5091 * imported into this VPN. Note that we cannot just look at the routes
5092 * for the VNI's RD -
5093 * remote routes applicable for this VNI could have any RD.
5095 /* EVPN routes are a 2-level table. */
5096 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
5097 rd_rn
= bgp_route_next(rd_rn
)) {
5098 table
= (struct bgp_table
*)(rd_rn
->info
);
5102 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
5104 for (pi
= rn
->info
; pi
; pi
= pi
->next
) {
5106 /* Consider "valid" remote routes applicable for
5108 if (!(pi
->type
== ZEBRA_ROUTE_BGP
5109 && pi
->sub_type
== BGP_ROUTE_NORMAL
))
5112 if (bgp_nexthop_self(bgp
, pi
->attr
->nexthop
)) {
5114 char attr_str
[BUFSIZ
];
5115 char pbuf
[PREFIX_STRLEN
];
5117 bgp_dump_attr(pi
->attr
, attr_str
,
5120 if (bgp_debug_update(pi
->peer
, &rn
->p
,
5123 "%u: prefix %s with attr %s - DENIED due to martian or self nexthop",
5130 bgp_evpn_unimport_route(bgp
, afi
, safi
,
5133 bgp_rib_remove(rn
, pi
, pi
->peer
, afi
,
5144 * Handle del of a local MACIP.
5146 int bgp_evpn_local_macip_del(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5149 struct bgpevpn
*vpn
;
5150 struct prefix_evpn p
;
5152 /* Lookup VNI hash - should exist. */
5153 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5154 if (!vpn
|| !is_vni_live(vpn
)) {
5155 flog_warn(EC_BGP_EVPN_VPN_VNI
,
5156 "%u: VNI hash entry for VNI %u %s at MACIP DEL",
5157 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5161 /* Remove EVPN type-2 route and schedule for processing. */
5162 build_evpn_type2_prefix(&p
, mac
, ip
);
5163 delete_evpn_route(bgp
, vpn
, &p
);
5169 * Handle add of a local MACIP.
5171 int bgp_evpn_local_macip_add(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5172 struct ipaddr
*ip
, uint8_t flags
, uint32_t seq
)
5174 struct bgpevpn
*vpn
;
5175 struct prefix_evpn p
;
5177 /* Lookup VNI hash - should exist. */
5178 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5179 if (!vpn
|| !is_vni_live(vpn
)) {
5180 flog_warn(EC_BGP_EVPN_VPN_VNI
,
5181 "%u: VNI hash entry for VNI %u %s at MACIP ADD",
5182 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5186 /* Create EVPN type-2 route and schedule for processing. */
5187 build_evpn_type2_prefix(&p
, mac
, ip
);
5188 if (update_evpn_route(bgp
, vpn
, &p
, flags
, seq
)) {
5189 char buf
[ETHER_ADDR_STRLEN
];
5190 char buf2
[INET6_ADDRSTRLEN
];
5193 EC_BGP_EVPN_ROUTE_CREATE
,
5194 "%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
5195 bgp
->vrf_id
, vpn
->vni
,
5196 CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
)
5199 prefix_mac2str(mac
, buf
, sizeof(buf
)),
5200 ipaddr2str(ip
, buf2
, sizeof(buf2
)), flags
);
5207 static void link_l2vni_hash_to_l3vni(struct hash_backet
*backet
,
5208 struct bgp
*bgp_vrf
)
5210 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
5211 struct bgp
*bgp_def
= NULL
;
5213 bgp_def
= bgp_get_default();
5216 if (vpn
->tenant_vrf_id
== bgp_vrf
->vrf_id
)
5217 bgpevpn_link_to_l3vni(vpn
);
5220 int bgp_evpn_local_l3vni_add(vni_t l3vni
, vrf_id_t vrf_id
, struct ethaddr
*rmac
,
5221 struct in_addr originator_ip
, int filter
)
5223 struct bgp
*bgp_vrf
= NULL
; /* bgp VRF instance */
5224 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5225 struct listnode
*node
= NULL
;
5226 struct bgpevpn
*vpn
= NULL
;
5229 /* get the default instance - required to get the AS number for VRF
5232 bgp_def
= bgp_get_default();
5236 "Cannot process L3VNI %u ADD - default BGP instance not yet created",
5242 /* if the BGP vrf instance doesnt exist - create one */
5243 bgp_vrf
= bgp_lookup_by_name(vrf_id_to_name(vrf_id
));
5248 ret
= bgp_get(&bgp_vrf
, &as
, vrf_id_to_name(vrf_id
),
5249 BGP_INSTANCE_TYPE_VRF
);
5251 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
:
5252 flog_err(EC_BGP_MULTI_INSTANCE
,
5253 "'bgp multiple-instance' not present\n");
5255 case BGP_ERR_AS_MISMATCH
:
5256 flog_err(EC_BGP_EVPN_AS_MISMATCH
,
5257 "BGP is already running; AS is %u\n", as
);
5259 case BGP_ERR_INSTANCE_MISMATCH
:
5260 flog_err(EC_BGP_EVPN_INSTANCE_MISMATCH
,
5261 "BGP instance name and AS number mismatch\n");
5265 /* mark as auto created */
5266 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
);
5269 /* associate with l3vni */
5270 bgp_vrf
->l3vni
= l3vni
;
5272 /* set the router mac - to be used in mac-ip routes for this vrf */
5273 memcpy(&bgp_vrf
->rmac
, rmac
, sizeof(struct ethaddr
));
5275 /* set the originator ip */
5276 bgp_vrf
->originator_ip
= originator_ip
;
5278 /* set the right filter - are we using l3vni only for prefix routes? */
5280 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
);
5282 /* auto derive RD/RT */
5283 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
5284 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
5285 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
))
5286 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
5287 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
5289 /* link all corresponding l2vnis */
5290 hash_iterate(bgp_def
->vnihash
,
5291 (void (*)(struct hash_backet
*,
5292 void *))link_l2vni_hash_to_l3vni
,
5295 /* Only update all corresponding type-2 routes if we are advertising two
5296 * labels along with type-2 routes
5299 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
5300 update_routes_for_vni(bgp_def
, vpn
);
5302 /* advertise type-5 routes if needed */
5303 update_advertise_vrf_routes(bgp_vrf
);
5305 /* install all remote routes belonging to this l3vni into correspondng
5307 install_routes_for_vrf(bgp_vrf
);
5312 int bgp_evpn_local_l3vni_del(vni_t l3vni
, vrf_id_t vrf_id
)
5314 struct bgp
*bgp_vrf
= NULL
; /* bgp vrf instance */
5315 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5316 struct listnode
*node
= NULL
;
5317 struct listnode
*next
= NULL
;
5318 struct bgpevpn
*vpn
= NULL
;
5320 bgp_vrf
= bgp_lookup_by_vrf_id(vrf_id
);
5324 "Cannot process L3VNI %u Del - Could not find BGP instance",
5329 bgp_def
= bgp_get_default();
5333 "Cannot process L3VNI %u Del - Could not find default BGP instance",
5338 /* Remove remote routes from BGT VRF even if BGP_VRF_AUTO is configured,
5339 * bgp_delete would not remove/decrement bgp_path_info of the ip_prefix
5340 * routes. This will uninstalling the routes from zebra and decremnt the
5343 uninstall_routes_for_vrf(bgp_vrf
);
5345 /* delete/withdraw all type-5 routes */
5346 delete_withdraw_vrf_routes(bgp_vrf
);
5348 /* remove the l3vni from vrf instance */
5351 /* remove the Rmac from the BGP vrf */
5352 memset(&bgp_vrf
->rmac
, 0, sizeof(struct ethaddr
));
5355 if (!list_isempty(bgp_vrf
->vrf_import_rtl
)) {
5356 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
5357 list_delete_all_node(bgp_vrf
->vrf_import_rtl
);
5359 if (!list_isempty(bgp_vrf
->vrf_export_rtl
)) {
5360 list_delete_all_node(bgp_vrf
->vrf_export_rtl
);
5363 /* update all corresponding local mac-ip routes */
5364 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)) {
5365 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
)) {
5366 UNSET_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
);
5367 update_routes_for_vni(bgp_def
, vpn
);
5371 /* If any L2VNIs point to this instance, unlink them. */
5372 for (ALL_LIST_ELEMENTS(bgp_vrf
->l2vnis
, node
, next
, vpn
))
5373 bgpevpn_unlink_from_l3vni(vpn
);
5375 /* Delete the instance if it was autocreated */
5376 if (CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
5377 bgp_delete(bgp_vrf
);
5383 * Handle del of a local VNI.
5385 int bgp_evpn_local_vni_del(struct bgp
*bgp
, vni_t vni
)
5387 struct bgpevpn
*vpn
;
5389 /* Locate VNI hash */
5390 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5392 if (bgp_debug_zebra(NULL
))
5394 EC_BGP_EVPN_VPN_VNI
,
5395 "%u: VNI hash entry for VNI %u not found at DEL",
5400 /* Remove all local EVPN routes and schedule for processing (to
5401 * withdraw from peers).
5403 delete_routes_for_vni(bgp
, vpn
);
5406 * tunnel is no longer active, del tunnel ip address from tip_hash
5408 bgp_tip_del(bgp
, &vpn
->originator_ip
);
5410 /* Clear "live" flag and see if hash needs to be freed. */
5411 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5412 if (!is_vni_configured(vpn
))
5413 bgp_evpn_free(bgp
, vpn
);
5419 * Handle add (or update) of a local VNI. The VNI changes we care
5420 * about are for the local-tunnel-ip and the (tenant) VRF.
5422 int bgp_evpn_local_vni_add(struct bgp
*bgp
, vni_t vni
,
5423 struct in_addr originator_ip
, vrf_id_t tenant_vrf_id
)
5425 struct bgpevpn
*vpn
;
5426 struct prefix_evpn p
;
5428 /* Lookup VNI. If present and no change, exit. */
5429 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5432 if (is_vni_live(vpn
)
5433 && IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
)
5434 && vpn
->tenant_vrf_id
== tenant_vrf_id
)
5435 /* Probably some other param has changed that we don't
5439 /* Update tenant_vrf_id if it has changed. */
5440 if (vpn
->tenant_vrf_id
!= tenant_vrf_id
) {
5441 bgpevpn_unlink_from_l3vni(vpn
);
5442 vpn
->tenant_vrf_id
= tenant_vrf_id
;
5443 bgpevpn_link_to_l3vni(vpn
);
5446 /* If tunnel endpoint IP has changed, update (and delete prior
5447 * type-3 route, if needed.)
5449 if (!IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
))
5450 handle_tunnel_ip_change(bgp
, vpn
, originator_ip
);
5452 /* Update all routes with new endpoint IP and/or export RT
5455 if (is_vni_live(vpn
))
5456 update_routes_for_vni(bgp
, vpn
);
5459 /* Create or update as appropriate. */
5461 vpn
= bgp_evpn_new(bgp
, vni
, originator_ip
, tenant_vrf_id
);
5465 "%u: Failed to allocate VNI entry for VNI %u - at Add",
5471 /* if the VNI is live already, there is nothing more to do */
5472 if (is_vni_live(vpn
))
5475 /* Mark as "live" */
5476 SET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5478 /* tunnel is now active, add tunnel-ip to db */
5479 bgp_tip_add(bgp
, &originator_ip
);
5481 /* filter routes as nexthop database has changed */
5482 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
5484 /* Create EVPN type-3 route and schedule for processing. */
5485 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
5486 if (update_evpn_route(bgp
, vpn
, &p
, 0, 0)) {
5487 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
5488 "%u: Type3 route creation failure for VNI %u",
5493 /* If we have learnt and retained remote routes (VTEPs, MACs) for this
5497 install_routes_for_vni(bgp
, vpn
);
5499 /* If we are advertising gateway mac-ip
5500 It needs to be conveyed again to zebra */
5501 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
, vpn
->vni
);
5507 * bgp_evpn_local_es_del
5509 int bgp_evpn_local_es_del(struct bgp
*bgp
,
5511 struct ipaddr
*originator_ip
)
5513 char buf
[ESI_STR_LEN
];
5514 struct evpnes
*es
= NULL
;
5516 if (!bgp
->esihash
) {
5517 flog_err(EC_BGP_ES_CREATE
, "%u: ESI hash not yet created",
5522 /* Lookup ESI hash - should exist. */
5523 es
= bgp_evpn_lookup_es(bgp
, esi
);
5525 flog_warn(EC_BGP_EVPN_ESI
,
5526 "%u: ESI hash entry for ESI %s at Local ES DEL",
5527 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5531 /* Delete all local EVPN ES routes from ESI table
5532 * and schedule for processing (to withdraw from peers))
5534 delete_routes_for_es(bgp
, es
);
5536 /* free the hash entry */
5537 bgp_evpn_es_free(bgp
, es
);
5543 * bgp_evpn_local_es_add
5545 int bgp_evpn_local_es_add(struct bgp
*bgp
,
5547 struct ipaddr
*originator_ip
)
5549 char buf
[ESI_STR_LEN
];
5550 struct evpnes
*es
= NULL
;
5551 struct prefix_evpn p
;
5553 if (!bgp
->esihash
) {
5554 flog_err(EC_BGP_ES_CREATE
, "%u: ESI hash not yet created",
5559 /* create the new es */
5560 es
= bgp_evpn_lookup_es(bgp
, esi
);
5562 es
= bgp_evpn_es_new(bgp
, esi
, originator_ip
);
5566 "%u: Failed to allocate ES entry for ESI %s - at Local ES Add",
5567 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5571 UNSET_FLAG(es
->flags
, EVPNES_REMOTE
);
5572 SET_FLAG(es
->flags
, EVPNES_LOCAL
);
5574 build_evpn_type4_prefix(&p
, esi
, originator_ip
->ipaddr_v4
);
5575 if (update_evpn_type4_route(bgp
, es
, &p
)) {
5576 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
5577 "%u: Type4 route creation failure for ESI %s",
5578 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5582 /* import all remote ES routes in th ES table */
5583 install_routes_for_es(bgp
, es
);
5589 * Cleanup EVPN information on disable - Need to delete and withdraw
5590 * EVPN routes from peers.
5592 void bgp_evpn_cleanup_on_disable(struct bgp
*bgp
)
5594 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
5595 void *))cleanup_vni_on_disable
,
5600 * Cleanup EVPN information - invoked at the time of bgpd exit or when the
5601 * BGP instance (default) is being freed.
5603 void bgp_evpn_cleanup(struct bgp
*bgp
)
5605 hash_iterate(bgp
->vnihash
,
5606 (void (*)(struct hash_backet
*, void *))free_vni_entry
,
5609 hash_free(bgp
->import_rt_hash
);
5610 bgp
->import_rt_hash
= NULL
;
5612 hash_free(bgp
->vrf_import_rt_hash
);
5613 bgp
->vrf_import_rt_hash
= NULL
;
5615 hash_free(bgp
->vnihash
);
5616 bgp
->vnihash
= NULL
;
5618 hash_free(bgp
->esihash
);
5619 bgp
->esihash
= NULL
;
5621 list_delete(&bgp
->vrf_import_rtl
);
5622 list_delete(&bgp
->vrf_export_rtl
);
5623 list_delete(&bgp
->l2vnis
);
5627 * Initialization for EVPN
5630 * hash for RT to VNI
5632 void bgp_evpn_init(struct bgp
*bgp
)
5635 hash_create(vni_hash_key_make
, vni_hash_cmp
, "BGP VNI Hash");
5637 hash_create(esi_hash_keymake
, esi_cmp
,
5638 "BGP EVPN Local ESI Hash");
5639 bgp
->import_rt_hash
=
5640 hash_create(import_rt_hash_key_make
, import_rt_hash_cmp
,
5641 "BGP Import RT Hash");
5642 bgp
->vrf_import_rt_hash
=
5643 hash_create(vrf_import_rt_hash_key_make
, vrf_import_rt_hash_cmp
,
5644 "BGP VRF Import RT Hash");
5645 bgp
->vrf_import_rtl
= list_new();
5646 bgp
->vrf_import_rtl
->cmp
=
5647 (int (*)(void *, void *))evpn_route_target_cmp
;
5648 bgp
->vrf_import_rtl
->del
= evpn_xxport_delete_ecomm
;
5649 bgp
->vrf_export_rtl
= list_new();
5650 bgp
->vrf_export_rtl
->cmp
=
5651 (int (*)(void *, void *))evpn_route_target_cmp
;
5652 bgp
->vrf_export_rtl
->del
= evpn_xxport_delete_ecomm
;
5653 bgp
->l2vnis
= list_new();
5654 bgp
->l2vnis
->cmp
= (int (*)(void *, void *))vni_hash_cmp
;
5657 void bgp_evpn_vrf_delete(struct bgp
*bgp_vrf
)
5659 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);