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
35 #include "bgpd/bgp_attr_evpn.h"
36 #include "bgpd/bgpd.h"
37 #include "bgpd/bgp_table.h"
38 #include "bgpd/bgp_route.h"
39 #include "bgpd/bgp_attr.h"
40 #include "bgpd/bgp_mplsvpn.h"
41 #include "bgpd/bgp_label.h"
42 #include "bgpd/bgp_evpn.h"
43 #include "bgpd/bgp_evpn_private.h"
44 #include "bgpd/bgp_ecommunity.h"
45 #include "bgpd/bgp_encap_types.h"
46 #include "bgpd/bgp_debug.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
)
60 * Static function declarations
62 static void delete_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
63 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
64 struct bgp_info
**ri
);
65 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
);
74 static unsigned int vni_hash_key_make(void *p
)
76 struct bgpevpn
*vpn
= p
;
77 return (jhash_1word(vpn
->vni
, 0));
81 * Comparison function for vni hash
83 static int vni_hash_cmp(const void *p1
, const void *p2
)
85 const struct bgpevpn
*vpn1
= p1
;
86 const struct bgpevpn
*vpn2
= p2
;
92 return (vpn1
->vni
== vpn2
->vni
);
96 * Make vrf import route target hash key.
98 static unsigned int vrf_import_rt_hash_key_make(void *p
)
100 struct vrf_irt_node
*irt
= p
;
101 char *pnt
= irt
->rt
.val
;
102 unsigned int key
= 0;
118 * Comparison function for vrf import rt hash
120 static int vrf_import_rt_hash_cmp(const void *p1
, const void *p2
)
122 const struct vrf_irt_node
*irt1
= p1
;
123 const struct vrf_irt_node
*irt2
= p2
;
125 if (irt1
== NULL
&& irt2
== NULL
)
128 if (irt1
== NULL
|| irt2
== NULL
)
131 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
135 * Create a new vrf import_rt in default instance
137 static struct vrf_irt_node
*vrf_import_rt_new(struct ecommunity_val
*rt
)
139 struct bgp
*bgp_def
= NULL
;
140 struct vrf_irt_node
*irt
;
142 bgp_def
= bgp_get_default();
144 zlog_err("vrf import rt new - def instance not created yet");
148 irt
= XCALLOC(MTYPE_BGP_EVPN_VRF_IMPORT_RT
,
149 sizeof(struct vrf_irt_node
));
154 irt
->vrfs
= list_new();
157 if (!hash_get(bgp_def
->vrf_import_rt_hash
, irt
, hash_alloc_intern
)) {
158 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
166 * Free the vrf import rt node
168 static void vrf_import_rt_free(struct vrf_irt_node
*irt
)
170 struct bgp
*bgp_def
= NULL
;
172 bgp_def
= bgp_get_default();
174 zlog_err("vrf import rt free - def instance not created yet");
178 hash_release(bgp_def
->vrf_import_rt_hash
, irt
);
179 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
183 * Function to lookup Import RT node - used to map a RT to set of
184 * VNIs importing routes with that RT.
186 static struct vrf_irt_node
*lookup_vrf_import_rt(struct ecommunity_val
*rt
)
188 struct bgp
*bgp_def
= NULL
;
189 struct vrf_irt_node
*irt
;
190 struct vrf_irt_node tmp
;
192 bgp_def
= bgp_get_default();
194 zlog_err("vrf import rt lookup - def instance not created yet");
198 memset(&tmp
, 0, sizeof(struct vrf_irt_node
));
199 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
200 irt
= hash_lookup(bgp_def
->vrf_import_rt_hash
, &tmp
);
205 * Is specified VRF present on the RT's list of "importing" VRFs?
207 static int is_vrf_present_in_irt_vrfs(struct list
*vrfs
,
210 struct listnode
*node
= NULL
, *nnode
= NULL
;
211 struct bgp
*tmp_bgp_vrf
= NULL
;
213 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
214 if (tmp_bgp_vrf
== bgp_vrf
)
221 * Make import route target hash key.
223 static unsigned int import_rt_hash_key_make(void *p
)
225 struct irt_node
*irt
= p
;
226 char *pnt
= irt
->rt
.val
;
227 unsigned int key
= 0;
243 * Comparison function for import rt hash
245 static int import_rt_hash_cmp(const void *p1
, const void *p2
)
247 const struct irt_node
*irt1
= p1
;
248 const struct irt_node
*irt2
= p2
;
250 if (irt1
== NULL
&& irt2
== NULL
)
253 if (irt1
== NULL
|| irt2
== NULL
)
256 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
260 * Create a new import_rt
262 static struct irt_node
*import_rt_new(struct bgp
*bgp
,
263 struct ecommunity_val
*rt
)
265 struct irt_node
*irt
;
270 irt
= XCALLOC(MTYPE_BGP_EVPN_IMPORT_RT
, sizeof(struct irt_node
));
275 irt
->vnis
= list_new();
278 if (!hash_get(bgp
->import_rt_hash
, irt
, hash_alloc_intern
)) {
279 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
287 * Free the import rt node
289 static void import_rt_free(struct bgp
*bgp
, struct irt_node
*irt
)
291 hash_release(bgp
->import_rt_hash
, irt
);
292 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
296 * Function to lookup Import RT node - used to map a RT to set of
297 * VNIs importing routes with that RT.
299 static struct irt_node
*lookup_import_rt(struct bgp
*bgp
,
300 struct ecommunity_val
*rt
)
302 struct irt_node
*irt
;
305 memset(&tmp
, 0, sizeof(struct irt_node
));
306 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
307 irt
= hash_lookup(bgp
->import_rt_hash
, &tmp
);
312 * Is specified VNI present on the RT's list of "importing" VNIs?
314 static int is_vni_present_in_irt_vnis(struct list
*vnis
, struct bgpevpn
*vpn
)
316 struct listnode
*node
, *nnode
;
317 struct bgpevpn
*tmp_vpn
;
319 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, tmp_vpn
)) {
328 * Compare Route Targets.
330 static int evpn_route_target_cmp(struct ecommunity
*ecom1
,
331 struct ecommunity
*ecom2
)
339 if (!ecom1
&& !ecom2
)
342 if (ecom1
->str
&& !ecom2
->str
)
345 if (!ecom1
->str
&& ecom2
->str
)
348 if (!ecom1
->str
&& !ecom2
->str
)
351 return strcmp(ecom1
->str
, ecom2
->str
);
355 * Mask off global-admin field of specified extended community (RT),
356 * just retain the local-admin field.
358 static inline void mask_ecom_global_admin(struct ecommunity_val
*dst
,
359 struct ecommunity_val
*src
)
365 if (type
== ECOMMUNITY_ENCODE_AS
) {
366 dst
->val
[2] = dst
->val
[3] = 0;
367 } else if (type
== ECOMMUNITY_ENCODE_AS4
368 || type
== ECOMMUNITY_ENCODE_IP
) {
369 dst
->val
[2] = dst
->val
[3] = 0;
370 dst
->val
[4] = dst
->val
[5] = 0;
375 * Map one RT to specified VRF.
376 * bgp_vrf = BGP vrf instance
378 static void map_vrf_to_rt(struct bgp
*bgp_vrf
,
379 struct ecommunity_val
*eval
)
381 struct vrf_irt_node
*irt
= NULL
;
382 struct ecommunity_val eval_tmp
;
384 /* If using "automatic" RT,
385 * we only care about the local-admin sub-field.
386 * This is to facilitate using L3VNI(VRF-VNI)
387 * as the RT for EBGP peering too.
389 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
390 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
391 BGP_VRF_IMPORT_RT_CFGD
))
392 mask_ecom_global_admin(&eval_tmp
, eval
);
394 irt
= lookup_vrf_import_rt(&eval_tmp
);
395 if (irt
&& irt
->vrfs
)
396 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
397 /* Already mapped. */
401 irt
= vrf_import_rt_new(&eval_tmp
);
405 /* Add VRF to the list for this RT. */
406 listnode_add(irt
->vrfs
, bgp_vrf
);
410 * Unmap specified VRF from specified RT. If there are no other
411 * VRFs for this RT, then the RT hash is deleted.
412 * bgp_vrf: BGP VRF specific instance
414 static void unmap_vrf_from_rt(struct bgp
*bgp_vrf
,
415 struct vrf_irt_node
*irt
)
417 /* Delete VRF from list for this RT. */
418 listnode_delete(irt
->vrfs
, bgp_vrf
);
419 if (!listnode_head(irt
->vrfs
)) {
420 list_delete_and_null(&irt
->vrfs
);
421 vrf_import_rt_free(irt
);
426 * Map one RT to specified VNI.
428 static void map_vni_to_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
429 struct ecommunity_val
*eval
)
431 struct irt_node
*irt
;
432 struct ecommunity_val eval_tmp
;
434 /* If using "automatic" RT, we only care about the local-admin
436 * This is to facilitate using VNI as the RT for EBGP peering too.
438 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
439 if (!is_import_rt_configured(vpn
))
440 mask_ecom_global_admin(&eval_tmp
, eval
);
442 irt
= lookup_import_rt(bgp
, &eval_tmp
);
443 if (irt
&& irt
->vnis
)
444 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
445 /* Already mapped. */
449 irt
= import_rt_new(bgp
, &eval_tmp
);
453 /* Add VNI to the hash list for this RT. */
454 listnode_add(irt
->vnis
, vpn
);
458 * Unmap specified VNI from specified RT. If there are no other
459 * VNIs for this RT, then the RT hash is deleted.
461 static void unmap_vni_from_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
462 struct irt_node
*irt
)
464 /* Delete VNI from hash list for this RT. */
465 listnode_delete(irt
->vnis
, vpn
);
466 if (!listnode_head(irt
->vnis
)) {
467 list_delete_and_null(&irt
->vnis
);
468 import_rt_free(bgp
, irt
);
473 * Create RT extended community automatically from passed information:
474 * of the form AS:VNI.
475 * NOTE: We use only the lower 16 bits of the AS. This is sufficient as
476 * the need is to get a RT value that will be unique across different
477 * VNIs but the same across routers (in the same AS) for a particular
480 static void form_auto_rt(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
482 struct ecommunity_val eval
;
483 struct ecommunity
*ecomadd
;
485 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
487 ecomadd
= ecommunity_new();
488 ecommunity_add_val(ecomadd
, &eval
);
489 listnode_add_sort(rtl
, ecomadd
);
493 * Derive RD and RT for a VNI automatically. Invoked at the time of
496 static void derive_rd_rt_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
498 bgp_evpn_derive_auto_rd(bgp
, vpn
);
499 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
500 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
504 * Add (update) or delete MACIP from zebra.
506 static int bgp_zebra_send_remote_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
507 struct prefix_evpn
*p
,
508 struct in_addr remote_vtep_ip
, int add
,
513 char buf1
[ETHER_ADDR_STRLEN
];
514 char buf2
[INET6_ADDRSTRLEN
];
515 char buf3
[INET6_ADDRSTRLEN
];
518 if (!zclient
|| zclient
->sock
< 0)
521 /* Don't try to register if Zebra doesn't know of this instance. */
522 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
528 zclient_create_header(s
, add
? ZEBRA_REMOTE_MACIP_ADD
529 : ZEBRA_REMOTE_MACIP_DEL
,
531 stream_putl(s
, vpn
->vni
);
532 stream_put(s
, &p
->prefix
.mac
.octet
, ETH_ALEN
); /* Mac Addr */
533 /* IP address length and IP address, if any. */
534 if (IS_EVPN_PREFIX_IPADDR_NONE(p
))
537 ipa_len
= IS_EVPN_PREFIX_IPADDR_V4(p
) ? IPV4_MAX_BYTELEN
539 stream_putl(s
, ipa_len
);
540 stream_put(s
, &p
->prefix
.ip
.ip
.addr
, ipa_len
);
542 stream_put_in_addr(s
, &remote_vtep_ip
);
544 /* TX MAC sticky status */
546 stream_putc(s
, sticky
);
548 stream_putw_at(s
, 0, stream_get_endp(s
));
550 if (bgp_debug_zebra(NULL
))
551 zlog_debug("Tx %s MACIP, VNI %u %sMAC %s IP %s remote VTEP %s",
552 add
? "ADD" : "DEL", vpn
->vni
,
553 sticky
? "sticky " : "",
554 prefix_mac2str(&p
->prefix
.mac
, buf1
, sizeof(buf1
)),
555 ipaddr2str(&p
->prefix
.ip
, buf3
, sizeof(buf3
)),
556 inet_ntop(AF_INET
, &remote_vtep_ip
, buf2
,
559 return zclient_send_message(zclient
);
563 * Add (update) or delete remote VTEP from zebra.
565 static int bgp_zebra_send_remote_vtep(struct bgp
*bgp
, struct bgpevpn
*vpn
,
566 struct prefix_evpn
*p
, int add
)
571 if (!zclient
|| zclient
->sock
< 0)
574 /* Don't try to register if Zebra doesn't know of this instance. */
575 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
581 zclient_create_header(s
, add
? ZEBRA_REMOTE_VTEP_ADD
582 : ZEBRA_REMOTE_VTEP_DEL
,
584 stream_putl(s
, vpn
->vni
);
585 if (IS_EVPN_PREFIX_IPADDR_V4(p
))
586 stream_put_in_addr(s
, &p
->prefix
.ip
.ipaddr_v4
);
587 else if (IS_EVPN_PREFIX_IPADDR_V6(p
)) {
589 "Bad remote IP when trying to %s remote VTEP for VNI %u",
590 add
? "ADD" : "DEL", vpn
->vni
);
594 stream_putw_at(s
, 0, stream_get_endp(s
));
596 if (bgp_debug_zebra(NULL
))
597 zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s",
598 add
? "ADD" : "DEL", vpn
->vni
,
599 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
));
601 return zclient_send_message(zclient
);
605 * Build extended communities for EVPN prefix route.
607 static void build_evpn_type5_route_extcomm(struct bgp
*bgp_vrf
,
610 struct ecommunity ecom_encap
;
611 struct ecommunity ecom_rmac
;
612 struct ecommunity_val eval
;
613 struct ecommunity_val eval_rmac
;
614 bgp_encap_types tnl_type
;
615 struct listnode
*node
, *nnode
;
616 struct ecommunity
*ecom
;
617 struct list
*vrf_export_rtl
= NULL
;
620 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
621 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
622 encode_encap_extcomm(tnl_type
, &eval
);
624 ecom_encap
.val
= (u_int8_t
*)eval
.val
;
627 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
629 /* Add the export RTs for L3VNI/VRF */
630 vrf_export_rtl
= bgp_vrf
->vrf_export_rtl
;
631 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
632 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
, ecom
))
633 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
637 /* add the router mac extended community */
638 if (!is_zero_mac(&attr
->rmac
)) {
639 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
640 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
642 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
643 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
647 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
651 * Build extended communities for EVPN route. RT and ENCAP are
652 * applicable to all routes.
653 * TODO: currently kernel doesnt support ipv6 routes with ipv4 nexthops.
654 * This means that we can't do symmetric routing for ipv6 hosts routes
655 * in the same way as ipv4 host routes.
656 * We wont attach l3-vni related RTs for ipv6 routes.
657 * For now, We will only adevrtise ipv4 host routes
658 * with L3-VNI related ext-comm.
660 static void build_evpn_route_extcomm(struct bgpevpn
*vpn
, struct attr
*attr
,
663 struct ecommunity ecom_encap
;
664 struct ecommunity ecom_sticky
;
665 struct ecommunity ecom_rmac
;
666 struct ecommunity_val eval
;
667 struct ecommunity_val eval_sticky
;
668 struct ecommunity_val eval_rmac
;
669 bgp_encap_types tnl_type
;
670 struct listnode
*node
, *nnode
;
671 struct ecommunity
*ecom
;
673 struct list
*vrf_export_rtl
= NULL
;
676 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
677 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
678 encode_encap_extcomm(tnl_type
, &eval
);
680 ecom_encap
.val
= (u_int8_t
*)eval
.val
;
683 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
685 /* Add the export RTs for L2VNI */
686 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
))
687 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
, ecom
);
689 /* Add the export RTs for L3VNI - currently only supported for IPV4 host
692 vrf_export_rtl
= bgpevpn_get_vrf_export_rtl(vpn
);
693 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
694 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
,
697 ecommunity_merge(attr
->ecommunity
,
704 memset(&ecom_sticky
, 0, sizeof(ecom_sticky
));
705 encode_mac_mobility_extcomm(1, seqnum
, &eval_sticky
);
706 ecom_sticky
.size
= 1;
707 ecom_sticky
.val
= (u_int8_t
*)eval_sticky
.val
;
709 ecommunity_merge(attr
->ecommunity
, &ecom_sticky
);
712 if (afi
== AFI_IP
&& !is_zero_mac(&attr
->rmac
)) {
713 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
714 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
716 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
717 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
721 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
725 * Add MAC mobility extended community to attribute.
727 static void add_mac_mobility_to_attr(u_int32_t seq_num
, struct attr
*attr
)
729 struct ecommunity ecom_tmp
;
730 struct ecommunity_val eval
;
731 u_int8_t
*ecom_val_ptr
;
738 encode_mac_mobility_extcomm(0, seq_num
, &eval
);
740 /* Find current MM ecommunity */
743 if (attr
->ecommunity
) {
744 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
745 pnt
= attr
->ecommunity
->val
+ (i
* 8);
749 if (type
== ECOMMUNITY_ENCODE_EVPN
751 == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY
) {
753 (u_int8_t
*)(attr
->ecommunity
->val
760 /* Update the existing MM ecommunity */
762 memcpy(ecom_val_ptr
, eval
.val
, sizeof(char) * ECOMMUNITY_SIZE
);
764 /* Add MM to existing */
766 memset(&ecom_tmp
, 0, sizeof(ecom_tmp
));
768 ecom_tmp
.val
= (u_int8_t
*)eval
.val
;
771 ecommunity_merge(attr
->ecommunity
, &ecom_tmp
);
775 /* Install EVPN route into zebra. */
776 static int evpn_zebra_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
777 struct prefix_evpn
*p
,
778 struct in_addr remote_vtep_ip
, u_char sticky
)
782 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
783 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
786 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 1);
791 /* Uninstall EVPN route from zebra. */
792 static int evpn_zebra_uninstall(struct bgp
*bgp
, struct bgpevpn
*vpn
,
793 struct prefix_evpn
*p
,
794 struct in_addr remote_vtep_ip
)
798 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
799 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
802 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 0);
808 * Due to MAC mobility, the prior "local" best route has been supplanted
809 * by a "remote" best route. The prior route has to be deleted and withdrawn
812 static void evpn_delete_old_local_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
814 struct bgp_info
*old_local
)
816 struct bgp_node
*global_rn
;
818 afi_t afi
= AFI_L2VPN
;
819 safi_t safi
= SAFI_EVPN
;
821 /* Locate route node in the global EVPN routing table. Note that
822 * this table is a 2-level tree (RD-level + Prefix-level) similar to
825 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
826 (struct prefix
*)&rn
->p
, &vpn
->prd
);
828 /* Delete route entry in the global EVPN table. */
829 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, &ri
);
831 /* Schedule for processing - withdraws to peers happen from
835 bgp_process(bgp
, global_rn
, afi
, safi
);
836 bgp_unlock_node(global_rn
);
839 /* Delete route entry in the VNI route table, caller to remove. */
840 bgp_info_delete(rn
, old_local
);
844 * Calculate the best path for an EVPN route. Install/update best path in zebra,
847 static int evpn_route_select_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
850 struct bgp_info
*old_select
, *new_select
;
851 struct bgp_info_pair old_and_new
;
852 afi_t afi
= AFI_L2VPN
;
853 safi_t safi
= SAFI_EVPN
;
856 /* Compute the best path. */
857 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
], &old_and_new
,
859 old_select
= old_and_new
.old
;
860 new_select
= old_and_new
.new;
862 /* If the best path hasn't changed - see if there is still something to
866 if (old_select
&& old_select
== new_select
867 && old_select
->type
== ZEBRA_ROUTE_BGP
868 && old_select
->sub_type
== BGP_ROUTE_NORMAL
869 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
870 && !CHECK_FLAG(old_select
->flags
, BGP_INFO_ATTR_CHANGED
)
871 && !bgp
->addpath_tx_used
[afi
][safi
]) {
872 if (bgp_zebra_has_route_changed(rn
, old_select
))
873 ret
= evpn_zebra_install(bgp
, vpn
,
874 (struct prefix_evpn
*)&rn
->p
,
875 old_select
->attr
->nexthop
,
876 old_select
->attr
->sticky
);
877 UNSET_FLAG(old_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
878 bgp_zebra_clear_route_change_flags(rn
);
882 /* If the user did a "clear" this flag will be set */
883 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
885 /* bestpath has changed; update relevant fields and install or uninstall
886 * into the zebra RIB.
888 if (old_select
|| new_select
)
889 bgp_bump_version(rn
);
892 bgp_info_unset_flag(rn
, old_select
, BGP_INFO_SELECTED
);
894 bgp_info_set_flag(rn
, new_select
, BGP_INFO_SELECTED
);
895 bgp_info_unset_flag(rn
, new_select
, BGP_INFO_ATTR_CHANGED
);
896 UNSET_FLAG(new_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
899 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
900 && new_select
->sub_type
== BGP_ROUTE_NORMAL
) {
901 ret
= evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
902 new_select
->attr
->nexthop
,
903 new_select
->attr
->sticky
);
904 /* If an old best existed and it was a "local" route, the only
906 * it would be supplanted is due to MAC mobility procedures. So,
908 * need to do an implicit delete and withdraw that route from
911 if (old_select
&& old_select
->peer
== bgp
->peer_self
912 && old_select
->type
== ZEBRA_ROUTE_BGP
913 && old_select
->sub_type
== BGP_ROUTE_STATIC
)
914 evpn_delete_old_local_route(bgp
, vpn
, rn
, old_select
);
916 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
917 && old_select
->sub_type
== BGP_ROUTE_NORMAL
)
918 ret
= evpn_zebra_uninstall(bgp
, vpn
,
919 (struct prefix_evpn
*)&rn
->p
,
920 old_select
->attr
->nexthop
);
923 /* Clear any route change flags. */
924 bgp_zebra_clear_route_change_flags(rn
);
926 /* Reap old select bgp_info, if it has been removed */
927 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_INFO_REMOVED
))
928 bgp_info_reap(rn
, old_select
);
935 * Return true if the local ri for this rn has sticky set
937 static int evpn_route_is_sticky(struct bgp
*bgp
, struct bgp_node
*rn
)
939 struct bgp_info
*tmp_ri
;
940 struct bgp_info
*local_ri
;
943 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
944 if (tmp_ri
->peer
== bgp
->peer_self
945 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
946 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
953 return local_ri
->attr
->sticky
;
956 static int update_evpn_type5_route_entry(struct bgp
*bgp_def
,
957 struct bgp
*bgp_vrf
, afi_t afi
,
958 safi_t safi
, struct bgp_node
*rn
,
959 struct attr
*attr
, int *route_changed
)
961 struct attr
*attr_new
= NULL
;
962 struct bgp_info
*ri
= NULL
;
963 mpls_label_t label
= MPLS_INVALID_LABEL
;
964 struct bgp_info
*local_ri
= NULL
;
965 struct bgp_info
*tmp_ri
= NULL
;
968 /* locate the local route entry if any */
969 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
970 if (tmp_ri
->peer
== bgp_def
->peer_self
971 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
972 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
976 /* create a new route entry if one doesnt exist.
977 Otherwise see if route attr has changed */
980 /* route has changed as this is the first entry */
983 /* Add (or update) attribute to hash. */
984 attr_new
= bgp_attr_intern(attr
);
986 /* create the route info from attribute */
987 ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
988 bgp_def
->peer_self
, attr_new
, rn
);
989 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
991 /* L3-VNI goes in the label2 field */
992 bgp_info_extra_get(ri
);
993 vni2label(bgp_vrf
->l3vni
, &label
);
994 memcpy(&ri
->extra
->label2
, &label
, BGP_LABEL_BYTES
);
996 /* add the route entry to route node*/
997 bgp_info_add(rn
, ri
);
1001 if (!attrhash_cmp(tmp_ri
->attr
, attr
)) {
1003 /* attribute changed */
1006 /* The attribute has changed. */
1007 /* Add (or update) attribute to hash. */
1008 attr_new
= bgp_attr_intern(attr
);
1009 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1011 /* Restore route, if needed. */
1012 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1013 bgp_info_restore(rn
, tmp_ri
);
1015 /* Unintern existing, set to new. */
1016 bgp_attr_unintern(&tmp_ri
->attr
);
1017 tmp_ri
->attr
= attr_new
;
1018 tmp_ri
->uptime
= bgp_clock();
1024 /* update evpn type-5 route entry */
1025 static int update_evpn_type5_route(struct bgp
*bgp_vrf
,
1026 struct prefix_evpn
*evp
)
1028 afi_t afi
= AFI_L2VPN
;
1029 safi_t safi
= SAFI_EVPN
;
1031 struct bgp_node
*rn
= NULL
;
1032 struct bgp
*bgp_def
= NULL
;
1033 int route_changed
= 0;
1035 bgp_def
= bgp_get_default();
1039 /* build path attribute for this route */
1040 memset(&attr
, 0, sizeof(struct attr
));
1041 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1042 attr
.nexthop
= bgp_vrf
->originator_ip
;
1043 attr
.mp_nexthop_global_in
= bgp_vrf
->originator_ip
;
1044 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1045 memcpy(&attr
.rmac
, &bgp_vrf
->rmac
, sizeof(struct ethaddr
));
1047 /* Setup RT and encap extended community */
1048 build_evpn_type5_route_extcomm(bgp_vrf
, &attr
);
1050 /* get the route node in global table */
1051 rn
= bgp_afi_node_get(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1052 (struct prefix
*)evp
,
1056 /* create or update the route entry within the route node */
1057 update_evpn_type5_route_entry(bgp_def
, bgp_vrf
,
1059 rn
, &attr
, &route_changed
);
1061 /* schedule for processing and unlock node */
1062 if (route_changed
) {
1063 bgp_process(bgp_def
, rn
, afi
, safi
);
1064 bgp_unlock_node(rn
);
1067 /* uninten temporary */
1068 aspath_unintern(&attr
.aspath
);
1073 * Create or update EVPN route entry. This could be in the VNI route table
1074 * or the global route table.
1076 static int update_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1077 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1078 struct attr
*attr
, int add
, int vni_table
,
1079 struct bgp_info
**ri
, u_char flags
)
1081 struct bgp_info
*tmp_ri
;
1082 struct bgp_info
*local_ri
, *remote_ri
;
1083 struct attr
*attr_new
;
1084 mpls_label_t label
= MPLS_INVALID_LABEL
;
1085 int route_change
= 1;
1090 /* See if this is an update of an existing route, or a new add. Also,
1091 * identify if already known from remote, and if so, the one with the
1092 * highest sequence number; this is only when adding to the VNI routing
1095 local_ri
= remote_ri
= NULL
;
1096 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1097 if (tmp_ri
->peer
== bgp
->peer_self
1098 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1099 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1102 if (tmp_ri
->type
== ZEBRA_ROUTE_BGP
1103 && tmp_ri
->sub_type
== BGP_ROUTE_NORMAL
1104 && CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
)) {
1107 else if (mac_mobility_seqnum(tmp_ri
->attr
)
1108 > mac_mobility_seqnum(remote_ri
->attr
))
1114 /* If route doesn't exist already, create a new one, if told to.
1115 * Otherwise act based on whether the attributes of the route have
1118 if (!local_ri
&& !add
)
1122 /* When learnt locally for the first time but already known from
1123 * remote, we have to initiate appropriate MAC mobility steps.
1125 * is applicable when updating the VNI routing table.
1126 * We need to skip mobility steps for g/w macs (local mac on g/w
1127 * SVI) advertised in EVPN.
1128 * This will ensure that local routes are preferred for g/w macs
1130 if (remote_ri
&& !CHECK_FLAG(flags
, ZEBRA_MAC_TYPE_GW
)) {
1131 u_int32_t cur_seqnum
;
1133 /* Add MM extended community to route. */
1134 cur_seqnum
= mac_mobility_seqnum(remote_ri
->attr
);
1135 add_mac_mobility_to_attr(cur_seqnum
+ 1, attr
);
1138 /* Add (or update) attribute to hash. */
1139 attr_new
= bgp_attr_intern(attr
);
1141 /* Extract MAC mobility sequence number, if any. */
1142 attr_new
->mm_seqnum
=
1143 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1144 attr_new
->sticky
= sticky
;
1146 /* Create new route with its attribute. */
1147 tmp_ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1148 bgp
->peer_self
, attr_new
, rn
);
1149 SET_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
);
1150 bgp_info_extra_get(tmp_ri
);
1152 /* The VNI goes into the 'label' field of the route */
1153 vni2label(vpn
->vni
, &label
);
1155 memcpy(&tmp_ri
->extra
->label
, &label
, BGP_LABEL_BYTES
);
1156 bgp_info_add(rn
, tmp_ri
);
1159 if (attrhash_cmp(tmp_ri
->attr
, attr
)
1160 && !CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1163 /* The attribute has changed. */
1164 /* Add (or update) attribute to hash. */
1165 attr_new
= bgp_attr_intern(attr
);
1166 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1168 /* Restore route, if needed. */
1169 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1170 bgp_info_restore(rn
, tmp_ri
);
1172 /* Unintern existing, set to new. */
1173 bgp_attr_unintern(&tmp_ri
->attr
);
1174 tmp_ri
->attr
= attr_new
;
1175 tmp_ri
->uptime
= bgp_clock();
1179 /* Return back the route entry. */
1181 return route_change
;
1185 * Create or update EVPN route (of type based on prefix) for specified VNI
1186 * and schedule for processing.
1188 static int update_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1189 struct prefix_evpn
*p
, u_char flags
)
1191 struct bgp_node
*rn
;
1193 struct attr
*attr_new
;
1194 struct bgp_info
*ri
;
1195 afi_t afi
= AFI_L2VPN
;
1196 safi_t safi
= SAFI_EVPN
;
1199 memset(&attr
, 0, sizeof(struct attr
));
1201 /* Build path-attribute for this route. */
1202 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1203 attr
.nexthop
= vpn
->originator_ip
;
1204 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1205 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1206 attr
.sticky
= CHECK_FLAG(flags
, ZEBRA_MAC_TYPE_STICKY
) ? 1 : 0;
1207 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1209 /* Set up RT and ENCAP extended community. */
1210 build_evpn_route_extcomm(vpn
, &attr
,
1211 IS_EVPN_PREFIX_IPADDR_V4(p
) ?
1214 /* First, create (or fetch) route node within the VNI. */
1215 /* NOTE: There is no RD here. */
1216 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1218 /* Create or update route entry. */
1219 route_change
= update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
,
1222 attr_new
= ri
->attr
;
1224 /* Perform route selection; this is just to set the flags correctly
1225 * as local route in the VNI always wins.
1227 evpn_route_select_install(bgp
, vpn
, rn
);
1228 bgp_unlock_node(rn
);
1230 /* If this is a new route or some attribute has changed, export the
1231 * route to the global table. The route will be advertised to peers
1232 * from there. Note that this table is a 2-level tree (RD-level +
1233 * Prefix-level) similar to L3VPN routes.
1236 struct bgp_info
*global_ri
;
1238 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1239 (struct prefix
*)p
, &vpn
->prd
);
1240 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, attr_new
, 1, 0,
1243 /* Schedule for processing and unlock node. */
1244 bgp_process(bgp
, rn
, afi
, safi
);
1245 bgp_unlock_node(rn
);
1248 /* Unintern temporary. */
1249 aspath_unintern(&attr
.aspath
);
1254 /* Delete EVPN type5 route entry from global table */
1255 static void delete_evpn_type5_route_entry(struct bgp
*bgp_def
,
1256 struct bgp
*bgp_vrf
,
1257 afi_t afi
, safi_t safi
,
1258 struct bgp_node
*rn
,
1259 struct bgp_info
**ri
)
1261 struct bgp_info
*tmp_ri
= NULL
;
1265 /* find the matching route entry */
1266 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
)
1267 if (tmp_ri
->peer
== bgp_def
->peer_self
1268 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1269 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1274 /* Mark route for delete. */
1276 bgp_info_delete(rn
, tmp_ri
);
1279 /* Delete EVPN type5 route */
1280 static int delete_evpn_type5_route(struct bgp
*bgp_vrf
,
1281 struct prefix_evpn
*evp
)
1283 afi_t afi
= AFI_L2VPN
;
1284 safi_t safi
= SAFI_EVPN
;
1285 struct bgp_node
*rn
= NULL
;
1286 struct bgp_info
*ri
= NULL
;
1287 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
1289 bgp_def
= bgp_get_default();
1293 /* locate the global route entry for this type-5 prefix */
1294 rn
= bgp_afi_node_lookup(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1295 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1299 delete_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &ri
);
1301 bgp_process(bgp_def
, rn
, afi
, safi
);
1302 bgp_unlock_node(rn
);
1307 * Delete EVPN route entry. This could be in the VNI route table
1308 * or the global route table.
1310 static void delete_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1311 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1312 struct bgp_info
**ri
)
1314 struct bgp_info
*tmp_ri
;
1318 /* Now, find matching route. */
1319 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
)
1320 if (tmp_ri
->peer
== bgp
->peer_self
1321 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1322 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1327 /* Mark route for delete. */
1329 bgp_info_delete(rn
, tmp_ri
);
1333 * Delete EVPN route (of type based on prefix) for specified VNI and
1334 * schedule for processing.
1336 static int delete_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1337 struct prefix_evpn
*p
)
1339 struct bgp_node
*rn
, *global_rn
;
1340 struct bgp_info
*ri
;
1341 afi_t afi
= AFI_L2VPN
;
1342 safi_t safi
= SAFI_EVPN
;
1344 /* First, locate the route node within the VNI. If it doesn't exist,
1346 * is nothing further to do.
1348 /* NOTE: There is no RD here. */
1349 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1353 /* Next, locate route node in the global EVPN routing table. Note that
1354 * this table is a 2-level tree (RD-level + Prefix-level) similar to
1357 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1358 (struct prefix
*)p
, &vpn
->prd
);
1360 /* Delete route entry in the global EVPN table. */
1361 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, &ri
);
1363 /* Schedule for processing - withdraws to peers happen from
1367 bgp_process(bgp
, global_rn
, afi
, safi
);
1368 bgp_unlock_node(global_rn
);
1371 /* Delete route entry in the VNI route table. This can just be removed.
1373 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &ri
);
1375 bgp_info_reap(rn
, ri
);
1376 bgp_unlock_node(rn
);
1382 * Update all type-2 (MACIP) local routes for this VNI - these should also
1383 * be scheduled for advertise to peers.
1385 static int update_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1389 struct bgp_node
*rn
;
1390 struct bgp_info
*ri
;
1392 struct attr attr_sticky
;
1393 struct attr attr_ip6
;
1394 struct attr attr_sticky_ip6
;
1395 struct attr
*attr_new
;
1399 memset(&attr
, 0, sizeof(struct attr
));
1400 memset(&attr_sticky
, 0, sizeof(struct attr
));
1401 memset(&attr_ip6
, 0, sizeof(struct attr
));
1402 memset(&attr_sticky_ip6
, 0, sizeof(struct attr
));
1404 /* Build path-attribute - all type-2 routes for this VNI will share the
1405 * same path attribute.
1407 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1408 bgp_attr_default_set(&attr_sticky
, BGP_ORIGIN_IGP
);
1409 attr
.nexthop
= vpn
->originator_ip
;
1410 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1411 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1412 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1413 attr_sticky
.nexthop
= vpn
->originator_ip
;
1414 attr_sticky
.mp_nexthop_global_in
= vpn
->originator_ip
;
1415 attr_sticky
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1416 attr_sticky
.sticky
= 1;
1417 bgpevpn_get_rmac(vpn
, &attr_sticky
.rmac
);
1418 bgp_attr_default_set(&attr_ip6
, BGP_ORIGIN_IGP
);
1419 bgp_attr_default_set(&attr_sticky_ip6
, BGP_ORIGIN_IGP
);
1420 attr_ip6
.nexthop
= vpn
->originator_ip
;
1421 attr_ip6
.mp_nexthop_global_in
= vpn
->originator_ip
;
1422 attr_ip6
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1423 bgpevpn_get_rmac(vpn
, &attr_ip6
.rmac
);
1424 attr_sticky_ip6
.nexthop
= vpn
->originator_ip
;
1425 attr_sticky_ip6
.mp_nexthop_global_in
= vpn
->originator_ip
;
1426 attr_sticky_ip6
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1427 attr_sticky_ip6
.sticky
= 1;
1428 bgpevpn_get_rmac(vpn
, &attr_sticky_ip6
.rmac
);
1430 /* Set up RT, ENCAP and sticky MAC extended community. */
1431 build_evpn_route_extcomm(vpn
, &attr
, AFI_IP
);
1432 build_evpn_route_extcomm(vpn
, &attr_sticky
, AFI_IP
);
1433 build_evpn_route_extcomm(vpn
, &attr_ip6
, AFI_IP6
);
1434 build_evpn_route_extcomm(vpn
, &attr_sticky_ip6
, AFI_IP6
);
1436 /* Walk this VNI's route table and update local type-2 routes. For any
1437 * routes updated, update corresponding entry in the global table too.
1439 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1440 rn
= bgp_route_next(rn
)) {
1441 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1442 struct bgp_node
*rd_rn
;
1443 struct bgp_info
*global_ri
;
1445 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1448 if (IS_EVPN_PREFIX_IPADDR_V4(evp
)) {
1449 if (evpn_route_is_sticky(bgp
, rn
))
1450 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1454 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1455 &attr
, 0, 1, &ri
, 0);
1457 if (evpn_route_is_sticky(bgp
, rn
))
1458 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1459 &attr_sticky_ip6
, 0, 1,
1462 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1467 /* If a local route exists for this prefix, we need to update
1468 * the global routing table too.
1473 /* Perform route selection; this is just to set the flags
1475 * as local route in the VNI always wins.
1477 evpn_route_select_install(bgp
, vpn
, rn
);
1479 attr_new
= ri
->attr
;
1481 /* Update route in global routing table. */
1482 rd_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1483 (struct prefix
*)evp
, &vpn
->prd
);
1485 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rd_rn
, attr_new
, 0,
1488 /* Schedule for processing and unlock node. */
1489 bgp_process(bgp
, rd_rn
, afi
, safi
);
1490 bgp_unlock_node(rd_rn
);
1493 /* Unintern temporary. */
1494 aspath_unintern(&attr
.aspath
);
1495 aspath_unintern(&attr_sticky
.aspath
);
1501 * Delete all type-2 (MACIP) local routes for this VNI - only from the
1502 * global routing table. These are also scheduled for withdraw from peers.
1504 static int delete_global_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1508 struct bgp_node
*rdrn
, *rn
;
1509 struct bgp_table
*table
;
1510 struct bgp_info
*ri
;
1515 rdrn
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)&vpn
->prd
);
1516 if (rdrn
&& rdrn
->info
) {
1517 table
= (struct bgp_table
*)rdrn
->info
;
1518 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
1519 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1521 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1524 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &ri
);
1526 bgp_process(bgp
, rn
, afi
, safi
);
1530 /* Unlock RD node. */
1532 bgp_unlock_node(rdrn
);
1538 * Delete all type-2 (MACIP) local routes for this VNI - from the global
1539 * table as well as the per-VNI route table.
1541 static int delete_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1545 struct bgp_node
*rn
;
1546 struct bgp_info
*ri
;
1551 /* First, walk the global route table for this VNI's type-2 local
1553 * EVPN routes are a 2-level table, first get the RD table.
1555 delete_global_type2_routes(bgp
, vpn
);
1557 /* Next, walk this VNI's route table and delete local type-2 routes. */
1558 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1559 rn
= bgp_route_next(rn
)) {
1560 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1562 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1565 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &ri
);
1567 /* Route entry in local table gets deleted immediately. */
1569 bgp_info_reap(rn
, ri
);
1576 * Delete all routes in the per-VNI route table.
1578 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1580 struct bgp_node
*rn
;
1581 struct bgp_info
*ri
, *nextri
;
1583 /* Walk this VNI's route table and delete all routes. */
1584 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1585 rn
= bgp_route_next(rn
)) {
1586 for (ri
= rn
->info
; (ri
!= NULL
) && (nextri
= ri
->next
, 1);
1588 bgp_info_delete(rn
, ri
);
1589 bgp_info_reap(rn
, ri
);
1597 * Update (and advertise) local routes for a VNI. Invoked upon the VNI
1598 * export RT getting modified or change to tunnel IP. Note that these
1599 * situations need the route in the per-VNI table as well as the global
1600 * table to be updated (as attributes change).
1602 static int update_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1605 struct prefix_evpn p
;
1607 /* Update and advertise the type-3 route (only one) followed by the
1608 * locally learnt type-2 routes (MACIP) - for this VNI.
1610 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
1611 ret
= update_evpn_route(bgp
, vpn
, &p
, 0);
1615 return update_all_type2_routes(bgp
, vpn
);
1619 * Delete (and withdraw) local routes for specified VNI from the global
1620 * table and per-VNI table. After this, remove all other routes from
1621 * the per-VNI table. Invoked upon the VNI being deleted or EVPN
1622 * (advertise-all-vni) being disabled.
1624 static int delete_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1627 struct prefix_evpn p
;
1629 /* Delete and withdraw locally learnt type-2 routes (MACIP)
1630 * followed by type-3 routes (only one) - for this VNI.
1632 ret
= delete_all_type2_routes(bgp
, vpn
);
1636 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
1637 ret
= delete_evpn_route(bgp
, vpn
, &p
);
1641 /* Delete all routes from the per-VNI table. */
1642 return delete_all_vni_routes(bgp
, vpn
);
1646 * There is a tunnel endpoint IP address change for this VNI,
1647 * need to re-advertise routes with the new nexthop.
1649 static int handle_tunnel_ip_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1650 struct in_addr originator_ip
)
1652 struct prefix_evpn p
;
1654 /* If VNI is not live, we only need to update the originator ip */
1655 if (!is_vni_live(vpn
)) {
1656 vpn
->originator_ip
= originator_ip
;
1660 /* Update the tunnel-ip hash */
1661 bgp_tip_del(bgp
, &vpn
->originator_ip
);
1662 bgp_tip_add(bgp
, &originator_ip
);
1664 /* filter routes as martian nexthop db has changed */
1665 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
1667 /* Need to withdraw type-3 route as the originator IP is part
1670 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
1671 delete_evpn_route(bgp
, vpn
, &p
);
1673 /* Update the tunnel IP and re-advertise all routes for this VNI. */
1674 vpn
->originator_ip
= originator_ip
;
1675 return update_routes_for_vni(bgp
, vpn
);
1679 * Install route entry into the VRF routing table and invoke route selection.
1681 static int install_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
1682 struct prefix_evpn
*evp
,
1683 struct bgp_info
*parent_ri
)
1685 struct bgp_node
*rn
;
1686 struct bgp_info
*ri
;
1687 struct attr
*attr_new
;
1690 struct prefix
*pp
= &p
;
1693 char buf
[PREFIX_STRLEN
];
1694 char buf1
[PREFIX_STRLEN
];
1696 memset(pp
, 0, sizeof(struct prefix
));
1697 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1698 ip_prefix_from_type2_prefix(evp
, pp
);
1699 else if(evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
)
1700 ip_prefix_from_type5_prefix(evp
, pp
);
1702 if (bgp_debug_zebra(NULL
)) {
1703 zlog_debug("installing evpn prefix %s as ip prefix %s in vrf %s",
1704 prefix2str(evp
, buf
, sizeof(buf
)),
1705 prefix2str(pp
, buf1
, sizeof(buf
)),
1706 vrf_id_to_name(bgp_vrf
->vrf_id
));
1709 /* Create (or fetch) route within the VRF. */
1710 /* NOTE: There is no RD here. */
1711 if (IS_EVPN_PREFIX_IPADDR_V4(evp
)) {
1713 safi
= SAFI_UNICAST
;
1714 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
1715 } else if (IS_EVPN_PREFIX_IPADDR_V6(evp
)) {
1717 safi
= SAFI_UNICAST
;
1718 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
1722 /* Check if route entry is already present. */
1723 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1725 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
1729 /* Add (or update) attribute to hash. */
1730 attr_new
= bgp_attr_intern(parent_ri
->attr
);
1732 /* Create new route with its attribute. */
1733 ri
= info_make(parent_ri
->type
, parent_ri
->sub_type
, 0,
1734 parent_ri
->peer
, attr_new
, rn
);
1735 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1736 bgp_info_extra_get(ri
);
1737 ri
->extra
->parent
= parent_ri
;
1738 if (parent_ri
->extra
)
1739 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
1741 bgp_info_add(rn
, ri
);
1743 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
1744 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
1745 bgp_unlock_node(rn
);
1748 /* The attribute has changed. */
1749 /* Add (or update) attribute to hash. */
1750 attr_new
= bgp_attr_intern(parent_ri
->attr
);
1752 /* Restore route, if needed. */
1753 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
1754 bgp_info_restore(rn
, ri
);
1756 /* Mark if nexthop has changed. */
1757 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
1758 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
1760 /* Unintern existing, set to new. */
1761 bgp_attr_unintern(&ri
->attr
);
1762 ri
->attr
= attr_new
;
1763 ri
->uptime
= bgp_clock();
1766 /* Perform route selection and update zebra, if required. */
1767 bgp_process(bgp_vrf
, rn
, afi
, safi
);
1773 * Install route entry into the VNI routing table and invoke route selection.
1775 static int install_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1776 struct prefix_evpn
*p
,
1777 struct bgp_info
*parent_ri
)
1779 struct bgp_node
*rn
;
1780 struct bgp_info
*ri
;
1781 struct attr
*attr_new
;
1784 /* Create (or fetch) route within the VNI. */
1785 /* NOTE: There is no RD here. */
1786 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1788 /* Check if route entry is already present. */
1789 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1791 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
1795 /* Add (or update) attribute to hash. */
1796 attr_new
= bgp_attr_intern(parent_ri
->attr
);
1798 /* Create new route with its attribute. */
1799 ri
= info_make(parent_ri
->type
, parent_ri
->sub_type
, 0,
1800 parent_ri
->peer
, attr_new
, rn
);
1801 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1802 bgp_info_extra_get(ri
);
1803 ri
->extra
->parent
= parent_ri
;
1804 if (parent_ri
->extra
)
1805 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
1807 bgp_info_add(rn
, ri
);
1809 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
1810 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
1811 bgp_unlock_node(rn
);
1814 /* The attribute has changed. */
1815 /* Add (or update) attribute to hash. */
1816 attr_new
= bgp_attr_intern(parent_ri
->attr
);
1818 /* Restore route, if needed. */
1819 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
1820 bgp_info_restore(rn
, ri
);
1822 /* Mark if nexthop has changed. */
1823 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
1824 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
1826 /* Unintern existing, set to new. */
1827 bgp_attr_unintern(&ri
->attr
);
1828 ri
->attr
= attr_new
;
1829 ri
->uptime
= bgp_clock();
1832 /* Perform route selection and update zebra, if required. */
1833 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
1839 * Uninstall route entry from the VRF routing table and send message
1840 * to zebra, if appropriate.
1842 static int uninstall_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
1843 struct prefix_evpn
*evp
,
1844 struct bgp_info
*parent_ri
)
1846 struct bgp_node
*rn
;
1847 struct bgp_info
*ri
;
1850 struct prefix
*pp
= &p
;
1853 char buf
[PREFIX_STRLEN
];
1854 char buf1
[PREFIX_STRLEN
];
1856 memset(pp
, 0, sizeof(struct prefix
));
1857 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1858 ip_prefix_from_type2_prefix(evp
, pp
);
1859 else if (evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
)
1860 ip_prefix_from_type5_prefix(evp
, pp
);
1862 if (bgp_debug_zebra(NULL
)) {
1863 zlog_debug("uninstalling evpn prefix %s as ip prefix %s in vrf %s",
1864 prefix2str(evp
, buf
, sizeof(buf
)),
1865 prefix2str(pp
, buf1
, sizeof(buf
)),
1866 vrf_id_to_name(bgp_vrf
->vrf_id
));
1869 /* Locate route within the VRF. */
1870 /* NOTE: There is no RD here. */
1871 if (IS_EVPN_PREFIX_IPADDR_V4(evp
)) {
1873 safi
= SAFI_UNICAST
;
1874 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
1877 safi
= SAFI_UNICAST
;
1878 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
1884 /* Find matching route entry. */
1885 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1887 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
1893 /* Mark entry for deletion */
1894 bgp_info_delete(rn
, ri
);
1896 /* Perform route selection and update zebra, if required. */
1897 bgp_process(bgp_vrf
, rn
, afi
, safi
);
1899 /* Unlock route node. */
1900 bgp_unlock_node(rn
);
1906 * Uninstall route entry from the VNI routing table and send message
1907 * to zebra, if appropriate.
1909 static int uninstall_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1910 struct prefix_evpn
*p
,
1911 struct bgp_info
*parent_ri
)
1913 struct bgp_node
*rn
;
1914 struct bgp_info
*ri
;
1917 /* Locate route within the VNI. */
1918 /* NOTE: There is no RD here. */
1919 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1923 /* Find matching route entry. */
1924 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1926 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
1932 /* Mark entry for deletion */
1933 bgp_info_delete(rn
, ri
);
1935 /* Perform route selection and update zebra, if required. */
1936 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
1938 /* Unlock route node. */
1939 bgp_unlock_node(rn
);
1945 * Given a route entry and a VRF, see if this route entry should be
1946 * imported into the VRF i.e., RTs match.
1948 static int is_route_matching_for_vrf(struct bgp
*bgp_vrf
,
1949 struct bgp_info
*ri
)
1951 struct attr
*attr
= ri
->attr
;
1952 struct ecommunity
*ecom
;
1956 /* Route should have valid RT to be even considered. */
1957 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
1960 ecom
= attr
->ecommunity
;
1961 if (!ecom
|| !ecom
->size
)
1964 /* For each extended community RT, see if it matches this VNI. If any RT
1965 * matches, we're done.
1967 for (i
= 0; i
< ecom
->size
; i
++) {
1969 u_char type
, sub_type
;
1970 struct ecommunity_val
*eval
;
1971 struct ecommunity_val eval_tmp
;
1972 struct vrf_irt_node
*irt
;
1974 /* Only deal with RTs */
1975 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
1976 eval
= (struct ecommunity_val
*)(ecom
->val
1977 + (i
* ECOMMUNITY_SIZE
));
1980 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
1983 /* See if this RT matches specified VNIs import RTs */
1984 irt
= lookup_vrf_import_rt(eval
);
1985 if (irt
&& irt
->vrfs
)
1986 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
1989 /* Also check for non-exact match. In this, we mask out the AS
1991 * only check on the local-admin sub-field. This is to
1993 * VNI as the RT for EBGP peering too.
1996 if (type
== ECOMMUNITY_ENCODE_AS
1997 || type
== ECOMMUNITY_ENCODE_AS4
1998 || type
== ECOMMUNITY_ENCODE_IP
) {
1999 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2000 mask_ecom_global_admin(&eval_tmp
, eval
);
2001 irt
= lookup_vrf_import_rt(&eval_tmp
);
2003 if (irt
&& irt
->vrfs
)
2004 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2012 * Given a route entry and a VNI, see if this route entry should be
2013 * imported into the VNI i.e., RTs match.
2015 static int is_route_matching_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2016 struct bgp_info
*ri
)
2018 struct attr
*attr
= ri
->attr
;
2019 struct ecommunity
*ecom
;
2023 /* Route should have valid RT to be even considered. */
2024 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2027 ecom
= attr
->ecommunity
;
2028 if (!ecom
|| !ecom
->size
)
2031 /* For each extended community RT, see if it matches this VNI. If any RT
2032 * matches, we're done.
2034 for (i
= 0; i
< ecom
->size
; i
++) {
2036 u_char type
, sub_type
;
2037 struct ecommunity_val
*eval
;
2038 struct ecommunity_val eval_tmp
;
2039 struct irt_node
*irt
;
2041 /* Only deal with RTs */
2042 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2043 eval
= (struct ecommunity_val
*)(ecom
->val
2044 + (i
* ECOMMUNITY_SIZE
));
2047 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2050 /* See if this RT matches specified VNIs import RTs */
2051 irt
= lookup_import_rt(bgp
, eval
);
2052 if (irt
&& irt
->vnis
)
2053 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2056 /* Also check for non-exact match. In this, we mask out the AS
2058 * only check on the local-admin sub-field. This is to
2060 * VNI as the RT for EBGP peering too.
2063 if (type
== ECOMMUNITY_ENCODE_AS
2064 || type
== ECOMMUNITY_ENCODE_AS4
2065 || type
== ECOMMUNITY_ENCODE_IP
) {
2066 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2067 mask_ecom_global_admin(&eval_tmp
, eval
);
2068 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2070 if (irt
&& irt
->vnis
)
2071 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2079 * Install or uninstall mac-ip routes are appropriate for this
2082 static int install_uninstall_routes_for_vrf(struct bgp
*bgp_vrf
,
2087 struct bgp_node
*rd_rn
, *rn
;
2088 struct bgp_table
*table
;
2089 struct bgp_info
*ri
;
2091 char buf
[PREFIX_STRLEN
];
2092 struct bgp
*bgp_def
= NULL
;
2096 bgp_def
= bgp_get_default();
2100 /* Walk entire global routing table and evaluate routes which could be
2101 * imported into this VRF. Note that we need to loop through all global
2102 * routes to determine which route matches the import rt on vrf
2104 for (rd_rn
= bgp_table_top(bgp_def
->rib
[afi
][safi
]); rd_rn
;
2105 rd_rn
= bgp_route_next(rd_rn
)) {
2106 table
= (struct bgp_table
*)(rd_rn
->info
);
2110 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2111 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2113 /* if not mac-ip route skip this route */
2114 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
||
2115 evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
2118 /* if not a mac+ip route skip this route */
2119 if (!(IS_EVPN_PREFIX_IPADDR_V4(evp
) ||
2120 IS_EVPN_PREFIX_IPADDR_V6(evp
)))
2123 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2124 /* Consider "valid" remote routes applicable for
2126 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2127 && ri
->type
== ZEBRA_ROUTE_BGP
2128 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2131 if (is_route_matching_for_vrf(bgp_vrf
, ri
)) {
2134 install_evpn_route_entry_in_vrf(
2138 uninstall_evpn_route_entry_in_vrf(
2143 "Failed to %s EVPN %s route in VRF %s",
2146 prefix2str(evp
, buf
,
2148 vrf_id_to_name(bgp_vrf
->vrf_id
));
2160 * Install or uninstall routes of specified type that are appropriate for this
2163 static int install_uninstall_routes_for_vni(struct bgp
*bgp
,
2164 struct bgpevpn
*vpn
,
2165 bgp_evpn_route_type rtype
,
2170 struct bgp_node
*rd_rn
, *rn
;
2171 struct bgp_table
*table
;
2172 struct bgp_info
*ri
;
2178 /* Walk entire global routing table and evaluate routes which could be
2179 * imported into this VPN. Note that we cannot just look at the routes
2181 * the VNI's RD - remote routes applicable for this VNI could have any
2184 /* EVPN routes are a 2-level table. */
2185 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2186 rd_rn
= bgp_route_next(rd_rn
)) {
2187 table
= (struct bgp_table
*)(rd_rn
->info
);
2191 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2192 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2194 if (evp
->prefix
.route_type
!= rtype
)
2197 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2198 /* Consider "valid" remote routes applicable for
2200 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2201 && ri
->type
== ZEBRA_ROUTE_BGP
2202 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2205 if (is_route_matching_for_vni(bgp
, vpn
, ri
)) {
2207 ret
= install_evpn_route_entry(
2210 ret
= uninstall_evpn_route_entry(
2215 "%u: Failed to %s EVPN %s route in VNI %u",
2219 rtype
== BGP_EVPN_MAC_IP_ROUTE
2233 /* Install any existing remote routes applicable for this VRF into VRF RIB. This
2234 * is invoked upon l3vni-add or l3vni import rt change */
2235 static int install_routes_for_vrf(struct bgp
*bgp_vrf
)
2237 install_uninstall_routes_for_vrf(bgp_vrf
, 1);
2242 * Install any existing remote routes applicable for this VNI into its
2243 * routing table. This is invoked when a VNI becomes "live" or its Import
2246 static int install_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2250 /* Install type-3 routes followed by type-2 routes - the ones applicable
2253 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
2258 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
2262 /* uninstall routes from l3vni vrf. */
2263 static int uninstall_routes_for_vrf(struct bgp
*bgp_vrf
)
2265 install_uninstall_routes_for_vrf(bgp_vrf
, 0);
2270 * Uninstall any existing remote routes for this VNI. One scenario in which
2271 * this is invoked is upon an import RT change.
2273 static int uninstall_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2277 /* Uninstall type-2 routes followed by type-3 routes - the ones
2281 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
2286 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
2291 * Install or uninstall route in matching VRFs (list).
2293 static int install_uninstall_route_in_vrfs(struct bgp
*bgp_def
, afi_t afi
,
2294 safi_t safi
, struct prefix_evpn
*evp
,
2295 struct bgp_info
*ri
,
2296 struct list
*vrfs
, int install
)
2298 char buf
[PREFIX2STR_BUFFER
];
2299 struct bgp
*bgp_vrf
;
2300 struct listnode
*node
, *nnode
;
2302 /* Only type-2/type-5 routes go into a VRF */
2303 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
||
2304 evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
2307 /* if it is type-2 route and not a mac+ip route skip this route */
2308 if ((evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) &&
2309 !(IS_EVPN_PREFIX_IPADDR_V4(evp
) || IS_EVPN_PREFIX_IPADDR_V6(evp
)))
2312 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, bgp_vrf
)) {
2316 ret
= install_evpn_route_entry_in_vrf(bgp_vrf
,
2319 ret
= uninstall_evpn_route_entry_in_vrf(bgp_vrf
,
2323 zlog_err("%u: Failed to %s prefix %s in VRF %s",
2325 install
? "install" : "uninstall",
2326 prefix2str(evp
, buf
, sizeof(buf
)),
2327 vrf_id_to_name(bgp_vrf
->vrf_id
));
2336 * Install or uninstall route in matching VNIs (list).
2338 static int install_uninstall_route_in_vnis(struct bgp
*bgp
, afi_t afi
,
2339 safi_t safi
, struct prefix_evpn
*evp
,
2340 struct bgp_info
*ri
,
2341 struct list
*vnis
, int install
)
2343 struct bgpevpn
*vpn
;
2344 struct listnode
*node
, *nnode
;
2346 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, vpn
)) {
2349 if (!is_vni_live(vpn
))
2353 ret
= install_evpn_route_entry(bgp
, vpn
, evp
, ri
);
2355 ret
= uninstall_evpn_route_entry(bgp
, vpn
, evp
, ri
);
2358 zlog_err("%u: Failed to %s EVPN %s route in VNI %u",
2359 bgp
->vrf_id
, install
? "install" : "uninstall",
2360 evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2372 * Install or uninstall route for appropriate VNIs.
2374 static int install_uninstall_evpn_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
2375 struct prefix
*p
, struct bgp_info
*ri
,
2378 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
2379 struct attr
*attr
= ri
->attr
;
2380 struct ecommunity
*ecom
;
2385 /* Only type-2 and type-3 and type-5 are supported currently */
2386 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2387 || evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
2388 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
2391 /* If we don't have Route Target, nothing much to do. */
2392 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2395 ecom
= attr
->ecommunity
;
2396 if (!ecom
|| !ecom
->size
)
2399 /* For each extended community RT, see which VNIs/VRFs match and import
2400 * the route into matching VNIs/VRFs.
2402 for (i
= 0; i
< ecom
->size
; i
++) {
2404 u_char type
, sub_type
;
2405 struct ecommunity_val
*eval
;
2406 struct ecommunity_val eval_tmp
;
2407 struct irt_node
*irt
; /* import rt for l2vni */
2408 struct vrf_irt_node
*vrf_irt
; /* import rt for l3vni */
2410 /* Only deal with RTs */
2411 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2412 eval
= (struct ecommunity_val
*)(ecom
->val
2413 + (i
* ECOMMUNITY_SIZE
));
2416 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2419 /* Import route into matching l2-vnis (type-2/type-3 routes go
2420 * into l2vni table) */
2421 irt
= lookup_import_rt(bgp
, eval
);
2422 if (irt
&& irt
->vnis
)
2423 install_uninstall_route_in_vnis(bgp
, afi
, safi
, evp
, ri
,
2426 /* Import route into matching l3-vnis (type-2/type-5 routes go
2427 * into l3vni/vrf table) */
2428 vrf_irt
= lookup_vrf_import_rt(eval
);
2429 if (vrf_irt
&& vrf_irt
->vrfs
)
2430 install_uninstall_route_in_vrfs(bgp
, afi
, safi
, evp
, ri
,
2431 vrf_irt
->vrfs
, import
);
2433 /* Also check for non-exact match. In this,
2434 * we mask out the AS and
2435 * only check on the local-admin sub-field.
2436 * This is to facilitate using
2437 * VNI as the RT for EBGP peering too.
2441 if (type
== ECOMMUNITY_ENCODE_AS
2442 || type
== ECOMMUNITY_ENCODE_AS4
2443 || type
== ECOMMUNITY_ENCODE_IP
) {
2444 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2445 mask_ecom_global_admin(&eval_tmp
, eval
);
2446 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2447 vrf_irt
= lookup_vrf_import_rt(&eval_tmp
);
2449 if (irt
&& irt
->vnis
)
2450 install_uninstall_route_in_vnis(bgp
, afi
, safi
, evp
, ri
,
2452 if (vrf_irt
&& vrf_irt
->vrfs
)
2453 install_uninstall_route_in_vrfs(bgp
, afi
, safi
, evp
,
2461 /* delete and withdraw all ipv4 and ipv6 routes in the vrf table as type-5
2463 static void delete_withdraw_vrf_routes(struct bgp
*bgp_vrf
)
2465 /* delete all ipv4 routes and withdraw from peers */
2466 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
2468 /* delete all ipv6 routes and withdraw from peers */
2469 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
2472 /* update and advertise all ipv4 and ipv6 routes in thr vrf table as type-5
2474 static void update_advertise_vrf_routes(struct bgp
*bgp_vrf
)
2476 /* update all ipv4 routes */
2477 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
2479 /* update all ipv6 routes */
2480 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
2484 * update and advertise local routes for a VRF as type-5 routes.
2485 * This is invoked upon RD change for a VRF. Note taht the processing is only
2486 * done in the global route table using the routes which already exist in the
2489 static void update_router_id_vrf(struct bgp
*bgp_vrf
)
2491 /* skip if the RD is configured */
2492 if (is_vrf_rd_configured(bgp_vrf
))
2495 /* derive the RD for the VRF based on new router-id */
2496 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
2498 /* update advertise ipv4|ipv6 routes as type-5 routes */
2499 update_advertise_vrf_routes(bgp_vrf
);
2503 * Delete and withdraw all type-5 routes for the RD corresponding to VRF.
2504 * This is invoked upon VRF RD change. The processing is done only from global
2507 static void withdraw_router_id_vrf(struct bgp
*bgp_vrf
)
2509 /* skip if the RD is configured */
2510 if (is_vrf_rd_configured(bgp_vrf
))
2513 /* delete/withdraw ipv4|ipv6 routes as type-5 routes */
2514 delete_withdraw_vrf_routes(bgp_vrf
);
2518 * Update and advertise local routes for a VNI. Invoked upon router-id
2519 * change. Note that the processing is done only on the global route table
2520 * using routes that already exist in the per-VNI table.
2522 static int update_advertise_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2524 struct prefix_evpn p
;
2525 struct bgp_node
*rn
, *global_rn
;
2526 struct bgp_info
*ri
, *global_ri
;
2528 afi_t afi
= AFI_L2VPN
;
2529 safi_t safi
= SAFI_EVPN
;
2531 /* Locate type-3 route for VNI in the per-VNI table and use its
2532 * attributes to create and advertise the type-3 route for this VNI
2533 * in the global table.
2535 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2536 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)&p
);
2537 if (!rn
) /* unexpected */
2539 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2540 if (ri
->peer
== bgp
->peer_self
&& ri
->type
== ZEBRA_ROUTE_BGP
2541 && ri
->sub_type
== BGP_ROUTE_STATIC
)
2543 if (!ri
) /* unexpected */
2547 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2548 (struct prefix
*)&p
, &vpn
->prd
);
2549 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1, 0, &ri
,
2552 /* Schedule for processing and unlock node. */
2553 bgp_process(bgp
, global_rn
, afi
, safi
);
2554 bgp_unlock_node(global_rn
);
2556 /* Now, walk this VNI's route table and use the route and its attribute
2557 * to create and schedule route in global table.
2559 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2560 rn
= bgp_route_next(rn
)) {
2561 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2563 /* Identify MAC-IP local routes. */
2564 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2567 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2568 if (ri
->peer
== bgp
->peer_self
2569 && ri
->type
== ZEBRA_ROUTE_BGP
2570 && ri
->sub_type
== BGP_ROUTE_STATIC
)
2575 /* Create route in global routing table using this route entry's
2579 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2580 (struct prefix
*)evp
, &vpn
->prd
);
2582 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1,
2585 /* Schedule for processing and unlock node. */
2586 bgp_process(bgp
, global_rn
, afi
, safi
);
2587 bgp_unlock_node(global_rn
);
2594 * Delete (and withdraw) local routes for a VNI - only from the global
2595 * table. Invoked upon router-id change.
2597 static int delete_withdraw_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2600 struct prefix_evpn p
;
2601 struct bgp_node
*global_rn
;
2602 struct bgp_info
*ri
;
2603 afi_t afi
= AFI_L2VPN
;
2604 safi_t safi
= SAFI_EVPN
;
2606 /* Delete and withdraw locally learnt type-2 routes (MACIP)
2607 * for this VNI - from the global table.
2609 ret
= delete_global_type2_routes(bgp
, vpn
);
2613 /* Remove type-3 route for this VNI from global table. */
2614 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2615 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
2616 (struct prefix
*)&p
, &vpn
->prd
);
2618 /* Delete route entry in the global EVPN table. */
2619 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, &ri
);
2621 /* Schedule for processing - withdraws to peers happen from
2625 bgp_process(bgp
, global_rn
, afi
, safi
);
2626 bgp_unlock_node(global_rn
);
2633 * Handle router-id change. Update and advertise local routes corresponding
2634 * to this VNI from peers. Note that this is invoked after updating the
2635 * router-id. The routes in the per-VNI table are used to create routes in
2636 * the global table and schedule them.
2638 static void update_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
2640 struct bgpevpn
*vpn
;
2642 vpn
= (struct bgpevpn
*)backet
->data
;
2645 zlog_warn("%s: VNI hash entry for VNI not found", __FUNCTION__
);
2649 /* Skip VNIs with configured RD. */
2650 if (is_rd_configured(vpn
))
2653 bgp_evpn_derive_auto_rd(bgp
, vpn
);
2654 update_advertise_vni_routes(bgp
, vpn
);
2658 * Handle router-id change. Delete and withdraw local routes corresponding
2659 * to this VNI from peers. Note that this is invoked prior to updating
2660 * the router-id and is done only on the global route table, the routes
2661 * are needed in the per-VNI table to re-advertise with new router id.
2663 static void withdraw_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
2665 struct bgpevpn
*vpn
;
2667 vpn
= (struct bgpevpn
*)backet
->data
;
2670 zlog_warn("%s: VNI hash entry for VNI not found", __FUNCTION__
);
2674 /* Skip VNIs with configured RD. */
2675 if (is_rd_configured(vpn
))
2678 delete_withdraw_vni_routes(bgp
, vpn
);
2682 * Process received EVPN type-2 route (advertise or withdraw).
2684 static int process_type2_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
2685 struct attr
*attr
, u_char
*pfx
, int psize
,
2686 u_int32_t addpath_id
)
2688 struct prefix_rd prd
;
2689 struct prefix_evpn p
;
2692 mpls_label_t
*label_pnt
;
2695 /* Type-2 route should be either 33, 37 or 49 bytes or an
2696 * additional 3 bytes if there is a second label (VNI):
2697 * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1),
2698 * MAC Addr (6), IP len (1), IP (0, 4 or 16),
2699 * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3)
2701 if (psize
!= 33 && psize
!= 37 && psize
!= 49 && psize
!= 36
2702 && psize
!= 40 && psize
!= 52) {
2703 zlog_err("%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
2704 peer
->bgp
->vrf_id
, peer
->host
, psize
);
2708 /* Make prefix_rd */
2709 prd
.family
= AF_UNSPEC
;
2711 memcpy(&prd
.val
, pfx
, 8);
2714 /* Make EVPN prefix. */
2715 memset(&p
, 0, sizeof(struct prefix_evpn
));
2717 p
.prefixlen
= EVPN_TYPE_2_ROUTE_PREFIXLEN
;
2718 p
.prefix
.route_type
= BGP_EVPN_MAC_IP_ROUTE
;
2720 /* Skip over Ethernet Seg Identifier for now. */
2723 /* Skip over Ethernet Tag for now. */
2726 /* Get the MAC Addr len */
2727 macaddr_len
= *pfx
++;
2729 /* Get the MAC Addr */
2730 if (macaddr_len
== (ETH_ALEN
* 8)) {
2731 memcpy(&p
.prefix
.mac
.octet
, pfx
, ETH_ALEN
);
2735 "%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
2736 peer
->bgp
->vrf_id
, peer
->host
, macaddr_len
);
2742 ipaddr_len
= *pfx
++;
2743 if (ipaddr_len
!= 0 && ipaddr_len
!= IPV4_MAX_BITLEN
2744 && ipaddr_len
!= IPV6_MAX_BITLEN
) {
2746 "%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
2747 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
2752 ipaddr_len
/= 8; /* Convert to bytes. */
2753 p
.prefix
.ip
.ipa_type
= (ipaddr_len
== IPV4_MAX_BYTELEN
)
2756 memcpy(&p
.prefix
.ip
.ip
.addr
, pfx
, ipaddr_len
);
2760 /* Get the VNI (in MPLS label field). */
2761 /* Note: We ignore the second VNI, if any. */
2762 label_pnt
= (mpls_label_t
*)pfx
;
2764 /* Process the route. */
2766 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2767 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2768 &prd
, label_pnt
, 0, NULL
);
2770 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2771 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2772 &prd
, label_pnt
, NULL
);
2777 * Process received EVPN type-3 route (advertise or withdraw).
2779 static int process_type3_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
2780 struct attr
*attr
, u_char
*pfx
, int psize
,
2781 u_int32_t addpath_id
)
2783 struct prefix_rd prd
;
2784 struct prefix_evpn p
;
2788 /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
2789 * IP len (1) and IP (4 or 16).
2791 if (psize
!= 17 && psize
!= 29) {
2792 zlog_err("%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
2793 peer
->bgp
->vrf_id
, peer
->host
, psize
);
2797 /* Make prefix_rd */
2798 prd
.family
= AF_UNSPEC
;
2800 memcpy(&prd
.val
, pfx
, 8);
2803 /* Make EVPN prefix. */
2804 memset(&p
, 0, sizeof(struct prefix_evpn
));
2806 p
.prefixlen
= EVPN_TYPE_3_ROUTE_PREFIXLEN
;
2807 p
.prefix
.route_type
= BGP_EVPN_IMET_ROUTE
;
2809 /* Skip over Ethernet Tag for now. */
2813 ipaddr_len
= *pfx
++;
2814 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
2815 p
.prefix
.ip
.ipa_type
= IPADDR_V4
;
2816 memcpy(&p
.prefix
.ip
.ip
.addr
, pfx
, IPV4_MAX_BYTELEN
);
2819 "%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
2820 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
2824 /* Process the route. */
2826 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2827 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2828 &prd
, NULL
, 0, NULL
);
2830 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2831 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2837 * Process received EVPN type-5 route (advertise or withdraw).
2839 static int process_type5_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
2840 struct attr
*attr
, u_char
*pfx
, int psize
,
2841 u_int32_t addpath_id
, int withdraw
)
2843 struct prefix_rd prd
;
2844 struct prefix_evpn p
;
2845 struct bgp_route_evpn evpn
;
2848 mpls_label_t
*label_pnt
;
2851 /* Type-5 route should be 34 or 58 bytes:
2852 * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16),
2853 * GW (4 or 16) and VNI (3).
2854 * Note that the IP and GW should both be IPv4 or both IPv6.
2856 if (psize
!= 34 && psize
!= 58) {
2857 zlog_err("%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
2858 peer
->bgp
->vrf_id
, peer
->host
, psize
);
2862 /* Make prefix_rd */
2863 prd
.family
= AF_UNSPEC
;
2865 memcpy(&prd
.val
, pfx
, 8);
2868 /* Make EVPN prefix. */
2869 memset(&p
, 0, sizeof(struct prefix_evpn
));
2871 p
.prefixlen
= EVPN_TYPE_5_ROUTE_PREFIXLEN
;
2872 p
.prefix
.route_type
= BGP_EVPN_IP_PREFIX_ROUTE
;
2874 /* Additional information outside of prefix - ESI and GW IP */
2875 memset(&evpn
, 0, sizeof(evpn
));
2878 memcpy(&evpn
.eth_s_id
.val
, pfx
, 10);
2881 /* Fetch Ethernet Tag. */
2882 memcpy(ð_tag
, pfx
, 4);
2883 p
.prefix
.eth_tag
= ntohl(eth_tag
);
2886 /* Fetch IP prefix length. */
2888 if (ippfx_len
> IPV6_MAX_BITLEN
) {
2890 "%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
2891 peer
->bgp
->vrf_id
, peer
->host
, ippfx_len
);
2894 p
.prefix
.ip_prefix_length
= ippfx_len
;
2896 /* Determine IPv4 or IPv6 prefix */
2897 /* Since the address and GW are from the same family, this just becomes
2898 * a simple check on the total size.
2901 SET_IPADDR_V4(&p
.prefix
.ip
);
2902 memcpy(&p
.prefix
.ip
.ipaddr_v4
, pfx
, 4);
2904 memcpy(&evpn
.gw_ip
.ipv4
, pfx
, 4);
2907 SET_IPADDR_V6(&p
.prefix
.ip
);
2908 memcpy(&p
.prefix
.ip
.ipaddr_v6
, pfx
, 16);
2910 memcpy(&evpn
.gw_ip
.ipv6
, pfx
, 16);
2914 label_pnt
= (mpls_label_t
*)pfx
;
2916 /* Process the route. */
2918 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2919 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2920 &prd
, label_pnt
, 0, &evpn
);
2922 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2923 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2924 &prd
, label_pnt
, &evpn
);
2929 static void evpn_mpattr_encode_type5(struct stream
*s
, struct prefix
*p
,
2930 struct prefix_rd
*prd
, mpls_label_t
*label
,
2935 struct evpn_addr
*p_evpn_p
;
2937 memset(&temp
, 0, 16);
2938 if (p
->family
!= AF_EVPN
)
2940 p_evpn_p
= &(p
->u
.prefix_evpn
);
2942 /* len denites the total len of IP and GW-IP in the route
2943 IP and GW-IP have to be both ipv4 or ipv6 */
2944 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
2945 len
= 8; /* IP and GWIP are both ipv4 */
2947 len
= 32; /* IP and GWIP are both ipv6 */
2948 /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */
2949 stream_putc(s
, 8 + 10 + 4 + 1 + len
+ 3);
2950 stream_put(s
, prd
->val
, 8);
2952 stream_put(s
, &(attr
->evpn_overlay
.eth_s_id
), 10);
2954 stream_put(s
, &temp
, 10);
2955 stream_putl(s
, p_evpn_p
->eth_tag
);
2956 stream_putc(s
, p_evpn_p
->ip_prefix_length
);
2957 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
2958 stream_put_ipv4(s
, p_evpn_p
->ip
.ipaddr_v4
.s_addr
);
2960 stream_put(s
, &p_evpn_p
->ip
.ipaddr_v6
, 16);
2962 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
2964 attr
->evpn_overlay
.gw_ip
.ipv4
.s_addr
);
2966 stream_put(s
, &(attr
->evpn_overlay
.gw_ip
.ipv6
), 16);
2968 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
2969 stream_put_ipv4(s
, 0);
2971 stream_put(s
, &temp
, 16);
2975 stream_put(s
, label
, 3);
2981 * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
2983 static void cleanup_vni_on_disable(struct hash_backet
*backet
, struct bgp
*bgp
)
2985 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
2987 /* Remove EVPN routes and schedule for processing. */
2988 delete_routes_for_vni(bgp
, vpn
);
2990 /* Clear "live" flag and see if hash needs to be freed. */
2991 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
2992 if (!is_vni_configured(vpn
))
2993 bgp_evpn_free(bgp
, vpn
);
2997 * Free a VNI entry; iterator function called during cleanup.
2999 static void free_vni_entry(struct hash_backet
*backet
, struct bgp
*bgp
)
3001 struct bgpevpn
*vpn
;
3003 vpn
= (struct bgpevpn
*)backet
->data
;
3004 delete_all_vni_routes(bgp
, vpn
);
3005 bgp_evpn_free(bgp
, vpn
);
3009 * Derive AUTO import RT for BGP VRF - L3VNI
3011 static void evpn_auto_rt_import_add_for_vrf(struct bgp
*bgp_vrf
)
3013 struct bgp
*bgp_def
= NULL
;
3015 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3016 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3019 bgp_def
= bgp_get_default();
3022 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3026 * Delete AUTO import RT from BGP VRF - L3VNI
3028 static void evpn_auto_rt_import_delete_for_vrf(struct bgp
*bgp_vrf
)
3030 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3034 * Derive AUTO export RT for BGP VRF - L3VNI
3036 static void evpn_auto_rt_export_add_for_vrf(struct bgp
*bgp_vrf
)
3038 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3039 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
3043 * Delete AUTO export RT from BGP VRF - L3VNI
3045 static void evpn_auto_rt_export_delete_for_vrf(struct bgp
*bgp_vrf
)
3047 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
3050 static void bgp_evpn_handle_export_rt_change_for_vrf(struct bgp
*bgp_vrf
)
3052 struct bgp
*bgp_def
= NULL
;
3053 struct listnode
*node
= NULL
;
3054 struct bgpevpn
*vpn
= NULL
;
3056 bgp_def
= bgp_get_default();
3060 /* update all type-5 routes */
3061 update_advertise_vrf_routes(bgp_vrf
);
3063 /* update all type-2 routes */
3064 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
3065 update_routes_for_vni(bgp_def
, vpn
);
3072 /* withdraw type-5 route corresponding to ip prefix */
3073 void bgp_evpn_withdraw_type5_route(struct bgp
*bgp_vrf
, struct bgp_node
*rn
,
3074 afi_t afi
, safi_t safi
)
3077 struct prefix_evpn evp
;
3078 char buf
[PREFIX_STRLEN
];
3080 build_type5_prefix_from_ip_prefix(&evp
, &rn
->p
);
3081 ret
= delete_evpn_type5_route(bgp_vrf
, &evp
);
3084 "%u failed to delete type-5 route for prefix %s in vrf %s",
3086 prefix2str(&rn
->p
, buf
, sizeof(buf
)),
3087 vrf_id_to_name(bgp_vrf
->vrf_id
));
3091 /* withdraw all type-5 routes for an address family */
3092 void bgp_evpn_withdraw_type5_routes(struct bgp
*bgp_vrf
,
3093 afi_t afi
, safi_t safi
)
3095 struct bgp_table
*table
= NULL
;
3096 struct bgp_node
*rn
= NULL
;
3098 if (!advertise_type5_routes(bgp_vrf
, afi
))
3101 table
= bgp_vrf
->rib
[afi
][safi
];
3102 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
3103 bgp_evpn_withdraw_type5_route(bgp_vrf
, rn
, afi
, safi
);
3107 /* advertise ip prefix as type-5 route*/
3108 void bgp_evpn_advertise_type5_route(struct bgp
*bgp_vrf
, struct bgp_node
*rn
,
3109 afi_t afi
, safi_t safi
)
3112 struct prefix_evpn evp
;
3113 char buf
[PREFIX_STRLEN
];
3115 if (!advertise_type5_routes(bgp_vrf
, afi
))
3121 /* only advertise subnet routes as type-5 */
3122 if (is_host_route(&rn
->p
))
3125 build_type5_prefix_from_ip_prefix(&evp
, &rn
->p
);
3126 ret
= update_evpn_type5_route(bgp_vrf
, &evp
);
3129 "%u failed to create type-5 route for prefix %s in vrf %s",
3131 prefix2str(&rn
->p
, buf
, sizeof(buf
)),
3132 vrf_id_to_name(bgp_vrf
->vrf_id
));
3136 /* advertise all type-5 routes for an address family */
3137 void bgp_evpn_advertise_type5_routes(struct bgp
*bgp_vrf
,
3138 afi_t afi
, safi_t safi
)
3140 struct bgp_table
*table
= NULL
;
3141 struct bgp_node
*rn
= NULL
;
3143 table
= bgp_vrf
->rib
[afi
][safi
];
3144 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
3145 bgp_evpn_advertise_type5_route(bgp_vrf
, rn
, afi
, safi
);
3148 void evpn_rt_delete_auto(struct bgp
*bgp
, vni_t vni
,
3151 struct listnode
*node
, *nnode
, *node_to_del
;
3152 struct ecommunity
*ecom
, *ecom_auto
;
3153 struct ecommunity_val eval
;
3155 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
3157 ecom_auto
= ecommunity_new();
3158 ecommunity_add_val(ecom_auto
, &eval
);
3161 for (ALL_LIST_ELEMENTS(rtl
, node
, nnode
, ecom
)) {
3162 if (ecommunity_match(ecom
, ecom_auto
)) {
3163 ecommunity_free(&ecom
);
3169 list_delete_node(rtl
, node_to_del
);
3171 ecommunity_free(&ecom_auto
);
3174 void bgp_evpn_configure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
3175 struct ecommunity
*ecomadd
)
3177 /* uninstall routes from vrf */
3178 uninstall_routes_for_vrf(bgp_vrf
);
3180 /* Cleanup the RT to VRF mapping */
3181 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
3183 /* Remove auto generated RT */
3184 evpn_auto_rt_import_delete_for_vrf(bgp_vrf
);
3186 /* Add the newly configured RT to RT list */
3187 listnode_add_sort(bgp_vrf
->vrf_import_rtl
, ecomadd
);
3188 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3190 /* map VRF to its RTs */
3191 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3193 /* install routes matching the new VRF */
3194 install_routes_for_vrf(bgp_vrf
);
3197 void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
3198 struct ecommunity
*ecomdel
)
3200 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
3201 struct ecommunity
*ecom
= NULL
;
3203 /* uninstall routes from vrf */
3204 uninstall_routes_for_vrf(bgp_vrf
);
3206 /* Cleanup the RT to VRF mapping */
3207 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
3209 /* remove the RT from the RT list */
3210 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
3211 if (ecommunity_match(ecom
, ecomdel
)) {
3212 ecommunity_free(&ecom
);
3219 list_delete_node(bgp_vrf
->vrf_import_rtl
, node_to_del
);
3221 /* fallback to auto import rt, if this was the last RT */
3222 if (list_isempty(bgp_vrf
->vrf_import_rtl
)) {
3223 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3224 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
3227 /* map VRFs to its RTs */
3228 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3230 /* install routes matching this new RT */
3231 install_routes_for_vrf(bgp_vrf
);
3234 void bgp_evpn_configure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
3235 struct ecommunity
*ecomadd
)
3237 /* remove auto-generated RT */
3238 evpn_auto_rt_export_delete_for_vrf(bgp_vrf
);
3240 /* Add the new RT to the RT list */
3241 listnode_add_sort(bgp_vrf
->vrf_export_rtl
, ecomadd
);
3242 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3244 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
3248 void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
3249 struct ecommunity
*ecomdel
)
3251 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
3252 struct ecommunity
*ecom
= NULL
;
3254 /* Remove the RT from the RT list */
3255 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, ecom
)) {
3256 if (ecommunity_match(ecom
, ecomdel
)) {
3257 ecommunity_free(&ecom
);
3264 list_delete_node(bgp_vrf
->vrf_export_rtl
, node_to_del
);
3266 /* fall back to auto-generated RT if this was the last RT */
3267 if (bgp_vrf
->vrf_export_rtl
&& list_isempty(bgp_vrf
->vrf_export_rtl
)) {
3268 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3269 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
3272 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
3276 * Handle change to BGP router id. This is invoked twice by the change
3277 * handler, first before the router id has been changed and then after
3278 * the router id has been changed. The first invocation will result in
3279 * local routes for all VNIs/VRF being deleted and withdrawn and the next
3280 * will result in the routes being re-advertised.
3282 void bgp_evpn_handle_router_id_update(struct bgp
*bgp
, int withdraw
)
3286 /* delete and withdraw all the type-5 routes
3287 stored in the global table for this vrf */
3288 withdraw_router_id_vrf(bgp
);
3290 /* delete all the VNI routes (type-2/type-3) routes for all the
3292 hash_iterate(bgp
->vnihash
,
3293 (void (*)(struct hash_backet
*,
3294 void *))withdraw_router_id_vni
,
3298 /* advertise all routes in the vrf as type-5 routes with the new
3300 update_router_id_vrf(bgp
);
3302 /* advertise all the VNI routes (type-2/type-3) routes with the
3304 hash_iterate(bgp
->vnihash
,
3305 (void (*)(struct hash_backet
*,
3306 void *))update_router_id_vni
,
3312 * Handle change to export RT - update and advertise local routes.
3314 int bgp_evpn_handle_export_rt_change(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3316 return update_routes_for_vni(bgp
, vpn
);
3319 void bgp_evpn_handle_vrf_rd_change(struct bgp
*bgp_vrf
,
3323 delete_withdraw_vrf_routes(bgp_vrf
);
3325 update_advertise_vrf_routes(bgp_vrf
);
3329 * Handle change to RD. This is invoked twice by the change handler,
3330 * first before the RD has been changed and then after the RD has
3331 * been changed. The first invocation will result in local routes
3332 * of this VNI being deleted and withdrawn and the next will result
3333 * in the routes being re-advertised.
3335 void bgp_evpn_handle_rd_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
3339 delete_withdraw_vni_routes(bgp
, vpn
);
3341 update_advertise_vni_routes(bgp
, vpn
);
3345 * Install routes for this VNI. Invoked upon change to Import RT.
3347 int bgp_evpn_install_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3349 return install_routes_for_vni(bgp
, vpn
);
3353 * Uninstall all routes installed for this VNI. Invoked upon change
3356 int bgp_evpn_uninstall_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3358 return uninstall_routes_for_vni(bgp
, vpn
);
3362 * Function to display "tag" in route as a VNI.
3364 char *bgp_evpn_label2str(mpls_label_t
*label
, char *buf
, int len
)
3368 vni
= label2vni(label
);
3369 snprintf(buf
, len
, "%u", vni
);
3374 * Function to convert evpn route to json format.
3375 * NOTE: We don't use prefix2str as the output here is a bit different.
3377 void bgp_evpn_route2json(struct prefix_evpn
*p
, json_object
*json
)
3379 char buf1
[ETHER_ADDR_STRLEN
];
3380 char buf2
[PREFIX2STR_BUFFER
];
3385 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
3386 json_object_int_add(json
, "routeType", p
->prefix
.route_type
);
3387 json_object_int_add(json
, "ethTag", 0);
3388 json_object_int_add(json
, "ipLen",
3389 IS_EVPN_PREFIX_IPADDR_V4(p
)
3392 json_object_string_add(json
, "ip",
3393 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
));
3394 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
3395 if (IS_EVPN_PREFIX_IPADDR_NONE(p
)) {
3396 json_object_int_add(json
, "routeType",
3397 p
->prefix
.route_type
);
3398 json_object_int_add(
3400 0); /* TODO: we don't support esi yet */
3401 json_object_int_add(json
, "ethTag", 0);
3402 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
3403 json_object_string_add(json
, "mac",
3404 prefix_mac2str(&p
->prefix
.mac
,
3410 family
= IS_EVPN_PREFIX_IPADDR_V4(p
) ? AF_INET
3413 json_object_int_add(json
, "routeType",
3414 p
->prefix
.route_type
);
3415 json_object_int_add(
3417 0); /* TODO: we don't support esi yet */
3418 json_object_int_add(json
, "ethTag", 0);
3419 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
3420 json_object_string_add(json
, "mac",
3421 prefix_mac2str(&p
->prefix
.mac
,
3424 json_object_int_add(json
, "ipLen",
3425 IS_EVPN_PREFIX_IPADDR_V4(p
)
3428 json_object_string_add(
3430 inet_ntop(family
, &p
->prefix
.ip
.ip
.addr
, buf2
,
3431 PREFIX2STR_BUFFER
));
3434 /* Currently, this is to cater to other AF_ETHERNET code. */
3439 * Function to convert evpn route to string.
3440 * NOTE: We don't use prefix2str as the output here is a bit different.
3442 char *bgp_evpn_route2str(struct prefix_evpn
*p
, char *buf
, int len
)
3444 char buf1
[ETHER_ADDR_STRLEN
];
3445 char buf2
[PREFIX2STR_BUFFER
];
3447 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
3448 snprintf(buf
, len
, "[%d]:[0]:[%d]:[%s]", p
->prefix
.route_type
,
3449 IS_EVPN_PREFIX_IPADDR_V4(p
) ? IPV4_MAX_BITLEN
3451 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
));
3452 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
3453 if (IS_EVPN_PREFIX_IPADDR_NONE(p
))
3454 snprintf(buf
, len
, "[%d]:[0]:[0]:[%d]:[%s]",
3455 p
->prefix
.route_type
, 8 * ETH_ALEN
,
3456 prefix_mac2str(&p
->prefix
.mac
, buf1
,
3461 family
= IS_EVPN_PREFIX_IPADDR_V4(p
) ? AF_INET
3463 snprintf(buf
, len
, "[%d]:[0]:[0]:[%d]:[%s]:[%d]:[%s]",
3464 p
->prefix
.route_type
, 8 * ETH_ALEN
,
3465 prefix_mac2str(&p
->prefix
.mac
, buf1
,
3467 family
== AF_INET
? IPV4_MAX_BITLEN
3469 inet_ntop(family
, &p
->prefix
.ip
.ip
.addr
, buf2
,
3470 PREFIX2STR_BUFFER
));
3472 } else if (p
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
3473 snprintf(buf
, len
, "[%d]:[0]:[%d]:[%s]",
3474 p
->prefix
.route_type
,
3475 p
->prefix
.ip_prefix_length
,
3476 IS_EVPN_PREFIX_IPADDR_V4(p
) ?
3477 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
) :
3478 inet6_ntoa(p
->prefix
.ip
.ipaddr_v6
));
3480 /* For EVPN route types not supported yet. */
3481 snprintf(buf
, len
, "(unsupported route type %d)",
3482 p
->prefix
.route_type
);
3489 * Encode EVPN prefix in Update (MP_REACH)
3491 void bgp_evpn_encode_prefix(struct stream
*s
, struct prefix
*p
,
3492 struct prefix_rd
*prd
, mpls_label_t
*label
,
3493 struct attr
*attr
, int addpath_encode
,
3494 u_int32_t addpath_tx_id
)
3496 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
3500 stream_putl(s
, addpath_tx_id
);
3503 stream_putc(s
, evp
->prefix
.route_type
);
3505 switch (evp
->prefix
.route_type
) {
3506 case BGP_EVPN_MAC_IP_ROUTE
:
3507 if (IS_EVPN_PREFIX_IPADDR_V4(evp
))
3508 ipa_len
= IPV4_MAX_BYTELEN
;
3509 else if (IS_EVPN_PREFIX_IPADDR_V6(evp
))
3510 ipa_len
= IPV6_MAX_BYTELEN
;
3511 stream_putc(s
, 33 + ipa_len
); // 1 VNI
3512 stream_put(s
, prd
->val
, 8); /* RD */
3513 stream_put(s
, 0, 10); /* ESI */
3514 stream_putl(s
, 0); /* Ethernet Tag ID */
3515 stream_putc(s
, 8 * ETH_ALEN
); /* Mac Addr Len - bits */
3516 stream_put(s
, evp
->prefix
.mac
.octet
, 6); /* Mac Addr */
3517 stream_putc(s
, 8 * ipa_len
); /* IP address Length */
3519 stream_put(s
, &evp
->prefix
.ip
.ip
.addr
,
3521 stream_put(s
, label
,
3522 BGP_LABEL_BYTES
); /* VNI is contained in 'tag' */
3525 case BGP_EVPN_IMET_ROUTE
:
3526 stream_putc(s
, 17); // TODO: length - assumes IPv4 address
3527 stream_put(s
, prd
->val
, 8); /* RD */
3528 stream_putl(s
, 0); /* Ethernet Tag ID */
3529 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
3530 /* Originating Router's IP Addr */
3531 stream_put_in_addr(s
, &evp
->prefix
.ip
.ipaddr_v4
);
3534 case BGP_EVPN_IP_PREFIX_ROUTE
:
3535 /* TODO: AddPath support. */
3536 evpn_mpattr_encode_type5(s
, p
, prd
, label
, attr
);
3544 int bgp_nlri_parse_evpn(struct peer
*peer
, struct attr
*attr
,
3545 struct bgp_nlri
*packet
, int withdraw
)
3551 u_int32_t addpath_id
;
3552 int addpath_encoded
;
3558 /* Check peer status. */
3559 if (peer
->status
!= Established
) {
3560 zlog_err("%u:%s - EVPN update received in state %d",
3561 peer
->bgp
->vrf_id
, peer
->host
, peer
->status
);
3565 /* Start processing the NLRI - there may be multiple in the MP_REACH */
3567 lim
= pnt
+ packet
->length
;
3569 safi
= packet
->safi
;
3573 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
3574 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
3575 PEER_CAP_ADDPATH_AF_TX_RCV
));
3577 for (; pnt
< lim
; pnt
+= psize
) {
3578 /* Clear prefix structure. */
3579 memset(&p
, 0, sizeof(struct prefix
));
3581 /* Deal with path-id if AddPath is supported. */
3582 if (addpath_encoded
) {
3583 /* When packet overflow occurs return immediately. */
3584 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
3587 addpath_id
= ntohl(*((uint32_t *)pnt
));
3588 pnt
+= BGP_ADDPATH_ID_LEN
;
3591 /* All EVPN NLRI types start with type and length. */
3596 psize
= rlen
= *pnt
++;
3598 /* When packet overflow occur return immediately. */
3599 if (pnt
+ psize
> lim
)
3603 case BGP_EVPN_MAC_IP_ROUTE
:
3604 if (process_type2_route(peer
, afi
, safi
,
3605 withdraw
? NULL
: attr
, pnt
,
3606 psize
, addpath_id
)) {
3608 "%u:%s - Error in processing EVPN type-2 NLRI size %d",
3609 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3614 case BGP_EVPN_IMET_ROUTE
:
3615 if (process_type3_route(peer
, afi
, safi
,
3616 withdraw
? NULL
: attr
, pnt
,
3617 psize
, addpath_id
)) {
3619 "%u:%s - Error in processing EVPN type-3 NLRI size %d",
3620 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3625 case BGP_EVPN_IP_PREFIX_ROUTE
:
3626 if (process_type5_route(peer
, afi
, safi
, attr
, pnt
,
3627 psize
, addpath_id
, withdraw
)) {
3629 "%u:%s - Error in processing EVPN type-5 NLRI size %d",
3630 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3640 /* Packet length consistency check. */
3648 * Map the RTs (configured or automatically derived) of a VRF to the VRF.
3649 * The mapping will be used during route processing.
3650 * bgp_def: default bgp instance
3651 * bgp_vrf: specific bgp vrf instance on which RT is configured
3653 void bgp_evpn_map_vrf_to_its_rts(struct bgp
*bgp_vrf
)
3656 struct ecommunity_val
*eval
= NULL
;
3657 struct listnode
*node
= NULL
, *nnode
= NULL
;
3658 struct ecommunity
*ecom
= NULL
;
3660 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
3661 for (i
= 0; i
< ecom
->size
; i
++) {
3662 eval
= (struct ecommunity_val
*)(ecom
->val
3664 * ECOMMUNITY_SIZE
));
3665 map_vrf_to_rt(bgp_vrf
, eval
);
3671 * Unmap the RTs (configured or automatically derived) of a VRF from the VRF.
3673 void bgp_evpn_unmap_vrf_from_its_rts(struct bgp
*bgp_vrf
)
3676 struct ecommunity_val
*eval
;
3677 struct listnode
*node
, *nnode
;
3678 struct ecommunity
*ecom
;
3680 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
3681 for (i
= 0; i
< ecom
->size
; i
++) {
3682 struct vrf_irt_node
*irt
;
3683 struct ecommunity_val eval_tmp
;
3685 eval
= (struct ecommunity_val
*)(ecom
->val
3687 * ECOMMUNITY_SIZE
));
3688 /* If using "automatic" RT, we only care about the
3689 * local-admin sub-field.
3690 * This is to facilitate using VNI as the RT for EBGP
3693 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3694 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
3695 BGP_VRF_IMPORT_RT_CFGD
))
3696 mask_ecom_global_admin(&eval_tmp
, eval
);
3698 irt
= lookup_vrf_import_rt(&eval_tmp
);
3700 unmap_vrf_from_rt(bgp_vrf
, irt
);
3708 * Map the RTs (configured or automatically derived) of a VNI to the VNI.
3709 * The mapping will be used during route processing.
3711 void bgp_evpn_map_vni_to_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3714 struct ecommunity_val
*eval
;
3715 struct listnode
*node
, *nnode
;
3716 struct ecommunity
*ecom
;
3718 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
3719 for (i
= 0; i
< ecom
->size
; i
++) {
3720 eval
= (struct ecommunity_val
*)(ecom
->val
3722 * ECOMMUNITY_SIZE
));
3723 map_vni_to_rt(bgp
, vpn
, eval
);
3729 * Unmap the RTs (configured or automatically derived) of a VNI from the VNI.
3731 void bgp_evpn_unmap_vni_from_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3734 struct ecommunity_val
*eval
;
3735 struct listnode
*node
, *nnode
;
3736 struct ecommunity
*ecom
;
3738 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
3739 for (i
= 0; i
< ecom
->size
; i
++) {
3740 struct irt_node
*irt
;
3741 struct ecommunity_val eval_tmp
;
3743 eval
= (struct ecommunity_val
*)(ecom
->val
3745 * ECOMMUNITY_SIZE
));
3746 /* If using "automatic" RT, we only care about the
3747 * local-admin sub-field.
3748 * This is to facilitate using VNI as the RT for EBGP
3751 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3752 if (!is_import_rt_configured(vpn
))
3753 mask_ecom_global_admin(&eval_tmp
, eval
);
3755 irt
= lookup_import_rt(bgp
, &eval_tmp
);
3757 unmap_vni_from_rt(bgp
, vpn
, irt
);
3763 * Derive Import RT automatically for VNI and map VNI to RT.
3764 * The mapping will be used during route processing.
3766 void bgp_evpn_derive_auto_rt_import(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3768 form_auto_rt(bgp
, vpn
->vni
, vpn
->import_rtl
);
3769 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
3772 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
3776 * Derive Export RT automatically for VNI.
3778 void bgp_evpn_derive_auto_rt_export(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3780 form_auto_rt(bgp
, vpn
->vni
, vpn
->export_rtl
);
3781 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
3785 * Derive RD automatically for VNI using passed information - it
3786 * is of the form RouterId:unique-id-for-vni.
3788 void bgp_evpn_derive_auto_rd_for_vrf(struct bgp
*bgp
)
3792 bgp
->vrf_prd
.family
= AF_UNSPEC
;
3793 bgp
->vrf_prd
.prefixlen
= 64;
3794 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), bgp
->vrf_rd_id
);
3795 str2prefix_rd(buf
, &bgp
->vrf_prd
);
3799 * Derive RD automatically for VNI using passed information - it
3800 * is of the form RouterId:unique-id-for-vni.
3802 void bgp_evpn_derive_auto_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3806 vpn
->prd
.family
= AF_UNSPEC
;
3807 vpn
->prd
.prefixlen
= 64;
3808 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), vpn
->rd_id
);
3809 (void)str2prefix_rd(buf
, &vpn
->prd
);
3810 UNSET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
3816 struct bgpevpn
*bgp_evpn_lookup_vni(struct bgp
*bgp
, vni_t vni
)
3818 struct bgpevpn
*vpn
;
3821 memset(&tmp
, 0, sizeof(struct bgpevpn
));
3823 vpn
= hash_lookup(bgp
->vnihash
, &tmp
);
3828 * Create a new vpn - invoked upon configuration or zebra notification.
3830 struct bgpevpn
*bgp_evpn_new(struct bgp
*bgp
, vni_t vni
,
3831 struct in_addr originator_ip
,
3832 vrf_id_t tenant_vrf_id
)
3834 struct bgpevpn
*vpn
;
3839 vpn
= XCALLOC(MTYPE_BGP_EVPN
, sizeof(struct bgpevpn
));
3843 /* Set values - RD and RT set to defaults. */
3845 vpn
->originator_ip
= originator_ip
;
3846 vpn
->tenant_vrf_id
= tenant_vrf_id
;
3848 /* Initialize route-target import and export lists */
3849 vpn
->import_rtl
= list_new();
3850 vpn
->import_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
3851 vpn
->export_rtl
= list_new();
3852 vpn
->export_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
3853 bf_assign_index(bm
->rd_idspace
, vpn
->rd_id
);
3854 derive_rd_rt_for_vni(bgp
, vpn
);
3856 /* Initialize EVPN route table. */
3857 vpn
->route_table
= bgp_table_init(AFI_L2VPN
, SAFI_EVPN
);
3860 if (!hash_get(bgp
->vnihash
, vpn
, hash_alloc_intern
)) {
3861 XFREE(MTYPE_BGP_EVPN
, vpn
);
3865 /* add to l2vni list on corresponding vrf */
3866 bgpevpn_link_to_l3vni(vpn
);
3868 QOBJ_REG(vpn
, bgpevpn
);
3873 * Free a given VPN - called in multiple scenarios such as zebra
3874 * notification, configuration being deleted, advertise-all-vni disabled etc.
3875 * This just frees appropriate memory, caller should have taken other
3878 void bgp_evpn_free(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3880 bgpevpn_unlink_from_l3vni(vpn
);
3881 bgp_table_unlock(vpn
->route_table
);
3882 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
3883 list_delete_and_null(&vpn
->import_rtl
);
3884 list_delete_and_null(&vpn
->export_rtl
);
3885 bf_release_index(bm
->rd_idspace
, vpn
->rd_id
);
3886 hash_release(bgp
->vnihash
, vpn
);
3888 XFREE(MTYPE_BGP_EVPN
, vpn
);
3892 * Import route into matching VNI(s).
3894 int bgp_evpn_import_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
3895 struct prefix
*p
, struct bgp_info
*ri
)
3897 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 1);
3901 * Unimport route from matching VNI(s).
3903 int bgp_evpn_unimport_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
3904 struct prefix
*p
, struct bgp_info
*ri
)
3906 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 0);
3909 /* filter routes which have martian next hops */
3910 int bgp_filter_evpn_routes_upon_martian_nh_change(struct bgp
*bgp
)
3914 struct bgp_node
*rd_rn
, *rn
;
3915 struct bgp_table
*table
;
3916 struct bgp_info
*ri
;
3921 /* Walk entire global routing table and evaluate routes which could be
3922 * imported into this VPN. Note that we cannot just look at the routes
3923 * for the VNI's RD -
3924 * remote routes applicable for this VNI could have any RD.
3926 /* EVPN routes are a 2-level table. */
3927 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
3928 rd_rn
= bgp_route_next(rd_rn
)) {
3929 table
= (struct bgp_table
*)(rd_rn
->info
);
3933 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
3935 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
3937 /* Consider "valid" remote routes applicable for
3939 if (!(ri
->type
== ZEBRA_ROUTE_BGP
3940 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
3943 if (bgp_nexthop_self(bgp
, ri
->attr
->nexthop
)) {
3945 char attr_str
[BUFSIZ
];
3946 char pbuf
[PREFIX_STRLEN
];
3948 bgp_dump_attr(ri
->attr
, attr_str
,
3951 if (bgp_debug_update(ri
->peer
, &rn
->p
,
3954 "%u: prefix %s with attr %s - DENIED due to martian or self nexthop",
3961 bgp_evpn_unimport_route(bgp
, afi
, safi
,
3964 bgp_rib_remove(rn
, ri
, ri
->peer
, afi
,
3975 * Handle del of a local MACIP.
3977 int bgp_evpn_local_macip_del(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
3980 struct bgpevpn
*vpn
;
3981 struct prefix_evpn p
;
3983 if (!bgp
->vnihash
) {
3984 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
3988 /* Lookup VNI hash - should exist. */
3989 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
3990 if (!vpn
|| !is_vni_live(vpn
)) {
3991 zlog_warn("%u: VNI hash entry for VNI %u %s at MACIP DEL",
3992 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
3996 /* Remove EVPN type-2 route and schedule for processing. */
3997 build_evpn_type2_prefix(&p
, mac
, ip
);
3998 delete_evpn_route(bgp
, vpn
, &p
);
4004 * Handle add of a local MACIP.
4006 int bgp_evpn_local_macip_add(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
4007 struct ipaddr
*ip
, u_char flags
)
4009 struct bgpevpn
*vpn
;
4010 struct prefix_evpn p
;
4012 if (!bgp
->vnihash
) {
4013 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4017 /* Lookup VNI hash - should exist. */
4018 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4019 if (!vpn
|| !is_vni_live(vpn
)) {
4020 zlog_warn("%u: VNI hash entry for VNI %u %s at MACIP ADD",
4021 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
4025 /* Create EVPN type-2 route and schedule for processing. */
4026 build_evpn_type2_prefix(&p
, mac
, ip
);
4027 if (update_evpn_route(bgp
, vpn
, &p
, flags
)) {
4028 char buf
[ETHER_ADDR_STRLEN
];
4029 char buf2
[INET6_ADDRSTRLEN
];
4032 "%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s",
4033 bgp
->vrf_id
, vpn
->vni
,
4034 CHECK_FLAG(flags
, ZEBRA_MAC_TYPE_STICKY
) ? "sticky gateway"
4036 prefix_mac2str(mac
, buf
, sizeof(buf
)),
4037 ipaddr2str(ip
, buf2
, sizeof(buf2
)));
4044 static void link_l2vni_hash_to_l3vni(struct hash_backet
*backet
,
4045 struct bgp
*bgp_vrf
)
4047 struct bgpevpn
*vpn
= NULL
;
4048 struct bgp
*bgp_def
= NULL
;
4050 bgp_def
= bgp_get_default();
4053 vpn
= (struct bgpevpn
*)backet
->data
;
4054 if (vpn
->tenant_vrf_id
== bgp_vrf
->vrf_id
)
4055 bgpevpn_link_to_l3vni(vpn
);
4058 int bgp_evpn_local_l3vni_add(vni_t l3vni
,
4060 struct ethaddr
*rmac
,
4061 struct in_addr originator_ip
)
4063 struct bgp
*bgp_vrf
= NULL
; /* bgp VRF instance */
4064 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
4065 struct listnode
*node
= NULL
;
4066 struct bgpevpn
*vpn
= NULL
;
4069 /* get the default instamce - required to get the AS number for VRF
4071 bgp_def
= bgp_get_default();
4073 zlog_err("Cannot process L3VNI %u ADD - default BGP instance not yet created",
4079 /* if the BGP vrf instance doesnt exist - create one */
4080 bgp_vrf
= bgp_lookup_by_name(vrf_id_to_name(vrf_id
));
4085 ret
= bgp_get(&bgp_vrf
, &as
, vrf_id_to_name(vrf_id
),
4086 BGP_INSTANCE_TYPE_VRF
);
4088 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
:
4089 zlog_err("'bgp multiple-instance' not present\n");
4091 case BGP_ERR_AS_MISMATCH
:
4092 zlog_err("BGP is already running; AS is %u\n", as
);
4094 case BGP_ERR_INSTANCE_MISMATCH
:
4095 zlog_err("BGP instance name and AS number mismatch\n");
4099 /* mark as auto created */
4100 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
);
4103 /* associate with l3vni */
4104 bgp_vrf
->l3vni
= l3vni
;
4106 /* set the router mac - to be used in mac-ip routes for this vrf */
4107 memcpy(&bgp_vrf
->rmac
, rmac
, sizeof(struct ethaddr
));
4109 /* set the originator ip */
4110 bgp_vrf
->originator_ip
= originator_ip
;
4112 /* auto derive RD/RT */
4113 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
4114 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
4115 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
))
4116 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
4117 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
4119 /* link all corresponding l2vnis */
4120 hash_iterate(bgp_def
->vnihash
,
4121 (void (*)(struct hash_backet
*, void *))
4122 link_l2vni_hash_to_l3vni
,
4125 /* updates all corresponding local mac-ip routes */
4126 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4127 update_routes_for_vni(bgp_def
, vpn
);
4129 /* advertise type-5 routes if needed */
4130 update_advertise_vrf_routes(bgp_vrf
);
4132 /* install all remote routes belonging to this l3vni into correspondng
4134 install_routes_for_vrf(bgp_vrf
);
4139 int bgp_evpn_local_l3vni_del(vni_t l3vni
,
4142 struct bgp
*bgp_vrf
= NULL
; /* bgp vrf instance */
4143 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
4144 struct listnode
*node
= NULL
;
4145 struct bgpevpn
*vpn
= NULL
;
4147 bgp_vrf
= bgp_lookup_by_vrf_id(vrf_id
);
4149 zlog_err("Cannot process L3VNI %u Del - Could not find BGP instance",
4154 bgp_def
= bgp_get_default();
4156 zlog_err("Cannot process L3VNI %u Del - Could not find default BGP instance",
4161 /* unimport remote routes from VRF, if it is AUTO vrf bgp_delete will
4162 * take care of uninstalling the routes from zebra */
4163 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
4164 uninstall_routes_for_vrf(bgp_vrf
);
4166 /* delete/withdraw all type-5 routes */
4167 delete_withdraw_vrf_routes(bgp_vrf
);
4169 /* remove the l3vni from vrf instance */
4172 /* remove the Rmac from the BGP vrf */
4173 memset(&bgp_vrf
->rmac
, 0, sizeof(struct ethaddr
));
4176 if (bgp_vrf
->vrf_import_rtl
&& !list_isempty(bgp_vrf
->vrf_import_rtl
)) {
4177 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4178 list_delete_all_node(bgp_vrf
->vrf_import_rtl
);
4180 if (bgp_vrf
->vrf_export_rtl
&& !list_isempty(bgp_vrf
->vrf_export_rtl
)) {
4181 list_delete_all_node(bgp_vrf
->vrf_export_rtl
);
4184 /* update all corresponding local mac-ip routes */
4185 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4186 update_routes_for_vni(bgp_def
, vpn
);
4189 /* Delete the instance if it was autocreated */
4190 if (CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
4191 bgp_delete(bgp_vrf
);
4197 * Handle del of a local VNI.
4199 int bgp_evpn_local_vni_del(struct bgp
*bgp
, vni_t vni
)
4201 struct bgpevpn
*vpn
;
4203 if (!bgp
->vnihash
) {
4204 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4208 /* Locate VNI hash */
4209 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4211 zlog_warn("%u: VNI hash entry for VNI %u not found at DEL",
4216 /* Remove all local EVPN routes and schedule for processing (to
4217 * withdraw from peers).
4219 delete_routes_for_vni(bgp
, vpn
);
4222 * tunnel is no longer active, del tunnel ip address from tip_hash
4224 bgp_tip_del(bgp
, &vpn
->originator_ip
);
4226 /* Clear "live" flag and see if hash needs to be freed. */
4227 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
4228 if (!is_vni_configured(vpn
))
4229 bgp_evpn_free(bgp
, vpn
);
4235 * Handle add (or update) of a local VNI. The only VNI change we care
4236 * about is change to local-tunnel-ip.
4238 int bgp_evpn_local_vni_add(struct bgp
*bgp
, vni_t vni
,
4239 struct in_addr originator_ip
,
4240 vrf_id_t tenant_vrf_id
)
4242 struct bgpevpn
*vpn
;
4243 struct prefix_evpn p
;
4245 if (!bgp
->vnihash
) {
4246 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4250 /* Lookup VNI. If present and no change, exit. */
4251 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4254 /* update tenant_vrf_id if required */
4255 if (vpn
->tenant_vrf_id
!= tenant_vrf_id
) {
4256 bgpevpn_unlink_from_l3vni(vpn
);
4257 vpn
->tenant_vrf_id
= tenant_vrf_id
;
4258 bgpevpn_link_to_l3vni(vpn
);
4260 /* update all routes with new export RT for VRFs */
4261 update_routes_for_vni(bgp
, vpn
);
4264 if (is_vni_live(vpn
)
4265 && IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
))
4266 /* Probably some other param has changed that we don't
4270 /* Local tunnel endpoint IP address has changed */
4271 handle_tunnel_ip_change(bgp
, vpn
, originator_ip
);
4274 /* Create or update as appropriate. */
4276 vpn
= bgp_evpn_new(bgp
, vni
, originator_ip
, tenant_vrf_id
);
4279 "%u: Failed to allocate VNI entry for VNI %u - at Add",
4285 /* if the VNI is live already, there is nothing more to do */
4286 if (is_vni_live(vpn
))
4289 /* Mark as "live" */
4290 SET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
4292 /* tunnel is now active, add tunnel-ip to db */
4293 bgp_tip_add(bgp
, &originator_ip
);
4295 /* filter routes as nexthop database has changed */
4296 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
4298 /* Create EVPN type-3 route and schedule for processing. */
4299 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
4300 if (update_evpn_route(bgp
, vpn
, &p
, 0)) {
4301 zlog_err("%u: Type3 route creation failure for VNI %u",
4306 /* If we have learnt and retained remote routes (VTEPs, MACs) for this
4310 install_routes_for_vni(bgp
, vpn
);
4312 /* If we are advertising gateway mac-ip
4313 It needs to be conveyed again to zebra */
4314 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
, vpn
->vni
);
4320 * Cleanup EVPN information on disable - Need to delete and withdraw
4321 * EVPN routes from peers.
4323 void bgp_evpn_cleanup_on_disable(struct bgp
*bgp
)
4325 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
4326 void *))cleanup_vni_on_disable
,
4331 * Cleanup EVPN information - invoked at the time of bgpd exit or when the
4332 * BGP instance (default) is being freed.
4334 void bgp_evpn_cleanup(struct bgp
*bgp
)
4337 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
4338 void *))free_vni_entry
,
4340 if (bgp
->import_rt_hash
)
4341 hash_free(bgp
->import_rt_hash
);
4342 bgp
->import_rt_hash
= NULL
;
4343 if (bgp
->vrf_import_rt_hash
)
4344 hash_free(bgp
->vrf_import_rt_hash
);
4345 bgp
->vrf_import_rt_hash
= NULL
;
4347 hash_free(bgp
->vnihash
);
4348 bgp
->vnihash
= NULL
;
4349 if (bgp
->vrf_import_rtl
)
4350 list_delete_and_null(&bgp
->vrf_import_rtl
);
4351 bgp
->vrf_import_rtl
= NULL
;
4352 if (bgp
->vrf_export_rtl
)
4353 list_delete_and_null(&bgp
->vrf_export_rtl
);
4354 bgp
->vrf_export_rtl
= NULL
;
4356 list_delete_and_null(&bgp
->l2vnis
);
4358 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
4362 * Initialization for EVPN
4365 * hash for RT to VNI
4366 * assign a unique rd id for auto derivation of vrf_prd
4368 void bgp_evpn_init(struct bgp
*bgp
)
4371 hash_create(vni_hash_key_make
, vni_hash_cmp
, "BGP VNI Hash");
4372 bgp
->import_rt_hash
=
4373 hash_create(import_rt_hash_key_make
, import_rt_hash_cmp
,
4374 "BGP Import RT Hash");
4375 bgp
->vrf_import_rt_hash
=
4376 hash_create(vrf_import_rt_hash_key_make
, vrf_import_rt_hash_cmp
,
4377 "BGP VRF Import RT Hash");
4378 bgp
->vrf_import_rtl
= list_new();
4379 bgp
->vrf_import_rtl
->cmp
=
4380 (int (*)(void *, void *))evpn_route_target_cmp
;
4382 bgp
->vrf_export_rtl
= list_new();
4383 bgp
->vrf_export_rtl
->cmp
=
4384 (int (*)(void *, void *))evpn_route_target_cmp
;
4385 bgp
->l2vnis
= list_new();
4387 (int (*)(void *, void *))vni_hash_cmp
;
4388 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
4392 void bgp_evpn_vrf_delete(struct bgp
*bgp_vrf
)
4394 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);