[mirror_frr.git] / zebra / zebra_gr.c

/*
 * Zebra GR related helper functions.
 *
 * Portions:
 *	Copyright (C) 2019 VMware, Inc.
 *	et al.
 *
 * This program 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 of the License, or (at your option)
 * any later version.
 *
 * This program 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 this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>
#include <libgen.h>

#include "lib/prefix.h"
#include "lib/command.h"
#include "lib/if.h"
#include "lib/thread.h"
#include "lib/stream.h"
#include "lib/memory.h"
#include "lib/table.h"
#include "lib/network.h"
#include "lib/sockunion.h"
#include "lib/log.h"
#include "lib/zclient.h"
#include "lib/privs.h"
#include "lib/network.h"
#include "lib/buffer.h"
#include "lib/nexthop.h"
#include "lib/vrf.h"
#include "lib/libfrr.h"
#include "lib/sockopt.h"

#include "zebra/zebra_router.h"
#include "zebra/debug.h"
#include "zebra/zapi_msg.h"


/*
 * Forward declaration.
 */
static struct zserv *zebra_gr_find_stale_client(struct zserv *client);
static int32_t zebra_gr_route_stale_delete_timer_expiry(struct thread *thread);
static int32_t zebra_gr_delete_stale_routes(struct client_gr_info *info);
static void zebra_gr_process_client_stale_routes(struct zserv *client,
						 vrf_id_t vrf_id);

/*
 * Debug macros.
 */
#define LOG_GR(msg, ...)                                                       \
	do {                                                                   \
		if (IS_ZEBRA_DEBUG_EVENT)                                      \
			zlog_debug(msg, ##__VA_ARGS__);                        \
	} while (0)


/*
 * Client connection functions
 */

/*
 * Function to clean all the stale clients,
 * function will also clean up all per instance
 * capabilities that are exchanged.
 */
void zebra_gr_stale_client_cleanup(struct list *client_list)
{
	struct listnode *node, *nnode;
	struct zserv *s_client = NULL;
	struct client_gr_info *info, *ninfo;

	/* Find the stale client */
	for (ALL_LIST_ELEMENTS(client_list, node, nnode, s_client)) {

		LOG_GR("%s: Stale client %s is being deleted", __func__,
		       zebra_route_string(s_client->proto));

		TAILQ_FOREACH_SAFE (info, &s_client->gr_info_queue, gr_info,
				    ninfo) {

			/* Cancel the stale timer */
			if (info->t_stale_removal != NULL) {
				THREAD_OFF(info->t_stale_removal);
				info->t_stale_removal = NULL;
				/* Process the stale routes */
				thread_execute(
				    zrouter.master,
				    zebra_gr_route_stale_delete_timer_expiry,
				    info, 1);
			}
		}
	}
}

/*
 * A helper function to create client info.
 */
static struct client_gr_info *zebra_gr_client_info_create(struct zserv *client)
{
	struct client_gr_info *info;

	info = XCALLOC(MTYPE_TMP, sizeof(struct client_gr_info));

	TAILQ_INSERT_TAIL(&(client->gr_info_queue), info, gr_info);
	return info;
}

/*
 * A helper function to delte and destory client info.
 */
static void zebra_gr_client_info_delte(struct zserv *client,
				       struct client_gr_info *info)
{
	TAILQ_REMOVE(&(client->gr_info_queue), info, gr_info);

	THREAD_OFF(info->t_stale_removal);

	if (info->current_prefix)
		XFREE(MTYPE_TMP, info->current_prefix);

	LOG_GR("%s: Instance info is being deleted for client %s", __func__,
	       zebra_route_string(client->proto));

	/* Delete all the stale routes. */
	info->delete = true;
	zebra_gr_delete_stale_routes(info);

	XFREE(MTYPE_TMP, info);
}

/*
 * Function to handle client when it disconnect.
 */
int32_t zebra_gr_client_disconnect(struct zserv *client)
{
	struct zserv *stale_client;
	struct timeval tv;
	struct client_gr_info *info = NULL;

	/* Find the stale client */
	stale_client = zebra_gr_find_stale_client(client);

	/*
	 * We should never be here.
	 */
	if (stale_client) {
		LOG_GR("%s: Stale client %s exist, we should not be here!",
		       __func__, zebra_route_string(client->proto));
		assert(0);
	}

	client->restart_time = monotime(&tv);

	/* For all the GR instance start the starle removal timer. */
	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
		if (ZEBRA_CLIENT_GR_ENABLED(info->capabilities)
		    && (info->t_stale_removal == NULL)) {
			thread_add_timer(
				zrouter.master,
				zebra_gr_route_stale_delete_timer_expiry, info,
				info->stale_removal_time,
				&info->t_stale_removal);
			info->current_afi = AFI_IP;
			info->stale_client_ptr = client;
			info->stale_client = true;
			LOG_GR("%s: Client %s Stale timer update to %d",
			       __func__, zebra_route_string(client->proto),
			       info->stale_removal_time);
		}
	}

	listnode_add(zrouter.stale_client_list, client);

	return 0;
}

/*
 * Function to delete stale client
 */
