proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-04-29 14:02:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

bgpd: BGP Garaceful Restart debug logs.

Browse Source 
Reorganizing bgp gr debug logs and code review comments.

Signed-off-by: Biswajit Sadhu <sadhub@vmware.com>
This commit is contained in:
bisdhdh 2019-11-25 20:48:15 +05:30
parent efcb2ebbb2
commit 2ba1fe6951
13 changed files with 322 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
bgpd/bgp_fsm.c
View File

@ -1122,10 +1122,11 @@ int bgp_stop(struct peer *peer)
safi_t safi;
char orf_name[BUFSIZ];
int ret = 0;
peer->nsf_af_count = 0;
struct bgp *bgp = peer->bgp;
struct graceful_restart_info *gr_info = NULL;
peer->nsf_af_count = 0;
if (peer_dynamic_neighbor(peer)
&& !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
if (bgp_debug_neighbor_events(peer))
@ -1208,7 +1209,7 @@ int bgp_stop(struct peer *peer)
if (gr_info && BGP_DEBUG(update,
UPDATE_OUT))
zlog_debug(
"peer %s, EOR %d",
"peer %s, EOR_required %d",
peer->host,
gr_info->eor_required);
@ -1741,7 +1742,7 @@ static int bgp_update_gr_info(struct peer *peer, afi_t afi, safi_t safi)
ret = bgp_start_deferral_timer(bgp, afi, safi, gr_info);
}
}
return (ret);
return ret;
}
/**
@ -1830,8 +1831,8 @@ static int bgp_establish(struct peer *peer)
status = bgp_update_gr_info(peer, afi,
safi);
if (status < 0)
zlog_debug("Error in updating graceful restart for %s",
get_afi_safi_str(afi,
zlog_err("Error in updating graceful restart for %s",
get_afi_safi_str(afi,
safi, false));
} else {
if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(
@ -2278,7 +2279,7 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: %s Peer: (%s) :",
"%s [BGP_GR] Peer: (%s) :",
__func__, peer->host);
peer_old_state = bgp_peer_gr_mode_get(peer);
@ -2293,29 +2294,23 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
*/
switch (global_new_state) {
case GLOBAL_HELPER:
BGP_PEER_GR_HELPER_ENABLE(peer);
break;
case GLOBAL_GR:
BGP_PEER_GR_ENABLE(peer);
break;
case GLOBAL_DISABLE:
BGP_PEER_GR_DISABLE(peer);
break;
case GLOBAL_INVALID:
zlog_debug(
"BGP_GR:: %s :GLOBAL_INVALID",
"%s [BGP_GR]GLOBAL_INVALID",
__func__);
return BGP_ERR_GR_OPERATION_FAILED;
default:
zlog_debug(
"BGP_GR:: %s :Global unknown ERROR",
"%s [BGP_GR]Global unknown ERROR",
__func__);
return BGP_ERR_GR_OPERATION_FAILED;
}
@ -2324,45 +2319,53 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
bgp->global_gr_present_state = global_new_state;
/* debug Trace msg */
return BGP_GR_SUCCESS;
}
int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd)
int bgp_gr_update_all(struct bgp *bgp, int global_gr_cmd)
{
enum global_mode global_new_state = GLOBAL_INVALID;
enum global_mode global_old_state = GLOBAL_INVALID;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR::%s:START: global_GR_Cmd :%d:",
__func__, global_GR_Cmd);
"%s [BGP_GR]START: global_gr_cmd :%s:",
__func__, print_global_gr_cmd(global_gr_cmd));
global_old_state = bgp_global_gr_mode_get(bgp);
if (global_old_state != GLOBAL_INVALID) {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"[BGP_GR] global_old_gr_state :%s:",
print_global_gr_mode(global_old_state));
if (global_old_state != GLOBAL_INVALID) {
global_new_state =
bgp->GLOBAL_GR_FSM[global_old_state][global_GR_Cmd];
bgp->GLOBAL_GR_FSM[global_old_state][global_gr_cmd];
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"[BGP_GR] global_new_gr_state :%s:",
print_global_gr_mode(global_new_state));
} else {
/* Trace msg */
zlog_debug("BGP_GR::%s:global_old_state == GLOBAL_INVALID",
zlog_err(
"%s [BGP_GR] global_old_state == GLOBAL_INVALID",
__func__);
return BGP_ERR_GR_OPERATION_FAILED;
}
if (global_new_state == GLOBAL_INVALID) {
/* Trace msg */
zlog_debug(
"BGP_GR::%s: global_new_state == GLOBAL_INVALID",
zlog_err(
"%s [BGP_GR] global_new_state == GLOBAL_INVALID",
__func__);
return BGP_ERR_GR_INVALID_CMD;
}
if (global_new_state == global_old_state) {
/* Trace msg */
zlog_debug(
"BGP_GR::%s : global_new_state == global_old_state",
__func__);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"%s [BGP_GR] global_new_state == global_old_state :%s",
__func__, print_global_gr_mode(global_new_state));
return BGP_GR_NO_OPERATION;
}
@ -2371,6 +2374,103 @@ int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd)
global_old_state);
}
const char *print_peer_gr_mode(enum peer_mode pr_mode)
{
const char *peer_gr_mode = NULL;
switch (pr_mode) {
case PEER_HELPER:
peer_gr_mode = "PEER_HELPER";
break;
case PEER_GR:
peer_gr_mode = "PEER_GR";
break;
case PEER_DISABLE:
peer_gr_mode = "PEER_DISABLE";
break;
case PEER_INVALID:
peer_gr_mode = "PEER_INVALID";
break;
case PEER_GLOBAL_INHERIT:
peer_gr_mode = "PEER_GLOBAL_INHERIT";
break;
}
return peer_gr_mode;
}
const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd)
{
const char *peer_gr_cmd = NULL;
switch (pr_gr_cmd) {
case PEER_GR_CMD:
peer_gr_cmd = "PEER_GR_CMD";
break;
case NO_PEER_GR_CMD:
peer_gr_cmd = "NO_PEER_GR_CMD";
break;
case PEER_DISABLE_CMD:
peer_gr_cmd = "PEER_GR_CMD";
break;
case NO_PEER_DISABLE_CMD:
peer_gr_cmd = "NO_PEER_GR_CMD";
break;
case PEER_HELPER_CMD:
peer_gr_cmd = "PEER_HELPER_CMD";
break;
case NO_PEER_HELPER_CMD:
peer_gr_cmd = "NO_PEER_HELPER_CMD";
break;
}
return peer_gr_cmd;
}
const char *print_global_gr_mode(enum global_mode gl_mode)
{
const char *global_gr_mode = NULL;
switch (gl_mode) {
case GLOBAL_HELPER:
global_gr_mode = "GLOBAL_HELPER";
break;
case GLOBAL_GR:
global_gr_mode = "GLOBAL_GR";
break;
case GLOBAL_DISABLE:
global_gr_mode = "GLOBAL_DISABLE";
break;
case GLOBAL_INVALID:
global_gr_mode = "GLOBAL_INVALID";
break;
}
return global_gr_mode;
}
const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd)
{
const char *global_gr_cmd = NULL;
switch (gl_gr_cmd) {
case GLOBAL_GR_CMD:
global_gr_cmd = "GLOBAL_GR_CMD";
break;
case NO_GLOBAL_GR_CMD:
global_gr_cmd = "NO_GLOBAL_GR_CMD";
break;
case GLOBAL_DISABLE_CMD:
global_gr_cmd = "GLOBAL_DISABLE_CMD";
break;
case NO_GLOBAL_DISABLE_CMD:
global_gr_cmd = "NO_GLOBAL_DISABLE_CMD";
break;
}
return global_gr_cmd;
}
enum global_mode bgp_global_gr_mode_get(struct bgp *bgp)
{
return bgp->global_gr_present_state;
@ -2382,7 +2482,7 @@ enum peer_mode bgp_peer_gr_mode_get(struct peer *peer)
}
int bgp_neighbor_graceful_restart(struct peer *peer,
int peer_GR_Cmd)
int peer_gr_cmd)
{
enum peer_mode peer_new_state = PEER_INVALID;
enum peer_mode peer_old_state = PEER_INVALID;
@ -2397,25 +2497,23 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: %s:START--->Peer: (%s) : peer_GR_Cmd :%d:",
__func__, peer->host, peer_GR_Cmd);
"%s [BGP_GR] START:Peer: (%s) : peer_gr_cmd :%s:",
__func__, peer->host, print_peer_gr_cmd(peer_gr_cmd));
peer_old_state = bgp_peer_gr_mode_get(peer);
if (peer_old_state == PEER_INVALID) {
/* debug Trace msg */
zlog_debug(
"BGP_GR:: peer_old_state ==Invalid state !");
"[BGP_GR] peer_old_state == Invalid state !");
return BGP_ERR_GR_OPERATION_FAILED;
}
peer_state = peer->PEER_GR_FSM[peer_old_state][peer_GR_Cmd];
peer_state = peer->PEER_GR_FSM[peer_old_state][peer_gr_cmd];
peer_new_state = peer_state.next_state;
if (peer_new_state == PEER_INVALID) {
/* debug Trace msg */
zlog_debug(
"BGP_GR:: Invalid bgp graceful restart command used !");
"[BGP_GR] Invalid bgp graceful restart command used !");
return BGP_ERR_GR_INVALID_CMD;
}
@ -2424,9 +2522,9 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
peer_old_state,
peer_new_state);
} else {
/* debug Trace msg */
zlog_debug(
"BGP_GR:: peer_old_state == peer_new_state !");
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"[BGP_GR] peer_old_state == peer_new_state !");
return BGP_GR_NO_OPERATION;
}
@ -2434,10 +2532,9 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
/* Update the mode i.e peer_new_state into the peer structure */
peer->peer_gr_present_state = peer_new_state;
/* debug Trace msg */
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Succesfully change the state of the peer to : %d : !",
peer_new_state);
zlog_debug("[BGP_GR] Succesfully change the state of the peer to : %s : !",
print_peer_gr_mode(peer_new_state));
return BGP_GR_SUCCESS;
}
@ -2450,15 +2547,15 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
{
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: %s : Move peer from old_peer_state :%d: to old_peer_state :%d: !!!!",
__func__, old_peer_state, new_peer_state);
"%s [BGP_GR] Move peer from old_peer_state :%s: to new_peer_state :%s: !!!!",
__func__, print_peer_gr_mode(old_peer_state),
print_peer_gr_mode(new_peer_state));
int bgp_gr_global_mode = GLOBAL_INVALID;
unsigned int ret = BGP_GR_FAILURE;
if (old_peer_state == new_peer_state) {
/* Nothing to do over here as the present and old state is the same */
/* debug Trace msg */
return BGP_GR_NO_OPERATION;
}
if ((old_peer_state == PEER_INVALID) ||
@ -2490,13 +2587,12 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
*of the existing session
*as the peer is already working in the same mode.
*/
/* debug Trace msg */
ret = BGP_GR_SUCCESS;
} else {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Peer state changed from :%d =>",
old_peer_state);
"[BGP_GR] Peer state changed from :%s ",
print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, new_peer_state);
@ -2531,8 +2627,8 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
*/
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Peer state changed from :%d ==>",
old_peer_state);
zlog_debug("[BGP_GR] Peer state changed from :%s",
print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, bgp_gr_global_mode);
@ -2545,8 +2641,8 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
*( old_peer_state != Peer_Global )
*/
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Peer state changed from :%d ===>",
old_peer_state);
zlog_debug("[BGP_GR] Peer state changed from :%s",
print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, new_peer_state);
@ -2562,19 +2658,15 @@ inline void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state)
int bgp_global_gr_mode = bgp_global_gr_mode_get(peer->bgp);
switch (new_state) {
case PEER_HELPER:
BGP_PEER_GR_HELPER_ENABLE(peer);
break;
case PEER_GR:
BGP_PEER_GR_ENABLE(peer);
break;
case PEER_DISABLE:
BGP_PEER_GR_DISABLE(peer);
break;
case PEER_GLOBAL_INHERIT:
BGP_PEER_GR_GLOBAL_INHERIT_SET(peer);
@ -2585,16 +2677,16 @@ inline void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state)
} else if (bgp_global_gr_mode == GLOBAL_DISABLE) {
BGP_PEER_GR_DISABLE(peer);
} else {
zlog_debug(
"BGP_GR:: Default switch inherit mode ::: SOMETHING IS WRONG !!!");
zlog_err(
"[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
}
break;
default:
zlog_debug("BGP_GR:: Default switch mode ::: SOMETHING IS WRONG !!!");
zlog_err("[BGP_GR] Default switch mode ::: SOMETHING IS WRONG !!!");
break;
}
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Peer state changed --to--> : %d : !",
zlog_debug("[BGP_GR] Peer state changed --to--> : %d : !",
new_state);
}
@ -2602,7 +2694,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
{
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: %s called !",
"%s [BGP_GR] called !",
__func__);
if (CHECK_FLAG(peer->peer_gr_new_status_flag,
PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
@ -2613,7 +2705,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
PEER_FLAG_GRACEFUL_RESTART_HELPER);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_HELPER : %s : !",
"[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_HELPER : %s : !",
peer->host,
(CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART_HELPER) ?
@ -2627,7 +2719,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
PEER_FLAG_GRACEFUL_RESTART);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
"[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
peer->host,
(CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART) ?
@ -2641,7 +2733,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT : %s : !",
"[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT : %s : !",
peer->host,
(CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT) ?
@ -2652,7 +2744,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
!CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART_HELPER)){
zlog_debug(
"BGP_GR:: Peer %s UNSET PEER_STATUS_NSF_MODE!",
"[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
peer->host);
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
@ -2662,7 +2754,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
peer_nsf_stop(peer);
zlog_debug(
"BGP_GR:: Peer %s UNSET PEER_STATUS_NSF_WAIT!",
"[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_WAIT!",
peer->host);
}
}

