2 * Zebra GR related helper functions.
5 * Copyright (C) 2019 VMware, Inc.
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)
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
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
26 #include "lib/prefix.h"
27 #include "lib/command.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"
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"
42 #include "lib/libfrr.h"
43 #include "lib/sockopt.h"
45 #include "zebra/zebra_router.h"
46 #include "zebra/debug.h"
47 #include "zebra/zapi_msg.h"
51 * Forward declaration.
53 static struct zserv
*zebra_gr_find_stale_client(struct zserv
*client
);
54 static void 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
,
62 #define LOG_GR(msg, ...) \
64 if (IS_ZEBRA_DEBUG_EVENT) \
65 zlog_debug(msg, ##__VA_ARGS__); \
70 * Client connection functions
74 * Function to clean all the stale clients,
75 * function will also clean up all per instance
76 * capabilities that are exchanged.
78 void zebra_gr_stale_client_cleanup(struct list
*client_list
)
80 struct listnode
*node
, *nnode
;
81 struct zserv
*s_client
= NULL
;
82 struct client_gr_info
*info
, *ninfo
;
84 /* Find the stale client */
85 for (ALL_LIST_ELEMENTS(client_list
, node
, nnode
, s_client
)) {
87 LOG_GR("%s: Stale client %s is being deleted", __func__
,
88 zebra_route_string(s_client
->proto
));
90 TAILQ_FOREACH_SAFE (info
, &s_client
->gr_info_queue
, gr_info
,
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 */
100 zebra_gr_route_stale_delete_timer_expiry
,
108 * A helper function to create client info.
110 static struct client_gr_info
*zebra_gr_client_info_create(struct zserv
*client
)
112 struct client_gr_info
*info
;
114 info
= XCALLOC(MTYPE_TMP
, sizeof(struct client_gr_info
));
116 TAILQ_INSERT_TAIL(&(client
->gr_info_queue
), info
, gr_info
);
121 * A helper function to delete and destroy client info.
123 static void zebra_gr_client_info_delte(struct zserv
*client
,
124 struct client_gr_info
*info
)
126 TAILQ_REMOVE(&(client
->gr_info_queue
), info
, gr_info
);
128 THREAD_OFF(info
->t_stale_removal
);
130 XFREE(MTYPE_TMP
, info
->current_prefix
);
132 LOG_GR("%s: Instance info is being deleted for client %s", __func__
,
133 zebra_route_string(client
->proto
));
135 /* Delete all the stale routes. */
136 info
->do_delete
= true;
137 zebra_gr_delete_stale_routes(info
);
139 XFREE(MTYPE_TMP
, info
);
143 * Function to handle client when it disconnect.
145 int32_t zebra_gr_client_disconnect(struct zserv
*client
)
147 struct zserv
*stale_client
;
149 struct client_gr_info
*info
= NULL
;
151 /* Find the stale client */
152 stale_client
= zebra_gr_find_stale_client(client
);
155 * We should never be here.
158 LOG_GR("%s: Stale client %s exist, we should not be here!",
159 __func__
, zebra_route_string(client
->proto
));
163 client
->restart_time
= monotime(&tv
);
165 /* For all the GR instance start the stale removal timer. */
166 TAILQ_FOREACH (info
, &client
->gr_info_queue
, gr_info
) {
167 if (ZEBRA_CLIENT_GR_ENABLED(info
->capabilities
)
168 && (info
->t_stale_removal
== NULL
)) {
171 zebra_gr_route_stale_delete_timer_expiry
, info
,
172 info
->stale_removal_time
,
173 &info
->t_stale_removal
);
174 info
->current_afi
= AFI_IP
;
175 info
->stale_client_ptr
= client
;
176 info
->stale_client
= true;
177 LOG_GR("%s: Client %s Stale timer update to %d",
178 __func__
, zebra_route_string(client
->proto
),
179 info
->stale_removal_time
);
183 listnode_add(zrouter
.stale_client_list
, client
);
189 * Function to delete stale client
191 static void zebra_gr_delete_stale_client(struct client_gr_info
*info
)
193 struct client_gr_info
*bgp_info
;
194 struct zserv
*s_client
= NULL
;
196 s_client
= info
->stale_client_ptr
;
198 if (!s_client
|| !info
->stale_client
)
202 * If there are bgp instances with the stale delete timer pending
203 * then stale client is not deleted
205 if ((s_client
->gr_instance_count
> 0) && info
->gr_enable
)
206 s_client
->gr_instance_count
--;
208 TAILQ_REMOVE(&(s_client
->gr_info_queue
), info
, gr_info
);
210 LOG_GR("%s: Client %s gr count %d", __func__
,
211 zebra_route_string(s_client
->proto
),
212 s_client
->gr_instance_count
);
214 TAILQ_FOREACH (bgp_info
, &s_client
->gr_info_queue
, gr_info
) {
215 if (bgp_info
->t_stale_removal
!= NULL
)
219 LOG_GR("%s: Client %s is being deleted", __func__
,
220 zebra_route_string(s_client
->proto
));
222 TAILQ_INIT(&(s_client
->gr_info_queue
));
223 listnode_delete(zrouter
.stale_client_list
, s_client
);
224 if (info
->stale_client
)
225 XFREE(MTYPE_TMP
, s_client
);
226 XFREE(MTYPE_TMP
, info
);
230 * Function to find stale client.
232 static struct zserv
*zebra_gr_find_stale_client(struct zserv
*client
)
234 struct listnode
*node
, *nnode
;
235 struct zserv
*stale_client
;
237 /* Find the stale client */
238 for (ALL_LIST_ELEMENTS(zrouter
.stale_client_list
, node
, nnode
,
240 if (client
->proto
== stale_client
->proto
241 && client
->instance
== stale_client
->instance
) {
250 * Function to handle reconnect of client post restart.
252 void zebra_gr_client_reconnect(struct zserv
*client
)
254 struct listnode
*node
, *nnode
;
255 struct zserv
*old_client
= NULL
;
256 struct client_gr_info
*info
= NULL
;
258 /* Find the stale client */
259 for (ALL_LIST_ELEMENTS(zrouter
.stale_client_list
, node
, nnode
,
261 if (client
->proto
== old_client
->proto
262 && client
->instance
== old_client
->instance
)
266 /* Copy the timers */
270 client
->gr_instance_count
= old_client
->gr_instance_count
;
271 client
->restart_time
= old_client
->restart_time
;
273 LOG_GR("%s : old client %s, gr_instance_count %d", __func__
,
274 zebra_route_string(old_client
->proto
),
275 old_client
->gr_instance_count
);
277 if (TAILQ_FIRST(&old_client
->gr_info_queue
)) {
278 TAILQ_CONCAT(&client
->gr_info_queue
, &old_client
->gr_info_queue
,
280 TAILQ_INIT(&old_client
->gr_info_queue
);
283 TAILQ_FOREACH (info
, &client
->gr_info_queue
, gr_info
) {
284 info
->stale_client_ptr
= client
;
285 info
->stale_client
= false;
288 /* Delete the stale client */
289 listnode_delete(zrouter
.stale_client_list
, old_client
);
290 /* Delete old client */
291 XFREE(MTYPE_TMP
, old_client
);
295 * Functions to deal with capabilities
299 * Update the graceful restart information
300 * for the client instance.
301 * This function handles all the capabilities that are received.
303 static void zebra_client_update_info(struct zserv
*client
, struct zapi_cap
*api
)
305 struct client_gr_info
*info
= NULL
;
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
)
315 * If the command is delete, then cancel the stale timer and
316 * delete the bgp info
319 case ZEBRA_CLIENT_GR_DISABLE
:
323 LOG_GR("%s: Client %s instance GR disabled count %d", __func__
,
324 zebra_route_string(client
->proto
),
325 client
->gr_instance_count
);
327 if ((info
->gr_enable
) && (client
->gr_instance_count
> 0))
328 client
->gr_instance_count
--;
330 zebra_gr_client_info_delte(client
, info
);
332 case ZEBRA_CLIENT_GR_CAPABILITIES
:
333 /* Allocate bgp info */
335 info
= zebra_gr_client_info_create(client
);
337 /* Update other parameters */
338 if (!info
->gr_enable
) {
339 client
->gr_instance_count
++;
341 LOG_GR("%s: Cient %s GR enabled count %d", __func__
,
342 zebra_route_string(client
->proto
),
343 client
->gr_instance_count
);
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;
351 case ZEBRA_CLIENT_RIB_STALE_TIME
:
352 LOG_GR("%s: Client %s stale time update event", __func__
,
353 zebra_route_string(client
->proto
));
355 /* Update the stale removal timer */
356 if (info
&& info
->t_stale_removal
== NULL
) {
358 LOG_GR("%s: Stale time: %d is now update to: %d",
359 __func__
, info
->stale_removal_time
,
360 api
->stale_removal_time
);
362 info
->stale_removal_time
= api
->stale_removal_time
;
366 case ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE
:
368 "%s: Client %s route update complete for AFI %d, SAFI %d",
369 __func__
, zebra_route_string(client
->proto
), api
->afi
,
372 info
->route_sync
[api
->afi
][api
->safi
] = true;
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
,
379 info
->af_enabled
[api
->afi
][api
->safi
] = true;
385 * Handler for capabilities that are received from client.
387 static void zebra_client_capabilities_handler(struct zserv
*client
,
388 struct zapi_cap
*api
)
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
:
396 * For all the cases we need to update the client info.
398 zebra_client_update_info(client
, api
);
400 case ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE
:
402 * After client info has been updated delete all
405 zebra_client_update_info(client
, api
);
406 zebra_gr_process_client_stale_routes(client
, api
->vrf_id
);
412 * Function to decode and call appropriate functions
413 * to handle client capabilities.
415 void zread_client_capabilities(ZAPI_HANDLER_ARGS
)
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
));
428 /* GR only for dynamic clients */
429 if (client
->proto
<= ZEBRA_ROUTE_CONNECT
) {
430 LOG_GR("%s: GR capabilities for client %s not supported",
431 __func__
, zebra_route_string(client
->proto
));
434 /* Call the capabilities handler */
435 zebra_client_capabilities_handler(client
, &api
);
440 * Stale route handling
444 * Delete all the stale routes that have not been refreshed
447 static void zebra_gr_route_stale_delete_timer_expiry(struct thread
*thread
)
449 struct client_gr_info
*info
;
451 struct zserv
*client
;
453 info
= THREAD_ARG(thread
);
454 info
->t_stale_removal
= NULL
;
455 client
= (struct zserv
*)info
->stale_client_ptr
;
457 /* Set the flag to indicate all stale route deletion */
458 if (thread
->u
.val
== 1)
459 info
->do_delete
= true;
461 cnt
= zebra_gr_delete_stale_routes(info
);
463 /* Restart the timer */
465 LOG_GR("%s: Client %s processed %d routes. Start timer again",
466 __func__
, zebra_route_string(client
->proto
), cnt
);
468 thread_add_timer(zrouter
.master
,
469 zebra_gr_route_stale_delete_timer_expiry
, info
,
470 ZEBRA_DEFAULT_STALE_UPDATE_DELAY
,
471 &info
->t_stale_removal
);
473 /* No routes to delete for the VRF */
474 LOG_GR("%s: Client %s all stale routes processed", __func__
,
475 zebra_route_string(client
->proto
));
477 XFREE(MTYPE_TMP
, info
->current_prefix
);
478 info
->current_afi
= 0;
479 zebra_gr_delete_stale_client(info
);
485 * Function to process to check if route entry is stale
486 * or has been updated.
488 static void zebra_gr_process_route_entry(struct zserv
*client
,
489 struct route_node
*rn
,
490 struct route_entry
*re
)
492 if ((client
== NULL
) || (rn
== NULL
) || (re
== NULL
))
495 /* If the route is not refreshed after restart, delete the entry */
496 if (re
->uptime
< client
->restart_time
) {
497 if (IS_ZEBRA_DEBUG_RIB
)
498 zlog_debug("%s: Client %s stale route %pFX is deleted",
499 __func__
, zebra_route_string(client
->proto
),
506 * This function walks through the route table for all vrf and deletes
507 * the stale routes for the restarted client specified by the protocol
510 static int32_t zebra_gr_delete_stale_route(struct client_gr_info
*info
,
511 struct zebra_vrf
*zvrf
)
513 struct route_node
*rn
, *curr
;
514 struct route_entry
*re
;
515 struct route_entry
*next
;
516 struct route_table
*table
;
521 struct zserv
*s_client
;
523 if ((info
== NULL
) || (zvrf
== NULL
))
526 s_client
= info
->stale_client_ptr
;
527 if (s_client
== NULL
) {
528 LOG_GR("%s: Stale client not present", __func__
);
532 proto
= s_client
->proto
;
533 instance
= s_client
->instance
;
534 curr_afi
= info
->current_afi
;
536 LOG_GR("%s: Client %s stale routes are being deleted", __func__
,
537 zebra_route_string(proto
));
539 /* Process routes for all AFI */
540 for (afi
= curr_afi
; afi
< AFI_MAX
; afi
++) {
541 table
= zvrf
->table
[afi
][SAFI_UNICAST
];
545 * If the current prefix is NULL then get the first
546 * route entry in the table
548 if (info
->current_prefix
== NULL
) {
549 rn
= route_top(table
);
554 /* Get the next route entry */
555 curr
= route_table_get_next(
556 table
, info
->current_prefix
);
558 for (rn
= curr
; rn
; rn
= srcdest_route_next(rn
)) {
559 RNODE_FOREACH_RE_SAFE (rn
, re
, next
) {
560 if (CHECK_FLAG(re
->status
,
561 ROUTE_ENTRY_REMOVED
))
563 /* If the route refresh is received
564 * after restart then do not delete
567 if (re
->type
== proto
568 && re
->instance
== instance
) {
569 zebra_gr_process_route_entry(
574 /* If the max route count is reached
575 * then timer thread will be restarted
576 * Store the current prefix and afi
578 if ((n
>= ZEBRA_MAX_STALE_ROUTE_COUNT
)
579 && (info
->do_delete
== false)) {
580 info
->current_afi
= afi
;
581 info
->current_prefix
= XCALLOC(
583 sizeof(struct prefix
));
585 info
->current_prefix
,
593 * Reset the current prefix to indicate processing completion
596 XFREE(MTYPE_TMP
, info
->current_prefix
);
602 * Delete the stale routes when client is restarted and routes are not
603 * refreshed within the stale timeout
605 static int32_t zebra_gr_delete_stale_routes(struct client_gr_info
*info
)
608 struct zebra_vrf
*zvrf
;
614 /* Get the current VRF */
615 vrf
= vrf_lookup_by_id(info
->vrf_id
);
617 LOG_GR("%s: Invalid VRF %d", __func__
, info
->vrf_id
);
623 LOG_GR("%s: Invalid VRF entry %d", __func__
, info
->vrf_id
);
627 cnt
= zebra_gr_delete_stale_route(info
, zvrf
);
632 * This function checks if route update for all AFI, SAFI is completed
633 * and cancels the stale timer
635 static void zebra_gr_process_client_stale_routes(struct zserv
*client
,
638 struct client_gr_info
*info
= NULL
;
642 TAILQ_FOREACH (info
, &client
->gr_info_queue
, gr_info
) {
643 if (info
->vrf_id
== vrf_id
)
650 /* Check if route update completed for all AFI, SAFI */
651 FOREACH_AFI_SAFI_NSF (afi
, safi
) {
652 if (info
->af_enabled
[afi
][safi
]) {
653 if (!info
->route_sync
[afi
][safi
]) {
654 LOG_GR("%s: Client %s route update not completed for AFI %d, SAFI %d",
656 zebra_route_string(client
->proto
), afi
,
664 * Route update completed for all AFI, SAFI
665 * Cancel the stale timer and process the routes
667 if (info
->t_stale_removal
) {
668 LOG_GR("%s: Client %s canceled stale delete timer vrf %d",
669 __func__
, zebra_route_string(client
->proto
),
671 THREAD_OFF(info
->t_stale_removal
);
672 thread_execute(zrouter
.master
,
673 zebra_gr_route_stale_delete_timer_expiry
, info
,