bgpd/bgp_evpn_private.h

   1 /* BGP EVPN internal definitions
   2  * Copyright (C) 2017 Cumulus Networks, Inc.
   3  *
   4  * This file is part of FRR.
   5  *
   6  * FRR is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * FRR is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with FRR; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #ifndef _BGP_EVPN_PRIVATE_H
  23 #define _BGP_EVPN_PRIVATE_H
  24
  25 #include "vxlan.h"
  26 #include "zebra.h"
  27
  28 #include "bgpd/bgpd.h"
  29 #include "bgpd/bgp_ecommunity.h"
  30
  31 #define RT_ADDRSTRLEN 28
  32
  33 /* EVPN prefix lengths. This reprsent the sizeof struct prefix_evpn  */
  34 #define EVPN_ROUTE_PREFIXLEN     224
  35
  36 /* EVPN route types. */
  37 typedef enum {
  38         BGP_EVPN_AD_ROUTE = 1,    /* Ethernet Auto-Discovery (A-D) route */
  39         BGP_EVPN_MAC_IP_ROUTE,    /* MAC/IP Advertisement route */
  40         BGP_EVPN_IMET_ROUTE,      /* Inclusive Multicast Ethernet Tag route */
  41         BGP_EVPN_ES_ROUTE,      /* Ethernet Segment route */
  42         BGP_EVPN_IP_PREFIX_ROUTE, /* IP Prefix route */
  43 } bgp_evpn_route_type;
  44
  45 /*
  46  * Hash table of EVIs. Right now, the only type of EVI supported is with
  47  * VxLAN encapsulation, hence each EVI corresponds to a L2 VNI.
  48  * The VNIs are not "created" through BGP but through some other interface
  49  * on the system. This table stores VNIs that BGP comes to know as present
  50  * on the system (through interaction with zebra) as well as pre-configured
  51  * VNIs (which need to be defined in the system to become "live").
  52  */
  53 struct bgpevpn {
  54         vni_t vni;
  55         vrf_id_t tenant_vrf_id;
  56         uint32_t flags;
  57 #define VNI_FLAG_CFGD              0x1  /* VNI is user configured */
  58 #define VNI_FLAG_LIVE              0x2  /* VNI is "live" */
  59 #define VNI_FLAG_RD_CFGD           0x4  /* RD is user configured. */
  60 #define VNI_FLAG_IMPRT_CFGD        0x8  /* Import RT is user configured */
  61 #define VNI_FLAG_EXPRT_CFGD        0x10 /* Export RT is user configured */
  62 #define VNI_FLAG_USE_TWO_LABELS    0x20 /* Attach both L2-VNI and L3-VNI if
  63                                            needed for this VPN */
  64
  65         struct bgp *bgp_vrf; /* back pointer to the vrf instance */
  66
  67                                            /* Flag to indicate if we are
  68                                             * advertising the g/w mac ip for
  69                                             * this VNI*/
  70         uint8_t advertise_gw_macip;
  71
  72         /* Flag to indicate if we are
  73          * advertising subnet for this VNI */
  74         uint8_t advertise_subnet;
  75
  76         /* Id for deriving the RD
  77          * automatically for this VNI */
  78         uint16_t rd_id;
  79
  80         /* RD for this VNI. */
  81         struct prefix_rd prd;
  82
  83         /* Route type 3 field */
  84         struct in_addr originator_ip;
  85
  86         /* Import and Export RTs. */
  87         struct list *import_rtl;
  88         struct list *export_rtl;
  89
  90         /* Route table for EVPN routes for
  91          * this VNI. */
  92         struct bgp_table *route_table;
  93
  94         QOBJ_FIELDS
  95 };
  96
  97 DECLARE_QOBJ_TYPE(bgpevpn)
  98
  99 struct evpnes {
 100
 101         /* Ethernet Segment Identifier */
 102         esi_t esi;
 103
 104         /* es flags */
 105         uint16_t flags;
 106 #define EVPNES_LOCAL    0x01
 107 #define EVPNES_REMOTE   0x02
 108
 109         /*
 110          * Id for deriving the RD
 111          * automatically for this ESI
 112          */
 113         uint16_t rd_id;
 114
 115         /* RD for this VNI. */
 116         struct prefix_rd prd;
 117
 118         /* originator ip address  */
 119         struct ipaddr originator_ip;
 120
 121         /* list of VTEPs in the same site */
 122         struct list *vtep_list;
 123
 124         /*
 125          * Route table for EVPN routes for
 126          * this ESI. - type4 routes
 127          */
 128         struct bgp_table *route_table;
 129
 130         QOBJ_FIELDS
 131 };
 132
 133 DECLARE_QOBJ_TYPE(evpnes)
 134
 135 /* Mapping of Import RT to VNIs.
 136  * The Import RTs of all VNIs are maintained in a hash table with each
 137  * RT linking to all VNIs that will import routes matching this RT.
 138  */
 139 struct irt_node {
 140         /* RT */
 141         struct ecommunity_val rt;
 142
 143         /* List of VNIs importing routes matching this RT. */
 144         struct list *vnis;
 145 };
 146
 147 /* Mapping of Import RT to VRFs.
 148  * The Import RTs of all VRFss are maintained in a hash table with each
 149  * RT linking to all VRFs that will import routes matching this RT.
 150  */
 151 struct vrf_irt_node {
 152         /* RT */
 153         struct ecommunity_val rt;
 154
 155         /* List of VNIs importing routes matching this RT. */
 156         struct list *vrfs;
 157 };
 158
 159
 160 #define RT_TYPE_IMPORT 1
 161 #define RT_TYPE_EXPORT 2
 162 #define RT_TYPE_BOTH   3
 163
 164 static inline int is_vrf_rd_configured(struct bgp *bgp_vrf)
 165 {
 166         return (CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_RD_CFGD));
 167 }
 168
 169 static inline int bgp_evpn_vrf_rd_matches_existing(struct bgp *bgp_vrf,
 170                                                    struct prefix_rd *prd)
 171 {
 172         return (memcmp(&bgp_vrf->vrf_prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
 173 }
 174
 175 static inline vni_t bgpevpn_get_l3vni(struct bgpevpn *vpn)
 176 {
 177         return vpn->bgp_vrf ? vpn->bgp_vrf->l3vni : 0;
 178 }
 179
 180 static inline void bgpevpn_get_rmac(struct bgpevpn *vpn, struct ethaddr *rmac)
 181 {
 182         memset(rmac, 0, sizeof(struct ethaddr));
 183         if (!vpn->bgp_vrf)
 184                 return;
 185         memcpy(rmac, &vpn->bgp_vrf->rmac, sizeof(struct ethaddr));
 186 }
 187
 188 static inline struct list *bgpevpn_get_vrf_export_rtl(struct bgpevpn *vpn)
 189 {
 190         if (!vpn->bgp_vrf)
 191                 return NULL;
 192
 193         return vpn->bgp_vrf->vrf_export_rtl;
 194 }
 195
 196 static inline struct list *bgpevpn_get_vrf_import_rtl(struct bgpevpn *vpn)
 197 {
 198         if (!vpn->bgp_vrf)
 199                 return NULL;
 200
 201         return vpn->bgp_vrf->vrf_import_rtl;
 202 }
 203
 204 static inline void bgpevpn_unlink_from_l3vni(struct bgpevpn *vpn)
 205 {
 206         /* bail if vpn is not associated to bgp_vrf */
 207         if (!vpn->bgp_vrf)
 208                 return;
 209
 210         UNSET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
 211         listnode_delete(vpn->bgp_vrf->l2vnis, vpn);
 212
 213         /* remove the backpointer to the vrf instance */
 214         vpn->bgp_vrf = NULL;
 215 }
 216
 217 static inline void bgpevpn_link_to_l3vni(struct bgpevpn *vpn)
 218 {
 219         struct bgp *bgp_vrf = NULL;
 220
 221         /* bail if vpn is already associated to vrf */
 222         if (vpn->bgp_vrf)
 223                 return;
 224
 225         bgp_vrf = bgp_lookup_by_vrf_id(vpn->tenant_vrf_id);
 226         if (!bgp_vrf)
 227                 return;
 228
 229         /* associate the vpn to the bgp_vrf instance */
 230         vpn->bgp_vrf = bgp_vrf;
 231         listnode_add_sort(bgp_vrf->l2vnis, vpn);
 232
 233         /* check if we are advertising two labels for this vpn */
 234         if (!CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY))
 235                 SET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
 236 }
 237
 238 static inline int is_vni_configured(struct bgpevpn *vpn)
 239 {
 240         return (CHECK_FLAG(vpn->flags, VNI_FLAG_CFGD));
 241 }
 242
 243 static inline int is_vni_live(struct bgpevpn *vpn)
 244 {
 245         return (CHECK_FLAG(vpn->flags, VNI_FLAG_LIVE));
 246 }
 247
 248 static inline int is_rd_configured(struct bgpevpn *vpn)
 249 {
 250         return (CHECK_FLAG(vpn->flags, VNI_FLAG_RD_CFGD));
 251 }
 252
 253 static inline int bgp_evpn_rd_matches_existing(struct bgpevpn *vpn,
 254                                                struct prefix_rd *prd)
 255 {
 256         return (memcmp(&vpn->prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
 257 }
 258
 259 static inline int is_import_rt_configured(struct bgpevpn *vpn)
 260 {
 261         return (CHECK_FLAG(vpn->flags, VNI_FLAG_IMPRT_CFGD));
 262 }
 263
 264 static inline int is_export_rt_configured(struct bgpevpn *vpn)
 265 {
 266         return (CHECK_FLAG(vpn->flags, VNI_FLAG_EXPRT_CFGD));
 267 }
 268
 269 static inline int is_vni_param_configured(struct bgpevpn *vpn)
 270 {
 271         return (is_rd_configured(vpn) || is_import_rt_configured(vpn)
 272                 || is_export_rt_configured(vpn));
 273 }
 274
 275 static inline void encode_es_rt_extcomm(struct ecommunity_val *eval,
 276                                         struct ethaddr *mac)
 277 {
 278         memset(eval, 0, sizeof(struct ecommunity_val));
 279         eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
 280         eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ES_IMPORT_RT;
 281         memcpy(&eval->val[2], mac, ETH_ALEN);
 282 }
 283
 284 static inline void encode_rmac_extcomm(struct ecommunity_val *eval,
 285                                        struct ethaddr *rmac)
 286 {
 287         memset(eval, 0, sizeof(*eval));
 288         eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
 289         eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC;
 290         memcpy(&eval->val[2], rmac, ETH_ALEN);
 291 }
 292
 293 static inline void encode_default_gw_extcomm(struct ecommunity_val *eval)
 294 {
 295         memset(eval, 0, sizeof(*eval));
 296         eval->val[0] = ECOMMUNITY_ENCODE_OPAQUE;
 297         eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_DEF_GW;
 298 }
 299
 300 static inline void encode_mac_mobility_extcomm(int static_mac, uint32_t seq,
 301                                                struct ecommunity_val *eval)
 302 {
 303         memset(eval, 0, sizeof(*eval));
 304         eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
 305         eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY;
 306         if (static_mac)
 307                 eval->val[2] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY_FLAG_STICKY;
 308         eval->val[4] = (seq >> 24) & 0xff;
 309         eval->val[5] = (seq >> 16) & 0xff;
 310         eval->val[6] = (seq >> 8) & 0xff;
 311         eval->val[7] = seq & 0xff;
 312 }
 313
 314 static inline void ip_prefix_from_type5_prefix(struct prefix_evpn *evp,
 315                                                struct prefix *ip)
 316 {
 317         memset(ip, 0, sizeof(struct prefix));
 318         if (is_evpn_prefix_ipaddr_v4(evp)) {
 319                 ip->family = AF_INET;
 320                 ip->prefixlen = evp->prefix.prefix_addr.ip_prefix_length;
 321                 memcpy(&(ip->u.prefix4), &(evp->prefix.prefix_addr.ip.ip),
 322                        IPV4_MAX_BYTELEN);
 323         } else if (is_evpn_prefix_ipaddr_v6(evp)) {
 324                 ip->family = AF_INET6;
 325                 ip->prefixlen = evp->prefix.prefix_addr.ip_prefix_length;
 326                 memcpy(&(ip->u.prefix6), &(evp->prefix.prefix_addr.ip.ip),
 327                        IPV6_MAX_BYTELEN);
 328         }
 329 }
 330
 331 static inline int is_evpn_prefix_default(const struct prefix *evp)
 332 {
 333         if (evp->family != AF_EVPN)
 334                 return 0;
 335
 336         return ((evp->u.prefix_evpn.prefix_addr.ip_prefix_length  == 0) ?
 337                 1 : 0);
 338 }
 339
 340 static inline void ip_prefix_from_type2_prefix(struct prefix_evpn *evp,
 341                                                struct prefix *ip)
 342 {
 343         memset(ip, 0, sizeof(struct prefix));
 344         if (is_evpn_prefix_ipaddr_v4(evp)) {
 345                 ip->family = AF_INET;
 346                 ip->prefixlen = IPV4_MAX_BITLEN;
 347                 memcpy(&(ip->u.prefix4), &(evp->prefix.macip_addr.ip.ip),
 348                        IPV4_MAX_BYTELEN);
 349         } else if (is_evpn_prefix_ipaddr_v6(evp)) {
 350                 ip->family = AF_INET6;
 351                 ip->prefixlen = IPV6_MAX_BITLEN;
 352                 memcpy(&(ip->u.prefix6), &(evp->prefix.macip_addr.ip.ip),
 353                        IPV6_MAX_BYTELEN);
 354         }
 355 }
 356
 357 static inline void ip_prefix_from_evpn_prefix(struct prefix_evpn *evp,
 358                                               struct prefix *ip)
 359 {
 360         if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE)
 361                 ip_prefix_from_type2_prefix(evp, ip);
 362         else if (evp->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE)
 363                 ip_prefix_from_type5_prefix(evp, ip);
 364 }
 365
 366 static inline void build_evpn_type2_prefix(struct prefix_evpn *p,
 367                                            struct ethaddr *mac,
 368                                            struct ipaddr *ip)
 369 {
 370         memset(p, 0, sizeof(struct prefix_evpn));
 371         p->family = AF_EVPN;
 372         p->prefixlen = EVPN_ROUTE_PREFIXLEN;
 373         p->prefix.route_type = BGP_EVPN_MAC_IP_ROUTE;
 374         memcpy(&p->prefix.macip_addr.mac.octet, mac->octet, ETH_ALEN);
 375         p->prefix.macip_addr.ip.ipa_type = IPADDR_NONE;
 376         if (ip)
 377                 memcpy(&p->prefix.macip_addr.ip, ip, sizeof(*ip));
 378 }
 379
 380 static inline void build_type5_prefix_from_ip_prefix(struct prefix_evpn *evp,
 381                                                      struct prefix *ip_prefix)
 382 {
 383         struct ipaddr ip;
 384
 385         memset(&ip, 0, sizeof(struct ipaddr));
 386         if (ip_prefix->family == AF_INET) {
 387                 ip.ipa_type = IPADDR_V4;
 388                 memcpy(&ip.ipaddr_v4, &ip_prefix->u.prefix4,
 389                        sizeof(struct in_addr));
 390         } else {
 391                 ip.ipa_type = IPADDR_V6;
 392                 memcpy(&ip.ipaddr_v6, &ip_prefix->u.prefix6,
 393                        sizeof(struct in6_addr));
 394         }
 395
 396         memset(evp, 0, sizeof(struct prefix_evpn));
 397         evp->family = AF_EVPN;
 398         evp->prefixlen = EVPN_ROUTE_PREFIXLEN;
 399         evp->prefix.route_type = BGP_EVPN_IP_PREFIX_ROUTE;
 400         evp->prefix.prefix_addr.ip_prefix_length = ip_prefix->prefixlen;
 401         evp->prefix.prefix_addr.ip.ipa_type = ip.ipa_type;
 402         memcpy(&evp->prefix.prefix_addr.ip, &ip, sizeof(struct ipaddr));
 403 }
 404
 405 static inline void build_evpn_type3_prefix(struct prefix_evpn *p,
 406                                            struct in_addr originator_ip)
 407 {
 408         memset(p, 0, sizeof(struct prefix_evpn));
 409         p->family = AF_EVPN;
 410         p->prefixlen = EVPN_ROUTE_PREFIXLEN;
 411         p->prefix.route_type = BGP_EVPN_IMET_ROUTE;
 412         p->prefix.imet_addr.ip.ipa_type = IPADDR_V4;
 413         p->prefix.imet_addr.ip.ipaddr_v4 = originator_ip;
 414 }
 415
 416 static inline void build_evpn_type4_prefix(struct prefix_evpn *p,
 417                                            esi_t *esi,
 418                                            struct in_addr originator_ip)
 419 {
 420         memset(p, 0, sizeof(struct prefix_evpn));
 421         p->family = AF_EVPN;
 422         p->prefixlen = EVPN_ROUTE_PREFIXLEN;
 423         p->prefix.route_type = BGP_EVPN_ES_ROUTE;
 424         p->prefix.es_addr.ip_prefix_length = IPV4_MAX_BITLEN;
 425         p->prefix.es_addr.ip.ipa_type = IPADDR_V4;
 426         p->prefix.es_addr.ip.ipaddr_v4 = originator_ip;
 427         memcpy(&p->prefix.es_addr.esi, esi, sizeof(esi_t));
 428 }
 429
 430 static inline int evpn_default_originate_set(struct bgp *bgp, afi_t afi,
 431                                              safi_t safi)
 432 {
 433         if (afi == AFI_IP &&
 434             CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
 435                        BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4))
 436                 return 1;
 437         else if (afi == AFI_IP6 &&
 438                  CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
 439                             BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6))
 440                 return 1;
 441         return 0;
 442 }
 443
 444 static inline void es_get_system_mac(esi_t *esi,
 445                                      struct ethaddr *mac)
 446 {
 447         /*
 448          * for type-1 and type-3 ESIs,
 449          * the system mac starts at val[1]
 450          */
 451         memcpy(mac, &esi->val[1], ETH_ALEN);
 452 }
 453
 454 static inline int is_es_local(struct evpnes *es)
 455 {
 456         return CHECK_FLAG(es->flags, EVPNES_LOCAL) ? 1 : 0;
 457 }
 458
 459 extern void evpn_rt_delete_auto(struct bgp *, vni_t, struct list *);
 460 extern void bgp_evpn_configure_export_rt_for_vrf(struct bgp *bgp_vrf,
 461                                                  struct ecommunity *ecomadd);
 462 extern void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp *bgp_vrf,
 463                                                    struct ecommunity *ecomdel);
 464 extern void bgp_evpn_configure_import_rt_for_vrf(struct bgp *bgp_vrf,
 465                                                  struct ecommunity *ecomadd);
 466 extern void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp *bgp_vrf,
 467                                                    struct ecommunity *ecomdel);
 468 extern int bgp_evpn_handle_export_rt_change(struct bgp *bgp,
 469                                             struct bgpevpn *vpn);
 470 extern void bgp_evpn_handle_autort_change(struct bgp *bgp);
 471 extern void bgp_evpn_handle_vrf_rd_change(struct bgp *bgp_vrf, int withdraw);
 472 extern void bgp_evpn_handle_rd_change(struct bgp *bgp, struct bgpevpn *vpn,
 473                                       int withdraw);
 474 extern int bgp_evpn_install_routes(struct bgp *bgp, struct bgpevpn *vpn);
 475 extern int bgp_evpn_uninstall_routes(struct bgp *bgp, struct bgpevpn *vpn);
 476 extern void bgp_evpn_map_vrf_to_its_rts(struct bgp *bgp_vrf);
 477 extern void bgp_evpn_unmap_vrf_from_its_rts(struct bgp *bgp_vrf);
 478 extern void bgp_evpn_map_vni_to_its_rts(struct bgp *bgp, struct bgpevpn *vpn);
 479 extern void bgp_evpn_unmap_vni_from_its_rts(struct bgp *bgp,
 480                                             struct bgpevpn *vpn);
 481 extern void bgp_evpn_derive_auto_rt_import(struct bgp *bgp,
 482                                            struct bgpevpn *vpn);
 483 extern void bgp_evpn_derive_auto_rt_export(struct bgp *bgp,
 484                                            struct bgpevpn *vpn);
 485 extern void bgp_evpn_derive_auto_rd(struct bgp *bgp, struct bgpevpn *vpn);
 486 extern void bgp_evpn_derive_auto_rd_for_vrf(struct bgp *bgp);
 487 extern struct bgpevpn *bgp_evpn_lookup_vni(struct bgp *bgp, vni_t vni);
 488 extern struct bgpevpn *bgp_evpn_new(struct bgp *bgp, vni_t vni,
 489                                     struct in_addr originator_ip,
 490                                     vrf_id_t tenant_vrf_id);
 491 extern void bgp_evpn_free(struct bgp *bgp, struct bgpevpn *vpn);
 492 extern struct evpnes *bgp_evpn_lookup_es(struct bgp *bgp, esi_t *esi);
 493 extern struct evpnes *bgp_evpn_es_new(struct bgp *bgp, esi_t *esi,
 494                                       struct ipaddr *originator_ip);
 495 extern void bgp_evpn_es_free(struct bgp *bgp, struct evpnes *es);
 496 #endif /* _BGP_EVPN_PRIVATE_H */