lib-lnet.h

lustre 1.6.5 source code

lnet_md2handle (lnet_handle_md_t *handle, lnet_libmd_t *md)
{
        handle->cookie = md->md_lh.lh_cookie;
}

static inline lnet_libmd_t *
lnet_handle2md (lnet_handle_md_t *handle)
{
        /* ALWAYS called with liblock held */
        lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
                                                  LNET_COOKIE_TYPE_MD);
        if (lh == NULL)
                return (NULL);

        return (lh_entry (lh, lnet_libmd_t, md_lh));
}

static inline lnet_libmd_t *
lnet_wire_handle2md (lnet_handle_wire_t *wh)
{
        /* ALWAYS called with liblock held */
        lnet_libhandle_t *lh;
        
        if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie)
                return (NULL);
        
        lh = lnet_lookup_cookie(wh->wh_object_cookie,
                                LNET_COOKIE_TYPE_MD);
        if (lh == NULL)
                return (NULL);

        return (lh_entry (lh, lnet_libmd_t, md_lh));
}

static inline void
lnet_me2handle (lnet_handle_me_t *handle, lnet_me_t *me)
{
        handle->cookie = me->me_lh.lh_cookie;
}

static inline lnet_me_t *
lnet_handle2me (lnet_handle_me_t *handle)
{
        /* ALWAYS called with liblock held */
        lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
                                                  LNET_COOKIE_TYPE_ME);
        if (lh == NULL)
                return (NULL);

        return (lh_entry (lh, lnet_me_t, me_lh));
}

static inline void
lnet_peer_addref_locked(lnet_peer_t *lp)
{
        LASSERT (lp->lp_refcount > 0);
        lp->lp_refcount++;
}

extern void lnet_destroy_peer_locked(lnet_peer_t *lp);

static inline void
lnet_peer_decref_locked(lnet_peer_t *lp)
{
        LASSERT (lp->lp_refcount > 0);
        lp->lp_refcount--;
        if (lp->lp_refcount == 0)
                lnet_destroy_peer_locked(lp);
}

static inline int
lnet_isrouter(lnet_peer_t *lp)
{
        return lp->lp_rtr_refcount != 0;
}

static inline void
lnet_ni_addref_locked(lnet_ni_t *ni) 
{
        LASSERT (ni->ni_refcount > 0);
        ni->ni_refcount++;
}

static inline void
lnet_ni_addref(lnet_ni_t *ni) 
{
        LNET_LOCK();
        lnet_ni_addref_locked(ni);
        LNET_UNLOCK();
}

static inline void
lnet_ni_decref_locked(lnet_ni_t *ni)
{
        LASSERT (ni->ni_refcount > 0);
        ni->ni_refcount--;
        if (ni->ni_refcount == 0)
                list_add_tail(&ni->ni_list, &the_lnet.ln_zombie_nis);
}

static inline void
lnet_ni_decref(lnet_ni_t *ni)
{
        LNET_LOCK();
        lnet_ni_decref_locked(ni);
        LNET_UNLOCK();
}

static inline lnet_nid_t
lnet_ptlcompat_srcnid(lnet_nid_t src, lnet_nid_t dst)
{
        /* Give myself a portals srcnid if I'm sending to portals */
        if (the_lnet.ln_ptlcompat > 0 &&   
            LNET_NIDNET(dst) == 0)
                return LNET_MKNID(0, LNET_NIDADDR(src));
        
        return src;
}

static inline int
lnet_ptlcompat_matchnid(lnet_nid_t lnet_nid, lnet_nid_t ptl_nid) 
{
        return ((ptl_nid == lnet_nid) ||
                (the_lnet.ln_ptlcompat > 0 &&
                 LNET_NIDNET(ptl_nid) == 0 &&
                 LNET_NETTYP(LNET_NIDNET(lnet_nid)) != LOLND &&
                 LNET_NIDADDR(ptl_nid) == LNET_NIDADDR(lnet_nid)));
}

static inline int
lnet_ptlcompat_matchnet(__u32 lnet_net, __u32 ptl_net) 
{
        return ((ptl_net == lnet_net) ||
                (the_lnet.ln_ptlcompat > 0 &&
                 ptl_net == 0 &&
                 LNET_NETTYP(lnet_net) != LOLND));
}