static void zebra_gr_delete_stale_client(struct client_gr_info *info)
{
	struct client_gr_info *bgp_info;
	struct zserv *s_client = NULL;

	s_client = info->stale_client_ptr;

	if (!s_client || !info->stale_client)
		return;

	/*
	 * If there are bgp instances with the stale delete timer pending
	 * then stale client is not deleted
	 */
	if ((s_client->gr_instance_count > 0) && info->gr_enable)
		s_client->gr_instance_count--;

	TAILQ_REMOVE(&(s_client->gr_info_queue), info, gr_info);

	LOG_GR("%s: Client %s gr count %d", __func__,
	       zebra_route_string(s_client->proto),
	       s_client->gr_instance_count);

	TAILQ_FOREACH (bgp_info, &s_client->gr_info_queue, gr_info) {
		if (bgp_info->t_stale_removal != NULL)
			return;
	}

	LOG_GR("%s: Client %s is being deleted", __func__,
	       zebra_route_string(s_client->proto));

	TAILQ_INIT(&(s_client->gr_info_queue));
	listnode_delete(zrouter.stale_client_list, s_client);
	if (info->stale_client)
		XFREE(MTYPE_TMP, s_client);
	XFREE(MTYPE_TMP, info);
}

/*
 * Function to find stale client.
 */
static struct zserv *zebra_gr_find_stale_client(struct zserv *client)
{
	struct listnode *node, *nnode;
	struct zserv *stale_client;

	/* Find the stale client */
	for (ALL_LIST_ELEMENTS(zrouter.stale_client_list, node, nnode,
			       stale_client)) {
		if (client->proto == stale_client->proto
		    && client->instance == stale_client->instance) {
			return stale_client;
		}
	}

	return NULL;
}

/*
 * Function to handle reconnect of client post restart.
 */
void zebra_gr_client_reconnect(struct zserv *client)
{
	struct listnode *node, *nnode;
	struct zserv *old_client = NULL;
	struct client_gr_info *info = NULL;

	/* Find the stale client */
	for (ALL_LIST_ELEMENTS(zrouter.stale_client_list, node, nnode,
			       old_client)) {
		if (client->proto == old_client->proto
		    && client->instance == old_client->instance)
			break;
	}

	/* Copy the timers */
	if (old_client) {
		client->gr_instance_count = old_client->gr_instance_count;
		client->restart_time = old_client->restart_time;

		LOG_GR("%s : old client %s, gr_instance_count %d", __func__,
		       zebra_route_string(old_client->proto),
		       old_client->gr_instance_count);

		if (TAILQ_FIRST(&old_client->gr_info_queue)) {
			TAILQ_CONCAT(&client->gr_info_queue,
				     &old_client->gr_info_queue, gr_info);
			TAILQ_INIT(&old_client->gr_info_queue);
		}

		TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
			info->stale_client_ptr = client;
			info->stale_client = false;
		}

		/* Delete the stale client */
		listnode_delete(zrouter.stale_client_list, old_client);
		/* Delete old client */
		XFREE(MTYPE_TMP, old_client);
	}
}

/*
 * Functions to deal with capabilities
 */

/*
 * Update the graceful restart information
 * for the client instance.
 * This function handles all the capabilties that are received.
 */
static void zebra_client_update_info(struct zserv *client, struct zapi_cap *api)
{
	struct client_gr_info *info = NULL;

	/* Find the bgp information for the specified vrf id */
	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
		if (info->vrf_id == api->vrf_id)
			break;
	}


	/*
	 * If the command is delete, then cancel the stale timer and
	 * delete the bgp info
	 */
	switch (api->cap) {
	case ZEBRA_CLIENT_GR_DISABLE:
		if (!info)
			return;

		LOG_GR("%s: Client %s instance GR disabled count %d", __func__,
		       zebra_route_string(client->proto),
		       client->gr_instance_count);

		if ((info->gr_enable) && (client->gr_instance_count > 0))
			client->gr_instance_count--;

		zebra_gr_client_info_delte(client, info);
		break;
	case ZEBRA_CLIENT_GR_CAPABILITIES:
		/* Allocate bgp info */
		if (!info)
			info = zebra_gr_client_info_create(client);

		/* Udpate other parameters */
		if (!info->gr_enable) {
			client->gr_instance_count++;

			LOG_GR("%s: Cient %s GR enabled count %d", __func__,
			       zebra_route_string(client->proto),
			       client->gr_instance_count);

			info->capabilities = api->cap;
			info->stale_removal_time = api->stale_removal_time;
			info->vrf_id = api->vrf_id;
			info->gr_enable = true;
		}
		break;
	case ZEBRA_CLIENT_RIB_STALE_TIME:
		LOG_GR("%s: Client %s stale time update event", __func__,
		       zebra_route_string(client->proto));

		/* Update the stale removal timer */
		if (info && info->t_stale_removal == NULL) {

			LOG_GR("%s: Stale time: %d is now update to: %d",
			       __func__, info->stale_removal_time,
			       api->stale_removal_time);

			info->stale_removal_time = api->stale_removal_time;
		}

		break;
	case ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE:
		LOG_GR(
		   "%s: Client %s route update complete for AFI %d, SAFI %d",
		   __func__, zebra_route_string(client->proto), api->afi,
		   api->safi);
		if (info)
			info->route_sync[api->afi][api->safi] = true;
		break;
	case ZEBRA_CLIENT_ROUTE_UPDATE_PENDING:
		LOG_GR("%s: Client %s route update pending for AFI %d, SAFI %d",
		       __func__, zebra_route_string(client->proto), api->afi,
		       api->safi);
		if (info)
			info->af_enabled[api->afi][api->safi] = true;
		break;
	}
}

