bgp_evpn.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef SRC_BGP_BGP_EVPN_H_
#define SRC_BGP_BGP_EVPN_H_
 
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/scoped_ptr.hpp>
#include <tbb/spin_rw_mutex.h>
 
#include <list>
#include <set>
#include <vector>
 
#include "base/lifetime.h"
#include "base/task_trigger.h"
#include "base/address.h"
#include "bgp/bgp_attr.h"
#include "bgp/bgp_path.h"
#include "db/db_entry.h"
 
class BgpPath;
class DBTablePartition;
class DBTablePartBase;
class EvpnRoute;
class ErmVpnRoute;
class EvpnState;
class EvpnTable;
class ErmVpnTable;
class EvpnManagerPartition;
class EvpnManager;
class ShowEvpnTable;
struct UpdateInfo;
 
typedef boost::intrusive_ptr<EvpnState> EvpnStatePtr;
 
class EvpnMcastNode : public DBState {
public:
    enum Type {
        LocalNode,
        RemoteNode
    };
    EvpnMcastNode(EvpnManagerPartition *partition, EvpnRoute *route,
        uint8_t type);
    EvpnMcastNode(EvpnManagerPartition *partition, EvpnRoute *route,
        uint8_t type, EvpnStatePtr state);
    ~EvpnMcastNode();
 
    bool UpdateAttributes(EvpnRoute *route);
 
    virtual void TriggerUpdate() = 0;
 
    EvpnStatePtr state() { return state_; };
    void set_state(EvpnStatePtr state) { state_ = state; };
    EvpnRoute *route() { return route_; }
    uint8_t type() const { return type_; }
    const BgpAttr *attr() const { return attr_.get(); }
    uint32_t label() const { return label_; }
    Ip4Address address() const { return address_; }
    Ip4Address replicator_address() const { return replicator_address_; }
    bool edge_replication_not_supported() const {
        return edge_replication_not_supported_;
    }
    bool assisted_replication_supported() const {
        return assisted_replication_supported_;
    }
    bool assisted_replication_leaf() const {
        return assisted_replication_leaf_;
    }
 
protected:
    EvpnManagerPartition *partition_;
    EvpnStatePtr state_;
    EvpnRoute *route_;
    uint8_t type_;
    BgpAttrPtr attr_;
    uint32_t label_;
    Ip4Address address_;
    Ip4Address replicator_address_;
    bool edge_replication_not_supported_;
    bool assisted_replication_supported_;
    bool assisted_replication_leaf_;
 
private:
    DISALLOW_COPY_AND_ASSIGN(EvpnMcastNode);
};
 
 
class EvpnLocalMcastNode : public EvpnMcastNode {
public:
 
    EvpnLocalMcastNode(EvpnManagerPartition *partition, EvpnRoute *route);
    EvpnLocalMcastNode(EvpnManagerPartition *partition, EvpnRoute *route,
                       EvpnStatePtr state);
    virtual ~EvpnLocalMcastNode();
 
    virtual void TriggerUpdate();
 
    UpdateInfo *GetUpdateInfo(EvpnRoute *route);
    EvpnRoute *inclusive_mcast_route() { return inclusive_mcast_route_; }
 
private:
    void AddInclusiveMulticastRoute();
 
    void DeleteInclusiveMulticastRoute();
 
    EvpnRoute *inclusive_mcast_route_;
 
    DISALLOW_COPY_AND_ASSIGN(EvpnLocalMcastNode);
};
 
 
class EvpnRemoteMcastNode : public EvpnMcastNode {
public:
    EvpnRemoteMcastNode(EvpnManagerPartition *partition, EvpnRoute *route);
    EvpnRemoteMcastNode(EvpnManagerPartition *partition, EvpnRoute *route,
                        EvpnStatePtr state);
    virtual ~EvpnRemoteMcastNode();
 
    virtual void TriggerUpdate();
 
private:
    DISALLOW_COPY_AND_ASSIGN(EvpnRemoteMcastNode);
};
 
 
class EvpnSegment : public DBState {
public:
    EvpnSegment(EvpnManager *evpn_manager, const EthernetSegmentId &esi);
    ~EvpnSegment();
 
    class RemotePe {
    public:
        RemotePe(const BgpPath *path);
 
        bool operator==(const RemotePe &rhs) const;
 
        bool esi_valid;
        bool single_active;
        const IPeer *peer;
        BgpAttrPtr attr;
        uint32_t flags;
        BgpPath::PathSource src;
    };
 
    typedef std::list<RemotePe> RemotePeList;
    typedef RemotePeList::const_iterator const_iterator;
 
