[mirror_frr.git] / zebra / zebra_router.h

/* Zebra Router header.
 * Copyright (C) 2018 Cumulus Networks, Inc.
 *                    Donald Sharp
 *
 * This file is part of FRR.
 *
 * FRR is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * FRR is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with FRR; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#ifndef __ZEBRA_ROUTER_H__
#define __ZEBRA_ROUTER_H__

#include "lib/mlag.h"

#include "zebra/zebra_ns.h"

#ifdef __cplusplus
extern "C" {
#endif

/*
 * This header file contains the idea of a router and as such
 * owns data that is associated with a router from zebra's
 * perspective.
 */

struct zebra_router_table {
	RB_ENTRY(zebra_router_table) zebra_router_table_entry;

	uint32_t tableid;
	afi_t afi;
	safi_t safi;
	ns_id_t ns_id;

	struct route_table *table;
};
RB_HEAD(zebra_router_table_head, zebra_router_table);
RB_PROTOTYPE(zebra_router_table_head, zebra_router_table,
	     zebra_router_table_entry, zebra_router_table_entry_compare)

/* RPF lookup behaviour */
enum multicast_mode {
	MCAST_NO_CONFIG = 0,  /* MIX_MRIB_FIRST, but no show in config write */
	MCAST_MRIB_ONLY,      /* MRIB only */
	MCAST_URIB_ONLY,      /* URIB only */
	MCAST_MIX_MRIB_FIRST, /* MRIB, if nothing at all then URIB */
	MCAST_MIX_DISTANCE,   /* MRIB & URIB, lower distance wins */
	MCAST_MIX_PFXLEN,     /* MRIB & URIB, longer prefix wins */
			      /* on equal value, MRIB wins for last 2 */
};

/* An interface can be error-disabled if a protocol (such as EVPN or
 * VRRP) detects a problem with keeping it operationally-up.
 * If any of the protodown bits are set protodown-on is programmed
 * in the dataplane. This results in a carrier/L1 down on the
 * physical device.
 */
enum protodown_reasons {
	/* A process outside of FRR's control protodowned the interface */
	ZEBRA_PROTODOWN_EXTERNAL = (1 << 0),
	/* On startup local ESs are held down for some time to
	 * allow the underlay to converge and EVPN routes to
	 * get learnt
	 */
	ZEBRA_PROTODOWN_EVPN_STARTUP_DELAY = (1 << 1),
	/* If all the uplinks are down the switch has lost access
	 * to the VxLAN overlay and must shut down the access
	 * ports to allow servers to re-direct their traffic to
	 * other switches on the Ethernet Segment
	 */
	ZEBRA_PROTODOWN_EVPN_UPLINK_DOWN = (1 << 2),
	ZEBRA_PROTODOWN_EVPN_ALL = (ZEBRA_PROTODOWN_EVPN_UPLINK_DOWN |
				    ZEBRA_PROTODOWN_EVPN_STARTUP_DELAY),
	ZEBRA_PROTODOWN_VRRP = (1 << 3),
	/* This reason used exclusively for testing */
	ZEBRA_PROTODOWN_SHARP = (1 << 4),
	/* Just used to clear our fields on shutdown, externel not included */
	ZEBRA_PROTODOWN_ALL = (ZEBRA_PROTODOWN_EVPN_ALL | ZEBRA_PROTODOWN_VRRP |
			       ZEBRA_PROTODOWN_SHARP)
};
#define ZEBRA_PROTODOWN_RC_STR_LEN 80

struct zebra_mlag_info {
	/* Role this zebra router is playing */
	enum mlag_role role;

	/* The peerlink being used for mlag */
	char *peerlink;
	ifindex_t peerlink_ifindex;

	/* The system mac being used */
	struct ethaddr mac;
	/*
	 * Zebra will open the communication channel with MLAGD only if any
	 * clients are interested and it is controlled dynamically based on
	 * client registers & un-registers.
	 */
	uint32_t clients_interested_cnt;

	/* coomunication channel with MLAGD is established */
	bool connected;

	/* connection retry timer is running */
	bool timer_running;

	/* Holds the client data(unencoded) that need to be pushed to MCLAGD*/
	struct stream_fifo *mlag_fifo;

	/*
	 * A new Kernel thread will be created to post the data to MCLAGD.
	 * where as, read will be performed from the zebra main thread, because
	 * read involves accessing client registartion data structures.
	 */
	struct frr_pthread *zebra_pth_mlag;

