zebra/zebra_evpn_mh.h

   1 /*
   2  * Zebra EVPN MH Data structures and definitions
   3  *
   4  * Copyright (C) 2019 Cumulus Networks, Inc.
   5  * Anuradha Karuppiah
   6  *
   7  * This file is part of FRR.
   8  *
   9  * FRR is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the
  11  * Free Software Foundation; either version 2, or (at your option) any
  12  * later version.
  13  *
  14  * FRR is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  */
  19
  20 #ifndef _ZEBRA_EVPN_MH_H
  21 #define _ZEBRA_EVPN_MH_H
  22
  23 #include <zebra.h>
  24
  25 #include "if.h"
  26 #include "linklist.h"
  27 #include "bitfield.h"
  28 #include "zebra_vxlan.h"
  29 #include "zebra_vxlan_private.h"
  30 #include "zebra_nhg.h"
  31
  32 #define EVPN_MH_VTY_STR "Multihoming\n"
  33
  34 /* Ethernet Segment entry -
  35  * - Local and remote ESs are maintained in a global RB tree,
  36  * zmh_info->es_rb_tree using ESI as key
  37  * - Local ESs are added via zebra config (ZEBRA_EVPNES_LOCAL) when an
  38  *   access port is associated with an ES-ID
  39  * - Remotes ESs are added by BGP based on received/remote EAD/Type-1 routes
  40  *   (ZEBRA_EVPNES_REMOTE)
  41  * - An ES can be simulatenously LOCAL and REMOTE; infact all LOCAL ESs are
  42  *   expected to have REMOTE ES peers.
  43  */
  44 struct zebra_evpn_es {
  45         esi_t esi;
  46         char esi_str[ESI_STR_LEN];
  47
  48         /* ES flags */
  49         uint32_t flags;
  50 #define ZEBRA_EVPNES_LOCAL         (1 << 0) /* configured in zebra */
  51 #define ZEBRA_EVPNES_REMOTE        (1 << 1) /* added by bgp */
  52 #define ZEBRA_EVPNES_OPER_UP       (1 << 2) /* es->ifp is oper-up */
  53 #define ZEBRA_EVPNES_READY_FOR_BGP (1 << 3) /* ready to be sent to BGP */
  54 #define ZEBRA_EVPNES_NHG_ACTIVE    (1 << 4) /* NHG has been installed */
  55 /* This flag is only applicable to local ESs and signifies that this
  56  * VTEP is not the DF
  57  */
  58 #define ZEBRA_EVPNES_NON_DF (1 << 5)
  59 /* When the ES becomes a bridge port we need to activate the BUM non-DF
  60  * filter, SPH filter and backup NHG for fast-failover
  61  */
  62 #define ZEBRA_EVPNES_BR_PORT (1 << 6)
  63 /* ES is in bypass mode i.e. must not be advertised. ES-bypass is set
  64  * when the associated host bond goes into LACP bypass
  65  */
  66 #define ZEBRA_EVPNES_BYPASS (1 << 7)
  67
  68         /* memory used for adding the es to zmh_info->es_rb_tree */
  69         RB_ENTRY(zebra_evpn_es) rb_node;
  70
  71         /* [EVPNES_LOCAL] memory used for linking the es to
  72          * zmh_info->local_es_list
  73          */
  74         struct listnode local_es_listnode;
  75
  76         /* [EVPNES_LOCAL] corresponding interface */
  77         struct zebra_if *zif;
  78
  79         /* list of ES-EVIs associated with the ES */
  80         struct list *es_evi_list;
  81
  82         /* [!EVPNES_LOCAL] List of remote VTEPs (zebra_evpn_es_vtep) */
  83         struct list *es_vtep_list;
  84
  85         /* list of zebra_mac entries using this ES as destination */
  86         struct list *mac_list;
  87
  88         /* Nexthop group id */
  89         uint32_t nhg_id;
  90
  91         /* Preference config for BUM-DF election. Sent to BGP and
  92          * advertised via the ESR
  93          */
  94         uint16_t df_pref;
  95
  96         /* When a new ES is configured it is held in a non-DF state
  97          * for 3 seconds. This allows the peer Type-4 routes to be
  98          * imported before running the DF election.
  99          */
 100 #define ZEBRA_EVPN_MH_DF_DELAY_TIME 3 /* seconds */
 101         struct thread *df_delay_timer;
 102 };
 103 RB_HEAD(zebra_es_rb_head, zebra_evpn_es);
 104 RB_PROTOTYPE(zebra_es_rb_head, zebra_evpn_es, rb_node, zebra_es_rb_cmp);
 105
 106 /* ES per-EVI info
 107  * - ES-EVIs are maintained per-EVPN (vni->es_evi_rb_tree)
 108  * - Local ES-EVIs are linked to per-EVPN list for quick access
 109  * - Although some infrastucture is present for remote ES-EVIs, currently
 110  *   BGP does NOT send remote ES-EVIs to zebra. This may change in the
 111  *   future (but must be changed thoughtfully and only if needed as ES-EVI
 112  *   can get prolific and come in the way of rapid failovers)
 113  */
 114 struct zebra_evpn_es_evi {
 115         struct zebra_evpn_es *es;
 116         struct zebra_evpn *zevpn;
 117
 118         /* ES-EVI flags */
 119         uint32_t flags;
 120         /* local ES-EVI */
 121 #define ZEBRA_EVPNES_EVI_LOCAL         (1 << 0) /* created by zebra */
 122 #define ZEBRA_EVPNES_EVI_READY_FOR_BGP (1 << 1) /* ready to be sent to BGP */
 123
 124         /* memory used for adding the es_evi to
 125          * es_evi->zevpn->es_evi_rb_tree
 126          */
 127         RB_ENTRY(zebra_evpn_es_evi) rb_node;
 128         /* memory used for linking the es_evi to
 129          * es_evi->zevpn->local_es_evi_list
 130          */
 131         struct listnode l2vni_listnode;
 132         /* memory used for linking the es_evi to
 133          * es_evi->es->es_evi_list
 134          */
 135         struct listnode es_listnode;
 136 };
 137
 138 /* A single L2 nexthop is allocated across all ESs with the same PE/VTEP
 139  * nexthop
 140  */
 141 struct zebra_evpn_l2_nh {
 142         struct in_addr vtep_ip;
 143
 144         /* MAC nexthop id */
 145         uint32_t nh_id;
 146
 147         /* es_vtep entries using this nexthop */
 148         uint32_t ref_cnt;
 149 };
 150
 151 /* PE attached to an ES */
 152 struct zebra_evpn_es_vtep {
 153         struct zebra_evpn_es *es; /* parent ES */
 154         struct in_addr vtep_ip;
 155
 156         uint32_t flags;
 157         /* Rxed Type-4 route from this VTEP */
 158 #define ZEBRA_EVPNES_VTEP_RXED_ESR (1 << 0)
 159 #define ZEBRA_EVPNES_VTEP_DEL_IN_PROG (1 << 1)
 160
 161         /* MAC nexthop info */
 162         struct zebra_evpn_l2_nh *nh;
 163
 164         /* memory used for adding the entry to es->es_vtep_list */
 165         struct listnode es_listnode;
 166
 167         /* Parameters for DF election */
 168         uint8_t df_alg;
 169         uint32_t df_pref;
 170
 171         /* XXX - maintain a backpointer to struct zebra_vtep */
 172 };
 173
 174 /* Local/access-side broadcast domain - zebra_evpn_access_bd is added to -
 175  * zrouter->evpn_vlan_table (for VLAN aware bridges) OR
 176  * zrouter->evpn_bridge_table (for VLAN unaware bridges)
 177  * XXX - support for VLAN unaware bridges is yet to be flushed out
 178  */
 179 struct zebra_evpn_access_bd {
 180         vlanid_t vid;
 181
 182         struct zebra_if *vxlan_zif; /* vxlan device */
 183         /* list of members associated with the BD i.e. (potential) ESs */
 184         struct list *mbr_zifs;
 185         /* presence of zevpn activates the EVI on all the ESs in mbr_zifs */
 186         struct zebra_evpn *zevpn;
 187         /* SVI associated with the VLAN */
 188         struct zebra_if *vlan_zif;
 189 };
 190
 191 /* multihoming information stored in zrouter */
 192 #define zmh_info (zrouter.mh_info)
 193 struct zebra_evpn_mh_info {
 194         uint32_t flags;
 195 /* If the dataplane is not capable of handling a backup NHG on an access
 196  * port we will need to explicitly failover each MAC entry on
 197  * local ES down
 198  */
 199 #define ZEBRA_EVPN_MH_REDIRECT_OFF (1 << 0)
 200 /* DAD support for EVPN-MH is yet to be added. So on detection of
 201  * first local ES, DAD is turned off
 202  */
 203 #define ZEBRA_EVPN_MH_DUP_ADDR_DETECT_OFF (1 << 1)
 204 /* If EVPN MH is enabled we only advertise REACHABLE neigh entries as Type-2
 205  * routes. As there is no global config knob for enabling EVPN MH we turn
 206  * this flag when the first local ES is detected.
 207  */
 208 #define ZEBRA_EVPN_MH_ADV_REACHABLE_NEIGH_ONLY (1 << 2)
 209 /* If EVPN MH is enabled we advertise the SVI MAC address to avoid
 210  * flooding of ARP replies rxed from the multi-homed host
 211  */
 212 #define ZEBRA_EVPN_MH_ADV_SVI_MAC (1 << 3)
 213
 214         /* RB tree of Ethernet segments (used for EVPN-MH)  */
 215         struct zebra_es_rb_head es_rb_tree;
 216         /* List of local ESs */
 217         struct list *local_es_list;
 218
 219         /* EVPN MH broadcast domains indexed by the VID */
 220         struct hash *evpn_vlan_table;
 221
 222         /* A base L2-VNI is maintained to derive parameters such as
 223          * ES originator-IP.
 224          * XXX: once single vxlan device model becomes available this will
 225          * not be necessary
 226          */
 227         struct zebra_evpn *es_base_evpn;
 228         struct in_addr es_originator_ip;
 229
 230         /* L2 NH and NHG ids -
 231          * Most significant 4 bits is type. Lower 28 bits is the value
 232          * allocated from the nh_id_bitmap.
 233          */
 234         bitfield_t nh_id_bitmap;
 235 #define EVPN_NH_ID_MAX       (16*1024)
 236 #define EVPN_NH_ID_VAL_MASK  0xffffff
 237 /* The purpose of using different types for NHG and NH is NOT to manage the
 238  * id space separately. It is simply to make debugging easier.
 239  */
 240 #define EVPN_NH_ID_TYPE_BIT (NHG_TYPE_L2_NH << NHG_ID_TYPE_POS)
 241 #define EVPN_NHG_ID_TYPE_BIT (NHG_TYPE_L2 << NHG_ID_TYPE_POS)
 242         /* L2-NHG table - key: nhg_id, data: zebra_evpn_es */
 243         struct hash *nhg_table;
 244         /* L2-NH table - key: vtep_up, data: zebra_evpn_nh */
 245         struct hash *nh_ip_table;
 246
 247         /* XXX - re-visit the default hold timer value */
 248         int mac_hold_time;
 249 #define ZEBRA_EVPN_MH_MAC_HOLD_TIME_DEF (18 * 60)
 250         int neigh_hold_time;
 251 #define ZEBRA_EVPN_MH_NEIGH_HOLD_TIME_DEF (18 * 60)
 252
 253         /* During this period access ports will be held in a protodown
 254          * state
 255          */
 256         int startup_delay_time; /* seconds */
 257 #define ZEBRA_EVPN_MH_STARTUP_DELAY_DEF (3 * 60)
 258         struct thread *startup_delay_timer;
 259
 260         /* Number of configured uplinks */
 261         uint32_t uplink_cfg_cnt;
 262         /* Number of operationally-up uplinks */
 263         uint32_t uplink_oper_up_cnt;
 264
 265         /* These protodown bits are inherited by all ES bonds */
 266         uint32_t protodown_rc;
 267 };
 268
 269 /* returns TRUE if the EVPN is ready to be sent to BGP */
 270 static inline bool zebra_evpn_send_to_client_ok(struct zebra_evpn *zevpn)
 271 {
 272         return !!(zevpn->flags & ZEVPN_READY_FOR_BGP);
 273 }
 274
 275 static inline bool zebra_evpn_mac_is_es_local(struct zebra_mac *mac)
 276 {
 277         return mac->es && (mac->es->flags & ZEBRA_EVPNES_LOCAL);
 278 }
 279
 280 /* Returns true if the id is of L2-NHG or L2-NH type */
 281 static inline bool zebra_evpn_mh_is_fdb_nh(uint32_t id)
 282 {
 283         return ((id & EVPN_NHG_ID_TYPE_BIT) ||
 284                         (id & EVPN_NH_ID_TYPE_BIT));
 285 }
 286
 287 static inline bool
 288 zebra_evpn_es_local_mac_via_network_port(struct zebra_evpn_es *es)
 289 {
 290         return !(es->flags & ZEBRA_EVPNES_OPER_UP)
 291                && (zmh_info->flags & ZEBRA_EVPN_MH_REDIRECT_OFF);
 292 }
 293
 294 static inline bool zebra_evpn_mh_do_dup_addr_detect(void)
 295 {
 296         return !(zmh_info->flags & ZEBRA_EVPN_MH_DUP_ADDR_DETECT_OFF);
 297 }
 298
 299 static inline bool zebra_evpn_mh_do_adv_reachable_neigh_only(void)
 300 {
 301         return !!(zmh_info->flags & ZEBRA_EVPN_MH_ADV_REACHABLE_NEIGH_ONLY);
 302 }
 303
 304 static inline bool zebra_evpn_mh_do_adv_svi_mac(void)
 305 {
 306         return zmh_info && (zmh_info->flags & ZEBRA_EVPN_MH_ADV_SVI_MAC);
 307 }
 308
 309 /*****************************************************************************/
 310 extern esi_t *zero_esi;
 311 extern void zebra_evpn_mh_init(void);
 312 extern void zebra_evpn_mh_terminate(void);
 313 extern bool zebra_evpn_is_if_es_capable(struct zebra_if *zif);
 314 extern void zebra_evpn_if_init(struct zebra_if *zif);
 315 extern void zebra_evpn_if_cleanup(struct zebra_if *zif);
 316 extern void zebra_evpn_es_evi_init(struct zebra_evpn *zevpn);
 317 extern void zebra_evpn_es_evi_cleanup(struct zebra_evpn *zevpn);
 318 extern void zebra_evpn_vxl_evpn_set(struct zebra_if *zif,
 319                                     struct zebra_evpn *zevpn, bool set);
 320 extern void zebra_evpn_es_set_base_evpn(struct zebra_evpn *zevpn);
 321 extern void zebra_evpn_es_clear_base_evpn(struct zebra_evpn *zevpn);
 322 extern void zebra_evpn_vl_vxl_ref(uint16_t vid, struct zebra_if *vxlan_zif);
 323 extern void zebra_evpn_vl_vxl_deref(uint16_t vid, struct zebra_if *vxlan_zif);
 324 extern void zebra_evpn_vl_mbr_ref(uint16_t vid, struct zebra_if *zif);
 325 extern void zebra_evpn_vl_mbr_deref(uint16_t vid, struct zebra_if *zif);
 326 extern void zebra_evpn_es_send_all_to_client(bool add);
 327 extern void zebra_evpn_es_if_oper_state_change(struct zebra_if *zif, bool up);
 328 extern void zebra_evpn_es_show(struct vty *vty, bool uj);
 329 extern void zebra_evpn_es_show_detail(struct vty *vty, bool uj);
 330 extern void zebra_evpn_es_show_esi(struct vty *vty, bool uj, esi_t *esi);
 331 extern void zebra_evpn_update_all_es(struct zebra_evpn *zevpn);
 332 extern void zebra_evpn_proc_remote_es(ZAPI_HANDLER_ARGS);
 333 int zebra_evpn_remote_es_add(const esi_t *esi, struct in_addr vtep_ip,
 334                              bool esr_rxed, uint8_t df_alg, uint16_t df_pref);
 335 int zebra_evpn_remote_es_del(const esi_t *esi, struct in_addr vtep_ip);
 336 extern void zebra_evpn_es_evi_show(struct vty *vty, bool uj, int detail);
 337 extern void zebra_evpn_es_evi_show_vni(struct vty *vty, bool uj,
 338                 vni_t vni, int detail);
 339 extern void zebra_evpn_es_mac_deref_entry(struct zebra_mac *mac);
 340 extern bool zebra_evpn_es_mac_ref_entry(struct zebra_mac *mac,
 341                                         struct zebra_evpn_es *es);
 342 extern bool zebra_evpn_es_mac_ref(struct zebra_mac *mac, const esi_t *esi);
 343 extern struct zebra_evpn_es *zebra_evpn_es_find(const esi_t *esi);
 344 extern void zebra_evpn_interface_init(void);
 345 extern int zebra_evpn_mh_if_write(struct vty *vty, struct interface *ifp);
 346 extern void zebra_evpn_acc_vl_show(struct vty *vty, bool uj);
 347 extern void zebra_evpn_acc_vl_show_detail(struct vty *vty, bool uj);
 348 extern void zebra_evpn_acc_vl_show_vid(struct vty *vty, bool uj, vlanid_t vid);
 349 extern void zebra_evpn_if_es_print(struct vty *vty, json_object *json,
 350                                    struct zebra_if *zif);
 351 extern void zebra_evpn_es_cleanup(void);
 352 extern int zebra_evpn_mh_mac_holdtime_update(struct vty *vty,
 353                 uint32_t duration, bool set_default);
 354 void zebra_evpn_mh_config_write(struct vty *vty);
 355 int zebra_evpn_mh_neigh_holdtime_update(struct vty *vty,
 356                 uint32_t duration, bool set_default);
 357 void zebra_evpn_es_local_br_port_update(struct zebra_if *zif);
 358 extern int zebra_evpn_mh_startup_delay_update(struct vty *vty,
 359                                               uint32_t duration,
 360                                               bool set_default);
 361 extern void zebra_evpn_mh_uplink_oper_update(struct zebra_if *zif);
 362 extern void zebra_evpn_mh_update_protodown_bond_mbr(struct zebra_if *zif,
 363                                                     bool clear,
 364                                                     const char *caller);
 365 extern bool zebra_evpn_is_es_bond(struct interface *ifp);
 366 extern bool zebra_evpn_is_es_bond_member(struct interface *ifp);
 367 extern void zebra_evpn_mh_print(struct vty *vty);
 368 extern void zebra_evpn_mh_json(json_object *json);
 369 extern bool zebra_evpn_nhg_is_local_es(uint32_t nhg_id,
 370                                        struct zebra_evpn_es **local_es);
 371 extern int zebra_evpn_mh_redirect_off(struct vty *vty, bool redirect_off);
 372 extern int zebra_evpn_mh_startup_delay_update(struct vty *vty,
 373                                               uint32_t duration,
 374                                               bool set_default);
 375 extern void zebra_evpn_mh_uplink_oper_update(struct zebra_if *zif);
 376 extern void zebra_evpn_mh_update_protodown_bond_mbr(struct zebra_if *zif,
 377                                                     bool clear,
 378                                                     const char *caller);
 379 extern bool zebra_evpn_is_es_bond(struct interface *ifp);
 380 extern bool zebra_evpn_is_es_bond_member(struct interface *ifp);
 381 extern void zebra_evpn_mh_print(struct vty *vty);
 382 extern void zebra_evpn_mh_json(json_object *json);
 383 extern void zebra_evpn_l2_nh_show(struct vty *vty, bool uj);
 384 extern void zebra_evpn_acc_bd_svi_set(struct zebra_if *vlan_zif,
 385                                       struct zebra_if *br_zif, bool is_up);
 386 extern void zebra_evpn_acc_bd_svi_mac_add(struct interface *vlan_if);
 387 extern void zebra_evpn_es_bypass_update(struct zebra_evpn_es *es,
 388                                         struct interface *ifp, bool bypass);
 389 extern void zebra_evpn_proc_remote_nh(ZAPI_HANDLER_ARGS);
 390 extern struct zebra_evpn_es_evi *
 391 zebra_evpn_es_evi_find(struct zebra_evpn_es *es, struct zebra_evpn *zevpn);
 392
 393 #endif /* _ZEBRA_EVPN_MH_H */