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
;
103 return jhash(pnt
, 8, 0x5abc1234);
107 * Comparison function for vrf import rt hash
109 static int vrf_import_rt_hash_cmp(const void *p1
, const void *p2
)
111 const struct vrf_irt_node
*irt1
= p1
;
112 const struct vrf_irt_node
*irt2
= p2
;
114 if (irt1
== NULL
&& irt2
== NULL
)
117 if (irt1
== NULL
|| irt2
== NULL
)
120 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
124 * Create a new vrf import_rt in default instance
126 static struct vrf_irt_node
*vrf_import_rt_new(struct ecommunity_val
*rt
)
128 struct bgp
*bgp_def
= NULL
;
129 struct vrf_irt_node
*irt
;
131 bgp_def
= bgp_get_default();
133 zlog_err("vrf import rt new - def instance not created yet");
137 irt
= XCALLOC(MTYPE_BGP_EVPN_VRF_IMPORT_RT
,
138 sizeof(struct vrf_irt_node
));
143 irt
->vrfs
= list_new();
146 if (!hash_get(bgp_def
->vrf_import_rt_hash
, irt
, hash_alloc_intern
)) {
147 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
155 * Free the vrf import rt node
157 static void vrf_import_rt_free(struct vrf_irt_node
*irt
)
159 struct bgp
*bgp_def
= NULL
;
161 bgp_def
= bgp_get_default();
163 zlog_err("vrf import rt free - def instance not created yet");
167 hash_release(bgp_def
->vrf_import_rt_hash
, irt
);
168 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
172 * Function to lookup Import RT node - used to map a RT to set of
173 * VNIs importing routes with that RT.
175 static struct vrf_irt_node
*lookup_vrf_import_rt(struct ecommunity_val
*rt
)
177 struct bgp
*bgp_def
= NULL
;
178 struct vrf_irt_node
*irt
;
179 struct vrf_irt_node tmp
;
181 bgp_def
= bgp_get_default();
183 zlog_err("vrf import rt lookup - def instance not created yet");
187 memset(&tmp
, 0, sizeof(struct vrf_irt_node
));
188 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
189 irt
= hash_lookup(bgp_def
->vrf_import_rt_hash
, &tmp
);
194 * Is specified VRF present on the RT's list of "importing" VRFs?
196 static int is_vrf_present_in_irt_vrfs(struct list
*vrfs
, struct bgp
*bgp_vrf
)
198 struct listnode
*node
= NULL
, *nnode
= NULL
;
199 struct bgp
*tmp_bgp_vrf
= NULL
;
201 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
202 if (tmp_bgp_vrf
== bgp_vrf
)
209 * Make import route target hash key.
211 static unsigned int import_rt_hash_key_make(void *p
)
213 struct irt_node
*irt
= p
;
214 char *pnt
= irt
->rt
.val
;
216 return jhash(pnt
, 8, 0xdeadbeef);
220 * Comparison function for import rt hash
222 static int import_rt_hash_cmp(const void *p1
, const void *p2
)
224 const struct irt_node
*irt1
= p1
;
225 const struct irt_node
*irt2
= p2
;
227 if (irt1
== NULL
&& irt2
== NULL
)
230 if (irt1
== NULL
|| irt2
== NULL
)
233 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
237 * Create a new import_rt
239 static struct irt_node
*import_rt_new(struct bgp
*bgp
,
240 struct ecommunity_val
*rt
)
242 struct irt_node
*irt
;
247 irt
= XCALLOC(MTYPE_BGP_EVPN_IMPORT_RT
, sizeof(struct irt_node
));
252 irt
->vnis
= list_new();
255 if (!hash_get(bgp
->import_rt_hash
, irt
, hash_alloc_intern
)) {
256 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
264 * Free the import rt node
266 static void import_rt_free(struct bgp
*bgp
, struct irt_node
*irt
)
268 hash_release(bgp
->import_rt_hash
, irt
);
269 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
273 * Function to lookup Import RT node - used to map a RT to set of
274 * VNIs importing routes with that RT.
276 static struct irt_node
*lookup_import_rt(struct bgp
*bgp
,
277 struct ecommunity_val
*rt
)
279 struct irt_node
*irt
;
282 memset(&tmp
, 0, sizeof(struct irt_node
));
283 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
284 irt
= hash_lookup(bgp
->import_rt_hash
, &tmp
);
289 * Is specified VNI present on the RT's list of "importing" VNIs?
291 static int is_vni_present_in_irt_vnis(struct list
*vnis
, struct bgpevpn
*vpn
)
293 struct listnode
*node
, *nnode
;
294 struct bgpevpn
*tmp_vpn
;
296 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, tmp_vpn
)) {
305 * Compare Route Targets.
307 static int evpn_route_target_cmp(struct ecommunity
*ecom1
,
308 struct ecommunity
*ecom2
)
316 if (!ecom1
&& !ecom2
)
319 if (ecom1
->str
&& !ecom2
->str
)
322 if (!ecom1
->str
&& ecom2
->str
)
325 if (!ecom1
->str
&& !ecom2
->str
)
328 return strcmp(ecom1
->str
, ecom2
->str
);
332 * Mask off global-admin field of specified extended community (RT),
333 * just retain the local-admin field.
335 static inline void mask_ecom_global_admin(struct ecommunity_val
*dst
,
336 struct ecommunity_val
*src
)
342 if (type
== ECOMMUNITY_ENCODE_AS
) {
343 dst
->val
[2] = dst
->val
[3] = 0;
344 } else if (type
== ECOMMUNITY_ENCODE_AS4
345 || type
== ECOMMUNITY_ENCODE_IP
) {
346 dst
->val
[2] = dst
->val
[3] = 0;
347 dst
->val
[4] = dst
->val
[5] = 0;
352 * Map one RT to specified VRF.
353 * bgp_vrf = BGP vrf instance
355 static void map_vrf_to_rt(struct bgp
*bgp_vrf
, struct ecommunity_val
*eval
)
357 struct vrf_irt_node
*irt
= NULL
;
358 struct ecommunity_val eval_tmp
;
360 /* If using "automatic" RT,
361 * we only care about the local-admin sub-field.
362 * This is to facilitate using L3VNI(VRF-VNI)
363 * as the RT for EBGP peering too.
365 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
366 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
367 mask_ecom_global_admin(&eval_tmp
, eval
);
369 irt
= lookup_vrf_import_rt(&eval_tmp
);
370 if (irt
&& irt
->vrfs
)
371 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
372 /* Already mapped. */
376 irt
= vrf_import_rt_new(&eval_tmp
);
380 /* Add VRF to the list for this RT. */
381 listnode_add(irt
->vrfs
, bgp_vrf
);
385 * Unmap specified VRF from specified RT. If there are no other
386 * VRFs for this RT, then the RT hash is deleted.
387 * bgp_vrf: BGP VRF specific instance
389 static void unmap_vrf_from_rt(struct bgp
*bgp_vrf
, struct vrf_irt_node
*irt
)
391 /* Delete VRF from list for this RT. */
392 listnode_delete(irt
->vrfs
, bgp_vrf
);
393 if (!listnode_head(irt
->vrfs
)) {
394 list_delete_and_null(&irt
->vrfs
);
395 vrf_import_rt_free(irt
);
400 * Map one RT to specified VNI.
402 static void map_vni_to_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
403 struct ecommunity_val
*eval
)
405 struct irt_node
*irt
;
406 struct ecommunity_val eval_tmp
;
408 /* If using "automatic" RT, we only care about the local-admin
410 * This is to facilitate using VNI as the RT for EBGP peering too.
412 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
413 if (!is_import_rt_configured(vpn
))
414 mask_ecom_global_admin(&eval_tmp
, eval
);
416 irt
= lookup_import_rt(bgp
, &eval_tmp
);
417 if (irt
&& irt
->vnis
)
418 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
419 /* Already mapped. */
423 irt
= import_rt_new(bgp
, &eval_tmp
);
427 /* Add VNI to the hash list for this RT. */
428 listnode_add(irt
->vnis
, vpn
);
432 * Unmap specified VNI from specified RT. If there are no other
433 * VNIs for this RT, then the RT hash is deleted.
435 static void unmap_vni_from_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
436 struct irt_node
*irt
)
438 /* Delete VNI from hash list for this RT. */
439 listnode_delete(irt
->vnis
, vpn
);
440 if (!listnode_head(irt
->vnis
)) {
441 list_delete_and_null(&irt
->vnis
);
442 import_rt_free(bgp
, irt
);
447 * Create RT extended community automatically from passed information:
448 * of the form AS:VNI.
449 * NOTE: We use only the lower 16 bits of the AS. This is sufficient as
450 * the need is to get a RT value that will be unique across different
451 * VNIs but the same across routers (in the same AS) for a particular
454 static void form_auto_rt(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
456 struct ecommunity_val eval
;
457 struct ecommunity
*ecomadd
;
459 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
461 ecomadd
= ecommunity_new();
462 ecommunity_add_val(ecomadd
, &eval
);
463 listnode_add_sort(rtl
, ecomadd
);
467 * Derive RD and RT for a VNI automatically. Invoked at the time of
470 static void derive_rd_rt_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
472 bgp_evpn_derive_auto_rd(bgp
, vpn
);
473 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
474 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
478 * Convert nexthop (remote VTEP IP) into an IPv6 address.
480 static void evpn_convert_nexthop_to_ipv6(struct attr
*attr
)
482 if (BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
484 ipv4_to_ipv4_mapped_ipv6(&attr
->mp_nexthop_global
, attr
->nexthop
);
485 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
489 * Add (update) or delete MACIP from zebra.
491 static int bgp_zebra_send_remote_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
492 struct prefix_evpn
*p
,
493 struct in_addr remote_vtep_ip
, int add
,
498 char buf1
[ETHER_ADDR_STRLEN
];
499 char buf2
[INET6_ADDRSTRLEN
];
500 char buf3
[INET6_ADDRSTRLEN
];
503 if (!zclient
|| zclient
->sock
< 0)
506 /* Don't try to register if Zebra doesn't know of this instance. */
507 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
513 zclient_create_header(
514 s
, add
? ZEBRA_REMOTE_MACIP_ADD
: ZEBRA_REMOTE_MACIP_DEL
,
516 stream_putl(s
, vpn
->vni
);
517 stream_put(s
, &p
->prefix
.mac
.octet
, ETH_ALEN
); /* Mac Addr */
518 /* IP address length and IP address, if any. */
519 if (IS_EVPN_PREFIX_IPADDR_NONE(p
))
522 ipa_len
= IS_EVPN_PREFIX_IPADDR_V4(p
) ? IPV4_MAX_BYTELEN
524 stream_putl(s
, ipa_len
);
525 stream_put(s
, &p
->prefix
.ip
.ip
.addr
, ipa_len
);
527 stream_put_in_addr(s
, &remote_vtep_ip
);
529 /* TX flags - MAC sticky status and/or gateway mac */
531 stream_putc(s
, flags
);
533 stream_putw_at(s
, 0, stream_get_endp(s
));
535 if (bgp_debug_zebra(NULL
))
537 "Tx %s MACIP, VNI %u MAC %s IP %s (flags: 0x%x) remote VTEP %s",
538 add
? "ADD" : "DEL", vpn
->vni
,
539 prefix_mac2str(&p
->prefix
.mac
, buf1
, sizeof(buf1
)),
540 ipaddr2str(&p
->prefix
.ip
, buf3
, sizeof(buf3
)), flags
,
541 inet_ntop(AF_INET
, &remote_vtep_ip
, buf2
,
544 return zclient_send_message(zclient
);
548 * Add (update) or delete remote VTEP from zebra.
550 static int bgp_zebra_send_remote_vtep(struct bgp
*bgp
, struct bgpevpn
*vpn
,
551 struct prefix_evpn
*p
, int add
)
556 if (!zclient
|| zclient
->sock
< 0)
559 /* Don't try to register if Zebra doesn't know of this instance. */
560 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
566 zclient_create_header(
567 s
, add
? ZEBRA_REMOTE_VTEP_ADD
: ZEBRA_REMOTE_VTEP_DEL
,
569 stream_putl(s
, vpn
->vni
);
570 if (IS_EVPN_PREFIX_IPADDR_V4(p
))
571 stream_put_in_addr(s
, &p
->prefix
.ip
.ipaddr_v4
);
572 else if (IS_EVPN_PREFIX_IPADDR_V6(p
)) {
574 "Bad remote IP when trying to %s remote VTEP for VNI %u",
575 add
? "ADD" : "DEL", vpn
->vni
);
579 stream_putw_at(s
, 0, stream_get_endp(s
));
581 if (bgp_debug_zebra(NULL
))
582 zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s",
583 add
? "ADD" : "DEL", vpn
->vni
,
584 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
));
586 return zclient_send_message(zclient
);
590 * Build extended communities for EVPN prefix route.
592 static void build_evpn_type5_route_extcomm(struct bgp
*bgp_vrf
,
595 struct ecommunity ecom_encap
;
596 struct ecommunity ecom_rmac
;
597 struct ecommunity_val eval
;
598 struct ecommunity_val eval_rmac
;
599 bgp_encap_types tnl_type
;
600 struct listnode
*node
, *nnode
;
601 struct ecommunity
*ecom
;
602 struct list
*vrf_export_rtl
= NULL
;
605 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
606 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
607 encode_encap_extcomm(tnl_type
, &eval
);
609 ecom_encap
.val
= (u_int8_t
*)eval
.val
;
612 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
614 /* Add the export RTs for L3VNI/VRF */
615 vrf_export_rtl
= bgp_vrf
->vrf_export_rtl
;
616 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
617 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
, ecom
))
619 ecommunity_merge(attr
->ecommunity
, ecom
);
622 /* add the router mac extended community */
623 if (!is_zero_mac(&attr
->rmac
)) {
624 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
625 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
627 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
629 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
632 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
636 * Build extended communities for EVPN route.
637 * This function is applicable for type-2 and type-3 routes. The layer-2 RT
638 * and ENCAP extended communities are applicable for all routes.
639 * The default gateway extended community and MAC mobility (sticky) extended
640 * community are added as needed based on passed settings - only for type-2
641 * routes. Likewise, the layer-3 RT and Router MAC extended communities are
642 * added, if present, based on passed settings - only for non-link-local
645 static void build_evpn_route_extcomm(struct bgpevpn
*vpn
, struct attr
*attr
,
648 struct ecommunity ecom_encap
;
649 struct ecommunity ecom_sticky
;
650 struct ecommunity ecom_default_gw
;
651 struct ecommunity ecom_rmac
;
652 struct ecommunity_val eval
;
653 struct ecommunity_val eval_sticky
;
654 struct ecommunity_val eval_default_gw
;
655 struct ecommunity_val eval_rmac
;
656 bgp_encap_types tnl_type
;
657 struct listnode
*node
, *nnode
;
658 struct ecommunity
*ecom
;
660 struct list
*vrf_export_rtl
= NULL
;
663 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
664 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
665 encode_encap_extcomm(tnl_type
, &eval
);
667 ecom_encap
.val
= (u_int8_t
*)eval
.val
;
670 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
672 /* Add the export RTs for L2VNI */
673 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
))
674 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
, ecom
);
676 /* Add the export RTs for L3VNI if told to - caller determines
677 * when this should be done.
680 vrf_export_rtl
= bgpevpn_get_vrf_export_rtl(vpn
);
681 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
682 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
,
684 attr
->ecommunity
= ecommunity_merge(
685 attr
->ecommunity
, ecom
);
689 /* Add MAC mobility (sticky) if needed. */
692 memset(&ecom_sticky
, 0, sizeof(ecom_sticky
));
693 encode_mac_mobility_extcomm(1, seqnum
, &eval_sticky
);
694 ecom_sticky
.size
= 1;
695 ecom_sticky
.val
= (u_int8_t
*)eval_sticky
.val
;
697 ecommunity_merge(attr
->ecommunity
, &ecom_sticky
);
700 /* Add RMAC, if told to. */
702 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
703 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
705 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
707 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
710 /* Add default gateway, if needed. */
711 if (attr
->default_gw
) {
712 memset(&ecom_default_gw
, 0, sizeof(ecom_default_gw
));
713 encode_default_gw_extcomm(&eval_default_gw
);
714 ecom_default_gw
.size
= 1;
715 ecom_default_gw
.val
= (uint8_t *)eval_default_gw
.val
;
717 ecommunity_merge(attr
->ecommunity
, &ecom_default_gw
);
720 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
724 * Add MAC mobility extended community to attribute.
726 static void add_mac_mobility_to_attr(u_int32_t seq_num
, struct attr
*attr
)
728 struct ecommunity ecom_tmp
;
729 struct ecommunity_val eval
;
730 u_int8_t
*ecom_val_ptr
;
737 encode_mac_mobility_extcomm(0, seq_num
, &eval
);
739 /* Find current MM ecommunity */
742 if (attr
->ecommunity
) {
743 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
744 pnt
= attr
->ecommunity
->val
+ (i
* 8);
748 if (type
== ECOMMUNITY_ENCODE_EVPN
750 == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY
) {
752 (u_int8_t
*)(attr
->ecommunity
->val
759 /* Update the existing MM ecommunity */
761 memcpy(ecom_val_ptr
, eval
.val
, sizeof(char) * ECOMMUNITY_SIZE
);
763 /* Add MM to existing */
765 memset(&ecom_tmp
, 0, sizeof(ecom_tmp
));
767 ecom_tmp
.val
= (u_int8_t
*)eval
.val
;
770 ecommunity_merge(attr
->ecommunity
, &ecom_tmp
);
774 /* Install EVPN route into zebra. */
775 static int evpn_zebra_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
776 struct prefix_evpn
*p
,
777 struct in_addr remote_vtep_ip
, u_char flags
)
781 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
782 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
785 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 1);
790 /* Uninstall EVPN route from zebra. */
791 static int evpn_zebra_uninstall(struct bgp
*bgp
, struct bgpevpn
*vpn
,
792 struct prefix_evpn
*p
,
793 struct in_addr remote_vtep_ip
)
797 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
798 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
801 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 0);
807 * Due to MAC mobility, the prior "local" best route has been supplanted
808 * by a "remote" best route. The prior route has to be deleted and withdrawn
811 static void evpn_delete_old_local_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
813 struct bgp_info
*old_local
)
815 struct bgp_node
*global_rn
;
817 afi_t afi
= AFI_L2VPN
;
818 safi_t safi
= SAFI_EVPN
;
820 /* Locate route node in the global EVPN routing table. Note that
821 * this table is a 2-level tree (RD-level + Prefix-level) similar to
824 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
825 (struct prefix
*)&rn
->p
, &vpn
->prd
);
827 /* Delete route entry in the global EVPN table. */
828 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, &ri
);
830 /* Schedule for processing - withdraws to peers happen from
834 bgp_process(bgp
, global_rn
, afi
, safi
);
835 bgp_unlock_node(global_rn
);
838 /* Delete route entry in the VNI route table, caller to remove. */
839 bgp_info_delete(rn
, old_local
);
843 * Calculate the best path for an EVPN route. Install/update best path in zebra,
846 static int evpn_route_select_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
849 struct bgp_info
*old_select
, *new_select
;
850 struct bgp_info_pair old_and_new
;
851 afi_t afi
= AFI_L2VPN
;
852 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 if (old_select
->attr
->sticky
)
874 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
875 if (old_select
->attr
->default_gw
)
876 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
877 ret
= evpn_zebra_install(
878 bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
879 old_select
->attr
->nexthop
, flags
);
881 UNSET_FLAG(old_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
882 bgp_zebra_clear_route_change_flags(rn
);
886 /* If the user did a "clear" this flag will be set */
887 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
889 /* bestpath has changed; update relevant fields and install or uninstall
890 * into the zebra RIB.
892 if (old_select
|| new_select
)
893 bgp_bump_version(rn
);
896 bgp_info_unset_flag(rn
, old_select
, BGP_INFO_SELECTED
);
898 bgp_info_set_flag(rn
, new_select
, BGP_INFO_SELECTED
);
899 bgp_info_unset_flag(rn
, new_select
, BGP_INFO_ATTR_CHANGED
);
900 UNSET_FLAG(new_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
903 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
904 && new_select
->sub_type
== BGP_ROUTE_NORMAL
) {
906 if (new_select
->attr
->sticky
)
907 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
908 if (new_select
->attr
->default_gw
)
909 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
910 ret
= evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
911 new_select
->attr
->nexthop
, flags
);
912 /* If an old best existed and it was a "local" route, the only
914 * it would be supplanted is due to MAC mobility procedures. So,
916 * need to do an implicit delete and withdraw that route from
919 if (old_select
&& old_select
->peer
== bgp
->peer_self
920 && old_select
->type
== ZEBRA_ROUTE_BGP
921 && old_select
->sub_type
== BGP_ROUTE_STATIC
)
922 evpn_delete_old_local_route(bgp
, vpn
, rn
, old_select
);
924 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
925 && old_select
->sub_type
== BGP_ROUTE_NORMAL
)
926 ret
= evpn_zebra_uninstall(bgp
, vpn
,
927 (struct prefix_evpn
*)&rn
->p
,
928 old_select
->attr
->nexthop
);
931 /* Clear any route change flags. */
932 bgp_zebra_clear_route_change_flags(rn
);
934 /* Reap old select bgp_info, if it has been removed */
935 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_INFO_REMOVED
))
936 bgp_info_reap(rn
, old_select
);
942 * Return true if the local ri for this rn is of type gateway mac
944 static int evpn_route_is_def_gw(struct bgp
*bgp
, struct bgp_node
*rn
)
946 struct bgp_info
*tmp_ri
= NULL
;
947 struct bgp_info
*local_ri
= NULL
;
950 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
951 if (tmp_ri
->peer
== bgp
->peer_self
952 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
953 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
960 return local_ri
->attr
->default_gw
;
965 * Return true if the local ri for this rn has sticky set
967 static int evpn_route_is_sticky(struct bgp
*bgp
, struct bgp_node
*rn
)
969 struct bgp_info
*tmp_ri
;
970 struct bgp_info
*local_ri
;
973 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
974 if (tmp_ri
->peer
== bgp
->peer_self
975 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
976 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
983 return local_ri
->attr
->sticky
;
986 static int update_evpn_type5_route_entry(struct bgp
*bgp_def
,
987 struct bgp
*bgp_vrf
, afi_t afi
,
988 safi_t safi
, struct bgp_node
*rn
,
989 struct attr
*attr
, int *route_changed
)
991 struct attr
*attr_new
= NULL
;
992 struct bgp_info
*ri
= NULL
;
993 mpls_label_t label
= MPLS_INVALID_LABEL
;
994 struct bgp_info
*local_ri
= NULL
;
995 struct bgp_info
*tmp_ri
= NULL
;
998 /* locate the local route entry if any */
999 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1000 if (tmp_ri
->peer
== bgp_def
->peer_self
1001 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1002 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1006 /* create a new route entry if one doesnt exist.
1007 Otherwise see if route attr has changed
1011 /* route has changed as this is the first entry */
1014 /* Add (or update) attribute to hash. */
1015 attr_new
= bgp_attr_intern(attr
);
1017 /* create the route info from attribute */
1018 ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1019 bgp_def
->peer_self
, attr_new
, rn
);
1020 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1022 /* Type-5 routes advertise the L3-VNI */
1023 bgp_info_extra_get(ri
);
1024 vni2label(bgp_vrf
->l3vni
, &label
);
1025 memcpy(&ri
->extra
->label
, &label
, sizeof(label
));
1026 ri
->extra
->num_labels
= 1;
1028 /* add the route entry to route node*/
1029 bgp_info_add(rn
, ri
);
1033 if (!attrhash_cmp(tmp_ri
->attr
, attr
)) {
1035 /* attribute changed */
1038 /* The attribute has changed. */
1039 /* Add (or update) attribute to hash. */
1040 attr_new
= bgp_attr_intern(attr
);
1041 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1043 /* Restore route, if needed. */
1044 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1045 bgp_info_restore(rn
, tmp_ri
);
1047 /* Unintern existing, set to new. */
1048 bgp_attr_unintern(&tmp_ri
->attr
);
1049 tmp_ri
->attr
= attr_new
;
1050 tmp_ri
->uptime
= bgp_clock();
1056 /* update evpn type-5 route entry */
1057 static int update_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
,
1058 struct attr
*src_attr
)
1060 afi_t afi
= AFI_L2VPN
;
1061 safi_t safi
= SAFI_EVPN
;
1063 struct bgp_node
*rn
= NULL
;
1064 struct bgp
*bgp_def
= NULL
;
1065 int route_changed
= 0;
1067 bgp_def
= bgp_get_default();
1071 /* Build path attribute for this route - use the source attr, if
1072 * present, else treat as locally originated.
1075 bgp_attr_dup(&attr
, src_attr
);
1077 memset(&attr
, 0, sizeof(struct attr
));
1078 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1080 /* Set nexthop to ourselves and fill in the Router MAC. */
1081 attr
.nexthop
= bgp_vrf
->originator_ip
;
1082 attr
.mp_nexthop_global_in
= bgp_vrf
->originator_ip
;
1083 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1084 memcpy(&attr
.rmac
, &bgp_vrf
->rmac
, sizeof(struct ethaddr
));
1086 /* Setup RT and encap extended community */
1087 build_evpn_type5_route_extcomm(bgp_vrf
, &attr
);
1089 /* get the route node in global table */
1090 rn
= bgp_afi_node_get(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1091 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1094 /* create or update the route entry within the route node */
1095 update_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &attr
,
1098 /* schedule for processing and unlock node */
1099 if (route_changed
) {
1100 bgp_process(bgp_def
, rn
, afi
, safi
);
1101 bgp_unlock_node(rn
);
1104 /* uninten temporary */
1106 aspath_unintern(&attr
.aspath
);
1111 * Create or update EVPN route entry. This could be in the VNI route table
1112 * or the global route table.
1114 static int update_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1115 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1116 struct attr
*attr
, int add
, int vni_table
,
1117 struct bgp_info
**ri
, u_char flags
)
1119 struct bgp_info
*tmp_ri
;
1120 struct bgp_info
*local_ri
, *remote_ri
;
1121 struct attr
*attr_new
;
1122 mpls_label_t label
[BGP_MAX_LABELS
];
1123 u_int32_t num_labels
= 1;
1124 int route_change
= 1;
1126 struct prefix_evpn
*evp
;
1129 evp
= (struct prefix_evpn
*)&rn
->p
;
1130 memset(&label
, 0, sizeof(label
));
1132 /* See if this is an update of an existing route, or a new add. Also,
1133 * identify if already known from remote, and if so, the one with the
1134 * highest sequence number; this is only when adding to the VNI routing
1137 local_ri
= remote_ri
= NULL
;
1138 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1139 if (tmp_ri
->peer
== bgp
->peer_self
1140 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1141 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1144 if (tmp_ri
->type
== ZEBRA_ROUTE_BGP
1145 && tmp_ri
->sub_type
== BGP_ROUTE_NORMAL
1146 && CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
)) {
1149 else if (mac_mobility_seqnum(tmp_ri
->attr
)
1150 > mac_mobility_seqnum(remote_ri
->attr
))
1156 /* If route doesn't exist already, create a new one, if told to.
1157 * Otherwise act based on whether the attributes of the route have
1160 if (!local_ri
&& !add
)
1164 /* When learnt locally for the first time but already known from
1165 * remote, we have to initiate appropriate MAC mobility steps.
1167 * is applicable when updating the VNI routing table.
1168 * We need to skip mobility steps for g/w macs (local mac on g/w
1169 * SVI) advertised in EVPN.
1170 * This will ensure that local routes are preferred for g/w macs
1172 if (remote_ri
&& !CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
)) {
1173 u_int32_t cur_seqnum
;
1175 /* Add MM extended community to route. */
1176 cur_seqnum
= mac_mobility_seqnum(remote_ri
->attr
);
1177 add_mac_mobility_to_attr(cur_seqnum
+ 1, attr
);
1180 /* Add (or update) attribute to hash. */
1181 attr_new
= bgp_attr_intern(attr
);
1183 /* Extract MAC mobility sequence number, if any. */
1184 attr_new
->mm_seqnum
=
1185 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1186 attr_new
->sticky
= sticky
;
1188 /* Create new route with its attribute. */
1189 tmp_ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1190 bgp
->peer_self
, attr_new
, rn
);
1191 SET_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
);
1192 bgp_info_extra_get(tmp_ri
);
1194 /* The VNI goes into the 'label' field of the route */
1195 vni2label(vpn
->vni
, &label
[0]);
1197 /* Type-2 routes may carry a second VNI - the L3-VNI.
1198 * Only attach second label if we are advertising two labels for
1201 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1202 && CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
)) {
1205 l3vni
= bgpevpn_get_l3vni(vpn
);
1207 vni2label(l3vni
, &label
[1]);
1212 memcpy(&tmp_ri
->extra
->label
, label
, sizeof(label
));
1213 tmp_ri
->extra
->num_labels
= num_labels
;
1214 bgp_info_add(rn
, tmp_ri
);
1217 if (attrhash_cmp(tmp_ri
->attr
, attr
)
1218 && !CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1222 * The attributes have changed, type-2 routes needs to
1223 * be advertised with right labels.
1225 vni2label(vpn
->vni
, &label
[0]);
1226 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1227 && CHECK_FLAG(vpn
->flags
,
1228 VNI_FLAG_USE_TWO_LABELS
)) {
1231 l3vni
= bgpevpn_get_l3vni(vpn
);
1233 vni2label(l3vni
, &label
[1]);
1237 memcpy(&tmp_ri
->extra
->label
, label
, sizeof(label
));
1238 tmp_ri
->extra
->num_labels
= num_labels
;
1240 /* The attribute has changed. */
1241 /* Add (or update) attribute to hash. */
1242 attr_new
= bgp_attr_intern(attr
);
1243 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1245 /* Restore route, if needed. */
1246 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1247 bgp_info_restore(rn
, tmp_ri
);
1249 /* Unintern existing, set to new. */
1250 bgp_attr_unintern(&tmp_ri
->attr
);
1251 tmp_ri
->attr
= attr_new
;
1252 tmp_ri
->uptime
= bgp_clock();
1256 /* Return back the route entry. */
1258 return route_change
;
1262 * Create or update EVPN route (of type based on prefix) for specified VNI
1263 * and schedule for processing.
1265 static int update_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1266 struct prefix_evpn
*p
, u_char flags
)
1268 struct bgp_node
*rn
;
1270 struct attr
*attr_new
;
1271 int add_l3_ecomm
= 0;
1272 struct bgp_info
*ri
;
1273 afi_t afi
= AFI_L2VPN
;
1274 safi_t safi
= SAFI_EVPN
;
1277 memset(&attr
, 0, sizeof(struct attr
));
1279 /* Build path-attribute for this route. */
1280 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1281 attr
.nexthop
= vpn
->originator_ip
;
1282 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1283 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1284 attr
.sticky
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
) ? 1 : 0;
1285 attr
.default_gw
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
) ? 1 : 0;
1287 /* PMSI is only needed for type-3 routes */
1288 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
)
1289 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
1291 /* router mac is only needed for type-2 routes here. */
1292 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1293 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1294 vni2label(vpn
->vni
, &(attr
.label
));
1296 /* Include L3 VNI related RTs and RMAC for type-2 routes, if they're
1297 * IPv4 or IPv6 global addresses and we're advertising L3VNI with
1300 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
&&
1301 (IS_EVPN_PREFIX_IPADDR_V4(p
) ||
1302 !IN6_IS_ADDR_LINKLOCAL(&p
->prefix
.ip
.ipaddr_v6
)) &&
1303 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
))
1306 /* Set up extended community. */
1307 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
1309 /* First, create (or fetch) route node within the VNI. */
1310 /* NOTE: There is no RD here. */
1311 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1313 /* Create or update route entry. */
1314 route_change
= update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
,
1317 attr_new
= ri
->attr
;
1319 /* Perform route selection; this is just to set the flags correctly
1320 * as local route in the VNI always wins.
1322 evpn_route_select_install(bgp
, vpn
, rn
);
1323 bgp_unlock_node(rn
);
1325 /* If this is a new route or some attribute has changed, export the
1326 * route to the global table. The route will be advertised to peers
1327 * from there. Note that this table is a 2-level tree (RD-level +
1328 * Prefix-level) similar to L3VPN routes.
1331 struct bgp_info
*global_ri
;
1333 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1334 (struct prefix
*)p
, &vpn
->prd
);
1335 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, attr_new
, 1, 0,
1338 /* Schedule for processing and unlock node. */
1339 bgp_process(bgp
, rn
, afi
, safi
);
1340 bgp_unlock_node(rn
);
1343 /* Unintern temporary. */
1344 aspath_unintern(&attr
.aspath
);
1349 /* Delete EVPN type5 route entry from global table */
1350 static void delete_evpn_type5_route_entry(struct bgp
*bgp_def
,
1351 struct bgp
*bgp_vrf
, afi_t afi
,
1352 safi_t safi
, struct bgp_node
*rn
,
1353 struct bgp_info
**ri
)
1355 struct bgp_info
*tmp_ri
= NULL
;
1359 /* find the matching route entry */
1360 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
)
1361 if (tmp_ri
->peer
== bgp_def
->peer_self
1362 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1363 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1368 /* Mark route for delete. */
1370 bgp_info_delete(rn
, tmp_ri
);
1373 /* Delete EVPN type5 route */
1374 static int delete_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
)
1376 afi_t afi
= AFI_L2VPN
;
1377 safi_t safi
= SAFI_EVPN
;
1378 struct bgp_node
*rn
= NULL
;
1379 struct bgp_info
*ri
= NULL
;
1380 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
1382 bgp_def
= bgp_get_default();
1386 /* locate the global route entry for this type-5 prefix */
1387 rn
= bgp_afi_node_lookup(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1388 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1392 delete_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &ri
);
1394 bgp_process(bgp_def
, rn
, afi
, safi
);
1395 bgp_unlock_node(rn
);
1400 * Delete EVPN route entry. This could be in the VNI route table
1401 * or the global route table.
1403 static void delete_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1404 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1405 struct bgp_info
**ri
)
1407 struct bgp_info
*tmp_ri
;
1411 /* Now, find matching route. */
1412 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
)
1413 if (tmp_ri
->peer
== bgp
->peer_self
1414 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1415 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1420 /* Mark route for delete. */
1422 bgp_info_delete(rn
, tmp_ri
);
1426 * Delete EVPN route (of type based on prefix) for specified VNI and
1427 * schedule for processing.
1429 static int delete_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1430 struct prefix_evpn
*p
)
1432 struct bgp_node
*rn
, *global_rn
;
1433 struct bgp_info
*ri
;
1434 afi_t afi
= AFI_L2VPN
;
1435 safi_t safi
= SAFI_EVPN
;
1437 /* First, locate the route node within the VNI. If it doesn't exist,
1439 * is nothing further to do.
1441 /* NOTE: There is no RD here. */
1442 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1446 /* Next, locate route node in the global EVPN routing table. Note that
1447 * this table is a 2-level tree (RD-level + Prefix-level) similar to
1450 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1451 (struct prefix
*)p
, &vpn
->prd
);
1453 /* Delete route entry in the global EVPN table. */
1454 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, &ri
);
1456 /* Schedule for processing - withdraws to peers happen from
1460 bgp_process(bgp
, global_rn
, afi
, safi
);
1461 bgp_unlock_node(global_rn
);
1464 /* Delete route entry in the VNI route table. This can just be removed.
1466 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &ri
);
1468 bgp_info_reap(rn
, ri
);
1469 bgp_unlock_node(rn
);
1475 * Update all type-2 (MACIP) local routes for this VNI - these should also
1476 * be scheduled for advertise to peers.
1478 static int update_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1482 struct bgp_node
*rn
;
1483 struct bgp_info
*ri
;
1485 struct attr attr_sticky
;
1486 struct attr attr_def_gw
;
1487 struct attr attr_ip6_ll
;
1488 struct attr
*attr_new
;
1489 int add_l3_ecomm
= 0;
1493 memset(&attr
, 0, sizeof(struct attr
));
1494 memset(&attr_sticky
, 0, sizeof(struct attr
));
1495 memset(&attr_def_gw
, 0, sizeof(struct attr
));
1496 memset(&attr_ip6_ll
, 0, sizeof(struct attr
));
1498 /* Build path-attribute - multiple type-2 routes for this VNI will share
1499 * the same path attribute, but we need separate structures for sticky
1500 * MACs, default gateway and IPv6 link-local addresses (no L3 RT/RMAC).
1502 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1503 bgp_attr_default_set(&attr_sticky
, BGP_ORIGIN_IGP
);
1504 bgp_attr_default_set(&attr_def_gw
, BGP_ORIGIN_IGP
);
1505 attr
.nexthop
= vpn
->originator_ip
;
1506 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1507 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1508 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1509 attr_sticky
.nexthop
= vpn
->originator_ip
;
1510 attr_sticky
.mp_nexthop_global_in
= vpn
->originator_ip
;
1511 attr_sticky
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1512 attr_sticky
.sticky
= 1;
1513 bgpevpn_get_rmac(vpn
, &attr_sticky
.rmac
);
1514 attr_def_gw
.nexthop
= vpn
->originator_ip
;
1515 attr_def_gw
.mp_nexthop_global_in
= vpn
->originator_ip
;
1516 attr_def_gw
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1517 attr_def_gw
.default_gw
= 1;
1518 bgpevpn_get_rmac(vpn
, &attr_def_gw
.rmac
);
1519 bgp_attr_default_set(&attr_ip6_ll
, BGP_ORIGIN_IGP
);
1520 attr_ip6_ll
.nexthop
= vpn
->originator_ip
;
1521 attr_ip6_ll
.mp_nexthop_global_in
= vpn
->originator_ip
;
1522 attr_ip6_ll
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1524 /* Add L3 VNI RTs and RMAC for non IPv6 link-local attributes if
1525 * using L3 VNI for type-2 routes also.
1527 if (CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
))
1530 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
1531 build_evpn_route_extcomm(vpn
, &attr_sticky
, add_l3_ecomm
);
1532 build_evpn_route_extcomm(vpn
, &attr_def_gw
, add_l3_ecomm
);
1533 build_evpn_route_extcomm(vpn
, &attr_ip6_ll
, 0);
1535 /* Walk this VNI's route table and update local type-2 routes. For any
1536 * routes updated, update corresponding entry in the global table too.
1538 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1539 rn
= bgp_route_next(rn
)) {
1540 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1541 struct bgp_node
*rd_rn
;
1542 struct bgp_info
*global_ri
;
1544 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1547 if (IS_EVPN_PREFIX_IPADDR_V6(evp
) &&
1548 IN6_IS_ADDR_LINKLOCAL(&evp
->prefix
.ip
.ipaddr_v6
))
1549 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1550 &attr_ip6_ll
, 0, 1, &ri
, 0);
1552 if (evpn_route_is_sticky(bgp
, rn
))
1553 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1554 &attr_sticky
, 0, 1, &ri
,
1556 else if (evpn_route_is_def_gw(bgp
, rn
))
1557 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1558 &attr_def_gw
, 0, 1, &ri
,
1561 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
1562 &attr
, 0, 1, &ri
, 0);
1565 /* If a local route exists for this prefix, we need to update
1566 * the global routing table too.
1571 /* Perform route selection; this is just to set the flags
1573 * as local route in the VNI always wins.
1575 evpn_route_select_install(bgp
, vpn
, rn
);
1577 attr_new
= ri
->attr
;
1579 /* Update route in global routing table. */
1580 rd_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1581 (struct prefix
*)evp
, &vpn
->prd
);
1583 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rd_rn
, attr_new
, 0,
1586 /* Schedule for processing and unlock node. */
1587 bgp_process(bgp
, rd_rn
, afi
, safi
);
1588 bgp_unlock_node(rd_rn
);
1591 /* Unintern temporary. */
1592 aspath_unintern(&attr
.aspath
);
1593 aspath_unintern(&attr_sticky
.aspath
);
1594 aspath_unintern(&attr_def_gw
.aspath
);
1595 aspath_unintern(&attr_ip6_ll
.aspath
);
1601 * Delete all type-2 (MACIP) local routes for this VNI - only from the
1602 * global routing table. These are also scheduled for withdraw from peers.
1604 static int delete_global_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1608 struct bgp_node
*rdrn
, *rn
;
1609 struct bgp_table
*table
;
1610 struct bgp_info
*ri
;
1615 rdrn
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)&vpn
->prd
);
1616 if (rdrn
&& rdrn
->info
) {
1617 table
= (struct bgp_table
*)rdrn
->info
;
1618 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
1619 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1621 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1624 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &ri
);
1626 bgp_process(bgp
, rn
, afi
, safi
);
1630 /* Unlock RD node. */
1632 bgp_unlock_node(rdrn
);
1638 * Delete all type-2 (MACIP) local routes for this VNI - from the global
1639 * table as well as the per-VNI route table.
1641 static int delete_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1645 struct bgp_node
*rn
;
1646 struct bgp_info
*ri
;
1651 /* First, walk the global route table for this VNI's type-2 local
1653 * EVPN routes are a 2-level table, first get the RD table.
1655 delete_global_type2_routes(bgp
, vpn
);
1657 /* Next, walk this VNI's route table and delete local type-2 routes. */
1658 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1659 rn
= bgp_route_next(rn
)) {
1660 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1662 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1665 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &ri
);
1667 /* Route entry in local table gets deleted immediately. */
1669 bgp_info_reap(rn
, ri
);
1676 * Delete all routes in the per-VNI route table.
1678 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1680 struct bgp_node
*rn
;
1681 struct bgp_info
*ri
, *nextri
;
1683 /* Walk this VNI's route table and delete all routes. */
1684 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1685 rn
= bgp_route_next(rn
)) {
1686 for (ri
= rn
->info
; (ri
!= NULL
) && (nextri
= ri
->next
, 1);
1688 bgp_info_delete(rn
, ri
);
1689 bgp_info_reap(rn
, ri
);
1697 * Update (and advertise) local routes for a VNI. Invoked upon the VNI
1698 * export RT getting modified or change to tunnel IP. Note that these
1699 * situations need the route in the per-VNI table as well as the global
1700 * table to be updated (as attributes change).
1702 static int update_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1705 struct prefix_evpn p
;
1707 /* Update and advertise the type-3 route (only one) followed by the
1708 * locally learnt type-2 routes (MACIP) - for this VNI.
1710 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
1711 ret
= update_evpn_route(bgp
, vpn
, &p
, 0);
1715 return update_all_type2_routes(bgp
, vpn
);
1719 * Delete (and withdraw) local routes for specified VNI from the global
1720 * table and per-VNI table. After this, remove all other routes from
1721 * the per-VNI table. Invoked upon the VNI being deleted or EVPN
1722 * (advertise-all-vni) being disabled.
1724 static int delete_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1727 struct prefix_evpn p
;
1729 /* Delete and withdraw locally learnt type-2 routes (MACIP)
1730 * followed by type-3 routes (only one) - for this VNI.
1732 ret
= delete_all_type2_routes(bgp
, vpn
);
1736 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
1737 ret
= delete_evpn_route(bgp
, vpn
, &p
);
1741 /* Delete all routes from the per-VNI table. */
1742 return delete_all_vni_routes(bgp
, vpn
);
1746 * There is a tunnel endpoint IP address change for this VNI, delete
1747 * prior type-3 route (if needed) and update.
1748 * Note: Route re-advertisement happens elsewhere after other processing
1751 static int handle_tunnel_ip_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1752 struct in_addr originator_ip
)
1754 struct prefix_evpn p
;
1756 /* If VNI is not live, we only need to update the originator ip */
1757 if (!is_vni_live(vpn
)) {
1758 vpn
->originator_ip
= originator_ip
;
1762 /* Update the tunnel-ip hash */
1763 bgp_tip_del(bgp
, &vpn
->originator_ip
);
1764 bgp_tip_add(bgp
, &originator_ip
);
1766 /* filter routes as martian nexthop db has changed */
1767 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
1769 /* Need to withdraw type-3 route as the originator IP is part
1772 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
1773 delete_evpn_route(bgp
, vpn
, &p
);
1775 /* Update the tunnel IP and re-advertise all routes for this VNI. */
1776 vpn
->originator_ip
= originator_ip
;
1781 * Install route entry into the VRF routing table and invoke route selection.
1783 static int install_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
1784 struct prefix_evpn
*evp
,
1785 struct bgp_info
*parent_ri
)
1787 struct bgp_node
*rn
;
1788 struct bgp_info
*ri
;
1790 struct attr
*attr_new
;
1793 struct prefix
*pp
= &p
;
1796 char buf
[PREFIX_STRLEN
];
1797 char buf1
[PREFIX_STRLEN
];
1799 memset(pp
, 0, sizeof(struct prefix
));
1800 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1801 ip_prefix_from_type2_prefix(evp
, pp
);
1802 else if (evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
)
1803 ip_prefix_from_type5_prefix(evp
, pp
);
1805 if (bgp_debug_zebra(NULL
)) {
1807 "installing evpn prefix %s as ip prefix %s in vrf %s",
1808 prefix2str(evp
, buf
, sizeof(buf
)),
1809 prefix2str(pp
, buf1
, sizeof(buf
)),
1810 vrf_id_to_name(bgp_vrf
->vrf_id
));
1813 /* Create (or fetch) route within the VRF. */
1814 /* NOTE: There is no RD here. */
1815 if (IS_EVPN_PREFIX_IPADDR_V4(evp
)) {
1817 safi
= SAFI_UNICAST
;
1818 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
1819 } else if (IS_EVPN_PREFIX_IPADDR_V6(evp
)) {
1821 safi
= SAFI_UNICAST
;
1822 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
1826 /* EVPN routes currently only support a IPv4 next hop which corresponds
1827 * to the remote VTEP. When importing into a VRF, if it is IPv6 host
1828 * route, we have to convert the next hop to an IPv4-mapped address
1829 * for the rest of the code to flow through.
1831 bgp_attr_dup(&attr
, parent_ri
->attr
);
1833 evpn_convert_nexthop_to_ipv6(&attr
);
1835 /* Check if route entry is already present. */
1836 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1838 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
1842 /* Add (or update) attribute to hash. */
1843 attr_new
= bgp_attr_intern(&attr
);
1845 /* Create new route with its attribute. */
1846 ri
= info_make(parent_ri
->type
, parent_ri
->sub_type
, 0,
1847 parent_ri
->peer
, attr_new
, rn
);
1848 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1849 bgp_info_extra_get(ri
);
1850 ri
->extra
->parent
= parent_ri
;
1851 if (parent_ri
->extra
) {
1852 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
1853 sizeof(ri
->extra
->label
));
1854 ri
->extra
->num_labels
= parent_ri
->extra
->num_labels
;
1856 bgp_info_add(rn
, ri
);
1858 if (attrhash_cmp(ri
->attr
, &attr
)
1859 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
1860 bgp_unlock_node(rn
);
1863 /* The attribute has changed. */
1864 /* Add (or update) attribute to hash. */
1865 attr_new
= bgp_attr_intern(&attr
);
1867 /* Restore route, if needed. */
1868 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
1869 bgp_info_restore(rn
, ri
);
1871 /* Mark if nexthop has changed. */
1872 if ((afi
== AFI_IP
&&
1873 !IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
)) ||
1875 !IPV6_ADDR_SAME(&ri
->attr
->mp_nexthop_global
,
1876 &attr_new
->mp_nexthop_global
)))
1877 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
1879 /* Unintern existing, set to new. */
1880 bgp_attr_unintern(&ri
->attr
);
1881 ri
->attr
= attr_new
;
1882 ri
->uptime
= bgp_clock();
1885 /* Perform route selection and update zebra, if required. */
1886 bgp_process(bgp_vrf
, rn
, afi
, safi
);
1892 * Install route entry into the VNI routing table and invoke route selection.
1894 static int install_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1895 struct prefix_evpn
*p
,
1896 struct bgp_info
*parent_ri
)
1898 struct bgp_node
*rn
;
1899 struct bgp_info
*ri
;
1900 struct attr
*attr_new
;
1903 /* Create (or fetch) route within the VNI. */
1904 /* NOTE: There is no RD here. */
1905 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1907 /* Check if route entry is already present. */
1908 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
1910 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
1914 /* Add (or update) attribute to hash. */
1915 attr_new
= bgp_attr_intern(parent_ri
->attr
);
1917 /* Create new route with its attribute. */
1918 ri
= info_make(parent_ri
->type
, parent_ri
->sub_type
, 0,
1919 parent_ri
->peer
, attr_new
, rn
);
1920 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1921 bgp_info_extra_get(ri
);
1922 ri
->extra
->parent
= parent_ri
;
1923 if (parent_ri
->extra
) {
1924 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
1925 sizeof(ri
->extra
->label
));
1926 ri
->extra
->num_labels
= parent_ri
->extra
->num_labels
;
1928 bgp_info_add(rn
, ri
);
1930 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
1931 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
1932 bgp_unlock_node(rn
);
1935 /* The attribute has changed. */
1936 /* Add (or update) attribute to hash. */
1937 attr_new
= bgp_attr_intern(parent_ri
->attr
);
1939 /* Restore route, if needed. */
1940 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
1941 bgp_info_restore(rn
, ri
);
1943 /* Mark if nexthop has changed. */
1944 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
1945 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
1947 /* Unintern existing, set to new. */
1948 bgp_attr_unintern(&ri
->attr
);
1949 ri
->attr
= attr_new
;
1950 ri
->uptime
= bgp_clock();
1953 /* Perform route selection and update zebra, if required. */
1954 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
1960 * Uninstall route entry from the VRF routing table and send message
1961 * to zebra, if appropriate.
1963 static int uninstall_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
1964 struct prefix_evpn
*evp
,
1965 struct bgp_info
*parent_ri
)
1967 struct bgp_node
*rn
;
1968 struct bgp_info
*ri
;
1971 struct prefix
*pp
= &p
;
1974 char buf
[PREFIX_STRLEN
];
1975 char buf1
[PREFIX_STRLEN
];
1977 memset(pp
, 0, sizeof(struct prefix
));
1978 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1979 ip_prefix_from_type2_prefix(evp
, pp
);
1980 else if (evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
)
1981 ip_prefix_from_type5_prefix(evp
, pp
);
1983 if (bgp_debug_zebra(NULL
)) {
1985 "uninstalling evpn prefix %s as ip prefix %s in vrf %s",
1986 prefix2str(evp
, buf
, sizeof(buf
)),
1987 prefix2str(pp
, buf1
, sizeof(buf
)),
1988 vrf_id_to_name(bgp_vrf
->vrf_id
));
1991 /* Locate route within the VRF. */
1992 /* NOTE: There is no RD here. */
1993 if (IS_EVPN_PREFIX_IPADDR_V4(evp
)) {
1995 safi
= SAFI_UNICAST
;
1996 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
1999 safi
= SAFI_UNICAST
;
2000 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2006 /* Find matching route entry. */
2007 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2009 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2015 /* Mark entry for deletion */
2016 bgp_info_delete(rn
, ri
);
2018 /* Perform route selection and update zebra, if required. */
2019 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2021 /* Unlock route node. */
2022 bgp_unlock_node(rn
);
2028 * Uninstall route entry from the VNI routing table and send message
2029 * to zebra, if appropriate.
2031 static int uninstall_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2032 struct prefix_evpn
*p
,
2033 struct bgp_info
*parent_ri
)
2035 struct bgp_node
*rn
;
2036 struct bgp_info
*ri
;
2039 /* Locate route within the VNI. */
2040 /* NOTE: There is no RD here. */
2041 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
2045 /* Find matching route entry. */
2046 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2048 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2054 /* Mark entry for deletion */
2055 bgp_info_delete(rn
, ri
);
2057 /* Perform route selection and update zebra, if required. */
2058 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2060 /* Unlock route node. */
2061 bgp_unlock_node(rn
);
2067 * Given a route entry and a VRF, see if this route entry should be
2068 * imported into the VRF i.e., RTs match.
2070 static int is_route_matching_for_vrf(struct bgp
*bgp_vrf
, struct bgp_info
*ri
)
2072 struct attr
*attr
= ri
->attr
;
2073 struct ecommunity
*ecom
;
2077 /* Route should have valid RT to be even considered. */
2078 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2081 ecom
= attr
->ecommunity
;
2082 if (!ecom
|| !ecom
->size
)
2085 /* For each extended community RT, see if it matches this VNI. If any RT
2086 * matches, we're done.
2088 for (i
= 0; i
< ecom
->size
; i
++) {
2090 u_char type
, sub_type
;
2091 struct ecommunity_val
*eval
;
2092 struct ecommunity_val eval_tmp
;
2093 struct vrf_irt_node
*irt
;
2095 /* Only deal with RTs */
2096 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2097 eval
= (struct ecommunity_val
*)(ecom
->val
2098 + (i
* ECOMMUNITY_SIZE
));
2101 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2104 /* See if this RT matches specified VNIs import RTs */
2105 irt
= lookup_vrf_import_rt(eval
);
2106 if (irt
&& irt
->vrfs
)
2107 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2110 /* Also check for non-exact match. In this, we mask out the AS
2112 * only check on the local-admin sub-field. This is to
2114 * VNI as the RT for EBGP peering too.
2117 if (type
== ECOMMUNITY_ENCODE_AS
2118 || type
== ECOMMUNITY_ENCODE_AS4
2119 || type
== ECOMMUNITY_ENCODE_IP
) {
2120 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2121 mask_ecom_global_admin(&eval_tmp
, eval
);
2122 irt
= lookup_vrf_import_rt(&eval_tmp
);
2124 if (irt
&& irt
->vrfs
)
2125 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2133 * Given a route entry and a VNI, see if this route entry should be
2134 * imported into the VNI i.e., RTs match.
2136 static int is_route_matching_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2137 struct bgp_info
*ri
)
2139 struct attr
*attr
= ri
->attr
;
2140 struct ecommunity
*ecom
;
2144 /* Route should have valid RT to be even considered. */
2145 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2148 ecom
= attr
->ecommunity
;
2149 if (!ecom
|| !ecom
->size
)
2152 /* For each extended community RT, see if it matches this VNI. If any RT
2153 * matches, we're done.
2155 for (i
= 0; i
< ecom
->size
; i
++) {
2157 u_char type
, sub_type
;
2158 struct ecommunity_val
*eval
;
2159 struct ecommunity_val eval_tmp
;
2160 struct irt_node
*irt
;
2162 /* Only deal with RTs */
2163 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2164 eval
= (struct ecommunity_val
*)(ecom
->val
2165 + (i
* ECOMMUNITY_SIZE
));
2168 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2171 /* See if this RT matches specified VNIs import RTs */
2172 irt
= lookup_import_rt(bgp
, eval
);
2173 if (irt
&& irt
->vnis
)
2174 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2177 /* Also check for non-exact match. In this, we mask out the AS
2179 * only check on the local-admin sub-field. This is to
2181 * VNI as the RT for EBGP peering too.
2184 if (type
== ECOMMUNITY_ENCODE_AS
2185 || type
== ECOMMUNITY_ENCODE_AS4
2186 || type
== ECOMMUNITY_ENCODE_IP
) {
2187 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2188 mask_ecom_global_admin(&eval_tmp
, eval
);
2189 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2191 if (irt
&& irt
->vnis
)
2192 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2200 * Install or uninstall mac-ip routes are appropriate for this
2203 static int install_uninstall_routes_for_vrf(struct bgp
*bgp_vrf
, int install
)
2207 struct bgp_node
*rd_rn
, *rn
;
2208 struct bgp_table
*table
;
2209 struct bgp_info
*ri
;
2211 char buf
[PREFIX_STRLEN
];
2212 struct bgp
*bgp_def
= NULL
;
2216 bgp_def
= bgp_get_default();
2220 /* Walk entire global routing table and evaluate routes which could be
2221 * imported into this VRF. Note that we need to loop through all global
2222 * routes to determine which route matches the import rt on vrf
2224 for (rd_rn
= bgp_table_top(bgp_def
->rib
[afi
][safi
]); rd_rn
;
2225 rd_rn
= bgp_route_next(rd_rn
)) {
2226 table
= (struct bgp_table
*)(rd_rn
->info
);
2230 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2231 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2233 /* if not mac-ip route skip this route */
2234 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2235 || evp
->prefix
.route_type
2236 == BGP_EVPN_IP_PREFIX_ROUTE
))
2239 /* if not a mac+ip route skip this route */
2240 if (!(IS_EVPN_PREFIX_IPADDR_V4(evp
)
2241 || IS_EVPN_PREFIX_IPADDR_V6(evp
)))
2244 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2245 /* Consider "valid" remote routes applicable for
2248 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2249 && ri
->type
== ZEBRA_ROUTE_BGP
2250 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2253 if (is_route_matching_for_vrf(bgp_vrf
, ri
)) {
2255 ret
= install_evpn_route_entry_in_vrf(
2258 ret
= uninstall_evpn_route_entry_in_vrf(
2263 "Failed to %s EVPN %s route in VRF %s",
2266 prefix2str(evp
, buf
,
2281 * Install or uninstall routes of specified type that are appropriate for this
2284 static int install_uninstall_routes_for_vni(struct bgp
*bgp
,
2285 struct bgpevpn
*vpn
,
2286 bgp_evpn_route_type rtype
,
2291 struct bgp_node
*rd_rn
, *rn
;
2292 struct bgp_table
*table
;
2293 struct bgp_info
*ri
;
2299 /* Walk entire global routing table and evaluate routes which could be
2300 * imported into this VPN. Note that we cannot just look at the routes
2302 * the VNI's RD - remote routes applicable for this VNI could have any
2305 /* EVPN routes are a 2-level table. */
2306 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2307 rd_rn
= bgp_route_next(rd_rn
)) {
2308 table
= (struct bgp_table
*)(rd_rn
->info
);
2312 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2313 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2315 if (evp
->prefix
.route_type
!= rtype
)
2318 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2319 /* Consider "valid" remote routes applicable for
2321 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2322 && ri
->type
== ZEBRA_ROUTE_BGP
2323 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2326 if (is_route_matching_for_vni(bgp
, vpn
, ri
)) {
2328 ret
= install_evpn_route_entry(
2331 ret
= uninstall_evpn_route_entry(
2336 "%u: Failed to %s EVPN %s route in VNI %u",
2340 rtype
== BGP_EVPN_MAC_IP_ROUTE
2354 /* Install any existing remote routes applicable for this VRF into VRF RIB. This
2355 * is invoked upon l3vni-add or l3vni import rt change
2357 static int install_routes_for_vrf(struct bgp
*bgp_vrf
)
2359 install_uninstall_routes_for_vrf(bgp_vrf
, 1);
2364 * Install any existing remote routes applicable for this VNI into its
2365 * routing table. This is invoked when a VNI becomes "live" or its Import
2368 static int install_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2372 /* Install type-3 routes followed by type-2 routes - the ones applicable
2375 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
2380 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
2384 /* uninstall routes from l3vni vrf. */
2385 static int uninstall_routes_for_vrf(struct bgp
*bgp_vrf
)
2387 install_uninstall_routes_for_vrf(bgp_vrf
, 0);
2392 * Uninstall any existing remote routes for this VNI. One scenario in which
2393 * this is invoked is upon an import RT change.
2395 static int uninstall_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2399 /* Uninstall type-2 routes followed by type-3 routes - the ones
2403 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
2408 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
2413 * Install or uninstall route in matching VRFs (list).
2415 static int install_uninstall_route_in_vrfs(struct bgp
*bgp_def
, afi_t afi
,
2416 safi_t safi
, struct prefix_evpn
*evp
,
2417 struct bgp_info
*ri
,
2418 struct list
*vrfs
, int install
)
2420 char buf
[PREFIX2STR_BUFFER
];
2421 struct bgp
*bgp_vrf
;
2422 struct listnode
*node
, *nnode
;
2424 /* Only type-2/type-5 routes go into a VRF */
2425 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2426 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
2429 /* if it is type-2 route and not a mac+ip route skip this route */
2430 if ((evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
2431 && !(IS_EVPN_PREFIX_IPADDR_V4(evp
)
2432 || IS_EVPN_PREFIX_IPADDR_V6(evp
)))
2435 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, bgp_vrf
)) {
2439 ret
= install_evpn_route_entry_in_vrf(bgp_vrf
, evp
, ri
);
2441 ret
= uninstall_evpn_route_entry_in_vrf(bgp_vrf
, evp
,
2445 zlog_err("%u: Failed to %s prefix %s in VRF %s",
2447 install
? "install" : "uninstall",
2448 prefix2str(evp
, buf
, sizeof(buf
)),
2449 vrf_id_to_name(bgp_vrf
->vrf_id
));
2458 * Install or uninstall route in matching VNIs (list).
2460 static int install_uninstall_route_in_vnis(struct bgp
*bgp
, afi_t afi
,
2461 safi_t safi
, struct prefix_evpn
*evp
,
2462 struct bgp_info
*ri
,
2463 struct list
*vnis
, int install
)
2465 struct bgpevpn
*vpn
;
2466 struct listnode
*node
, *nnode
;
2468 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, vpn
)) {
2471 if (!is_vni_live(vpn
))
2475 ret
= install_evpn_route_entry(bgp
, vpn
, evp
, ri
);
2477 ret
= uninstall_evpn_route_entry(bgp
, vpn
, evp
, ri
);
2480 zlog_err("%u: Failed to %s EVPN %s route in VNI %u",
2481 bgp
->vrf_id
, install
? "install" : "uninstall",
2482 evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2494 * Install or uninstall route for appropriate VNIs.
2496 static int install_uninstall_evpn_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
2497 struct prefix
*p
, struct bgp_info
*ri
,
2500 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
2501 struct attr
*attr
= ri
->attr
;
2502 struct ecommunity
*ecom
;
2507 /* Only type-2 and type-3 and type-5 are supported currently */
2508 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2509 || evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
2510 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
2513 /* If we don't have Route Target, nothing much to do. */
2514 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2517 ecom
= attr
->ecommunity
;
2518 if (!ecom
|| !ecom
->size
)
2521 /* For each extended community RT, see which VNIs/VRFs match and import
2522 * the route into matching VNIs/VRFs.
2524 for (i
= 0; i
< ecom
->size
; i
++) {
2526 u_char type
, sub_type
;
2527 struct ecommunity_val
*eval
;
2528 struct ecommunity_val eval_tmp
;
2529 struct irt_node
*irt
; /* import rt for l2vni */
2530 struct vrf_irt_node
*vrf_irt
; /* import rt for l3vni */
2532 /* Only deal with RTs */
2533 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2534 eval
= (struct ecommunity_val
*)(ecom
->val
2535 + (i
* ECOMMUNITY_SIZE
));
2538 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2541 /* Import route into matching l2-vnis (type-2/type-3 routes go
2544 irt
= lookup_import_rt(bgp
, eval
);
2545 if (irt
&& irt
->vnis
)
2546 install_uninstall_route_in_vnis(bgp
, afi
, safi
, evp
, ri
,
2549 /* Import route into matching l3-vnis (type-2/type-5 routes go
2550 * into l3vni/vrf table)
2552 vrf_irt
= lookup_vrf_import_rt(eval
);
2553 if (vrf_irt
&& vrf_irt
->vrfs
)
2554 install_uninstall_route_in_vrfs(bgp
, afi
, safi
, evp
, ri
,
2555 vrf_irt
->vrfs
, import
);
2557 /* Also check for non-exact match. In this,
2558 * we mask out the AS and
2559 * only check on the local-admin sub-field.
2560 * This is to facilitate using
2561 * VNI as the RT for EBGP peering too.
2565 if (type
== ECOMMUNITY_ENCODE_AS
2566 || type
== ECOMMUNITY_ENCODE_AS4
2567 || type
== ECOMMUNITY_ENCODE_IP
) {
2568 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2569 mask_ecom_global_admin(&eval_tmp
, eval
);
2570 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2571 vrf_irt
= lookup_vrf_import_rt(&eval_tmp
);
2573 if (irt
&& irt
->vnis
)
2574 install_uninstall_route_in_vnis(bgp
, afi
, safi
, evp
, ri
,
2576 if (vrf_irt
&& vrf_irt
->vrfs
)
2577 install_uninstall_route_in_vrfs(bgp
, afi
, safi
, evp
, ri
,
2578 vrf_irt
->vrfs
, import
);
2584 /* delete and withdraw all ipv4 and ipv6 routes in the vrf table as type-5
2586 static void delete_withdraw_vrf_routes(struct bgp
*bgp_vrf
)
2588 /* delete all ipv4 routes and withdraw from peers */
2589 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
2590 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
2592 /* delete all ipv6 routes and withdraw from peers */
2593 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
2594 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
2597 /* update and advertise all ipv4 and ipv6 routes in thr vrf table as type-5
2599 static void update_advertise_vrf_routes(struct bgp
*bgp_vrf
)
2601 /* update all ipv4 routes */
2602 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
2603 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
2605 /* update all ipv6 routes */
2606 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
2607 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
2611 * update and advertise local routes for a VRF as type-5 routes.
2612 * This is invoked upon RD change for a VRF. Note taht the processing is only
2613 * done in the global route table using the routes which already exist in the
2616 static void update_router_id_vrf(struct bgp
*bgp_vrf
)
2618 /* skip if the RD is configured */
2619 if (is_vrf_rd_configured(bgp_vrf
))
2622 /* derive the RD for the VRF based on new router-id */
2623 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
2625 /* update advertise ipv4|ipv6 routes as type-5 routes */
2626 update_advertise_vrf_routes(bgp_vrf
);
2630 * Delete and withdraw all type-5 routes for the RD corresponding to VRF.
2631 * This is invoked upon VRF RD change. The processing is done only from global
2634 static void withdraw_router_id_vrf(struct bgp
*bgp_vrf
)
2636 /* skip if the RD is configured */
2637 if (is_vrf_rd_configured(bgp_vrf
))
2640 /* delete/withdraw ipv4|ipv6 routes as type-5 routes */
2641 delete_withdraw_vrf_routes(bgp_vrf
);
2645 * Update and advertise local routes for a VNI. Invoked upon router-id
2646 * change. Note that the processing is done only on the global route table
2647 * using routes that already exist in the per-VNI table.
2649 static int update_advertise_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2651 struct prefix_evpn p
;
2652 struct bgp_node
*rn
, *global_rn
;
2653 struct bgp_info
*ri
, *global_ri
;
2655 afi_t afi
= AFI_L2VPN
;
2656 safi_t safi
= SAFI_EVPN
;
2658 /* Locate type-3 route for VNI in the per-VNI table and use its
2659 * attributes to create and advertise the type-3 route for this VNI
2660 * in the global table.
2662 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2663 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)&p
);
2664 if (!rn
) /* unexpected */
2666 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2667 if (ri
->peer
== bgp
->peer_self
&& ri
->type
== ZEBRA_ROUTE_BGP
2668 && ri
->sub_type
== BGP_ROUTE_STATIC
)
2670 if (!ri
) /* unexpected */
2674 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2675 (struct prefix
*)&p
, &vpn
->prd
);
2676 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1, 0, &ri
,
2679 /* Schedule for processing and unlock node. */
2680 bgp_process(bgp
, global_rn
, afi
, safi
);
2681 bgp_unlock_node(global_rn
);
2683 /* Now, walk this VNI's route table and use the route and its attribute
2684 * to create and schedule route in global table.
2686 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2687 rn
= bgp_route_next(rn
)) {
2688 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2690 /* Identify MAC-IP local routes. */
2691 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2694 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2695 if (ri
->peer
== bgp
->peer_self
2696 && ri
->type
== ZEBRA_ROUTE_BGP
2697 && ri
->sub_type
== BGP_ROUTE_STATIC
)
2702 /* Create route in global routing table using this route entry's
2706 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2707 (struct prefix
*)evp
, &vpn
->prd
);
2709 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1,
2712 /* Schedule for processing and unlock node. */
2713 bgp_process(bgp
, global_rn
, afi
, safi
);
2714 bgp_unlock_node(global_rn
);
2721 * Delete (and withdraw) local routes for a VNI - only from the global
2722 * table. Invoked upon router-id change.
2724 static int delete_withdraw_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2727 struct prefix_evpn p
;
2728 struct bgp_node
*global_rn
;
2729 struct bgp_info
*ri
;
2730 afi_t afi
= AFI_L2VPN
;
2731 safi_t safi
= SAFI_EVPN
;
2733 /* Delete and withdraw locally learnt type-2 routes (MACIP)
2734 * for this VNI - from the global table.
2736 ret
= delete_global_type2_routes(bgp
, vpn
);
2740 /* Remove type-3 route for this VNI from global table. */
2741 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2742 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
2743 (struct prefix
*)&p
, &vpn
->prd
);
2745 /* Delete route entry in the global EVPN table. */
2746 delete_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, &ri
);
2748 /* Schedule for processing - withdraws to peers happen from
2752 bgp_process(bgp
, global_rn
, afi
, safi
);
2753 bgp_unlock_node(global_rn
);
2760 * Handle router-id change. Update and advertise local routes corresponding
2761 * to this VNI from peers. Note that this is invoked after updating the
2762 * router-id. The routes in the per-VNI table are used to create routes in
2763 * the global table and schedule them.
2765 static void update_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
2767 struct bgpevpn
*vpn
;
2769 vpn
= (struct bgpevpn
*)backet
->data
;
2772 zlog_warn("%s: VNI hash entry for VNI not found", __FUNCTION__
);
2776 /* Skip VNIs with configured RD. */
2777 if (is_rd_configured(vpn
))
2780 bgp_evpn_derive_auto_rd(bgp
, vpn
);
2781 update_advertise_vni_routes(bgp
, vpn
);
2785 * Handle router-id change. Delete and withdraw local routes corresponding
2786 * to this VNI from peers. Note that this is invoked prior to updating
2787 * the router-id and is done only on the global route table, the routes
2788 * are needed in the per-VNI table to re-advertise with new router id.
2790 static void withdraw_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
2792 struct bgpevpn
*vpn
;
2794 vpn
= (struct bgpevpn
*)backet
->data
;
2797 zlog_warn("%s: VNI hash entry for VNI not found", __FUNCTION__
);
2801 /* Skip VNIs with configured RD. */
2802 if (is_rd_configured(vpn
))
2805 delete_withdraw_vni_routes(bgp
, vpn
);
2809 * Process received EVPN type-2 route (advertise or withdraw).
2811 static int process_type2_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
2812 struct attr
*attr
, u_char
*pfx
, int psize
,
2813 u_int32_t addpath_id
)
2815 struct prefix_rd prd
;
2816 struct prefix_evpn p
;
2819 mpls_label_t label
[BGP_MAX_LABELS
]; /* holds the VNI(s) as in packet */
2820 u_int32_t num_labels
= 0;
2823 /* Type-2 route should be either 33, 37 or 49 bytes or an
2824 * additional 3 bytes if there is a second label (VNI):
2825 * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1),
2826 * MAC Addr (6), IP len (1), IP (0, 4 or 16),
2827 * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3)
2829 if (psize
!= 33 && psize
!= 37 && psize
!= 49 && psize
!= 36
2830 && psize
!= 40 && psize
!= 52) {
2831 zlog_err("%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
2832 peer
->bgp
->vrf_id
, peer
->host
, psize
);
2836 /* Make prefix_rd */
2837 prd
.family
= AF_UNSPEC
;
2839 memcpy(&prd
.val
, pfx
, 8);
2842 /* Make EVPN prefix. */
2843 memset(&p
, 0, sizeof(struct prefix_evpn
));
2845 p
.prefixlen
= EVPN_TYPE_2_ROUTE_PREFIXLEN
;
2846 p
.prefix
.route_type
= BGP_EVPN_MAC_IP_ROUTE
;
2848 /* Skip over Ethernet Seg Identifier for now. */
2851 /* Skip over Ethernet Tag for now. */
2854 /* Get the MAC Addr len */
2855 macaddr_len
= *pfx
++;
2857 /* Get the MAC Addr */
2858 if (macaddr_len
== (ETH_ALEN
* 8)) {
2859 memcpy(&p
.prefix
.mac
.octet
, pfx
, ETH_ALEN
);
2863 "%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
2864 peer
->bgp
->vrf_id
, peer
->host
, macaddr_len
);
2870 ipaddr_len
= *pfx
++;
2871 if (ipaddr_len
!= 0 && ipaddr_len
!= IPV4_MAX_BITLEN
2872 && ipaddr_len
!= IPV6_MAX_BITLEN
) {
2874 "%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
2875 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
2880 ipaddr_len
/= 8; /* Convert to bytes. */
2881 p
.prefix
.ip
.ipa_type
= (ipaddr_len
== IPV4_MAX_BYTELEN
)
2884 memcpy(&p
.prefix
.ip
.ip
.addr
, pfx
, ipaddr_len
);
2888 /* Get the VNI(s). Stored as bytes here. */
2890 memset(label
, 0, sizeof(label
));
2891 memcpy(&label
[0], pfx
, BGP_LABEL_BYTES
);
2892 pfx
+= BGP_LABEL_BYTES
;
2893 psize
-= (33 + ipaddr_len
);
2894 /* Do we have a second VNI? */
2897 memcpy(&label
[1], pfx
, BGP_LABEL_BYTES
);
2899 * If in future, we are required to access additional fields,
2900 * we MUST increment pfx by BGP_LABEL_BYTES in before reading
2905 /* Process the route. */
2907 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2908 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2909 &prd
, &label
[0], num_labels
, 0, NULL
);
2911 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2912 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2913 &prd
, &label
[0], num_labels
, NULL
);
2918 * Process received EVPN type-3 route (advertise or withdraw).
2920 static int process_type3_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
2921 struct attr
*attr
, u_char
*pfx
, int psize
,
2922 u_int32_t addpath_id
)
2924 struct prefix_rd prd
;
2925 struct prefix_evpn p
;
2929 /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
2930 * IP len (1) and IP (4 or 16).
2932 if (psize
!= 17 && psize
!= 29) {
2933 zlog_err("%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
2934 peer
->bgp
->vrf_id
, peer
->host
, psize
);
2938 /* If PMSI is present, log if it is anything other than IR.
2939 * Note: We just simply ignore the values as it is not clear if
2940 * doing anything else is better.
2943 (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
))) {
2944 if (attr
->pmsi_tnl_type
!= PMSI_TNLTYPE_INGR_REPL
) {
2945 zlog_warn("%u:%s - Rx EVPN Type-3 NLRI with unsupported PTA %d",
2946 peer
->bgp
->vrf_id
, peer
->host
,
2947 attr
->pmsi_tnl_type
);
2951 /* Make prefix_rd */
2952 prd
.family
= AF_UNSPEC
;
2954 memcpy(&prd
.val
, pfx
, 8);
2957 /* Make EVPN prefix. */
2958 memset(&p
, 0, sizeof(struct prefix_evpn
));
2960 p
.prefixlen
= EVPN_TYPE_3_ROUTE_PREFIXLEN
;
2961 p
.prefix
.route_type
= BGP_EVPN_IMET_ROUTE
;
2963 /* Skip over Ethernet Tag for now. */
2967 ipaddr_len
= *pfx
++;
2968 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
2969 p
.prefix
.ip
.ipa_type
= IPADDR_V4
;
2970 memcpy(&p
.prefix
.ip
.ip
.addr
, pfx
, IPV4_MAX_BYTELEN
);
2973 "%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
2974 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
2978 /* Process the route. */
2980 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2981 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2982 &prd
, NULL
, 0, 0, NULL
);
2984 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
2985 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
2986 &prd
, NULL
, 0, NULL
);
2991 * Process received EVPN type-5 route (advertise or withdraw).
2993 static int process_type5_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
2994 struct attr
*attr
, u_char
*pfx
, int psize
,
2995 u_int32_t addpath_id
, int withdraw
)
2997 struct prefix_rd prd
;
2998 struct prefix_evpn p
;
2999 struct bgp_route_evpn evpn
;
3002 mpls_label_t label
; /* holds the VNI as in the packet */
3005 /* Type-5 route should be 34 or 58 bytes:
3006 * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16),
3007 * GW (4 or 16) and VNI (3).
3008 * Note that the IP and GW should both be IPv4 or both IPv6.
3010 if (psize
!= 34 && psize
!= 58) {
3011 zlog_err("%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
3012 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3016 /* Make prefix_rd */
3017 prd
.family
= AF_UNSPEC
;
3019 memcpy(&prd
.val
, pfx
, 8);
3022 /* Make EVPN prefix. */
3023 memset(&p
, 0, sizeof(struct prefix_evpn
));
3025 p
.prefixlen
= EVPN_TYPE_5_ROUTE_PREFIXLEN
;
3026 p
.prefix
.route_type
= BGP_EVPN_IP_PREFIX_ROUTE
;
3028 /* Additional information outside of prefix - ESI and GW IP */
3029 memset(&evpn
, 0, sizeof(evpn
));
3032 memcpy(&evpn
.eth_s_id
.val
, pfx
, 10);
3035 /* Fetch Ethernet Tag. */
3036 memcpy(ð_tag
, pfx
, 4);
3037 p
.prefix
.eth_tag
= ntohl(eth_tag
);
3040 /* Fetch IP prefix length. */
3042 if (ippfx_len
> IPV6_MAX_BITLEN
) {
3044 "%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
3045 peer
->bgp
->vrf_id
, peer
->host
, ippfx_len
);
3048 p
.prefix
.ip_prefix_length
= ippfx_len
;
3050 /* Determine IPv4 or IPv6 prefix */
3051 /* Since the address and GW are from the same family, this just becomes
3052 * a simple check on the total size.
3055 SET_IPADDR_V4(&p
.prefix
.ip
);
3056 memcpy(&p
.prefix
.ip
.ipaddr_v4
, pfx
, 4);
3058 memcpy(&evpn
.gw_ip
.ipv4
, pfx
, 4);
3061 SET_IPADDR_V6(&p
.prefix
.ip
);
3062 memcpy(&p
.prefix
.ip
.ipaddr_v6
, pfx
, 16);
3064 memcpy(&evpn
.gw_ip
.ipv6
, pfx
, 16);
3068 /* Get the VNI (in MPLS label field). Stored as bytes here. */
3069 memset(&label
, 0, sizeof(label
));
3070 memcpy(&label
, pfx
, BGP_LABEL_BYTES
);
3073 * If in future, we are required to access additional fields,
3074 * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next
3078 /* Process the route. */
3080 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3081 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3082 &prd
, &label
, 1, 0, &evpn
);
3084 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3085 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3086 &prd
, &label
, 1, &evpn
);
3091 static void evpn_mpattr_encode_type5(struct stream
*s
, struct prefix
*p
,
3092 struct prefix_rd
*prd
, mpls_label_t
*label
,
3093 u_int32_t num_labels
, struct attr
*attr
)
3097 struct evpn_addr
*p_evpn_p
;
3099 memset(&temp
, 0, 16);
3100 if (p
->family
!= AF_EVPN
)
3102 p_evpn_p
= &(p
->u
.prefix_evpn
);
3104 /* len denites the total len of IP and GW-IP in the route
3105 IP and GW-IP have to be both ipv4 or ipv6
3107 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
3108 len
= 8; /* IP and GWIP are both ipv4 */
3110 len
= 32; /* IP and GWIP are both ipv6 */
3111 /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */
3112 stream_putc(s
, 8 + 10 + 4 + 1 + len
+ 3);
3113 stream_put(s
, prd
->val
, 8);
3115 stream_put(s
, &(attr
->evpn_overlay
.eth_s_id
), 10);
3117 stream_put(s
, &temp
, 10);
3118 stream_putl(s
, p_evpn_p
->eth_tag
);
3119 stream_putc(s
, p_evpn_p
->ip_prefix_length
);
3120 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
3121 stream_put_ipv4(s
, p_evpn_p
->ip
.ipaddr_v4
.s_addr
);
3123 stream_put(s
, &p_evpn_p
->ip
.ipaddr_v6
, 16);
3125 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
3127 attr
->evpn_overlay
.gw_ip
.ipv4
.s_addr
);
3129 stream_put(s
, &(attr
->evpn_overlay
.gw_ip
.ipv6
), 16);
3131 if (IS_IPADDR_V4(&p_evpn_p
->ip
))
3132 stream_put_ipv4(s
, 0);
3134 stream_put(s
, &temp
, 16);
3138 stream_put(s
, label
, 3);
3144 * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
3146 static void cleanup_vni_on_disable(struct hash_backet
*backet
, struct bgp
*bgp
)
3148 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3150 /* Remove EVPN routes and schedule for processing. */
3151 delete_routes_for_vni(bgp
, vpn
);
3153 /* Clear "live" flag and see if hash needs to be freed. */
3154 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
3155 if (!is_vni_configured(vpn
))
3156 bgp_evpn_free(bgp
, vpn
);
3160 * Free a VNI entry; iterator function called during cleanup.
3162 static void free_vni_entry(struct hash_backet
*backet
, struct bgp
*bgp
)
3164 struct bgpevpn
*vpn
;
3166 vpn
= (struct bgpevpn
*)backet
->data
;
3167 delete_all_vni_routes(bgp
, vpn
);
3168 bgp_evpn_free(bgp
, vpn
);
3172 * Derive AUTO import RT for BGP VRF - L3VNI
3174 static void evpn_auto_rt_import_add_for_vrf(struct bgp
*bgp_vrf
)
3176 struct bgp
*bgp_def
= NULL
;
3178 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3179 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3182 bgp_def
= bgp_get_default();
3185 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3189 * Delete AUTO import RT from BGP VRF - L3VNI
3191 static void evpn_auto_rt_import_delete_for_vrf(struct bgp
*bgp_vrf
)
3193 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3197 * Derive AUTO export RT for BGP VRF - L3VNI
3199 static void evpn_auto_rt_export_add_for_vrf(struct bgp
*bgp_vrf
)
3201 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3202 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
3206 * Delete AUTO export RT from BGP VRF - L3VNI
3208 static void evpn_auto_rt_export_delete_for_vrf(struct bgp
*bgp_vrf
)
3210 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
3213 static void bgp_evpn_handle_export_rt_change_for_vrf(struct bgp
*bgp_vrf
)
3215 struct bgp
*bgp_def
= NULL
;
3216 struct listnode
*node
= NULL
;
3217 struct bgpevpn
*vpn
= NULL
;
3219 bgp_def
= bgp_get_default();
3223 /* update all type-5 routes */
3224 update_advertise_vrf_routes(bgp_vrf
);
3226 /* update all type-2 routes */
3227 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
3228 update_routes_for_vni(bgp_def
, vpn
);
3235 /* withdraw type-5 route corresponding to ip prefix */
3236 void bgp_evpn_withdraw_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
3237 afi_t afi
, safi_t safi
)
3240 struct prefix_evpn evp
;
3241 char buf
[PREFIX_STRLEN
];
3243 build_type5_prefix_from_ip_prefix(&evp
, p
);
3244 ret
= delete_evpn_type5_route(bgp_vrf
, &evp
);
3247 "%u failed to delete type-5 route for prefix %s in vrf %s",
3248 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)),
3249 vrf_id_to_name(bgp_vrf
->vrf_id
));
3253 /* withdraw all type-5 routes for an address family */
3254 void bgp_evpn_withdraw_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
, safi_t safi
)
3256 struct bgp_table
*table
= NULL
;
3257 struct bgp_node
*rn
= NULL
;
3258 struct bgp_info
*ri
;
3260 table
= bgp_vrf
->rib
[afi
][safi
];
3261 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
3262 /* Only care about "selected" routes - non-imported. */
3263 /* TODO: Support for AddPath for EVPN. */
3264 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
3265 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
3266 && (!ri
->extra
|| !ri
->extra
->parent
)) {
3267 bgp_evpn_withdraw_type5_route(bgp_vrf
, &rn
->p
,
3276 * Advertise IP prefix as type-5 route. The afi/safi and src_attr passed
3277 * to this function correspond to those of the source IP prefix (best
3278 * path in the case of the attr. In the case of a local prefix (when we
3279 * are advertising local subnets), the src_attr will be NULL.
3281 void bgp_evpn_advertise_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
3282 struct attr
*src_attr
, afi_t afi
,
3286 struct prefix_evpn evp
;
3287 char buf
[PREFIX_STRLEN
];
3289 build_type5_prefix_from_ip_prefix(&evp
, p
);
3290 ret
= update_evpn_type5_route(bgp_vrf
, &evp
, src_attr
);
3292 zlog_err("%u: Failed to create type-5 route for prefix %s",
3293 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)));
3296 /* Inject all prefixes of a particular address-family (currently, IPv4 or
3297 * IPv6 unicast) into EVPN as type-5 routes. This is invoked when the
3298 * advertisement is enabled.
3300 void bgp_evpn_advertise_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
,
3303 struct bgp_table
*table
= NULL
;
3304 struct bgp_node
*rn
= NULL
;
3305 struct bgp_info
*ri
;
3307 table
= bgp_vrf
->rib
[afi
][safi
];
3308 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
3309 /* Need to identify the "selected" route entry to use its
3310 * attribute. Also, we only consider "non-imported" routes.
3311 * TODO: Support for AddPath for EVPN.
3313 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
3314 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
3315 && (!ri
->extra
|| !ri
->extra
->parent
)) {
3317 /* apply the route-map */
3318 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
) {
3321 ret
= route_map_apply(
3322 bgp_vrf
->adv_cmd_rmap
[afi
][safi
]
3324 &rn
->p
, RMAP_BGP
, ri
);
3325 if (ret
== RMAP_DENYMATCH
)
3328 bgp_evpn_advertise_type5_route(
3329 bgp_vrf
, &rn
->p
, ri
->attr
, afi
, safi
);
3336 void evpn_rt_delete_auto(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
3338 struct listnode
*node
, *nnode
, *node_to_del
;
3339 struct ecommunity
*ecom
, *ecom_auto
;
3340 struct ecommunity_val eval
;
3342 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
3344 ecom_auto
= ecommunity_new();
3345 ecommunity_add_val(ecom_auto
, &eval
);
3348 for (ALL_LIST_ELEMENTS(rtl
, node
, nnode
, ecom
)) {
3349 if (ecommunity_match(ecom
, ecom_auto
)) {
3350 ecommunity_free(&ecom
);
3356 list_delete_node(rtl
, node_to_del
);
3358 ecommunity_free(&ecom_auto
);
3361 void bgp_evpn_configure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
3362 struct ecommunity
*ecomadd
)
3364 /* uninstall routes from vrf */
3365 uninstall_routes_for_vrf(bgp_vrf
);
3367 /* Cleanup the RT to VRF mapping */
3368 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
3370 /* Remove auto generated RT */
3371 evpn_auto_rt_import_delete_for_vrf(bgp_vrf
);
3373 /* Add the newly configured RT to RT list */
3374 listnode_add_sort(bgp_vrf
->vrf_import_rtl
, ecomadd
);
3375 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3377 /* map VRF to its RTs */
3378 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3380 /* install routes matching the new VRF */
3381 install_routes_for_vrf(bgp_vrf
);
3384 void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
3385 struct ecommunity
*ecomdel
)
3387 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
3388 struct ecommunity
*ecom
= NULL
;
3390 /* uninstall routes from vrf */
3391 uninstall_routes_for_vrf(bgp_vrf
);
3393 /* Cleanup the RT to VRF mapping */
3394 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
3396 /* remove the RT from the RT list */
3397 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
3398 if (ecommunity_match(ecom
, ecomdel
)) {
3399 ecommunity_free(&ecom
);
3406 list_delete_node(bgp_vrf
->vrf_import_rtl
, node_to_del
);
3408 /* fallback to auto import rt, if this was the last RT */
3409 if (list_isempty(bgp_vrf
->vrf_import_rtl
)) {
3410 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3411 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
3414 /* map VRFs to its RTs */
3415 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3417 /* install routes matching this new RT */
3418 install_routes_for_vrf(bgp_vrf
);
3421 void bgp_evpn_configure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
3422 struct ecommunity
*ecomadd
)
3424 /* remove auto-generated RT */
3425 evpn_auto_rt_export_delete_for_vrf(bgp_vrf
);
3427 /* Add the new RT to the RT list */
3428 listnode_add_sort(bgp_vrf
->vrf_export_rtl
, ecomadd
);
3429 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3431 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
3434 void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
3435 struct ecommunity
*ecomdel
)
3437 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
3438 struct ecommunity
*ecom
= NULL
;
3440 /* Remove the RT from the RT list */
3441 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, ecom
)) {
3442 if (ecommunity_match(ecom
, ecomdel
)) {
3443 ecommunity_free(&ecom
);
3450 list_delete_node(bgp_vrf
->vrf_export_rtl
, node_to_del
);
3452 /* fall back to auto-generated RT if this was the last RT */
3453 if (bgp_vrf
->vrf_export_rtl
&& list_isempty(bgp_vrf
->vrf_export_rtl
)) {
3454 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
3455 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
3458 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
3462 * Handle change to BGP router id. This is invoked twice by the change
3463 * handler, first before the router id has been changed and then after
3464 * the router id has been changed. The first invocation will result in
3465 * local routes for all VNIs/VRF being deleted and withdrawn and the next
3466 * will result in the routes being re-advertised.
3468 void bgp_evpn_handle_router_id_update(struct bgp
*bgp
, int withdraw
)
3472 /* delete and withdraw all the type-5 routes
3473 stored in the global table for this vrf
3475 withdraw_router_id_vrf(bgp
);
3477 /* delete all the VNI routes (type-2/type-3) routes for all the
3480 hash_iterate(bgp
->vnihash
,
3481 (void (*)(struct hash_backet
*,
3482 void *))withdraw_router_id_vni
,
3486 /* advertise all routes in the vrf as type-5 routes with the new
3489 update_router_id_vrf(bgp
);
3491 /* advertise all the VNI routes (type-2/type-3) routes with the
3494 hash_iterate(bgp
->vnihash
,
3495 (void (*)(struct hash_backet
*,
3496 void *))update_router_id_vni
,
3502 * Handle change to export RT - update and advertise local routes.
3504 int bgp_evpn_handle_export_rt_change(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3506 return update_routes_for_vni(bgp
, vpn
);
3509 void bgp_evpn_handle_vrf_rd_change(struct bgp
*bgp_vrf
, int withdraw
)
3512 delete_withdraw_vrf_routes(bgp_vrf
);
3514 update_advertise_vrf_routes(bgp_vrf
);
3518 * Handle change to RD. This is invoked twice by the change handler,
3519 * first before the RD has been changed and then after the RD has
3520 * been changed. The first invocation will result in local routes
3521 * of this VNI being deleted and withdrawn and the next will result
3522 * in the routes being re-advertised.
3524 void bgp_evpn_handle_rd_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
3528 delete_withdraw_vni_routes(bgp
, vpn
);
3530 update_advertise_vni_routes(bgp
, vpn
);
3534 * Install routes for this VNI. Invoked upon change to Import RT.
3536 int bgp_evpn_install_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3538 return install_routes_for_vni(bgp
, vpn
);
3542 * Uninstall all routes installed for this VNI. Invoked upon change
3545 int bgp_evpn_uninstall_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3547 return uninstall_routes_for_vni(bgp
, vpn
);
3551 * TODO: Hardcoded for a maximum of 2 VNIs right now
3553 char *bgp_evpn_label2str(mpls_label_t
*label
, u_int32_t num_labels
, char *buf
,
3558 vni1
= label2vni(label
);
3559 if (num_labels
== 2) {
3560 vni2
= label2vni(label
+ 1);
3561 snprintf(buf
, len
, "%u/%u", vni1
, vni2
);
3563 snprintf(buf
, len
, "%u", vni1
);
3568 * Function to convert evpn route to json format.
3569 * NOTE: We don't use prefix2str as the output here is a bit different.
3571 void bgp_evpn_route2json(struct prefix_evpn
*p
, json_object
*json
)
3573 char buf1
[ETHER_ADDR_STRLEN
];
3574 char buf2
[PREFIX2STR_BUFFER
];
3579 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
3580 json_object_int_add(json
, "routeType", p
->prefix
.route_type
);
3581 json_object_int_add(json
, "ethTag", 0);
3582 json_object_int_add(json
, "ipLen",
3583 IS_EVPN_PREFIX_IPADDR_V4(p
)
3586 json_object_string_add(json
, "ip",
3587 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
));
3588 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
3589 if (IS_EVPN_PREFIX_IPADDR_NONE(p
)) {
3590 json_object_int_add(json
, "routeType",
3591 p
->prefix
.route_type
);
3592 json_object_int_add(
3594 0); /* TODO: we don't support esi yet */
3595 json_object_int_add(json
, "ethTag", 0);
3596 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
3597 json_object_string_add(json
, "mac",
3598 prefix_mac2str(&p
->prefix
.mac
,
3604 family
= IS_EVPN_PREFIX_IPADDR_V4(p
) ? AF_INET
3607 json_object_int_add(json
, "routeType",
3608 p
->prefix
.route_type
);
3609 json_object_int_add(
3611 0); /* TODO: we don't support esi yet */
3612 json_object_int_add(json
, "ethTag", 0);
3613 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
3614 json_object_string_add(json
, "mac",
3615 prefix_mac2str(&p
->prefix
.mac
,
3618 json_object_int_add(json
, "ipLen",
3619 IS_EVPN_PREFIX_IPADDR_V4(p
)
3622 json_object_string_add(
3624 inet_ntop(family
, &p
->prefix
.ip
.ip
.addr
, buf2
,
3625 PREFIX2STR_BUFFER
));
3628 /* Currently, this is to cater to other AF_ETHERNET code. */
3633 * Function to convert evpn route to string.
3634 * NOTE: We don't use prefix2str as the output here is a bit different.
3636 char *bgp_evpn_route2str(struct prefix_evpn
*p
, char *buf
, int len
)
3638 char buf1
[ETHER_ADDR_STRLEN
];
3639 char buf2
[PREFIX2STR_BUFFER
];
3641 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
3642 snprintf(buf
, len
, "[%d]:[0]:[%d]:[%s]", p
->prefix
.route_type
,
3643 IS_EVPN_PREFIX_IPADDR_V4(p
) ? IPV4_MAX_BITLEN
3645 inet_ntoa(p
->prefix
.ip
.ipaddr_v4
));
3646 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
3647 if (IS_EVPN_PREFIX_IPADDR_NONE(p
))
3648 snprintf(buf
, len
, "[%d]:[0]:[0]:[%d]:[%s]",
3649 p
->prefix
.route_type
, 8 * ETH_ALEN
,
3650 prefix_mac2str(&p
->prefix
.mac
, buf1
,
3655 family
= IS_EVPN_PREFIX_IPADDR_V4(p
) ? AF_INET
3657 snprintf(buf
, len
, "[%d]:[0]:[0]:[%d]:[%s]:[%d]:[%s]",
3658 p
->prefix
.route_type
, 8 * ETH_ALEN
,
3659 prefix_mac2str(&p
->prefix
.mac
, buf1
,
3661 family
== AF_INET
? IPV4_MAX_BITLEN
3663 inet_ntop(family
, &p
->prefix
.ip
.ip
.addr
, buf2
,
3664 PREFIX2STR_BUFFER
));
3666 } else if (p
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
3667 snprintf(buf
, len
, "[%d]:[0]:[0]:[%d]:[%s]",
3668 p
->prefix
.route_type
, p
->prefix
.ip_prefix_length
,
3669 IS_EVPN_PREFIX_IPADDR_V4(p
)
3670 ? inet_ntoa(p
->prefix
.ip
.ipaddr_v4
)
3671 : inet6_ntoa(p
->prefix
.ip
.ipaddr_v6
));
3673 /* For EVPN route types not supported yet. */
3674 snprintf(buf
, len
, "(unsupported route type %d)",
3675 p
->prefix
.route_type
);
3682 * Encode EVPN prefix in Update (MP_REACH)
3684 void bgp_evpn_encode_prefix(struct stream
*s
, struct prefix
*p
,
3685 struct prefix_rd
*prd
, mpls_label_t
*label
,
3686 u_int32_t num_labels
, struct attr
*attr
,
3687 int addpath_encode
, u_int32_t addpath_tx_id
)
3689 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
3690 int len
, ipa_len
= 0;
3693 stream_putl(s
, addpath_tx_id
);
3696 stream_putc(s
, evp
->prefix
.route_type
);
3698 switch (evp
->prefix
.route_type
) {
3699 case BGP_EVPN_MAC_IP_ROUTE
:
3700 if (IS_EVPN_PREFIX_IPADDR_V4(evp
))
3701 ipa_len
= IPV4_MAX_BYTELEN
;
3702 else if (IS_EVPN_PREFIX_IPADDR_V6(evp
))
3703 ipa_len
= IPV6_MAX_BYTELEN
;
3704 /* RD, ESI, EthTag, MAC+len, IP len, [IP], 1 VNI */
3705 len
= 8 + 10 + 4 + 1 + 6 + 1 + ipa_len
+ 3;
3706 if (ipa_len
&& num_labels
> 1) /* There are 2 VNIs */
3708 stream_putc(s
, len
);
3709 stream_put(s
, prd
->val
, 8); /* RD */
3710 stream_put(s
, 0, 10); /* ESI */
3711 stream_putl(s
, 0); /* Ethernet Tag ID */
3712 stream_putc(s
, 8 * ETH_ALEN
); /* Mac Addr Len - bits */
3713 stream_put(s
, evp
->prefix
.mac
.octet
, 6); /* Mac Addr */
3714 stream_putc(s
, 8 * ipa_len
); /* IP address Length */
3715 if (ipa_len
) /* IP */
3716 stream_put(s
, &evp
->prefix
.ip
.ip
.addr
, ipa_len
);
3717 /* 1st label is the L2 VNI */
3718 stream_put(s
, label
, BGP_LABEL_BYTES
);
3719 /* Include 2nd label (L3 VNI) if advertising MAC+IP */
3720 if (ipa_len
&& num_labels
> 1)
3721 stream_put(s
, label
+ 1, BGP_LABEL_BYTES
);
3724 case BGP_EVPN_IMET_ROUTE
:
3725 stream_putc(s
, 17); // TODO: length - assumes IPv4 address
3726 stream_put(s
, prd
->val
, 8); /* RD */
3727 stream_putl(s
, 0); /* Ethernet Tag ID */
3728 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
3729 /* Originating Router's IP Addr */
3730 stream_put_in_addr(s
, &evp
->prefix
.ip
.ipaddr_v4
);
3733 case BGP_EVPN_IP_PREFIX_ROUTE
:
3734 /* TODO: AddPath support. */
3735 evpn_mpattr_encode_type5(s
, p
, prd
, label
, num_labels
, attr
);
3743 int bgp_nlri_parse_evpn(struct peer
*peer
, struct attr
*attr
,
3744 struct bgp_nlri
*packet
, int withdraw
)
3750 u_int32_t addpath_id
;
3751 int addpath_encoded
;
3757 /* Start processing the NLRI - there may be multiple in the MP_REACH */
3759 lim
= pnt
+ packet
->length
;
3761 safi
= packet
->safi
;
3765 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
3766 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
3767 PEER_CAP_ADDPATH_AF_TX_RCV
));
3769 for (; pnt
< lim
; pnt
+= psize
) {
3770 /* Clear prefix structure. */
3771 memset(&p
, 0, sizeof(struct prefix
));
3773 /* Deal with path-id if AddPath is supported. */
3774 if (addpath_encoded
) {
3775 /* When packet overflow occurs return immediately. */
3776 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
3779 addpath_id
= ntohl(*((uint32_t *)pnt
));
3780 pnt
+= BGP_ADDPATH_ID_LEN
;
3783 /* All EVPN NLRI types start with type and length. */
3788 psize
= rlen
= *pnt
++;
3790 /* When packet overflow occur return immediately. */
3791 if (pnt
+ psize
> lim
)
3795 case BGP_EVPN_MAC_IP_ROUTE
:
3796 if (process_type2_route(peer
, afi
, safi
,
3797 withdraw
? NULL
: attr
, pnt
,
3798 psize
, addpath_id
)) {
3800 "%u:%s - Error in processing EVPN type-2 NLRI size %d",
3801 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3806 case BGP_EVPN_IMET_ROUTE
:
3807 if (process_type3_route(peer
, afi
, safi
,
3808 withdraw
? NULL
: attr
, pnt
,
3809 psize
, addpath_id
)) {
3811 "%u:%s - Error in processing EVPN type-3 NLRI size %d",
3812 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3817 case BGP_EVPN_IP_PREFIX_ROUTE
:
3818 if (process_type5_route(peer
, afi
, safi
, attr
, pnt
,
3819 psize
, addpath_id
, withdraw
)) {
3821 "%u:%s - Error in processing EVPN type-5 NLRI size %d",
3822 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3832 /* Packet length consistency check. */
3840 * Map the RTs (configured or automatically derived) of a VRF to the VRF.
3841 * The mapping will be used during route processing.
3842 * bgp_def: default bgp instance
3843 * bgp_vrf: specific bgp vrf instance on which RT is configured
3845 void bgp_evpn_map_vrf_to_its_rts(struct bgp
*bgp_vrf
)
3848 struct ecommunity_val
*eval
= NULL
;
3849 struct listnode
*node
= NULL
, *nnode
= NULL
;
3850 struct ecommunity
*ecom
= NULL
;
3852 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
3853 for (i
= 0; i
< ecom
->size
; i
++) {
3854 eval
= (struct ecommunity_val
*)(ecom
->val
3856 * ECOMMUNITY_SIZE
));
3857 map_vrf_to_rt(bgp_vrf
, eval
);
3863 * Unmap the RTs (configured or automatically derived) of a VRF from the VRF.
3865 void bgp_evpn_unmap_vrf_from_its_rts(struct bgp
*bgp_vrf
)
3868 struct ecommunity_val
*eval
;
3869 struct listnode
*node
, *nnode
;
3870 struct ecommunity
*ecom
;
3872 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
3873 for (i
= 0; i
< ecom
->size
; i
++) {
3874 struct vrf_irt_node
*irt
;
3875 struct ecommunity_val eval_tmp
;
3877 eval
= (struct ecommunity_val
*)(ecom
->val
3879 * ECOMMUNITY_SIZE
));
3880 /* If using "automatic" RT, we only care about the
3881 * local-admin sub-field.
3882 * This is to facilitate using VNI as the RT for EBGP
3885 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3886 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
3887 BGP_VRF_IMPORT_RT_CFGD
))
3888 mask_ecom_global_admin(&eval_tmp
, eval
);
3890 irt
= lookup_vrf_import_rt(&eval_tmp
);
3892 unmap_vrf_from_rt(bgp_vrf
, irt
);
3899 * Map the RTs (configured or automatically derived) of a VNI to the VNI.
3900 * The mapping will be used during route processing.
3902 void bgp_evpn_map_vni_to_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3905 struct ecommunity_val
*eval
;
3906 struct listnode
*node
, *nnode
;
3907 struct ecommunity
*ecom
;
3909 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
3910 for (i
= 0; i
< ecom
->size
; i
++) {
3911 eval
= (struct ecommunity_val
*)(ecom
->val
3913 * ECOMMUNITY_SIZE
));
3914 map_vni_to_rt(bgp
, vpn
, eval
);
3920 * Unmap the RTs (configured or automatically derived) of a VNI from the VNI.
3922 void bgp_evpn_unmap_vni_from_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3925 struct ecommunity_val
*eval
;
3926 struct listnode
*node
, *nnode
;
3927 struct ecommunity
*ecom
;
3929 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
3930 for (i
= 0; i
< ecom
->size
; i
++) {
3931 struct irt_node
*irt
;
3932 struct ecommunity_val eval_tmp
;
3934 eval
= (struct ecommunity_val
*)(ecom
->val
3936 * ECOMMUNITY_SIZE
));
3937 /* If using "automatic" RT, we only care about the
3938 * local-admin sub-field.
3939 * This is to facilitate using VNI as the RT for EBGP
3942 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3943 if (!is_import_rt_configured(vpn
))
3944 mask_ecom_global_admin(&eval_tmp
, eval
);
3946 irt
= lookup_import_rt(bgp
, &eval_tmp
);
3948 unmap_vni_from_rt(bgp
, vpn
, irt
);
3954 * Derive Import RT automatically for VNI and map VNI to RT.
3955 * The mapping will be used during route processing.
3957 void bgp_evpn_derive_auto_rt_import(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3959 form_auto_rt(bgp
, vpn
->vni
, vpn
->import_rtl
);
3960 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
3963 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
3967 * Derive Export RT automatically for VNI.
3969 void bgp_evpn_derive_auto_rt_export(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3971 form_auto_rt(bgp
, vpn
->vni
, vpn
->export_rtl
);
3972 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
3976 * Derive RD automatically for VNI using passed information - it
3977 * is of the form RouterId:unique-id-for-vni.
3979 void bgp_evpn_derive_auto_rd_for_vrf(struct bgp
*bgp
)
3983 bgp
->vrf_prd
.family
= AF_UNSPEC
;
3984 bgp
->vrf_prd
.prefixlen
= 64;
3985 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), bgp
->vrf_rd_id
);
3986 str2prefix_rd(buf
, &bgp
->vrf_prd
);
3990 * Derive RD automatically for VNI using passed information - it
3991 * is of the form RouterId:unique-id-for-vni.
3993 void bgp_evpn_derive_auto_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3997 vpn
->prd
.family
= AF_UNSPEC
;
3998 vpn
->prd
.prefixlen
= 64;
3999 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), vpn
->rd_id
);
4000 (void)str2prefix_rd(buf
, &vpn
->prd
);
4001 UNSET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
4007 struct bgpevpn
*bgp_evpn_lookup_vni(struct bgp
*bgp
, vni_t vni
)
4009 struct bgpevpn
*vpn
;
4012 memset(&tmp
, 0, sizeof(struct bgpevpn
));
4014 vpn
= hash_lookup(bgp
->vnihash
, &tmp
);
4019 * Create a new vpn - invoked upon configuration or zebra notification.
4021 struct bgpevpn
*bgp_evpn_new(struct bgp
*bgp
, vni_t vni
,
4022 struct in_addr originator_ip
,
4023 vrf_id_t tenant_vrf_id
)
4025 struct bgpevpn
*vpn
;
4030 vpn
= XCALLOC(MTYPE_BGP_EVPN
, sizeof(struct bgpevpn
));
4034 /* Set values - RD and RT set to defaults. */
4036 vpn
->originator_ip
= originator_ip
;
4037 vpn
->tenant_vrf_id
= tenant_vrf_id
;
4039 /* Initialize route-target import and export lists */
4040 vpn
->import_rtl
= list_new();
4041 vpn
->import_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4042 vpn
->export_rtl
= list_new();
4043 vpn
->export_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4044 bf_assign_index(bm
->rd_idspace
, vpn
->rd_id
);
4045 derive_rd_rt_for_vni(bgp
, vpn
);
4047 /* Initialize EVPN route table. */
4048 vpn
->route_table
= bgp_table_init(AFI_L2VPN
, SAFI_EVPN
);
4051 if (!hash_get(bgp
->vnihash
, vpn
, hash_alloc_intern
)) {
4052 XFREE(MTYPE_BGP_EVPN
, vpn
);
4056 /* add to l2vni list on corresponding vrf */
4057 bgpevpn_link_to_l3vni(vpn
);
4059 QOBJ_REG(vpn
, bgpevpn
);
4064 * Free a given VPN - called in multiple scenarios such as zebra
4065 * notification, configuration being deleted, advertise-all-vni disabled etc.
4066 * This just frees appropriate memory, caller should have taken other
4069 void bgp_evpn_free(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4071 bgpevpn_unlink_from_l3vni(vpn
);
4072 bgp_table_unlock(vpn
->route_table
);
4073 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4074 list_delete_and_null(&vpn
->import_rtl
);
4075 list_delete_and_null(&vpn
->export_rtl
);
4076 bf_release_index(bm
->rd_idspace
, vpn
->rd_id
);
4077 hash_release(bgp
->vnihash
, vpn
);
4079 XFREE(MTYPE_BGP_EVPN
, vpn
);
4083 * Import route into matching VNI(s).
4085 int bgp_evpn_import_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
4086 struct prefix
*p
, struct bgp_info
*ri
)
4088 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 1);
4092 * Unimport route from matching VNI(s).
4094 int bgp_evpn_unimport_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
4095 struct prefix
*p
, struct bgp_info
*ri
)
4097 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 0);
4100 /* filter routes which have martian next hops */
4101 int bgp_filter_evpn_routes_upon_martian_nh_change(struct bgp
*bgp
)
4105 struct bgp_node
*rd_rn
, *rn
;
4106 struct bgp_table
*table
;
4107 struct bgp_info
*ri
;
4112 /* Walk entire global routing table and evaluate routes which could be
4113 * imported into this VPN. Note that we cannot just look at the routes
4114 * for the VNI's RD -
4115 * remote routes applicable for this VNI could have any RD.
4117 /* EVPN routes are a 2-level table. */
4118 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
4119 rd_rn
= bgp_route_next(rd_rn
)) {
4120 table
= (struct bgp_table
*)(rd_rn
->info
);
4124 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4126 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
4128 /* Consider "valid" remote routes applicable for
4130 if (!(ri
->type
== ZEBRA_ROUTE_BGP
4131 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
4134 if (bgp_nexthop_self(bgp
, ri
->attr
->nexthop
)) {
4136 char attr_str
[BUFSIZ
];
4137 char pbuf
[PREFIX_STRLEN
];
4139 bgp_dump_attr(ri
->attr
, attr_str
,
4142 if (bgp_debug_update(ri
->peer
, &rn
->p
,
4145 "%u: prefix %s with attr %s - DENIED due to martian or self nexthop",
4152 bgp_evpn_unimport_route(bgp
, afi
, safi
,
4155 bgp_rib_remove(rn
, ri
, ri
->peer
, afi
,
4166 * Handle del of a local MACIP.
4168 int bgp_evpn_local_macip_del(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
4171 struct bgpevpn
*vpn
;
4172 struct prefix_evpn p
;
4174 if (!bgp
->vnihash
) {
4175 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4179 /* Lookup VNI hash - should exist. */
4180 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4181 if (!vpn
|| !is_vni_live(vpn
)) {
4182 zlog_warn("%u: VNI hash entry for VNI %u %s at MACIP DEL",
4183 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
4187 /* Remove EVPN type-2 route and schedule for processing. */
4188 build_evpn_type2_prefix(&p
, mac
, ip
);
4189 delete_evpn_route(bgp
, vpn
, &p
);
4195 * Handle add of a local MACIP.
4197 int bgp_evpn_local_macip_add(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
4198 struct ipaddr
*ip
, u_char flags
)
4200 struct bgpevpn
*vpn
;
4201 struct prefix_evpn p
;
4203 if (!bgp
->vnihash
) {
4204 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4208 /* Lookup VNI hash - should exist. */
4209 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4210 if (!vpn
|| !is_vni_live(vpn
)) {
4211 zlog_warn("%u: VNI hash entry for VNI %u %s at MACIP ADD",
4212 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
4216 /* Create EVPN type-2 route and schedule for processing. */
4217 build_evpn_type2_prefix(&p
, mac
, ip
);
4218 if (update_evpn_route(bgp
, vpn
, &p
, flags
)) {
4219 char buf
[ETHER_ADDR_STRLEN
];
4220 char buf2
[INET6_ADDRSTRLEN
];
4223 "%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
4224 bgp
->vrf_id
, vpn
->vni
,
4225 CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
)
4228 prefix_mac2str(mac
, buf
, sizeof(buf
)),
4229 ipaddr2str(ip
, buf2
, sizeof(buf2
)), flags
);
4236 static void link_l2vni_hash_to_l3vni(struct hash_backet
*backet
,
4237 struct bgp
*bgp_vrf
)
4239 struct bgpevpn
*vpn
= NULL
;
4240 struct bgp
*bgp_def
= NULL
;
4242 bgp_def
= bgp_get_default();
4245 vpn
= (struct bgpevpn
*)backet
->data
;
4246 if (vpn
->tenant_vrf_id
== bgp_vrf
->vrf_id
)
4247 bgpevpn_link_to_l3vni(vpn
);
4250 int bgp_evpn_local_l3vni_add(vni_t l3vni
, vrf_id_t vrf_id
, struct ethaddr
*rmac
,
4251 struct in_addr originator_ip
, int filter
)
4253 struct bgp
*bgp_vrf
= NULL
; /* bgp VRF instance */
4254 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
4255 struct listnode
*node
= NULL
;
4256 struct bgpevpn
*vpn
= NULL
;
4259 /* get the default instamce - required to get the AS number for VRF
4262 bgp_def
= bgp_get_default();
4265 "Cannot process L3VNI %u ADD - default BGP instance not yet created",
4271 /* if the BGP vrf instance doesnt exist - create one */
4272 bgp_vrf
= bgp_lookup_by_name(vrf_id_to_name(vrf_id
));
4277 ret
= bgp_get(&bgp_vrf
, &as
, vrf_id_to_name(vrf_id
),
4278 BGP_INSTANCE_TYPE_VRF
);
4280 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
:
4281 zlog_err("'bgp multiple-instance' not present\n");
4283 case BGP_ERR_AS_MISMATCH
:
4284 zlog_err("BGP is already running; AS is %u\n", as
);
4286 case BGP_ERR_INSTANCE_MISMATCH
:
4287 zlog_err("BGP instance name and AS number mismatch\n");
4291 /* mark as auto created */
4292 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
);
4295 /* associate with l3vni */
4296 bgp_vrf
->l3vni
= l3vni
;
4298 /* set the router mac - to be used in mac-ip routes for this vrf */
4299 memcpy(&bgp_vrf
->rmac
, rmac
, sizeof(struct ethaddr
));
4301 /* set the originator ip */
4302 bgp_vrf
->originator_ip
= originator_ip
;
4304 /* set the right filter - are we using l3vni only for prefix routes? */
4306 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
);
4308 /* auto derive RD/RT */
4309 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
4310 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
4311 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
))
4312 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
4313 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
4315 /* link all corresponding l2vnis */
4316 hash_iterate(bgp_def
->vnihash
,
4317 (void (*)(struct hash_backet
*,
4318 void *))link_l2vni_hash_to_l3vni
,
4321 /* Only update all corresponding type-2 routes if we are advertising two
4322 * labels along with type-2 routes
4325 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4326 update_routes_for_vni(bgp_def
, vpn
);
4328 /* advertise type-5 routes if needed */
4329 update_advertise_vrf_routes(bgp_vrf
);
4331 /* install all remote routes belonging to this l3vni into correspondng
4333 install_routes_for_vrf(bgp_vrf
);
4338 int bgp_evpn_local_l3vni_del(vni_t l3vni
, vrf_id_t vrf_id
)
4340 struct bgp
*bgp_vrf
= NULL
; /* bgp vrf instance */
4341 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
4342 struct listnode
*node
= NULL
;
4343 struct bgpevpn
*vpn
= NULL
;
4345 bgp_vrf
= bgp_lookup_by_vrf_id(vrf_id
);
4348 "Cannot process L3VNI %u Del - Could not find BGP instance",
4353 bgp_def
= bgp_get_default();
4356 "Cannot process L3VNI %u Del - Could not find default BGP instance",
4361 /* unimport remote routes from VRF, if it is AUTO vrf bgp_delete will
4362 * take care of uninstalling the routes from zebra
4364 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
4365 uninstall_routes_for_vrf(bgp_vrf
);
4367 /* delete/withdraw all type-5 routes */
4368 delete_withdraw_vrf_routes(bgp_vrf
);
4370 /* remove the l3vni from vrf instance */
4373 /* remove the Rmac from the BGP vrf */
4374 memset(&bgp_vrf
->rmac
, 0, sizeof(struct ethaddr
));
4377 if (bgp_vrf
->vrf_import_rtl
&& !list_isempty(bgp_vrf
->vrf_import_rtl
)) {
4378 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4379 list_delete_all_node(bgp_vrf
->vrf_import_rtl
);
4381 if (bgp_vrf
->vrf_export_rtl
&& !list_isempty(bgp_vrf
->vrf_export_rtl
)) {
4382 list_delete_all_node(bgp_vrf
->vrf_export_rtl
);
4385 /* update all corresponding local mac-ip routes */
4386 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)) {
4387 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
)) {
4388 UNSET_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
);
4389 update_routes_for_vni(bgp_def
, vpn
);
4393 /* Delete the instance if it was autocreated */
4394 if (CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
4395 bgp_delete(bgp_vrf
);
4401 * Handle del of a local VNI.
4403 int bgp_evpn_local_vni_del(struct bgp
*bgp
, vni_t vni
)
4405 struct bgpevpn
*vpn
;
4407 if (!bgp
->vnihash
) {
4408 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4412 /* Locate VNI hash */
4413 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4415 zlog_warn("%u: VNI hash entry for VNI %u not found at DEL",
4420 /* Remove all local EVPN routes and schedule for processing (to
4421 * withdraw from peers).
4423 delete_routes_for_vni(bgp
, vpn
);
4426 * tunnel is no longer active, del tunnel ip address from tip_hash
4428 bgp_tip_del(bgp
, &vpn
->originator_ip
);
4430 /* Clear "live" flag and see if hash needs to be freed. */
4431 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
4432 if (!is_vni_configured(vpn
))
4433 bgp_evpn_free(bgp
, vpn
);
4439 * Handle add (or update) of a local VNI. The VNI changes we care
4440 * about are for the local-tunnel-ip and the (tenant) VRF.
4442 int bgp_evpn_local_vni_add(struct bgp
*bgp
, vni_t vni
,
4443 struct in_addr originator_ip
, vrf_id_t tenant_vrf_id
)
4445 struct bgpevpn
*vpn
;
4446 struct prefix_evpn p
;
4448 if (!bgp
->vnihash
) {
4449 zlog_err("%u: VNI hash not created", bgp
->vrf_id
);
4453 /* Lookup VNI. If present and no change, exit. */
4454 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
4457 if (is_vni_live(vpn
)
4458 && IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
)
4459 && vpn
->tenant_vrf_id
== tenant_vrf_id
)
4460 /* Probably some other param has changed that we don't
4464 /* Update tenant_vrf_id if it has changed. */
4465 if (vpn
->tenant_vrf_id
!= tenant_vrf_id
) {
4466 bgpevpn_unlink_from_l3vni(vpn
);
4467 vpn
->tenant_vrf_id
= tenant_vrf_id
;
4468 bgpevpn_link_to_l3vni(vpn
);
4471 /* If tunnel endpoint IP has changed, update (and delete prior
4472 * type-3 route, if needed.)
4474 if (!IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
))
4475 handle_tunnel_ip_change(bgp
, vpn
, originator_ip
);
4477 /* Update all routes with new endpoint IP and/or export RT
4480 if (is_vni_live(vpn
))
4481 update_routes_for_vni(bgp
, vpn
);
4484 /* Create or update as appropriate. */
4486 vpn
= bgp_evpn_new(bgp
, vni
, originator_ip
, tenant_vrf_id
);
4489 "%u: Failed to allocate VNI entry for VNI %u - at Add",
4495 /* if the VNI is live already, there is nothing more to do */
4496 if (is_vni_live(vpn
))
4499 /* Mark as "live" */
4500 SET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
4502 /* tunnel is now active, add tunnel-ip to db */
4503 bgp_tip_add(bgp
, &originator_ip
);
4505 /* filter routes as nexthop database has changed */
4506 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
4508 /* Create EVPN type-3 route and schedule for processing. */
4509 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
4510 if (update_evpn_route(bgp
, vpn
, &p
, 0)) {
4511 zlog_err("%u: Type3 route creation failure for VNI %u",
4516 /* If we have learnt and retained remote routes (VTEPs, MACs) for this
4520 install_routes_for_vni(bgp
, vpn
);
4522 /* If we are advertising gateway mac-ip
4523 It needs to be conveyed again to zebra */
4524 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
, vpn
->vni
);
4530 * Cleanup EVPN information on disable - Need to delete and withdraw
4531 * EVPN routes from peers.
4533 void bgp_evpn_cleanup_on_disable(struct bgp
*bgp
)
4535 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
4536 void *))cleanup_vni_on_disable
,
4541 * Cleanup EVPN information - invoked at the time of bgpd exit or when the
4542 * BGP instance (default) is being freed.
4544 void bgp_evpn_cleanup(struct bgp
*bgp
)
4547 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
4548 void *))free_vni_entry
,
4550 if (bgp
->import_rt_hash
)
4551 hash_free(bgp
->import_rt_hash
);
4552 bgp
->import_rt_hash
= NULL
;
4553 if (bgp
->vrf_import_rt_hash
)
4554 hash_free(bgp
->vrf_import_rt_hash
);
4555 bgp
->vrf_import_rt_hash
= NULL
;
4557 hash_free(bgp
->vnihash
);
4558 bgp
->vnihash
= NULL
;
4559 if (bgp
->vrf_import_rtl
)
4560 list_delete_and_null(&bgp
->vrf_import_rtl
);
4561 if (bgp
->vrf_export_rtl
)
4562 list_delete_and_null(&bgp
->vrf_export_rtl
);
4564 list_delete_and_null(&bgp
->l2vnis
);
4565 bf_release_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
4569 * Initialization for EVPN
4572 * hash for RT to VNI
4573 * assign a unique rd id for auto derivation of vrf_prd
4575 void bgp_evpn_init(struct bgp
*bgp
)
4578 hash_create(vni_hash_key_make
, vni_hash_cmp
, "BGP VNI Hash");
4579 bgp
->import_rt_hash
=
4580 hash_create(import_rt_hash_key_make
, import_rt_hash_cmp
,
4581 "BGP Import RT Hash");
4582 bgp
->vrf_import_rt_hash
=
4583 hash_create(vrf_import_rt_hash_key_make
, vrf_import_rt_hash_cmp
,
4584 "BGP VRF Import RT Hash");
4585 bgp
->vrf_import_rtl
= list_new();
4586 bgp
->vrf_import_rtl
->cmp
=
4587 (int (*)(void *, void *))evpn_route_target_cmp
;
4589 bgp
->vrf_export_rtl
= list_new();
4590 bgp
->vrf_export_rtl
->cmp
=
4591 (int (*)(void *, void *))evpn_route_target_cmp
;
4592 bgp
->l2vnis
= list_new();
4593 bgp
->l2vnis
->cmp
= (int (*)(void *, void *))vni_hash_cmp
;
4594 bf_assign_index(bm
->rd_idspace
, bgp
->vrf_rd_id
);
4597 void bgp_evpn_vrf_delete(struct bgp
*bgp_vrf
)
4599 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);