static inline struct list_head *
lnet_nid2peerhash (lnet_nid_t nid)
{
	unsigned int idx = LNET_NIDADDR(nid) % LNET_PEER_HASHSIZE;

        return &the_lnet.ln_peer_hash[idx];
}

extern lnd_t the_lolnd;

#ifndef __KERNEL__
/* unconditional registration */
#define LNET_REGISTER_ULND(lnd)                 \
do {                                            \
        extern lnd_t lnd;                       \
                                                \
        lnet_register_lnd(&(lnd));              \
} while (0)

/* conditional registration */
#define LNET_REGISTER_ULND_IF_PRESENT(lnd)                              \
do {                                                                    \
        extern lnd_t lnd __attribute__ ((weak, alias("the_lolnd")));    \
                                                                        \
        if (&(lnd) != &the_lolnd)                                       \
                lnet_register_lnd(&(lnd));                              \
} while (0)
#endif

#ifdef CRAY_XT3
inline static void
lnet_set_msg_uid(lnet_ni_t *ni, lnet_msg_t *msg, lnet_uid_t uid)
{
        LASSERT (msg->msg_ev.uid == LNET_UID_ANY);
        msg->msg_ev.uid = uid;
}
#endif

extern lnet_ni_t *lnet_nid2ni_locked (lnet_nid_t nid);
extern lnet_ni_t *lnet_net2ni_locked (__u32 net);
static inline lnet_ni_t *
lnet_net2ni (__u32 net) 
{
        lnet_ni_t *ni;

        LNET_LOCK();
        ni = lnet_net2ni_locked(net);
        LNET_UNLOCK();

        return ni;
}

int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, time_t when);
int lnet_add_route(__u32 net, unsigned int hops, lnet_nid_t gateway_nid);
int lnet_check_routes(void);
int lnet_del_route(__u32 net, lnet_nid_t gw_nid);
void lnet_destroy_routes(void);
int lnet_get_route(int idx, __u32 *net, __u32 *hops, 
                   lnet_nid_t *gateway, __u32 *alive);
void lnet_proc_init(void);
void lnet_proc_fini(void);
void lnet_init_rtrpools(void);
int  lnet_alloc_rtrpools(int im_a_router);
void lnet_free_rtrpools(void);
lnet_remotenet_t *lnet_find_net_locked (__u32 net);

int lnet_islocalnid(lnet_nid_t nid);
int lnet_islocalnet(__u32 net);

void lnet_enq_event_locked(lnet_eq_t *eq, lnet_event_t *ev);
void lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target,
                    unsigned int offset, unsigned int len);
int lnet_send(lnet_nid_t nid, lnet_msg_t *msg);
void lnet_return_credits_locked (lnet_msg_t *msg);
void lnet_match_blocked_msg(lnet_libmd_t *md);
int lnet_parse (lnet_ni_t *ni, lnet_hdr_t *hdr,
                lnet_nid_t fromnid, void *private, int rdma_req);
void lnet_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
               unsigned int offset, unsigned int mlen, unsigned int rlen);
lnet_msg_t *lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *get_msg);
void lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *msg, unsigned int len);
void lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int rc);

char *lnet_msgtyp2str (int type);
void lnet_print_hdr (lnet_hdr_t * hdr);
int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold);

unsigned int lnet_iov_nob (unsigned int niov, struct iovec *iov);
int lnet_extract_iov (int dst_niov, struct iovec *dst,
                      int src_niov, struct iovec *src,
                      unsigned int offset, unsigned int len);

unsigned int lnet_kiov_nob (unsigned int niov, lnet_kiov_t *iov);
int lnet_extract_kiov (int dst_niov, lnet_kiov_t *dst, 
                      int src_niov, lnet_kiov_t *src,
                      unsigned int offset, unsigned int len);

void lnet_copy_iov2iov (unsigned int ndiov, struct iovec *diov, 
                        unsigned int doffset, 
                        unsigned int nsiov, struct iovec *siov, 
                        unsigned int soffset, unsigned int nob);
void lnet_copy_kiov2iov (unsigned int niov, struct iovec *iov, 
                         unsigned int iovoffset,
                         unsigned int nkiov, lnet_kiov_t *kiov, 
                         unsigned int kiovoffset, unsigned int nob);
