agent_route_walker.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */

#ifndef vnsw_agent_route_walker_hpp
#define vnsw_agent_route_walker_hpp

#include <boost/intrusive_ptr.hpp>
#include <boost/array.hpp>

#include <cmn/agent_cmn.h>
#include <cmn/agent.h>
#include <sandesh/sandesh_trace.h>

#define AGENT_DBWALK_TRACE_BUF "AgentDBwalkTrace"
extern SandeshTraceBufferPtr AgentDBwalkTraceBuf;

#define AGENT_DBWALK_TRACE(obj, ...) do {                                  \
    obj::TraceMsg(AgentDBwalkTraceBuf, __FILE__, __LINE__, ##__VA_ARGS__); \
} while (false)

class AgentRouteWalker;
class AgentRouteWalkerManager;
void intrusive_ptr_add_ref(AgentRouteWalker *w);
void intrusive_ptr_release(AgentRouteWalker *w);
typedef boost::intrusive_ptr<AgentRouteWalker> AgentRouteWalkerPtr;

struct RouteWalkerDBState : DBState {
    typedef boost::array<DBTable::DBTableWalkRef, Agent::ROUTE_TABLE_MAX> RouteWalkRef;
    typedef std::map<AgentRouteWalkerPtr, RouteWalkRef> AgentRouteWalkerRefMap;
    typedef AgentRouteWalkerRefMap::iterator AgentRouteWalkerRefMapIter;
    typedef AgentRouteWalkerRefMap::const_iterator AgentRouteWalkerRefMapConstIter;

    RouteWalkerDBState();
    AgentRouteWalkerRefMap walker_ref_map_;
};

class AgentRouteWalker {
public:
    static const int kInvalidWalkCount = 0;
    typedef boost::function<void()> WalkDone;
    typedef boost::function<void(VrfEntry *)> RouteWalkDoneCb;
    typedef std::map<const VrfEntry *, tbb::atomic<int> > VrfRouteWalkCountMap;

    virtual ~AgentRouteWalker();

    void StartVrfWalk();
    //Route table walk for specified VRF
    void StartRouteWalk(VrfEntry *vrf);

    virtual bool VrfWalkNotify(DBTablePartBase *partition, DBEntryBase *e);
    virtual bool RouteWalkNotify(DBTablePartBase *partition, DBEntryBase *e);

    virtual void VrfWalkDone(DBTableBase *part);
    virtual void RouteWalkDone(DBTableBase *part);

    //Walk done callbacks
    void WalkDoneCallback(WalkDone cb);
    void RouteWalkDoneForVrfCallback(RouteWalkDoneCb cb);

    //Helpers
    int walk_count() const {return walk_count_;}
    bool IsWalkCompleted() const {return (walk_count_ == kInvalidWalkCount);}
    bool IsValidDeleteWalkRef() const {
        return delete_walk_ref_.get() != NULL;
    }
    bool IsValidVrfWalkRef() const {
        return vrf_walk_ref_.get() != NULL;
    }
    bool IsDeregisterDone() const { return deregister_done_;}
    bool AreAllWalksDone() const;
    bool AreAllRouteWalksDone(const VrfEntry *vrf) const;
    bool IsRouteTableWalkCompleted(RouteWalkerDBState *state);
    AgentRouteWalkerManager *mgr() {return mgr_;}
    Agent *agent() const {return agent_;}
    uint32_t refcount() const { return refcount_; }

protected:
    friend class AgentRouteWalkerManager;
    friend void intrusive_ptr_add_ref(AgentRouteWalker *w);
    friend void intrusive_ptr_release(AgentRouteWalker *w);
    AgentRouteWalker(const std::string &name, Agent *agent);
    void set_mgr(AgentRouteWalkerManager *mgr) {mgr_ = mgr;}

private:
    void Callback(VrfEntry *vrf);
    void OnRouteTableWalkCompleteForVrf(VrfEntry *vrf);
    void DecrementWalkCount();
    void DecrementRouteWalkCount(const VrfEntry *vrf);
    void IncrementWalkCount() {walk_count_.fetch_and_increment();}
    void IncrementRouteWalkCount(const VrfEntry *vrf);
    void WalkTable(AgentRouteTable *table,
                   DBTable::DBTableWalkRef &route_table_walk_ref);
    DBTable::DBTableWalkRef AllocateRouteTableReferences(AgentRouteTable *table);
    void VrfWalkDoneInternal(DBTableBase *part);
    void RouteWalkDoneInternal(DBTableBase *part, AgentRouteWalkerPtr ptr);
    DBTable::DBTableWalkRef LocateRouteTableWalkRef(const VrfEntry *vrf,
                                                    RouteWalkerDBState *state,
                                                    AgentRouteTable *table);
    RouteWalkerDBState *LocateRouteWalkerDBState(VrfEntry *vrf);
    DBTable::DBTableWalkRef &vrf_walk_ref() {
        return vrf_walk_ref_;
    }
    DBTable::DBTableWalkRef &delete_walk_ref() {
        return delete_walk_ref_;
    }
    //Walk to release all references.
    void ReleaseVrfWalkReference();
    bool Deregister(DBTablePartBase *partition, DBEntryBase *e);
    static void DeregisterDone(AgentRouteWalkerPtr walker);

    Agent *agent_;
    std::string name_;
    VrfRouteWalkCountMap route_walk_count_;
    tbb::atomic<int> walk_count_;
    WalkDone walk_done_cb_;
    RouteWalkDoneCb route_walk_done_for_vrf_cb_;
    DBTable::DBTableWalkRef vrf_walk_ref_;
    AgentRouteWalkerManager *mgr_;
    bool deregister_done_;
    DBTable::DBTableWalkRef delete_walk_ref_;
    mutable tbb::atomic<uint32_t> refcount_;
    DISALLOW_COPY_AND_ASSIGN(AgentRouteWalker);
};

class AgentRouteWalkerManager {
public:
    typedef std::set<AgentRouteWalkerPtr> WalkRefList;
    typedef std::set<AgentRouteWalkerPtr>::iterator WalkRefListIter;

    AgentRouteWalkerManager(Agent *agent);
    virtual ~AgentRouteWalkerManager();
    Agent *agent() {return agent_;}

    void RegisterWalker(AgentRouteWalker *walker);
    void ReleaseWalker(AgentRouteWalker *walker);
    void Shutdown();
    void TryUnregister();
    //UT helper
    uint8_t walk_ref_list_size() const {return walk_ref_list_.size();}

protected:
    friend class AgentRouteWalker;
    void VrfNotify(DBTablePartBase *partition, DBEntryBase *e);
    void RemoveWalker(AgentRouteWalkerPtr walker);
    void ValidateAgentRouteWalker(AgentRouteWalkerPtr walker) const;
    RouteWalkerDBState *CreateState(VrfEntry *vrf);
    void RemoveWalkReferencesInVrf(RouteWalkerDBState *state, VrfEntry *vrf);
    DBTable::ListenerId vrf_listener_id() const {
        return vrf_listener_id_;
    }

private:
    DBTable::ListenerId vrf_listener_id_;
    Agent *agent_;
    WalkRefList walk_ref_list_;
    bool marked_for_deletion_;
    DISALLOW_COPY_AND_ASSIGN(AgentRouteWalkerManager);
};

#endif