    const_iterator begin() const { return pe_list_.begin(); }
    const_iterator end() const { return pe_list_.end(); }
 
    void AddMacRoute(size_t part_id, EvpnRoute *route);
 
    void DeleteMacRoute(size_t part_id, EvpnRoute *route);
 
    void TriggerMacRouteUpdate();
 
    bool UpdatePeList();
 
    bool MayDelete() const;
 
    const EthernetSegmentId &esi() const { return esi_; }
    EvpnRoute *esi_ad_route() { return esi_ad_route_; }
    void set_esi_ad_route(EvpnRoute *esi_ad_route) {
        esi_ad_route_ = esi_ad_route;
    }
    void clear_esi_ad_route() { esi_ad_route_ = NULL; }
    bool single_active() const { return single_active_; }
 
private:
    typedef std::set<EvpnRoute *> RouteList;
    typedef std::vector<RouteList> RouteListVector;
 
    EvpnManager *evpn_manager_;
    EthernetSegmentId esi_;
    EvpnRoute *esi_ad_route_;
    bool single_active_;
    RouteListVector route_lists_;
    RemotePeList pe_list_;
 
    DISALLOW_COPY_AND_ASSIGN(EvpnSegment);
};
 
 
//
class EvpnMacState : public DBState {
public:
    EvpnMacState(EvpnManager *evpn_manager, EvpnRoute *route);
    ~EvpnMacState();
 
    bool ProcessMacRouteAliasing();
 
    EvpnSegment *segment() { return segment_; }
    const EvpnSegment *segment() const { return segment_; }
    void set_segment(EvpnSegment *segment) { segment_ = segment; }
    void clear_segment() { segment_ = NULL; }
 
private:
    typedef std::set<BgpPath *> AliasedPathList;
 
    void AddAliasedPath(AliasedPathList::const_iterator it);
 
    void DeleteAliasedPath(AliasedPathList::const_iterator it);
 
    BgpPath *LocateAliasedPath(const EvpnSegment::RemotePe *remote_pe,
        uint32_t label);
 
    EvpnManager *evpn_manager_;
    EvpnRoute *route_;
    EvpnSegment *segment_;
    AliasedPathList aliased_path_list_;
 
    DISALLOW_COPY_AND_ASSIGN(EvpnMacState);
};
 
class EvpnState {
public:
    typedef std::set<EvpnRoute *> RoutesSet;
    typedef std::map<EvpnRoute *, BgpAttrPtr> RoutesMap;
 
    struct SG {
        SG(const Ip4Address &source, const Ip4Address &group);
        SG(const IpAddress &source, const IpAddress &group);
        explicit SG(const ErmVpnRoute *route);
        explicit SG(const EvpnRoute *route);
        bool operator<(const SG &other) const;
 
        IpAddress source;
        IpAddress group;
    };
 
    typedef std::map<SG, EvpnState *> StatesMap;
 
    EvpnState(const SG &sg, StatesMap *states, EvpnManager* manager);
 
    virtual ~EvpnState();
    const SG &sg() const;
    ErmVpnRoute *global_ermvpn_tree_rt();
    const ErmVpnRoute *global_ermvpn_tree_rt() const;
    void set_global_ermvpn_tree_rt(ErmVpnRoute *global_ermvpn_tree_rt);
    RoutesSet &smet_routes() { return smet_routes_; }
    const RoutesSet &smet_routes() const { return smet_routes_; }
    const StatesMap *states() const { return states_; }
    StatesMap *states() { return states_; }
    EvpnManager *manager() { return manager_; }
    const EvpnManager *manager() const { return manager_; }
    int refcount() const { return refcount_; }
 
private:
    friend class EvpnMcastNode;
    friend class EvpnManagerPartition;
 
    friend void intrusive_ptr_add_ref(EvpnState *evpn_state);
 
    friend void intrusive_ptr_release(EvpnState *evpn_state);
 
    const ErmVpnTable *table() const;
 
    SG sg_;
    ErmVpnRoute *global_ermvpn_tree_rt_;
    RoutesSet smet_routes_;
    StatesMap *states_;
    EvpnManager *manager_;
    tbb::atomic<int> refcount_;
 
    DISALLOW_COPY_AND_ASSIGN(EvpnState);
};
 
 
class EvpnManagerPartition {
public:
    typedef EvpnState::SG SG;
    typedef std::map<SG, std::set<EvpnMcastNode *> > EvpnMcastNodeList;
 
    EvpnManagerPartition(EvpnManager *evpn_manager, size_t part_id);
    ~EvpnManagerPartition();
 
    DBTablePartition *GetTablePartition();
 