/*
 * Handler for capabilities that are received from client.
 */
static void zebra_client_capabilities_handler(struct zserv *client,
					      struct zapi_cap *api)
{
	switch (api->cap) {
	case ZEBRA_CLIENT_GR_CAPABILITIES:
	case ZEBRA_CLIENT_ROUTE_UPDATE_PENDING:
	case ZEBRA_CLIENT_GR_DISABLE:
	case ZEBRA_CLIENT_RIB_STALE_TIME:
		/*
		 * For all the cases we need to update the client info.
		 */
		zebra_client_update_info(client, api);
		break;
	case ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE:
		/*
		 * After client info has been updated delete all
		 * stale routes
		 */
		zebra_client_update_info(client, api);
		zebra_gr_process_client_stale_routes(client, api->vrf_id);
		break;
	}
}

/*
 * Function to decode and call appropriate functions
 * to handle client capabilities.
 */
void zread_client_capabilities(ZAPI_HANDLER_ARGS)
{
	struct zapi_cap api;
	struct stream *s;

	s = msg;

	if (zapi_capabilities_decode(s, &api)) {
		LOG_GR("%s: Error in reading capabilities for client %s",
		       __func__, zebra_route_string(client->proto));
		return;
	}

	/* Call the capabilities handler */
	zebra_client_capabilities_handler(client, &api);
}


/*
 * Stale route handling
 */

/*
 * Delete all the stale routes that have not been refreshed
 * post restart.
 */
static int32_t zebra_gr_route_stale_delete_timer_expiry(struct thread *thread)
{
	struct client_gr_info *info;
	int32_t cnt = 0;
	struct zserv *client;

	info = THREAD_ARG(thread);
	info->t_stale_removal = NULL;
	client = (struct zserv *)info->stale_client_ptr;

	/* Set the flag to indicate all stale route deletion */
	if (thread->u.val == 1)
		info->delete = true;

	cnt = zebra_gr_delete_stale_routes(info);

	/* Retsart the timer */
	if (cnt > 0) {
		LOG_GR("%s: Client %s processed %d routes. Start timer again",
		       __func__, zebra_route_string(client->proto), cnt);

		thread_add_timer(zrouter.master,
				 zebra_gr_route_stale_delete_timer_expiry, info,
				 ZEBRA_DEFAULT_STALE_UPDATE_DELAY,
				 &info->t_stale_removal);
	} else {
		/* No routes to delete for the VRF */
		LOG_GR("%s: Client %s all starle routes processed", __func__,
		       zebra_route_string(client->proto));

		if (info->current_prefix != NULL)
			XFREE(MTYPE_TMP, info->current_prefix);
		info->current_prefix = NULL;
		info->current_afi = 0;
		zebra_gr_delete_stale_client(info);
	}
	return 0;
}


/*
 * Function to process to check if route entry is stale
 * or has been updated.
 */
static void zebra_gr_process_route_entry(struct zserv *client,
					 struct route_node *rn,
					 struct route_entry *re)
{
	char buf[PREFIX2STR_BUFFER];

	if ((client == NULL) || (rn == NULL) || (re == NULL))
		return;

	/* If the route is not refreshed after restart, delete the entry */
	if (re->uptime < client->restart_time) {
		if (IS_ZEBRA_DEBUG_RIB) {
			prefix2str(&rn->p, buf, sizeof(buf));
			zlog_debug("%s: Client %s stale route %s is deleted",
				   __func__, zebra_route_string(client->proto),
				   buf);
		}
		rib_delnode(rn, re);
	}
}

/*
 * This function walks through the route table for all vrf and deletes
 * the stale routes for the restarted client specified by the protocol
 * type
 */
static int32_t zebra_gr_delete_stale_route(struct client_gr_info *info,
					   struct zebra_vrf *zvrf)
{
	struct route_node *rn, *curr;
	struct route_entry *re;
	struct route_entry *next;
	struct route_table *table;
	int32_t n = 0;
	struct prefix *p;
	afi_t afi, curr_afi;
	uint8_t proto;
	uint16_t instance;
	struct zserv *s_client;

	if ((info == NULL) || (zvrf == NULL))
		return -1;

	s_client = info->stale_client_ptr;
	if (s_client == NULL) {
		LOG_GR("%s: Stale client not present", __func__);
		return -1;
	}

	proto = s_client->proto;
	instance = s_client->instance;
	curr_afi = info->current_afi;

	LOG_GR("%s: Client %s stale routes are being deleted", __func__,
	       zebra_route_string(proto));

