router.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/router.cc" -*-
#ifndef CLICK_ROUTER_HH
#define CLICK_ROUTER_HH
#include <click/element.hh>
#include <click/timer.hh>
#include <click/sync.hh>
#include <click/task.hh>
#include <click/vector.hh>
#include <click/pair.hh>
#include <click/standard/threadsched.hh>
#if CLICK_NS
# include <click/simclick.h>
#endif
#if CLICK_USERLEVEL
#include <functional>
#endif
CLICK_DECLS
class Master;
class ElementFilter;
class RouterVisitor;
class RouterThread;
class HashMap_ArenaFactory;
class NotifierSignal;
class ThreadSched;
class Handler;
class NameInfo;
 
class Router { public:
 
    // MASTER
    inline Master* master() const;
 
    // STATUS
    inline bool initialized() const;
    inline bool handlers_ready() const;
    inline bool running() const;
    inline bool dying() const;
 
    // RUNCOUNT AND RUNCLASS
    enum { STOP_RUNCOUNT = -2147483647 - 1 };
    inline int32_t runcount() const;
    void adjust_runcount(int32_t delta);
    void set_runcount(int32_t rc);
    inline void please_stop_driver();
 
    // ELEMENTS
    inline const Vector<Element*>& elements() const;
    inline int nelements() const;
    inline Element* element(int i) const;
    inline Element* root_element() const;
    static Element* element(const Router *router, int i);
 
    const String& ename(int i) const;
    String ename_context(int i) const;
    String elandmark(int i) const;
    const String& econfiguration(int i) const;
    void set_econfiguration(int i, const String& conf);
 
    Element* find(const String& name, ErrorHandler* errh = 0) const;
    Element* find(const String& name, String context, ErrorHandler* errh = 0) const;
    Element* find(const String& name, const Element* context, ErrorHandler* errh = 0) const;
 
    bool element_can_reach(Element* a, Element* b);
    int visit(Element *e, bool isoutput, int port, RouterVisitor *visitor, bool all_paths = false) const;
    int visit_ports(Element *e, bool isoutput, int port, RouterVisitor *visitor) const;
    int visit_paths(Element *e, bool isoutput, int port, RouterVisitor *visitor) const {
        return visit(e, isoutput, port, visitor, true);
    }
    int visit_downstream(Element *e, int port, RouterVisitor *visitor) const;
    int visit_upstream(Element *e, int port, RouterVisitor *visitor) const;
 
    int downstream_elements(Element *e, int port, ElementFilter *filter, Vector<Element*> &result) CLICK_DEPRECATED;
    int upstream_elements(Element *e, int port, ElementFilter *filter, Vector<Element*> &result) CLICK_DEPRECATED;
 
    inline const char *flow_code_override(int eindex) const;
    void set_flow_code_override(int eindex, const String &flow_code);
 
    // HANDLERS
    // 'const Handler *' results last until that element/handlername modified
    static const Handler *handler(const Element *e, const String &hname);
    static void add_read_handler(const Element *e, const String &hname, ReadHandlerCallback callback, void *user_data, uint32_t flags = 0);
    static void add_write_handler(const Element *e, const String &hname, WriteHandlerCallback callback, void *user_data, uint32_t flags = 0);
    static void set_handler(const Element *e, const String &hname, uint32_t flags, HandlerCallback callback, void *read_user_data = 0, void *write_user_data = 0);
    static int set_handler_flags(const Element *e, const String &hname, uint32_t set_flags, uint32_t clear_flags = 0);
    static int router_handler(int operation, String &data, Element *e, const Handler *handler, ErrorHandler *errh);
 
    enum { FIRST_GLOBAL_HANDLER = 0x40000000 };
    static int hindex(const Element *e, const String &hname);
    static const Handler *handler(const Router *router, int hindex);
    static void element_hindexes(const Element *e, Vector<int> &result);
 
    // ATTACHMENTS AND REQUIREMENTS
    void* attachment(const String& aname) const;
    void*& force_attachment(const String& aname);
    void* set_attachment(const String& aname, void* value);
 
    ErrorHandler* chatter_channel(const String& channel_name) const;
    HashMap_ArenaFactory* arena_factory() const;
 
    inline ThreadSched* thread_sched() const;
    inline void set_thread_sched(ThreadSched* scheduler);
    inline int home_thread_id(const Element* e) const;
    inline void set_home_thread_id(const Element* e, int home_thread);
    inline bool is_fullpush() const;
    inline void non_fullpush();
 