8
bgpd/bgp_fsm.h
View File

@ -142,9 +142,9 @@ extern void bgp_adjust_routeadv(struct peer *);
DECLARE_HOOK(peer_backward_transition, (struct peer *peer), (peer))
DECLARE_HOOK(peer_established, (struct peer *peer), (peer))
int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd);
int bgp_gr_update_all(struct bgp *bgp, int global_gr_cmd);
int bgp_neighbor_graceful_restart(struct peer *peer,
int peer_GR_Cmd);
int peer_gr_cmd);
unsigned int bgp_peer_gr_action(struct peer *peer,
int old_peer_state, int new_peer_state);
void bgp_peer_move_to_gr_mode(struct peer *peer, int new_state);
@ -160,4 +160,8 @@ int bgp_gr_lookup_n_update_all_peer(struct bgp *bgp,
enum global_mode global_new_state,
enum global_mode global_old_state);
void bgp_peer_gr_flags_update(struct peer *peer);
const char *print_peer_gr_mode(enum peer_mode pr_mode);
const char *print_peer_gr_cmd(enum peer_gr_command pr_gr_cmd);
const char *print_global_gr_mode(enum global_mode gl_mode);
const char *print_global_gr_cmd(enum global_gr_command gl_gr_cmd);
#endif /* _QUAGGA_BGP_FSM_H */

