LCOV - code coverage report
Current view: top level - bgp - bgp_membership.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 634 775 81.8 %
Date: 2026-11-16 02:06:09 Functions: 79 89 88.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "bgp/bgp_membership.h"
       7             : 
       8             : #include <boost/foreach.hpp>
       9             : 
      10             : #include "base/task_annotations.h"
      11             : #include "base/task_trigger.h"
      12             : #include "bgp/bgp_export.h"
      13             : #include "bgp/bgp_log.h"
      14             : #include "bgp/bgp_peer_types.h"
      15             : #include "bgp/bgp_route.h"
      16             : #include "bgp/bgp_server.h"
      17             : #include "bgp/bgp_update_sender.h"
      18             : #include "bgp/routing-instance/routing_instance.h"
      19             : 
      20             : using std::list;
      21             : using std::make_pair;
      22             : using std::string;
      23             : using std::vector;
      24             : 
      25             : //
      26             : // Constructor for BgpMembershipManager.
      27             : //
      28          20 : BgpMembershipManager::BgpMembershipManager(BgpServer *server)
      29          20 :     : server_(server),
      30          20 :       walker_(new Walker(this)),
      31          40 :       event_queue_(new WorkQueue<Event *>(
      32          40 :           TaskScheduler::GetInstance()->GetTaskId("bgp::PeerMembership"), 0,
      33          60 :           boost::bind(&BgpMembershipManager::EventCallback, this, _1))) {
      34          20 :     current_jobs_count_ = 0;
      35          20 :     total_jobs_count_ = 0;
      36          20 : }
      37             : 
      38             : //
      39             : // Destructor for BgpMembershipManager.
      40             : //
      41          40 : BgpMembershipManager::~BgpMembershipManager() {
      42          20 :     assert(current_jobs_count_ == 0);
      43          20 :     assert(rib_state_map_.empty());
      44          20 :     assert(peer_state_map_.empty());
      45          40 : }
      46             : 
      47          80 : int BgpMembershipManager::RegisterPeerRegistrationCallback(
      48             :     PeerRegistrationCallback callback) {
      49          80 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
      50             : 
      51          80 :     size_t id = registration_bmap_.find_first();
      52          80 :     if (id == registration_bmap_.npos) {
      53          80 :         id = registration_callbacks_.size();
      54          80 :         registration_callbacks_.push_back(callback);
      55             :     } else {
      56           0 :         registration_bmap_.reset(id);
      57           0 :         if (registration_bmap_.none()) {
      58           0 :             registration_bmap_.clear();
      59             :         }
      60           0 :         registration_callbacks_[id] = callback;
      61             :     }
      62          80 :     return id;
      63          80 : }
      64             : 
      65          80 : void BgpMembershipManager::UnregisterPeerRegistrationCallback(int id) {
      66          80 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
      67             : 
      68          80 :     registration_callbacks_[id] = NULL;
      69          80 :     if ((size_t) id == registration_callbacks_.size() - 1) {
      70         180 :         while (!registration_callbacks_.empty() &&
      71          80 :                registration_callbacks_.back() == NULL) {
      72          80 :             registration_callbacks_.pop_back();
      73             :         }
      74          20 :         if (registration_bmap_.size() > registration_callbacks_.size()) {
      75          20 :             registration_bmap_.resize(registration_callbacks_.size());
      76             :         }
      77             :     } else {
      78          60 :         if ((size_t) id >= registration_bmap_.size()) {
      79          60 :             registration_bmap_.resize(id + 1);
      80             :         }
      81          60 :         registration_bmap_.set(id);
      82             :     }
      83          80 : }
      84             : 
      85        4368 : void BgpMembershipManager::NotifyPeerRegistration(IPeer *peer, BgpTable *table,
      86             :     bool unregister) {
      87        4368 :     CHECK_CONCURRENCY("bgp::PeerMembership");
      88             : 
      89        4368 :     if (!peer->IsXmppPeer())
      90         688 :         return;
      91             : 
      92        3680 :     for (PeerRegistrationListenerList::iterator iter =
      93        3680 :          registration_callbacks_.begin();
      94       18400 :          iter != registration_callbacks_.end(); ++iter) {
      95       14720 :         if (*iter != NULL) {
      96       14720 :             PeerRegistrationCallback callback = *iter;
      97       14720 :             (callback)(peer, table, unregister);
      98       14720 :         }
      99             :     }
     100             : }
     101             : 
     102        2184 : bool BgpMembershipManager::AssertRegister(PeerRibState *prs, bool do_assert) {
     103        2184 :     if (prs->action() != NONE) {
     104           0 :         if (do_assert)
     105           0 :             assert(prs->action() == NONE);
     106           0 :         return false;
     107             :     }
     108             : 
     109        2184 :     if (prs->ribout_registered()) {
     110           0 :         if (do_assert)
     111           0 :             assert(!prs->ribout_registered());
     112           0 :         return false;
     113             :     }
     114             : 
     115        2184 :     return true;
     116             : }
     117             : 
     118             : // Register the IPeer to the BgpTable.
     119             : // Post a REGISTER_RIB event to deal with concurrency issues with RibOut.
     120        2184 : void BgpMembershipManager::Register(IPeer *peer, BgpTable *table,
     121             :     const RibExportPolicy &policy, int instance_id) {
     122        2184 :     CHECK_CONCURRENCY("bgp::Config", "bgp::ConfigHelper",
     123             :         "bgp::StateMachine", "xmpp::StateMachine");
     124             : 
     125        2184 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     126        2184 :     PeerRibState *prs = LocatePeerRibState(peer, table);
     127        2184 :     if (!AssertRegister(prs))
     128           0 :         return;
     129        2184 :     current_jobs_count_++;
     130        2184 :     total_jobs_count_++;
     131        2184 :     prs->set_ribin_registered(true);
     132        2184 :     prs->set_action(RIBOUT_ADD);
     133        2184 :     Event *event = new Event(REGISTER_RIB, peer, table, policy, instance_id);
     134        2184 :     EnqueueEvent(event);
     135        2184 : }
     136             : 
     137         320 : bool BgpMembershipManager::AssertRegisterRibIn(PeerRibState *prs, IPeer *peer,
     138             :                                                bool do_assert) {
     139         320 :     if (prs->action() != NONE) {
     140           0 :         if (do_assert)
     141           0 :             assert(prs->action() == NONE);
     142           0 :         return false;
     143             :     }
     144             : 
     145         320 :     if (prs->ribin_registered() && !peer->IsInGRTimerWaitState()) {
     146           0 :         if (do_assert)
     147           0 :             assert(!prs->ribin_registered() || peer->IsInGRTimerWaitState());
     148           0 :         return false;
     149             :     }
     150             : 
     151         320 :     if (prs->ribout_registered()) {
     152           0 :         if (do_assert)
     153           0 :             assert(!prs->ribout_registered());
     154           0 :         return false;
     155             :     }
     156             : 
     157         320 :     return true;
     158             : }
     159             : 
     160             : // Synchronously register the IPeer to the BgpTable for RIBIN.
     161         320 : void BgpMembershipManager::RegisterRibIn(IPeer *peer, BgpTable *table) {
     162         320 :     CHECK_CONCURRENCY("bgp::Config", "bgp::ConfigHelper",
     163             :         "bgp::StateMachine", "xmpp::StateMachine");
     164             : 
     165         320 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     166         320 :     PeerRibState *prs = LocatePeerRibState(peer, table);
     167         320 :     if (!AssertRegisterRibIn(prs, peer))
     168           0 :         return;
     169         320 :     prs->set_ribin_registered(true);
     170         320 : }
     171             : 
     172        2128 : bool BgpMembershipManager::AssertUnregister(PeerRibState *prs, bool do_assert) {
     173        2128 :     if (!prs || prs->action() != NONE) {
     174           0 :         if (do_assert)
     175           0 :             assert(prs && prs->action() == NONE);
     176           0 :         return false;
     177             :     }
     178             : 
     179        2128 :     if (!prs->ribin_registered()) {
     180           0 :         if (do_assert)
     181           0 :             assert(prs->ribin_registered());
     182           0 :         return false;
     183             :     }
     184             : 
     185        2128 :     return true;
     186             : }
     187             : 
     188             : // Unregister the IPeer from the BgpTable.
     189             : // Post an UNREGISTER_RIB event to deal with concurrency issues with RibOut.
     190        2128 : void BgpMembershipManager::Unregister(IPeer *peer, BgpTable *table) {
     191        2128 :     CHECK_CONCURRENCY("bgp::Config", "bgp::StateMachine", "xmpp::StateMachine");
     192             : 
     193        2128 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     194        2128 :     PeerRibState *prs = FindPeerRibState(peer, table);
     195        2128 :     if (!AssertUnregister(prs))
     196           0 :         return;
     197             : 
     198        2128 :     current_jobs_count_++;
     199        2128 :     total_jobs_count_++;
     200             : 
     201        2128 :     if (!prs->ribout_registered()) {
     202         184 :         UnregisterRibInUnlocked(prs);
     203         184 :         return;
     204             :     }
     205             : 
     206        1944 :     prs->set_action(RIBIN_DELETE_RIBOUT_DELETE);
     207        1944 :     prs->set_ribin_registered(false);
     208        1944 :     prs->set_instance_id(-1);
     209        1944 :     prs->set_subscription_gen_id(0);
     210        1944 :     Event *event = new Event(UNREGISTER_RIB, peer, table);
     211        1944 :     EnqueueEvent(event);
     212        2128 : }
     213             : 
     214             : //
     215             : // Unregister the IPeer from the BgpTable for RIBIN.
     216             : //
     217          32 : void BgpMembershipManager::UnregisterRibIn(IPeer *peer, BgpTable *table) {
     218          32 :     CHECK_CONCURRENCY("bgp::Config", "bgp::StateMachine", "xmpp::StateMachine");
     219             : 
     220          32 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     221          32 :     current_jobs_count_++;
     222          32 :     total_jobs_count_++;
     223          32 :     PeerRibState *prs = FindPeerRibState(peer, table);
     224          32 :     assert(prs && prs->action() == NONE);
     225          32 :     assert(prs->ribin_registered() && !prs->ribout_registered());
     226          32 :     UnregisterRibInUnlocked(prs);
     227          32 : }
     228             : 
     229             : //
     230             : // Common routine to handle unregister of IPeer from Table for RIBIN.
     231             : //
     232         216 : void BgpMembershipManager::UnregisterRibInUnlocked(PeerRibState *prs) {
     233         216 :     prs->set_ribin_registered(false);
     234         216 :     prs->set_instance_id(-1);
     235         216 :     prs->set_subscription_gen_id(0);
     236         216 :     prs->set_action(RIBIN_DELETE);
     237         216 :     prs->UnregisterRibIn();
     238         584 :     BGP_LOG_PEER_TABLE(prs->peer(), SandeshLevel::SYS_DEBUG,
     239             :         BGP_LOG_FLAG_SYSLOG, prs->table(),
     240             :         "Unregister table requested for action " << prs->action());
     241         216 : }
     242             : 
     243             : //
     244             : // Unregister the IPeer from the BgpTable.
     245             : // Post an UNREGISTER_RIB event to deal with concurrency issues with RibOut.
     246             : // The action is set to RIBIN_WALK_RIBOUT_DELETE.
     247             : // This API is to be used when handling graceful restart of the peer.
     248             : //
     249         240 : void BgpMembershipManager::UnregisterRibOut(IPeer *peer, BgpTable *table) {
     250         240 :     CHECK_CONCURRENCY("bgp::Config", "bgp::StateMachine", "xmpp::StateMachine");
     251             : 
     252         240 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     253         240 :     current_jobs_count_++;
     254         240 :     total_jobs_count_++;
     255         240 :     PeerRibState *prs = FindPeerRibState(peer, table);
     256         240 :     assert(prs && prs->action() == NONE);
     257         240 :     assert(prs->ribin_registered());
     258         240 :     assert(prs->ribout_registered());
     259         240 :     prs->set_instance_id(-1);
     260         240 :     prs->set_subscription_gen_id(0);
     261         240 :     prs->set_action(RIBIN_WALK_RIBOUT_DELETE);
     262         240 :     Event *event = new Event(UNREGISTER_RIB, peer, table);
     263         240 :     EnqueueEvent(event);
     264         240 : }
     265             : 
     266         432 : bool BgpMembershipManager::AssertWalkRibIn(PeerRibState *prs, bool do_assert) {
     267         432 :     if (!prs || prs->action() != NONE) {
     268           0 :         if (do_assert)
     269           0 :             assert(prs && prs->action() == NONE);
     270           0 :         return false;
     271             :     }
     272             : 
     273         432 :     if (!prs->ribin_registered()) {
     274           0 :         if (do_assert)
     275           0 :             assert(prs->ribin_registered());
     276           0 :         return false;
     277             :     }
     278             : 
     279         432 :     return true;
     280             : }
     281             : 
     282             : //
     283             : // Trigger a walk of IPeer's RIBIN for the BgpTable.
     284             : // This API can be used when sweeping paths as part of graceful restart.
     285             : // It can also be used in future when re-evaluating import policy for a peer.
     286             : //
     287         432 : void BgpMembershipManager::WalkRibIn(IPeer *peer, BgpTable *table) {
     288         432 :     CHECK_CONCURRENCY("bgp::Config", "bgp::StateMachine", "xmpp::StateMachine");
     289             : 
     290         432 :     tbb::spin_rw_mutex::scoped_lock write_lock(rw_mutex_, true);
     291         432 :     PeerRibState *prs = FindPeerRibState(peer, table);
     292         432 :     if (!AssertWalkRibIn(prs))
     293           0 :         return;
     294         432 :     current_jobs_count_++;
     295         432 :     total_jobs_count_++;
     296         432 :     prs->set_action(RIBIN_WALK);
     297         432 :     prs->WalkRibIn();
     298        1232 :     BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     299             :         table, "Walk table requested for action " << prs->action());
     300         432 : }
     301             : 
     302             : //
     303             : // Fill in the registration info of the IPeer for the BgpTable.
     304             : // Return true if the IPeer is registered with the BgpTable, false otherwise.
     305             : //
     306        2512 : bool BgpMembershipManager::GetRegistrationInfo(
     307             :     const IPeer *peer, const BgpTable *table,
     308             :     int *instance_id, uint64_t *subscription_gen_id) const {
     309        2512 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     310        2512 :     const PeerRibState *prs = FindPeerRibState(peer, table);
     311        2511 :     if (!prs)
     312         720 :         return false;
     313        1791 :     if (instance_id)
     314        1791 :         *instance_id = prs->instance_id();
     315        1791 :     if (subscription_gen_id)
     316        1791 :         *subscription_gen_id = prs->subscription_gen_id();
     317        1791 :     return true;
     318        2511 : }
     319             : 
     320             : //
     321             : // Update the registration info of the IPeer for the BgpTable.
     322             : //
     323        1839 : void BgpMembershipManager::SetRegistrationInfo(
     324             :     const IPeer *peer, const BgpTable *table,
     325             :     int instance_id, uint64_t subscription_gen_id) {
     326        1839 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     327        1840 :     PeerRibState *prs = FindPeerRibState(peer, table);
     328        1838 :     if (!prs)
     329           0 :         return;
     330        1838 :     prs->set_instance_id(instance_id);
     331        1838 :     prs->set_subscription_gen_id(subscription_gen_id);
     332        1838 : }
     333             : 
     334             : //
     335             : // Return true if the IPeer is registered to the BgpTable.
     336             : //
     337        2648 : bool BgpMembershipManager::IsRegistered(const IPeer *peer,
     338             :     const BgpTable *table) const {
     339        2648 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     340        2648 :     const PeerRibState *prs = FindPeerRibState(peer, table);
     341        5296 :     return (prs && prs->ribin_registered() && prs->ribout_registered());
     342        2648 : }
     343             : 
     344             : //
     345             : // Return true if the IPeer is registered to the BgpTable for RibIn.
     346             : //
     347         424 : bool BgpMembershipManager::IsRibInRegistered(const IPeer *peer,
     348             :     const BgpTable *table) const {
     349         424 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     350         424 :     const PeerRibState *prs = FindPeerRibState(peer, table);
     351         848 :     return (prs && prs->ribin_registered());
     352         424 : }
     353             : 
     354             : //
     355             : // Return true if the IPeer is registered to the BgpTable for RibOut.
     356             : //
     357        1836 : bool BgpMembershipManager::IsRibOutRegistered(const IPeer *peer,
     358             :     const BgpTable *table) const {
     359        1836 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     360        1840 :     const PeerRibState *prs = FindPeerRibState(peer, table);
     361        3678 :     return (prs && prs->ribout_registered());
     362        1838 : }
     363             : 
     364             : //
     365             : // Return RibOut's output queue depth.
     366             : //
     367           0 : uint32_t BgpMembershipManager::GetRibOutQueueDepth(const IPeer *peer,
     368             :     const BgpTable *table) const {
     369           0 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     370           0 :     const PeerRibState *prs = FindPeerRibState(peer, table);
     371           0 :     if (!prs || !prs->ribout_registered())
     372           0 :         return 0;
     373           0 :     RibOut *ribout = prs->ribout();
     374           0 :     if (!ribout)
     375           0 :         return 0;
     376           0 :     return ribout->GetQueueSize();
     377           0 : }
     378             : 
     379             : //
     380             : // Fill in the list of registered BgpTables for given IPeer.
     381             : //
     382         248 : void BgpMembershipManager::GetRegisteredRibs(const IPeer *peer,
     383             :     list<BgpTable *> *table_list) const {
     384         248 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     385         248 :     table_list->clear();
     386         248 :     const PeerState *ps = FindPeerState(peer);
     387         248 :     if (ps)
     388         184 :         ps->GetRegisteredRibs(table_list);
     389         248 : }
     390             : 
     391             : //
     392             : //
     393             : // Fill membership introspect information for a BgpTable.
     394             : //
     395           0 : void BgpMembershipManager::FillRoutingInstanceTableInfo(
     396             :     ShowRoutingInstanceTable *srit, const BgpTable *table) const {
     397           0 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     398           0 :     BgpTable *nc_table = const_cast<BgpTable *>(table);
     399           0 :     const RibState *rs = FindRibState(nc_table);
     400           0 :     if (rs)
     401           0 :         rs->FillRoutingInstanceTableInfo(srit);
     402           0 : }
     403             : 
     404             : //
     405             : // Fill membership introspect information for an IPeer.
     406             : //
     407           0 : void BgpMembershipManager::FillPeerMembershipInfo(const IPeer *peer,
     408             :         BgpNeighborResp *resp) const {
     409           0 :     tbb::spin_rw_mutex::scoped_lock read_lock(rw_mutex_, false);
     410           0 :     assert(resp->get_routing_tables().empty());
     411           0 :     IPeer *nc_peer = const_cast<IPeer *>(peer);
     412             : 
     413           0 :     BgpUpdateSender *sender = server_->update_sender();
     414           0 :     if (sender->PeerIsRegistered(nc_peer)) {
     415           0 :         resp->set_send_state(
     416           0 :             sender->PeerInSync(nc_peer) ? "in sync" : "not in sync");
     417             :     } else {
     418           0 :         resp->set_send_state("not advertising");
     419             :     }
     420             : 
     421           0 :     const PeerState *ps = FindPeerState(nc_peer);
     422           0 :     if (ps)
     423           0 :         ps->FillPeerMembershipInfo(resp);
     424           0 : }
     425             : 
     426             : //
     427             : // Return true if no pending work in the BgpMembershipManager itself and
     428             : // in the Walker.
     429             : //
     430        4192 : bool BgpMembershipManager::IsQueueEmpty() const {
     431        4192 :     return (event_queue_->IsQueueEmpty() && walker_->IsQueueEmpty());
     432             : }
     433             : 
     434             : //
     435             : // Return number of PeerRibStates.
     436             : //
     437           0 : size_t BgpMembershipManager::GetMembershipCount() const {
     438           0 :     size_t count = 0;
     439           0 :     for (PeerStateMap::const_iterator loc = peer_state_map_.begin();
     440           0 :          loc != peer_state_map_.end(); ++loc) {
     441           0 :         const PeerState *ps = loc->second;
     442           0 :         count += ps->GetMembershipCount();
     443             :     }
     444           0 :     return count;
     445             : }
     446             : 
     447             : //
     448             : // Find or create the PeerState for given IPeer.
     449             : //
     450        2504 : BgpMembershipManager::PeerState *BgpMembershipManager::LocatePeerState(
     451             :     IPeer *peer) {
     452        2504 :     PeerStateMap::iterator loc = peer_state_map_.find(peer);
     453        2504 :     if (loc == peer_state_map_.end()) {
     454         144 :         PeerState *ps = new PeerState(this, peer);
     455         144 :         peer_state_map_.insert(make_pair(peer, ps));
     456         144 :         return ps;
     457             :     } else {
     458        2360 :         return loc->second;
     459             :     }
     460             : }
     461             : 
     462             : //
     463             : // Find the PeerState for given IPeer.
     464             : //
     465       14056 : BgpMembershipManager::PeerState *BgpMembershipManager::FindPeerState(
     466             :     const IPeer *peer) {
     467       14056 :     PeerStateMap::iterator loc = peer_state_map_.find(peer);
     468       14054 :     return (loc != peer_state_map_.end() ? loc->second : NULL);
     469             : }
     470             : 
     471             : //
     472             : // Find the PeerState for given IPeer.
     473             : // Const version.
     474             : //
     475        7672 : const BgpMembershipManager::PeerState *BgpMembershipManager::FindPeerState(
     476             :     const IPeer *peer) const {
     477        7672 :     PeerStateMap::const_iterator loc = peer_state_map_.find(peer);
     478        7667 :     return (loc != peer_state_map_.end() ? loc->second : NULL);
     479             : }
     480             : 
     481             : //
     482             : // Destroy the given PeerState.
     483             : //
     484         144 : void BgpMembershipManager::DestroyPeerState(PeerState *ps) {
     485         144 :     peer_state_map_.erase(ps->peer());
     486         144 :     delete ps;
     487         144 : }
     488             : 
     489             : //
     490             : // Find or create the RibState for given BgpTable.
     491             : //
     492        2504 : BgpMembershipManager::RibState *BgpMembershipManager::LocateRibState(
     493             :     BgpTable *table) {
     494        2504 :     RibStateMap::iterator loc = rib_state_map_.find(table);
     495        2502 :     if (loc == rib_state_map_.end()) {
     496         689 :         RibState *rs = new RibState(this, table);
     497         689 :         rib_state_map_.insert(make_pair(table, rs));
     498         689 :         return rs;
     499             :     } else {
     500        1815 :         return loc->second;
     501             :     }
     502             : }
     503             : 
     504             : //
     505             : // Find the RibState for given BgpTable.
     506             : //
     507       14054 : BgpMembershipManager::RibState *BgpMembershipManager::FindRibState(
     508             :     const BgpTable *table) {
     509       14054 :     RibStateMap::iterator loc = rib_state_map_.find(table);
     510       14054 :     return (loc != rib_state_map_.end() ? loc->second : NULL);
     511             : }
     512             : 
     513             : //
     514             : // Find the RibState for given BgpTable.
     515             : // Const version.
     516             : //
     517        7419 : const BgpMembershipManager::RibState *BgpMembershipManager::FindRibState(
     518             :     const BgpTable *table) const {
     519        7419 :     RibStateMap::const_iterator loc = rib_state_map_.find(table);
     520        7419 :     return (loc != rib_state_map_.end() ? loc->second : NULL);
     521             : }
     522             : 
     523             : //
     524             : // Destroy the given RibState.
     525             : //
     526         689 : void BgpMembershipManager::DestroyRibState(RibState *rs) {
     527         689 :     rib_state_map_.erase(rs->table());
     528         689 :     delete rs;
     529         689 : }
     530             : 
     531             : //
     532             : // Request the Walker to schedule a table walk for the given RibState.
     533             : // Note that the Walker accumulates requests and starts walks asynchronously.
     534             : //
     535        5016 : void BgpMembershipManager::EnqueueRibState(RibState *rs) {
     536        5016 :     walker_->Enqueue(rs);
     537        5016 : }
     538             : 
     539             : //
     540             : // Find or create the PeerRibState for given (IPeer, BgpTable).
     541             : //
     542        2504 : BgpMembershipManager::PeerRibState *BgpMembershipManager::LocatePeerRibState(
     543             :     IPeer *peer, BgpTable *table) {
     544        2504 :     PeerState *ps = LocatePeerState(peer);
     545        2504 :     RibState *rs = LocateRibState(table);
     546        2504 :     PeerRibState *prs = ps->LocatePeerRibState(rs);
     547        2504 :     rs->InsertPeerRibState(prs);
     548        2504 :     return prs;
     549             : }
     550             : 
     551             : //
     552             : // Find the PeerRibState for given (IPeer, BgpTable).
     553             : //
     554       14056 : BgpMembershipManager::PeerRibState *BgpMembershipManager::FindPeerRibState(
     555             :     const IPeer *peer, const BgpTable *table) {
     556       14056 :     PeerState *ps = FindPeerState(peer);
     557       14054 :     RibState *rs = FindRibState(table);
     558       14054 :     return (ps && rs ? ps->FindPeerRibState(rs) : NULL);
     559             : }
     560             : 
     561             : //
     562             : // Find the PeerRibState for given (IPeer, BgpTable).
     563             : // Const version.
     564             : //
     565             : const BgpMembershipManager::PeerRibState *
     566        7424 : BgpMembershipManager::FindPeerRibState(
     567             :     const IPeer *peer, const BgpTable *table) const {
     568        7424 :     const PeerState *ps = FindPeerState(peer);
     569        7419 :     const RibState *rs = FindRibState(table);
     570        7418 :     return (ps && rs ? ps->FindPeerRibState(rs) : NULL);
     571             : }
     572             : 
     573             : //
     574             : // Destroy the given PeerRibState.
     575             : // Also destroy the PeerState and/or RibState if they are no longer required.
     576             : //
     577        2160 : void BgpMembershipManager::DestroyPeerRibState(PeerRibState *prs) {
     578        2160 :     PeerState *ps = prs->peer_state();
     579        2160 :     RibState *rs = prs->rib_state();
     580        2160 :     if (ps->RemovePeerRibState(prs))
     581         144 :         DestroyPeerState(ps);
     582        2160 :     if (rs->RemovePeerRibState(prs))
     583         689 :         DestroyRibState(rs);
     584        2160 :     delete prs;
     585        2160 : }
     586             : 
     587             : //
     588             : // Trigger REGISTER_RIB_COMPLETE event.
     589             : //
     590        2184 : void BgpMembershipManager::TriggerRegisterRibCompleteEvent(IPeer *peer,
     591             :     BgpTable *table) {
     592        2184 :     Event *event = new Event(REGISTER_RIB_COMPLETE, peer, table);
     593        2184 :     EnqueueEvent(event);
     594        2184 : }
     595             : 
     596             : //
     597             : // Trigger UNREGISTER_RIB_COMPLETE event.
     598             : //
     599        2184 : void BgpMembershipManager::TriggerUnregisterRibCompleteEvent(IPeer *peer,
     600             :     BgpTable *table) {
     601        2184 :     Event *event = new Event(UNREGISTER_RIB_COMPLETE, peer, table);
     602        2184 :     EnqueueEvent(event);
     603        2184 : }
     604             : 
     605             : //
     606             : // Trigger WALK_RIB_COMPLETE event.
     607             : //
     608         648 : void BgpMembershipManager::TriggerWalkRibCompleteEvent(IPeer *peer,
     609             :     BgpTable *table) {
     610         648 :     Event *event = new Event(WALK_RIB_COMPLETE, peer, table);
     611         648 :     EnqueueEvent(event);
     612         648 : }
     613             : 
     614             : //
     615             : // Process REGISTER_RIB event.
     616             : //
     617        2184 : void BgpMembershipManager::ProcessRegisterRibEvent(Event *event) {
     618        2184 :     IPeer *peer = event->peer;
     619        2184 :     BgpTable *table = event->table;
     620        2184 :     PeerRibState *prs = FindPeerRibState(peer, table);
     621        2184 :     assert(prs && prs->action() == RIBOUT_ADD);
     622        2184 :     assert(prs->ribin_registered());
     623        2184 :     prs->set_instance_id(event->instance_id);
     624             : 
     625             :     // Notify completion right away if the table is marked for deletion.
     626             :     // Mark the ribout as registered even though no RibOut gets created.
     627             :     // The unregister code path handles a PeerRibState without a RibOut.
     628        2184 :     if (table->IsDeleted()) {
     629           0 :         prs->set_ribout_registered(true);
     630           0 :         prs->clear_action();
     631           0 :         peer->MembershipRequestCallback(table);
     632           0 :         current_jobs_count_--;
     633           0 :         return;
     634             :     }
     635             : 
     636        2184 :     prs->RegisterRibOut(event->policy);
     637        3096 :     BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     638             :         table, "Register table requested for action " << prs->action());
     639             : }
     640             : 
     641             : 
     642             : //
     643             : // Process REGISTER_RIB_COMPLETE event.
     644             : //
     645        2184 : void BgpMembershipManager::ProcessRegisterRibCompleteEvent(Event *event) {
     646        2184 :     IPeer *peer = event->peer;
     647        2184 :     BgpTable *table = event->table;
     648        2184 :     PeerRibState *prs = FindPeerRibState(peer, table);
     649        2184 :     assert(prs && prs->action() == RIBOUT_ADD);
     650        2184 :     assert(prs->ribin_registered());
     651        2184 :     assert(prs->ribout_registered());
     652        3096 :     BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     653             :         table, "Register table completed for action " << prs->action());
     654        2184 :     prs->clear_action();
     655        2184 :     peer->MembershipRequestCallback(table);
     656        2184 :     NotifyPeerRegistration(peer, table, false);
     657        2184 :     current_jobs_count_--;
     658        2184 : }
     659             : 
     660             : //
     661             : // Process UNREGISTER_RIB event.
     662             : //
     663        2184 : void BgpMembershipManager::ProcessUnregisterRibEvent(Event *event) {
     664        2184 :     IPeer *peer = event->peer;
     665        2184 :     BgpTable *table = event->table;
     666        2184 :     PeerRibState *prs = FindPeerRibState(peer, table);
     667        2184 :     assert(prs);
     668        2184 :     assert(prs->action() == RIBIN_DELETE_RIBOUT_DELETE ||
     669             :         prs->action() == RIBIN_WALK_RIBOUT_DELETE);
     670        2184 :     if (prs->action() == RIBIN_DELETE_RIBOUT_DELETE)
     671        1944 :         assert(!prs->ribin_registered());
     672        2184 :     if (prs->action() == RIBIN_WALK_RIBOUT_DELETE)
     673         240 :         assert(prs->ribin_registered());
     674        2184 :     assert(prs->ribout_registered());
     675             : 
     676        2184 :     prs->DeactivateRibOut();
     677        3096 :     BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     678             :         table, "Unregister table requested for action " << prs->action());
     679        2184 : }
     680             : 
     681             : //
     682             : // Process UNREGISTER_RIB_COMPLETE event.
     683             : //
     684        2184 : void BgpMembershipManager::ProcessUnregisterRibCompleteEvent(Event *event) {
     685        2184 :     IPeer *peer = event->peer;
     686        2184 :     BgpTable *table = event->table;
     687        2184 :     PeerRibState *prs = FindPeerRibState(peer, table);
     688        2184 :     assert(prs);
     689        2184 :     assert(prs->action() == RIBIN_DELETE_RIBOUT_DELETE ||
     690             :         prs->action() == RIBIN_WALK_RIBOUT_DELETE);
     691        2184 :     if (prs->action() == RIBIN_DELETE_RIBOUT_DELETE)
     692        1944 :         assert(!prs->ribin_registered());
     693        2184 :     if (prs->action() == RIBIN_WALK_RIBOUT_DELETE)
     694         240 :         assert(prs->ribin_registered());
     695             : 
     696        2184 :     prs->UnregisterRibOut();
     697        3096 :     BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     698             :         table, "Unregister table completed for action " << prs->action());
     699        2184 :     prs->clear_action();
     700        2184 :     if (!prs->ribin_registered() && !prs->ribout_registered())
     701        1944 :         DestroyPeerRibState(prs);
     702             : 
     703        2184 :     peer->MembershipRequestCallback(table);
     704        2184 :     NotifyPeerRegistration(peer, table, true);
     705        2184 :     current_jobs_count_--;
     706        2184 : }
     707             : 
     708             : //
     709             : // Process WALK_RIB_COMPLETE event.
     710             : //
     711         648 : void BgpMembershipManager::ProcessWalkRibCompleteEvent(Event *event) {
     712         648 :     IPeer *peer = event->peer;
     713         648 :     BgpTable *table = event->table;
     714         648 :     PeerRibState *prs = FindPeerRibState(peer, table);
     715         648 :     assert(prs);
     716         648 :     assert(prs->action() == RIBIN_WALK || prs->action() == RIBIN_DELETE);
     717         648 :     if (prs->action() == RIBIN_WALK) {
     718         432 :         assert(prs->ribin_registered());
     719        1232 :         BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     720             :             table, "Walk table completed for action " << prs->action());
     721             :     } else {
     722         216 :         assert(!prs->ribin_registered());
     723         584 :         BGP_LOG_PEER_TABLE(peer, SandeshLevel::SYS_DEBUG, BGP_LOG_FLAG_SYSLOG,
     724             :             table, "Unregister table completed for action " << prs->action());
     725             :     }
     726         648 :     prs->clear_action();
     727         648 :     if (!prs->ribin_registered() && !prs->ribout_registered())
     728         216 :         DestroyPeerRibState(prs);
     729         648 :     peer->MembershipRequestCallback(table);
     730         648 :     current_jobs_count_--;
     731         648 : }
     732             : 
     733             : //
     734             : // Internal handler for an Event.
     735             : // Exists so that test code can override it.
     736             : //
     737        9384 : bool BgpMembershipManager::EventCallbackInternal(Event *event) {
     738        9384 :     switch (event->event_type) {
     739        2184 :     case REGISTER_RIB:
     740        2184 :         ProcessRegisterRibEvent(event);
     741        2184 :         break;
     742        2184 :     case REGISTER_RIB_COMPLETE:
     743        2184 :         ProcessRegisterRibCompleteEvent(event);
     744        2184 :         break;
     745        2184 :     case UNREGISTER_RIB:
     746        2184 :         ProcessUnregisterRibEvent(event);
     747        2184 :         break;
     748        2184 :     case UNREGISTER_RIB_COMPLETE:
     749        2184 :         ProcessUnregisterRibCompleteEvent(event);
     750        2184 :         break;
     751         648 :     case WALK_RIB_COMPLETE:
     752         648 :         ProcessWalkRibCompleteEvent(event);
     753         648 :         break;
     754           0 :     default:
     755           0 :         assert(false);
     756             :         break;
     757             :     }
     758             : 
     759        9384 :     delete event;
     760        9384 :     return true;
     761             : }
     762             : 
     763             : //
     764             : // Handler for an Event.
     765             : //
     766        9384 : bool BgpMembershipManager::EventCallback(Event *event) {
     767        9384 :     CHECK_CONCURRENCY("bgp::PeerMembership");
     768        9384 :     return EventCallbackInternal(event);
     769             : }
     770             : 
     771             : //
     772             : // Constructor.
     773             : //`
     774        7200 : BgpMembershipManager::Event::Event(EventType event_type, IPeer *peer,
     775        7200 :     BgpTable *table)
     776        7200 :     : event_type(event_type),
     777        7200 :       peer(peer),
     778        7200 :       table(table),
     779        7200 :       instance_id(-1) {
     780        7200 : }
     781             : 
     782             : //
     783             : // Constructor.
     784             : //`
     785        2184 : BgpMembershipManager::Event::Event(EventType event_type, IPeer *peer,
     786        2184 :     BgpTable *table, const RibExportPolicy &policy, int instance_id)
     787        2184 :     : event_type(event_type),
     788        2184 :       peer(peer),
     789        2184 :       table(table),
     790        2184 :       policy(policy),
     791        2184 :       instance_id(instance_id) {
     792        2184 : }
     793             : 
     794             : //
     795             : // Constructor.
     796             : //`
     797         144 : BgpMembershipManager::PeerState::PeerState(BgpMembershipManager *manager,
     798         144 :     IPeer *peer)
     799         144 :     : manager_(manager),
     800         144 :       peer_(peer) {
     801         144 : }
     802             : 
     803             : //
     804             : // Destructor.
     805             : //`
     806         144 : BgpMembershipManager::PeerState::~PeerState() {
     807         144 :     assert(rib_map_.empty());
     808         144 : }
     809             : 
     810             : //
     811             : // Find or create the PeerRibState for given RibState.
     812             : //
     813             : BgpMembershipManager::PeerRibState *
     814        2504 : BgpMembershipManager::PeerState::LocatePeerRibState(RibState *rs) {
     815        2504 :     PeerRibStateMap::iterator loc = rib_map_.find(rs);
     816        2504 :     if (loc == rib_map_.end()) {
     817        2160 :         PeerRibState *prs = new PeerRibState(manager_, this, rs);
     818        2160 :         rib_map_.insert(make_pair(rs, prs));
     819        2160 :         return prs;
     820             :     } else {
     821         344 :         return loc->second;
     822             :     }
     823             : }
     824             : 
     825             : //
     826             : // Find the PeerRibState for given RibState.
     827             : //
     828             : BgpMembershipManager::PeerRibState *
     829       14054 : BgpMembershipManager::PeerState::FindPeerRibState(const RibState *rs) {
     830       14054 :     PeerRibStateMap::iterator loc = rib_map_.find(rs);
     831       14054 :     return (loc != rib_map_.end() ? loc->second : NULL);
     832             : }
     833             : 
     834             : //
     835             : // Find the PeerRibState for given RibState.
     836             : // Const version.
     837             : //
     838             : const BgpMembershipManager::PeerRibState *
     839        7418 : BgpMembershipManager::PeerState::FindPeerRibState(const RibState *rs) const {
     840        7418 :     PeerRibStateMap::const_iterator loc = rib_map_.find(rs);
     841        7422 :     return (loc != rib_map_.end() ? loc->second : NULL);
     842             : }
     843             : 
     844             : //
     845             : // Remove given PeerRibState from PeerRibStateMap.
     846             : // Return true if the PeerState itself can we deleted.
     847             : //
     848        2160 : bool BgpMembershipManager::PeerState::RemovePeerRibState(PeerRibState *prs) {
     849        2160 :     PeerRibStateMap::iterator loc = rib_map_.find(prs->rib_state());
     850        2160 :     if (loc != rib_map_.end())
     851        2160 :         rib_map_.erase(loc);
     852        4320 :     return rib_map_.empty();
     853             : }
     854             : 
     855             : //
     856             : // Fill in the list of registered BgpTables.
     857             : //
     858         184 : void BgpMembershipManager::PeerState::GetRegisteredRibs(
     859             :     list<BgpTable *> *table_list) const {
     860         184 :     for (PeerRibStateMap::const_iterator loc = rib_map_.begin();
     861        2832 :          loc != rib_map_.end(); ++loc) {
     862        2648 :         const RibState *rs = loc->first;
     863        2648 :         table_list->push_back(rs->table());
     864             :     }
     865         184 : }
     866             : 
     867             : //
     868             : // Fill introspect information.
     869             : //
     870           0 : void BgpMembershipManager::PeerState::FillPeerMembershipInfo(
     871             :     BgpNeighborResp *resp) const {
     872           0 :     vector<BgpNeighborRoutingTable> table_list;
     873           0 :     for (PeerRibStateMap::const_iterator loc = rib_map_.begin();
     874           0 :          loc != rib_map_.end(); ++loc) {
     875           0 :         const RibState *rs = loc->first;
     876           0 :         BgpNeighborRoutingTable table;
     877           0 :         table.set_name(rs->table()->name());
     878           0 :         table.set_current_state("subscribed");
     879           0 :         table_list.push_back(table);
     880           0 :     }
     881           0 :     resp->set_routing_tables(table_list);
     882           0 : }
     883             : 
     884             : //
     885             : // Constructor.
     886             : //
     887         689 : BgpMembershipManager::RibState::RibState(BgpMembershipManager *manager,
     888         689 :     BgpTable *table)
     889         689 :     : manager_(manager),
     890         689 :       table_(table),
     891         689 :       request_count_(0),
     892         689 :       walk_count_(0),
     893         689 :       table_delete_ref_(this, table->deleter()) {
     894         689 : }
     895             : 
     896             : //
     897             : // Destructor.
     898             : //
     899         689 : BgpMembershipManager::RibState::~RibState() {
     900         689 :     assert(peer_rib_list_.empty());
     901         689 :     assert(pending_peer_rib_list_.empty());
     902         689 : }
     903             : 
     904             : //
     905             : // Enqueue given PeerRibState into the pending PeerRibStateList.
     906             : //
     907        5016 : void BgpMembershipManager::RibState::EnqueuePeerRibState(PeerRibState *prs) {
     908        5016 :     request_count_++;
     909        5016 :     pending_peer_rib_list_.insert(prs);
     910        5016 :     manager_->EnqueueRibState(this);
     911        5016 : }
     912             : 
     913             : //
     914             : // Clear the pending PeerRibStateList.
     915             : //
     916        3646 : void BgpMembershipManager::RibState::ClearPeerRibStateList() {
     917        3646 :     pending_peer_rib_list_.clear();
     918        3646 : }
     919             : 
     920             : //
     921             : // Insert given PeerRibState into the regular PeerRibStateList.
     922             : //
     923        2504 : void BgpMembershipManager::RibState::InsertPeerRibState(PeerRibState *prs) {
     924        2504 :     peer_rib_list_.insert(prs);
     925        2504 : }
     926             : 
     927             : //
     928             : // Remove given PeerRibState from the regular PeerRibStateList.
     929             : //
     930        2160 : bool BgpMembershipManager::RibState::RemovePeerRibState(PeerRibState *prs) {
     931        2160 :     peer_rib_list_.erase(prs);
     932        2160 :     return peer_rib_list_.empty();
     933             : }
     934             : 
     935             : //
     936             : // Fill introspect information.
     937             : //
     938           0 : void BgpMembershipManager::RibState::FillRoutingInstanceTableInfo(
     939             :     ShowRoutingInstanceTable *srit) const {
     940           0 :     ShowTableMembershipInfo stmi;
     941           0 :     stmi.set_requests(request_count_);
     942           0 :     stmi.set_walks(walk_count_);
     943           0 :     vector<ShowMembershipPeerInfo> peers;
     944           0 :     for (PeerRibList::const_iterator it = peer_rib_list_.begin();
     945           0 :          it != peer_rib_list_.end(); ++it) {
     946           0 :         const PeerRibState *prs = *it;
     947           0 :         ShowMembershipPeerInfo smpi;
     948           0 :         prs->FillMembershipInfo(&smpi);
     949           0 :         peers.push_back(smpi);
     950           0 :     }
     951           0 :     stmi.set_peers(peers);
     952           0 :     srit->set_membership(stmi);
     953           0 : }
     954             : 
     955             : //
     956             : // Constructor.
     957             : //
     958        2160 : BgpMembershipManager::PeerRibState::PeerRibState(BgpMembershipManager *manager,
     959        2160 :     PeerState *ps, RibState *rs)
     960        2160 :     : manager_(manager),
     961        2160 :       ps_(ps),
     962        2160 :       rs_(rs),
     963        2160 :       ribout_(NULL),
     964        2160 :       ribout_index_(-1),
     965        2160 :       action_(BgpMembershipManager::NONE),
     966        2160 :       ribin_registered_(false),
     967        2160 :       ribout_registered_(false),
     968        2160 :       instance_id_(-1),
     969        2160 :       subscription_gen_id_(0) {
     970        2160 : }
     971             : 
     972             : //
     973             : // Destructor.
     974             : //
     975        2160 : BgpMembershipManager::PeerRibState::~PeerRibState() {
     976        2160 :     assert(!ribout_);
     977        2160 :     assert(ribout_index_ == -1);
     978        2160 :     assert(action_ == BgpMembershipManager::NONE);
     979        2160 :     assert(!ribin_registered_);
     980        2160 :     assert(!ribout_registered_);
     981        2160 :     assert(instance_id_ == -1);
     982        2160 :     assert(subscription_gen_id_ == 0);
     983        2160 : }
     984             : 
     985             : //
     986             : // Create RibOut for this PeerRibState and registers the RibOut as a listener
     987             : // for the BgpTable.
     988             : //
     989             : // Register the IPeer to the RibOut.
     990             : // This PeerRibState is added to the pending PeerRibStateList of RibState
     991             : // so that Join processing is handled when walking the BgpTable.
     992             : //
     993        2184 : void BgpMembershipManager::PeerRibState::RegisterRibOut(
     994             :     const RibExportPolicy &policy) {
     995        2184 :     CHECK_CONCURRENCY("bgp::PeerMembership");
     996             : 
     997        2184 :     BgpUpdateSender *sender = manager_->server()->update_sender();
     998        2184 :     ribout_ = rs_->table()->RibOutLocate(sender, policy);
     999        2184 :     ribout_->RegisterListener();
    1000        2184 :     ribout_->Register(ps_->peer());
    1001        2184 :     ribout_index_ = ribout_->GetPeerIndex(ps_->peer());
    1002        2184 :     ribout_registered_ = true;
    1003        2184 :     rs_->EnqueuePeerRibState(this);
    1004        2184 : }
    1005             : 
    1006             : //
    1007             : // Deactivate the IPeer in the RibOut.
    1008             : // This ensures that the IPeer will stop exporting routes from now onwards.
    1009             : //
    1010             : // Note that this is called before Leave processing for the IPeer is started.
    1011             : //
    1012             : // Bypass the Walker and directly post an UNREGISTER_RIB_COMPLETE event if
    1013             : // there's no RibOut. This happens if the table was marked deleted when the
    1014             : // register was processed.
    1015             : //
    1016        2184 : void BgpMembershipManager::PeerRibState::DeactivateRibOut() {
    1017        2184 :     CHECK_CONCURRENCY("bgp::PeerMembership");
    1018        2184 :     if (ribout_) {
    1019        2184 :         ribout_->Deactivate(ps_->peer());
    1020        2184 :         rs_->EnqueuePeerRibState(this);
    1021             :     } else {
    1022           0 :         assert(ribout_index_ == -1);
    1023           0 :         ribout_registered_ = false;
    1024           0 :         manager_->TriggerUnregisterRibCompleteEvent(ps_->peer(), rs_->table());
    1025             :     }
    1026        2184 : }
    1027             : 
    1028             : //
    1029             : // Unregister the IPeer from the BgpTable.
    1030             : // Unregister the IPeer from the RibOut, which may result in deletion of the
    1031             : // RibOut itself.
    1032             : //
    1033             : // Note that this is called only after Leave processing for the IPeer has been
    1034             : // completed.
    1035             : //
    1036        2184 : void BgpMembershipManager::PeerRibState::UnregisterRibOut() {
    1037        2184 :     CHECK_CONCURRENCY("bgp::PeerMembership");
    1038             : 
    1039        2184 :     if (!ribout_)
    1040           0 :         return;
    1041        2184 :     assert(ribout_index_ != -1);
    1042        2184 :     ribout_->Unregister(ps_->peer());
    1043        2184 :     ribout_ = NULL;
    1044        2184 :     ribout_index_ = -1;
    1045        2184 :     ribout_registered_ = false;
    1046             : }
    1047             : 
    1048             : //
    1049             : // Unregister the RibIn for the IPeer.
    1050             : //
    1051         216 : void BgpMembershipManager::PeerRibState::UnregisterRibIn() {
    1052         216 :     rs_->EnqueuePeerRibState(this);
    1053         216 : }
    1054             : 
    1055             : //
    1056             : // Walk the RibIn for the IPeer.
    1057             : //
    1058         432 : void BgpMembershipManager::PeerRibState::WalkRibIn() {
    1059         432 :     rs_->EnqueuePeerRibState(this);
    1060         432 : }
    1061             : 
    1062             : //
    1063             : // Fill introspect information.
    1064             : //
    1065           0 : void BgpMembershipManager::PeerRibState::FillMembershipInfo(
    1066             :     ShowMembershipPeerInfo *smpi) const {
    1067           0 :     smpi->set_peer(ps_->peer()->ToString());
    1068           0 :     smpi->set_ribin_registered(ribin_registered_);
    1069           0 :     smpi->set_ribout_registered(ribout_registered_);
    1070           0 :     smpi->set_instance_id(instance_id_);
    1071           0 :     smpi->set_generation_id(subscription_gen_id_);
    1072           0 : }
    1073             : 
    1074             : //
    1075             : // Constructor.
    1076             : //
    1077          20 : BgpMembershipManager::Walker::Walker(BgpMembershipManager *manager)
    1078          20 :     : manager_(manager),
    1079          40 :       trigger_(new TaskTrigger(
    1080             :           boost::bind(&BgpMembershipManager::Walker::WalkTrigger, this),
    1081          40 :           TaskScheduler::GetInstance()->GetTaskId("bgp::PeerMembership"), 0)),
    1082          20 :       postpone_walk_(false),
    1083          20 :       walk_started_(false),
    1084          20 :       walk_completed_(false),
    1085          20 :       rs_(NULL),
    1086          20 :       rib_state_list_size_(0),
    1087          40 :       ribout_state_list_size_(0) {
    1088          20 : }
    1089             : 
    1090             : //
    1091             : // Destructor.
    1092             : //
    1093          20 : BgpMembershipManager::Walker::~Walker() {
    1094          20 :     assert(rib_state_set_.empty());
    1095          20 :     assert(rib_state_list_.empty());
    1096          20 :     assert(!postpone_walk_);
    1097          20 :     assert(!rs_);
    1098          20 :     assert(walk_ref_ == NULL);
    1099          20 :     assert(peer_rib_list_.empty());
    1100          20 :     assert(peer_list_.empty());
    1101          20 :     assert(ribout_state_map_.empty());
    1102          20 :     assert(ribout_state_list_.empty());
    1103          20 : }
    1104             : 
    1105             : //
    1106             : // Add the given RibState to the RibStateList if it's not already present.
    1107             : // Trigger processing of the RibStateList if a walk is not already in progress.
    1108             : //
    1109        5016 : void BgpMembershipManager::Walker::Enqueue(RibState *rs) {
    1110        5016 :     if (rib_state_set_.find(rs) != rib_state_set_.end())
    1111        1370 :         return;
    1112        3646 :     rib_state_set_.insert(rs);
    1113        3646 :     rib_state_list_.push_back(rs);
    1114        3646 :     rib_state_list_size_++;
    1115        3646 :     if (!walk_started_)
    1116        3185 :         trigger_->Set();
    1117             : }
    1118             : 
    1119             : //
    1120             : // Return true if the Walk does not have any pending items.
    1121             : //
    1122        4033 : bool BgpMembershipManager::Walker::IsQueueEmpty() const {
    1123        4033 :     return (rib_state_list_.empty() && !trigger_->IsSet() && !rs_);
    1124             : }
    1125             : 
    1126             : //
    1127             : // Find or create the RibOutState for given RibOut.
    1128             : //
    1129             : BgpMembershipManager::Walker::RibOutState *
    1130        4368 : BgpMembershipManager::Walker::LocateRibOutState(RibOut *ribout) {
    1131        4368 :     RibOutStateMap::iterator loc = ribout_state_map_.find(ribout);
    1132        4368 :     if (loc == ribout_state_map_.end()) {
    1133        3164 :         RibOutState *ros = new RibOutState(ribout);
    1134        3164 :         ribout_state_map_.insert(make_pair(ribout, ros));
    1135        3164 :         ribout_state_list_.push_back(ros);
    1136        3164 :         ribout_state_list_size_++;
    1137        3164 :         return ros;
    1138             :     } else {
    1139        1204 :         return loc->second;
    1140             :     }
    1141             : }
    1142             : 
    1143             : //
    1144             : // Process table walk callback from DB infrastructure.
    1145             : //
    1146       53626 : bool BgpMembershipManager::Walker::WalkCallback(DBTablePartBase *tpart,
    1147             :     DBEntryBase *db_entry) {
    1148       53626 :     CHECK_CONCURRENCY("db::DBTable");
    1149             : 
    1150             :     // Walk all RibOutStates and handle join/leave processing.
    1151       53386 :     for (RibOutStateList::iterator it = ribout_state_list_.begin();
    1152       85220 :          it != ribout_state_list_.end(); ++it) {
    1153       31707 :         RibOutState *ros = *it;
    1154       31701 :         RibOut *ribout = ros->ribout();
    1155       31697 :         ribout->bgp_export()->Join(tpart, ros->join_bitset(), db_entry);
    1156       31770 :         ribout->bgp_export()->Leave(tpart, ros->leave_bitset(), db_entry);
    1157             :     }
    1158             : 
    1159             :     // Bail if there's no peers that need RibIn processing.
    1160       53507 :     if (peer_list_.empty())
    1161        5168 :         return true;
    1162             : 
    1163             :     // Walk through all eligible paths and notify the source peer if needed.
    1164       48323 :     bool notify = false;
    1165       48323 :     BgpRoute *route = static_cast<BgpRoute *>(db_entry);
    1166       96652 :     for (Route::PathList::iterator it = route->GetPathList().begin(), next = it;
    1167      189911 :          it != route->GetPathList().end(); it = next) {
    1168       46603 :         next++;
    1169             : 
    1170       46603 :         BgpPath *path = static_cast<BgpPath *>(it.operator->());
    1171       46603 :         IPeer *peer = path->GetPeer();
    1172             : 
    1173             :         // Skip resolved paths - PathResolver is responsible for them.
    1174       46677 :         if (path->IsResolved())
    1175       39558 :             continue;
    1176             : 
    1177             :         // Skip aliased paths - EvpnManager is responsible for them.
    1178       46681 :         if (path->IsAliased())
    1179           0 :             continue;
    1180             : 
    1181             :         // Skip secondary paths.
    1182       46674 :         if (dynamic_cast<BgpSecondaryPath *>(path))
    1183       30917 :             continue;
    1184             : 
    1185             :         // Skip if there's no walk requested for this IPeer.
    1186       15757 :         if (!peer || peer_list_.find(peer) == peer_list_.end())
    1187        8641 :             continue;
    1188             : 
    1189        7087 :         notify |= peer->MembershipPathCallback(tpart, route, path);
    1190             :     }
    1191             : 
    1192       48253 :     rs_->table()->InputCommonPostProcess(tpart, route, notify);
    1193       48444 :     return true;
    1194             : }
    1195             : 
    1196             : //
    1197             : // Process table walk done callback from DB infrastructure.
    1198             : // Just note that the walk has completed and trigger processing from the
    1199             : // bgp::PeerMembership task.
    1200             : //
    1201        3646 : void BgpMembershipManager::Walker::WalkDoneCallback(DBTableBase *table_base) {
    1202        3646 :     CHECK_CONCURRENCY("db::Walker");
    1203        3646 :     assert(rs_->table() == table_base);
    1204        3646 :     walk_completed_ = true;
    1205        3646 :     trigger_->Set();
    1206        3646 : }
    1207             : 
    1208             : //
    1209             : // Start a walk for the BgpTable corresponding to the next RibState in the
    1210             : // RibStateList.
    1211             : //
    1212        4212 : void BgpMembershipManager::Walker::WalkStart() {
    1213        4212 :     CHECK_CONCURRENCY("bgp::PeerMembership");
    1214             : 
    1215        4212 :     assert(walk_ref_ == NULL);
    1216        4212 :     assert(!rs_);
    1217        4212 :     assert(peer_rib_list_.empty());
    1218        4212 :     assert(peer_list_.empty());
    1219        4212 :     assert(ribout_state_map_.empty());
    1220        4212 :     assert(ribout_state_list_.empty());
    1221        4212 :     assert(rib_state_list_size_ == rib_state_set_.size());
    1222             : 
    1223             :     // Bail if the list if empty.
    1224        4212 :     if (rib_state_list_.empty())
    1225         566 :         return;
    1226             : 
    1227             :     // Get and remove the first RibState from the RibStateList.
    1228        3646 :     rs_ = rib_state_list_.front();
    1229        3646 :     rib_state_list_.pop_front();
    1230        3646 :     rib_state_list_size_--;
    1231        3646 :     assert(rib_state_set_.erase(rs_) == 1);
    1232             : 
    1233             :     // Process all pending PeerRibStates for chosen RibState.
    1234             :     // Insert the PeerRibStates into PeerRibList for post processing when
    1235             :     // table walk is complete.
    1236        8662 :     for (RibState::iterator it = rs_->begin(); it != rs_->end(); ++it) {
    1237        5016 :         PeerRibState *prs = *it;
    1238        5016 :         peer_rib_list_.insert(prs);
    1239             : 
    1240             :         // Update PeerList for RIBIN actions and RibOutStateMap for RIBOUT
    1241             :         // actions.
    1242        5016 :         switch (prs->action()) {
    1243        2184 :         case RIBOUT_ADD: {
    1244        2184 :             RibOutState *ros = LocateRibOutState(prs->ribout());
    1245        2184 :             ros->JoinPeer(prs->ribout_index());
    1246        2184 :             break;
    1247             :         }
    1248         648 :         case RIBIN_DELETE:
    1249             :         case RIBIN_WALK: {
    1250         648 :             IPeer *peer = prs->peer_state()->peer();
    1251         648 :             peer_list_.insert(peer);
    1252         648 :             break;
    1253             :         }
    1254        2184 :         case RIBIN_WALK_RIBOUT_DELETE:
    1255             :         case RIBIN_DELETE_RIBOUT_DELETE: {
    1256        2184 :             IPeer *peer = prs->peer_state()->peer();
    1257        2184 :             peer_list_.insert(peer);
    1258        2184 :             RibOutState *ros = LocateRibOutState(prs->ribout());
    1259        2184 :             ros->LeavePeer(prs->ribout_index());
    1260        2184 :             break;
    1261             :         }
    1262           0 :         default: {
    1263           0 :             assert(false);
    1264             :             break;
    1265             :         }
    1266             :         }
    1267             :     }
    1268             : 
    1269             :     // Clear the pending PeerRibStates in the RibState.
    1270             :     // This allows the RibState to accumulate new PeerRibStates for a future
    1271             :     // walk of it's BgpTable.
    1272        3646 :     rs_->ClearPeerRibStateList();
    1273             : 
    1274             :     // Start the walk.
    1275        3646 :     rs_->increment_walk_count();
    1276        3646 :     BgpTable *table = rs_->table();
    1277        7292 :     walk_ref_ = table->AllocWalker(
    1278             :         boost::bind(&BgpMembershipManager::Walker::WalkCallback, this, _1, _2),
    1279        3646 :         boost::bind(&BgpMembershipManager::Walker::WalkDoneCallback, this, _2));
    1280        3646 :     walk_started_ = true;
    1281        3646 :     if (!postpone_walk_)
    1282        3646 :         table->WalkTable(walk_ref_);
    1283             : }
    1284             : 
    1285             : //
    1286             : // Finish processing of the walk of BgpTable for current RibState.
    1287             : //
    1288             : // The walk complete notification is handled by WalkDoneCallback but all the
    1289             : // book-keeping and triggering of Events is handled by this method since it
    1290             : // needs to happen in bgp::PeerMembership task.
    1291             : //
    1292        3646 : void BgpMembershipManager::Walker::WalkFinish() {
    1293        3646 :     CHECK_CONCURRENCY("bgp::PeerMembership");
    1294             : 
    1295        3646 :     assert(walk_ref_ != NULL);
    1296        3646 :     assert(rs_);
    1297        3646 :     assert(!peer_rib_list_.empty());
    1298        3646 :     assert(!peer_list_.empty() || !ribout_state_map_.empty());
    1299        3646 :     assert(rib_state_list_size_ == rib_state_set_.size());
    1300        3646 :     assert(ribout_state_list_size_ == ribout_state_map_.size());
    1301             : 
    1302        3646 :     BgpTable *table = rs_->table();
    1303        3646 :     for (PeerRibList::iterator it = peer_rib_list_.begin();
    1304        8662 :          it != peer_rib_list_.end(); ++it) {
    1305        5016 :         PeerRibState *prs = *it;
    1306        5016 :         IPeer *peer = prs->peer_state()->peer();
    1307             : 
    1308        5016 :         switch (prs->action()) {
    1309        2184 :         case RIBOUT_ADD:
    1310        2184 :             manager_->TriggerRegisterRibCompleteEvent(peer, table);
    1311        2184 :             break;
    1312         648 :         case RIBIN_DELETE:
    1313             :         case RIBIN_WALK:
    1314         648 :             manager_->TriggerWalkRibCompleteEvent(peer, table);
    1315         648 :             break;
    1316        2184 :         case RIBIN_WALK_RIBOUT_DELETE:
    1317             :         case RIBIN_DELETE_RIBOUT_DELETE:
    1318        2184 :             manager_->TriggerUnregisterRibCompleteEvent(peer, table);
    1319        2184 :             break;
    1320           0 :         default:
    1321           0 :             assert(false);
    1322             :             break;
    1323             :         }
    1324             :     }
    1325             : 
    1326        3646 :     table->ReleaseWalker(walk_ref_);
    1327        3646 :     rs_ = NULL;
    1328        3646 :     peer_rib_list_.clear();
    1329        3646 :     peer_list_.clear();
    1330        3646 :     ribout_state_list_.clear();
    1331        3646 :     ribout_state_list_size_ = 0;
    1332        3646 :     STLDeleteElements(&ribout_state_map_);
    1333             : 
    1334        3646 :     walk_started_ = false;
    1335        3646 :     walk_completed_ = false;
    1336        3646 : }
    1337             : 
    1338             : //
    1339             : // Handler for TaskTrigger.
    1340             : // Start a new walk or finish processing for the current walk and start a new
    1341             : // one.
    1342             : //
    1343        4212 : bool BgpMembershipManager::Walker::WalkTrigger() {
    1344        4212 :     CHECK_CONCURRENCY("bgp::PeerMembership");
    1345             : 
    1346        4212 :     if (!walk_started_) {
    1347         566 :         assert(!walk_completed_);
    1348         566 :         WalkStart();
    1349        3646 :     } else if (walk_completed_) {
    1350        3646 :         WalkFinish();
    1351        3646 :         WalkStart();
    1352             :     }
    1353        4212 :     return true;
    1354             : }
    1355             : 
    1356             : //
    1357             : // Disable the TaskTrigger so that the Walker can accumulate RibStates in the
    1358             : // RibStateList.
    1359             : // Testing only.
    1360             : //
    1361           0 : void BgpMembershipManager::Walker::SetQueueDisable(bool value) {
    1362           0 :     if (value) {
    1363           0 :         trigger_->set_disable();
    1364             :     } else {
    1365           0 :         trigger_->set_enable();
    1366             :     }
    1367           0 : }
    1368             : 
    1369             : //
    1370             : // Force the Walker to trigger walks that are postponed.
    1371             : // Testing only.
    1372             : //
    1373           0 : void BgpMembershipManager::Walker::PostponeWalk() {
    1374           0 :     assert(!walk_started_);
    1375           0 :     assert(walk_ref_ == NULL);
    1376           0 :     postpone_walk_ = true;
    1377           0 : }
    1378             : 
    1379             : //
    1380             : // Tell the DBTableWalkMgr to resume walk that was postponed previously.
    1381             : // Testing only.
    1382             : //
    1383           0 : void BgpMembershipManager::Walker::ResumeWalk() {
    1384           0 :     assert(walk_started_);
    1385           0 :     assert(!walk_completed_);
    1386           0 :     assert(walk_ref_ != NULL);
    1387           0 :     postpone_walk_ = false;
    1388           0 :     BgpTable *table = rs_->table();
    1389           0 :     table->WalkTable(walk_ref_);
    1390           0 : }

Generated by: LCOV version 1.14