    // Needs to be public for NameInfo, but not useful outside
    inline NameInfo* name_info() const;
    NameInfo* force_name_info();
    // UNPARSING
    String configuration_string() const;
    void unparse(StringAccum& sa, const String& indent = String()) const;
    void unparse_requirements(StringAccum& sa, const String& indent = String()) const;
    void unparse_declarations(StringAccum& sa, const String& indent = String()) const;
    void unparse_connections(StringAccum& sa, const String& indent = String()) const;
 
    String element_ports_string(const Element *e) const;
 
    // INITIALIZATION
    Router(const String& configuration, Master* master);
    ~Router();
 
    static void static_initialize();
    static void static_cleanup();
 
    inline void use();
    void unuse();
 
    void add_requirement(const String &type, const String &value);
    int add_element(Element *e, const String &name, const String &conf, const String &filename, unsigned lineno);
    int add_connection(int from_idx, int from_port, int to_idx, int to_port, bool is_context, String context);
#if CLICK_LINUXMODULE
    int add_module_ref(struct module* module);
#endif
 
    inline Router* hotswap_router() const;
    void set_hotswap_router(Router* router);
 
#if CLICK_USERLEVEL
    class InitFuture { public:
        InitFuture(Element* owner = 0);
        ~InitFuture();
 
        virtual void notifyParent(InitFuture* future);
 
        virtual int solve_initialize(ErrorHandler* errh);
 
        virtual int completed(ErrorHandler* errh);
    protected:
        bool _completed;
        Element* _owner;
    };
 
    class ChildrenFuture : public InitFuture { public:
        ChildrenFuture(Element* owner = 0);
        ~ChildrenFuture();
        virtual int solve_initialize(ErrorHandler* errh);
        void postOnce(InitFuture* future);
        virtual void post(InitFuture* future);
        void post(std::function<int(ErrorHandler*)>, Element* owner = 0);
        void post(std::function<int(void)>, Element* owner = 0);
        virtual int completed(ErrorHandler* errh);
    private:
        Vector<InitFuture*> _children;
    };
 
    class FctFuture : public InitFuture { public:
        FctFuture(std::function<int(void)> f, Element* owner = 0);
        FctFuture(std::function<int(ErrorHandler*)> f, Element* owner = 0);
        ~FctFuture();
 
        virtual int solve_initialize(ErrorHandler* errh) override;
        std::function<int(ErrorHandler*)> _f;
    };
 
    class FctChildFuture : public FctFuture { public:
        FctChildFuture(std::function<int(ErrorHandler*)> f, Element* owner, InitFuture* future);
        ~FctChildFuture();
 
        virtual int solve_initialize(ErrorHandler* errh) override;
    private:
        InitFuture* _child;
    };
 
    ChildrenFuture* get_root_init_future() {
        return &_root_init_future;
    }
 
#endif
    int initialize(ErrorHandler* errh);
    void activate(bool foreground, ErrorHandler* errh);
    inline void activate(ErrorHandler* errh);
    inline void set_foreground(bool foreground);
 
    int new_notifier_signal(const char *name, NotifierSignal &signal);
    String notifier_signal_name(const atomic_uint32_t *signal) const;
 
    // Needs to be public for Lexer, etc., but not useful outside
    struct Port {
        int idx;
        int port;
 
        Port() {
        }
        Port(int i, int p)
            : idx(i), port(p) {
        }
 
        bool operator==(const Port &x) const {
            return idx == x.idx && port == x.port;
        }
        bool operator!=(const Port &x) const {
            return idx != x.idx || port != x.port;
        }
        bool operator<(const Port &x) const {
            return idx < x.idx || (idx == x.idx && port < x.port);
        }
        bool operator<=(const Port &x) const {
            return idx < x.idx || (idx == x.idx && port <= x.port);
        }
    };
 
    struct Connection {
        Port p[2];
        bool _is_context;
        String _context;
 
 
        Connection() : _is_context(false), _context("") {
        }
        Connection(int from_idx, int from_port, int to_idx, int to_port) : _is_context(false), _context("") {
            p[0] = Port(to_idx, to_port);
            p[1] = Port(from_idx, from_port);
        }
        Connection(int from_idx, int from_port, int to_idx, int to_port, bool is_context, String context) {
            p[0] = Port(to_idx, to_port);
            p[1] = Port(from_idx, from_port);
            _is_context = is_context;
            _context = context;
        }
 