6
bgpd/bgp_open.c
View File

@ -1327,7 +1327,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Sending helper Capability for Peer :%s :",
"[BGP_GR] Sending helper Capability for Peer :%s :",
peer->host);
SET_FLAG(peer->cap, PEER_CAP_RESTART_ADV);
@ -1345,7 +1345,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Sending R-Bit for Peer :%s :",
"[BGP_GR] Sending R-Bit for Peer :%s :",
peer->host);
}
@ -1360,7 +1360,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
if (BGP_DEBUG(graceful_restart,
GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: Sending GR Capability for AFI :%d :, SAFI :%d:",
"[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
afi, safi);
/* Convert AFI, SAFI to values for

4
bgpd/bgp_packet.c
View File

@ -738,14 +738,14 @@ void bgp_notify_send_with_data(struct peer *peer, uint8_t code,
data[i]);
strlcat(bgp_notify.data, c,
bgp_notify.length * 3);
bgp_notify.length);
} else {
first = 1;
snprintf(c, sizeof(c), "%02x", data[i]);
strlcpy(bgp_notify.data, c,
bgp_notify.length * 3);
bgp_notify.length);
}
}

6
bgpd/bgp_route.c
View File

@ -311,7 +311,7 @@ static int bgp_node_set_defer_flag(struct bgp_node *rn, bool delete)
/* If the flag BGP_NODE_SELECT_DEFER is set and new path is added
* then the route selection is deferred
*/
if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER) && (delete == false))
if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER) && (!delete))
return 0;
if (CHECK_FLAG(rn->flags, BGP_NODE_PROCESS_SCHEDULED)) {
@ -359,7 +359,7 @@ static int bgp_node_set_defer_flag(struct bgp_node *rn, bool delete)
/* Set the flag BGP_NODE_SELECT_DEFER if route selection deferral timer
* is active
*/
if (set_flag) {
if (set_flag && table) {
if (bgp && (bgp->gr_info[afi][safi].t_select_deferral)) {
SET_FLAG(rn->flags, BGP_NODE_SELECT_DEFER);
prefix2str(&rn->p, buf, PREFIX2STR_BUFFER);
@ -2486,7 +2486,7 @@ static void bgp_process_main_one(struct bgp *bgp, struct bgp_node *rn,
*/
if (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER)) {
if (BGP_DEBUG(update, UPDATE_OUT))
zlog_debug("DEFER set for route %p", rn);
zlog_debug("SELECT_DEFER falg set for route %p", rn);
return;
}

4
bgpd/bgp_table.c
View File

@ -146,7 +146,9 @@ void bgp_delete_listnode(struct bgp_node *node)
bgp = table->bgp;
afi = table->afi;
safi = table->safi;
}
} else
return;
rn = bgp_node_to_rnode(node);
if (bgp && rn && rn->lock == 1) {

252
bgpd/bgp_vty.c
View File

@ -105,7 +105,7 @@ DEFINE_HOOK(bgp_inst_config_write,
(struct bgp *bgp, struct vty *vty),
(bgp, vty))
#define GR_NO_OPER "The Graceful Restart No Operation was executed as cmd same as previous one"
#define GR_NO_OPER "The Graceful Restart No Operation was executed as cmd same as previous one."
#define GR_INVALID "The Graceful Restart command used is not valid at this moment."
static struct peer_group *listen_range_exists(struct bgp *bgp,
struct prefix *range, int exact);
@ -944,7 +944,7 @@ static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = TRUE;
gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
@ -982,7 +982,7 @@ static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
if (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = TRUE;
gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
@ -2182,16 +2182,16 @@ DEFUN (no_bgp_deterministic_med,
/* "bgp graceful-restart mode" configuration. */
DEFUN (bgp_graceful_restart,
bgp_graceful_restart_cmd,
"bgp graceful-restart",
"BGP specific commands\n"
GR_CMD
bgp_graceful_restart_cmd,
"bgp graceful-restart",
"BGP specific commands\n"
GR_CMD
)
{
int ret = BGP_GR_FAILURE;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: bgp_graceful_restart_cmd : START ");
zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : START ");
VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2201,24 +2201,24 @@ DEFUN (bgp_graceful_restart,
bgp->peer, ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: bgp_graceful_restart_cmd : END ");
zlog_debug("[BGP_GR] bgp_graceful_restart_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n");
return bgp_vty_return(vty, ret);
}
DEFUN (no_bgp_graceful_restart,
no_bgp_graceful_restart_cmd,
"no bgp graceful-restart",
NO_STR
"BGP specific commands\n"
NO_GR_CMD
no_bgp_graceful_restart_cmd,
"no bgp graceful-restart",
NO_STR
"BGP specific commands\n"
NO_GR_CMD
)
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: no_bgp_graceful_restart_cmd : START ");
zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : START ");
int ret = BGP_GR_FAILURE;
@ -2228,7 +2228,7 @@ DEFUN (no_bgp_graceful_restart,
bgp->peer, ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: no_bgp_graceful_restart_cmd : END ");
zlog_debug("[BGP_GR] no_bgp_graceful_restart_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n");
@ -2236,12 +2236,12 @@ DEFUN (no_bgp_graceful_restart,
}
DEFUN (bgp_graceful_restart_stalepath_time,
bgp_graceful_restart_stalepath_time_cmd,
"bgp graceful-restart stalepath-time (1-4095)",
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the max time to hold onto restarting peer's stale paths\n"
"Delay value (seconds)\n")
bgp_graceful_restart_stalepath_time_cmd,
"bgp graceful-restart stalepath-time (1-4095)",
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the max time to hold onto restarting peer's stale paths\n"
"Delay value (seconds)\n")
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3;
@ -2253,12 +2253,12 @@ DEFUN (bgp_graceful_restart_stalepath_time,
}
DEFUN (bgp_graceful_restart_restart_time,
bgp_graceful_restart_restart_time_cmd,
"bgp graceful-restart restart-time (1-4095)",
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the time to wait to delete stale routes before a BGP open message is received\n"
"Delay value (seconds)\n")
bgp_graceful_restart_restart_time_cmd,
"bgp graceful-restart restart-time (1-4095)",
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the time to wait to delete stale routes before a BGP open message is received\n"
"Delay value (seconds)\n")
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3;
@ -2292,13 +2292,13 @@ DEFUN (bgp_graceful_restart_select_defer_time,
}
DEFUN (no_bgp_graceful_restart_stalepath_time,
no_bgp_graceful_restart_stalepath_time_cmd,
"no bgp graceful-restart stalepath-time [(1-4095)]",
NO_STR
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the max time to hold onto restarting peer's stale paths\n"
"Delay value (seconds)\n")
no_bgp_graceful_restart_stalepath_time_cmd,
"no bgp graceful-restart stalepath-time [(1-4095)]",
NO_STR
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the max time to hold onto restarting peer's stale paths\n"
"Delay value (seconds)\n")
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2307,13 +2307,13 @@ DEFUN (no_bgp_graceful_restart_stalepath_time,
}
DEFUN (no_bgp_graceful_restart_restart_time,
no_bgp_graceful_restart_restart_time_cmd,
"no bgp graceful-restart restart-time [(1-4095)]",
NO_STR
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the time to wait to delete stale routes before a BGP open message is received\n"
"Delay value (seconds)\n")
no_bgp_graceful_restart_restart_time_cmd,
"no bgp graceful-restart restart-time [(1-4095)]",
NO_STR
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Set the time to wait to delete stale routes before a BGP open message is received\n"
"Delay value (seconds)\n")
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2339,11 +2339,11 @@ DEFUN (no_bgp_graceful_restart_select_defer_time,
}
DEFUN (bgp_graceful_restart_preserve_fw,
bgp_graceful_restart_preserve_fw_cmd,
"bgp graceful-restart preserve-fw-state",
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
bgp_graceful_restart_preserve_fw_cmd,
"bgp graceful-restart preserve-fw-state",
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
bgp_flag_set(bgp, BGP_FLAG_GR_PRESERVE_FWD);
@ -2351,12 +2351,12 @@ DEFUN (bgp_graceful_restart_preserve_fw,
}
DEFUN (no_bgp_graceful_restart_preserve_fw,
no_bgp_graceful_restart_preserve_fw_cmd,
"no bgp graceful-restart preserve-fw-state",
NO_STR
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
no_bgp_graceful_restart_preserve_fw_cmd,
"no bgp graceful-restart preserve-fw-state",
NO_STR
"BGP specific commands\n"
"Graceful restart capability parameters\n"
"Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
bgp_flag_unset(bgp, BGP_FLAG_GR_PRESERVE_FWD);
@ -2364,16 +2364,16 @@ DEFUN (no_bgp_graceful_restart_preserve_fw,
}
DEFUN (bgp_graceful_restart_disable,
bgp_graceful_restart_disable_cmd,
"bgp graceful-restart-disable",
"BGP specific commands\n"
GR_DISABLE)
bgp_graceful_restart_disable_cmd,
"bgp graceful-restart-disable",
"BGP specific commands\n"
GR_DISABLE)
{
int ret = BGP_GR_FAILURE;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_graceful_restart_disable_cmd : START ");
"[BGP_GR] bgp_graceful_restart_disable_cmd : START ");
VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2384,7 +2384,7 @@ DEFUN (bgp_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_graceful_restart_disable_cmd : END ");
"[BGP_GR] bgp_graceful_restart_disable_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n");
@ -2392,18 +2392,18 @@ DEFUN (bgp_graceful_restart_disable,
}
DEFUN (no_bgp_graceful_restart_disable,
no_bgp_graceful_restart_disable_cmd,
"no bgp graceful-restart-disable",
NO_STR
"BGP specific commands\n"
NO_GR_DISABLE
no_bgp_graceful_restart_disable_cmd,
"no bgp graceful-restart-disable",
NO_STR
"BGP specific commands\n"
NO_GR_DISABLE
)
{
VTY_DECLVAR_CONTEXT(bgp, bgp);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_graceful_restart_disable_cmd : START ");
"[BGP_GR] no_bgp_graceful_restart_disable_cmd : START ");
int ret = BGP_GR_FAILURE;
@ -2414,7 +2414,7 @@ DEFUN (no_bgp_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_graceful_restart_disable_cmd : END ");
"[BGP_GR] no_bgp_graceful_restart_disable_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n");
@ -2422,11 +2422,11 @@ DEFUN (no_bgp_graceful_restart_disable,
}
DEFUN (bgp_neighbor_graceful_restart_set,
bgp_neighbor_graceful_restart_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_CMD
bgp_neighbor_graceful_restart_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_CMD
)
{
int idx_peer = 1;
@ -2437,7 +2437,7 @@ DEFUN (bgp_neighbor_graceful_restart_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_neighbor_graceful_restart_set_cmd : START ");
"[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : START ");
peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
if (!peer)
@ -2450,7 +2450,7 @@ DEFUN (bgp_neighbor_graceful_restart_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_neighbor_graceful_restart_set_cmd : END ");
"[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n");
@ -2458,12 +2458,12 @@ DEFUN (bgp_neighbor_graceful_restart_set,
}
DEFUN (no_bgp_neighbor_graceful_restart,
no_bgp_neighbor_graceful_restart_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_CMD
no_bgp_neighbor_graceful_restart_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_CMD
)
{
int idx_peer = 2;
@ -2478,7 +2478,7 @@ DEFUN (no_bgp_neighbor_graceful_restart,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_neighbor_graceful_restart_set_cmd : START ");
"[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : START ");
ret = bgp_neighbor_graceful_restart(peer, NO_PEER_GR_CMD);
@ -2487,7 +2487,7 @@ DEFUN (no_bgp_neighbor_graceful_restart,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_neighbor_graceful_restart_set_cmd : END ");
"[BGP_GR] no_bgp_neighbor_graceful_restart_set_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n");
@ -2495,11 +2495,11 @@ DEFUN (no_bgp_neighbor_graceful_restart,
}
DEFUN (bgp_neighbor_graceful_restart_helper_set,
bgp_neighbor_graceful_restart_helper_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_HELPER_CMD
bgp_neighbor_graceful_restart_helper_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_HELPER_CMD
)
{
int idx_peer = 1;
@ -2510,7 +2510,7 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_neighbor_graceful_restart_helper_set_cmd : START ");
"[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : START ");
peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
@ -2525,7 +2525,7 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_neighbor_graceful_restart_helper_set_cmd : END ");
"[BGP_GR] bgp_neighbor_graceful_restart_helper_set_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n");
@ -2533,12 +2533,12 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
}
DEFUN (no_bgp_neighbor_graceful_restart_helper,
no_bgp_neighbor_graceful_restart_helper_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_HELPER_CMD
no_bgp_neighbor_graceful_restart_helper_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_HELPER_CMD
)
{
int idx_peer = 2;
@ -2553,7 +2553,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
"[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : START ");
ret = bgp_neighbor_graceful_restart(peer,
NO_PEER_HELPER_CMD);
@ -2563,7 +2563,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_neighbor_graceful_restart_helper_set_cmd : END ");
"[BGP_GR] no_bgp_neighbor_graceful_restart_helper_set_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n");
@ -2571,11 +2571,11 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
}
DEFUN (bgp_neighbor_graceful_restart_disable_set,
bgp_neighbor_graceful_restart_disable_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_DISABLE_CMD
bgp_neighbor_graceful_restart_disable_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_DISABLE_CMD
)
{
int idx_peer = 1;
@ -2586,14 +2586,14 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: bgp_neighbor_graceful_restart_disable_set_cmd : START ");
"[BGP_GR] bgp_neighbor_graceful_restart_disable_set_cmd : START ");
peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
if (!peer)
return CMD_WARNING_CONFIG_FAILED;
ret = bgp_neighbor_graceful_restart(peer,
PEER_DISABLE_cmd);
PEER_DISABLE_CMD);
if (peer->bgp->t_startup)
bgp_peer_gr_flags_update(peer);
@ -2603,7 +2603,7 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR::bgp_neighbor_graceful_restart_disable_set_cmd : END ");
"[BGP_GR]bgp_neighbor_graceful_restart_disable_set_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n");
@ -2611,12 +2611,12 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
}
DEFUN (no_bgp_neighbor_graceful_restart_disable,
no_bgp_neighbor_graceful_restart_disable_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_DISABLE_CMD
no_bgp_neighbor_graceful_restart_disable_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
NO_STR
NEIGHBOR_STR
NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_DISABLE_CMD
)
{
int idx_peer = 2;
@ -2631,7 +2631,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_neighbor_graceful_restart_disable_set_cmd : START ");
"[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : START ");
ret = bgp_neighbor_graceful_restart(peer, NO_PEER_DISABLE_CMD);
@ -2640,7 +2640,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug(
"BGP_GR:: no_bgp_neighbor_graceful_restart_disable_set_cmd : END ");
"[BGP_GR] no_bgp_neighbor_graceful_restart_disable_set_cmd : END ");
vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n");
@ -9507,19 +9507,16 @@ static void bgp_show_neighbor_graceful_restart_remote_mode(
if ((peer->nsf_af_count == 0) &&
!CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
/*Gr disabled case*/
mode = "Disable";
} else if (peer->nsf_af_count == 0 &&
CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
/* Helper */
mode = "Helper";
} else if (peer->nsf_af_count != 0 &&
CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
/* Restart */
mode = "Restart";
}
@ -9548,7 +9545,7 @@ static void bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
mode = "Restart";
else if (bgp_peer_gr_mode_get(p) == PEER_DISABLE)
mode = "Disable";
else if (bgp_peer_gr_mode_get(p) == PEER_GLOBAL_INHERIT)
else if (bgp_peer_gr_mode_get(p) == PEER_GLOBAL_INHERIT) {
if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_HELPER)
mode = "Helper*";
else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_GR)
@ -9557,8 +9554,7 @@ static void bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
mode = "Disable*";
else
mode = "Invalid*";
else
mode = "Invalid";
}
if (use_json) {
json_object_string_add(json,
@ -9572,8 +9568,8 @@ static void bgp_show_neighbor_graceful_restart_capability_per_afi_safi(
struct vty *vty, struct peer *peer,
bool use_json, json_object *json)
{
afi_t afi = AFI_MAX;
safi_t safi = SAFI_MAX;
afi_t afi;
safi_t safi;
json_object *json_afi_safi = NULL;
json_object *json_timer = NULL;
json_object *json_endofrib_status = NULL;
@ -9809,7 +9805,7 @@ static void bgp_show_neighbor_graceful_restart_time(struct vty *vty,
p->bgp->restart_time);
json_object_int_add(json_timer,
"recivedRestartTimer",
"receivedRestartTimer",
p->v_gr_restart);
if (p->t_gr_restart != NULL) {
@ -9848,7 +9844,6 @@ static void bgp_show_peer_gr_status(struct vty *vty, struct peer *p,
char dn_flag[2] = {0};
char neighborAddr[INET6_ADDRSTRLEN] = {0};
memset(dn_flag, '\0', sizeof(dn_flag));
if (!p->conf_if && peer_dynamic_neighbor(p))
dn_flag[0] = '*';
@ -12197,7 +12192,7 @@ static int bgp_show_neighbor_graceful_restart(struct vty *vty,
if (use_json)
json_neighbor = json_object_new_object();
if (show_all == type) {
if (type == show_all) {
bgp_show_peer_gr_status(vty, peer, use_json,
json_neighbor);
@ -12205,7 +12200,7 @@ static int bgp_show_neighbor_graceful_restart(struct vty *vty,
json_object_object_add(json,
peer->host, json_neighbor);
} else if (show_peer == type) {
} else if (type == show_peer) {
if (conf_if) {
if ((peer->conf_if
&& !strcmp(peer->conf_if, conf_if))
@ -12554,7 +12549,6 @@ DEFUN (show_ip_bgp_neighbors_gracrful_restart,
enum show_type sh_type;
int idx = 0;
afi_t afi = AFI_MAX;
bool uj = use_json(argc, argv);
if (!argv_find_and_parse_afi(argv, argc, &idx, &afi))
@ -12734,23 +12728,23 @@ static void bgp_show_global_graceful_restart_mode_vty(struct vty *vty,
case GLOBAL_HELPER:
vty_out(vty,
"Global Bgp GR Mode : Helper\n");
"Global BGP GR Mode : Helper\n");
break;
case GLOBAL_GR:
vty_out(vty,
"Global Bgp GR Mode : Restart\n");
"Global BGP GR Mode : Restart\n");
break;
case GLOBAL_DISABLE:
vty_out(vty,
"Global Bgp GR Mode : Disable\n");
"Global BGP GR Mode : Disable\n");
break;
case GLOBAL_INVALID:
default:
vty_out(vty,
"Global Bgp GR Mode Invalid\n");
"Global BGP GR Mode Invalid\n");
break;
}
vty_out(vty, "\n");

11
bgpd/bgp_zebra.c
View File

@ -3052,8 +3052,7 @@ int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable)
if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES,
zclient, &api) < 0) {
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("error sending capability");
zlog_err("error sending capability");
ret = BGP_GR_FAILURE;
} else {
if (disable)
@ -3073,11 +3072,11 @@ int bgp_zebra_send_capabilities(struct bgp *bgp, bool disable)
*/
int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type)
{
struct zapi_cap api;
struct zapi_cap api = {0};
if (zclient == NULL) {
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("zclient invalid");
zlog_debug("zclient == NULL, invalid");
return BGP_GR_FAILURE;
}
@ -3088,7 +3087,6 @@ int bgp_zebra_update(afi_t afi, safi_t safi, vrf_id_t vrf_id, int type)
return BGP_GR_FAILURE;
}
memset(&api, 0, sizeof(struct zapi_cap));
api.afi = afi;
api.safi = safi;
api.vrf_id = vrf_id;
@ -3141,9 +3139,6 @@ int zclient_capabilities_send(uint32_t cmd, struct zclient *zclient,
return zclient_send_message(zclient);
}
/* Send RIB stale timer update */
int bgp_zebra_stale_timer_update(struct bgp *bgp)
{

1
bgpd/bgp_zebra.h
View File

@ -85,7 +85,6 @@ struct bgp_pbr_match;
struct bgp_pbr_rule;
struct bgp_pbr_match_entry;
extern void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra,
struct bgp_pbr_rule *pbr,
bool install);

21
bgpd/bgpd.c
View File

@ -1109,7 +1109,7 @@ int bgp_global_gr_init(struct bgp *bgp)
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("%s called ..", __func__);
int local_GLOBAL_GR_FSM[GLOBAL_MODE][EVENT_CMD] = {
int local_GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE][BGP_GLOBAL_GR_EVENT_CMD] = {
/* GLOBAL_HELPER Mode */
{
/*Event -> */
@ -1157,12 +1157,13 @@ int bgp_peer_gr_init(struct peer *peer)
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("%s called ..", __func__);
struct bgp_peer_gr local_Peer_GR_FSM[PEER_MODE][PEER_EVENT_CMD] = {
struct bgp_peer_gr local_Peer_GR_FSM[BGP_PEER_GR_MODE]
[BGP_PEER_GR_EVENT_CMD] = {
{
/* PEER_HELPER Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_GR, bgp_peer_gr_action }, {PEER_INVALID, NULL },
/* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
/* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
{PEER_DISABLE, bgp_peer_gr_action }, {PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_INVALID, NULL }, {PEER_GLOBAL_INHERIT,
@ -1173,7 +1174,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
bgp_peer_gr_action },
/* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
/* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
{PEER_DISABLE, bgp_peer_gr_action }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
@ -1182,7 +1183,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* PEER_DISABLE Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
/* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
{ PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
bgp_peer_gr_action },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
@ -1192,7 +1193,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* PEER_INVALID Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_INVALID, NULL }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
/* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
{ PEER_INVALID, NULL }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_INVALID, NULL }, { PEER_INVALID, NULL },
@ -1201,7 +1202,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* PEER_GLOBAL_INHERIT Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_DISABLE_cmd */ /* NO_PEER_DISABLE_CMD */
/* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
{ PEER_DISABLE, bgp_peer_gr_action}, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
@ -7253,7 +7254,7 @@ void bgp_gr_apply_running_config(void)
bool gr_router_detected = false;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: %s called !",
zlog_debug("[BGP_GR] %s called !",
__func__);
for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
@ -7266,10 +7267,10 @@ void bgp_gr_apply_running_config(void)
if (gr_router_detected &&
bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
bgp_zebra_send_capabilities(bgp, false);
bgp_zebra_send_capabilities(bgp, true);
} else if (!gr_router_detected &&
bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
bgp_zebra_send_capabilities(bgp, true);
bgp_zebra_send_capabilities(bgp, false);
}
gr_router_detected = false;

21
bgpd/bgpd.h
View File

@ -246,8 +246,8 @@ enum bgp_instance_type {
/* BGP GR Global ds */
#define GLOBAL_MODE 4
#define EVENT_CMD 4
#define BGP_GLOBAL_GR_MODE 4
#define BGP_GLOBAL_GR_EVENT_CMD 4
/* Graceful restart selection deferral timer info */
struct graceful_restart_info {
@ -425,7 +425,8 @@ struct bgp {
#define BGP_FLAG_SELECT_DEFER_DISABLE (1 << 23)
#define BGP_FLAG_GR_DISABLE_EOR (1 << 24)
enum global_mode GLOBAL_GR_FSM[GLOBAL_MODE][EVENT_CMD];
enum global_mode GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE]
[BGP_GLOBAL_GR_EVENT_CMD];
enum global_mode global_gr_present_state;
/* This variable stores the current Graceful Restart state of Zebra
@ -618,12 +619,6 @@ struct bgp {
#define BGP_VRF_RD_CFGD (1 << 3)
#define BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY (1 << 4)
#define BGP_SEND_EOR(bgp, afi, safi) \
(!bgp_flag_check(bgp, BGP_FLAG_GR_DISABLE_EOR) && \
((bgp->gr_info[afi][safi].t_select_deferral == NULL) || \
(bgp->gr_info[afi][safi].eor_required == \
bgp->gr_info[afi][safi].eor_received)))
/* unique ID for auto derivation of RD for this vrf */
uint16_t vrf_rd_id;
@ -813,8 +808,8 @@ struct peer_af {
};
/* BGP GR per peer ds */
#define PEER_MODE 5
#define PEER_EVENT_CMD 6
#define BGP_PEER_GR_MODE 5
#define BGP_PEER_GR_EVENT_CMD 6
enum peer_mode {
PEER_HELPER = 0,
@ -828,7 +823,7 @@ enum peer_mode {
enum peer_gr_command {
PEER_GR_CMD = 0,
NO_PEER_GR_CMD,
PEER_DISABLE_cmd,
PEER_DISABLE_CMD,
NO_PEER_DISABLE_CMD,
PEER_HELPER_CMD,
NO_PEER_HELPER_CMD
@ -1073,7 +1068,7 @@ struct peer {
*and PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT
*/
struct bgp_peer_gr PEER_GR_FSM[PEER_MODE][PEER_EVENT_CMD];
struct bgp_peer_gr PEER_GR_FSM[BGP_PEER_GR_MODE][BGP_PEER_GR_EVENT_CMD];
enum peer_mode peer_gr_present_state;
/* Non stop forwarding afi-safi count for BGP gr feature*/
uint8_t nsf_af_count;

2
doc/user/bgp.rst
View File

@ -827,7 +827,7 @@ Default global mode is helper and default peer per mode is inherit from global.
If per peer mode is configured, the GR mode of this particular peer will
override the global mode.
.. _bgp-GR-globla-mode-cmd:
.. _bgp-GR-global-mode-cmd:
BGP GR Global Mode Commands
^^^^^^^^^^^^^^^^^^^^^^^^^^^

1
lib/zclient.c
View File

@ -3324,6 +3324,7 @@ int zapi_capabilities_decode(struct stream *s, struct zapi_cap *api)
default:
break;
}
stream_failure:
return 0;
}