	/* Process routes for all AFI */
	for (afi = curr_afi; afi < AFI_MAX; afi++) {
		table = zvrf->table[afi][SAFI_UNICAST];
		p = info->current_prefix;

		if (table) {
			/*
			 * If the current prefix is NULL then get the first
			 * route entry in the table
			 */
			if (p == NULL) {
				rn = route_top(table);
				if (rn == NULL)
					continue;
				p = XCALLOC(MTYPE_TMP, sizeof(struct prefix));
				if (p == NULL)
					return -1;
				curr = rn;
				prefix_copy(p, &rn->p);
			} else
				/* Get the next route entry */
				curr = route_table_get_next(table, p);

			for (rn = curr; rn; rn = srcdest_route_next(rn)) {
				RNODE_FOREACH_RE_SAFE (rn, re, next) {
					if (CHECK_FLAG(re->status,
						       ROUTE_ENTRY_REMOVED))
						continue;
					/* If the route refresh is received
					 * after restart then do not delete
					 * the route
					 */
					if (re->type == proto
					    && re->instance == instance) {
						zebra_gr_process_route_entry(
							s_client, rn, re);
						n++;
					}

					/* If the max route count is reached
					 * then timer thread will be restarted
					 * Store the current prefix and afi
					 */
					if ((n >= ZEBRA_MAX_STALE_ROUTE_COUNT)
					    && (info->delete == false)) {
						prefix_copy(p, &rn->p);
						info->current_afi = afi;
						info->current_prefix = p;
						return n;
					}
				}
			}
		}
		/*
		 * Reset the current prefix to indicate processing completion
		 * of the current AFI
		 */
		if (info->current_prefix) {
			XFREE(MTYPE_TMP, info->current_prefix);
			info->current_prefix = NULL;
		}
		continue;
	}
	return 0;
}

/*
 * Delete the stale routes when client is restarted and routes are not
 * refreshed within the stale timeout
 */
static int32_t zebra_gr_delete_stale_routes(struct client_gr_info *info)
{
	struct vrf *vrf;
	struct zebra_vrf *zvrf;
	uint64_t cnt = 0;

	if (info == NULL)
		return -1;

	/* Get the current VRF */
	vrf = vrf_lookup_by_id(info->vrf_id);
	if (vrf == NULL) {
		LOG_GR("%s: Invalid VRF %d", __func__, info->vrf_id);
		return -1;
	}

	zvrf = vrf->info;
	if (zvrf == NULL) {
		LOG_GR("%s: Invalid VRF entry %d", __func__, info->vrf_id);
		return -1;
	}

	cnt = zebra_gr_delete_stale_route(info, zvrf);
	return cnt;
}

/*
 * This function checks if route update for all AFI, SAFI is completed
 * and cancels the stale timer
 */
static void zebra_gr_process_client_stale_routes(struct zserv *client,
						 vrf_id_t vrf_id)
{
	struct client_gr_info *info = NULL;
	afi_t afi;
	safi_t safi;

	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
		if (info->vrf_id == vrf_id)
			break;
	}

	if (info == NULL)
		return;

	/* Check if route update completed for all AFI, SAFI */
	for (afi = AFI_IP; afi < AFI_MAX; afi++)
		for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++) {
			if (info->af_enabled[afi][safi]) {
				if (!info->route_sync[afi][safi]) {
					LOG_GR(
					   "%s: Client %s route update not completed for AFI %d, SAFI %d",
					   __func__, zebra_route_string(
							    client->proto),
					   afi, safi);
					return;
				}
			}
		}

	/*
	 * Route update completed for all AFI, SAFI
	 * Cancel the stale timer and process the routes
	 */
	if (info->t_stale_removal) {
		LOG_GR("%s: Client %s cancled stale delete timer vrf %d",
		       __func__, zebra_route_string(client->proto),
		       info->vrf_id);
		THREAD_OFF(info->t_stale_removal);
		thread_execute(zrouter.master,
			       zebra_gr_route_stale_delete_timer_expiry, info,
			       0);
	}
}
Commit	Line	Data
851140a7 S	1	/*
	2	* Zebra GR related helper functions.
	3	*
	4	* Portions:
	5	* Copyright (C) 2019 VMware, Inc.
	6	* et al.
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the Free
	10	* Software Foundation; either version 2 of the License, or (at your option)
	11	* any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful, but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	16	* more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include <zebra.h>
	24	#include <libgen.h>
	25
	26	#include "lib/prefix.h"
	27	#include "lib/command.h"
	28	#include "lib/if.h"
	29	#include "lib/thread.h"
	30	#include "lib/stream.h"
	31	#include "lib/memory.h"
	32	#include "lib/table.h"
	33	#include "lib/network.h"
	34	#include "lib/sockunion.h"
	35	#include "lib/log.h"
	36	#include "lib/zclient.h"
	37	#include "lib/privs.h"
	38	#include "lib/network.h"
	39	#include "lib/buffer.h"
	40	#include "lib/nexthop.h"
	41	#include "lib/vrf.h"
	42	#include "lib/libfrr.h"
	43	#include "lib/sockopt.h"
	44
	45	#include "zebra/zebra_router.h"
	46	#include "zebra/debug.h"
	47	#include "zebra/zapi_msg.h"
	48
	49
	50	/*
	51	* Forward declaration.
	52	*/
	53	static struct zserv zebra_gr_find_stale_client(struct zserv client);
b9e6727a S	54	static int32_t zebra_gr_route_stale_delete_timer_expiry(struct thread *thread);
	55	static int32_t zebra_gr_delete_stale_routes(struct client_gr_info *info);
	56	static void zebra_gr_process_client_stale_routes(struct zserv *client,
	57	vrf_id_t vrf_id);