    void NotifyNodeRoute(EvpnMcastNode *node);
 
    void NotifyReplicatorNodeRoutes();
 
    void NotifyIrClientNodeRoutes(bool exclude_edge_replication_supported);
 
    void AddMcastNode(EvpnMcastNode *node, EvpnRoute *route);
 
    void DeleteMcastNode(EvpnMcastNode *node, EvpnRoute *route);
 
    void UpdateMcastNode(EvpnMcastNode *node, EvpnRoute *route);
 
    bool RemoveMcastNodeFromList(EvpnState::SG &sg, EvpnMcastNode *node,
                                 EvpnMcastNodeList *list);
 
    void TriggerMacRouteUpdate(EvpnRoute *route);
 
    bool empty() const;
 
    const EvpnMcastNodeList &remote_mcast_node_list() const {
        return remote_mcast_node_list_;
    }
    const EvpnMcastNodeList &local_mcast_node_list() const {
        return local_mcast_node_list_;
    }
    const EvpnMcastNodeList &leaf_node_list() const {
        return leaf_node_list_;
    }
    EvpnMcastNodeList *remote_mcast_node_list() {
        return &remote_mcast_node_list_;
    }
    EvpnMcastNodeList *local_mcast_node_list() {
        return &local_mcast_node_list_;
    }
    EvpnMcastNodeList *leaf_node_list() {
        return &leaf_node_list_;
    }
 
    BgpServer *server();
 
    const EvpnTable *table() const;
 
    size_t part_id() const { return part_id_; }
 
private:
    friend class EvpnManager;
    friend class BgpEvpnManagerTest;
 
    typedef std::set<EvpnRoute *> EvpnRouteList;
 
    bool ProcessMacUpdateList();
 
    void DisableMacUpdateProcessing();
 
    void EnableMacUpdateProcessing();
 
    EvpnStatePtr GetState(const SG &sg);
    EvpnStatePtr GetState(const SG &sg) const;
    EvpnStatePtr GetState(EvpnRoute *route);
    EvpnStatePtr LocateState(EvpnRoute *route);
    EvpnStatePtr LocateState(const SG &sg);
    EvpnStatePtr CreateState(const SG &sg);
    const EvpnState::StatesMap &states() const { return states_; }
    EvpnState::StatesMap &states() { return states_; }
    bool GetForestNodeAddress(ErmVpnRoute *rt, Ip4Address *address) const;
    void NotifyForestNode(EvpnRoute *route, ErmVpnTable *table);
 
    EvpnManager *evpn_manager_;
    size_t part_id_;
    EvpnState::StatesMap states_;;
    DBTablePartition *table_partition_;
    EvpnMcastNodeList local_mcast_node_list_;
    EvpnMcastNodeList remote_mcast_node_list_;
    EvpnMcastNodeList replicator_node_list_;
    EvpnMcastNodeList leaf_node_list_;
    EvpnMcastNodeList regular_node_list_;
    EvpnMcastNodeList ir_client_node_list_;
    EvpnRouteList mac_update_list_;
    boost::scoped_ptr<TaskTrigger> mac_update_trigger_;
 
    DISALLOW_COPY_AND_ASSIGN(EvpnManagerPartition);
};
 
 
class EvpnManager {
public:
    explicit EvpnManager(EvpnTable *table);
    virtual ~EvpnManager();
 
    virtual void Initialize();
 
    virtual void Terminate();
 
    virtual UpdateInfo *GetUpdateInfo(EvpnRoute *route);
 
    EvpnManagerPartition *GetPartition(size_t part_id);
 
    DBTablePartition *GetTablePartition(size_t part_id);
 
    void FillShowInfo(ShowEvpnTable *sevt) const;
 
    BgpServer *server();
    EvpnTable *table() { return table_; }
    const EvpnTable *table() const { return table_; }
    ErmVpnTable *ermvpn_table() { return ermvpn_table_; }
    const ErmVpnTable *ermvpn_table() const { return ermvpn_table_; }
    int listener_id() const { return listener_id_; }
    int ermvpn_listener_id() const { return ermvpn_listener_id_; }
 
    EvpnSegment *LocateSegment(const EthernetSegmentId &esi);
 
    EvpnSegment *FindSegment(const EthernetSegmentId &esi);
 
    void TriggerSegmentDelete(EvpnSegment *segment);
 
    void TriggerSegmentUpdate(EvpnSegment *segment);
 
    void ManagedDelete();
 
    void Shutdown();
 
    bool MayDelete() const;
 
    void RetryDelete();
 