        const Port &operator[](int i) const {
            assert(i >= 0 && i < 2);
            return p[i];
        }
        Port &operator[](int i) {
            assert(i >= 0 && i < 2);
            return p[i];
        }
 
        bool operator==(const Connection &x) const {
            return p[0] == x.p[0] && p[1] == x.p[1];
        }
        bool operator<(const Connection &x) const {
            return p[0] < x.p[0] || (p[0] == x.p[0] && p[1] < x.p[1]);
        }
    };
#if CLICK_NS
    simclick_node_t *simnode() const;
    int sim_get_ifid(const char* ifname);
    int sim_listen(int ifid, int element);
    int sim_if_ready(int ifid);
    int sim_write(int ifid, int ptype, const unsigned char *, int len,
                  simclick_simpacketinfo *pinfo);
    int sim_incoming_packet(int ifid, int ptype, const unsigned char *,
                            int len, simclick_simpacketinfo* pinfo);
    void sim_trace(const char* event);
    int sim_get_node_id();
    int sim_get_next_pkt_id();
    int sim_if_promisc(int ifid);
 
  protected:
    Vector<Vector<int> *> _listenvecs;
    Vector<int>* sim_listenvec(int ifid);
#endif
 
  private:
 
    class RouterContextErrh;
 
    enum {
        ROUTER_NEW, ROUTER_PRECONFIGURE, ROUTER_PREINITIALIZE,
        ROUTER_LIVE, ROUTER_DEAD                // order is important
    };
    enum {
        RUNNING_DEAD = -2, RUNNING_INACTIVE = -1, RUNNING_PREPARING = 0,
        RUNNING_BACKGROUND = 1, RUNNING_ACTIVE = 2
    };
 
    Master* _master;
    ChildrenFuture _root_init_future;
 
    atomic_uint32_t _runcount;
 
    volatile int _state;
    bool _have_connections : 1;
    mutable bool _conn_sorted : 1;
    bool _have_configuration : 1;
    volatile int _running;
 
    atomic_uint32_t _refcount;
 
    Vector<Element *> _elements;
    Vector<String> _element_names;
    Vector<String> _element_configurations;
    Vector<uint32_t> _element_landmarkids;
    mutable Vector<int> _element_home_thread_ids;
 
    struct element_landmark_t {
        uint32_t first_landmarkid;
        String filename;
    };
    Vector<element_landmark_t> _element_landmarks;
    uint32_t _last_landmarkid;
 
    mutable Vector<int> _element_name_sorter;
    Vector<int> _element_gport_offset[2];
    Vector<int> _element_configure_order;
 
    mutable Vector<Connection> _conn;
    mutable Vector<int> _conn_output_sorter;
 
    Vector<String> _requirements;
 
    Vector<int> _ehandler_first_by_element;
    Vector<int> _ehandler_to_handler;
    Vector<int> _ehandler_next;
 
    Vector<int> _handler_first_by_name;
 
    enum { HANDLER_BUFSIZ = 256 };
    Handler** _handler_bufs;
    int _nhandlers_bufs;
    int _free_handler;
 
    Vector<String> _attachment_names;
    Vector<void*> _attachments;
 
    Element* _root_element;
    String _configuration;
 
    struct notifier_signals_t {
        enum { capacity = 4096 };
        String name;
        int nsig;
        atomic_uint32_t sig[capacity / 32];
        notifier_signals_t *next;
        notifier_signals_t(const String &n, notifier_signals_t *nx)
            : name(n), nsig(0), next(nx) {
            memset(&sig[0], 0, sizeof(sig));
        }
    };
    notifier_signals_t *_notifier_signals;
    HashMap_ArenaFactory* _arena_factory;
    Router* _hotswap_router;
    ThreadSched* _thread_sched;
    bool _is_fullpush;
    mutable NameInfo* _name_info;
    Vector<int> _flow_code_override_eindex;
    Vector<String> _flow_code_override;
 
    Router* _next_router;
 
#if CLICK_LINUXMODULE
    Vector<struct module*> _modules;
#endif
 
    Router(const Router&);
    Router& operator=(const Router&);
 
    Connection *remove_connection(Connection *cp);
    void hookup_error(const Port &p, bool isoutput, const char *message,
                      ErrorHandler *errh, bool active = false);
    int check_hookup_elements(ErrorHandler*);
    int check_hookup_range(ErrorHandler*);
    int check_hookup_completeness(ErrorHandler*);
 