void lnet_copy_iov2kiov (unsigned int nkiov, lnet_kiov_t *kiov, 
                         unsigned int kiovoffset,
                         unsigned int niov, struct iovec *iov, 
                         unsigned int iovoffset, unsigned int nob);
void lnet_copy_kiov2kiov (unsigned int ndkiov, lnet_kiov_t *dkiov, 
                          unsigned int doffset, 
                          unsigned int nskiov, lnet_kiov_t *skiov, 
                          unsigned int soffset, unsigned int nob);

static inline void
lnet_copy_iov2flat(int dlen, void *dest, unsigned int doffset,
                   unsigned int nsiov, struct iovec *siov, unsigned int soffset,
                   unsigned int nob)
{
        struct iovec diov = {/*.iov_base = */ dest, /*.iov_len = */ dlen};

        lnet_copy_iov2iov(1, &diov, doffset,
                          nsiov, siov, soffset, nob);
}

static inline void
lnet_copy_kiov2flat(int dlen, void *dest, unsigned int doffset,
                    unsigned int nsiov, lnet_kiov_t *skiov, unsigned int soffset,
                    unsigned int nob)
{
        struct iovec diov = {/* .iov_base = */ dest, /* .iov_len = */ dlen};

        lnet_copy_kiov2iov(1, &diov, doffset,
                           nsiov, skiov, soffset, nob);
}

static inline void
lnet_copy_flat2iov(unsigned int ndiov, struct iovec *diov, unsigned int doffset,
                   int slen, void *src, unsigned int soffset, unsigned int nob)
{
        struct iovec siov = {/*.iov_base = */ src, /*.iov_len = */slen};
        lnet_copy_iov2iov(ndiov, diov, doffset,
                          1, &siov, soffset, nob);
}

static inline void
lnet_copy_flat2kiov(unsigned int ndiov, lnet_kiov_t *dkiov, unsigned int doffset,
                    int slen, void *src, unsigned int soffset, unsigned int nob)
{
        struct iovec siov = {/* .iov_base = */ src, /* .iov_len = */ slen};
        lnet_copy_iov2kiov(ndiov, dkiov, doffset,
                           1, &siov, soffset, nob);
}

void lnet_me_unlink(lnet_me_t *me);

void lnet_md_unlink(lnet_libmd_t *md);
void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd);

void lnet_register_lnd(lnd_t *lnd);
void lnet_unregister_lnd(lnd_t *lnd);
int lnet_set_ip_niaddr (lnet_ni_t *ni);

#ifdef __KERNEL__
int lnet_connect(cfs_socket_t **sockp, lnet_nid_t peer_nid,
                 __u32 local_ip, __u32 peer_ip, int peer_port);
void lnet_connect_console_error(int rc, lnet_nid_t peer_nid,
                                __u32 peer_ip, int port);
int lnet_count_acceptor_nis(lnet_ni_t **first_ni);
int lnet_accept(lnet_ni_t *blind_ni, cfs_socket_t *sock, __u32 magic);
int lnet_acceptor_timeout(void);
int lnet_acceptor_port(void);
#endif

#ifdef HAVE_LIBPTHREAD
int lnet_count_acceptor_nis(lnet_ni_t **first_ni);
int lnet_acceptor_port(void);
#endif

int lnet_acceptor_start(void);
void lnet_acceptor_stop(void);

int lnet_peers_start_down(void);
int lnet_router_checker_start(void);
void lnet_router_checker_stop(void);

int lnet_ping_target_init(void);
void lnet_ping_target_fini(void);
int lnet_ping(lnet_process_id_t id, int timeout_ms,
              lnet_process_id_t *ids, int n_ids);

int lnet_parse_ip2nets (char **networksp, char *ip2nets);
int lnet_parse_routes (char *route_str, int *im_a_router);
int lnet_parse_networks (struct list_head *nilist, char *networks);

int lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid);
lnet_peer_t *lnet_find_peer_locked (lnet_nid_t nid);
void lnet_clear_peer_table(void);
void lnet_destroy_peer_table(void);
int lnet_create_peer_table(void);
void lnet_debug_peer(lnet_nid_t nid);

#endif