851140a7 S	58
	59	/*
	60	* Debug macros.
	61	*/
	62	#define LOG_GR(msg, ...) \
	63	do { \
	64	if (IS_ZEBRA_DEBUG_EVENT) \
	65	zlog_debug(msg, ##__VA_ARGS__); \
	66	} while (0)
	67
	68
	69	/*
	70	* Client connection functions
	71	*/
	72
b9e6727a S	73	/*
	74	* Function to clean all the stale clients,
	75	* function will also clean up all per instance
	76	* capabilities that are exchanged.
	77	*/
	78	void zebra_gr_stale_client_cleanup(struct list *client_list)
	79	{
	80	struct listnode node, nnode;
	81	struct zserv *s_client = NULL;
	82	struct client_gr_info info, ninfo;
	83
	84	/* Find the stale client */
	85	for (ALL_LIST_ELEMENTS(client_list, node, nnode, s_client)) {
	86
	87	LOG_GR("%s: Stale client %s is being deleted", __func__,
	88	zebra_route_string(s_client->proto));
	89
	90	TAILQ_FOREACH_SAFE (info, &s_client->gr_info_queue, gr_info,
	91	ninfo) {
	92
	93	/* Cancel the stale timer */
	94	if (info->t_stale_removal != NULL) {
	95	THREAD_OFF(info->t_stale_removal);
	96	info->t_stale_removal = NULL;
	97	/* Process the stale routes */
	98	thread_execute(
	99	zrouter.master,
	100	zebra_gr_route_stale_delete_timer_expiry,
	101	info, 1);
	102	}
	103	}
	104	}
	105	}
	106
	107	/*
	108	* A helper function to create client info.
	109	*/
	110	static struct client_gr_info zebra_gr_client_info_create(struct zserv client)
	111	{
	112	struct client_gr_info *info;
	113
	114	info = XCALLOC(MTYPE_TMP, sizeof(struct client_gr_info));
	115
	116	TAILQ_INSERT_TAIL(&(client->gr_info_queue), info, gr_info);
	117	return info;
	118	}
	119
	120	/*
	121	* A helper function to delte and destory client info.
	122	*/
	123	static void zebra_gr_client_info_delte(struct zserv *client,
	124	struct client_gr_info *info)
	125	{
	126	TAILQ_REMOVE(&(client->gr_info_queue), info, gr_info);
	127
	128	THREAD_OFF(info->t_stale_removal);
	129
	130	if (info->current_prefix)
	131	XFREE(MTYPE_TMP, info->current_prefix);
	132
	133	LOG_GR("%s: Instance info is being deleted for client %s", __func__,
	134	zebra_route_string(client->proto));
	135
	136	/* Delete all the stale routes. */
137	info->delete = true;
138	zebra_gr_delete_stale_routes(info);
139
140	XFREE(MTYPE_TMP, info);
141	}
142
851140a7 S	143	/*
	144	* Function to handle client when it disconnect.
	145	*/
b9e6727a	146	int32_t zebra_gr_client_disconnect(struct zserv *client)
851140a7 S	147	{
	148	struct zserv *stale_client;
	149	struct timeval tv;
	150	struct client_gr_info *info = NULL;
	151
	152	/* Find the stale client */
	153	stale_client = zebra_gr_find_stale_client(client);
	154
	155	/*
	156	* We should never be here.
	157	*/
	158	if (stale_client) {
	159	LOG_GR("%s: Stale client %s exist, we should not be here!",
	160	__func__, zebra_route_string(client->proto));
	161	assert(0);
	162	}
	163
	164	client->restart_time = monotime(&tv);
	165
	166	/* For all the GR instance start the starle removal timer. */
	167	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
	168	if (ZEBRA_CLIENT_GR_ENABLED(info->capabilities)
	169	&& (info->t_stale_removal == NULL)) {
	170	thread_add_timer(
	171	zrouter.master,
	172	zebra_gr_route_stale_delete_timer_expiry, info,
	173	info->stale_removal_time,
	174	&info->t_stale_removal);
	175	info->current_afi = AFI_IP;
	176	info->stale_client_ptr = client;
	177	info->stale_client = true;
	178	LOG_GR("%s: Client %s Stale timer update to %d",
	179	__func__, zebra_route_string(client->proto),
	180	info->stale_removal_time);
	181	}
	182	}
	183
	184	listnode_add(zrouter.stale_client_list, client);
	185
	186	return 0;
	187	}
	188
b9e6727a S	189	/*
	190	* Function to delete stale client
	191	*/
	192	static void zebra_gr_delete_stale_client(struct client_gr_info *info)
	193	{
	194	struct client_gr_info *bgp_info;
	195	struct zserv *s_client = NULL;
	196
	197	s_client = info->stale_client_ptr;
	198
	199	if (!s_client \|\| !info->stale_client)
	200	return;
	201
	202	/*
	203	* If there are bgp instances with the stale delete timer pending
	204	* then stale client is not deleted
	205	*/
	206	if ((s_client->gr_instance_count > 0) && info->gr_enable)
	207	s_client->gr_instance_count--;
	208
	209	TAILQ_REMOVE(&(s_client->gr_info_queue), info, gr_info);
	210
	211	LOG_GR("%s: Client %s gr count %d", __func__,
	212	zebra_route_string(s_client->proto),
	213	s_client->gr_instance_count);
	214
	215	TAILQ_FOREACH (bgp_info, &s_client->gr_info_queue, gr_info) {
	216	if (bgp_info->t_stale_removal != NULL)
	217	return;
	218	}
	219
	220	LOG_GR("%s: Client %s is being deleted", __func__,
	221	zebra_route_string(s_client->proto));
	222
	223	TAILQ_INIT(&(s_client->gr_info_queue));
	224	listnode_delete(zrouter.stale_client_list, s_client);
	225	if (info->stale_client)
	226	XFREE(MTYPE_TMP, s_client);
	227	XFREE(MTYPE_TMP, info);
	228	}
	229
