zebra/zebra_router.h

   1 /* Zebra Router header.
   2  * Copyright (C) 2018 Cumulus Networks, Inc.
   3  *                    Donald Sharp
   4  *
   5  * This file is part of FRR.
   6  *
   7  * FRR 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
  10  * later version.
  11  *
  12  * FRR 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.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with FRR; see the file COPYING.  If not, write to the Free
  19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20  * 02111-1307, USA.
  21  */
  22 #ifndef __ZEBRA_ROUTER_H__
  23 #define __ZEBRA_ROUTER_H__
  24
  25 #include "lib/mlag.h"
  26
  27 #include "zebra/zebra_ns.h"
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 /*
  34  * This header file contains the idea of a router and as such
  35  * owns data that is associated with a router from zebra's
  36  * perspective.
  37  */
  38
  39 struct zebra_router_table {
  40         RB_ENTRY(zebra_router_table) zebra_router_table_entry;
  41
  42         uint32_t tableid;
  43         afi_t afi;
  44         safi_t safi;
  45         ns_id_t ns_id;
  46
  47         struct route_table *table;
  48 };
  49 RB_HEAD(zebra_router_table_head, zebra_router_table);
  50 RB_PROTOTYPE(zebra_router_table_head, zebra_router_table,
  51              zebra_router_table_entry, zebra_router_table_entry_compare)
  52
  53 /* RPF lookup behaviour */
  54 enum multicast_mode {
  55         MCAST_NO_CONFIG = 0,  /* MIX_MRIB_FIRST, but no show in config write */
  56         MCAST_MRIB_ONLY,      /* MRIB only */
  57         MCAST_URIB_ONLY,      /* URIB only */
  58         MCAST_MIX_MRIB_FIRST, /* MRIB, if nothing at all then URIB */
  59         MCAST_MIX_DISTANCE,   /* MRIB & URIB, lower distance wins */
  60         MCAST_MIX_PFXLEN,     /* MRIB & URIB, longer prefix wins */
  61                               /* on equal value, MRIB wins for last 2 */
  62 };
  63
  64 struct zebra_mlag_info {
  65         /* Role this zebra router is playing */
  66         enum mlag_role role;
  67
  68         /* The peerlink being used for mlag */
  69         char *peerlink;
  70         ifindex_t peerlink_ifindex;
  71
  72         /* The system mac being used */
  73         struct ethaddr mac;
  74         /*
  75          * Zebra will open the communication channel with MLAGD only if any
  76          * clients are interested and it is controlled dynamically based on
  77          * client registers & un-registers.
  78          */
  79         uint32_t clients_interested_cnt;
  80
  81         /* coomunication channel with MLAGD is established */
  82         bool connected;
  83
  84         /* connection retry timer is running */
  85         bool timer_running;
  86
  87         /* Holds the client data(unencoded) that need to be pushed to MCLAGD*/
  88         struct stream_fifo *mlag_fifo;
  89
  90         /*
  91          * A new Kernel thread will be created to post the data to MCLAGD.
  92          * where as, read will be performed from the zebra main thread, because
  93          * read involves accessing client registartion data structures.
  94          */
  95         struct frr_pthread *zebra_pth_mlag;
  96
  97         /* MLAG Thread context 'master' */
  98         struct thread_master *th_master;
  99
 100         /*
 101          * Event for Initial MLAG Connection setup & Data Read
 102          * Read can be performed only after successful connection establishment,
 103          * so no issues.
 104          *
 105          */
 106         struct thread *t_read;
 107         /* Event for MLAG write */
 108         struct thread *t_write;
 109 };
 110
 111 struct zebra_router {
 112         atomic_bool in_shutdown;
 113
 114         /* Thread master */
 115         struct thread_master *master;
 116
 117         /* Lists of clients who have connected to us */
 118         struct list *client_list;
 119
 120         /* List of clients in GR */
 121         struct list *stale_client_list;
 122
 123         struct zebra_router_table_head tables;
 124
 125         /* L3-VNI hash table (for EVPN). Only in default instance */
 126         struct hash *l3vni_table;
 127
 128         struct hash *rules_hash;
 129
 130         struct hash *ipset_hash;
 131
 132         struct hash *ipset_entry_hash;
 133
 134         struct hash *iptable_hash;
 135
 136         /* used if vrf backend is not network namespace */
 137         int rtadv_sock;
 138
 139         /* A sequence number used for tracking routes */
 140         _Atomic uint32_t sequence_num;
 141
 142         /* rib work queue */
 143 #define ZEBRA_RIB_PROCESS_HOLD_TIME 10
 144 #define ZEBRA_RIB_PROCESS_RETRY_TIME 1
 145         struct work_queue *ribq;
 146
 147         /* Meta Queue Information */
 148         struct meta_queue *mq;
 149
 150         /* LSP work queue */
 151         struct work_queue *lsp_process_q;
 152
 153 #define ZEBRA_ZAPI_PACKETS_TO_PROCESS 1000
 154         _Atomic uint32_t packets_to_process;
 155
 156         /* Mlag information for the router */
 157         struct zebra_mlag_info mlag_info;
 158
 159         /*
 160          * The EVPN instance, if any
 161          */
 162         struct zebra_vrf *evpn_vrf;
 163
 164         uint32_t multipath_num;
 165
 166         /* RPF Lookup behavior */
 167         enum multicast_mode ipv4_multicast_mode;
 168
 169         /*
 170          * Time for when we sweep the rib from old routes
 171          */
 172         time_t startup_time;
 173
 174         /*
 175          * The hash of nexthop groups associated with this router
 176          */
 177         struct hash *nhgs;
 178         struct hash *nhgs_id;
 179 };
 180
 181 #define GRACEFUL_RESTART_TIME 60
 182
 183 extern struct zebra_router zrouter;
 184
 185 extern void zebra_router_init(void);
 186 extern void zebra_router_cleanup(void);
 187 extern void zebra_router_terminate(void);
 188
 189 extern struct route_table *zebra_router_find_table(struct zebra_vrf *zvrf,
 190                                                    uint32_t tableid, afi_t afi,
 191                                                    safi_t safi);
 192 extern struct route_table *zebra_router_get_table(struct zebra_vrf *zvrf,
 193                                                   uint32_t tableid, afi_t afi,
 194                                                   safi_t safi);
 195 extern void zebra_router_release_table(struct zebra_vrf *zvrf, uint32_t tableid,
 196                                        afi_t afi, safi_t safi);
 197
 198 extern int zebra_router_config_write(struct vty *vty);
 199
 200 extern void zebra_router_sweep_route(void);
 201 extern void zebra_router_sweep_nhgs(void);
 202
 203 extern void zebra_router_show_table_summary(struct vty *vty);
 204
 205 extern uint32_t zebra_router_get_next_sequence(void);
 206
 207 static inline vrf_id_t zebra_vrf_get_evpn_id(void)
 208 {
 209         return zrouter.evpn_vrf ? zvrf_id(zrouter.evpn_vrf) : VRF_DEFAULT;
 210 }
 211 static inline struct zebra_vrf *zebra_vrf_get_evpn(void)
 212 {
 213         return zrouter.evpn_vrf ? zrouter.evpn_vrf
 214                                 : zebra_vrf_lookup_by_id(VRF_DEFAULT);
 215 }
 216
 217 extern void multicast_mode_ipv4_set(enum multicast_mode mode);
 218
 219 extern enum multicast_mode multicast_mode_ipv4_get(void);
 220
 221 #ifdef __cplusplus
 222 }
 223 #endif
 224
 225 #endif