	/* MLAG Thread context 'master' */
	struct thread_master *th_master;

	/*
	 * Event for Initial MLAG Connection setup & Data Read
	 * Read can be performed only after successful connection establishment,
	 * so no issues.
	 *
	 */
	struct thread *t_read;
	/* Event for MLAG write */
	struct thread *t_write;
};

struct zebra_router {
	atomic_bool in_shutdown;

	/* Thread master */
	struct thread_master *master;

	/* Lists of clients who have connected to us */
	struct list *client_list;

	/* List of clients in GR */
	struct list *stale_client_list;

	struct zebra_router_table_head tables;

	/* L3-VNI hash table (for EVPN). Only in default instance */
	struct hash *l3vni_table;

	/* Tables and other global info maintained for EVPN multihoming */
	struct zebra_evpn_mh_info *mh_info;

	struct zebra_neigh_info *neigh_info;

	/* EVPN MH broadcast domains indexed by the VID */
	struct hash *evpn_vlan_table;

	struct hash *rules_hash;

	struct hash *ipset_hash;

	struct hash *ipset_entry_hash;

	struct hash *iptable_hash;

	struct hash *qdisc_hash;
	struct hash *class_hash;
	struct hash *filter_hash;

	/* A sequence number used for tracking routes */
	_Atomic uint32_t sequence_num;

	/* rib work queue */
#define ZEBRA_RIB_PROCESS_HOLD_TIME 10
#define ZEBRA_RIB_PROCESS_RETRY_TIME 1
	struct work_queue *ribq;

	/* Meta Queue Information */
	struct meta_queue *mq;

	/* LSP work queue */
	struct work_queue *lsp_process_q;

#define ZEBRA_ZAPI_PACKETS_TO_PROCESS 1000
	_Atomic uint32_t packets_to_process;

	/* Mlag information for the router */
	struct zebra_mlag_info mlag_info;

	/*
	 * The EVPN instance, if any
	 */
	struct zebra_vrf *evpn_vrf;

	uint32_t multipath_num;

	/* RPF Lookup behavior */
	enum multicast_mode ipv4_multicast_mode;

	/*
	 * Time for when we sweep the rib from old routes
	 */
	time_t startup_time;
	struct thread *sweeper;

	/*
	 * The hash of nexthop groups associated with this router
	 */
	struct hash *nhgs;
	struct hash *nhgs_id;

	/*
	 * Does the underlying system provide an asic offload
	 */
	bool asic_offloaded;
	bool notify_on_ack;

	/*
	 * If the asic is notifying us about successful nexthop
	 * allocation/control.  Some developers have made their
	 * asic take control of how many nexthops/ecmp they can
	 * have and will report what is successfull or not
	 */
	bool asic_notification_nexthop_control;

	bool supports_nhgs;

	bool all_mc_forwardingv4, default_mc_forwardingv4;
	bool all_mc_forwardingv6, default_mc_forwardingv6;
	bool all_linkdownv4, default_linkdownv4;
	bool all_linkdownv6, default_linkdownv6;

#define ZEBRA_DEFAULT_NHG_KEEP_TIMER 180
	uint32_t nhg_keep;

	/* Should we allow non FRR processes to delete our routes */
	bool allow_delete;
};

#define GRACEFUL_RESTART_TIME 60

extern struct zebra_router zrouter;
extern uint32_t rcvbufsize;

extern void zebra_router_init(bool asic_offload, bool notify_on_ack);
extern void zebra_router_cleanup(void);
extern void zebra_router_terminate(void);

extern struct zebra_router_table *zebra_router_find_zrt(struct zebra_vrf *zvrf,
							uint32_t tableid,
							afi_t afi, safi_t safi);
extern struct route_table *zebra_router_find_table(struct zebra_vrf *zvrf,
						   uint32_t tableid, afi_t afi,
						   safi_t safi);
extern struct route_table *zebra_router_get_table(struct zebra_vrf *zvrf,
						  uint32_t tableid, afi_t afi,
						  safi_t safi);
extern void zebra_router_release_table(struct zebra_vrf *zvrf, uint32_t tableid,
				       afi_t afi, safi_t safi);

extern int zebra_router_config_write(struct vty *vty);