851140a7 S	230	/*
	231	* Function to find stale client.
	232	*/
	233	static struct zserv zebra_gr_find_stale_client(struct zserv client)
	234	{
	235	struct listnode node, nnode;
	236	struct zserv *stale_client;
	237
	238	/* Find the stale client */
	239	for (ALL_LIST_ELEMENTS(zrouter.stale_client_list, node, nnode,
	240	stale_client)) {
	241	if (client->proto == stale_client->proto
	242	&& client->instance == stale_client->instance) {
	243	return stale_client;
	244	}
	245	}
	246
	247	return NULL;
	248	}
	249
	250	/*
	251	* Function to handle reconnect of client post restart.
	252	*/
	253	void zebra_gr_client_reconnect(struct zserv *client)
	254	{
	255	struct listnode node, nnode;
	256	struct zserv *old_client = NULL;
	257	struct client_gr_info *info = NULL;
	258
	259	/* Find the stale client */
	260	for (ALL_LIST_ELEMENTS(zrouter.stale_client_list, node, nnode,
	261	old_client)) {
	262	if (client->proto == old_client->proto
	263	&& client->instance == old_client->instance)
	264	break;
	265	}
	266
	267	/* Copy the timers */
	268	if (old_client) {
	269	client->gr_instance_count = old_client->gr_instance_count;
	270	client->restart_time = old_client->restart_time;
	271
	272	LOG_GR("%s : old client %s, gr_instance_count %d", __func__,
	273	zebra_route_string(old_client->proto),
	274	old_client->gr_instance_count);
	275
	276	if (TAILQ_FIRST(&old_client->gr_info_queue)) {
	277	TAILQ_CONCAT(&client->gr_info_queue,
	278	&old_client->gr_info_queue, gr_info);
	279	TAILQ_INIT(&old_client->gr_info_queue);
	280	}
	281
	282	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
	283	info->stale_client_ptr = client;
	284	info->stale_client = false;
	285	}
	286
	287	/* Delete the stale client */
	288	listnode_delete(zrouter.stale_client_list, old_client);
	289	/* Delete old client */
	290	XFREE(MTYPE_TMP, old_client);
	291	}
	292	}
	293
