proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-06-14 11:32:30 +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; safi_t safi;
char orf_name[BUFSIZ]; char orf_name[BUFSIZ];
int ret = 0; int ret = 0;
peer->nsf_af_count = 0;
struct bgp *bgp = peer->bgp; struct bgp *bgp = peer->bgp;
struct graceful_restart_info *gr_info = NULL; struct graceful_restart_info *gr_info = NULL;
peer->nsf_af_count = 0;
if (peer_dynamic_neighbor(peer) if (peer_dynamic_neighbor(peer)
&& !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) { && !(CHECK_FLAG(peer->flags, PEER_FLAG_DELETE))) {
if (bgp_debug_neighbor_events(peer)) if (bgp_debug_neighbor_events(peer))
@ -1208,7 +1209,7 @@ int bgp_stop(struct peer *peer)
if (gr_info && BGP_DEBUG(update, if (gr_info && BGP_DEBUG(update,
UPDATE_OUT)) UPDATE_OUT))
zlog_debug( zlog_debug(
"peer %s, EOR %d", "peer %s, EOR_required %d",
peer->host, peer->host,
gr_info->eor_required); 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); 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, status = bgp_update_gr_info(peer, afi,
safi); safi);
if (status < 0) if (status < 0)
zlog_debug("Error in updating graceful restart for %s", zlog_err("Error in updating graceful restart for %s",
get_afi_safi_str(afi, get_afi_safi_str(afi,
safi, false)); safi, false));
} else { } else {
if (BGP_PEER_GRACEFUL_RESTART_CAPABLE( 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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: %s Peer: (%s) :", "%s [BGP_GR] Peer: (%s) :",
__func__, peer->host); __func__, peer->host);
peer_old_state = bgp_peer_gr_mode_get(peer); 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) { switch (global_new_state) {
case GLOBAL_HELPER: case GLOBAL_HELPER:
BGP_PEER_GR_HELPER_ENABLE(peer); BGP_PEER_GR_HELPER_ENABLE(peer);
break; break;
case GLOBAL_GR: case GLOBAL_GR:
BGP_PEER_GR_ENABLE(peer); BGP_PEER_GR_ENABLE(peer);
break; break;
case GLOBAL_DISABLE: case GLOBAL_DISABLE:
BGP_PEER_GR_DISABLE(peer); BGP_PEER_GR_DISABLE(peer);
break; break;
case GLOBAL_INVALID: case GLOBAL_INVALID:
zlog_debug( zlog_debug(
"BGP_GR:: %s :GLOBAL_INVALID", "%s [BGP_GR]GLOBAL_INVALID",
__func__); __func__);
return BGP_ERR_GR_OPERATION_FAILED; return BGP_ERR_GR_OPERATION_FAILED;
default: default:
zlog_debug( zlog_debug(
"BGP_GR:: %s :Global unknown ERROR", "%s [BGP_GR]Global unknown ERROR",
__func__); __func__);
return BGP_ERR_GR_OPERATION_FAILED; 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; bgp->global_gr_present_state = global_new_state;
/* debug Trace msg */
return BGP_GR_SUCCESS; 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_new_state = GLOBAL_INVALID;
enum global_mode global_old_state = GLOBAL_INVALID; enum global_mode global_old_state = GLOBAL_INVALID;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR::%s:START: global_GR_Cmd :%d:", "%s [BGP_GR]START: global_gr_cmd :%s:",
__func__, global_GR_Cmd); __func__, print_global_gr_cmd(global_gr_cmd));
global_old_state = bgp_global_gr_mode_get(bgp); 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 = 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 { } else {
/* Trace msg */ zlog_err(
zlog_debug("BGP_GR::%s:global_old_state == GLOBAL_INVALID", "%s [BGP_GR] global_old_state == GLOBAL_INVALID",
__func__); __func__);
return BGP_ERR_GR_OPERATION_FAILED; return BGP_ERR_GR_OPERATION_FAILED;
} }
if (global_new_state == GLOBAL_INVALID) { if (global_new_state == GLOBAL_INVALID) {
/* Trace msg */ zlog_err(
zlog_debug( "%s [BGP_GR] global_new_state == GLOBAL_INVALID",
"BGP_GR::%s: global_new_state == GLOBAL_INVALID",
__func__); __func__);
return BGP_ERR_GR_INVALID_CMD; return BGP_ERR_GR_INVALID_CMD;
} }
if (global_new_state == global_old_state) { if (global_new_state == global_old_state) {
/* Trace msg */ /* Trace msg */
zlog_debug( if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
"BGP_GR::%s : global_new_state == global_old_state", zlog_debug(
__func__); "%s [BGP_GR] global_new_state == global_old_state :%s",
__func__, print_global_gr_mode(global_new_state));
return BGP_GR_NO_OPERATION; return BGP_GR_NO_OPERATION;
} }
@ -2371,6 +2374,103 @@ int bgp_gr_update_all(struct bgp *bgp, int global_GR_Cmd)
global_old_state); 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) enum global_mode bgp_global_gr_mode_get(struct bgp *bgp)
{ {
return bgp->global_gr_present_state; 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 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_new_state = PEER_INVALID;
enum peer_mode peer_old_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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: %s:START--->Peer: (%s) : peer_GR_Cmd :%d:", "%s [BGP_GR] START:Peer: (%s) : peer_gr_cmd :%s:",
__func__, peer->host, peer_GR_Cmd); __func__, peer->host, print_peer_gr_cmd(peer_gr_cmd));
peer_old_state = bgp_peer_gr_mode_get(peer); peer_old_state = bgp_peer_gr_mode_get(peer);
if (peer_old_state == PEER_INVALID) { if (peer_old_state == PEER_INVALID) {
/* debug Trace msg */
zlog_debug( zlog_debug(
"BGP_GR:: peer_old_state ==Invalid state !"); "[BGP_GR] peer_old_state == Invalid state !");
return BGP_ERR_GR_OPERATION_FAILED; 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; peer_new_state = peer_state.next_state;
if (peer_new_state == PEER_INVALID) { if (peer_new_state == PEER_INVALID) {
/* debug Trace msg */
zlog_debug( zlog_debug(
"BGP_GR:: Invalid bgp graceful restart command used !"); "[BGP_GR] Invalid bgp graceful restart command used !");
return BGP_ERR_GR_INVALID_CMD; return BGP_ERR_GR_INVALID_CMD;
} }
@ -2424,9 +2522,9 @@ int bgp_neighbor_graceful_restart(struct peer *peer,
peer_old_state, peer_old_state,
peer_new_state); peer_new_state);
} else { } else {
/* debug Trace msg */ if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: peer_old_state == peer_new_state !"); "[BGP_GR] peer_old_state == peer_new_state !");
return BGP_GR_NO_OPERATION; 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 */ /* Update the mode i.e peer_new_state into the peer structure */
peer->peer_gr_present_state = peer_new_state; peer->peer_gr_present_state = peer_new_state;
/* debug Trace msg */
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Succesfully change the state of the peer to : %d : !", zlog_debug("[BGP_GR] Succesfully change the state of the peer to : %s : !",
peer_new_state); print_peer_gr_mode(peer_new_state));
return BGP_GR_SUCCESS; return BGP_GR_SUCCESS;
} }
@ -2450,15 +2547,15 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
{ {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: %s : Move peer from old_peer_state :%d: to old_peer_state :%d: !!!!", "%s [BGP_GR] Move peer from old_peer_state :%s: to new_peer_state :%s: !!!!",
__func__, old_peer_state, new_peer_state); __func__, print_peer_gr_mode(old_peer_state),
print_peer_gr_mode(new_peer_state));
int bgp_gr_global_mode = GLOBAL_INVALID; int bgp_gr_global_mode = GLOBAL_INVALID;
unsigned int ret = BGP_GR_FAILURE; unsigned int ret = BGP_GR_FAILURE;
if (old_peer_state == new_peer_state) { if (old_peer_state == new_peer_state) {
/* Nothing to do over here as the present and old state is the same */ /* Nothing to do over here as the present and old state is the same */
/* debug Trace msg */
return BGP_GR_NO_OPERATION; return BGP_GR_NO_OPERATION;
} }
if ((old_peer_state == PEER_INVALID) || if ((old_peer_state == PEER_INVALID) ||
@ -2490,13 +2587,12 @@ unsigned int bgp_peer_gr_action(struct peer *peer,
*of the existing session *of the existing session
*as the peer is already working in the same mode. *as the peer is already working in the same mode.
*/ */
/* debug Trace msg */
ret = BGP_GR_SUCCESS; ret = BGP_GR_SUCCESS;
} else { } else {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: Peer state changed from :%d =>", "[BGP_GR] Peer state changed from :%s ",
old_peer_state); print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, new_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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Peer state changed from :%d ==>", zlog_debug("[BGP_GR] Peer state changed from :%s",
old_peer_state); print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, bgp_gr_global_mode); 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 ) *( old_peer_state != Peer_Global )
*/ */
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: Peer state changed from :%d ===>", zlog_debug("[BGP_GR] Peer state changed from :%s",
old_peer_state); print_peer_gr_mode(old_peer_state));
bgp_peer_move_to_gr_mode(peer, new_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); int bgp_global_gr_mode = bgp_global_gr_mode_get(peer->bgp);
switch (new_state) { switch (new_state) {
case PEER_HELPER: case PEER_HELPER:
BGP_PEER_GR_HELPER_ENABLE(peer); BGP_PEER_GR_HELPER_ENABLE(peer);
break; break;
case PEER_GR: case PEER_GR:
BGP_PEER_GR_ENABLE(peer); BGP_PEER_GR_ENABLE(peer);
break; break;
case PEER_DISABLE: case PEER_DISABLE:
BGP_PEER_GR_DISABLE(peer); BGP_PEER_GR_DISABLE(peer);
break; break;
case PEER_GLOBAL_INHERIT: case PEER_GLOBAL_INHERIT:
BGP_PEER_GR_GLOBAL_INHERIT_SET(peer); 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) { } else if (bgp_global_gr_mode == GLOBAL_DISABLE) {
BGP_PEER_GR_DISABLE(peer); BGP_PEER_GR_DISABLE(peer);
} else { } else {
zlog_debug( zlog_err(
"BGP_GR:: Default switch inherit mode ::: SOMETHING IS WRONG !!!"); "[BGP_GR] Default switch inherit mode ::: SOMETHING IS WRONG !!!");
} }
break; break;
default: default:
zlog_debug("BGP_GR:: Default switch mode ::: SOMETHING IS WRONG !!!"); zlog_err("[BGP_GR] Default switch mode ::: SOMETHING IS WRONG !!!");
break; break;
} }
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) 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); new_state);
} }
@ -2602,7 +2694,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
{ {
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: %s called !", "%s [BGP_GR] called !",
__func__); __func__);
if (CHECK_FLAG(peer->peer_gr_new_status_flag, if (CHECK_FLAG(peer->peer_gr_new_status_flag,
PEER_GRACEFUL_RESTART_NEW_STATE_HELPER)) PEER_GRACEFUL_RESTART_NEW_STATE_HELPER))
@ -2613,7 +2705,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
PEER_FLAG_GRACEFUL_RESTART_HELPER); PEER_FLAG_GRACEFUL_RESTART_HELPER);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, peer->host,
(CHECK_FLAG(peer->flags, (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART_HELPER) ? PEER_FLAG_GRACEFUL_RESTART_HELPER) ?
@ -2627,7 +2719,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
PEER_FLAG_GRACEFUL_RESTART); PEER_FLAG_GRACEFUL_RESTART);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !", "[BGP_GR] Peer %s Flag PEER_FLAG_GRACEFUL_RESTART : %s : !",
peer->host, peer->host,
(CHECK_FLAG(peer->flags, (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART) ? PEER_FLAG_GRACEFUL_RESTART) ?
@ -2641,7 +2733,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT); PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, peer->host,
(CHECK_FLAG(peer->flags, (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT) ? PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT) ?
@ -2652,7 +2744,7 @@ void bgp_peer_gr_flags_update(struct peer *peer)
!CHECK_FLAG(peer->flags, !CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART_HELPER)){ PEER_FLAG_GRACEFUL_RESTART_HELPER)){
zlog_debug( zlog_debug(
"BGP_GR:: Peer %s UNSET PEER_STATUS_NSF_MODE!", "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_MODE!",
peer->host); peer->host);
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE); 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); peer_nsf_stop(peer);
zlog_debug( zlog_debug(
"BGP_GR:: Peer %s UNSET PEER_STATUS_NSF_WAIT!", "[BGP_GR] Peer %s UNSET PEER_STATUS_NSF_WAIT!",
peer->host); 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_backward_transition, (struct peer *peer), (peer))
DECLARE_HOOK(peer_established, (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 bgp_neighbor_graceful_restart(struct peer *peer,
int peer_GR_Cmd); int peer_gr_cmd);
unsigned int bgp_peer_gr_action(struct peer *peer, unsigned int bgp_peer_gr_action(struct peer *peer,
int old_peer_state, int new_peer_state); int old_peer_state, int new_peer_state);
void bgp_peer_move_to_gr_mode(struct peer *peer, int new_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_new_state,
enum global_mode global_old_state); enum global_mode global_old_state);
void bgp_peer_gr_flags_update(struct peer *peer); 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 */ #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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: Sending helper Capability for Peer :%s :", "[BGP_GR] Sending helper Capability for Peer :%s :",
peer->host); peer->host);
SET_FLAG(peer->cap, PEER_CAP_RESTART_ADV); 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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: Sending R-Bit for Peer :%s :", "[BGP_GR] Sending R-Bit for Peer :%s :",
peer->host); peer->host);
} }
@ -1360,7 +1360,7 @@ static void bgp_peer_send_gr_capability(struct stream *s, struct peer *peer,
if (BGP_DEBUG(graceful_restart, if (BGP_DEBUG(graceful_restart,
GRACEFUL_RESTART)) GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: Sending GR Capability for AFI :%d :, SAFI :%d:", "[BGP_GR] Sending GR Capability for AFI :%d :, SAFI :%d:",
afi, safi); afi, safi);
/* Convert AFI, SAFI to values for /* 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]); data[i]);
strlcat(bgp_notify.data, c, strlcat(bgp_notify.data, c,
bgp_notify.length * 3); bgp_notify.length);
} else { } else {
first = 1; first = 1;
snprintf(c, sizeof(c), "%02x", data[i]); snprintf(c, sizeof(c), "%02x", data[i]);
strlcpy(bgp_notify.data, c, 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 /* If the flag BGP_NODE_SELECT_DEFER is set and new path is added
* then the route selection is deferred * 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; return 0;
if (CHECK_FLAG(rn->flags, BGP_NODE_PROCESS_SCHEDULED)) { 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 /* Set the flag BGP_NODE_SELECT_DEFER if route selection deferral timer
* is active * is active
*/ */
if (set_flag) { if (set_flag && table) {
if (bgp && (bgp->gr_info[afi][safi].t_select_deferral)) { if (bgp && (bgp->gr_info[afi][safi].t_select_deferral)) {
SET_FLAG(rn->flags, BGP_NODE_SELECT_DEFER); SET_FLAG(rn->flags, BGP_NODE_SELECT_DEFER);
prefix2str(&rn->p, buf, PREFIX2STR_BUFFER); 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 (CHECK_FLAG(rn->flags, BGP_NODE_SELECT_DEFER)) {
if (BGP_DEBUG(update, UPDATE_OUT)) 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; return;
} }

4
bgpd/bgp_table.c
View File

@ -146,7 +146,9 @@ void bgp_delete_listnode(struct bgp_node *node)
bgp = table->bgp; bgp = table->bgp;
afi = table->afi; afi = table->afi;
safi = table->safi; safi = table->safi;
} } else
return;
rn = bgp_node_to_rnode(node); rn = bgp_node_to_rnode(node);
if (bgp && rn && rn->lock == 1) { 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), (struct bgp *bgp, struct vty *vty),
(bgp, 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." #define GR_INVALID "The Graceful Restart command used is not valid at this moment."
static struct peer_group *listen_range_exists(struct bgp *bgp, static struct peer_group *listen_range_exists(struct bgp *bgp,
struct prefix *range, int exact); 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, if (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART)) PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = TRUE; gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode, stype); 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, if (CHECK_FLAG(peer->flags,
PEER_FLAG_GRACEFUL_RESTART)) PEER_FLAG_GRACEFUL_RESTART))
gr_router_detected = TRUE; gr_router_detected = true;
ret = bgp_peer_clear(peer, afi, safi, nnode, stype); ret = bgp_peer_clear(peer, afi, safi, nnode, stype);
@ -2182,16 +2182,16 @@ DEFUN (no_bgp_deterministic_med,
/* "bgp graceful-restart mode" configuration. */ /* "bgp graceful-restart mode" configuration. */
DEFUN (bgp_graceful_restart, DEFUN (bgp_graceful_restart,
bgp_graceful_restart_cmd, bgp_graceful_restart_cmd,
"bgp graceful-restart", "bgp graceful-restart",
"BGP specific commands\n" "BGP specific commands\n"
GR_CMD GR_CMD
) )
{ {
int ret = BGP_GR_FAILURE; int ret = BGP_GR_FAILURE;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) 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); VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2201,24 +2201,24 @@ DEFUN (bgp_graceful_restart,
bgp->peer, ret); bgp->peer, ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) 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, vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n"); "Graceful restart configuration changed, reset all peers to take effect\n");
return bgp_vty_return(vty, ret); return bgp_vty_return(vty, ret);
} }
DEFUN (no_bgp_graceful_restart, DEFUN (no_bgp_graceful_restart,
no_bgp_graceful_restart_cmd, no_bgp_graceful_restart_cmd,
"no bgp graceful-restart", "no bgp graceful-restart",
NO_STR NO_STR
"BGP specific commands\n" "BGP specific commands\n"
NO_GR_CMD NO_GR_CMD
) )
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) 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; int ret = BGP_GR_FAILURE;
@ -2228,7 +2228,7 @@ DEFUN (no_bgp_graceful_restart,
bgp->peer, ret); bgp->peer, ret);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) 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, vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n"); "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, DEFUN (bgp_graceful_restart_stalepath_time,
bgp_graceful_restart_stalepath_time_cmd, bgp_graceful_restart_stalepath_time_cmd,
"bgp graceful-restart stalepath-time (1-4095)", "bgp graceful-restart stalepath-time (1-4095)",
"BGP specific commands\n" "BGP specific commands\n"
"Graceful restart capability parameters\n" "Graceful restart capability parameters\n"
"Set the max time to hold onto restarting peer's stale paths\n" "Set the max time to hold onto restarting peer's stale paths\n"
"Delay value (seconds)\n") "Delay value (seconds)\n")
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3; int idx_number = 3;
@ -2253,12 +2253,12 @@ DEFUN (bgp_graceful_restart_stalepath_time,
} }
DEFUN (bgp_graceful_restart_restart_time, DEFUN (bgp_graceful_restart_restart_time,
bgp_graceful_restart_restart_time_cmd, bgp_graceful_restart_restart_time_cmd,
"bgp graceful-restart restart-time (1-4095)", "bgp graceful-restart restart-time (1-4095)",
"BGP specific commands\n" "BGP specific commands\n"
"Graceful restart capability parameters\n" "Graceful restart capability parameters\n"
"Set the time to wait to delete stale routes before a BGP open message is received\n" "Set the time to wait to delete stale routes before a BGP open message is received\n"
"Delay value (seconds)\n") "Delay value (seconds)\n")
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
int idx_number = 3; int idx_number = 3;
@ -2292,13 +2292,13 @@ DEFUN (bgp_graceful_restart_select_defer_time,
} }
DEFUN (no_bgp_graceful_restart_stalepath_time, DEFUN (no_bgp_graceful_restart_stalepath_time,
no_bgp_graceful_restart_stalepath_time_cmd, no_bgp_graceful_restart_stalepath_time_cmd,
"no bgp graceful-restart stalepath-time [(1-4095)]", "no bgp graceful-restart stalepath-time [(1-4095)]",
NO_STR NO_STR
"BGP specific commands\n" "BGP specific commands\n"
"Graceful restart capability parameters\n" "Graceful restart capability parameters\n"
"Set the max time to hold onto restarting peer's stale paths\n" "Set the max time to hold onto restarting peer's stale paths\n"
"Delay value (seconds)\n") "Delay value (seconds)\n")
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2307,13 +2307,13 @@ DEFUN (no_bgp_graceful_restart_stalepath_time,
} }
DEFUN (no_bgp_graceful_restart_restart_time, DEFUN (no_bgp_graceful_restart_restart_time,
no_bgp_graceful_restart_restart_time_cmd, no_bgp_graceful_restart_restart_time_cmd,
"no bgp graceful-restart restart-time [(1-4095)]", "no bgp graceful-restart restart-time [(1-4095)]",
NO_STR NO_STR
"BGP specific commands\n" "BGP specific commands\n"
"Graceful restart capability parameters\n" "Graceful restart capability parameters\n"
"Set the time to wait to delete stale routes before a BGP open message is received\n" "Set the time to wait to delete stale routes before a BGP open message is received\n"
"Delay value (seconds)\n") "Delay value (seconds)\n")
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2339,11 +2339,11 @@ DEFUN (no_bgp_graceful_restart_select_defer_time,
} }
DEFUN (bgp_graceful_restart_preserve_fw, DEFUN (bgp_graceful_restart_preserve_fw,
bgp_graceful_restart_preserve_fw_cmd, bgp_graceful_restart_preserve_fw_cmd,
"bgp graceful-restart preserve-fw-state", "bgp graceful-restart preserve-fw-state",
"BGP specific commands\n" "BGP specific commands\n"
"Graceful restart capability parameters\n" "Graceful restart capability parameters\n"
"Sets F-bit indication that fib is preserved while doing Graceful Restart\n") "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
bgp_flag_set(bgp, BGP_FLAG_GR_PRESERVE_FWD); 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, DEFUN (no_bgp_graceful_restart_preserve_fw,
no_bgp_graceful_restart_preserve_fw_cmd, no_bgp_graceful_restart_preserve_fw_cmd,
"no bgp graceful-restart preserve-fw-state", "no bgp graceful-restart preserve-fw-state",
NO_STR NO_STR
"BGP specific commands\n" "BGP specific commands\n"
"Graceful restart capability parameters\n" "Graceful restart capability parameters\n"
"Unsets F-bit indication that fib is preserved while doing Graceful Restart\n") "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
bgp_flag_unset(bgp, BGP_FLAG_GR_PRESERVE_FWD); 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, DEFUN (bgp_graceful_restart_disable,
bgp_graceful_restart_disable_cmd, bgp_graceful_restart_disable_cmd,
"bgp graceful-restart-disable", "bgp graceful-restart-disable",
"BGP specific commands\n" "BGP specific commands\n"
GR_DISABLE) GR_DISABLE)
{ {
int ret = BGP_GR_FAILURE; int ret = BGP_GR_FAILURE;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: bgp_graceful_restart_disable_cmd : START "); "[BGP_GR] bgp_graceful_restart_disable_cmd : START ");
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
@ -2384,7 +2384,7 @@ DEFUN (bgp_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: bgp_graceful_restart_disable_cmd : END "); "[BGP_GR] bgp_graceful_restart_disable_cmd : END ");
vty_out(vty, vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n"); "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, DEFUN (no_bgp_graceful_restart_disable,
no_bgp_graceful_restart_disable_cmd, no_bgp_graceful_restart_disable_cmd,
"no bgp graceful-restart-disable", "no bgp graceful-restart-disable",
NO_STR NO_STR
"BGP specific commands\n" "BGP specific commands\n"
NO_GR_DISABLE NO_GR_DISABLE
) )
{ {
VTY_DECLVAR_CONTEXT(bgp, bgp); VTY_DECLVAR_CONTEXT(bgp, bgp);
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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; int ret = BGP_GR_FAILURE;
@ -2414,7 +2414,7 @@ DEFUN (no_bgp_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: no_bgp_graceful_restart_disable_cmd : END "); "[BGP_GR] no_bgp_graceful_restart_disable_cmd : END ");
vty_out(vty, vty_out(vty,
"Graceful restart configuration changed, reset all peers to take effect\n"); "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, DEFUN (bgp_neighbor_graceful_restart_set,
bgp_neighbor_graceful_restart_set_cmd, bgp_neighbor_graceful_restart_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart", "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
NEIGHBOR_STR NEIGHBOR_STR
NEIGHBOR_ADDR_STR2 NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_CMD GR_NEIGHBOR_CMD
) )
{ {
int idx_peer = 1; int idx_peer = 1;
@ -2437,7 +2437,7 @@ DEFUN (bgp_neighbor_graceful_restart_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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); peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
if (!peer) if (!peer)
@ -2450,7 +2450,7 @@ DEFUN (bgp_neighbor_graceful_restart_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( zlog_debug(
"BGP_GR:: bgp_neighbor_graceful_restart_set_cmd : END "); "[BGP_GR] bgp_neighbor_graceful_restart_set_cmd : END ");
vty_out(vty, vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n"); "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, DEFUN (no_bgp_neighbor_graceful_restart,
no_bgp_neighbor_graceful_restart_set_cmd, no_bgp_neighbor_graceful_restart_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart", "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart",
NO_STR NO_STR
NEIGHBOR_STR NEIGHBOR_STR
NEIGHBOR_ADDR_STR2 NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_CMD NO_GR_NEIGHBOR_CMD
) )
{ {
int idx_peer = 2; int idx_peer = 2;
@ -2478,7 +2478,7 @@ DEFUN (no_bgp_neighbor_graceful_restart,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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); 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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n"); "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, DEFUN (bgp_neighbor_graceful_restart_helper_set,
bgp_neighbor_graceful_restart_helper_set_cmd, bgp_neighbor_graceful_restart_helper_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper", "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
NEIGHBOR_STR NEIGHBOR_STR
NEIGHBOR_ADDR_STR2 NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_HELPER_CMD GR_NEIGHBOR_HELPER_CMD
) )
{ {
int idx_peer = 1; int idx_peer = 1;
@ -2510,7 +2510,7 @@ DEFUN (bgp_neighbor_graceful_restart_helper_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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); 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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n"); "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, DEFUN (no_bgp_neighbor_graceful_restart_helper,
no_bgp_neighbor_graceful_restart_helper_set_cmd, no_bgp_neighbor_graceful_restart_helper_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper", "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-helper",
NO_STR NO_STR
NEIGHBOR_STR NEIGHBOR_STR
NEIGHBOR_ADDR_STR2 NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_HELPER_CMD NO_GR_NEIGHBOR_HELPER_CMD
) )
{ {
int idx_peer = 2; int idx_peer = 2;
@ -2553,7 +2553,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, ret = bgp_neighbor_graceful_restart(peer,
NO_PEER_HELPER_CMD); NO_PEER_HELPER_CMD);
@ -2563,7 +2563,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_helper,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n"); "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, DEFUN (bgp_neighbor_graceful_restart_disable_set,
bgp_neighbor_graceful_restart_disable_set_cmd, bgp_neighbor_graceful_restart_disable_set_cmd,
"neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable", "neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
NEIGHBOR_STR NEIGHBOR_STR
NEIGHBOR_ADDR_STR2 NEIGHBOR_ADDR_STR2
GR_NEIGHBOR_DISABLE_CMD GR_NEIGHBOR_DISABLE_CMD
) )
{ {
int idx_peer = 1; int idx_peer = 1;
@ -2586,14 +2586,14 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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); peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
if (!peer) if (!peer)
return CMD_WARNING_CONFIG_FAILED; return CMD_WARNING_CONFIG_FAILED;
ret = bgp_neighbor_graceful_restart(peer, ret = bgp_neighbor_graceful_restart(peer,
PEER_DISABLE_cmd); PEER_DISABLE_CMD);
if (peer->bgp->t_startup) if (peer->bgp->t_startup)
bgp_peer_gr_flags_update(peer); bgp_peer_gr_flags_update(peer);
@ -2603,7 +2603,7 @@ DEFUN (bgp_neighbor_graceful_restart_disable_set,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n"); "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, DEFUN (no_bgp_neighbor_graceful_restart_disable,
no_bgp_neighbor_graceful_restart_disable_set_cmd, no_bgp_neighbor_graceful_restart_disable_set_cmd,
"no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable", "no neighbor <A.B.C.D|X:X::X:X|WORD> graceful-restart-disable",
NO_STR NO_STR
NEIGHBOR_STR NEIGHBOR_STR
NEIGHBOR_ADDR_STR2 NEIGHBOR_ADDR_STR2
NO_GR_NEIGHBOR_DISABLE_CMD NO_GR_NEIGHBOR_DISABLE_CMD
) )
{ {
int idx_peer = 2; int idx_peer = 2;
@ -2631,7 +2631,7 @@ DEFUN (no_bgp_neighbor_graceful_restart_disable,
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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); 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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug( 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, vty_out(vty,
"Graceful restart configuration changed, reset this peer to take effect\n"); "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) && if ((peer->nsf_af_count == 0) &&
!CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) { !CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
/*Gr disabled case*/
mode = "Disable"; mode = "Disable";
} else if (peer->nsf_af_count == 0 && } else if (peer->nsf_af_count == 0 &&
CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) { CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
/* Helper */
mode = "Helper"; mode = "Helper";
} else if (peer->nsf_af_count != 0 && } else if (peer->nsf_af_count != 0 &&
CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) { CHECK_FLAG(peer->cap, PEER_CAP_RESTART_RCV)) {
/* Restart */
mode = "Restart"; mode = "Restart";
} }
@ -9548,7 +9545,7 @@ static void bgp_show_neighbor_graceful_restart_local_mode(struct vty *vty,
mode = "Restart"; mode = "Restart";
else if (bgp_peer_gr_mode_get(p) == PEER_DISABLE) else if (bgp_peer_gr_mode_get(p) == PEER_DISABLE)
mode = "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) if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_HELPER)
mode = "Helper*"; mode = "Helper*";
else if (bgp_global_gr_mode_get(p->bgp) == GLOBAL_GR) 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*"; mode = "Disable*";
else else
mode = "Invalid*"; mode = "Invalid*";
else }
mode = "Invalid";
if (use_json) { if (use_json) {
json_object_string_add(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, struct vty *vty, struct peer *peer,
bool use_json, json_object *json) bool use_json, json_object *json)
{ {
afi_t afi = AFI_MAX; afi_t afi;
safi_t safi = SAFI_MAX; safi_t safi;
json_object *json_afi_safi = NULL; json_object *json_afi_safi = NULL;
json_object *json_timer = NULL; json_object *json_timer = NULL;
json_object *json_endofrib_status = 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); p->bgp->restart_time);
json_object_int_add(json_timer, json_object_int_add(json_timer,
"recivedRestartTimer", "receivedRestartTimer",
p->v_gr_restart); p->v_gr_restart);
if (p->t_gr_restart != NULL) { 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 dn_flag[2] = {0};
char neighborAddr[INET6_ADDRSTRLEN] = {0}; char neighborAddr[INET6_ADDRSTRLEN] = {0};
memset(dn_flag, '\0', sizeof(dn_flag));
if (!p->conf_if && peer_dynamic_neighbor(p)) if (!p->conf_if && peer_dynamic_neighbor(p))
dn_flag[0] = '*'; dn_flag[0] = '*';
@ -12197,7 +12192,7 @@ static int bgp_show_neighbor_graceful_restart(struct vty *vty,
if (use_json) if (use_json)
json_neighbor = json_object_new_object(); json_neighbor = json_object_new_object();
if (show_all == type) { if (type == show_all) {
bgp_show_peer_gr_status(vty, peer, use_json, bgp_show_peer_gr_status(vty, peer, use_json,
json_neighbor); json_neighbor);
@ -12205,7 +12200,7 @@ static int bgp_show_neighbor_graceful_restart(struct vty *vty,
json_object_object_add(json, json_object_object_add(json,
peer->host, json_neighbor); peer->host, json_neighbor);
} else if (show_peer == type) { } else if (type == show_peer) {
if (conf_if) { if (conf_if) {
if ((peer->conf_if if ((peer->conf_if
&& !strcmp(peer->conf_if, conf_if)) && !strcmp(peer->conf_if, conf_if))
@ -12554,7 +12549,6 @@ DEFUN (show_ip_bgp_neighbors_gracrful_restart,
enum show_type sh_type; enum show_type sh_type;
int idx = 0; int idx = 0;
afi_t afi = AFI_MAX; afi_t afi = AFI_MAX;
bool uj = use_json(argc, argv); bool uj = use_json(argc, argv);
if (!argv_find_and_parse_afi(argv, argc, &idx, &afi)) 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: case GLOBAL_HELPER:
vty_out(vty, vty_out(vty,
"Global Bgp GR Mode : Helper\n"); "Global BGP GR Mode : Helper\n");
break; break;
case GLOBAL_GR: case GLOBAL_GR:
vty_out(vty, vty_out(vty,
"Global Bgp GR Mode : Restart\n"); "Global BGP GR Mode : Restart\n");
break; break;
case GLOBAL_DISABLE: case GLOBAL_DISABLE:
vty_out(vty, vty_out(vty,
"Global Bgp GR Mode : Disable\n"); "Global BGP GR Mode : Disable\n");
break; break;
case GLOBAL_INVALID: case GLOBAL_INVALID:
default: default:
vty_out(vty, vty_out(vty,
"Global Bgp GR Mode Invalid\n"); "Global BGP GR Mode Invalid\n");
break; break;
} }
vty_out(vty, "\n"); 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, if (zclient_capabilities_send(ZEBRA_CLIENT_CAPABILITIES,
zclient, &api) < 0) { zclient, &api) < 0) {
if (BGP_DEBUG(zebra, ZEBRA)) zlog_err("error sending capability");
zlog_debug("error sending capability");
ret = BGP_GR_FAILURE; ret = BGP_GR_FAILURE;
} else { } else {
if (disable) 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) 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 (zclient == NULL) {
if (BGP_DEBUG(zebra, ZEBRA)) if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("zclient invalid"); zlog_debug("zclient == NULL, invalid");
return BGP_GR_FAILURE; 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; return BGP_GR_FAILURE;
} }
memset(&api, 0, sizeof(struct zapi_cap));
api.afi = afi; api.afi = afi;
api.safi = safi; api.safi = safi;
api.vrf_id = vrf_id; api.vrf_id = vrf_id;
@ -3141,9 +3139,6 @@ int zclient_capabilities_send(uint32_t cmd, struct zclient *zclient,
return zclient_send_message(zclient); return zclient_send_message(zclient);
} }
/* Send RIB stale timer update */ /* Send RIB stale timer update */
int bgp_zebra_stale_timer_update(struct bgp *bgp) 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_rule;
struct bgp_pbr_match_entry; struct bgp_pbr_match_entry;
extern void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra, extern void bgp_send_pbr_rule_action(struct bgp_pbr_action *pbra,
struct bgp_pbr_rule *pbr, struct bgp_pbr_rule *pbr,
bool install); 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)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("%s called ..", __func__); 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 */ /* GLOBAL_HELPER Mode */
{ {
/*Event -> */ /*Event -> */
@ -1157,12 +1157,13 @@ int bgp_peer_gr_init(struct peer *peer)
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("%s called ..", __func__); 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 */ /* PEER_HELPER Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */ /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_GR, bgp_peer_gr_action }, {PEER_INVALID, NULL }, { 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 }, {PEER_DISABLE, bgp_peer_gr_action }, {PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */ /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_INVALID, NULL }, {PEER_GLOBAL_INHERIT, { 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 */ /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT, { PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
bgp_peer_gr_action }, 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 }, {PEER_DISABLE, bgp_peer_gr_action }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */ /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL } { PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
@ -1182,7 +1183,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* PEER_DISABLE Mode */ /* PEER_DISABLE Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */ /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL }, { 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, { PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
bgp_peer_gr_action }, bgp_peer_gr_action },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */ /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
@ -1192,7 +1193,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* PEER_INVALID Mode */ /* PEER_INVALID Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */ /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_INVALID, NULL }, { PEER_INVALID, NULL }, { 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 }, { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */ /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_INVALID, NULL }, { PEER_INVALID, NULL }, { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
@ -1201,7 +1202,7 @@ int bgp_peer_gr_init(struct peer *peer)
/* PEER_GLOBAL_INHERIT Mode */ /* PEER_GLOBAL_INHERIT Mode */
/* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */ /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
{ PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL }, { 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 }, { PEER_DISABLE, bgp_peer_gr_action}, { PEER_INVALID, NULL },
/* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */ /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
{ PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL } { 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; bool gr_router_detected = false;
if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART)) if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
zlog_debug("BGP_GR:: %s called !", zlog_debug("[BGP_GR] %s called !",
__func__); __func__);
for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) { for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
@ -7266,10 +7267,10 @@ void bgp_gr_apply_running_config(void)
if (gr_router_detected && if (gr_router_detected &&
bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) { 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 && } else if (!gr_router_detected &&
bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) { bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
bgp_zebra_send_capabilities(bgp, true); bgp_zebra_send_capabilities(bgp, false);
} }
gr_router_detected = false; gr_router_detected = false;

21
bgpd/bgpd.h
View File

@ -246,8 +246,8 @@ enum bgp_instance_type {
/* BGP GR Global ds */ /* BGP GR Global ds */
#define GLOBAL_MODE 4 #define BGP_GLOBAL_GR_MODE 4
#define EVENT_CMD 4 #define BGP_GLOBAL_GR_EVENT_CMD 4
/* Graceful restart selection deferral timer info */ /* Graceful restart selection deferral timer info */
struct graceful_restart_info { struct graceful_restart_info {
@ -425,7 +425,8 @@ struct bgp {
#define BGP_FLAG_SELECT_DEFER_DISABLE (1 << 23) #define BGP_FLAG_SELECT_DEFER_DISABLE (1 << 23)
#define BGP_FLAG_GR_DISABLE_EOR (1 << 24) #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; enum global_mode global_gr_present_state;
/* This variable stores the current Graceful Restart state of Zebra /* 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_RD_CFGD (1 << 3)
#define BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY (1 << 4) #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 */ /* unique ID for auto derivation of RD for this vrf */
uint16_t vrf_rd_id; uint16_t vrf_rd_id;
@ -813,8 +808,8 @@ struct peer_af {
}; };
/* BGP GR per peer ds */ /* BGP GR per peer ds */
#define PEER_MODE 5 #define BGP_PEER_GR_MODE 5
#define PEER_EVENT_CMD 6 #define BGP_PEER_GR_EVENT_CMD 6
enum peer_mode { enum peer_mode {
PEER_HELPER = 0, PEER_HELPER = 0,
@ -828,7 +823,7 @@ enum peer_mode {
enum peer_gr_command { enum peer_gr_command {
PEER_GR_CMD = 0, PEER_GR_CMD = 0,
NO_PEER_GR_CMD, NO_PEER_GR_CMD,
PEER_DISABLE_cmd, PEER_DISABLE_CMD,
NO_PEER_DISABLE_CMD, NO_PEER_DISABLE_CMD,
PEER_HELPER_CMD, PEER_HELPER_CMD,
NO_PEER_HELPER_CMD NO_PEER_HELPER_CMD
@ -1073,7 +1068,7 @@ struct peer {
*and PEER_FLAG_GRACEFUL_RESTART_GLOBAL_INHERIT *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; enum peer_mode peer_gr_present_state;
/* Non stop forwarding afi-safi count for BGP gr feature*/ /* Non stop forwarding afi-safi count for BGP gr feature*/
uint8_t nsf_af_count; 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 If per peer mode is configured, the GR mode of this particular peer will
override the global mode. override the global mode.
.. _bgp-GR-globla-mode-cmd: .. _bgp-GR-global-mode-cmd:
BGP GR Global Mode Commands 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: default:
break; break;
} }
stream_failure: stream_failure:
return 0; return 0;
} }