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_