b9e6727a S	294	/*
	295	* Functions to deal with capabilities
	296	*/
	297
	298	/*
	299	* Update the graceful restart information
	300	* for the client instance.
	301	* This function handles all the capabilties that are received.
	302	*/
	303	static void zebra_client_update_info(struct zserv client, struct zapi_cap api)
	304	{
	305	struct client_gr_info *info = NULL;
	306
	307	/* Find the bgp information for the specified vrf id */
	308	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
	309	if (info->vrf_id == api->vrf_id)
	310	break;
	311	}
	312
	313
	314	/*
	315	* If the command is delete, then cancel the stale timer and
	316	* delete the bgp info
	317	*/
	318	switch (api->cap) {
	319	case ZEBRA_CLIENT_GR_DISABLE:
	320	if (!info)
	321	return;
	322
	323	LOG_GR("%s: Client %s instance GR disabled count %d", __func__,
	324	zebra_route_string(client->proto),
	325	client->gr_instance_count);
	326
	327	if ((info->gr_enable) && (client->gr_instance_count > 0))
	328	client->gr_instance_count--;
	329
	330	zebra_gr_client_info_delte(client, info);
	331	break;
	332	case ZEBRA_CLIENT_GR_CAPABILITIES:
	333	/* Allocate bgp info */
	334	if (!info)
	335	info = zebra_gr_client_info_create(client);
	336
	337	/* Udpate other parameters */
	338	if (!info->gr_enable) {
	339	client->gr_instance_count++;
	340
	341	LOG_GR("%s: Cient %s GR enabled count %d", __func__,
	342	zebra_route_string(client->proto),
	343	client->gr_instance_count);
	344
	345	info->capabilities = api->cap;
	346	info->stale_removal_time = api->stale_removal_time;
	347	info->vrf_id = api->vrf_id;
	348	info->gr_enable = true;
	349	}
	350	break;
	351	case ZEBRA_CLIENT_RIB_STALE_TIME:
	352	LOG_GR("%s: Client %s stale time update event", __func__,
	353	zebra_route_string(client->proto));
	354
	355	/* Update the stale removal timer */
	356	if (info && info->t_stale_removal == NULL) {
	357
358	LOG_GR("%s: Stale time: %d is now update to: %d",
359	__func__, info->stale_removal_time,
360	api->stale_removal_time);
361
362	info->stale_removal_time = api->stale_removal_time;
363	}
364
365	break;
366	case ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE:
367	LOG_GR(
368	"%s: Client %s route update complete for AFI %d, SAFI %d",
369	__func__, zebra_route_string(client->proto), api->afi,
370	api->safi);
371	if (info)
372	info->route_sync[api->afi][api->safi] = true;
373	break;
374	case ZEBRA_CLIENT_ROUTE_UPDATE_PENDING:
375	LOG_GR("%s: Client %s route update pending for AFI %d, SAFI %d",
376	__func__, zebra_route_string(client->proto), api->afi,
377	api->safi);
378	if (info)
379	info->af_enabled[api->afi][api->safi] = true;
380	break;
381	}
382	}
383
384	/*
385	* Handler for capabilities that are received from client.
386	*/
387	static void zebra_client_capabilities_handler(struct zserv *client,
388	struct zapi_cap *api)
389	{
390	switch (api->cap) {
391	case ZEBRA_CLIENT_GR_CAPABILITIES:
392	case ZEBRA_CLIENT_ROUTE_UPDATE_PENDING:
393	case ZEBRA_CLIENT_GR_DISABLE:
394	case ZEBRA_CLIENT_RIB_STALE_TIME:
395	/*
396	* For all the cases we need to update the client info.
397	*/
398	zebra_client_update_info(client, api);
399	break;
400	case ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE:
401	/*
402	* After client info has been updated delete all
403	* stale routes
404	*/
405	zebra_client_update_info(client, api);
406	zebra_gr_process_client_stale_routes(client, api->vrf_id);
407	break;
408	}
409	}
410
411	/*
412	* Function to decode and call appropriate functions
413	* to handle client capabilities.
414	*/
415	void zread_client_capabilities(ZAPI_HANDLER_ARGS)
416	{
417	struct zapi_cap api;
418	struct stream *s;
419
420	s = msg;
421
422	if (zapi_capabilities_decode(s, &api)) {
423	LOG_GR("%s: Error in reading capabilities for client %s",
424	__func__, zebra_route_string(client->proto));
425	return;
426	}
427
428	/* Call the capabilities handler */
429	zebra_client_capabilities_handler(client, &api);
430	}
431
432
433	/*
434	* Stale route handling
435	*/
436
437	/*
438	* Delete all the stale routes that have not been refreshed
439	* post restart.
440	*/
441	static int32_t zebra_gr_route_stale_delete_timer_expiry(struct thread *thread)
442	{
443	struct client_gr_info *info;
444	int32_t cnt = 0;
445	struct zserv *client;
446
447	info = THREAD_ARG(thread);
448	info->t_stale_removal = NULL;
449	client = (struct zserv *)info->stale_client_ptr;
450
451	/* Set the flag to indicate all stale route deletion */
452	if (thread->u.val == 1)
453	info->delete = true;
454
455	cnt = zebra_gr_delete_stale_routes(info);
456
457	/* Retsart the timer */
458	if (cnt > 0) {
459	LOG_GR("%s: Client %s processed %d routes. Start timer again",
460	__func__, zebra_route_string(client->proto), cnt);
461
462	thread_add_timer(zrouter.master,
463	zebra_gr_route_stale_delete_timer_expiry, info,
464	ZEBRA_DEFAULT_STALE_UPDATE_DELAY,
465	&info->t_stale_removal);
466	} else {
467	/* No routes to delete for the VRF */
468	LOG_GR("%s: Client %s all starle routes processed", __func__,
469	zebra_route_string(client->proto));
470
471	if (info->current_prefix != NULL)
472	XFREE(MTYPE_TMP, info->current_prefix);
473	info->current_prefix = NULL;
474	info->current_afi = 0;
475	zebra_gr_delete_stale_client(info);
476	}
477	return 0;
478	}
479
480
481	/*
482	* Function to process to check if route entry is stale
483	* or has been updated.
484	*/
485	static void zebra_gr_process_route_entry(struct zserv *client,
486	struct route_node *rn,
487	struct route_entry *re)
488	{
489	char buf[PREFIX2STR_BUFFER];
490
491	if ((client == NULL) \|\| (rn == NULL) \|\| (re == NULL))
492	return;
493
494	/* If the route is not refreshed after restart, delete the entry */
495	if (re->uptime < client->restart_time) {
496	if (IS_ZEBRA_DEBUG_RIB) {
497	prefix2str(&rn->p, buf, sizeof(buf));
498	zlog_debug("%s: Client %s stale route %s is deleted",
499	__func__, zebra_route_string(client->proto),
500	buf);
501	}
502	rib_delnode(rn, re);
503	}
504	}
851140a7	505
b9e6727a S	506	/*
	507	* This function walks through the route table for all vrf and deletes
	508	* the stale routes for the restarted client specified by the protocol
	509	* type
	510	*/
	511	static int32_t zebra_gr_delete_stale_route(struct client_gr_info *info,
	512	struct zebra_vrf *zvrf)