    const char *hard_flow_code_override(int e) const;
    int processing_error(const Connection &conn, bool, int, ErrorHandler*);
    int check_push_and_pull(ErrorHandler*);
 
    void set_connections();
    void sort_connections() const;
    int connindex_lower_bound(bool isoutput, const Port &port) const;
 
    void make_gports();
    inline int ngports(bool isout) const {
        return _element_gport_offset[isout].back();
    }
    inline int gport(bool isoutput, const Port &port) const;
 
    int hard_home_thread_id(const Element *e) const;
 
    int element_lerror(ErrorHandler*, Element*, const char*, ...) const;
 
    // private handler methods
    void initialize_handlers(bool, bool);
    inline Handler* xhandler(int) const;
    int find_ehandler(int, const String&, bool allow_star) const;
    static inline Handler fetch_handler(const Element*, const String&);
    void store_local_handler(int eindex, Handler &h);
    static void store_global_handler(Handler &h);
    static inline void store_handler(const Element *element, Handler &h);
 
    // global handlers
    static String router_read_handler(Element *e, void *user_data);
    static int router_write_handler(const String &str, Element *e, void *user_data, ErrorHandler *errh);
 
    friend class Master;
    friend class Task;
    friend class Lexer;
    friend int Element::set_nports(int, int);
};
 
 
inline void
Router::use()
{
    _refcount++;
}
 
inline bool
Router::running() const
{
    return _running > 0;
}
 
inline bool
Router::dying() const
{
    return _running == RUNNING_DEAD;
}
 
inline bool
Router::initialized() const
{
    return _state == ROUTER_LIVE;
}
 
inline bool
Router::handlers_ready() const
{
    return _state > ROUTER_PRECONFIGURE;
}
 
inline const Vector<Element*>&
Router::elements() const
{
    return _elements;
}
 
inline int
Router::nelements() const
{
    return _elements.size();
}
 
inline Element*
Router::element(int i) const
{
    return element(this, i);
}
 
inline Element*
Router::root_element() const
{
    return _root_element;
}
 
inline ThreadSched*
Router::thread_sched() const
{
    return _thread_sched;
}
 
inline void
Router::set_thread_sched(ThreadSched* ts)
{
    _thread_sched = ts;
}
 
inline int
Router::home_thread_id(const Element* e) const
{
    if (initialized())
        return _element_home_thread_ids[e->eindex() + 1];
    else
        return hard_home_thread_id(e);
}
 
inline void
Router::set_home_thread_id(const Element* e, int home_thread_id)
{
    _element_home_thread_ids[e->eindex() + 1] = home_thread_id;
}
 
 
inline bool
Router::is_fullpush() const {
    return _is_fullpush;
}
 
inline void
Router::non_fullpush() {
    _is_fullpush = false;
}
 
inline NameInfo*
Router::name_info() const
{
    return _name_info;
}
inline Master*
Router::master() const
{
    return _master;
}
 
inline int32_t
Router::runcount() const
{
    return _runcount.value();
}
 
inline void
Router::please_stop_driver()
{
    adjust_runcount(-1);
}
 
inline const char *
Router::flow_code_override(int eindex) const
{
    if (_flow_code_override.size())
        return hard_flow_code_override(eindex);
    else
        return 0;
}
 
inline void
Router::activate(ErrorHandler* errh)
{
    activate(true, errh);
}
 
inline void
Router::set_foreground(bool foreground)
{
    assert(_running >= RUNNING_BACKGROUND);
    _running = foreground ? RUNNING_ACTIVE : RUNNING_BACKGROUND;
}
 
inline Element *
Router::find(const String& name, ErrorHandler *errh) const
{
    return find(name, "", errh);
}
 
inline int
Router::visit_downstream(Element *e, int port, RouterVisitor *visitor) const
{
    return visit(e, true, port, visitor);
}
 
inline int
Router::visit_upstream(Element *e, int port, RouterVisitor *visitor) const
{
    return visit(e, false, port, visitor);
}
 
inline HashMap_ArenaFactory*
Router::arena_factory() const
{
    return _arena_factory;
}
 
inline Router*
Router::hotswap_router() const
{
    return _hotswap_router;
}
 
inline
Handler::Handler(const String &name)
    : _name(name), _read_user_data(0), _write_user_data(0), _flags(0),
      _use_count(0), _next_by_name(-1)
{
    _read_hook.r = 0;
    _write_hook.w = 0;
}
 
CLICK_ENDDECLS
#endif