    LifetimeActor *deleter();
 
private:
    friend class BgpEvpnManagerTest;
    friend class BgpEvpnAliasingTest;
 
    class DeleteActor;
    typedef std::vector<EvpnManagerPartition *> PartitionList;
    typedef boost::ptr_map<const EthernetSegmentId, EvpnSegment> SegmentMap;
    typedef std::set<EvpnSegment *> SegmentSet;
 
    void AllocPartitions();
 
    void FreePartitions();
 
    void AutoDiscoveryRouteListener(EvpnRoute *route);
 
    void MacAdvertisementRouteListener(EvpnManagerPartition *partition,
        EvpnRoute *route);
 
    void InclusiveMulticastRouteListener(EvpnManagerPartition *partition,
        EvpnRoute *route);
        
    void SelectiveMulticastRouteListener(EvpnManagerPartition *partition,
        EvpnRoute *route);
 
    void RouteListener(DBTablePartBase *tpart, DBEntryBase *db_entry);
 
    void ErmVpnRouteListener(DBTablePartBase *tpart, DBEntryBase *db_entry);
 
    bool ProcessSegmentDeleteSet();
 
    bool ProcessSegmentUpdateSet();
 
    bool IsUsableGlobalTreeRootRoute(ErmVpnRoute *ermvpn_route) const;
 
    void DisableSegmentUpdateProcessing();
 
    void EnableSegmentUpdateProcessing();
 
    void DisableSegmentDeleteProcessing();
 
    void EnableSegmentDeleteProcessing();
 
    void DisableMacUpdateProcessing();
 
    void EnableMacUpdateProcessing();
 
    void SetDBState(EvpnRoute *route, EvpnMcastNode *dbstate);
 
    void ClearDBState(EvpnRoute *route);
 
    EvpnTable *table_;
    ErmVpnTable *ermvpn_table_;
    int listener_id_;
    int ermvpn_listener_id_;
    tbb::atomic<int> db_states_count_;
    PartitionList partitions_;
    tbb::spin_rw_mutex segment_rw_mutex_;
    SegmentMap segment_map_;
    SegmentSet segment_delete_set_;
    SegmentSet segment_update_set_;
    boost::scoped_ptr<TaskTrigger> segment_delete_trigger_;
    boost::scoped_ptr<TaskTrigger> segment_update_trigger_;
 
    boost::scoped_ptr<DeleteActor> deleter_;
    LifetimeRef<EvpnManager> table_delete_ref_;
 
    DISALLOW_COPY_AND_ASSIGN(EvpnManager);
};
 
inline void intrusive_ptr_add_ref(EvpnState *evpn_state) {
    evpn_state->refcount_.fetch_and_increment();
}
 
inline void intrusive_ptr_release(EvpnState *evpn_state) {
    int prev = evpn_state->refcount_.fetch_and_decrement();
    if (prev > 1)
        return;
    if (evpn_state->states()) {
        EvpnState::StatesMap::iterator iter =
            evpn_state->states()->find(evpn_state->sg());
        if (iter != evpn_state->states()->end()) {
            assert(iter->second == evpn_state);
            evpn_state->states()->erase(iter);
 
            // Attempt project manager deletion as it could be held up due to
            // this map being non-empty so far..
            if (evpn_state->manager()->deleter()->IsDeleted())
                evpn_state->manager()->deleter()->RetryDelete();
        }
    }
    delete evpn_state;
}
 
#define EVPN_RT_LOG(rt, ...) \
    RTINSTANCE_LOG(EvpnRoute, this->table()->routing_instance(), \
                   SandeshLevel::UT_DEBUG, \
                   RTINSTANCE_LOG_FLAG_ALL, \
                   (rt)->GetPrefix().source().to_string(), \
                   (rt)->GetPrefix().group().to_string(), \
                   (rt)->ToString(), ##__VA_ARGS__)
 
#define EVPN_ERMVPN_RT_LOG(rt, ...) \
    RTINSTANCE_LOG(EvpnErmVpnRoute, this->table()->routing_instance(), \
                   SandeshLevel::UT_DEBUG, \
                   RTINSTANCE_LOG_FLAG_ALL, \
                   (rt)->GetPrefix().source().to_string(), \
                   (rt)->GetPrefix().group().to_string(), \
                   (rt)->ToString(), ##__VA_ARGS__)
 
#define EVPN_TRACE(type, ...) \
    RTINSTANCE_LOG(type, this->table()->routing_instance(), \
        SandeshLevel::UT_DEBUG, RTINSTANCE_LOG_FLAG_ALL, ##__VA_ARGS__)
 
#endif  // SRC_BGP_BGP_EVPN_H_