851140a7	513	{
b9e6727a S	514	struct route_node rn, curr;
	515	struct route_entry *re;
	516	struct route_entry *next;
	517	struct route_table *table;
	518	int32_t n = 0;
	519	struct prefix *p;
	520	afi_t afi, curr_afi;
	521	uint8_t proto;
	522	uint16_t instance;
	523	struct zserv *s_client;
	524
	525	if ((info == NULL) \|\| (zvrf == NULL))
	526	return -1;
	527
	528	s_client = info->stale_client_ptr;
	529	if (s_client == NULL) {
	530	LOG_GR("%s: Stale client not present", __func__);
	531	return -1;
	532	}
	533
	534	proto = s_client->proto;
	535	instance = s_client->instance;
	536	curr_afi = info->current_afi;
	537
	538	LOG_GR("%s: Client %s stale routes are being deleted", __func__,
	539	zebra_route_string(proto));
	540
	541	/* Process routes for all AFI */
	542	for (afi = curr_afi; afi < AFI_MAX; afi++) {
	543	table = zvrf->table[afi][SAFI_UNICAST];
	544	p = info->current_prefix;
	545
	546	if (table) {
	547	/*
	548	* If the current prefix is NULL then get the first
	549	* route entry in the table
	550	*/
	551	if (p == NULL) {
	552	rn = route_top(table);
	553	if (rn == NULL)
	554	continue;
	555	p = XCALLOC(MTYPE_TMP, sizeof(struct prefix));
	556	if (p == NULL)
	557	return -1;
	558	curr = rn;
	559	prefix_copy(p, &rn->p);
	560	} else
	561	/* Get the next route entry */
	562	curr = route_table_get_next(table, p);
	563
	564	for (rn = curr; rn; rn = srcdest_route_next(rn)) {
	565	RNODE_FOREACH_RE_SAFE (rn, re, next) {
	566	if (CHECK_FLAG(re->status,
	567	ROUTE_ENTRY_REMOVED))
	568	continue;
	569	/* If the route refresh is received
	570	* after restart then do not delete
	571	* the route
	572	*/
	573	if (re->type == proto
	574	&& re->instance == instance) {
	575	zebra_gr_process_route_entry(
	576	s_client, rn, re);
	577	n++;
578	}
579
580	/* If the max route count is reached
581	* then timer thread will be restarted
582	* Store the current prefix and afi
583	*/
584	if ((n >= ZEBRA_MAX_STALE_ROUTE_COUNT)
585	&& (info->delete == false)) {
586	prefix_copy(p, &rn->p);
587	info->current_afi = afi;
588	info->current_prefix = p;
589	return n;
590	}
591	}
592	}
593	}
594	/*
595	* Reset the current prefix to indicate processing completion
596	* of the current AFI
597	*/
598	if (info->current_prefix) {
599	XFREE(MTYPE_TMP, info->current_prefix);
600	info->current_prefix = NULL;
601	}
602	continue;
603	}
851140a7 S	604	return 0;
851140a7 S	605	}
b9e6727a S	606
	607	/*
	608	* Delete the stale routes when client is restarted and routes are not
	609	* refreshed within the stale timeout
	610	*/
	611	static int32_t zebra_gr_delete_stale_routes(struct client_gr_info *info)
	612	{
	613	struct vrf *vrf;
	614	struct zebra_vrf *zvrf;
	615	uint64_t cnt = 0;
	616
	617	if (info == NULL)
	618	return -1;
	619
	620	/* Get the current VRF */
	621	vrf = vrf_lookup_by_id(info->vrf_id);
	622	if (vrf == NULL) {
	623	LOG_GR("%s: Invalid VRF %d", __func__, info->vrf_id);
	624	return -1;
	625	}
	626
	627	zvrf = vrf->info;
	628	if (zvrf == NULL) {
	629	LOG_GR("%s: Invalid VRF entry %d", __func__, info->vrf_id);
	630	return -1;
	631	}
	632
	633	cnt = zebra_gr_delete_stale_route(info, zvrf);
	634	return cnt;
	635	}
	636
	637	/*
	638	* This function checks if route update for all AFI, SAFI is completed
	639	* and cancels the stale timer
	640	*/
	641	static void zebra_gr_process_client_stale_routes(struct zserv *client,
	642	vrf_id_t vrf_id)
	643	{
	644	struct client_gr_info *info = NULL;
	645	afi_t afi;
	646	safi_t safi;
	647
	648	TAILQ_FOREACH (info, &client->gr_info_queue, gr_info) {
	649	if (info->vrf_id == vrf_id)
	650	break;
	651	}
	652
	653	if (info == NULL)
	654	return;
	655
	656	/* Check if route update completed for all AFI, SAFI */
	657	for (afi = AFI_IP; afi < AFI_MAX; afi++)
	658	for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++) {
	659	if (info->af_enabled[afi][safi]) {
	660	if (!info->route_sync[afi][safi]) {
	661	LOG_GR(
	662	"%s: Client %s route update not completed for AFI %d, SAFI %d",
	663	__func__, zebra_route_string(
	664	client->proto),
	665	afi, safi);
	666	return;
	667	}
	668	}
	669	}
670
671	/*
672	* Route update completed for all AFI, SAFI
673	* Cancel the stale timer and process the routes
674	*/
675	if (info->t_stale_removal) {
676	LOG_GR("%s: Client %s cancled stale delete timer vrf %d",
677	__func__, zebra_route_string(client->proto),
678	info->vrf_id);
679	THREAD_OFF(info->t_stale_removal);
680	thread_execute(zrouter.master,
681	zebra_gr_route_stale_delete_timer_expiry, info,
682	0);
683	}
684	}