extern void zebra_router_sweep_route(void);
extern void zebra_router_sweep_nhgs(void);

extern void zebra_router_show_table_summary(struct vty *vty);

extern uint32_t zebra_router_get_next_sequence(void);

static inline vrf_id_t zebra_vrf_get_evpn_id(void)
{
	return zrouter.evpn_vrf ? zvrf_id(zrouter.evpn_vrf) : VRF_DEFAULT;
}
static inline struct zebra_vrf *zebra_vrf_get_evpn(void)
{
	return zrouter.evpn_vrf ? zrouter.evpn_vrf
			        : zebra_vrf_lookup_by_id(VRF_DEFAULT);
}

extern void multicast_mode_ipv4_set(enum multicast_mode mode);

extern enum multicast_mode multicast_mode_ipv4_get(void);

extern bool zebra_router_notify_on_ack(void);

static inline void zebra_router_set_supports_nhgs(bool support)
{
	zrouter.supports_nhgs = support;
}

static inline bool zebra_router_in_shutdown(void)
{
	return atomic_load_explicit(&zrouter.in_shutdown, memory_order_relaxed);
}

/* zebra_northbound.c */
extern const struct frr_yang_module_info frr_zebra_info;

#ifdef __cplusplus
}
#endif

#endif
Commit	Line	Data
89272910 DS	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
e96ba9da DS	25	#include "lib/mlag.h"
e96ba9da DS	26
89272910 DS	27	#include "zebra/zebra_ns.h"
89272910 DS	28
51e94aa7 EDP	29	#ifdef __cplusplus
	30	extern "C" {
	31	#endif
	32
89272910 DS	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
526052fb DS	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
c36e442c AK	64	/* An interface can be error-disabled if a protocol (such as EVPN or
	65	* VRRP) detects a problem with keeping it operationally-up.
	66	* If any of the protodown bits are set protodown-on is programmed
	67	* in the dataplane. This results in a carrier/L1 down on the
	68	* physical device.
	69	*/
	70	enum protodown_reasons {
5d414138 SW	71	/* A process outside of FRR's control protodowned the interface */
5d414138 SW	72	ZEBRA_PROTODOWN_EXTERNAL = (1 << 0),
c36e442c AK	73	/* On startup local ESs are held down for some time to
	74	* allow the underlay to converge and EVPN routes to
	75	* get learnt
	76	*/
5d414138	77	ZEBRA_PROTODOWN_EVPN_STARTUP_DELAY = (1 << 1),
c36e442c AK	78	/* If all the uplinks are down the switch has lost access
	79	* to the VxLAN overlay and must shut down the access
	80	* ports to allow servers to re-direct their traffic to
	81	* other switches on the Ethernet Segment
	82	*/
5d414138 SW	83	ZEBRA_PROTODOWN_EVPN_UPLINK_DOWN = (1 << 2),
	84	ZEBRA_PROTODOWN_EVPN_ALL = (ZEBRA_PROTODOWN_EVPN_UPLINK_DOWN \|
	85	ZEBRA_PROTODOWN_EVPN_STARTUP_DELAY),
	86	ZEBRA_PROTODOWN_VRRP = (1 << 3),
	87	/* This reason used exclusively for testing */
0dcd8506 SW	88	ZEBRA_PROTODOWN_SHARP = (1 << 4),
	89	/* Just used to clear our fields on shutdown, externel not included */
	90	ZEBRA_PROTODOWN_ALL = (ZEBRA_PROTODOWN_EVPN_ALL \| ZEBRA_PROTODOWN_VRRP \|
	91	ZEBRA_PROTODOWN_SHARP)
c36e442c AK	92	};
	93	#define ZEBRA_PROTODOWN_RC_STR_LEN 80
	94
e96ba9da DS	95	struct zebra_mlag_info {
	96	/* Role this zebra router is playing */
	97	enum mlag_role role;
	98
	99	/* The peerlink being used for mlag */
	100	char *peerlink;
	101	ifindex_t peerlink_ifindex;
	102
	103	/* The system mac being used */
	104	struct ethaddr mac;
ee235396 SK	105	/*
	106	* Zebra will open the communication channel with MLAGD only if any
	107	* clients are interested and it is controlled dynamically based on
	108	* client registers & un-registers.
	109	*/
	110	uint32_t clients_interested_cnt;
	111
	112	/* coomunication channel with MLAGD is established */
	113	bool connected;
	114
	115	/* connection retry timer is running */
	116	bool timer_running;
	117
	118	/* Holds the client data(unencoded) that need to be pushed to MCLAGD*/
	119	struct stream_fifo *mlag_fifo;
	120
	121	/*
	122	* A new Kernel thread will be created to post the data to MCLAGD.
	123	* where as, read will be performed from the zebra main thread, because
	124	* read involves accessing client registartion data structures.
	125	*/
	126	struct frr_pthread *zebra_pth_mlag;
	127
	128	/* MLAG Thread context 'master' */
	129	struct thread_master *th_master;
	130
21a93a5f SK	131	/*
	132	* Event for Initial MLAG Connection setup & Data Read
	133	* Read can be performed only after successful connection establishment,
	134	* so no issues.
	135	*
	136	*/
ee235396	137	struct thread *t_read;
21a93a5f	138	/* Event for MLAG write */
ee235396	139	struct thread *t_write;
e96ba9da DS	140	};
e96ba9da DS	141
89272910	142	struct zebra_router {
2fc69f03 MS	143	atomic_bool in_shutdown;
2fc69f03 MS	144
3801e764 DS	145	/* Thread master */
3801e764 DS	146	struct thread_master *master;
89272910	147
161e9ab7 DS	148	/* Lists of clients who have connected to us */
	149	struct list *client_list;
	150
8062cbe2 S	151	/* List of clients in GR */
	152	struct list *stale_client_list;
	153
89272910	154	struct zebra_router_table_head tables;
7f0ea8a4	155
89272910 DS	156	/* L3-VNI hash table (for EVPN). Only in default instance */
89272910 DS	157	struct hash *l3vni_table;
7f0ea8a4	158
ce5160c0 AK	159	/* Tables and other global info maintained for EVPN multihoming */
	160	struct zebra_evpn_mh_info *mh_info;
	161
4cf4fad1 AK	162	struct zebra_neigh_info *neigh_info;
4cf4fad1 AK	163
ce5160c0 AK	164	/* EVPN MH broadcast domains indexed by the VID */
	165	struct hash *evpn_vlan_table;
	166
7f0ea8a4	167	struct hash *rules_hash;
62f20a52 DS	168
	169	struct hash *ipset_hash;
	170
	171	struct hash *ipset_entry_hash;
	172
	173	struct hash *iptable_hash;
a3be9fa1	174
c317d3f2 SY	175	struct hash *qdisc_hash;
	176	struct hash *class_hash;
	177	struct hash *filter_hash;
	178
1485bbe7 DS	179	/* A sequence number used for tracking routes */
1485bbe7 DS	180	_Atomic uint32_t sequence_num;
b3d43ff4	181
489a9614 DS	182	/* rib work queue */
	183	#define ZEBRA_RIB_PROCESS_HOLD_TIME 10
	184	#define ZEBRA_RIB_PROCESS_RETRY_TIME 1
	185	struct work_queue *ribq;
ea45a4e7 DS	186
	187	/* Meta Queue Information */
	188	struct meta_queue *mq;
e2353ec2 DS	189
	190	/* LSP work queue */
	191	struct work_queue *lsp_process_q;
5ec5a716 DS	192
	193	#define ZEBRA_ZAPI_PACKETS_TO_PROCESS 1000
	194	_Atomic uint32_t packets_to_process;
e96ba9da DS	195
	196	/* Mlag information for the router */
	197	struct zebra_mlag_info mlag_info;
0fb2ad05 T	198
	199	/*
	200	* The EVPN instance, if any
	201	*/
	202	struct zebra_vrf *evpn_vrf;
b3f2b590 DS	203
b3f2b590 DS	204	uint32_t multipath_num;
d4644d41	205
526052fb DS	206	/* RPF Lookup behavior */
	207	enum multicast_mode ipv4_multicast_mode;
	208
d4644d41 DS	209	/*
	210	* Time for when we sweep the rib from old routes
	211	*/
	212	time_t startup_time;
c3343a75	213	struct thread *sweeper;
69171da2 DS	214
	215	/*
	216	* The hash of nexthop groups associated with this router
	217	*/
	218	struct hash *nhgs;
a95b8020	219	struct hash *nhgs_id;
4c56ce1c DS	220
	221	/*
	222	* Does the underlying system provide an asic offload
	223	*/
	224	bool asic_offloaded;
e4876266	225	bool notify_on_ack;
090ee856	226
06525c4f DS	227	/*
	228	* If the asic is notifying us about successful nexthop
	229	* allocation/control. Some developers have made their
	230	* asic take control of how many nexthops/ecmp they can
	231	* have and will report what is successfull or not
	232	*/
	233	bool asic_notification_nexthop_control;
	234
090ee856	235	bool supports_nhgs;
c9af62e3	236
385d37ab DS	237	bool all_mc_forwardingv4, default_mc_forwardingv4;
	238	bool all_mc_forwardingv6, default_mc_forwardingv6;
	239	bool all_linkdownv4, default_linkdownv4;
	240	bool all_linkdownv6, default_linkdownv6;
	241
c9af62e3 DS	242	#define ZEBRA_DEFAULT_NHG_KEEP_TIMER 180
c9af62e3 DS	243	uint32_t nhg_keep;
88b0baa6 DS	244
	245	/* Should we allow non FRR processes to delete our routes */
	246	bool allow_delete;
89272910 DS	247	};
89272910 DS	248
d4644d41 DS	249	#define GRACEFUL_RESTART_TIME 60
d4644d41 DS	250
89272910	251	extern struct zebra_router zrouter;
9fb83b55	252	extern uint32_t rcvbufsize;
89272910	253
e4876266	254	extern void zebra_router_init(bool asic_offload, bool notify_on_ack);
3e0372d2	255	extern void zebra_router_cleanup(void);
89272910 DS	256	extern void zebra_router_terminate(void);
89272910 DS	257
9d86e091 CS	258	extern struct zebra_router_table zebra_router_find_zrt(struct zebra_vrf zvrf,
	259	uint32_t tableid,
	260	afi_t afi, safi_t safi);
89272910 DS	261	extern struct route_table zebra_router_find_table(struct zebra_vrf zvrf,
	262	uint32_t tableid, afi_t afi,
	263	safi_t safi);
	264	extern struct route_table zebra_router_get_table(struct zebra_vrf zvrf,
	265	uint32_t tableid, afi_t afi,
	266	safi_t safi);
bd4fb615 DS	267	extern void zebra_router_release_table(struct zebra_vrf *zvrf, uint32_t tableid,
bd4fb615 DS	268	afi_t afi, safi_t safi);
89272910 DS	269
	270	extern int zebra_router_config_write(struct vty *vty);
	271
89272910	272	extern void zebra_router_sweep_route(void);
38e40db1	273	extern void zebra_router_sweep_nhgs(void);
ac5aa23f DS	274
ac5aa23f DS	275	extern void zebra_router_show_table_summary(struct vty *vty);
1485bbe7 DS	276
1485bbe7 DS	277	extern uint32_t zebra_router_get_next_sequence(void);
0fb2ad05 T	278
	279	static inline vrf_id_t zebra_vrf_get_evpn_id(void)
	280	{
	281	return zrouter.evpn_vrf ? zvrf_id(zrouter.evpn_vrf) : VRF_DEFAULT;
	282	}
	283	static inline struct zebra_vrf *zebra_vrf_get_evpn(void)
	284	{
	285	return zrouter.evpn_vrf ? zrouter.evpn_vrf
	286	: zebra_vrf_lookup_by_id(VRF_DEFAULT);
	287	}
d074383c	288
526052fb DS	289	extern void multicast_mode_ipv4_set(enum multicast_mode mode);
	290
	291	extern enum multicast_mode multicast_mode_ipv4_get(void);
	292
e4876266 DS	293	extern bool zebra_router_notify_on_ack(void);
e4876266 DS	294
090ee856 DS	295	static inline void zebra_router_set_supports_nhgs(bool support)
	296	{
	297	zrouter.supports_nhgs = support;
	298	}
	299
0a5f9773 DS	300	static inline bool zebra_router_in_shutdown(void)
	301	{
	302	return atomic_load_explicit(&zrouter.in_shutdown, memory_order_relaxed);
	303	}
	304
b87fa24d RZ	305	/* zebra_northbound.c */
	306	extern const struct frr_yang_module_info frr_zebra_info;
	307
51e94aa7 EDP	308	#ifdef __cplusplus
	309	}
	310	#endif
	311
89272910	312	#endif