LCOV - code coverage report
Current view: top level - bgp - peer_close_manager.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 336 479 70.1 %
Date: 2026-11-16 02:06:09 Functions: 37 41 90.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "bgp/peer_close_manager.h"
       7             : 
       8             : 
       9             : #include <list>
      10             : #include <map>
      11             : 
      12             : #include <boost/foreach.hpp>
      13             : 
      14             : #include "base/task_annotations.h"
      15             : #include "bgp/bgp_log.h"
      16             : #include "bgp/bgp_membership.h"
      17             : #include "bgp/bgp_peer_types.h"
      18             : #include "bgp/bgp_route.h"
      19             : #include "bgp/bgp_server.h"
      20             : #include "bgp/routing-instance/routing_instance.h"
      21             : #include "net/community_type.h"
      22             : 
      23             : #define PEER_CLOSE_MANAGER_LOG(msg) \
      24             :     BGP_LOG_PEER(Event, peer_close_->peer(), SandeshLevel::SYS_INFO,           \
      25             :         BGP_LOG_FLAG_ALL, BGP_PEER_DIR_NA,                                     \
      26             :         "PeerCloseManager: State " << GetStateName(state_) <<                  \
      27             :         ", MembershipState: " << GetMembershipStateName(membership_state_) <<  \
      28             :         ", MembershipReqPending: " << membership_req_pending_ <<               \
      29             :         ", CloseAgain?: " << (close_again_ ? "Yes" : "No") << ": " << msg);
      30             : 
      31             : #define PEER_CLOSE_MANAGER_TABLE_LOG(msg)                                      \
      32             :     BGP_LOG_PEER_TABLE(peer_close_->peer(), SandeshLevel::SYS_INFO,            \
      33             :         BGP_LOG_FLAG_ALL, table,                                               \
      34             :         "PeerCloseManager: State " << GetStateName(state_) <<                  \
      35             :         ", MembershipState: " << GetMembershipStateName(membership_state_) <<  \
      36             :         ", MembershipReqPending: " << membership_req_pending_ <<               \
      37             :         ", CloseAgain?: " << (close_again_ ? "Yes" : "No") << ": " << msg);
      38             : 
      39             : #define MOVE_TO_STATE(state)                                                   \
      40             :     do {                                                                       \
      41             :         assert(state_ != state);                                               \
      42             :         PEER_CLOSE_MANAGER_LOG("Move to state " << GetStateName(state));       \
      43             :         state_ = state;                                                        \
      44             :     } while (false)
      45             : 
      46             : // Create an instance of PeerCloseManager with back reference to parent IPeer
      47           0 : PeerCloseManager::PeerCloseManager(IPeerClose *peer_close,
      48           0 :                                    boost::asio::io_context *io_service) :
      49           0 :         peer_close_(peer_close), gr_timer_(NULL),
      50           0 :         event_queue_(new WorkQueue<Event *>(
      51           0 :                      TaskScheduler::GetInstance()->GetTaskId(
      52           0 :                          peer_close_->GetTaskName()),
      53           0 :                      peer_close_->GetTaskInstance(),
      54           0 :                      boost::bind(&PeerCloseManager::EventCallback, this, _1))),
      55           0 :         state_(NONE), close_again_(false), graceful_(true), gr_elapsed_(0),
      56           0 :         llgr_elapsed_(0), membership_state_(MEMBERSHIP_NONE) {
      57           0 :     stats_.init++;
      58           0 :     membership_req_pending_ = 0;
      59           0 :     gr_timer_ = TimerManager::CreateTimer(*io_service,
      60             :                                           "Graceful Restart Timer");
      61           0 : }
      62             : 
      63             : // Create an instance of PeerCloseManager with back reference to parent IPeer
      64         232 : PeerCloseManager::PeerCloseManager(IPeerClose *peer_close) :
      65         232 :         peer_close_(peer_close), gr_timer_(NULL),
      66         464 :         event_queue_(new WorkQueue<Event *>(
      67         696 :                      TaskScheduler::GetInstance()->GetTaskId(
      68         232 :                          peer_close_->GetTaskName()),
      69         232 :                      peer_close_->GetTaskInstance(),
      70         232 :                      boost::bind(&PeerCloseManager::EventCallback, this, _1))),
      71         232 :         state_(NONE), close_again_(false), graceful_(true), gr_elapsed_(0),
      72         464 :         llgr_elapsed_(0), membership_state_(MEMBERSHIP_NONE) {
      73         232 :     stats_.init++;
      74         232 :     membership_req_pending_ = 0;
      75         232 :     if (peer_close->peer() && peer_close->peer()->server()) {
      76         152 :         gr_timer_ =
      77         152 :            TimerManager::CreateTimer(*peer_close->peer()->server()->ioservice(),
      78             :                                      "Graceful Restart Timer");
      79             :     }
      80         232 : }
      81             : 
      82         232 : PeerCloseManager::~PeerCloseManager() {
      83         232 :     event_queue_->Shutdown();
      84         232 :     TimerManager::DeleteTimer(gr_timer_);
      85         232 : }
      86             : 
      87        3804 : std::string PeerCloseManager::GetStateName(State state) const {
      88        3804 :     switch (state) {
      89         330 :     case NONE:
      90         330 :         return "NONE";
      91         226 :     case GR_TIMER:
      92         226 :         return "GR_TIMER";
      93        1408 :     case STALE:
      94        1408 :         return "STALE";
      95           0 :     case LLGR_STALE:
      96           0 :         return "LLGR_STALE";
      97           0 :     case LLGR_TIMER:
      98           0 :         return "LLGR_TIMER";
      99         768 :     case SWEEP:
     100         768 :         return "SWEEP";
     101        1072 :     case DELETE:
     102        1072 :         return "DELETE";
     103             :     }
     104           0 :     assert(false);
     105             :     return "";
     106             : }
     107             : 
     108        3596 : std::string PeerCloseManager::GetMembershipStateName(
     109             :         MembershipState state) const {
     110        3596 :     switch (state) {
     111         428 :     case MEMBERSHIP_NONE:
     112         428 :         return "NONE";
     113        3142 :     case MEMBERSHIP_IN_USE:
     114        3142 :         return "IN_USE";
     115          26 :     case MEMBERSHIP_IN_WAIT:
     116          26 :         return "IN_WAIT";
     117             :     }
     118           0 :     assert(false);
     119             :     return "";
     120             : }
     121             : 
     122        1332 : std::string PeerCloseManager::GetEventName(EventType eventType) const {
     123        1332 :     switch (eventType) {
     124           0 :     case EVENT_NONE:
     125           0 :         return "NONE";
     126          80 :     case CLOSE:
     127          80 :         return "CLOSE";
     128         196 :     case EOR_RECEIVED:
     129         196 :         return "EOR_RECEIVED";
     130          64 :     case MEMBERSHIP_REQUEST:
     131          64 :         return "MEMBERSHIP_REQUEST";
     132         976 :     case MEMBERSHIP_REQUEST_COMPLETE_CALLBACK:
     133         976 :         return "MEMBERSHIP_REQUEST_COMPLETE_CALLBACK";
     134          16 :     case TIMER_CALLBACK:
     135          16 :         return "TIMER_CALLBACK";
     136             :     }
     137             : 
     138           0 :     return "";
     139             : }
     140             : 
     141        3447 : void PeerCloseManager::EnqueueEvent(Event *event) {
     142        4271 :     PEER_CLOSE_MANAGER_LOG("Enqueued event " <<
     143             :             GetEventName(event->event_type) <<
     144             :             ", graceful " << event->graceful <<
     145             :             ", family " << Address::FamilyToString(event->family));
     146        3449 :     event_queue_->Enqueue(event);
     147        3464 : }
     148             : 
     149             : // Trigger closure of an IPeer
     150             : //
     151             : // Graceful                                 close_state_: NONE
     152             : // RibIn Stale Marking and Ribout deletion  close_state_: STALE
     153             : // StateMachine restart and GR timer start  close_state_: GR_TIMER
     154             : //
     155             : // Peer IsReady() in GR timer callback (or via reception of all EoRs)
     156             : // RibIn Sweep and Ribout Generation        close_state_: SWEEP
     157             : //   MembershipRequestCallback      close_state_: NONE
     158             : //
     159             : // Peer not IsReady() in GR timer callback
     160             : // If LLGR supported                     close_state_: LLGR_STALE
     161             : //   RibIn Stale marking with LLGR_STALE community close_state_: LLGR_TIMER
     162             : //
     163             : //     Peer not IsReady() in LLGR timer callback
     164             : //       RibIn Delete                       close_state_: DELETE
     165             : //       MembershipRequestCallback                 close_state_: NONE
     166             : //
     167             : //     Peer IsReady() in LLGR timer callback (or via reception of all EoRs)
     168             : //     RibIn Sweep                          close_state_: SWEEP
     169             : //       MembershipRequestCallback  close_state_: NONE
     170             : //
     171             : // If LLGR is not supported
     172             : //     RibIn Delete                         close_state_: DELETE
     173             : //     MembershipRequestCallback    close_state_: NONE
     174             : //
     175             : // Close() call during any state other than NONE and DELETE
     176             : //     Cancel GR timer and restart GR Closure all over again
     177             : //
     178             : // NonGraceful                              close_state_ = * (except DELETE)
     179             : // A. RibIn deletion and Ribout deletion    close_state_ = DELETE
     180             : // B. MembershipRequestCallback => Peers delete/StateMachine restart
     181             : //                                          close_state_ = NONE
     182             : //
     183             : // If Close is restarted, account for GR timer's elapsed time.
     184             : //
     185             : // Use graceful as true to close gracefully.
     186         232 : void PeerCloseManager::Close(bool graceful) {
     187         232 :     EnqueueEvent(new Event(CLOSE, graceful));
     188         232 : }
     189             : 
     190         232 : void PeerCloseManager::Close(Event *event) {
     191             :     // Note down non-graceful close trigger. Once non-graceful closure is
     192             :     // triggered, it should remain so until close process is complete. Further
     193             :     // graceful closure calls until then should remain non-graceful.
     194         232 :     graceful_ &= event->graceful;
     195         232 :     CloseInternal();
     196         232 : }
     197             : 
     198         248 : void PeerCloseManager::CloseInternal() {
     199         248 :     stats_.close++;
     200             : 
     201             :     // Ignore nested closures
     202         248 :     if (close_again_) {
     203           0 :         PEER_CLOSE_MANAGER_LOG("Nested close calls ignored");
     204           0 :         return;
     205             :     }
     206             : 
     207         248 :     switch (state_) {
     208         232 :     case NONE:
     209         232 :         stats_.ResetRouteStats();
     210         232 :         ProcessClosure();
     211         232 :         break;
     212             : 
     213          16 :     case GR_TIMER:
     214          24 :         PEER_CLOSE_MANAGER_LOG("Nested close: Restart GR");
     215          16 :         close_again_ = true;
     216          16 :         stats_.nested++;
     217          16 :         gr_elapsed_ += gr_timer_->GetElapsedTime();
     218          16 :         CloseComplete();
     219          16 :         break;
     220             : 
     221           0 :     case LLGR_TIMER:
     222           0 :         PEER_CLOSE_MANAGER_LOG("Nested close: Restart LLGR");
     223           0 :         close_again_ = true;
     224           0 :         stats_.nested++;
     225           0 :         llgr_elapsed_ += gr_timer_->GetElapsedTime();
     226           0 :         CloseComplete();
     227           0 :         break;
     228             : 
     229           0 :     case STALE:
     230             :     case LLGR_STALE:
     231             :     case SWEEP:
     232             :     case DELETE:
     233           0 :         PEER_CLOSE_MANAGER_LOG("Nested close");
     234           0 :         close_again_ = true;
     235           0 :         stats_.nested++;
     236           0 :         break;
     237             :     }
     238             : }
     239             : 
     240         356 : void PeerCloseManager::ProcessEORMarkerReceived(Address::Family family) {
     241         356 :     EnqueueEvent(new Event(EOR_RECEIVED, family));
     242         356 : }
     243             : 
     244         356 : void PeerCloseManager::ProcessEORMarkerReceived(Event *event) {
     245         356 :     if ((state_ == GR_TIMER || state_ == LLGR_TIMER) && !families_.empty()) {
     246          50 :         if (event->family == Address::UNSPEC) {
     247           8 :             families_.clear();
     248             :         } else {
     249          42 :             families_.erase(event->family);
     250             :         }
     251             : 
     252             :         // Start the timer if all EORs have been received.
     253          50 :         if (families_.empty())
     254          16 :             StartRestartTimer(0);
     255             :     }
     256         356 : }
     257             : 
     258             : // Process RibIn during peer closure.
     259          48 : void PeerCloseManager::StartRestartTimer(int time) {
     260          48 :     gr_timer_->Cancel();
     261          72 :     PEER_CLOSE_MANAGER_LOG("GR Timer started to fire after " << time/1000 <<
     262             :                            " seconds");
     263          48 :     gr_timer_->Start(time,
     264             :         boost::bind(&PeerCloseManager::RestartTimerCallback, this));
     265          48 : }
     266             : 
     267          16 : bool PeerCloseManager::RestartTimerCallback() {
     268          16 :     CHECK_CONCURRENCY("timer::TimerTask");
     269          16 :     EnqueueEvent(new Event(TIMER_CALLBACK));
     270          16 :     return false;
     271             : }
     272             : 
     273          16 : void PeerCloseManager::RestartTimerCallback(Event *event) {
     274          16 :     CHECK_CONCURRENCY(peer_close_->GetTaskName());
     275             : 
     276          24 :     PEER_CLOSE_MANAGER_LOG("GR Timer callback started");
     277          16 :     if (state_ != GR_TIMER && state_ != LLGR_TIMER)
     278           0 :         return;
     279             : 
     280          16 :     if (peer_close_->IsReady() && !families_.empty()) {
     281             :         // Fake reception of all EORs.
     282           0 :         for (IPeerClose::Families::iterator i = families_.begin(), next = i;
     283           0 :                 i != families_.end(); i = next) {
     284           0 :             next++;
     285           0 :             PEER_CLOSE_MANAGER_LOG("Simulate EoR reception for family " << *i);
     286           0 :             peer_close_->ReceiveEndOfRIB(*i);
     287             :         }
     288             :     } else {
     289          16 :         ProcessClosure();
     290             :     }
     291             : }
     292             : 
     293             : // Route stale timer callback. If the peer has come back up, sweep routes for
     294             : // those address families that are still active. Delete the rest
     295         248 : void PeerCloseManager::ProcessClosure() {
     296             :     // If the peer is back up and this address family is still supported,
     297             :     // sweep old paths which may not have come back in the new session
     298         248 :     switch (state_) {
     299         232 :         case NONE:
     300         232 :             if (!graceful_ || !peer_close_->IsCloseGraceful()) {
     301         224 :                 MOVE_TO_STATE(DELETE);
     302         200 :                 stats_.deletes++;
     303             :             } else {
     304          48 :                 MOVE_TO_STATE(STALE);
     305          32 :                 stats_.stale++;
     306          32 :                 StaleNotify();
     307          32 :                 return;
     308             :             }
     309         200 :             break;
     310          16 :         case GR_TIMER:
     311          16 :             if (peer_close_->IsReady()) {
     312          24 :                 MOVE_TO_STATE(SWEEP);
     313          16 :                 gr_elapsed_ = 0;
     314          16 :                 llgr_elapsed_ = 0;
     315          16 :                 stats_.sweep++;
     316          16 :                 break;
     317             :             }
     318           0 :             if (peer_close_->IsCloseLongLivedGraceful()) {
     319           0 :                 MOVE_TO_STATE(LLGR_STALE);
     320           0 :                 stats_.llgr_stale++;
     321           0 :                 peer_close_->LongLivedGracefulRestartStale();
     322           0 :                 break;
     323             :             }
     324           0 :             MOVE_TO_STATE(DELETE);
     325           0 :             stats_.deletes++;
     326           0 :             break;
     327             : 
     328           0 :         case LLGR_TIMER:
     329           0 :             if (peer_close_->IsReady()) {
     330           0 :                 MOVE_TO_STATE(SWEEP);
     331           0 :                 gr_elapsed_ = 0;
     332           0 :                 llgr_elapsed_ = 0;
     333           0 :                 stats_.sweep++;
     334           0 :                 break;
     335             :             }
     336           0 :             MOVE_TO_STATE(DELETE);
     337           0 :             stats_.deletes++;
     338           0 :             break;
     339             : 
     340           0 :         case STALE:
     341             :         case LLGR_STALE:
     342             :         case SWEEP:
     343             :         case DELETE:
     344           0 :             assert(false);
     345             :             return;
     346             :     }
     347             : 
     348         216 :     if (state_ == DELETE)
     349         200 :         peer_close_->CustomClose();
     350         216 :     MembershipRequest();
     351             : }
     352             : 
     353          32 : void PeerCloseManager::CloseComplete() {
     354          48 :     MOVE_TO_STATE(NONE);
     355          32 :     gr_timer_->Cancel();
     356          32 :     families_.clear();
     357          32 :     stats_.init++;
     358             : 
     359             :     // Nested closures trigger fresh GR
     360          32 :     if (close_again_) {
     361          16 :         close_again_ = false;
     362          16 :         CloseInternal();
     363             :     }
     364          32 : }
     365             : 
     366          16 : bool PeerCloseManager::AssertSweepState(bool do_assert) {
     367          16 :     bool check = (state_ == SWEEP);
     368          16 :     if (do_assert)
     369          16 :         assert(check);
     370          16 :     return check;
     371             : }
     372             : 
     373        2712 : bool PeerCloseManager::AssertMembershipManagerInUse(bool do_assert) {
     374        2712 :     bool check = false;
     375        4752 :     check |= (state_ == STALE || state_ == LLGR_STALE || state_ == SWEEP ||
     376        2040 :               state_ == DELETE);
     377        2712 :     check |= (membership_state_ == MEMBERSHIP_IN_USE);
     378        2712 :     check |= (membership_req_pending_ > 0);
     379        2712 :     if (do_assert)
     380        2712 :         assert(check);
     381        2712 :     return check;
     382             : }
     383             : 
     384         256 : bool PeerCloseManager::AssertMembershipState(bool do_assert) {
     385         256 :     bool check = (membership_state_ != MEMBERSHIP_IN_USE);
     386         256 :     if (do_assert)
     387         256 :         assert(check);
     388         256 :     return check;
     389             : }
     390             : 
     391         248 : bool PeerCloseManager::AssertMembershipReqCount(bool do_assert) {
     392         248 :     bool check = !membership_req_pending_;
     393         248 :     if (do_assert)
     394         248 :         assert(check);
     395         248 :     return check;
     396             : }
     397             : 
     398          16 : void PeerCloseManager::TriggerSweepStateActions() {
     399          16 :     CHECK_CONCURRENCY(peer_close_->GetTaskName());
     400          16 :     if (!AssertSweepState())
     401           0 :         return;
     402             : 
     403             :     // Notify clients to trigger sweep as appropriate.
     404          16 :     peer_close_->GracefulRestartSweep();
     405             : 
     406             :     // Reset MembershipUse state after client has been notified above.
     407          16 :     set_membership_state(MEMBERSHIP_NONE);
     408          16 :     CloseComplete();
     409             : }
     410             : 
     411             : // Notify clients about entering Stale event.
     412          32 : void PeerCloseManager::StaleNotify() {
     413          32 :     CHECK_CONCURRENCY(peer_close_->GetTaskName());
     414             : 
     415          32 :     peer_close_->GracefulRestartStale();
     416          32 :     if (!AssertMembershipState())
     417           0 :         return;
     418          32 :     MembershipRequest(NULL);
     419             : }
     420             : 
     421         224 : bool PeerCloseManager::CanUseMembershipManager() const {
     422         224 :     return peer_close_->peer()->CanUseMembershipManager();
     423             : }
     424             : 
     425         248 : void PeerCloseManager::GetRegisteredRibs(std::list<BgpTable *> *tables) {
     426         248 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     427         248 :     mgr->GetRegisteredRibs(peer_close_->peer(), tables);
     428         248 : }
     429             : 
     430        2648 : bool PeerCloseManager::IsRegistered(BgpTable *table) const {
     431        2648 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     432        2648 :     return mgr->IsRegistered(peer_close_->peer(), table);
     433             : }
     434             : 
     435        1944 : void PeerCloseManager::Unregister(BgpTable *table) {
     436        1944 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     437        1944 :     mgr->Unregister(peer_close_->peer(), table);
     438        1944 : }
     439             : 
     440         432 : void PeerCloseManager::WalkRibIn(BgpTable *table) {
     441         432 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     442         432 :     mgr->WalkRibIn(peer_close_->peer(), table);
     443         432 : }
     444             : 
     445         240 : void PeerCloseManager::UnregisterRibOut(BgpTable *table) {
     446         240 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     447         240 :     mgr->UnregisterRibOut(peer_close_->peer(), table);
     448         240 : }
     449             : 
     450         424 : bool PeerCloseManager::IsRibInRegistered(BgpTable *table) const {
     451         424 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     452         424 :     return mgr->IsRibInRegistered(peer_close_->peer(), table);
     453             : }
     454             : 
     455          32 : void PeerCloseManager::UnregisterRibIn(BgpTable *table) {
     456          32 :     BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
     457          32 :     mgr->UnregisterRibIn(peer_close_->peer(), table);
     458          32 : }
     459             : 
     460         224 : void PeerCloseManager::MembershipRequest() {
     461         224 :     if (!AssertMembershipState())
     462           0 :         return;
     463             : 
     464             :     // Pause if membership manager is not ready for usage.
     465         224 :     if (!CanUseMembershipManager()) {
     466           8 :         set_membership_state(MEMBERSHIP_IN_WAIT);
     467           8 :         PEER_CLOSE_MANAGER_LOG("Wait for membership manager availability");
     468           8 :         return;
     469             :     }
     470         216 :     set_membership_state(MEMBERSHIP_IN_USE);
     471         216 :     EnqueueEvent(new Event(MEMBERSHIP_REQUEST));
     472             : }
     473             : 
     474         248 : void PeerCloseManager::MembershipRequest(Event *evnet) {
     475         248 :     CHECK_CONCURRENCY(peer_close_->GetTaskName());
     476             : 
     477         248 :     set_membership_state(MEMBERSHIP_IN_USE);
     478         248 :     if (!AssertMembershipReqCount())
     479          64 :         return;
     480         248 :     membership_req_pending_++;
     481         248 :     std::list<BgpTable *> tables;
     482         248 :     GetRegisteredRibs(&tables);
     483             : 
     484         248 :     if (tables.empty()) {
     485          64 :         assert(MembershipRequestCallback(NULL));
     486          64 :         return;
     487             :     }
     488             : 
     489             :     // Account for extra increment above.
     490         184 :     membership_req_pending_--;
     491        5480 :     BOOST_FOREACH(BgpTable *table, tables) {
     492        2648 :         membership_req_pending_++;
     493        2648 :         if (IsRegistered(table)) {
     494        2224 :             if (state_ == PeerCloseManager::DELETE) {
     495        2432 :                 PEER_CLOSE_MANAGER_TABLE_LOG(
     496             :                     "MembershipManager::Unregister");
     497        1944 :                 Unregister(table);
     498         280 :             } else if (state_ == PeerCloseManager::SWEEP) {
     499          80 :                 PEER_CLOSE_MANAGER_TABLE_LOG("MembershipManager::WalkRibIn");
     500          40 :                 WalkRibIn(table);
     501             :             } else {
     502         664 :                 PEER_CLOSE_MANAGER_TABLE_LOG(
     503             :                     "MembershipManager::UnregisterRibOut");
     504         240 :                 UnregisterRibOut(table);
     505             :             }
     506             :         } else {
     507         424 :             assert(IsRibInRegistered(table));
     508         424 :             if (state_ == PeerCloseManager::DELETE) {
     509          32 :                 PEER_CLOSE_MANAGER_TABLE_LOG(
     510             :                     "MembershipManager::UnregisterRibIn");
     511          32 :                 UnregisterRibIn(table);
     512             :             } else {
     513        1152 :                 PEER_CLOSE_MANAGER_TABLE_LOG("MembershipManager::WalkRibIn");
     514         392 :                 WalkRibIn(table);
     515             :             }
     516             :         }
     517             :     }
     518         248 : }
     519             : 
     520        2630 : void PeerCloseManager::MembershipRequestCallback() {
     521        2630 :     EnqueueEvent(new Event(MEMBERSHIP_REQUEST_COMPLETE_CALLBACK));
     522        2645 : }
     523             : 
     524             : // Close process for this peer in terms of walking RibIns and RibOuts are
     525             : // complete. Do the final cleanups necessary and notify interested party
     526             : //
     527             : // Retrun true if we are done using membership manager, false otherwise.
     528        2712 : bool PeerCloseManager::MembershipRequestCallback(Event *event) {
     529        2712 :     CHECK_CONCURRENCY(peer_close_->GetTaskName());
     530             : 
     531        2712 :     bool result = false;
     532        3464 :     PEER_CLOSE_MANAGER_LOG("MembershipRequestCallback");
     533             : 
     534        2712 :     if (!AssertMembershipManagerInUse())
     535           0 :         return result;
     536        2712 :     if (--membership_req_pending_)
     537        2464 :         return result;
     538             : 
     539             :     // Indicate to the caller that we are done using the membership manager.
     540         248 :     result = true;
     541             : 
     542         248 :     if (state_ == DELETE) {
     543         224 :         MOVE_TO_STATE(NONE);
     544         200 :         peer_close_->Delete();
     545         200 :         gr_elapsed_ = 0;
     546         200 :         llgr_elapsed_ = 0;
     547         200 :         stats_.init++;
     548         200 :         close_again_ = false;
     549         200 :         graceful_ = true;
     550         200 :         set_membership_state(MEMBERSHIP_NONE);
     551         200 :         return result;
     552             :     }
     553             : 
     554             :     // Process nested closures.
     555          48 :     if (close_again_) {
     556           0 :         set_membership_state(MEMBERSHIP_NONE);
     557           0 :         CloseComplete();
     558             : 
     559             :         // Nested closure can make membership manager to be in use again.
     560           0 :         return membership_state_ != MEMBERSHIP_IN_USE;
     561             :     }
     562             : 
     563             :     // If any GR stale timer has to be launched, then to wait for some time
     564             :     // hoping for the peer (and the paths) to come back up.
     565          48 :     if (state_ == STALE) {
     566          32 :         peer_close_->CloseComplete();
     567          48 :         MOVE_TO_STATE(GR_TIMER);
     568          32 :         peer_close_->GetGracefulRestartFamilies(&families_);
     569             : 
     570             :         // Offset restart time with elapsed time during nested closures.
     571          32 :         int time = peer_close_->GetGracefulRestartTime() * 1000;
     572          32 :         time -= gr_elapsed_;
     573          32 :         if (time < 0)
     574           0 :             time = 0;
     575          32 :         StartRestartTimer(time);
     576          32 :         stats_.gr_timer++;
     577          32 :         set_membership_state(MEMBERSHIP_NONE);
     578          32 :         return result;
     579             :     }
     580             : 
     581             :     // From LLGR_STALE state, switch to LLGR_TIMER state. Typically this would
     582             :     // be a very long timer, and we expect to receive EORs before this timer
     583             :     // expires.
     584             :     // Just like for GRSTALE in the above case, before moving to LLGR_TIMER and 
     585             :     // starting LLGR_TIMER, we can check if the peer can come back up.
     586          16 :     if (state_ == LLGR_STALE) {
     587           0 :         MOVE_TO_STATE(LLGR_TIMER);
     588           0 :         peer_close_->CloseComplete();
     589           0 :         peer_close_->GetLongLivedGracefulRestartFamilies(&families_);
     590             : 
     591             :         // Offset restart time with elapsed time during nested closures.
     592           0 :         int time = peer_close_->GetLongLivedGracefulRestartTime() * 1000;
     593           0 :         time -= llgr_elapsed_;
     594           0 :         if (time < 0)
     595           0 :             time = 0;
     596           0 :         StartRestartTimer(time);
     597           0 :         stats_.llgr_timer++;
     598           0 :         set_membership_state(MEMBERSHIP_NONE);
     599           0 :         return result;
     600             :     }
     601             : 
     602          16 :     TriggerSweepStateActions();
     603          16 :     return result;
     604             : }
     605             : 
     606           0 : void PeerCloseManager::FillRouteCloseInfo(PeerCloseInfo *close_info) const {
     607           0 :     std::map<std::string, PeerCloseRouteInfo> route_stats;
     608             : 
     609           0 :     for (int i = 0; i < Address::NUM_FAMILIES; i++) {
     610           0 :         if (!stats_.route_stats[i].IsSet())
     611           0 :             continue;
     612           0 :         PeerCloseRouteInfo route_info;
     613           0 :         route_info.set_staled(stats_.route_stats[i].staled);
     614           0 :         route_info.set_llgr_staled(stats_.route_stats[i].llgr_staled);
     615           0 :         route_info.set_refreshed(stats_.route_stats[i].refreshed);
     616           0 :         route_info.set_fresh(stats_.route_stats[i].fresh);
     617           0 :         route_info.set_deleted(stats_.route_stats[i].deleted);
     618           0 :         route_stats[Address::FamilyToString(static_cast<Address::Family>(i))] = route_info;
     619           0 :     }
     620             : 
     621           0 :     if (!route_stats.empty())
     622           0 :         close_info->set_route_stats(route_stats);
     623           0 : }
     624             : 
     625           0 : BgpNeighborResp *PeerCloseManager::FillCloseInfo(BgpNeighborResp *resp) const {
     626           0 :     PeerCloseInfo peer_close_info;
     627           0 :     peer_close_info.set_state(GetStateName(state_));
     628           0 :     peer_close_info.set_membership_state(
     629           0 :         GetMembershipStateName(membership_state_));
     630           0 :     peer_close_info.set_close_again(close_again_);
     631           0 :     peer_close_info.set_graceful(graceful_);
     632           0 :     peer_close_info.set_init(stats_.init);
     633           0 :     peer_close_info.set_close(stats_.close);
     634           0 :     peer_close_info.set_nested(stats_.nested);
     635           0 :     peer_close_info.set_deletes(stats_.deletes);
     636           0 :     peer_close_info.set_stale(stats_.stale);
     637           0 :     peer_close_info.set_llgr_stale(stats_.llgr_stale);
     638           0 :     peer_close_info.set_sweep(stats_.sweep);
     639           0 :     peer_close_info.set_gr_timer(stats_.gr_timer);
     640           0 :     peer_close_info.set_llgr_timer(stats_.llgr_timer);
     641           0 :     FillRouteCloseInfo(&peer_close_info);
     642             : 
     643           0 :     resp->set_peer_close_info(peer_close_info);
     644             : 
     645           0 :     return resp;
     646           0 : }
     647             : 
     648       10595 : void PeerCloseManager::UpdateRouteStats(Address::Family family,
     649             :         const BgpPath *old_path, uint32_t path_flags) const {
     650       10595 :     if (state_ == NONE)
     651        9690 :         return;
     652             : 
     653         905 :     if (!old_path)
     654           0 :         stats_.route_stats[family].fresh++;
     655         905 :     else if (old_path->IsStale() && !(path_flags & BgpPath::Stale))
     656         102 :         stats_.route_stats[family].refreshed++;
     657             : }
     658             : 
     659        7155 : bool PeerCloseManager::MembershipPathCallback(DBTablePartBase *root,
     660             :                                               BgpRoute *rt, BgpPath *path) {
     661        7155 :     CHECK_CONCURRENCY("db::DBTable");
     662        7151 :     DBRequest::DBOperation oper = DBRequest::DB_ENTRY_INVALID;
     663        7151 :     BgpAttrPtr attrs;
     664             : 
     665        7151 :     BgpTable *table = static_cast<BgpTable *>(root->parent());
     666        7149 :     assert(table);
     667             : 
     668        7149 :     uint32_t stale = 0;
     669             : 
     670        7149 :     switch (state_) {
     671           0 :         case NONE:
     672             :         case GR_TIMER:
     673             :         case LLGR_TIMER:
     674           0 :             return false;
     675             : 
     676         782 :         case SWEEP:
     677             : 
     678             :             // Stale paths must be deleted.
     679         782 :             if (!path->IsStale() && !path->IsLlgrStale())
     680          80 :                 return false;
     681         702 :             if (path->IsStale()) {
     682         702 :                 path->ResetStale();
     683         702 :                 table->UpdateStalePathCount(-1);
     684             :             }
     685         704 :             if (path->IsLlgrStale()) {
     686           0 :                 path->ResetLlgrStale();
     687           0 :                 table->UpdateLlgrStalePathCount(-1);
     688             :             }
     689         704 :             oper = DBRequest::DB_ENTRY_DELETE;
     690         704 :             attrs = NULL;
     691         703 :             stats_.route_stats[table->family()].deleted++;
     692         703 :             break;
     693             : 
     694        4816 :         case DELETE:
     695             : 
     696             :             // This path must be deleted. Hence attr is not required.
     697        4816 :             oper = DBRequest::DB_ENTRY_DELETE;
     698        4816 :             attrs = NULL;
     699        4817 :             stats_.route_stats[table->family()].deleted++;
     700        4830 :             break;
     701             : 
     702        1551 :         case STALE:
     703             : 
     704             :             // We do not support GR for multicast routes (yet).
     705        3105 :             if ((table->family() == Address::ERMVPN) ||
     706        1555 :                     (table->family() == Address::MVPN)) {
     707           0 :                 oper = DBRequest::DB_ENTRY_DELETE;
     708           0 :                 attrs = NULL;
     709           0 :                 stats_.route_stats[table->family()].deleted++;
     710           0 :                 break;
     711             :             }
     712             : 
     713             :             // If path is already marked as stale, then there is no need to
     714             :             // process again. This can happen if the session flips while in
     715             :             // GR_TIMER state.
     716        1553 :             if (path->IsStale())
     717         752 :                 return false;
     718             : 
     719             :             // This path must be marked for staling. Update the local
     720             :             // preference and update the route accordingly.
     721         801 :             oper = DBRequest::DB_ENTRY_ADD_CHANGE;
     722         801 :             attrs = path->GetAttr();
     723         806 :             stale = BgpPath::Stale;
     724         806 :             stats_.route_stats[table->family()].staled++;
     725         806 :             break;
     726             : 
     727           0 :         case LLGR_STALE:
     728             : 
     729             :             // If the path has NO_LLGR community, DELETE it.
     730           0 :             if (path->GetAttr()->community() &&
     731           0 :                 path->GetAttr()->community()->ContainsValue(
     732             :                     CommunityType::NoLlgr)) {
     733           0 :                 oper = DBRequest::DB_ENTRY_DELETE;
     734           0 :                 attrs = NULL;
     735           0 :                 stats_.route_stats[table->family()].deleted++;
     736           0 :                 break;
     737             :             }
     738             : 
     739             :             // If path is already marked as llgr_stale, then there is no
     740             :             // need to process again. This can happen if the session flips
     741             :             // while in LLGR_TIMER state.
     742           0 :             if (path->IsLlgrStale())
     743           0 :                 return false;
     744             : 
     745           0 :             attrs = path->GetAttr();
     746           0 :             stale = BgpPath::LlgrStale;
     747           0 :             oper = DBRequest::DB_ENTRY_ADD_CHANGE;
     748           0 :             stats_.route_stats[table->family()].llgr_staled++;
     749           0 :             break;
     750             :     }
     751             : 
     752             :     // Feed the route modify/delete request to the table input process.
     753       19015 :     return table->InputCommon(root, rt, path, peer_close_->peer(), NULL, oper,
     754        6338 :         attrs, path->GetPathId(), path->GetFlags() | stale, path->GetLabel(),
     755        6338 :         path->GetL3Label());
     756        7170 : }
     757             : 
     758             : //
     759             : // Handler for an Event.
     760             : //
     761        3468 : bool PeerCloseManager::EventCallback(Event *event) {
     762        3468 :     CHECK_CONCURRENCY(peer_close_->GetTaskName());
     763             :     bool result;
     764             : 
     765        3468 :     switch (event->event_type) {
     766           0 :     case EVENT_NONE:
     767           0 :         break;
     768         232 :     case CLOSE:
     769         232 :         Close(event);
     770         232 :         break;
     771         356 :     case EOR_RECEIVED:
     772         356 :         ProcessEORMarkerReceived(event);
     773         356 :         break;
     774         216 :     case MEMBERSHIP_REQUEST:
     775         216 :         MembershipRequest(event);
     776         216 :         break;
     777        2648 :     case MEMBERSHIP_REQUEST_COMPLETE_CALLBACK:
     778        2648 :         result = MembershipRequestCallback(event);
     779             : 
     780             :         // Notify clients if we are no longer using the membership mgr.
     781        2648 :         if (result)
     782         184 :             peer_close_->MembershipRequestCallbackComplete();
     783        2648 :         break;
     784          16 :     case TIMER_CALLBACK:
     785          16 :         RestartTimerCallback(event);
     786          16 :         break;
     787             :     }
     788             : 
     789        3468 :     delete event;
     790        3468 :     return true;
     791             : }

Generated by: LCOV version 1.14