.flags = 0, \
.event = 0, \
.hits = 0, \
- .linkage = PTL_LIST_HEAD_INIT(name.linkage), \
+ .linkage = CFS_LIST_HEAD_INIT(name.linkage), \
.magic = KSLEEP_LINK_MAGIC \
}
#define CLASSERT(cond) ({ switch(42) { case (cond): case 0: break; } })
/* support decl needed both by kernel and liblustre */
-int libcfs_isknown_nal(int type);
-char *libcfs_nal2modname(int type);
-char *libcfs_nal2str(int type);
-int libcfs_str2nal(char *str);
+int libcfs_isknown_lnd(int type);
+char *libcfs_lnd2modname(int type);
+char *libcfs_lnd2str(int type);
+int libcfs_str2lnd(char *str);
char *libcfs_net2str(__u32 net);
char *libcfs_nid2str(lnet_nid_t nid);
__u32 libcfs_str2net(char *str);
#define PTL_MKNID(net,addr) ((((__u64)(net))<<32)|((__u64)(addr)))
/* how net encodes type:number */
#define PTL_NETNUM(net) ((net) & 0xffff)
-#define PTL_NETNAL(net) (((net) >> 16) & 0xffff)
-#define PTL_MKNET(nal,num) ((((__u32)(nal))<<16)|((__u32)(num)))
+#define PTL_NETTYP(net) (((net) >> 16) & 0xffff)
+#define PTL_MKNET(typ,num) ((((__u32)(typ))<<16)|((__u32)(num)))
#ifndef CURRENT_TIME
# define CURRENT_TIME time(0)
#define IOC_PORTAL_LWT_LOOKUP_STRING _IOWR('e', 35, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_MEMHOG _IOWR('e', 36, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_PING _IOWR('e', 37, IOCTL_PORTAL_TYPE)
-/* portals ioctls */
+/* lnet ioctls */
#define IOC_PORTAL_GET_NI _IOWR('e', 50, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_FAIL_NID _IOWR('e', 51, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_ADD_ROUTE _IOWR('e', 52, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_NOTIFY_ROUTER _IOWR('e', 55, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_UNCONFIGURE _IOWR('e', 56, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_PORTALS_COMPATIBILITY _IOWR('e', 57, IOCTL_PORTAL_TYPE)
-/* nal ioctls */
+/* lnd ioctls */
#define IOC_PORTAL_REGISTER_MYNID _IOWR('e', 70, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_CLOSE_CONNECTION _IOWR('e', 71, IOCTL_PORTAL_TYPE)
#define IOC_PORTAL_PUSH_CONNECTION _IOWR('e', 72, IOCTL_PORTAL_TYPE)
enum {
/* Only add to these values (i.e. don't ever change or redefine them):
* network addresses depend on them... */
- QSWNAL = 1,
- SOCKNAL = 2,
- GMNAL = 3,
+ QSWLND = 1,
+ SOCKLND = 2,
+ GMLND = 3,
PTLLND = 4,
/* unused 5 */
/* unused 6 */
- OPENIBNAL = 7,
- IIBNAL = 8,
- LONAL = 9,
- RANAL = 10,
- VIBNAL = 11,
+ OPENIBLND = 7,
+ IIBLND = 8,
+ LOLND = 9,
+ RALND = 10,
+ VIBLND = 11,
};
enum {
int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand);
/* libcfs tcpip */
-#define PTL_ACCEPTOR_MIN_RESERVED_PORT 512
-#define PTL_ACCEPTOR_MAX_RESERVED_PORT 1023
+#define LNET_ACCEPTOR_MIN_RESERVED_PORT 512
+#define LNET_ACCEPTOR_MAX_RESERVED_PORT 1023
int libcfs_ipif_query(char *name, int *up, __u32 *ip, __u32 *mask);
int libcfs_ipif_enumerate(char ***names);
#include <lnet/lnet.h>
#include <lnet/lib-types.h>
-extern lnet_apini_t lnet_apini; /* THE network interface (at the API) */
+extern lnet_t the_lnet; /* THE network */
-static inline int ptl_is_wire_handle_none (ptl_handle_wire_t *wh)
+static inline int lnet_is_wire_handle_none (lnet_handle_wire_t *wh)
{
- return (wh->wh_interface_cookie == PTL_WIRE_HANDLE_NONE.wh_interface_cookie &&
- wh->wh_object_cookie == PTL_WIRE_HANDLE_NONE.wh_object_cookie);
+ return (wh->wh_interface_cookie == LNET_WIRE_HANDLE_NONE.wh_interface_cookie &&
+ wh->wh_object_cookie == LNET_WIRE_HANDLE_NONE.wh_object_cookie);
}
-static inline int ptl_md_exhausted (ptl_libmd_t *md)
+static inline int lnet_md_exhausted (lnet_libmd_t *md)
{
return (md->md_threshold == 0 ||
((md->md_options & LNET_MD_MAX_SIZE) != 0 &&
}
#ifdef __KERNEL__
-#define PTL_LOCK(flags) \
- spin_lock_irqsave(&lnet_apini.apini_lock, flags)
-#define PTL_UNLOCK(flags) \
- spin_unlock_irqrestore(&lnet_apini.apini_lock, flags)
-#define PTL_MUTEX_DOWN(m) mutex_down(m)
-#define PTL_MUTEX_UP(m) mutex_up(m)
+#define LNET_LOCK(flags) \
+ spin_lock_irqsave(&the_lnet.ln_lock, flags)
+#define LNET_UNLOCK(flags) \
+ spin_unlock_irqrestore(&the_lnet.ln_lock, flags)
+#define LNET_MUTEX_DOWN(m) mutex_down(m)
+#define LNET_MUTEX_UP(m) mutex_up(m)
#else
-#define PTL_LOCK(flags) \
- (pthread_mutex_lock(&lnet_apini.apini_mutex), (flags) = 0)
-#define PTL_UNLOCK(flags) \
- pthread_mutex_unlock(&lnet_apini.apini_mutex)
-#define PTL_MUTEX_DOWN(m) pthread_mutex_lock(m)
-#define PTL_MUTEX_UP(m) pthread_mutex_unlock(m)
+#define LNET_LOCK(flags) \
+ (pthread_mutex_lock(&the_lnet.ln_mutex), (flags) = 0)
+#define LNET_UNLOCK(flags) \
+ pthread_mutex_unlock(&the_lnet.ln_mutex)
+#define LNET_MUTEX_DOWN(m) pthread_mutex_lock(m)
+#define LNET_MUTEX_UP(m) pthread_mutex_unlock(m)
#endif
#define MAX_PORTALS 64
-#ifdef PTL_USE_LIB_FREELIST
+#ifdef LNET_USE_LIB_FREELIST
#define MAX_MES 2048
#define MAX_MDS 2048
#define MAX_EQS 512
static inline void *
-ptl_freelist_alloc (ptl_freelist_t *fl)
+lnet_freelist_alloc (lnet_freelist_t *fl)
{
/* ALWAYS called with liblock held */
- ptl_freeobj_t *o;
+ lnet_freeobj_t *o;
if (list_empty (&fl->fl_list))
return (NULL);
- o = list_entry (fl->fl_list.next, ptl_freeobj_t, fo_list);
+ o = list_entry (fl->fl_list.next, lnet_freeobj_t, fo_list);
list_del (&o->fo_list);
return ((void *)&o->fo_contents);
}
static inline void
-ptl_freelist_free (ptl_freelist_t *fl, void *obj)
+lnet_freelist_free (lnet_freelist_t *fl, void *obj)
{
/* ALWAYS called with liblock held */
- ptl_freeobj_t *o = list_entry (obj, ptl_freeobj_t, fo_contents);
+ lnet_freeobj_t *o = list_entry (obj, lnet_freeobj_t, fo_contents);
list_add (&o->fo_list, &fl->fl_list);
}
-static inline ptl_eq_t *
-ptl_eq_alloc (void)
+static inline lnet_eq_t *
+lnet_eq_alloc (void)
{
/* NEVER called with liblock held */
unsigned long flags;
- ptl_eq_t *eq;
+ lnet_eq_t *eq;
- PTL_LOCK(flags);
- eq = (ptl_eq_t *)ptl_freelist_alloc(&lnet_apini.apini_free_eqs);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ eq = (lnet_eq_t *)lnet_freelist_alloc(&the_lnet.ln_free_eqs);
+ LNET_UNLOCK(flags);
return (eq);
}
static inline void
-ptl_eq_free (ptl_eq_t *eq)
+lnet_eq_free (lnet_eq_t *eq)
{
/* ALWAYS called with liblock held */
- ptl_freelist_free(&lnet_apini.apini_free_eqs, eq);
+ lnet_freelist_free(&the_lnet.ln_free_eqs, eq);
}
-static inline ptl_libmd_t *
-ptl_md_alloc (lnet_md_t *umd)
+static inline lnet_libmd_t *
+lnet_md_alloc (lnet_md_t *umd)
{
/* NEVER called with liblock held */
unsigned long flags;
- ptl_libmd_t *md;
+ lnet_libmd_t *md;
- PTL_LOCK(flags);
- md = (ptl_libmd_t *)ptl_freelist_alloc(&lnet_apini.apini_free_mds);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ md = (lnet_libmd_t *)lnet_freelist_alloc(&the_lnet.ln_free_mds);
+ LNET_UNLOCK(flags);
return (md);
}
static inline void
-ptl_md_free (ptl_libmd_t *md)
+lnet_md_free (lnet_libmd_t *md)
{
/* ALWAYS called with liblock held */
- ptl_freelist_free (&lnet_apini.apini_free_mds, md);
+ lnet_freelist_free (&the_lnet.ln_free_mds, md);
}
-static inline ptl_me_t *
-ptl_me_alloc (void)
+static inline lnet_me_t *
+lnet_me_alloc (void)
{
/* NEVER called with liblock held */
unsigned long flags;
- ptl_me_t *me;
+ lnet_me_t *me;
- PTL_LOCK(flags);
- me = (ptl_me_t *)ptl_freelist_alloc(&lnet_apini.apini_free_mes);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ me = (lnet_me_t *)lnet_freelist_alloc(&the_lnet.ln_free_mes);
+ LNET_UNLOCK(flags);
return (me);
}
static inline void
-ptl_me_free (ptl_me_t *me)
+lnet_me_free (lnet_me_t *me)
{
/* ALWAYS called with liblock held */
- ptl_freelist_free (&lnet_apini.apini_free_mes, me);
+ lnet_freelist_free (&the_lnet.ln_free_mes, me);
}
-static inline ptl_msg_t *
-ptl_msg_alloc (void)
+static inline lnet_msg_t *
+lnet_msg_alloc (void)
{
/* NEVER called with liblock held */
unsigned long flags;
- ptl_msg_t *msg;
+ lnet_msg_t *msg;
- PTL_LOCK(flags);
- msg = (ptl_msg_t *)ptl_freelist_alloc(&lnet_apini.apini_free_msgs);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ msg = (lnet_msg_t *)lnet_freelist_alloc(&the_lnet.ln_free_msgs);
+ LNET_UNLOCK(flags);
if (msg != NULL) {
/* NULL pointers, clear flags etc */
memset (msg, 0, sizeof (*msg));
- msg->msg_ack_wmd = PTL_WIRE_HANDLE_NONE;
+ msg->msg_ack_wmd = LNET_WIRE_HANDLE_NONE;
}
return(msg);
}
static inline void
-ptl_msg_free (ptl_msg_t *msg)
+lnet_msg_free (lnet_msg_t *msg)
{
/* ALWAYS called with liblock held */
- ptl_freelist_free(&lnet_apini.apini_free_msgs, msg);
+ lnet_freelist_free(&the_lnet.ln_free_msgs, msg);
}
#else
-static inline ptl_eq_t *
-ptl_eq_alloc (void)
+static inline lnet_eq_t *
+lnet_eq_alloc (void)
{
/* NEVER called with liblock held */
- ptl_eq_t *eq;
+ lnet_eq_t *eq;
PORTAL_ALLOC(eq, sizeof(*eq));
return (eq);
}
static inline void
-ptl_eq_free (ptl_eq_t *eq)
+lnet_eq_free (lnet_eq_t *eq)
{
/* ALWAYS called with liblock held */
PORTAL_FREE(eq, sizeof(*eq));
}
-static inline ptl_libmd_t *
-ptl_md_alloc (lnet_md_t *umd)
+static inline lnet_libmd_t *
+lnet_md_alloc (lnet_md_t *umd)
{
/* NEVER called with liblock held */
- ptl_libmd_t *md;
- int size;
- int niov;
+ lnet_libmd_t *md;
+ int size;
+ unsigned int niov;
if ((umd->options & LNET_MD_KIOV) != 0) {
niov = umd->length;
- size = offsetof(ptl_libmd_t, md_iov.kiov[niov]);
+ size = offsetof(lnet_libmd_t, md_iov.kiov[niov]);
} else {
niov = ((umd->options & LNET_MD_IOVEC) != 0) ?
umd->length : 1;
- size = offsetof(ptl_libmd_t, md_iov.iov[niov]);
+ size = offsetof(lnet_libmd_t, md_iov.iov[niov]);
}
PORTAL_ALLOC(md, size);
}
static inline void
-ptl_md_free (ptl_libmd_t *md)
+lnet_md_free (lnet_libmd_t *md)
{
/* ALWAYS called with liblock held */
int size;
if ((md->md_options & LNET_MD_KIOV) != 0)
- size = offsetof(ptl_libmd_t, md_iov.kiov[md->md_niov]);
+ size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]);
else
- size = offsetof(ptl_libmd_t, md_iov.iov[md->md_niov]);
+ size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]);
PORTAL_FREE(md, size);
}
-static inline ptl_me_t *
-ptl_me_alloc (void)
+static inline lnet_me_t *
+lnet_me_alloc (void)
{
/* NEVER called with liblock held */
- ptl_me_t *me;
+ lnet_me_t *me;
PORTAL_ALLOC(me, sizeof(*me));
return (me);
}
static inline void
-ptl_me_free(ptl_me_t *me)
+lnet_me_free(lnet_me_t *me)
{
/* ALWAYS called with liblock held */
PORTAL_FREE(me, sizeof(*me));
}
-static inline ptl_msg_t *
-ptl_msg_alloc(void)
+static inline lnet_msg_t *
+lnet_msg_alloc(void)
{
/* NEVER called with liblock held; may be in interrupt... */
- ptl_msg_t *msg;
+ lnet_msg_t *msg;
if (in_interrupt())
PORTAL_ALLOC_ATOMIC(msg, sizeof(*msg));
if (msg != NULL) {
/* NULL pointers, clear flags etc */
memset (msg, 0, sizeof (*msg));
- msg->msg_ack_wmd = PTL_WIRE_HANDLE_NONE;
+ msg->msg_ack_wmd = LNET_WIRE_HANDLE_NONE;
}
return (msg);
}
static inline void
-ptl_msg_free(ptl_msg_t *msg)
+lnet_msg_free(lnet_msg_t *msg)
{
/* ALWAYS called with liblock held */
PORTAL_FREE(msg, sizeof(*msg));
}
#endif
-extern ptl_libhandle_t *ptl_lookup_cookie (__u64 cookie, int type);
-extern void ptl_initialise_handle (ptl_libhandle_t *lh, int type);
-extern void ptl_invalidate_handle (ptl_libhandle_t *lh);
+extern lnet_libhandle_t *lnet_lookup_cookie (__u64 cookie, int type);
+extern void lnet_initialise_handle (lnet_libhandle_t *lh, int type);
+extern void lnet_invalidate_handle (lnet_libhandle_t *lh);
static inline void
-ptl_eq2handle (lnet_handle_eq_t *handle, ptl_eq_t *eq)
+lnet_eq2handle (lnet_handle_eq_t *handle, lnet_eq_t *eq)
{
if (eq == NULL) {
*handle = LNET_EQ_NONE;
handle->cookie = eq->eq_lh.lh_cookie;
}
-static inline ptl_eq_t *
-ptl_handle2eq (lnet_handle_eq_t *handle)
+static inline lnet_eq_t *
+lnet_handle2eq (lnet_handle_eq_t *handle)
{
/* ALWAYS called with liblock held */
- ptl_libhandle_t *lh = ptl_lookup_cookie (handle->cookie,
- PTL_COOKIE_TYPE_EQ);
+ lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
+ LNET_COOKIE_TYPE_EQ);
if (lh == NULL)
return (NULL);
- return (lh_entry (lh, ptl_eq_t, eq_lh));
+ return (lh_entry (lh, lnet_eq_t, eq_lh));
}
static inline void
-ptl_md2handle (lnet_handle_md_t *handle, ptl_libmd_t *md)
+lnet_md2handle (lnet_handle_md_t *handle, lnet_libmd_t *md)
{
handle->cookie = md->md_lh.lh_cookie;
}
-static inline ptl_libmd_t *
-ptl_handle2md (lnet_handle_md_t *handle)
+static inline lnet_libmd_t *
+lnet_handle2md (lnet_handle_md_t *handle)
{
/* ALWAYS called with liblock held */
- ptl_libhandle_t *lh = ptl_lookup_cookie (handle->cookie,
- PTL_COOKIE_TYPE_MD);
+ lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
+ LNET_COOKIE_TYPE_MD);
if (lh == NULL)
return (NULL);
- return (lh_entry (lh, ptl_libmd_t, md_lh));
+ return (lh_entry (lh, lnet_libmd_t, md_lh));
}
-static inline ptl_libmd_t *
-ptl_wire_handle2md (ptl_handle_wire_t *wh)
+static inline lnet_libmd_t *
+lnet_wire_handle2md (lnet_handle_wire_t *wh)
{
/* ALWAYS called with liblock held */
- ptl_libhandle_t *lh;
+ lnet_libhandle_t *lh;
- if (wh->wh_interface_cookie != lnet_apini.apini_interface_cookie)
+ if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie)
return (NULL);
- lh = ptl_lookup_cookie (wh->wh_object_cookie,
- PTL_COOKIE_TYPE_MD);
+ lh = lnet_lookup_cookie(wh->wh_object_cookie,
+ LNET_COOKIE_TYPE_MD);
if (lh == NULL)
return (NULL);
- return (lh_entry (lh, ptl_libmd_t, md_lh));
+ return (lh_entry (lh, lnet_libmd_t, md_lh));
}
static inline void
-ptl_me2handle (lnet_handle_me_t *handle, ptl_me_t *me)
+lnet_me2handle (lnet_handle_me_t *handle, lnet_me_t *me)
{
handle->cookie = me->me_lh.lh_cookie;
}
-static inline ptl_me_t *
-ptl_handle2me (lnet_handle_me_t *handle)
+static inline lnet_me_t *
+lnet_handle2me (lnet_handle_me_t *handle)
{
/* ALWAYS called with liblock held */
- ptl_libhandle_t *lh = ptl_lookup_cookie (handle->cookie,
- PTL_COOKIE_TYPE_ME);
+ lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
+ LNET_COOKIE_TYPE_ME);
if (lh == NULL)
return (NULL);
- return (lh_entry (lh, ptl_me_t, me_lh));
+ return (lh_entry (lh, lnet_me_t, me_lh));
}
/******************************************************************************/
/* NI APIs */
int lnet_forwarding(void);
-lnet_nid_t lnet_lookup(ptl_ni_t **ni, lnet_nid_t nid, int nob);
-void lnet_fwd_start(ptl_ni_t *ni, kpr_fwd_desc_t *fwd);
-void lnet_fwd_done(ptl_ni_t *ni, kpr_fwd_desc_t *fwd, int error);
-int lnet_notify(ptl_ni_t *ni, lnet_nid_t peer, int alive, time_t when);
+lnet_nid_t lnet_lookup(lnet_ni_t **ni, lnet_nid_t nid, int nob);
+int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, time_t when);
/* internal APIs */
int kpr_distance(lnet_nid_t nid, int *order);
int kpr_initialise(void);
void kpr_finalise(void);
-static inline void
-kpr_fwd_init (kpr_fwd_desc_t *fwd, lnet_nid_t target_nid,
- lnet_nid_t sender_nid, lnet_nid_t source_nid,
- ptl_hdr_t *hdr, int nob, int niov, lnet_kiov_t *kiov,
- kpr_fwd_callback_t callback, void *callback_arg)
-{
- fwd->kprfd_target_nid = target_nid;
- fwd->kprfd_gateway_nid = target_nid;
- fwd->kprfd_sender_nid = sender_nid;
- fwd->kprfd_source_nid = source_nid;
- fwd->kprfd_hdr = hdr;
- fwd->kprfd_nob = nob;
- fwd->kprfd_niov = niov;
- fwd->kprfd_kiov = kiov;
- fwd->kprfd_callback = callback;
- fwd->kprfd_callback_arg = callback_arg;
-}
-
/******************************************************************************/
static inline void
-ptl_ni_addref_locked(ptl_ni_t *ni)
+lnet_ni_addref_locked(lnet_ni_t *ni)
{
LASSERT (ni->ni_refcount > 0);
ni->ni_refcount++;
}
static inline void
-ptl_ni_addref(ptl_ni_t *ni)
+lnet_ni_addref(lnet_ni_t *ni)
{
unsigned long flags;
- PTL_LOCK(flags);
- ptl_ni_addref_locked(ni);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ lnet_ni_addref_locked(ni);
+ LNET_UNLOCK(flags);
}
static inline void
-ptl_ni_decref_locked(ptl_ni_t *ni)
+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, &lnet_apini.apini_zombie_nis);
+ list_add_tail(&ni->ni_list, &the_lnet.ln_zombie_nis);
}
static inline void
-ptl_ni_decref(ptl_ni_t *ni)
+lnet_ni_decref(lnet_ni_t *ni)
{
unsigned long flags;
- PTL_LOCK(flags);
- ptl_ni_decref_locked(ni);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ lnet_ni_decref_locked(ni);
+ LNET_UNLOCK(flags);
}
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 (lnet_apini.apini_ptlcompat > 0 &&
+ if (the_lnet.ln_ptlcompat > 0 &&
PTL_NIDNET(dst) == 0)
return PTL_MKNID(0, PTL_NIDADDR(src));
lnet_ptlcompat_matchnid(lnet_nid_t lnet_nid, lnet_nid_t ptl_nid)
{
return ((ptl_nid == lnet_nid) ||
- (lnet_apini.apini_ptlcompat > 0 &&
+ (the_lnet.ln_ptlcompat > 0 &&
PTL_NIDNET(ptl_nid) == 0 &&
PTL_NIDADDR(ptl_nid) == PTL_NIDADDR(lnet_nid)));
}
-extern ptl_nal_t ptl_lonal;
-extern ptl_ni_t *ptl_loni;
-
-extern ptl_ni_t *lnet_net2ni (__u32 net);
-extern int ptl_islocalnid (lnet_nid_t nid);
-extern int ptl_islocalnet (__u32 net, int *orderp);
-extern void ptl_enq_event_locked (void *private,
- ptl_eq_t *eq, lnet_event_t *ev);
-extern void lnet_finalize (ptl_ni_t *ni, void *private, ptl_msg_t *msg, int rc);
-extern int lnet_parse (ptl_ni_t *ni, ptl_hdr_t *hdr, void *private);
-extern ptl_msg_t *lnet_create_reply_msg (ptl_ni_t *ni, lnet_nid_t peer_nid,
- ptl_msg_t *get_msg);
-extern void ptl_print_hdr (ptl_hdr_t * hdr);
-extern int ptl_fail_nid(lnet_nid_t nid, unsigned int threshold);
-
-extern unsigned int lnet_iov_nob (int niov, struct iovec *iov);
-extern void lnet_copy_iov2buf (char *dest, int niov, struct iovec *iov,
- unsigned int offset, unsigned int len);
-extern void lnet_copy_buf2iov (int niov, struct iovec *iov, unsigned int offset,
- char *src, unsigned int len);
+extern lnd_t the_lolnd;
+extern lnet_ni_t *lnet_loni;
+
+extern lnet_ni_t *lnet_net2ni (__u32 net);
+extern int lnet_islocalnid (lnet_nid_t nid);
+extern int lnet_islocalnet (__u32 net, int *orderp);
+extern void lnet_enq_event_locked (void *private,
+ lnet_eq_t *eq, lnet_event_t *ev);
+extern void lnet_finalize (lnet_ni_t *ni, void *private, lnet_msg_t *msg, int rc);
+extern int lnet_parse (lnet_ni_t *ni, lnet_hdr_t *hdr, void *private);
+extern lnet_msg_t *lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *get_msg);
+extern void lnet_print_hdr (lnet_hdr_t * hdr);
+extern int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold);
+
+extern unsigned int lnet_iov_nob (unsigned int niov, struct iovec *iov);
extern int lnet_extract_iov (int dst_niov, struct iovec *dst,
int src_niov, struct iovec *src,
unsigned int offset, unsigned int len);
-extern unsigned int lnet_kiov_nob (int niov, lnet_kiov_t *iov);
-extern void lnet_copy_kiov2buf (char *dest, int niov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int len);
-extern void lnet_copy_buf2kiov (int niov, lnet_kiov_t *kiov, unsigned int offset,
- char *src, unsigned int len);
+extern unsigned int lnet_kiov_nob (unsigned int niov, lnet_kiov_t *iov);
extern int lnet_extract_kiov (int dst_niov, lnet_kiov_t *dst,
int src_niov, lnet_kiov_t *src,
unsigned int offset, unsigned int len);
-extern lnet_pid_t lnet_getpid(void);
+extern 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);
+extern 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);
+extern 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);
+extern 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);
+}
-extern int ptl_recv (ptl_ni_t *ni, void *private, ptl_msg_t *msg, ptl_libmd_t *md,
- unsigned int offset, unsigned int mlen, unsigned int rlen);
-extern int ptl_send (ptl_ni_t *ni, void *private, ptl_msg_t *msg,
- ptl_hdr_t *hdr, int type, lnet_process_id_t target,
- ptl_libmd_t *md, unsigned int offset, unsigned int len);
+extern int lnet_send(lnet_ni_t *ni, void *private, lnet_msg_t *msg,
+ int type, lnet_process_id_t target,
+ lnet_libmd_t *md, unsigned int offset, unsigned int len);
-extern void ptl_me_unlink(ptl_me_t *me);
+extern void lnet_me_unlink(lnet_me_t *me);
-extern void ptl_md_unlink(ptl_libmd_t *md);
-extern void ptl_md_deconstruct(ptl_libmd_t *lmd, lnet_md_t *umd);
+extern void lnet_md_unlink(lnet_libmd_t *md);
+extern void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd);
-extern void lnet_register_nal(ptl_nal_t *nal);
-extern void lnet_unregister_nal(ptl_nal_t *nal);
-extern int lnet_set_ip_niaddr (ptl_ni_t *ni);
+extern void lnet_register_lnd(lnd_t *lnd);
+extern void lnet_unregister_lnd(lnd_t *lnd);
+extern int lnet_set_ip_niaddr (lnet_ni_t *ni);
#ifdef __KERNEL__
extern int lnet_connect(struct socket **sockp, lnet_nid_t peer_nid,
extern void lnet_connect_console_error(int rc, lnet_nid_t peer_nid,
__u32 peer_ip, int port);
-extern int ptl_count_acceptor_nis(ptl_ni_t **first_ni);
+extern int lnet_count_acceptor_nis(lnet_ni_t **first_ni);
-extern int lnet_accept(ptl_ni_t *blind_ni, struct socket *sock, __u32 magic);
-extern int lnet_acceptor_timeout(void);
-extern int lnet_acceptor_port(void);
+extern int lnet_accept(lnet_ni_t *blind_ni, struct socket *sock, __u32 magic);
+extern int lnet_acceptor_timeout(void);
+extern int lnet_acceptor_port(void);
#endif
extern int lnet_acceptor_start(void);
-extern void lnet_acceptor_stop(void);
+extern void lnet_acceptor_stop(void);
extern int lnet_parse_routes (char *route_str);
extern int lnet_parse_networks (struct list_head *nilist, char *networks);
typedef struct {
__u64 wh_interface_cookie;
__u64 wh_object_cookie;
-} WIRE_ATTR ptl_handle_wire_t;
+} WIRE_ATTR lnet_handle_wire_t;
/* byte-flip insensitive! */
-#define PTL_WIRE_HANDLE_NONE \
-((const ptl_handle_wire_t) {.wh_interface_cookie = -1, .wh_object_cookie = -1})
+#define LNET_WIRE_HANDLE_NONE \
+((const lnet_handle_wire_t) {.wh_interface_cookie = -1, .wh_object_cookie = -1})
typedef enum {
- PTL_MSG_ACK = 0,
- PTL_MSG_PUT,
- PTL_MSG_GET,
- PTL_MSG_REPLY,
- PTL_MSG_HELLO,
-} ptl_msg_type_t;
+ LNET_MSG_ACK = 0,
+ LNET_MSG_PUT,
+ LNET_MSG_GET,
+ LNET_MSG_REPLY,
+ LNET_MSG_HELLO,
+} lnet_msg_type_t;
/* The variant fields of the portals message header are aligned on an 8
* byte boundary in the message header. Note that all types used in these
* wire structs MUST be fixed size and the smaller types are placed at the
* end. */
-typedef struct ptl_ack {
- ptl_handle_wire_t dst_wmd;
+typedef struct lnet_ack {
+ lnet_handle_wire_t dst_wmd;
__u64 match_bits;
__u32 mlength;
-} WIRE_ATTR ptl_ack_t;
+} WIRE_ATTR lnet_ack_t;
-typedef struct ptl_put {
- ptl_handle_wire_t ack_wmd;
+typedef struct lnet_put {
+ lnet_handle_wire_t ack_wmd;
__u64 match_bits;
__u64 hdr_data;
__u32 ptl_index;
__u32 offset;
-} WIRE_ATTR ptl_put_t;
+} WIRE_ATTR lnet_put_t;
-typedef struct ptl_get {
- ptl_handle_wire_t return_wmd;
+typedef struct lnet_get {
+ lnet_handle_wire_t return_wmd;
__u64 match_bits;
__u32 ptl_index;
__u32 src_offset;
__u32 sink_length;
-} WIRE_ATTR ptl_get_t;
+} WIRE_ATTR lnet_get_t;
-typedef struct ptl_reply {
- ptl_handle_wire_t dst_wmd;
-} WIRE_ATTR ptl_reply_t;
+typedef struct lnet_reply {
+ lnet_handle_wire_t dst_wmd;
+} WIRE_ATTR lnet_reply_t;
-typedef struct ptl_hello {
+typedef struct lnet_hello {
__u64 incarnation;
__u32 type;
-} WIRE_ATTR ptl_hello_t;
+} WIRE_ATTR lnet_hello_t;
typedef struct {
lnet_nid_t dest_nid;
lnet_nid_t src_nid;
lnet_pid_t dest_pid;
lnet_pid_t src_pid;
- __u32 type; /* ptl_msg_type_t */
+ __u32 type; /* lnet_msg_type_t */
__u32 payload_length; /* payload data to follow */
/*<------__u64 aligned------->*/
union {
- ptl_ack_t ack;
- ptl_put_t put;
- ptl_get_t get;
- ptl_reply_t reply;
- ptl_hello_t hello;
+ lnet_ack_t ack;
+ lnet_put_t put;
+ lnet_get_t get;
+ lnet_reply_t reply;
+ lnet_hello_t hello;
} msg;
-} WIRE_ATTR ptl_hdr_t;
+} WIRE_ATTR lnet_hdr_t;
/* A HELLO message contains a magic number and protocol version
* code in the header's dest_nid, the peer's NID in the src_nid, and
- * PTL_MSG_HELLO in the type field. All other common fields are zero
+ * LNET_MSG_HELLO in the type field. All other common fields are zero
* (including payload_size; i.e. no payload).
* This is for use by byte-stream NALs (e.g. TCP/IP) to check the peer is
* running the same protocol and to find out its NID. These NALs should
* exchange HELLO messages when a connection is first established. Individual
- * NALs can put whatever else they fancy in ptl_hdr_t::msg.
+ * NALs can put whatever else they fancy in lnet_hdr_t::msg.
*/
typedef struct {
- __u32 magic; /* PTL_PROTO_TCP_MAGIC */
+ __u32 magic; /* LNET_PROTO_TCP_MAGIC */
__u16 version_major; /* increment on incompatible change */
__u16 version_minor; /* increment on compatible change */
-} WIRE_ATTR ptl_magicversion_t;
+} WIRE_ATTR lnet_magicversion_t;
/* PROTO MAGIC for NALs that once used their own private acceptor */
-#define PTL_PROTO_OPENIB_MAGIC 0x0be91b91
-#define PTL_PROTO_RA_MAGIC 0x0be91b92
-#define PTL_PROTO_TCP_MAGIC 0xeebc0ded
+#define LNET_PROTO_OPENIB_MAGIC 0x0be91b91
+#define LNET_PROTO_RA_MAGIC 0x0be91b92
+#define LNET_PROTO_TCP_MAGIC 0xeebc0ded
-#define PTL_PROTO_TCP_VERSION_MAJOR 1
-#define PTL_PROTO_TCP_VERSION_MINOR 0
+#define LNET_PROTO_TCP_VERSION_MAJOR 1
+#define LNET_PROTO_TCP_VERSION_MINOR 0
/* Acceptor connection request */
typedef struct {
__u64 acr_nid; /* target NID */
} WIRE_ATTR lnet_acceptor_connreq_t;
-#define PTL_PROTO_ACCEPTOR_MAGIC 0xacce7100
-#define PTL_PROTO_ACCEPTOR_VERSION 1
-
+#define LNET_PROTO_ACCEPTOR_MAGIC 0xacce7100
+#define LNET_PROTO_ACCEPTOR_VERSION 1
/* forward refs */
-struct ptl_libmd;
-
-typedef struct ptl_msg {
- struct list_head msg_list;
- struct ptl_libmd *msg_md;
- ptl_handle_wire_t msg_ack_wmd;
- lnet_event_t msg_ev;
-} ptl_msg_t;
-
-typedef struct ptl_libhandle {
+struct lnet_libmd;
+
+typedef struct lnet_msg {
+ struct list_head msg_activelist;
+
+ __u32 msg_type;
+ lnet_process_id_t msg_target;
+ int msg_target_is_router:1;
+ int msg_routing:1;
+ lnet_hdr_t msg_hdr;
+ unsigned int msg_len;
+ unsigned int msg_offset;
+ unsigned int msg_niov;
+ struct iovec *msg_iov;
+ lnet_kiov_t *msg_kiov;
+
+ struct lnet_libmd *msg_md;
+ lnet_handle_wire_t msg_ack_wmd;
+ lnet_event_t msg_ev;
+} lnet_msg_t;
+
+typedef struct lnet_libhandle {
struct list_head lh_hash_chain;
__u64 lh_cookie;
-} ptl_libhandle_t;
+} lnet_libhandle_t;
#define lh_entry(ptr, type, member) \
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
-typedef struct ptl_eq {
+typedef struct lnet_eq {
struct list_head eq_list;
- ptl_libhandle_t eq_lh;
+ lnet_libhandle_t eq_lh;
lnet_seq_t eq_enq_seq;
lnet_seq_t eq_deq_seq;
unsigned int eq_size;
lnet_event_t *eq_events;
int eq_refcount;
lnet_eq_handler_t eq_callback;
-} ptl_eq_t;
-
-typedef struct ptl_me {
- struct list_head me_list;
- ptl_libhandle_t me_lh;
- lnet_process_id_t me_match_id;
- __u64 me_match_bits;
- __u64 me_ignore_bits;
- lnet_unlink_t me_unlink;
- struct ptl_libmd *me_md;
-} ptl_me_t;
-
-typedef struct ptl_libmd {
+} lnet_eq_t;
+
+typedef struct lnet_me {
+ struct list_head me_list;
+ lnet_libhandle_t me_lh;
+ lnet_process_id_t me_match_id;
+ __u64 me_match_bits;
+ __u64 me_ignore_bits;
+ lnet_unlink_t me_unlink;
+ struct lnet_libmd *me_md;
+} lnet_me_t;
+
+typedef struct lnet_libmd {
struct list_head md_list;
- ptl_libhandle_t md_lh;
- ptl_me_t *md_me;
+ lnet_libhandle_t md_lh;
+ lnet_me_t *md_me;
char *md_start;
unsigned int md_offset;
unsigned int md_length;
unsigned int md_options;
unsigned int md_flags;
void *md_user_ptr;
- ptl_eq_t *md_eq;
+ lnet_eq_t *md_eq;
void *md_addrkey;
unsigned int md_niov; /* # frags */
union {
struct iovec iov[PTL_MD_MAX_IOV];
- lnet_kiov_t kiov[PTL_MD_MAX_IOV];
+ lnet_kiov_t kiov[PTL_MD_MAX_IOV];
} md_iov;
-} ptl_libmd_t;
+} lnet_libmd_t;
-#define PTL_MD_FLAG_ZOMBIE (1 << 0)
-#define PTL_MD_FLAG_AUTO_UNLINK (1 << 1)
+#define LNET_MD_FLAG_ZOMBIE (1 << 0)
+#define LNET_MD_FLAG_AUTO_UNLINK (1 << 1)
-#ifdef PTL_USE_LIB_FREELIST
+#ifdef LNET_USE_LIB_FREELIST
typedef struct
{
void *fl_objs; /* single contiguous array of objects */
int fl_nobjs; /* the number of them */
int fl_objsize; /* the size (including overhead) of each of them */
struct list_head fl_list; /* where they are enqueued */
-} ptl_freelist_t;
+} lnet_freelist_t;
typedef struct
{
struct list_head fo_list; /* enqueue on fl_list */
void *fo_contents; /* aligned contents */
-} ptl_freeobj_t;
+} lnet_freeobj_t;
#endif
typedef struct {
/* info about peers we are trying to fail */
- struct list_head tp_list; /* apini_test_peers */
+ struct list_head tp_list; /* ln_test_peers */
lnet_nid_t tp_nid; /* matching nid */
unsigned int tp_threshold; /* # failures to simulate */
-} ptl_test_peer_t;
-
-#define PTL_COOKIE_TYPE_MD 1
-#define PTL_COOKIE_TYPE_ME 2
-#define PTL_COOKIE_TYPE_EQ 3
-#define PTL_COOKIE_TYPES 4
-/* PTL_COOKIE_TYPES must be a power of 2, so the cookie type can be
- * extracted by masking with (PTL_COOKIE_TYPES - 1) */
-
-struct ptl_ni; /* forward ref */
-
-/******************************************************************************/
-/* Portals Router */
+} lnet_test_peer_t;
-typedef void (*kpr_fwd_callback_t)(struct ptl_ni *ni,
- void *arg, int error);
+#define LNET_COOKIE_TYPE_MD 1
+#define LNET_COOKIE_TYPE_ME 2
+#define LNET_COOKIE_TYPE_EQ 3
+#define LNET_COOKIE_TYPES 4
+/* LNET_COOKIE_TYPES must be a power of 2, so the cookie type can be
+ * extracted by masking with (LNET_COOKIE_TYPES - 1) */
-/* space for routing targets to stash "stuff" in a forwarded packet */
-typedef union {
- long long _alignment;
- void *_space[16]; /* scale with CPU arch */
-} kprfd_scratch_t;
+struct lnet_ni; /* forward ref */
-/* Kernel Portals Routing Forwarded message Descriptor */
-typedef struct {
- struct list_head kprfd_list; /* stash in queues (routing target can use) */
- lnet_nid_t kprfd_target_nid; /* final destination NID */
- lnet_nid_t kprfd_gateway_nid; /* next hop NID */
- lnet_nid_t kprfd_sender_nid; /* previous hop NID */
- lnet_nid_t kprfd_source_nid; /* original sender's NID */
- ptl_hdr_t *kprfd_hdr; /* header in wire byte order */
- int kprfd_nob; /* # payload bytes */
- int kprfd_niov; /* # payload frags */
- lnet_kiov_t *kprfd_kiov; /* payload fragments */
- struct ptl_ni *kprfd_src_ni; /* originating NI */
- kpr_fwd_callback_t kprfd_callback; /* completion callback */
- void *kprfd_callback_arg; /* completion callback arg */
- kprfd_scratch_t kprfd_scratch; /* scratchpad for routing targets */
-} kpr_fwd_desc_t;
-
-/******************************************************************************/
-
-typedef struct ptl_nal
+typedef struct lnet_lnd
{
/* fields managed by portals */
- struct list_head nal_list; /* stash in the NAL table */
- int nal_refcount; /* # active instances */
+ struct list_head lnd_list; /* stash in the NAL table */
+ int lnd_refcount; /* # active instances */
/* fields initialised by the NAL */
- unsigned int nal_type;
+ unsigned int lnd_type;
- int (*nal_startup) (struct ptl_ni *ni);
- void (*nal_shutdown) (struct ptl_ni *ni);
- int (*nal_ctl)(struct ptl_ni *ni, unsigned int cmd, void *arg);
+ int (*lnd_startup) (struct lnet_ni *ni);
+ void (*lnd_shutdown) (struct lnet_ni *ni);
+ int (*lnd_ctl)(struct lnet_ni *ni, unsigned int cmd, void *arg);
/* In data movement APIs below, payload buffers are described as a set
* of 'niov' fragments which are...
* fragments to start from
*/
- /* Start sending a preformatted header and 'mlen' bytes of payload data
- * of to a specified remote process. 'private' is NULL for PUT and GET
- * messages; otherwise this is a response to an incoming message and
- * 'private' is the 'private' passed to lnet_parse(). Return non-zero
- * for immediate failure, otherwise complete later with
+ /* Start sending a preformatted message. 'private' is NULL for PUT and
+ * GET messages; otherwise this is a response to an incoming message
+ * and 'private' is the 'private' passed to lnet_parse(). Return
+ * non-zero for immediate failure, otherwise complete later with
* lnet_finalize() */
- int (*nal_send) (struct ptl_ni *ni, void *private, ptl_msg_t *msg,
- ptl_hdr_t *hdr, int type, lnet_process_id_t target,
- int target_is_router, int routing, unsigned int niov,
- struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int mlen);
+ int (*lnd_send)(struct lnet_ni *ni, void *private, lnet_msg_t *msg);
/* Start receiving 'mlen' bytes of payload data, skipping the following
* 'rlen' - 'mlen' bytes. 'private' is the 'private' passed to
- * lnet_parse(). Return non-zero for immedaite failuyre, otherwise
+ * lnet_parse(). Return non-zero for immedaite failure, otherwise
* complete later with lnet_finalize() */
- int (*nal_recv) (struct ptl_ni *ni, void *private, ptl_msg_t * cookie,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int mlen, unsigned int rlen);
-
- /* forward a packet for the router */
- void (*nal_fwd)(struct ptl_ni *ni, kpr_fwd_desc_t *fwd);
+ int (*lnd_recv)(struct lnet_ni *ni, void *private, lnet_msg_t *msg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
+ unsigned int offset, unsigned int mlen, unsigned int rlen);
/* notification of peer health */
- void (*nal_notify)(struct ptl_ni *ni, lnet_nid_t peer, int alive);
+ void (*lnd_notify)(struct lnet_ni *ni, lnet_nid_t peer, int alive);
#ifdef __KERNEL__
/* accept a new connection */
- int (*nal_accept)(struct ptl_ni *ni, struct socket *sock);
+ int (*lnd_accept)(struct lnet_ni *ni, struct socket *sock);
#endif
-} ptl_nal_t;
+} lnd_t;
-#define PTL_MAX_INTERFACES 16
+#define LNET_MAX_INTERFACES 16
-typedef struct ptl_ni {
- struct list_head ni_list; /* chain on apini_nis */
+typedef struct lnet_ni {
+ struct list_head ni_list; /* chain on ln_nis */
lnet_nid_t ni_nid; /* interface's NID */
void *ni_data; /* instance-specific data */
- ptl_nal_t *ni_nal; /* procedural interface */
+ lnd_t *ni_lnd; /* procedural interface */
int ni_shutdown; /* shutting down? */
int ni_refcount; /* reference count */
- char *ni_interfaces[PTL_MAX_INTERFACES]; /* equivalent interfaces to use */
-} ptl_ni_t;
-
-typedef struct /* loopback descriptor */
-{
- unsigned int lod_type;
- unsigned int lod_niov;
- unsigned int lod_offset;
- unsigned int lod_nob;
- union {
- struct iovec *iov;
- lnet_kiov_t *kiov;
- } lod_iov;
-} lo_desc_t;
-
-/* loopback descriptor types */
-#define LOD_IOV 0xeb105
-#define LOD_KIOV 0xeb106
+ char *ni_interfaces[LNET_MAX_INTERFACES]; /* equivalent interfaces to use */
+} lnet_ni_t;
typedef struct
{
/* Stuff initialised at LNetInit() */
- int apini_init; /* LNetInit() called? */
- int apini_refcount; /* LNetNIInit/LNetNIFini counter */
- int apini_niinit_self; /* Have I called LNetNIInit myself? */
+ int ln_init; /* LNetInit() called? */
+ int ln_refcount; /* LNetNIInit/LNetNIFini counter */
+ int ln_niinit_self; /* Have I called LNetNIInit myself? */
- int apini_ptlcompat; /* support talking to portals */
+ int ln_ptlcompat; /* support talking to portals */
- struct list_head apini_nals; /* registered NALs */
+ struct list_head ln_lnds; /* registered NALs */
#ifdef __KERNEL__
- spinlock_t apini_lock;
- cfs_waitq_t apini_waitq;
- struct semaphore apini_api_mutex;
- struct semaphore apini_nal_mutex;
+ spinlock_t ln_lock;
+ cfs_waitq_t ln_waitq;
+ struct semaphore ln_api_mutex;
+ struct semaphore ln_lnd_mutex;
#else
- pthread_mutex_t apini_mutex;
- pthread_cond_t apini_cond;
- pthread_mutex_t apini_api_mutex;
- pthread_mutex_t apini_nal_mutex;
+ pthread_mutex_t ln_mutex;
+ pthread_cond_t ln_cond;
+ pthread_mutex_t ln_api_mutex;
+ pthread_mutex_t ln_lnd_mutex;
#endif
/* Stuff initialised at LNetNIInit() */
- int apini_nportals; /* # portals */
- struct list_head *apini_portals; /* the vector of portals */
+ int ln_nportals; /* # portals */
+ struct list_head *ln_portals; /* the vector of portals */
- lnet_pid_t apini_pid; /* requested pid */
+ lnet_pid_t ln_pid; /* requested pid */
- struct list_head apini_nis; /* NAL instances */
- struct list_head apini_zombie_nis; /* dying NAL instances */
- int apini_nzombie_nis; /* # of NIS to wait for */
+ struct list_head ln_nis; /* NAL instances */
+ struct list_head ln_zombie_nis; /* dying NAL instances */
+ int ln_nzombie_nis; /* # of NIS to wait for */
- int apini_lh_hash_size; /* size of lib handle hash table */
- struct list_head *apini_lh_hash_table; /* all extant lib handles, this interface */
- __u64 apini_next_object_cookie; /* cookie generator */
- __u64 apini_interface_cookie; /* uniquely identifies this ni in this epoch */
+ int ln_lh_hash_size; /* size of lib handle hash table */
+ struct list_head *ln_lh_hash_table; /* all extant lib handles, this interface */
+ __u64 ln_next_object_cookie; /* cookie generator */
+ __u64 ln_interface_cookie; /* uniquely identifies this ni in this epoch */
- char *apini_network_tokens; /* space for network names */
- int apini_network_tokens_nob;
+ char *ln_network_tokens; /* space for network names */
+ int ln_network_tokens_nob;
- struct list_head apini_test_peers;
+ struct list_head ln_test_peers;
-#ifdef PTL_USE_LIB_FREELIST
- ptl_freelist_t apini_free_mes;
- ptl_freelist_t apini_free_msgs;
- ptl_freelist_t apini_free_mds;
- ptl_freelist_t apini_free_eqs;
+#ifdef LNET_USE_LIB_FREELIST
+ lnet_freelist_t ln_free_mes;
+ lnet_freelist_t ln_free_msgs;
+ lnet_freelist_t ln_free_mds;
+ lnet_freelist_t ln_free_eqs;
#endif
- struct list_head apini_active_msgs;
- struct list_head apini_active_mds;
- struct list_head apini_active_eqs;
+ struct list_head ln_active_msgs;
+ struct list_head ln_active_mds;
+ struct list_head ln_active_eqs;
struct {
long recv_count;
long drop_length;
long msgs_alloc;
long msgs_max;
- } apini_counters;
+ } ln_counters;
-} lnet_apini_t;
+} lnet_t;
#endif
# include <linux/smp_lock.h>
# include <linux/types.h>
#else
-# define PTL_USE_LIB_FREELIST
+# define LNET_USE_LIB_FREELIST
# include <sys/types.h>
#endif
* #defines shared between socknal implementation and utilities
*/
-#define SOCKNAL_CONN_NONE (-1)
-#define SOCKNAL_CONN_ANY 0
-#define SOCKNAL_CONN_CONTROL 1
-#define SOCKNAL_CONN_BULK_IN 2
-#define SOCKNAL_CONN_BULK_OUT 3
-#define SOCKNAL_CONN_NTYPES 4
+#define SOCKLND_CONN_NONE (-1)
+#define SOCKLND_CONN_ANY 0
+#define SOCKLND_CONN_CONTROL 1
+#define SOCKLND_CONN_BULK_IN 2
+#define SOCKLND_CONN_BULK_OUT 3
+#define SOCKLND_CONN_NTYPES 4
/* Wire protocol */
typedef struct {
- ptl_hdr_t gmim_hdr; /* portals header */
+ lnet_hdr_t gmim_hdr; /* portals header */
char gmim_payload[0]; /* payload */
} gmnal_immediate_msg_t;
typedef struct netbuf {
__u64 nb_netaddr; /* network VM address */
- struct page *nb_pages[1]; /* the pages (at least 1) */
+ lnet_kiov_t nb_kiov[1]; /* the pages (at least 1) */
} gmnal_netbuf_t;
-#define GMNAL_NETBUF_MSG(nb) ((gmnal_msg_t *)page_address((nb)->nb_pages[0]))
+#define GMNAL_NETBUF_MSG(nb) ((gmnal_msg_t *)page_address((nb)->nb_kiov[0].kiov_page))
#define GMNAL_NETBUF_LOCAL_NETADDR(nb) ((void *)((unsigned long)(nb)->nb_netaddr))
typedef struct gmnal_txbuf {
struct gmnal_ni *tx_gmni; /* owning NI */
lnet_nid_t tx_nid; /* destination NID */
int tx_gmlid; /* destination GM local ID */
- ptl_msg_t *tx_ptlmsg; /* ptlmsg to finalize on completion */
+ lnet_msg_t *tx_lntmsg; /* lntmsg to finalize on completion */
gmnal_netbuf_t tx_buf; /* small tx buffer */
gmnal_txbuf_t *tx_ltxb; /* large buffer (to free on completion) */
} gmnal_rx_t;
typedef struct gmnal_ni {
- ptl_ni_t *gmni_ni; /* generic NI */
+ lnet_ni_t *gmni_ni; /* generic NI */
struct gm_port *gmni_port; /* GM port */
spinlock_t gmni_gm_lock; /* serialise GM calls */
int gmni_large_pages; /* # pages in a large message buffer */
/* gmnal_api.c */
int gmnal_init(void);
void gmnal_fini(void);
-int gmnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg);
-int gmnal_startup(ptl_ni_t *ni);
-void gmnal_shutdown(ptl_ni_t *ni);
+int gmnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
+int gmnal_startup(lnet_ni_t *ni);
+void gmnal_shutdown(lnet_ni_t *ni);
/* gmnal_cb.c */
-int gmnal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+int gmnal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
-int gmnal_send(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr, int type, lnet_process_id_t tgt,
- int target_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int len);
+int gmnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
/* gmnal_util.c */
void gmnal_free_ltxbufs(gmnal_ni_t *gmni);
char *gmnal_rxevent2str(gm_recv_event_t *ev);
void gmnal_yield(int delay);
-void gmnal_copy_tofrom_netbuf(int niov, struct iovec *iov, lnet_kiov_t *kiov, int offset,
- int nb_pages, gmnal_netbuf_t *nb, int nb_offset,
- int nob, int from_nb);
-
-static inline void
-gmnal_copy_from_netbuf(int niov, struct iovec *iov, lnet_kiov_t *kiov, int offset,
- int nb_pages, gmnal_netbuf_t *nb, int nb_offset, int nob)
-{
- gmnal_copy_tofrom_netbuf(niov, iov, kiov, offset,
- nb_pages, nb, nb_offset, nob, 1);
-}
-
-static inline void
-gmnal_copy_to_netbuf(int nb_pages, gmnal_netbuf_t *nb, int nb_offset,
- int niov, struct iovec *iov, lnet_kiov_t *kiov, int offset,
- int nob)
-{
- gmnal_copy_tofrom_netbuf(niov, iov, kiov, offset,
- nb_pages, nb, nb_offset, nob, 0);
-}
-
/* gmnal_comm.c */
void gmnal_post_rx(gmnal_ni_t *gmni, gmnal_rx_t *rx);
gmnal_tx_t *gmnal_get_tx(gmnal_ni_t *gmni, int may_block);
#include "gmlnd.h"
-ptl_nal_t gmnal_nal =
+lnd_t the_gmlnd =
{
- .nal_type = GMNAL,
- .nal_startup = gmnal_startup,
- .nal_shutdown = gmnal_shutdown,
- .nal_ctl = gmnal_ctl,
- .nal_send = gmnal_send,
- .nal_recv = gmnal_recv,
+ .lnd_type = GMLND,
+ .lnd_startup = gmnal_startup,
+ .lnd_shutdown = gmnal_shutdown,
+ .lnd_ctl = gmnal_ctl,
+ .lnd_send = gmnal_send,
+ .lnd_recv = gmnal_recv,
};
gmnal_ni_t *the_gmni = NULL;
int
-gmnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg)
+gmnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
int
gmnal_set_local_nid (gmnal_ni_t *gmni)
{
- ptl_ni_t *ni = gmni->gmni_ni;
+ lnet_ni_t *ni = gmni->gmni_ni;
__u32 local_gmid;
__u32 global_gmid;
gm_status_t gm_status;
}
void
-gmnal_shutdown(ptl_ni_t *ni)
+gmnal_shutdown(lnet_ni_t *ni)
{
gmnal_ni_t *gmni = ni->ni_data;
}
int
-gmnal_startup(ptl_ni_t *ni)
+gmnal_startup(lnet_ni_t *ni)
{
gmnal_ni_t *gmni = NULL;
gmnal_rx_t *rx = NULL;
gm_status_t gm_status;
int rc;
- LASSERT (ni->ni_nal == &gmnal_nal);
+ LASSERT (ni->ni_lnd == &the_gmlnd);
if (the_gmni != NULL) {
CERROR("Only 1 instance supported\n");
*/
int gmnal_init(void)
{
- lnet_register_nal(&gmnal_nal);
+ lnet_register_lnd(&the_gmlnd);
return 0;
}
*/
void gmnal_fini()
{
- lnet_unregister_nal(&gmnal_nal);
+ lnet_unregister_lnd(&the_gmlnd);
}
#include "gmlnd.h"
int
-gmnal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+gmnal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
gmnal_ni_t *gmni = ni->ni_data;
if (rx->rx_recv_nob < nob) {
CERROR("Short message from nid %s: got %d, need %d\n",
libcfs_nid2str(msg->gmm_srcnid), rx->rx_recv_nob, nob);
+ gmnal_post_rx(gmni, rx);
return -EIO;
}
- gmnal_copy_from_netbuf(niov, iov, kiov, offset,
- npages, &rx->rx_buf, payload_offset,
- mlen);
-
- lnet_finalize(ni, private, ptlmsg, 0);
+ if (kiov != NULL)
+ lnet_copy_kiov2kiov(niov, kiov, offset,
+ npages, rx->rx_buf.nb_kiov, payload_offset,
+ mlen);
+ else
+ lnet_copy_kiov2iov(niov, iov, offset,
+ npages, rx->rx_buf.nb_kiov, payload_offset,
+ mlen);
+
+ lnet_finalize(ni, private, lntmsg, 0);
+ gmnal_post_rx(gmni, rx);
return 0;
}
int
-gmnal_send(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr, int type, lnet_process_id_t target,
- int target_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int len)
+gmnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- gmnal_ni_t *gmni = ni->ni_data;
- gm_status_t gmrc;
- gmnal_tx_t *tx;
+ lnet_hdr_t *hdr= &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ int target_is_router = lntmsg->msg_target_is_router;
+ int routing = lntmsg->msg_routing;
+ unsigned int niov = lntmsg->msg_niov;
+ struct iovec *iov = lntmsg->msg_iov;
+ lnet_kiov_t *kiov = lntmsg->msg_kiov;
+ unsigned int offset = lntmsg->msg_offset;
+ unsigned int len = lntmsg->msg_len;
+ gmnal_ni_t *gmni = ni->ni_data;
+ gm_status_t gmrc;
+ gmnal_tx_t *tx;
LASSERT (iov == NULL || kiov == NULL);
/* I may not block for a tx if I'm responding to an incoming message */
tx = gmnal_get_tx(gmni,
!(routing ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY));
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY));
if (tx == NULL) {
if (!gmni->gmni_shutdown)
CERROR ("Can't get tx for msg type %d for %s\n",
if (gmrc != GM_SUCCESS) {
CERROR("Can't map Nid %s to a GM local ID: %d\n",
libcfs_nid2str(target.nid), gmrc);
- /* NB tx_ptlmsg not set => doesn't finalize */
+ /* NB tx_lntmsg not set => doesn't finalize */
gmnal_tx_done(tx, -EIO);
return -EIO;
}
if (tx->tx_msgnob + len <= gmni->gmni_small_msgsize) {
/* whole message fits in tx_buf */
char *buffer = &(GMNAL_NETBUF_MSG(&tx->tx_buf)->gmm_u.immediate.gmim_payload[0]);
-
+
if (iov != NULL)
- lnet_copy_iov2buf(buffer, niov, iov, offset, len);
+ lnet_copy_iov2flat(len, buffer, 0,
+ niov, iov, offset, len);
else
- lnet_copy_kiov2buf(buffer, niov, kiov, offset, len);
+ lnet_copy_kiov2flat(len, buffer, 0,
+ niov, kiov, offset, len);
tx->tx_msgnob += len;
tx->tx_large_nob = 0;
/* We've copied everything... */
- LASSERT(tx->tx_ptlmsg == NULL);
- lnet_finalize(ni, NULL, ptlmsg, 0);
+ LASSERT(tx->tx_lntmsg == NULL);
+ lnet_finalize(ni, NULL, lntmsg, 0);
} else {
/* stash payload pts to copy later */
tx->tx_large_nob = len;
tx->tx_large_frags.iov = iov;
/* finalize later */
- tx->tx_ptlmsg = ptlmsg;
+ tx->tx_lntmsg = lntmsg;
}
spin_lock(&gmni->gmni_tx_lock);
}
if (tx != NULL) {
- LASSERT (tx->tx_ptlmsg == NULL);
+ LASSERT (tx->tx_lntmsg == NULL);
LASSERT (tx->tx_ltxb == NULL);
LASSERT (!tx->tx_credit);
int wake_sched = 0;
int wake_idle = 0;
- LASSERT(tx->tx_ptlmsg == NULL);
+ LASSERT(tx->tx_lntmsg == NULL);
spin_lock(&gmni->gmni_tx_lock);
GMNAL_NETBUF_MSG(&tx->tx_buf), tx->tx_msgnob);
/* 2. Copy the payload */
- gmnal_copy_to_netbuf(
- gmni->gmni_large_pages,
- <xb->txb_buf,
- tx->tx_msgnob,
- tx->tx_large_niov,
- tx->tx_large_iskiov ? NULL : tx->tx_large_frags.iov,
- tx->tx_large_iskiov ? tx->tx_large_frags.kiov : NULL,
- tx->tx_large_offset,
- tx->tx_large_nob);
+ if (tx->tx_large_iskiov)
+ lnet_copy_kiov2kiov(
+ gmni->gmni_large_pages,
+ ltxb->txb_buf.nb_kiov,
+ tx->tx_msgnob,
+ tx->tx_large_niov,
+ tx->tx_large_frags.kiov,
+ tx->tx_large_offset,
+ tx->tx_large_nob);
+ else
+ lnet_copy_iov2kiov(
+ gmni->gmni_large_pages,
+ ltxb->txb_buf.nb_kiov,
+ tx->tx_msgnob,
+ tx->tx_large_niov,
+ tx->tx_large_frags.iov,
+ tx->tx_large_offset,
+ tx->tx_large_nob);
tx->tx_msgnob += tx->tx_large_nob;
/* We've copied everything... */
- lnet_finalize(gmni->gmni_ni, NULL, tx->tx_ptlmsg, 0);
- tx->tx_ptlmsg = NULL;
+ lnet_finalize(gmni->gmni_ni, NULL, tx->tx_lntmsg, 0);
+ tx->tx_lntmsg = NULL;
spin_lock(&gmni->gmni_tx_lock);
}
- LASSERT (tx->tx_ptlmsg == NULL);
+ LASSERT (tx->tx_lntmsg == NULL);
list_add_tail(&tx->tx_list, &gmni->gmni_cred_txq);
}
gm_recv_event_t *rxevent = NULL;
gm_recv_t *recv = NULL;
gmnal_rx_t *rx;
+ int rc;
libcfs_daemonize("gmnal_rxd");
/* We're connectionless: simply drop packets with
* errors */
- if (gmnal_unpack_msg(gmni, rx) == 0) {
- LASSERT (GMNAL_NETBUF_MSG(&rx->rx_buf)->gmm_type == GMNAL_MSG_IMMEDIATE);
- (void)lnet_parse(gmni->gmni_ni,
- &(GMNAL_NETBUF_MSG(&rx->rx_buf)->gmm_u.immediate.gmim_hdr),
- rx);
+ rc = gmnal_unpack_msg(gmni, rx);
+ if (rc == 0) {
+ gmnal_msg_t *msg = GMNAL_NETBUF_MSG(&rx->rx_buf);
+
+ LASSERT (msg->gmm_type == GMNAL_MSG_IMMEDIATE);
+ rc = lnet_parse(gmni->gmni_ni,
+ &msg->gmm_u.immediate.gmim_hdr,
+ rx);
}
- gmnal_post_rx(gmni, rx);
+ if (rc < 0) /* parse failure */
+ gmnal_post_rx(gmni, rx);
down(&gmni->gmni_rx_mutex);
}
int i;
for (i = 0; i < npages; i++)
- __free_page(nb->nb_pages[i]);
+ __free_page(nb->nb_kiov[i].kiov_page);
}
int
for (i = 0; i < npages; i++) {
- nb->nb_pages[i] = alloc_page(GFP_KERNEL);
+ nb->nb_kiov[i].kiov_page = alloc_page(GFP_KERNEL);
+ nb->nb_kiov[i].kiov_offset = 0;
+ nb->nb_kiov[i].kiov_len = PAGE_SIZE;
- if (nb->nb_pages[i] == NULL) {
+ if (nb->nb_kiov[i].kiov_page == NULL) {
CERROR("Can't allocate page\n");
gmnal_free_netbuf_pages(nb, i);
return -ENOMEM;
}
CDEBUG(D_NET,"[%3d] page %p, phys "LPX64", @ "LPX64"\n",
- i, nb->nb_pages[i], (__u64)page_to_phys(nb->nb_pages[i]),
+ i, nb->nb_kiov[i].kiov_page,
+ (__u64)page_to_phys(nb->nb_kiov[i].kiov_page),
gmni->gmni_netaddr_base);
gmrc = gm_register_memory_ex_phys(gmni->gmni_port,
- page_to_phys(nb->nb_pages[i]),
+ page_to_phys(nb->nb_kiov[i].kiov_page),
PAGE_SIZE,
gmni->gmni_netaddr_base);
- CDEBUG(D_NET,"[%3d] page %p: %d\n", i, nb->nb_pages[i], gmrc);
+ CDEBUG(D_NET,"[%3d] page %p: %d\n", i, nb->nb_kiov[i].kiov_page, gmrc);
if (gmrc != GM_SUCCESS) {
CERROR("Can't map page: %d(%s)\n", gmrc,
/* No unmapping; the port has been closed */
gmnal_free_netbuf_pages(&txb->txb_buf, gmni->gmni_large_pages);
- PORTAL_FREE(txb, offsetof(gmnal_txbuf_t, txb_buf.nb_pages[npages]));
+ PORTAL_FREE(txb, offsetof(gmnal_txbuf_t, txb_buf.nb_kiov[npages]));
}
int
gmnal_alloc_ltxbuf (gmnal_ni_t *gmni)
{
int npages = gmni->gmni_large_pages;
- int sz = offsetof(gmnal_txbuf_t, txb_buf.nb_pages[npages]);
+ int sz = offsetof(gmnal_txbuf_t, txb_buf.nb_kiov[npages]);
gmnal_txbuf_t *txb;
int rc;
LASSERT (gmni->gmni_port == NULL);
gmnal_free_netbuf_pages(&rx->rx_buf, npages);
- PORTAL_FREE(rx, offsetof(gmnal_rx_t, rx_buf.nb_pages[npages]));
+ PORTAL_FREE(rx, offsetof(gmnal_rx_t, rx_buf.nb_kiov[npages]));
}
int
gmnal_alloc_rx (gmnal_ni_t *gmni, int islarge)
{
int npages = islarge ? gmni->gmni_large_pages : 1;
- int sz = offsetof(gmnal_rx_t, rx_buf.nb_pages[npages]);
+ int sz = offsetof(gmnal_rx_t, rx_buf.nb_kiov[npages]);
int rc;
gmnal_rx_t *rx;
gm_status_t gmrc;
}
void
-gmnal_copy_tofrom_netbuf(int niov, struct iovec *iov, lnet_kiov_t *kiov, int offset,
- int nb_pages, gmnal_netbuf_t *nb, int nb_offset,
- int nob, int from_nb)
-{
- int nb_page;
- int nb_nob;
- char *nb_ptr;
- int iov_nob;
- char *iov_ptr;
-
- if (nob == 0)
- return;
-
- LASSERT (nob > 0);
- LASSERT (niov > 0);
- LASSERT ((iov == NULL) != (kiov == NULL));
-
- /* skip 'offset' bytes */
- if (kiov != NULL) {
- while (offset >= kiov->kiov_len) {
- offset -= kiov->kiov_len;
- kiov++;
- niov--;
- LASSERT (niov > 0);
- }
- iov_ptr = ((char *)kmap(kiov->kiov_page)) +
- kiov->kiov_offset + offset;
- iov_nob = kiov->kiov_len - offset;
- } else {
- while (offset >= iov->iov_len) {
- offset -= iov->iov_len;
- iov++;
- niov--;
- LASSERT (niov > 0);
- }
- iov_ptr = iov->iov_base + offset;
- iov_nob = iov->iov_len - offset;
- }
-
- LASSERT (nb_pages > 0);
- LASSERT (nb_offset < PAGE_SIZE);
-
- nb_page = 0;
- nb_ptr = page_address(nb->nb_pages[0]) + nb_offset;
- nb_nob = PAGE_SIZE - nb_offset;
-
- for (;;) {
- int this_nob = nob;
-
- if (this_nob > nb_nob)
- this_nob = nb_nob;
- if (this_nob > iov_nob)
- this_nob = iov_nob;
-
- if (from_nb)
- memcpy(iov_ptr, nb_ptr, this_nob);
- else
- memcpy(nb_ptr, iov_ptr, this_nob);
-
- nob -= this_nob;
- if (nob == 0)
- break;
-
- nb_nob -= this_nob;
- if (nb_nob != 0) {
- nb_ptr += this_nob;
- } else {
- nb_page++;
- LASSERT (nb_page < nb_pages);
- nb_ptr = page_address(nb->nb_pages[nb_page]);
- nb_nob = PAGE_SIZE;
- }
-
- iov_nob -= this_nob;
- if (iov_nob != 0) {
- iov_ptr += this_nob;
- } else if (kiov != NULL) {
- kunmap(kiov->kiov_page);
- kiov++;
- niov--;
- LASSERT (niov > 0);
- iov_ptr = ((char *)kmap(kiov->kiov_page)) +
- kiov->kiov_offset;
- iov_nob = kiov->kiov_len;
- } else {
- iov++;
- niov--;
- LASSERT (niov > 0);
- iov_ptr = iov->iov_base;
- iov_nob = iov->iov_len;
- }
- }
-
- if (kiov != NULL)
- kunmap(kiov->kiov_page);
-}
-
-void
gmnal_free_ltxbufs (gmnal_ni_t *gmni)
{
gmnal_txbuf_t *txb;
#include "iiblnd.h"
-ptl_nal_t kibnal_nal = {
- .nal_type = IIBNAL,
- .nal_startup = kibnal_startup,
- .nal_shutdown = kibnal_shutdown,
- .nal_ctl = kibnal_ctl,
- .nal_send = kibnal_send,
- .nal_recv = kibnal_recv,
+lnd_t the_kiblnd = {
+ .lnd_type = IIBLND,
+ .lnd_startup = kibnal_startup,
+ .lnd_shutdown = kibnal_shutdown,
+ .lnd_ctl = kibnal_ctl,
+ .lnd_send = kibnal_send,
+ .lnd_recv = kibnal_recv,
};
kib_tunables_t kibnal_tunables;
}
int
-kibnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg)
+kibnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
int rc = -EINVAL;
}
void
-kibnal_shutdown (ptl_ni_t *ni)
+kibnal_shutdown (lnet_ni_t *ni)
{
int i;
int rc;
#undef roundup_power
int
-kibnal_startup (ptl_ni_t *ni)
+kibnal_startup (lnet_ni_t *ni)
{
IB_PORT_ATTRIBUTES *pattr;
FSTATUS frc;
int n;
int i;
- LASSERT (ni->ni_nal == &kibnal_nal);
+ LASSERT (ni->ni_lnd == &the_kiblnd);
/* Only 1 instance supported */
if (kibnal_data.kib_init != IBNAL_INIT_NOTHING) {
if (kibnal_tunables.kib_sysctl != NULL)
unregister_sysctl_table (kibnal_tunables.kib_sysctl);
#endif
- lnet_unregister_nal(&kibnal_nal);
+ lnet_unregister_lnd(&the_kiblnd);
}
int __init
{
int rc;
- if (lnet_apini.apini_ptlcompat != 0) {
+ if (the_lnet.ln_ptlcompat != 0) {
LCONSOLE_ERROR("IIB does not support portals compatibility mode\n");
return -ENODEV;
}
/* Initialise dynamic tunables to defaults once only */
kibnal_tunables.kib_io_timeout = IBNAL_IO_TIMEOUT;
- lnet_register_nal(&kibnal_nal);
+ lnet_register_lnd(&the_kiblnd);
#ifdef CONFIG_SYSCTL
/* Press on regardless even if registering sysctl doesn't work */
__u64 kib_incarnation; /* which one am I */
int kib_shutdown; /* shut down? */
atomic_t kib_nthreads; /* # live threads */
- ptl_ni_t *kib_ni; /* _the_ nal instance */
+ lnet_ni_t *kib_ni; /* _the_ nal instance */
__u64 kib_service_id; /* service number I listen on */
__u64 kib_port_guid; /* my GUID (lo 64 of GID)*/
typedef struct
{
- ptl_hdr_t ibim_hdr; /* portals header */
+ lnet_hdr_t ibim_hdr; /* portals header */
char ibim_payload[0]; /* piggy-backed payload */
} WIRE_ATTR kib_immediate_msg_t;
* the different roles result in split local/remote meaning of desc->rd_key */
typedef struct
{
- ptl_hdr_t ibrm_hdr; /* portals header */
+ lnet_hdr_t ibrm_hdr; /* portals header */
__u64 ibrm_cookie; /* opaque completion cookie */
__u32 ibrm_num_descs; /* how many descs */
__u32 rd_key; /* remote key */
struct list_head rx_list; /* queue for attention */
struct kib_conn *rx_conn; /* owning conn */
int rx_rdma; /* RDMA completion posted? */
- int rx_posted; /* posted? */
+ int rx_nob; /* # bytes received (-1 while posted) */
__u64 rx_vaddr; /* pre-mapped buffer (hca vaddr) */
kib_msg_t *rx_msg; /* pre-mapped buffer (host vaddr) */
IB_WORK_REQ rx_wrq;
int tx_passive_rdma; /* peer sucks/blows */
int tx_passive_rdma_wait; /* waiting for peer to complete */
__u64 tx_passive_rdma_cookie; /* completion cookie */
- ptl_msg_t *tx_ptlmsg[2]; /* ptl msgs to finalize on completion */
+ lnet_msg_t *tx_lntmsg[2]; /* lnet msgs to finalize on completion */
kib_md_t tx_md; /* RDMA mapping (active/passive) */
__u64 tx_vaddr; /* pre-mapped buffer (hca vaddr) */
kib_msg_t *tx_msg; /* pre-mapped buffer (host vaddr) */
return kibnal_data.kib_md.md_handle != NULL;
}
-extern int kibnal_startup (ptl_ni_t *ni);
-extern void kibnal_shutdown (ptl_ni_t *ni);
-extern int kibnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg);
-int kibnal_send (ptl_ni_t *ni, void *private,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr,
- int type, lnet_process_id_t tgt,
- int tgt_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob);
-extern int kibnal_recv (ptl_ni_t *ni, void *private, ptl_msg_t *msg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+extern int kibnal_startup (lnet_ni_t *ni);
+extern void kibnal_shutdown (lnet_ni_t *ni);
+extern int kibnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
+int kibnal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+extern int kibnal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *msg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
extern kib_peer_t *kibnal_create_peer (lnet_nid_t nid);
extern void kibnal_init_tx_msg (kib_tx_t *tx, int type, int body_nob);
extern void kibnal_close_conn (kib_conn_t *conn, int why);
extern void kibnal_start_active_rdma (int type, int status,
- kib_rx_t *rx, ptl_msg_t *ptlmsg,
+ kib_rx_t *rx, lnet_msg_t *lntmsg,
unsigned int niov,
struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int nob);
static void
kibnal_tx_done (kib_tx_t *tx)
{
- int ptlrc = (tx->tx_status == 0) ? 0 : -EIO;
unsigned long flags;
int i;
FSTATUS frc;
for (i = 0; i < 2; i++) {
/* tx may have up to 2 ptlmsgs to finalise */
- if (tx->tx_ptlmsg[i] == NULL)
+ if (tx->tx_lntmsg[i] == NULL)
continue;
- lnet_finalize (kibnal_data.kib_ni, NULL, tx->tx_ptlmsg[i], ptlrc);
- tx->tx_ptlmsg[i] = NULL;
+ lnet_finalize (kibnal_data.kib_ni, NULL, tx->tx_lntmsg[i],
+ tx->tx_status);
+ tx->tx_lntmsg[i] = NULL;
}
if (tx->tx_conn != NULL) {
LASSERT (tx->tx_conn == NULL);
LASSERT (!tx->tx_passive_rdma);
LASSERT (!tx->tx_passive_rdma_wait);
- LASSERT (tx->tx_ptlmsg[0] == NULL);
- LASSERT (tx->tx_ptlmsg[1] == NULL);
+ LASSERT (tx->tx_lntmsg[0] == NULL);
+ LASSERT (tx->tx_lntmsg[1] == NULL);
}
spin_unlock_irqrestore (&kibnal_data.kib_tx_lock, flags);
KIB_ASSERT_CONN_STATE_RANGE(conn, IBNAL_CONN_ESTABLISHED,
IBNAL_CONN_DREP);
- LASSERT (!rx->rx_posted);
- rx->rx_posted = 1;
+ LASSERT (rx->rx_nob >= 0);
+ rx->rx_nob = -1; /* flag posted */
mb();
if (conn->ibc_state != IBNAL_CONN_ESTABLISHED)
IBNAL_CONN_DISCONNECTED);
CDEBUG(D_NET, "rx %p conn %p\n", rx, conn);
- LASSERT (rx->rx_posted);
- rx->rx_posted = 0;
+ LASSERT (rx->rx_nob < 0); /* was posted */
+ rx->rx_nob = 0; /* isn't now */
mb();
/* receives complete with error in any case after we've started
goto failed;
}
+ rx->rx_nob = nob;
+ mb();
+
hexdump("rx", rx->rx_msg, sizeof(kib_msg_t));
/* Receiver does any byte flipping if necessary... */
void
kibnal_rx (kib_rx_t *rx)
{
+ int rc = 0;
kib_msg_t *msg = rx->rx_msg;
/* Clear flag so I can detect if I've sent an RDMA completion */
switch (msg->ibm_type) {
case IBNAL_MSG_GET_RDMA:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
- /* If the incoming get was matched, I'll have initiated the
- * RDMA and the completion message... */
- if (rx->rx_rdma)
- break;
-
- /* Otherwise, I'll send a failed completion now to prevent
- * the peer's GET blocking for the full timeout. */
- CERROR ("Completing unmatched RDMA GET from %s\n",
- libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
- kibnal_start_active_rdma (IBNAL_MSG_GET_DONE, -EIO,
- rx, NULL, 0, NULL, NULL, 0, 0);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
break;
case IBNAL_MSG_PUT_RDMA:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
- if (rx->rx_rdma)
- break;
- /* This is most unusual, since even if lnet_parse() didn't
- * match anything, it should have asked us to read (and
- * discard) the payload. The portals header must be
- * inconsistent with this message type, so it's the
- * sender's fault for sending garbage and she can time
- * herself out... */
- CERROR ("Uncompleted RMDA PUT from %s\n",
- libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
break;
case IBNAL_MSG_IMMEDIATE:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.immediate.ibim_hdr, rx);
- LASSERT (!rx->rx_rdma);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.immediate.ibim_hdr, rx);
break;
-
+
default:
LBUG();
break;
}
- kibnal_post_rx (rx, 1);
+ if (rc < 0) {
+ kibnal_close_conn(rx->rx_conn, rc);
+ kibnal_post_rx (rx, 1);
+ }
}
static struct page *
static int
kibnal_map_iov (kib_tx_t *tx, IB_ACCESS_CONTROL access,
- int niov, struct iovec *iov, int offset, int nob, int active)
+ unsigned int niov, struct iovec *iov, int offset, int nob, int active)
{
void *vaddr;
}
static int
-kibnal_start_passive_rdma (int type, int may_block, lnet_nid_t nid,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr)
+kibnal_start_passive_rdma (int type, int may_block, lnet_msg_t *lntmsg)
{
- int nob = ptlmsg->msg_md->md_length;
+ lnet_nid_t nid = lntmsg->msg_target.nid;
+ int nob = lntmsg->msg_md->md_length;
kib_tx_t *tx;
kib_msg_t *ibmsg;
int rc;
return -ENOMEM;
}
- if ((ptlmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
+ if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
rc = kibnal_map_iov (tx, access,
- ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.iov,
+ lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.iov,
0, nob, 0);
else
rc = kibnal_map_kiov (tx, access,
- ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.kiov,
+ lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.kiov,
0, nob, 0);
if (rc != 0) {
if (type == IBNAL_MSG_GET_RDMA) {
/* reply gets finalized when tx completes */
- tx->tx_ptlmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
- nid, ptlmsg);
- if (tx->tx_ptlmsg[1] == NULL) {
+ tx->tx_lntmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
+ lntmsg);
+ if (tx->tx_lntmsg[1] == NULL) {
CERROR ("Can't create reply for GET -> %s\n",
libcfs_nid2str(nid));
rc = -ENOMEM;
ibmsg = tx->tx_msg;
- ibmsg->ibm_u.rdma.ibrm_hdr = *hdr;
+ ibmsg->ibm_u.rdma.ibrm_hdr = lntmsg->msg_hdr;
ibmsg->ibm_u.rdma.ibrm_cookie = tx->tx_passive_rdma_cookie;
/* map_kiov alrady filled the rdma descs for the whole_mem case */
if (!kibnal_whole_mem()) {
tx, tx->tx_passive_rdma_cookie, tx->tx_md.md_rkey,
tx->tx_md.md_addr, nob);
- /* ptlmsg gets finalized when tx completes. */
- tx->tx_ptlmsg[0] = ptlmsg;
+ /* lntmsg gets finalized when tx completes. */
+ tx->tx_lntmsg[0] = lntmsg;
kibnal_launch_tx(tx, nid);
return (0);
void
kibnal_start_active_rdma (int type, int status,
- kib_rx_t *rx, ptl_msg_t *ptlmsg,
- unsigned int niov,
- struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob)
+ kib_rx_t *rx, lnet_msg_t *lntmsg,
+ unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
+ unsigned int offset, unsigned int nob)
{
kib_msg_t *rxmsg = rx->rx_msg;
kib_msg_t *txmsg;
CERROR ("tx descs exhausted on RDMA from %s"
" completing locally with failure\n",
libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
- lnet_finalize (kibnal_data.kib_ni, NULL, ptlmsg, -ENOMEM);
+ lnet_finalize (kibnal_data.kib_ni, NULL, lntmsg, -ENOMEM);
return;
}
LASSERT (tx->tx_nsp == 0);
if (status == 0 && nob != 0) {
LASSERT (tx->tx_nsp > 1);
- /* RDMA: ptlmsg gets finalized when the tx completes. This
+ /* RDMA: lntmsg gets finalized when the tx completes. This
* is after the completion message has been sent, which in
* turn is after the RDMA has finished. */
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
} else {
LASSERT (tx->tx_nsp == 1);
/* No RDMA: local completion happens now! */
CDEBUG(D_WARNING,"No data: immediate completion\n");
- lnet_finalize (kibnal_data.kib_ni, NULL, ptlmsg,
+ lnet_finalize (kibnal_data.kib_ni, NULL, lntmsg,
status == 0 ? 0 : -EIO);
}
}
int
-kibnal_send(ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int payload_niov,
- struct iovec *payload_iov,
- lnet_kiov_t *payload_kiov,
- unsigned int payload_offset,
- unsigned int payload_nob)
+kibnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- kib_msg_t *ibmsg;
- kib_tx_t *tx;
- int nob;
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ int target_is_router = lntmsg->msg_target_is_router;
+ int routing = lntmsg->msg_routing;
+ unsigned int payload_niov = lntmsg->msg_niov;
+ struct iovec *payload_iov = lntmsg->msg_iov;
+ lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
+ unsigned int payload_offset = lntmsg->msg_offset;
+ unsigned int payload_nob = lntmsg->msg_len;
+ kib_msg_t *ibmsg;
+ kib_tx_t *tx;
+ int nob;
/* NB 'private' is different depending on what we're sending.... */
- CDEBUG(D_NET, "sending "LPSZ" bytes in %d frags to %s\n",
+ CDEBUG(D_NET, "sending %d bytes in %d frags to %s\n",
payload_nob, payload_niov, libcfs_id2str(target));
LASSERT (payload_nob == 0 || payload_niov > 0);
LASSERT (payload_niov <= PTL_MD_MAX_IOV);
/* Thread context if we're sending payload */
- LASSERT (!in_interrupt() || payload_niov == 0);
+ LASSERT (!in_interrupt() || payload_nob == 0);
/* payload is either all vaddrs or all pages */
LASSERT (!(payload_kiov != NULL && payload_iov != NULL));
LBUG();
return (-EIO);
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
LASSERT (payload_nob == 0);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
if (routing || target_is_router)
break; /* send IMMEDIATE */
/* is the REPLY message too small for RDMA? */
- nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[ptlmsg->msg_md->md_length]);
+ nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[lntmsg->msg_md->md_length]);
if (nob <= IBNAL_MSG_SIZE)
break; /* send IMMEDIATE */
- return kibnal_start_passive_rdma(IBNAL_MSG_GET_RDMA, 1,
- target.nid, ptlmsg, hdr);
+ return kibnal_start_passive_rdma(IBNAL_MSG_GET_RDMA, 1, lntmsg);
- case PTL_MSG_REPLY: {
+ case LNET_MSG_REPLY: {
/* reply's 'private' is the incoming receive */
kib_rx_t *rx = private;
}
kibnal_start_active_rdma(IBNAL_MSG_GET_DONE, 0,
- rx, ptlmsg, payload_niov,
+ rx, lntmsg, payload_niov,
payload_iov, payload_kiov,
payload_offset, payload_nob);
return (0);
/* Fall through to handle like PUT */
}
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
/* Is the payload small enough not to need RDMA? */
nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob]);
if (nob <= IBNAL_MSG_SIZE)
break; /* send IMMEDIATE */
return kibnal_start_passive_rdma(IBNAL_MSG_PUT_RDMA,
- !(routing || type == PTL_MSG_REPLY),
- target.nid, ptlmsg, hdr);
+ !(routing || type == LNET_MSG_REPLY),
+ lntmsg);
}
- /* send IMMEDIATE */
+ /* Send IMMEDIATE */
tx = kibnal_get_idle_tx(!(routing ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY ||
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY ||
in_interrupt()));
if (tx == NULL) {
CERROR ("Can't send %d to %s: tx descs exhausted%s\n",
ibmsg = tx->tx_msg;
ibmsg->ibm_u.immediate.ibim_hdr = *hdr;
- if (payload_nob > 0) {
- if (payload_kiov != NULL)
- lnet_copy_kiov2buf(ibmsg->ibm_u.immediate.ibim_payload,
- payload_niov, payload_kiov,
- payload_offset, payload_nob);
- else
- lnet_copy_iov2buf(ibmsg->ibm_u.immediate.ibim_payload,
- payload_niov, payload_iov,
- payload_offset, payload_nob);
- }
+ if (payload_kiov != NULL)
+ lnet_copy_kiov2flat(IBNAL_MSG_SIZE, ibmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ payload_niov, payload_kiov,
+ payload_offset, payload_nob);
+ else
+ lnet_copy_iov2flat(IBNAL_MSG_SIZE, ibmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ payload_niov, payload_iov,
+ payload_offset, payload_nob);
kibnal_init_tx_msg (tx, IBNAL_MSG_IMMEDIATE,
offsetof(kib_immediate_msg_t,
ibim_payload[payload_nob]));
- /* ptlmsg gets finalized when tx completes */
- tx->tx_ptlmsg[0] = ptlmsg;
+ /* lntmsg gets finalized when tx completes */
+ tx->tx_lntmsg[0] = lntmsg;
kibnal_launch_tx(tx, target.nid);
return (0);
}
int
-kibnal_recv (ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+kibnal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
kib_rx_t *rx = private;
kib_msg_t *rxmsg = rx->rx_msg;
int msg_nob;
-
+ int rc = 0;
+
LASSERT (mlen <= rlen);
LASSERT (!in_interrupt ());
/* Either all pages or all vaddrs */
switch (rxmsg->ibm_type) {
default:
LBUG();
- return (-EIO);
-
+
case IBNAL_MSG_IMMEDIATE:
msg_nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]);
- if (msg_nob > IBNAL_MSG_SIZE) {
- CERROR ("Immediate message from %s too big: %d\n",
- libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
- rlen);
- return (-EIO);
+ if (msg_nob > rx->rx_nob) {
+ CERROR ("Immediate message from %s too big: %d(%d)\n",
+ libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
+ rlen, rx->rx_nob);
+ rc = -EPROTO;
+ break;
}
if (kiov != NULL)
- lnet_copy_buf2kiov(niov, kiov, offset,
- rxmsg->ibm_u.immediate.ibim_payload,
- mlen);
+ lnet_copy_flat2kiov(niov, kiov, offset,
+ IBNAL_MSG_SIZE, rxmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ mlen);
else
- lnet_copy_buf2iov(niov, iov, offset,
- rxmsg->ibm_u.immediate.ibim_payload,
- mlen);
+ lnet_copy_flat2iov(niov, iov, offset,
+ IBNAL_MSG_SIZE, rxmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ mlen);
- lnet_finalize (ni, NULL, ptlmsg, 0);
- return (0);
+ lnet_finalize (ni, NULL, lntmsg, 0);
+ break;
case IBNAL_MSG_GET_RDMA:
- /* We get called here just to discard any junk after the
- * GET hdr. */
- LASSERT (ptlmsg == NULL);
- lnet_finalize (ni, NULL, ptlmsg, 0);
- return (0);
+ LASSERT (lntmsg == NULL); /* no need to finalise */
+ if (!rx->rx_rdma) {
+ /* GET didn't match anything */
+ kibnal_start_active_rdma (IBNAL_MSG_GET_DONE, -ENODATA,
+ rx, NULL, 0, NULL, NULL, 0, 0);
+ }
+ break;
case IBNAL_MSG_PUT_RDMA:
- kibnal_start_active_rdma (IBNAL_MSG_PUT_DONE, 0,
- rx, ptlmsg,
+ kibnal_start_active_rdma (IBNAL_MSG_PUT_DONE, 0, rx, lntmsg,
niov, iov, kiov, offset, mlen);
- return (0);
+ break;
}
+
+ kibnal_post_rx(rx, 1);
+ return rc;
}
/*****************************************************************************
#include "openiblnd.h"
-ptl_nal_t kibnal_nal = {
- .nal_type = OPENIBNAL,
- .nal_startup = kibnal_startup,
- .nal_shutdown = kibnal_shutdown,
- .nal_ctl = kibnal_ctl,
- .nal_send = kibnal_send,
- .nal_recv = kibnal_recv,
- .nal_accept = kibnal_accept,
+lnd_t the_kiblnd = {
+ .lnd_type = OPENIBLND,
+ .lnd_startup = kibnal_startup,
+ .lnd_shutdown = kibnal_shutdown,
+ .lnd_ctl = kibnal_ctl,
+ .lnd_send = kibnal_send,
+ .lnd_recv = kibnal_recv,
+ .lnd_accept = kibnal_accept,
};
kib_data_t kibnal_data;
}
int
-kibnal_accept(ptl_ni_t *ni, struct socket *sock)
+kibnal_accept(lnet_ni_t *ni, struct socket *sock)
{
kib_acceptsock_t *as;
int rc;
}
int
-kibnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg)
+kibnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
int rc = -EINVAL;
}
void
-kibnal_shutdown (ptl_ni_t *ni)
+kibnal_shutdown (lnet_ni_t *ni)
{
int i;
int rc;
}
int
-kibnal_startup (ptl_ni_t *ni)
+kibnal_startup (lnet_ni_t *ni)
{
struct timeval tv;
int rc;
int i;
- LASSERT (ni->ni_nal == &kibnal_nal);
+ LASSERT (ni->ni_lnd == &the_kiblnd);
/* Only 1 instance supported */
if (kibnal_data.kib_init != IBNAL_INIT_NOTHING) {
void __exit
kibnal_module_fini (void)
{
- lnet_unregister_nal(&kibnal_nal);
+ lnet_unregister_lnd(&the_kiblnd);
kibnal_tunables_fini();
}
if (rc != 0)
return rc;
- lnet_register_nal(&kibnal_nal);
+ lnet_register_lnd(&the_kiblnd);
return (0);
}
__u64 kib_incarnation; /* which one am I */
int kib_shutdown; /* shut down? */
atomic_t kib_nthreads; /* # live threads */
- ptl_ni_t *kib_ni; /* _the_ openib interface */
+ lnet_ni_t *kib_ni; /* _the_ openib interface */
__u64 kib_svc_id; /* service number I listen on */
tTS_IB_GID kib_svc_gid; /* device/port GID */
typedef struct
{
- ptl_hdr_t ibim_hdr; /* portals header */
+ lnet_hdr_t ibim_hdr; /* portals header */
char ibim_payload[0]; /* piggy-backed payload */
} WIRE_ATTR kib_immediate_msg_t;
typedef struct
{
- ptl_hdr_t ibrm_hdr; /* portals header */
+ lnet_hdr_t ibrm_hdr; /* portals header */
__u64 ibrm_cookie; /* opaque completion cookie */
kib_rdma_desc_t ibrm_desc; /* where to suck/blow */
} WIRE_ATTR kib_rdma_msg_t;
} WIRE_ATTR ibm_u;
} WIRE_ATTR kib_msg_t;
-#define IBNAL_MSG_MAGIC PTL_PROTO_OPENIB_MAGIC /* unique magic */
+#define IBNAL_MSG_MAGIC LNET_PROTO_OPENIB_MAGIC /* unique magic */
#define IBNAL_MSG_VERSION 2 /* current protocol version */
#define IBNAL_MSG_SVCQRY 0xb0 /* service query */
struct list_head rx_list; /* queue for attention */
struct kib_conn *rx_conn; /* owning conn */
int rx_rdma; /* RDMA completion posted? */
- int rx_posted; /* posted? */
+ int rx_nob; /* # bytes received (-1 while posted) */
__u64 rx_vaddr; /* pre-mapped buffer (hca vaddr) */
kib_msg_t *rx_msg; /* pre-mapped buffer (host vaddr) */
struct ib_receive_param rx_sp; /* receive work item */
int tx_passive_rdma; /* peer sucks/blows */
int tx_passive_rdma_wait; /* waiting for peer to complete */
__u64 tx_passive_rdma_cookie; /* completion cookie */
- ptl_msg_t *tx_ptlmsg[2]; /* ptl msgs to finalize on completion */
+ lnet_msg_t *tx_lntmsg[2]; /* ptl msgs to finalize on completion */
kib_md_t tx_md; /* RDMA mapping (active/passive) */
__u64 tx_vaddr; /* pre-mapped buffer (hca vaddr) */
kib_msg_t *tx_msg; /* pre-mapped buffer (host vaddr) */
# define sk_sleep sleep
#endif
-int kibnal_startup (ptl_ni_t *ni);
-void kibnal_shutdown (ptl_ni_t *ni);
-int kibnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg);
-int kibnal_send (ptl_ni_t *ni, void *private,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr,
- int type, lnet_process_id_t tgt,
- int tgt_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob);
-int kibnal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+int kibnal_startup (lnet_ni_t *ni);
+void kibnal_shutdown (lnet_ni_t *ni);
+int kibnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
+int kibnal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+int kibnal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
-int kibnal_accept(ptl_ni_t *ni, struct socket *sock);
+int kibnal_accept(lnet_ni_t *ni, struct socket *sock);
extern void kibnal_init_msg(kib_msg_t *msg, int type, int body_nob);
extern void kibnal_pack_msg(kib_msg_t *msg, int credits,
extern void kibnal_init_tx_msg (kib_tx_t *tx, int type, int body_nob);
extern int kibnal_close_conn (kib_conn_t *conn, int why);
extern void kibnal_start_active_rdma (int type, int status,
- kib_rx_t *rx, ptl_msg_t *ptlmsg,
+ kib_rx_t *rx, lnet_msg_t *lntmsg,
unsigned int niov,
struct iovec *iov, lnet_kiov_t *kiov,
int offset, int nob);
void
kibnal_tx_done (kib_tx_t *tx)
{
- int ptlrc = (tx->tx_status == 0) ? 0 : -EIO;
unsigned long flags;
int i;
int rc;
for (i = 0; i < 2; i++) {
/* tx may have up to 2 ptlmsgs to finalise */
- if (tx->tx_ptlmsg[i] == NULL)
+ if (tx->tx_lntmsg[i] == NULL)
continue;
- lnet_finalize (kibnal_data.kib_ni, NULL, tx->tx_ptlmsg[i], ptlrc);
- tx->tx_ptlmsg[i] = NULL;
+ lnet_finalize (kibnal_data.kib_ni, NULL, tx->tx_lntmsg[i],
+ tx->tx_status);
+ tx->tx_lntmsg[i] = NULL;
}
if (tx->tx_conn != NULL) {
LASSERT (tx->tx_conn == NULL);
LASSERT (!tx->tx_passive_rdma);
LASSERT (!tx->tx_passive_rdma_wait);
- LASSERT (tx->tx_ptlmsg[0] == NULL);
- LASSERT (tx->tx_ptlmsg[1] == NULL);
+ LASSERT (tx->tx_lntmsg[0] == NULL);
+ LASSERT (tx->tx_lntmsg[1] == NULL);
}
spin_unlock_irqrestore (&kibnal_data.kib_tx_lock, flags);
};
LASSERT (conn->ibc_state >= IBNAL_CONN_ESTABLISHED);
- LASSERT (!rx->rx_posted);
- rx->rx_posted = 1;
+ LASSERT (rx->rx_nob >= 0); /* not posted */
+ rx->rx_nob = -1; /* is now */
mb();
if (conn->ibc_state != IBNAL_CONN_ESTABLISHED)
int rc;
CDEBUG (D_NET, "rx %p conn %p\n", rx, conn);
- LASSERT (rx->rx_posted);
- rx->rx_posted = 0;
+ LASSERT (rx->rx_nob < 0); /* was posted */
+ rx->rx_nob = 0; /* isn't now */
mb();
/* receives complete with error in any case after we've started
goto failed;
}
- rc = kibnal_unpack_msg(msg, e->bytes_transferred);
+ LASSERT (e->bytes_transferred >= 0);
+ rx->rx_nob = e->bytes_transferred;
+ mb();
+
+ rc = kibnal_unpack_msg(msg, rx->rx_nob);
if (rc != 0) {
CERROR ("Error %d unpacking rx from %s\n",
rc, libcfs_nid2str(conn->ibc_peer->ibp_nid));
void
kibnal_rx (kib_rx_t *rx)
{
+ int rc = 0;
kib_msg_t *msg = rx->rx_msg;
/* Clear flag so I can detect if I've sent an RDMA completion */
switch (msg->ibm_type) {
case IBNAL_MSG_GET_RDMA:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
- /* If the incoming get was matched, I'll have initiated the
- * RDMA and the completion message... */
- if (rx->rx_rdma)
- break;
-
- /* Otherwise, I'll send a failed completion now to prevent
- * the peer's GET blocking for the full timeout. */
- CERROR ("Completing unmatched RDMA GET from %s\n",
- libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
- kibnal_start_active_rdma (IBNAL_MSG_GET_DONE, -EIO,
- rx, NULL, 0, NULL, NULL, 0, 0);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
break;
case IBNAL_MSG_PUT_RDMA:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
- if (rx->rx_rdma)
- break;
- /* This is most unusual, since even if lnet_parse() didn't
- * match anything, it should have asked us to read (and
- * discard) the payload. The portals header must be
- * inconsistent with this message type, so it's the
- * sender's fault for sending garbage and she can time
- * herself out... */
- CERROR ("Uncompleted RMDA PUT from %s\n",
- libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.rdma.ibrm_hdr, rx);
break;
case IBNAL_MSG_IMMEDIATE:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.immediate.ibim_hdr, rx);
- LASSERT (!rx->rx_rdma);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.immediate.ibim_hdr, rx);
break;
-
+
default:
LBUG();
break;
}
- kibnal_post_rx (rx, 1);
+ if (rc < 0) {
+ kibnal_close_conn(rx->rx_conn, rc);
+ kibnal_post_rx (rx, 1);
+ }
}
#if 0
int
kibnal_map_iov (kib_tx_t *tx, enum ib_memory_access access,
- int niov, struct iovec *iov, int offset, int nob)
+ unsigned int niov, struct iovec *iov, int offset, int nob)
{
void *vaddr;
}
int
-kibnal_start_passive_rdma (int type, lnet_nid_t nid, int may_block,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr)
+kibnal_start_passive_rdma (int type, int may_block, lnet_msg_t *lntmsg)
{
- int nob = ptlmsg->msg_md->md_length;
+ lnet_nid_t nid = lntmsg->msg_target.nid;
+ int nob = lntmsg->msg_md->md_length;
kib_tx_t *tx;
kib_msg_t *ibmsg;
int rc;
return -ENOMEM;
}
- if ((ptlmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
+ if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
rc = kibnal_map_iov (tx, access,
- ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.iov,
+ lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.iov,
0, nob);
else
rc = kibnal_map_kiov (tx, access,
- ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.kiov,
+ lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.kiov,
0, nob);
if (rc != 0) {
if (type == IBNAL_MSG_GET_RDMA) {
/* reply gets finalized when tx completes */
- tx->tx_ptlmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
- nid, ptlmsg);
- if (tx->tx_ptlmsg[1] == NULL) {
+ tx->tx_lntmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
+ lntmsg);
+ if (tx->tx_lntmsg[1] == NULL) {
CERROR ("Can't create reply for GET -> %s\n",
libcfs_nid2str(nid));
rc = -ENOMEM;
ibmsg = tx->tx_msg;
- ibmsg->ibm_u.rdma.ibrm_hdr = *hdr;
+ ibmsg->ibm_u.rdma.ibrm_hdr = lntmsg->msg_hdr;
ibmsg->ibm_u.rdma.ibrm_cookie = tx->tx_passive_rdma_cookie;
ibmsg->ibm_u.rdma.ibrm_desc.rd_key = tx->tx_md.md_rkey;
ibmsg->ibm_u.rdma.ibrm_desc.rd_addr = tx->tx_md.md_addr;
tx, tx->tx_passive_rdma_cookie, tx->tx_md.md_rkey,
tx->tx_md.md_addr, nob);
- /* ptlmsg gets finalized when tx completes. */
- tx->tx_ptlmsg[0] = ptlmsg;
+ /* lntmsg gets finalized when tx completes. */
+ tx->tx_lntmsg[0] = lntmsg;
kibnal_launch_tx(tx, nid);
return (0);
void
kibnal_start_active_rdma (int type, int status,
- kib_rx_t *rx, ptl_msg_t *ptlmsg,
- unsigned int niov,
- struct iovec *iov, lnet_kiov_t *kiov,
- int offset, int nob)
+ kib_rx_t *rx, lnet_msg_t *lntmsg,
+ unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
+ int offset, int nob)
{
kib_msg_t *rxmsg = rx->rx_msg;
kib_msg_t *txmsg;
CERROR ("tx descs exhausted on RDMA from %s"
" completing locally with failure\n",
libcfs_nid2str(rx->rx_conn->ibc_peer->ibp_nid));
- lnet_finalize (kibnal_data.kib_ni, NULL, ptlmsg, -ENOMEM);
+ lnet_finalize (kibnal_data.kib_ni, NULL, lntmsg, -ENOMEM);
return;
}
LASSERT (tx->tx_nsp == 0);
if (status == 0 && nob != 0) {
LASSERT (tx->tx_nsp > 1);
- /* RDMA: ptlmsg gets finalized when the tx completes. This
+ /* RDMA: lntmsg gets finalized when the tx completes. This
* is after the completion message has been sent, which in
* turn is after the RDMA has finished. */
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
} else {
LASSERT (tx->tx_nsp == 1);
/* No RDMA: local completion happens now! */
CDEBUG(D_NET, "No data: immediate completion\n");
- lnet_finalize (kibnal_data.kib_ni, NULL, ptlmsg,
+ lnet_finalize (kibnal_data.kib_ni, NULL, lntmsg,
status == 0 ? 0 : -EIO);
}
}
int
-kibnal_send(ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int payload_niov,
- struct iovec *payload_iov,
- lnet_kiov_t *payload_kiov,
- unsigned int payload_offset,
- unsigned int payload_nob)
+kibnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- kib_msg_t *ibmsg;
- kib_tx_t *tx;
- int nob;
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ int target_is_router = lntmsg->msg_target_is_router;
+ int routing = lntmsg->msg_routing;
+ unsigned int payload_niov = lntmsg->msg_niov;
+ struct iovec *payload_iov = lntmsg->msg_iov;
+ lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
+ unsigned int payload_offset = lntmsg->msg_offset;
+ unsigned int payload_nob = lntmsg->msg_len;
+ kib_msg_t *ibmsg;
+ kib_tx_t *tx;
+ int nob;
/* NB 'private' is different depending on what we're sending.... */
LBUG();
return (-EIO);
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
LASSERT (payload_nob == 0);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
if (routing || target_is_router)
- break; /* send IMMEDIATE */
-
+ break; /* send IMMEDIATE */
+
/* is the REPLY message too small for RDMA? */
- nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[ptlmsg->msg_md->md_length]);
+ nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[lntmsg->msg_md->md_length]);
if (nob <= IBNAL_MSG_SIZE)
break; /* send IMMEDIATE */
-
- return kibnal_start_passive_rdma(IBNAL_MSG_GET_RDMA, 1,
- target.nid, ptlmsg, hdr);
- case PTL_MSG_REPLY: {
+ return kibnal_start_passive_rdma(IBNAL_MSG_GET_RDMA, 1, lntmsg);
+
+ case LNET_MSG_REPLY: {
/* reply's 'private' is the incoming receive */
kib_rx_t *rx = private;
/* RDMA reply expected? */
if (!routing && rx->rx_msg->ibm_type != IBNAL_MSG_IMMEDIATE) {
- /* Incoming message consistent with RDMA? */
+ /* Incoming message consistent with RDMA */
if (rx->rx_msg->ibm_type != IBNAL_MSG_GET_RDMA) {
CERROR ("REPLY to %s bad ibm type %d!!!\n",
libcfs_nid2str(target.nid),
}
kibnal_start_active_rdma(IBNAL_MSG_GET_DONE, 0,
- rx, ptlmsg, payload_niov,
+ rx, lntmsg, payload_niov,
payload_iov, payload_kiov,
payload_offset, payload_nob);
return (0);
/* Fall through to handle like PUT */
}
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
/* Is the payload small enough not to need RDMA? */
nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob]);
if (nob <= IBNAL_MSG_SIZE)
break; /* send IMMEDIATE */
return kibnal_start_passive_rdma(IBNAL_MSG_PUT_RDMA,
- !(routing || type == PTL_MSG_REPLY),
- target.nid, ptlmsg, hdr);
+ !(routing || type == LNET_MSG_REPLY),
+ lntmsg);
}
/* Send IMMEDIATE */
tx = kibnal_get_idle_tx(!(routing ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY ||
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY ||
in_interrupt()));
if (tx == NULL) {
CERROR ("Can't send %d to %s: tx descs exhausted%s\n",
ibmsg = tx->tx_msg;
ibmsg->ibm_u.immediate.ibim_hdr = *hdr;
- if (payload_nob > 0) {
- if (payload_kiov != NULL)
- lnet_copy_kiov2buf(ibmsg->ibm_u.immediate.ibim_payload,
- payload_niov, payload_kiov,
- payload_offset, payload_nob);
- else
- lnet_copy_iov2buf(ibmsg->ibm_u.immediate.ibim_payload,
- payload_niov, payload_iov,
- payload_offset, payload_nob);
- }
+ if (payload_kiov != NULL)
+ lnet_copy_kiov2flat(IBNAL_MSG_SIZE, ibmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ payload_niov, payload_kiov,
+ payload_offset, payload_nob);
+ else
+ lnet_copy_iov2flat(IBNAL_MSG_SIZE, ibmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ payload_niov, payload_iov,
+ payload_offset, payload_nob);
kibnal_init_tx_msg (tx, IBNAL_MSG_IMMEDIATE,
offsetof(kib_immediate_msg_t,
ibim_payload[payload_nob]));
- /* ptlmsg gets finalized when tx completes */
- tx->tx_ptlmsg[0] = ptlmsg;
+ /* lntmsg gets finalized when tx completes */
+ tx->tx_lntmsg[0] = lntmsg;
kibnal_launch_tx(tx, target.nid);
return (0);
}
+
int
-kibnal_recv (ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+kibnal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
kib_rx_t *rx = private;
kib_msg_t *rxmsg = rx->rx_msg;
int msg_nob;
+ int rc = 0;
LASSERT (mlen <= rlen);
LASSERT (!in_interrupt ());
switch (rxmsg->ibm_type) {
default:
LBUG();
- return (-EIO);
-
+
case IBNAL_MSG_IMMEDIATE:
msg_nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]);
- if (msg_nob > IBNAL_MSG_SIZE) {
- CERROR ("Immediate message from %s too big: %d\n",
+ if (msg_nob > rx->rx_nob) {
+ CERROR ("Immediate message from %s too big: %d(%d)\n",
libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
- rlen);
- return (-EIO);
+ rlen, rx->rx_nob);
+ rc = -EPROTO;
+ break;
}
if (kiov != NULL)
- lnet_copy_buf2kiov(niov, kiov, offset,
- rxmsg->ibm_u.immediate.ibim_payload,
- mlen);
+ lnet_copy_flat2kiov(
+ niov, kiov, offset,
+ IBNAL_MSG_SIZE, rxmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ mlen);
else
- lnet_copy_buf2iov(niov, iov, offset,
- rxmsg->ibm_u.immediate.ibim_payload,
- mlen);
+ lnet_copy_flat2iov(
+ niov, iov, offset,
+ IBNAL_MSG_SIZE, rxmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ mlen);
- lnet_finalize (ni, NULL, ptlmsg, 0);
- return (0);
+ lnet_finalize (ni, NULL, lntmsg, 0);
+ break;
case IBNAL_MSG_GET_RDMA:
- /* We get called here just to discard any junk after the
- * GET hdr. */
- LASSERT (ptlmsg == NULL);
- lnet_finalize (ni, NULL, ptlmsg, 0);
- return (0);
+ LASSERT (lntmsg == NULL); /* no need to finalise */
+ if (!rx->rx_rdma) {
+ /* GET didn't match anything */
+ kibnal_start_active_rdma (IBNAL_MSG_GET_DONE, -ENODATA,
+ rx, NULL, 0, NULL, NULL, 0, 0);
+ }
+ break;
case IBNAL_MSG_PUT_RDMA:
- kibnal_start_active_rdma (IBNAL_MSG_PUT_DONE, 0,
- rx, ptlmsg,
+ kibnal_start_active_rdma (IBNAL_MSG_PUT_DONE, 0, rx, lntmsg,
niov, iov, kiov, offset, mlen);
- return (0);
+ break;
}
+
+ kibnal_post_rx(rx, 1);
+ return rc;
}
int
#include "ptllnd.h"
-ptl_handle_ni_t nih;\r
+lnet_handle_ni_t nih;\r
\r
\r
void __exit
kptllnd_module_init (void)
{
int rc = 0;\r
- ptl_process_id_t portals_id;
+ lnet_process_id_t portals_id;
PJK_UT_MSG(">>> %s %s\n",__DATE__,__TIME__);\r
\r
PJK_UT_MSG("PtlNIInit\n");
#include "qswlnd.h"
-ptl_nal_t kqswnal_nal =
+lnd_t the_kqswlnd =
{
- .nal_type = QSWNAL,
- .nal_startup = kqswnal_startup,
- .nal_shutdown = kqswnal_shutdown,
- .nal_ctl = kqswnal_ctl,
- .nal_send = kqswnal_send,
- .nal_recv = kqswnal_recv,
- .nal_fwd = kqswnal_fwd_packet,
+ .lnd_type = QSWLND,
+ .lnd_startup = kqswnal_startup,
+ .lnd_shutdown = kqswnal_shutdown,
+ .lnd_ctl = kqswnal_ctl,
+ .lnd_send = kqswnal_send,
+ .lnd_recv = kqswnal_recv,
};
kqswnal_data_t kqswnal_data;
unsigned long flags;
struct list_head *tmp;
kqswnal_tx_t *ktx;
- ptl_hdr_t *hdr;
+ lnet_hdr_t *hdr;
int index = data->ioc_count;
int rc = -ENOENT;
continue;
ktx = list_entry (tmp, kqswnal_tx_t, ktx_list);
- hdr = (ptl_hdr_t *)ktx->ktx_buffer;
+ hdr = (lnet_hdr_t *)ktx->ktx_buffer;
data->ioc_count = le32_to_cpu(hdr->payload_length);
data->ioc_nid = le64_to_cpu(hdr->dest_nid);
}
int
-kqswnal_ctl (ptl_ni_t *ni, unsigned int cmd, void *arg)
+kqswnal_ctl (lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
}
void
-kqswnal_shutdown(ptl_ni_t *ni)
+kqswnal_shutdown(lnet_ni_t *ni)
{
unsigned long flags;
kqswnal_tx_t *ktx;
/* NB ep_free_rcvr() returns only after we've freed off all receive
* buffers (see shutdown handling in kqswnal_requeue_rx()). This
* means we must have completed any messages we passed to
- * lnet_parse() or lnet_fwd_start(). */
+ * lnet_parse() */
if (kqswnal_data.kqn_eptx != NULL)
ep_free_xmtr (kqswnal_data.kqn_eptx);
#if MULTIRAIL_EKC
LASSERT (list_empty (&kqswnal_data.kqn_readyrxds));
LASSERT (list_empty (&kqswnal_data.kqn_delayedtxds));
- LASSERT (list_empty (&kqswnal_data.kqn_delayedfwds));
#endif
/**********************************************************************/
- /* Complete any blocked forwarding packets, with error
- */
-
- while (!list_empty (&kqswnal_data.kqn_idletxd_fwdq))
- {
- kpr_fwd_desc_t *fwd = list_entry (kqswnal_data.kqn_idletxd_fwdq.next,
- kpr_fwd_desc_t, kprfd_list);
- list_del (&fwd->kprfd_list);
- lnet_fwd_done (ni, fwd, -ESHUTDOWN);
- }
-
- /**********************************************************************/
/* Unmap message buffers and free all descriptors and buffers
*/
}
int
-kqswnal_startup (ptl_ni_t *ni)
+kqswnal_startup (lnet_ni_t *ni)
{
#if MULTIRAIL_EKC
EP_RAILMASK all_rails = EP_RAILMASK_ALL;
kqswnal_tx_t *ktx;
int elan_page_idx;
- LASSERT (ni->ni_nal == &kqswnal_nal);
+ LASSERT (ni->ni_lnd == &the_kqswlnd);
/* Only 1 instance supported */
if (kqswnal_data.kqn_init != KQN_INIT_NOTHING) {
INIT_LIST_HEAD (&kqswnal_data.kqn_activetxds);
spin_lock_init (&kqswnal_data.kqn_idletxd_lock);
init_waitqueue_head (&kqswnal_data.kqn_idletxd_waitq);
- INIT_LIST_HEAD (&kqswnal_data.kqn_idletxd_fwdq);
- INIT_LIST_HEAD (&kqswnal_data.kqn_delayedfwds);
INIT_LIST_HEAD (&kqswnal_data.kqn_delayedtxds);
INIT_LIST_HEAD (&kqswnal_data.kqn_readyrxds);
return (-ENOMEM);
}
- krx->krx_kiov[j].kiov_page = page;
+ krx->krx_kiov[j] = (lnet_kiov_t) {.kiov_page = page,
+ .kiov_offset = 0,
+ .kiov_len = PAGE_SIZE};
LASSERT(page_address(page) != NULL);
-
#if MULTIRAIL_EKC
ep_dvma_load(kqswnal_data.kqn_ep, NULL,
page_address(page),
void __exit
kqswnal_finalise (void)
{
- lnet_unregister_nal(&kqswnal_nal);
+ lnet_unregister_lnd(&the_kqswlnd);
kqswnal_tunables_fini();
}
if (rc != 0)
return rc;
- lnet_register_nal(&kqswnal_nal);
+ lnet_register_lnd(&the_kqswlnd);
return (0);
}
#include <lnet/lnet.h>
#include <lnet/lib-lnet.h>
-#define KQSW_CHECKSUM 0
-#if KQSW_CHECKSUM
-typedef unsigned long kqsw_csum_t;
-#define KQSW_CSUM_SIZE (2 * sizeof (kqsw_csum_t))
-#else
-#define KQSW_CSUM_SIZE 0
-#endif
-#define KQSW_HDR_SIZE (sizeof (ptl_hdr_t) + KQSW_CSUM_SIZE)
+#define KQSW_HDR_SIZE (sizeof (lnet_hdr_t))
/*
* Performance Tuning defines
#define KQSW_OPTIMIZED_PUTS (32<<10) /* optimize puts >= this size */
/* fixed constants */
-#define KQSW_MAXPAYLOAD PTL_MTU
#define KQSW_SMALLPAYLOAD ((4<<10) - KQSW_HDR_SIZE) /* small/large ep receiver breakpoint */
#define KQSW_RESCHED 100 /* # busy loops that forces scheduler to yield */
#define KQSW_TX_BUFFER_SIZE (KQSW_HDR_SIZE + *kqswnal_tunables.kqn_tx_maxcontig)
/* The pre-allocated tx buffer (hdr + small payload) */
-#define KQSW_NTXMSGPAGES (btopr(KQSW_TX_BUFFER_SIZE) + 1 + btopr(KQSW_MAXPAYLOAD) + 1)
+#define KQSW_NTXMSGPAGES (btopr(KQSW_TX_BUFFER_SIZE) + 1 + btopr(PTL_MTU) + 1)
/* Reserve elan address space for pre-allocated and pre-mapped transmit
* buffer and a full payload too. Extra pages allow for page alignment */
/* receive hdr/payload always contiguous and page aligned */
#define KQSW_NRXMSGBYTES_SMALL (KQSW_NRXMSGPAGES_SMALL * PAGE_SIZE)
-#define KQSW_NRXMSGPAGES_LARGE (btopr(KQSW_HDR_SIZE + KQSW_MAXPAYLOAD))
+#define KQSW_NRXMSGPAGES_LARGE (btopr(KQSW_HDR_SIZE + PTL_MTU))
/* receive hdr/payload always contiguous and page aligned */
#define KQSW_NRXMSGBYTES_LARGE (KQSW_NRXMSGPAGES_LARGE * PAGE_SIZE)
/* biggest complete packet we can receive (or transmit) */
int krx_rpc_reply_status; /* what status to send */
int krx_state; /* what this RX is doing */
atomic_t krx_refcount; /* how to tell when rpc is done */
- kpr_fwd_desc_t krx_fwd; /* embedded forwarding descriptor */
- lnet_kiov_t krx_kiov[KQSW_NRXMSGPAGES_LARGE]; /* buffer frags */
+ lnet_kiov_t krx_kiov[KQSW_NRXMSGPAGES_LARGE]; /* buffer frags */
} kqswnal_rx_t;
#define KRX_POSTED 1 /* receiving */
} kqswnal_tx_t;
#define KTX_IDLE 0 /* on kqn_(nblk_)idletxds */
-#define KTX_FORWARDING 1 /* sending a forwarded packet */
-#define KTX_SENDING 2 /* normal send */
-#define KTX_GETTING 3 /* sending optimised get */
-#define KTX_PUTTING 4 /* sending optimised put */
-#define KTX_RDMAING 5 /* handling optimised put/get */
+#define KTX_SENDING 1 /* normal send */
+#define KTX_GETTING 2 /* sending optimised get */
+#define KTX_PUTTING 3 /* sending optimised put */
+#define KTX_RDMAING 4 /* handling optimised put/get */
typedef struct
{
char kqn_init; /* what's been initialised */
char kqn_shuttingdown; /* I'm trying to shut down */
atomic_t kqn_nthreads; /* # threads running */
- ptl_ni_t *kqn_ni; /* _the_ instance of me */
+ lnet_ni_t *kqn_ni; /* _the_ instance of me */
kqswnal_rx_t *kqn_rxds; /* stack of all the receive descriptors */
kqswnal_tx_t *kqn_txds; /* stack of all the transmit descriptors */
struct list_head kqn_activetxds; /* transmit descriptors being used */
spinlock_t kqn_idletxd_lock; /* serialise idle txd access */
wait_queue_head_t kqn_idletxd_waitq; /* sender blocks here waiting for idle txd */
- struct list_head kqn_idletxd_fwdq; /* forwarded packets block here waiting for idle txd */
atomic_t kqn_pending_txs; /* # transmits being prepped */
spinlock_t kqn_sched_lock; /* serialise packet schedulers */
wait_queue_head_t kqn_sched_waitq; /* scheduler blocks here */
struct list_head kqn_readyrxds; /* rxds full of data */
- struct list_head kqn_delayedfwds; /* delayed forwards */
struct list_head kqn_delayedtxds; /* delayed transmits */
#if MULTIRAIL_EKC
extern int kqswnal_thread_start (int (*fn)(void *arg), void *arg);
extern void kqswnal_rxhandler(EP_RXD *rxd);
extern int kqswnal_scheduler (void *);
-extern void kqswnal_fwd_packet (ptl_ni_t *ni, kpr_fwd_desc_t *fwd);
extern void kqswnal_rx_done (kqswnal_rx_t *krx);
static inline lnet_nid_t
return (last_page - first_page + 1);
}
-#if KQSW_CHECKSUM
-static inline kqsw_csum_t kqsw_csum (kqsw_csum_t sum, void *base, int nob)
-{
- unsigned char *ptr = (unsigned char *)base;
-
- while (nob-- > 0)
- sum += *ptr++;
-
- return (sum);
-}
-#endif
-
static inline void kqswnal_rx_decref (kqswnal_rx_t *krx)
{
LASSERT (atomic_read (&krx->krx_refcount) > 0);
}
#endif
-int kqswnal_startup (ptl_ni_t *ni);
-void kqswnal_shutdown (ptl_ni_t *ni);
-int kqswnal_ctl (ptl_ni_t *ni, unsigned int cmd, void *arg);
-int kqswnal_send (ptl_ni_t *ni, void *private,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr,
- int type, lnet_process_id_t tgt,
- int tgt_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob);
-int kqswnal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+int kqswnal_startup (lnet_ni_t *ni);
+void kqswnal_shutdown (lnet_ni_t *ni);
+int kqswnal_ctl (lnet_ni_t *ni, unsigned int cmd, void *arg);
+int kqswnal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+int kqswnal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
int kqswnal_tunables_init(void);
}
int
-kqswnal_map_tx_kiov (kqswnal_tx_t *ktx, int offset, int nob, int niov, lnet_kiov_t *kiov)
+kqswnal_map_tx_kiov (kqswnal_tx_t *ktx, int offset, int nob,
+ unsigned int niov, lnet_kiov_t *kiov)
{
int nfrags = ktx->ktx_nfrag;
int nmapped = ktx->ktx_nmappedpages;
int
kqswnal_map_tx_iov (kqswnal_tx_t *ktx, int offset, int nob,
- int niov, struct iovec *iov)
+ unsigned int niov, struct iovec *iov)
{
int nfrags = ktx->ktx_nfrag;
int nmapped = ktx->ktx_nmappedpages;
void
kqswnal_put_idle_tx (kqswnal_tx_t *ktx)
{
- kpr_fwd_desc_t *fwd = NULL;
unsigned long flags;
kqswnal_unmap_tx (ktx); /* release temporary mappings */
list_add (&ktx->ktx_list, &kqswnal_data.kqn_idletxds);
- /* anything blocking for a tx descriptor? */
- if (!kqswnal_data.kqn_shuttingdown &&
- !list_empty(&kqswnal_data.kqn_idletxd_fwdq)) /* forwarded packet? */
- {
- CDEBUG(D_NET,"wakeup fwd\n");
-
- fwd = list_entry (kqswnal_data.kqn_idletxd_fwdq.next,
- kpr_fwd_desc_t, kprfd_list);
- list_del (&fwd->kprfd_list);
- }
-
wake_up (&kqswnal_data.kqn_idletxd_waitq);
spin_unlock_irqrestore (&kqswnal_data.kqn_idletxd_lock, flags);
-
- if (fwd == NULL)
- return;
-
- /* schedule packet for forwarding again */
- spin_lock_irqsave (&kqswnal_data.kqn_sched_lock, flags);
-
- list_add_tail (&fwd->kprfd_list, &kqswnal_data.kqn_delayedfwds);
- wake_up (&kqswnal_data.kqn_sched_waitq);
-
- spin_unlock_irqrestore (&kqswnal_data.kqn_sched_lock, flags);
}
kqswnal_tx_t *
-kqswnal_get_idle_tx (kpr_fwd_desc_t *fwd, int may_block)
+kqswnal_get_idle_tx (int may_block)
{
unsigned long flags;
kqswnal_tx_t *ktx = NULL;
break;
}
- if (fwd != NULL) /* forwarded packet? */
- break;
-
- /* doing a local transmit */
if (!may_block) {
if (list_empty (&kqswnal_data.kqn_nblk_idletxds)) {
CERROR ("intr tx desc pool exhausted\n");
list_add (&ktx->ktx_list, &kqswnal_data.kqn_activetxds);
ktx->ktx_launcher = current->pid;
atomic_inc(&kqswnal_data.kqn_pending_txs);
- } else if (fwd != NULL) {
- /* queue forwarded packet until idle txd available */
- CDEBUG (D_NET, "blocked fwd [%p]\n", fwd);
- list_add_tail (&fwd->kprfd_list,
- &kqswnal_data.kqn_idletxd_fwdq);
- }
+ }
spin_unlock_irqrestore (&kqswnal_data.kqn_idletxd_lock, flags);
kqswnal_tx_done (kqswnal_tx_t *ktx, int error)
{
switch (ktx->ktx_state) {
- case KTX_FORWARDING: /* router asked me to forward this packet */
- lnet_fwd_done (kqswnal_data.kqn_ni,
- (kpr_fwd_desc_t *)ktx->ktx_args[0], error);
- break;
-
case KTX_RDMAING: /* optimized GET/PUT handled */
case KTX_PUTTING: /* optimized PUT sent */
case KTX_SENDING: /* normal send */
lnet_finalize (kqswnal_data.kqn_ni, NULL,
- (ptl_msg_t *)ktx->ktx_args[1],
+ (lnet_msg_t *)ktx->ktx_args[1],
(error == 0) ? 0 : -EIO);
break;
* delivering a REPLY event; we committed to it when we
* launched the GET */
lnet_finalize (kqswnal_data.kqn_ni, NULL,
- (ptl_msg_t *)ktx->ktx_args[1], 0);
+ (lnet_msg_t *)ktx->ktx_args[1], 0);
lnet_finalize (kqswnal_data.kqn_ni, NULL,
- (ptl_msg_t *)ktx->ktx_args[2],
+ (lnet_msg_t *)ktx->ktx_args[2],
(error == 0) ? 0 : -EIO);
break;
#endif
break;
- case KTX_FORWARDING:
case KTX_SENDING:
status = 0;
break;
NULL, ktx->ktx_frags, 1);
break;
- case KTX_FORWARDING:
case KTX_SENDING:
#if MULTIRAIL_EKC
rc = ep_transmit_message(kqswnal_data.kqn_eptx, dest,
#if 0
static char *
-hdr_type_string (ptl_hdr_t *hdr)
+hdr_type_string (lnet_hdr_t *hdr)
{
switch (hdr->type) {
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
return ("ACK");
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
return ("PUT");
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
return ("GET");
- case PTL_MSG_REPLY:
+ case LNET_MSG_REPLY:
return ("REPLY");
default:
return ("<UNKNOWN>");
}
static void
-kqswnal_cerror_hdr(ptl_hdr_t * hdr)
+kqswnal_cerror_hdr(lnet_hdr_t * hdr)
{
char *type_str = hdr_type_string (hdr);
le32_to_cpu(hdr->dest_pid));
switch (le32_to_cpu(hdr->type)) {
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
CERROR(" Ptl index %d, ack md "LPX64"."LPX64", "
"match bits "LPX64"\n",
le32_to_cpu(hdr->msg.put.ptl_index),
hdr->msg.put.hdr_data);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
CERROR(" Ptl index %d, return md "LPX64"."LPX64", "
"match bits "LPX64"\n",
le32_to_cpu(hdr->msg.get.ptl_index),
le32_to_cpu(hdr->msg.get.src_offset));
break;
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
CERROR(" dst md "LPX64"."LPX64", manipulated length %d\n",
hdr->msg.ack.dst_wmd.wh_interface_cookie,
hdr->msg.ack.dst_wmd.wh_object_cookie,
le32_to_cpu(hdr->msg.ack.mlength));
break;
- case PTL_MSG_REPLY:
+ case LNET_MSG_REPLY:
CERROR(" dst md "LPX64"."LPX64"\n",
hdr->msg.reply.dst_wmd.wh_interface_cookie,
hdr->msg.reply.dst_wmd.wh_object_cookie);
kqswnal_parse_rmd (kqswnal_rx_t *krx, int type, lnet_nid_t expected_nid)
{
char *buffer = (char *)page_address(krx->krx_kiov[0].kiov_page);
- ptl_hdr_t *hdr = (ptl_hdr_t *)buffer;
+ lnet_hdr_t *hdr = (lnet_hdr_t *)buffer;
kqswnal_remotemd_t *rmd = (kqswnal_remotemd_t *)(buffer + KQSW_HDR_SIZE);
lnet_nid_t nid = kqswnal_rx_nid(krx);
krx->krx_rpc_reply_needed = 0;
kqswnal_rx_decref (krx);
- /* free ktx & finalize() its ptl_msg_t */
+ /* free ktx & finalize() its lnet_msg_t */
kqswnal_tx_done(ktx, (status == EP_SUCCESS) ? 0 : -ECONNABORTED);
}
status = -ECONNABORTED;
}
- /* free ktx & finalize() its ptl_msg_t */
+ /* free ktx & finalize() its lnet_msg_t */
kqswnal_tx_done(ktx, status);
if (!in_interrupt()) {
}
int
-kqswnal_rdma (kqswnal_rx_t *krx, ptl_msg_t *ptlmsg, int type,
- int niov, struct iovec *iov, lnet_kiov_t *kiov,
+kqswnal_rdma (kqswnal_rx_t *krx, lnet_msg_t *lntmsg, int type,
+ unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int len)
{
kqswnal_remotemd_t *rmd;
int ndatav;
#endif
- LASSERT (type == PTL_MSG_GET ||
- type == PTL_MSG_PUT ||
- type == PTL_MSG_REPLY);
+ LASSERT (type == LNET_MSG_GET ||
+ type == LNET_MSG_PUT ||
+ type == LNET_MSG_REPLY);
/* Not both mapped and paged payload */
LASSERT (iov == NULL || kiov == NULL);
/* RPC completes with failure by default */
LASSERT (krx->krx_rpc_reply_needed);
LASSERT (krx->krx_rpc_reply_status != 0);
- rmd = kqswnal_parse_rmd(krx, type, ptlmsg->msg_ev.initiator.nid);
+ rmd = kqswnal_parse_rmd(krx, type, lntmsg->msg_ev.initiator.nid);
if (rmd == NULL)
return (-EPROTO);
if (len == 0) {
/* data got truncated to nothing. */
- lnet_finalize(kqswnal_data.kqn_ni, krx, ptlmsg, 0);
+ lnet_finalize(kqswnal_data.kqn_ni, krx, lntmsg, 0);
/* Let kqswnal_rx_done() complete the RPC with success */
krx->krx_rpc_reply_status = 0;
return (0);
/* NB I'm using 'ktx' just to map the local RDMA buffers; I'm not
actually sending a portals message with it */
- ktx = kqswnal_get_idle_tx(NULL, 0);
+ ktx = kqswnal_get_idle_tx(0);
if (ktx == NULL) {
CERROR ("Can't get txd for RDMA with %s\n",
- libcfs_nid2str(ptlmsg->msg_ev.initiator.nid));
+ libcfs_nid2str(lntmsg->msg_ev.initiator.nid));
return (-ENOMEM);
}
ktx->ktx_state = KTX_RDMAING;
- ktx->ktx_nid = ptlmsg->msg_ev.initiator.nid;
+ ktx->ktx_nid = lntmsg->msg_ev.initiator.nid;
ktx->ktx_args[0] = krx;
- ktx->ktx_args[1] = ptlmsg;
+ ktx->ktx_args[1] = lntmsg;
+
+ LASSERT (atomic_read(&krx->krx_refcount) > 0);
+ /* Take an extra ref for the completion callback */
+ atomic_inc(&krx->krx_refcount);
#if MULTIRAIL_EKC
/* Map on the rail the RPC prefers */
default:
LBUG();
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
ndatav = kqswnal_eiovs2datav(EP_MAXFRAG, datav,
ktx->ktx_nfrag, ktx->ktx_frags,
rmd->kqrmd_nfrag, rmd->kqrmd_frag);
break;
- case PTL_MSG_PUT:
- case PTL_MSG_REPLY:
+ case LNET_MSG_PUT:
+ case LNET_MSG_REPLY:
ndatav = kqswnal_eiovs2datav(EP_MAXFRAG, datav,
rmd->kqrmd_nfrag, rmd->kqrmd_frag,
ktx->ktx_nfrag, ktx->ktx_frags);
}
#endif
- LASSERT (atomic_read(&krx->krx_refcount) > 0);
- /* Take an extra ref for the completion callback */
- atomic_inc(&krx->krx_refcount);
-
switch (type) {
default:
LBUG();
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
#if MULTIRAIL_EKC
eprc = ep_complete_rpc(krx->krx_rxd,
kqswnal_rdma_store_complete, ktx,
}
break;
- case PTL_MSG_PUT:
- case PTL_MSG_REPLY:
+ case LNET_MSG_PUT:
+ case LNET_MSG_REPLY:
#if MULTIRAIL_EKC
eprc = ep_rpc_get (krx->krx_rxd,
kqswnal_rdma_fetch_complete, ktx,
}
int
-kqswnal_send (ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int payload_niov,
- struct iovec *payload_iov,
- lnet_kiov_t *payload_kiov,
- unsigned int payload_offset,
- unsigned int payload_nob)
+kqswnal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- kqswnal_tx_t *ktx;
- int rc;
-#if KQSW_CHECKSUM
- int i;
- kqsw_csum_t csum;
- int sumoff;
- int sumnob;
-#endif
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ int target_is_router = lntmsg->msg_target_is_router;
+ int routing = lntmsg->msg_routing;
+ unsigned int payload_niov = lntmsg->msg_niov;
+ struct iovec *payload_iov = lntmsg->msg_iov;
+ lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
+ unsigned int payload_offset = lntmsg->msg_offset;
+ unsigned int payload_nob = lntmsg->msg_len;
+ kqswnal_tx_t *ktx;
+ int rc;
/* NB 1. hdr is in network byte order */
/* 2. 'private' depends on the message type */
/* payload is either all vaddrs or all pages */
LASSERT (!(payload_kiov != NULL && payload_iov != NULL));
- if (payload_nob > KQSW_MAXPAYLOAD) {
- CERROR ("request exceeds MTU size %u (max %u).\n",
- payload_nob, KQSW_MAXPAYLOAD);
- return (-EIO);
- }
-
- if (type == PTL_MSG_REPLY) {
+ if (type == LNET_MSG_REPLY) {
kqswnal_rx_t *rx = (kqswnal_rx_t *)private;
LASSERT (routing || rx != NULL);
if (!routing && rx->krx_rpc_reply_needed) { /* is it an RPC */
/* Must be a REPLY for an optimized GET */
- rc = kqswnal_rdma (
- rx, ptlmsg, PTL_MSG_GET,
+ return kqswnal_rdma (
+ rx, lntmsg, LNET_MSG_GET,
payload_niov, payload_iov, payload_kiov,
payload_offset, payload_nob);
- return ((rc == 0) ? 0 : -EIO);
}
}
/* I may not block for a transmit descriptor if I might block the
* router, receiver, or an interrupt handler. */
- ktx = kqswnal_get_idle_tx(NULL, !(routing ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY ||
- in_interrupt()));
+ ktx = kqswnal_get_idle_tx(!(routing ||
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY ||
+ in_interrupt()));
if (ktx == NULL) {
CERROR ("Can't get txd for msg type %d for %s\n",
type, libcfs_nid2str(target.nid));
ktx->ktx_state = KTX_SENDING;
ktx->ktx_nid = target.nid;
ktx->ktx_args[0] = private;
- ktx->ktx_args[1] = ptlmsg;
+ ktx->ktx_args[1] = lntmsg;
ktx->ktx_args[2] = NULL; /* set when a GET commits to REPLY */
memcpy (ktx->ktx_buffer, hdr, sizeof (*hdr)); /* copy hdr from caller's stack */
-#if KQSW_CHECKSUM
- csum = kqsw_csum (0, (char *)hdr, sizeof (*hdr));
- memcpy (ktx->ktx_buffer + sizeof (*hdr), &csum, sizeof (csum));
- for (csum = 0, i = 0, sumoff = payload_offset, sumnob = payload_nob; sumnob > 0; i++) {
- LASSERT(i < niov);
- if (payload_kiov != NULL) {
- lnet_kiov_t *kiov = &payload_kiov[i];
-
- if (sumoff >= kiov->kiov_len) {
- sumoff -= kiov->kiov_len;
- } else {
- char *addr = ((char *)kmap (kiov->kiov_page)) +
- kiov->kiov_offset + sumoff;
- int fragnob = kiov->kiov_len - sumoff;
-
- csum = kqsw_csum(csum, addr, MIN(sumnob, fragnob));
- sumnob -= fragnob;
- sumoff = 0;
- kunmap(kiov->kiov_page);
- }
- } else {
- struct iovec *iov = &payload_iov[i];
-
- if (sumoff > iov->iov_len) {
- sumoff -= iov->iov_len;
- } else {
- char *addr = iov->iov_base + sumoff;
- int fragnob = iov->iov_len - sumoff;
-
- csum = kqsw_csum(csum, addr, MIN(sumnob, fragnob));
- sumnob -= fragnob;
- sumoff = 0;
- }
- }
- }
- memcpy(ktx->ktx_buffer + sizeof(*hdr) + sizeof(csum), &csum, sizeof(csum));
-#endif
-
/* The first frag will be the pre-mapped buffer for (at least) the
* portals header. */
ktx->ktx_nfrag = ktx->ktx_firsttmpfrag = 1;
if ((!target_is_router && /* target.nid is final dest */
!routing && /* I'm the source */
- type == PTL_MSG_GET && /* optimize GET? */
+ type == LNET_MSG_GET && /* optimize GET? */
*kqswnal_tunables.kqn_optimized_gets != 0 &&
- ptlmsg->msg_md->md_length >=
+ lntmsg->msg_md->md_length >=
*kqswnal_tunables.kqn_optimized_gets) ||
- ((type == PTL_MSG_PUT || /* optimize PUT? */
- type == PTL_MSG_REPLY) && /* optimize REPLY? */
+ ((type == LNET_MSG_PUT || /* optimize PUT? */
+ type == LNET_MSG_REPLY) && /* optimize REPLY? */
*kqswnal_tunables.kqn_optimized_puts != 0 &&
payload_nob >= *kqswnal_tunables.kqn_optimized_puts)) {
- ptl_libmd_t *md = ptlmsg->msg_md;
+ lnet_libmd_t *md = lntmsg->msg_md;
kqswnal_remotemd_t *rmd = (kqswnal_remotemd_t *)(ktx->ktx_buffer + KQSW_HDR_SIZE);
/* Optimised path: I send over the Elan vaddrs of the local
* immediately after the header, and send that as my
* message. */
- ktx->ktx_state = (type == PTL_MSG_GET) ? KTX_GETTING : KTX_PUTTING;
+ ktx->ktx_state = (type == LNET_MSG_GET) ? KTX_GETTING : KTX_PUTTING;
- if ((ptlmsg->msg_md->md_options & LNET_MD_KIOV) != 0)
+ if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) != 0)
rc = kqswnal_map_tx_kiov (ktx, 0, md->md_length,
md->md_niov, md->md_iov.kiov);
else
ktx->ktx_frags[0].Base = ktx->ktx_ebuffer;
ktx->ktx_frags[0].Len = KQSW_HDR_SIZE + payload_nob;
#endif
- if (type == PTL_MSG_GET) {
+ if (type == LNET_MSG_GET) {
/* Allocate reply message now while I'm in thread context */
ktx->ktx_args[2] = lnet_create_reply_msg (
- kqswnal_data.kqn_ni, target.nid, ptlmsg);
+ kqswnal_data.kqn_ni, lntmsg);
if (ktx->ktx_args[2] == NULL)
goto out;
ktx->ktx_frags[0].Base = ktx->ktx_ebuffer;
ktx->ktx_frags[0].Len = KQSW_HDR_SIZE + payload_nob;
#endif
- if (payload_nob > 0) {
- if (payload_kiov != NULL)
- lnet_copy_kiov2buf (ktx->ktx_buffer + KQSW_HDR_SIZE,
- payload_niov, payload_kiov,
- payload_offset, payload_nob);
- else
- lnet_copy_iov2buf (ktx->ktx_buffer + KQSW_HDR_SIZE,
- payload_niov, payload_iov,
- payload_offset, payload_nob);
- }
+ if (payload_kiov != NULL)
+ lnet_copy_kiov2flat(KQSW_TX_BUFFER_SIZE, ktx->ktx_buffer,
+ KQSW_HDR_SIZE,
+ payload_niov, payload_kiov,
+ payload_offset, payload_nob);
+ else
+ lnet_copy_iov2flat(KQSW_TX_BUFFER_SIZE, ktx->ktx_buffer,
+ KQSW_HDR_SIZE,
+ payload_niov, payload_iov,
+ payload_offset, payload_nob);
} else {
/* large message: multiple frags: first is hdr in pre-mapped buffer */
* pretend the GET succeeded but the REPLY
* failed. */
rc = 0;
- lnet_finalize (kqswnal_data.kqn_ni, private, ptlmsg, 0);
+ lnet_finalize (kqswnal_data.kqn_ni, private, lntmsg, 0);
lnet_finalize (kqswnal_data.kqn_ni, private,
- (ptl_msg_t *)ktx->ktx_args[2], -EIO);
+ (lnet_msg_t *)ktx->ktx_args[2], -EIO);
}
kqswnal_put_idle_tx (ktx);
}
void
-kqswnal_fwd_packet (ptl_ni_t *ni, kpr_fwd_desc_t *fwd)
-{
- int rc;
- kqswnal_tx_t *ktx;
- lnet_kiov_t *kiov = fwd->kprfd_kiov;
- int niov = fwd->kprfd_niov;
- int nob = fwd->kprfd_nob;
- lnet_nid_t nid = fwd->kprfd_gateway_nid;
-
-#if KQSW_CHECKSUM
- CERROR ("checksums for forwarded packets not implemented\n");
- LBUG ();
-#endif
- /* The router wants this NAL to forward a packet */
- CDEBUG (D_NET, "forwarding [%p] to %s, payload: %d frags %d bytes\n",
- fwd, libcfs_nid2str(nid), niov, nob);
-
- ktx = kqswnal_get_idle_tx (fwd, 0);
- if (ktx == NULL) /* can't get txd right now */
- return; /* fwd will be scheduled when tx desc freed */
-
- /* copy hdr into pre-mapped buffer */
- memcpy(ktx->ktx_buffer, fwd->kprfd_hdr, sizeof(ptl_hdr_t));
-
- ktx->ktx_port = (nob <= KQSW_SMALLPAYLOAD) ?
- EP_MSG_SVC_PORTALS_SMALL : EP_MSG_SVC_PORTALS_LARGE;
- ktx->ktx_nid = nid;
- ktx->ktx_state = KTX_FORWARDING;
- ktx->ktx_args[0] = fwd;
- ktx->ktx_nfrag = ktx->ktx_firsttmpfrag = 1;
-
- if (kqswnal_nid2elanid (nid) < 0) {
- CERROR("Can't forward [%p] to %s: not a peer\n",
- fwd, libcfs_nid2str(nid));
- rc = -EHOSTUNREACH;
- goto out;
- }
-
- if (nob <= *kqswnal_tunables.kqn_tx_maxcontig)
- {
- /* send payload from ktx's pre-mapped contiguous buffer */
-#if MULTIRAIL_EKC
- ep_nmd_subset(&ktx->ktx_frags[0], &ktx->ktx_ebuffer,
- 0, KQSW_HDR_SIZE + nob);
-#else
- ktx->ktx_frags[0].Base = ktx->ktx_ebuffer;
- ktx->ktx_frags[0].Len = KQSW_HDR_SIZE + nob;
-#endif
- if (nob > 0)
- lnet_copy_kiov2buf(ktx->ktx_buffer + KQSW_HDR_SIZE,
- niov, kiov, 0, nob);
- }
- else
- {
- /* zero copy payload */
-#if MULTIRAIL_EKC
- ep_nmd_subset(&ktx->ktx_frags[0], &ktx->ktx_ebuffer,
- 0, KQSW_HDR_SIZE);
-#else
- ktx->ktx_frags[0].Base = ktx->ktx_ebuffer;
- ktx->ktx_frags[0].Len = KQSW_HDR_SIZE;
-#endif
- rc = kqswnal_map_tx_kiov (ktx, 0, nob, niov, kiov);
- if (rc != 0)
- goto out;
- }
-
- rc = kqswnal_launch (ktx);
- out:
- if (rc != 0) {
- CERROR ("Failed to forward [%p] to %s: %d\n",
- fwd, libcfs_nid2str(nid), rc);
-
- /* complete now (with failure) */
- kqswnal_tx_done (ktx, rc);
- }
-
- atomic_dec(&kqswnal_data.kqn_pending_txs);
-}
-
-void
-kqswnal_fwd_callback (ptl_ni_t *ni, void *arg, int error)
-{
- kqswnal_rx_t *krx = (kqswnal_rx_t *)arg;
-
- /* The router has finished forwarding this packet */
-
- if (error != 0)
- {
- ptl_hdr_t *hdr = (ptl_hdr_t *)page_address (krx->krx_kiov[0].kiov_page);
-
- CERROR("Failed to route packet from %s to %s: %d\n",
- libcfs_nid2str(le64_to_cpu(hdr->src_nid)),
- libcfs_nid2str(le64_to_cpu(hdr->dest_nid)), error);
- }
-
- LASSERT (atomic_read(&krx->krx_refcount) == 1);
- kqswnal_rx_decref (krx);
-}
-
-void
kqswnal_requeue_rx (kqswnal_rx_t *krx)
{
LASSERT (atomic_read(&krx->krx_refcount) == 0);
void
kqswnal_parse (kqswnal_rx_t *krx)
{
- ptl_hdr_t *hdr = (ptl_hdr_t *) page_address(krx->krx_kiov[0].kiov_page);
- lnet_nid_t dest_nid;
- lnet_nid_t src_nid;
- lnet_nid_t sender_nid;
- int payload_nob;
- int nob;
- int niov;
+ lnet_hdr_t *hdr = (lnet_hdr_t *) page_address(krx->krx_kiov[0].kiov_page);
int rc;
LASSERT (atomic_read(&krx->krx_refcount) == 1);
rc = lnet_parse (kqswnal_data.kqn_ni, hdr, krx);
-
- if (rc != 1) {
- /* It's for me or there's been some error.
- * However I ignore parse errors since I'm not consuming a byte
- * stream */
-
- /* Drop my ref; any RDMA activity takes an additional ref */
+ if (rc < 0) {
kqswnal_rx_decref(krx);
return;
}
-
- LASSERT (lnet_apini.apini_ptlcompat == 0);
-
- dest_nid = le64_to_cpu(hdr->dest_nid); /* final dest */
- src_nid = le64_to_cpu(hdr->src_nid); /* original source */
- sender_nid = kqswnal_elanid2nid(ep_rxd_node(krx->krx_rxd)); /* who sent it to me */
-#if KQSW_CHECKSUM
- LASSERTF (0, "checksums for forwarded packets not implemented\n");
-#endif
- nob = payload_nob = krx->krx_nob - KQSW_HDR_SIZE;
- niov = 0;
- if (nob > 0) {
- krx->krx_kiov[0].kiov_offset = KQSW_HDR_SIZE;
- krx->krx_kiov[0].kiov_len = MIN(PAGE_SIZE - KQSW_HDR_SIZE, nob);
- niov = 1;
- nob -= PAGE_SIZE - KQSW_HDR_SIZE;
-
- while (nob > 0) {
- LASSERT (niov < krx->krx_npages);
-
- krx->krx_kiov[niov].kiov_offset = 0;
- krx->krx_kiov[niov].kiov_len = MIN(PAGE_SIZE, nob);
- niov++;
- nob -= PAGE_SIZE;
- }
- }
-
- kpr_fwd_init (&krx->krx_fwd, dest_nid, sender_nid, src_nid,
- hdr, payload_nob, niov, krx->krx_kiov,
- kqswnal_fwd_callback, krx);
-
- lnet_fwd_start (kqswnal_data.kqn_ni, &krx->krx_fwd);
}
/* Receive Interrupt Handler: posts to schedulers */
atomic_set (&krx->krx_refcount, 1);
/* must receive a whole header to be able to parse */
- if (status != EP_SUCCESS || nob < sizeof (ptl_hdr_t))
+ if (status != EP_SUCCESS || nob < sizeof (lnet_hdr_t))
{
/* receives complete with failure when receiver is removed */
#if MULTIRAIL_EKC
spin_unlock_irqrestore (&kqswnal_data.kqn_sched_lock, flags);
}
-#if KQSW_CHECKSUM
-void
-kqswnal_csum_error (kqswnal_rx_t *krx, int ishdr)
-{
- ptl_hdr_t *hdr = (ptl_hdr_t *)page_address (krx->krx_kiov[0].kiov_page);
-
- CERROR ("%s checksum mismatch %p: dnid %s, snid %s, "
- "dpid %d, spid %d, type %d\n",
- ishdr ? "Header" : "Payload", krx,
- libcfs_nid2str(le64_to_cpu(hdr->dest_nid)),
- libcfs_nid2str(le64_to_cpu(hdr->src_nid)),
- le32_to_cpu(hdr->dest_pid), le32_to_cpu(hdr->src_pid),
- le32_to_cpu(hdr->type));
-
- switch (le32_to_cpu(hdr->type))
- {
- case PTL_MSG_ACK:
- CERROR("ACK: mlen %d dmd "LPX64"."LPX64" match "LPX64
- " len %u\n",
- le32_to_cpu(hdr->msg.ack.mlength),
- hdr->msg.ack.dst_wmd.handle_cookie,
- hdr->msg.ack.dst_wmd.handle_idx,
- le64_to_cpu(hdr->msg.ack.match_bits),
- le32_to_cpu(hdr->msg.ack.length));
- break;
- case PTL_MSG_PUT:
- CERROR("PUT: ptl %d amd "LPX64"."LPX64" match "LPX64
- " len %u off %u data "LPX64"\n",
- le32_to_cpu(hdr->msg.put.ptl_index),
- hdr->msg.put.ack_wmd.handle_cookie,
- hdr->msg.put.ack_wmd.handle_idx,
- le64_to_cpu(hdr->msg.put.match_bits),
- le32_to_cpu(hdr->msg.put.length),
- le32_to_cpu(hdr->msg.put.offset),
- hdr->msg.put.hdr_data);
- break;
- case PTL_MSG_GET:
- CERROR ("GET: <>\n");
- break;
- case PTL_MSG_REPLY:
- CERROR ("REPLY: <>\n");
- break;
- default:
- CERROR ("TYPE?: <>\n");
- }
-}
-#endif
-
int
-kqswnal_recv (ptl_ni_t *ni,
+kqswnal_recv (lnet_ni_t *ni,
void *private,
- ptl_msg_t *ptlmsg,
+ lnet_msg_t *lntmsg,
+ int delayed,
unsigned int niov,
struct iovec *iov,
lnet_kiov_t *kiov,
{
kqswnal_rx_t *krx = (kqswnal_rx_t *)private;
char *buffer = page_address(krx->krx_kiov[0].kiov_page);
- ptl_hdr_t *hdr = (ptl_hdr_t *)buffer;
- int page;
- char *page_ptr;
- int page_nob;
- char *iov_ptr;
- int iov_nob;
- int frag;
+ lnet_hdr_t *hdr = (lnet_hdr_t *)buffer;
int rc;
-#if KQSW_CHECKSUM
- kqsw_csum_t senders_csum;
- kqsw_csum_t payload_csum = 0;
- kqsw_csum_t hdr_csum = kqsw_csum(0, hdr, sizeof(*hdr));
- unsigned int csum_len = mlen;
- int csum_frags = 0;
- int csum_nob = 0;
- static atomic_t csum_counter;
- int csum_verbose = (atomic_read(&csum_counter)%1000001) == 0;
-
- atomic_inc (&csum_counter);
-
- memcpy (&senders_csum, buffer + sizeof (ptl_hdr_t), sizeof (kqsw_csum_t));
- if (senders_csum != hdr_csum)
- kqswnal_csum_error (krx, 1);
-#endif
- /* NB lnet_parse() has already flipped *hdr */
- CDEBUG(D_NET,"kqswnal_recv, mlen=%u, rlen=%u\n", mlen, rlen);
+ /* NB lnet_parse() has already flipped *hdr */
- if (ptlmsg == NULL) { /* portals is discarding. */
- LASSERT (mlen == 0);
- return 0; /* ignored by caller! */
- }
-
if (krx->krx_rpc_reply_needed &&
- (hdr->type == PTL_MSG_PUT ||
- hdr->type == PTL_MSG_REPLY)) {
- /* This must be an optimized PUT/REPLY */
- rc = kqswnal_rdma (krx, ptlmsg, hdr->type,
- niov, iov, kiov, offset, mlen);
- return (rc == 0 ? 0 : -EIO);
+ (hdr->type == LNET_MSG_PUT ||
+ hdr->type == LNET_MSG_REPLY)) {
+ /* This is an optimized PUT/REPLY */
+ rc = kqswnal_rdma(krx, lntmsg, hdr->type,
+ niov, iov, kiov, offset, mlen);
+ kqswnal_rx_decref(krx);
+ return rc;
}
-
- /* What was actually received must be >= payload. */
- LASSERT (mlen <= rlen);
- if (krx->krx_nob < KQSW_HDR_SIZE + mlen) {
+
+ if (krx->krx_nob < KQSW_HDR_SIZE + rlen) {
CERROR("Bad message size: have %d, need %d + %d\n",
- krx->krx_nob, (int)KQSW_HDR_SIZE, (int)mlen);
- return (-EIO);
+ krx->krx_nob, (int)KQSW_HDR_SIZE, rlen);
+ kqswnal_rx_decref(krx);
+ return -EPROTO;
}
+ /* NB lnet_parse() has already flipped *hdr */
/* It must be OK to kmap() if required */
LASSERT (kiov == NULL || !in_interrupt ());
/* Either all pages or all vaddrs */
LASSERT (!(kiov != NULL && iov != NULL));
- if (mlen != 0) {
- page = 0;
- page_ptr = buffer + KQSW_HDR_SIZE;
- page_nob = PAGE_SIZE - KQSW_HDR_SIZE;
-
- LASSERT (niov > 0);
-
- if (kiov != NULL) {
- /* skip complete frags */
- while (offset >= kiov->kiov_len) {
- offset -= kiov->kiov_len;
- kiov++;
- niov--;
- LASSERT (niov > 0);
- }
- iov_ptr = ((char *)kmap (kiov->kiov_page)) +
- kiov->kiov_offset + offset;
- iov_nob = kiov->kiov_len - offset;
- } else {
- /* skip complete frags */
- while (offset >= iov->iov_len) {
- offset -= iov->iov_len;
- iov++;
- niov--;
- LASSERT (niov > 0);
- }
- iov_ptr = iov->iov_base + offset;
- iov_nob = iov->iov_len - offset;
- }
-
- for (;;)
- {
- frag = mlen;
- if (frag > page_nob)
- frag = page_nob;
- if (frag > iov_nob)
- frag = iov_nob;
-
- memcpy (iov_ptr, page_ptr, frag);
-#if KQSW_CHECKSUM
- payload_csum = kqsw_csum (payload_csum, iov_ptr, frag);
- csum_nob += frag;
- csum_frags++;
-#endif
- mlen -= frag;
- if (mlen == 0)
- break;
-
- page_nob -= frag;
- if (page_nob != 0)
- page_ptr += frag;
- else
- {
- page++;
- LASSERT (page < krx->krx_npages);
- page_ptr = page_address(krx->krx_kiov[page].kiov_page);
- page_nob = PAGE_SIZE;
- }
-
- iov_nob -= frag;
- if (iov_nob != 0)
- iov_ptr += frag;
- else if (kiov != NULL) {
- kunmap (kiov->kiov_page);
- kiov++;
- niov--;
- LASSERT (niov > 0);
- iov_ptr = ((char *)kmap (kiov->kiov_page)) + kiov->kiov_offset;
- iov_nob = kiov->kiov_len;
- } else {
- iov++;
- niov--;
- LASSERT (niov > 0);
- iov_ptr = iov->iov_base;
- iov_nob = iov->iov_len;
- }
- }
-
- if (kiov != NULL)
- kunmap (kiov->kiov_page);
- }
-
-#if KQSW_CHECKSUM
- memcpy (&senders_csum, buffer + sizeof(ptl_hdr_t) + sizeof(kqsw_csum_t),
- sizeof(kqsw_csum_t));
-
- if (csum_len != rlen)
- CERROR("Unable to checksum data in user's buffer\n");
- else if (senders_csum != payload_csum)
- kqswnal_csum_error (krx, 0);
-
- if (csum_verbose)
- CERROR("hdr csum %lx, payload_csum %lx, csum_frags %d, "
- "csum_nob %d\n",
- hdr_csum, payload_csum, csum_frags, csum_nob);
-#endif
- lnet_finalize(ni, private, ptlmsg, 0);
+ if (kiov != NULL)
+ lnet_copy_kiov2kiov(niov, kiov, offset,
+ krx->krx_npages, krx->krx_kiov,
+ KQSW_HDR_SIZE, mlen);
+ else
+ lnet_copy_kiov2iov(niov, iov, offset,
+ krx->krx_npages, krx->krx_kiov,
+ KQSW_HDR_SIZE, mlen);
- return (0);
+ lnet_finalize(ni, private, lntmsg, 0);
+ kqswnal_rx_decref(krx);
+ return 0;
}
int
{
kqswnal_rx_t *krx;
kqswnal_tx_t *ktx;
- kpr_fwd_desc_t *fwd;
unsigned long flags;
int rc;
int counter = 0;
spin_lock_irqsave (&kqswnal_data.kqn_sched_lock, flags);
}
- if (!list_empty (&kqswnal_data.kqn_delayedfwds))
- {
- fwd = list_entry (kqswnal_data.kqn_delayedfwds.next, kpr_fwd_desc_t, kprfd_list);
- list_del (&fwd->kprfd_list);
- spin_unlock_irqrestore (&kqswnal_data.kqn_sched_lock, flags);
-
- /* If we're shutting down, this will just requeue fwd on kqn_idletxd_fwdq */
- kqswnal_fwd_packet (kqswnal_data.kqn_ni, fwd);
-
- did_something = 1;
- spin_lock_irqsave (&kqswnal_data.kqn_sched_lock, flags);
- }
-
/* nothing to do or hogging CPU */
if (!did_something || counter++ == KQSW_RESCHED) {
spin_unlock_irqrestore(&kqswnal_data.kqn_sched_lock,
rc = wait_event_interruptible (kqswnal_data.kqn_sched_waitq,
kqswnal_data.kqn_shuttingdown == 2 ||
!list_empty(&kqswnal_data.kqn_readyrxds) ||
- !list_empty(&kqswnal_data.kqn_delayedtxds) ||
- !list_empty(&kqswnal_data.kqn_delayedfwds));
+ !list_empty(&kqswnal_data.kqn_delayedtxds));
LASSERT (rc == 0);
} else if (need_resched())
schedule ();
static int kranal_devids[RANAL_MAXDEVS] = {RAPK_MAIN_DEVICE_ID,
RAPK_EXPANSION_DEVICE_ID};
-ptl_nal_t kranal_nal = {
- .nal_type = RANAL,
- .nal_startup = kranal_startup,
- .nal_shutdown = kranal_shutdown,
- .nal_ctl = kranal_ctl,
- .nal_send = kranal_send,
- .nal_recv = kranal_recv,
- .nal_accept = kranal_accept,
+lnd_t the_kralnd = {
+ .lnd_type = RALND,
+ .lnd_startup = kranal_startup,
+ .lnd_shutdown = kranal_shutdown,
+ .lnd_ctl = kranal_ctl,
+ .lnd_send = kranal_send,
+ .lnd_recv = kranal_recv,
+ .lnd_accept = kranal_accept,
};
kra_data_t kranal_data;
}
int
-kranal_accept (ptl_ni_t *ni, struct socket *sock)
+kranal_accept (lnet_ni_t *ni, struct socket *sock)
{
kra_acceptsock_t *ras;
int rc;
}
int
-kranal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg)
+kranal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
int rc = -EINVAL;
}
void
-kranal_shutdown (ptl_ni_t *ni)
+kranal_shutdown (lnet_ni_t *ni)
{
int i;
unsigned long flags;
}
int
-kranal_startup (ptl_ni_t *ni)
+kranal_startup (lnet_ni_t *ni)
{
struct timeval tv;
int pkmem = atomic_read(&libcfs_kmemory);
int i;
kra_device_t *dev;
- LASSERT (ni->ni_nal == &kranal_nal);
+ LASSERT (ni->ni_lnd == &the_kralnd);
/* Only 1 instance supported */
if (kranal_data.kra_init != RANAL_INIT_NOTHING) {
void __exit
kranal_module_fini (void)
{
- lnet_unregister_nal(&kranal_nal);
+ lnet_unregister_lnd(&the_kralnd);
kranal_tunables_fini();
}
if (rc != 0)
return rc;
- lnet_register_nal(&kranal_nal);
+ lnet_register_lnd(&the_kralnd);
return 0;
}
int kra_init; /* initialisation state */
int kra_shutdown; /* shut down? */
atomic_t kra_nthreads; /* # live threads */
- ptl_ni_t *kra_ni; /* _the_ nal instance */
+ lnet_ni_t *kra_ni; /* _the_ nal instance */
kra_device_t kra_devices[RANAL_MAXDEVS]; /* device/ptag/cq etc */
int kra_ndevs; /* # devices */
typedef struct
{
- ptl_hdr_t raim_hdr; /* portals header */
+ lnet_hdr_t raim_hdr; /* portals header */
/* Portals payload is in FMA "Message Data" */
} kra_immediate_msg_t;
typedef struct
{
- ptl_hdr_t raprm_hdr; /* portals header */
+ lnet_hdr_t raprm_hdr; /* portals header */
__u64 raprm_cookie; /* opaque completion cookie */
} kra_putreq_msg_t;
typedef struct
{
- ptl_hdr_t ragm_hdr; /* portals header */
+ lnet_hdr_t ragm_hdr; /* portals header */
__u64 ragm_cookie; /* opaque completion cookie */
kra_rdma_desc_t ragm_desc; /* sender's sink buffer */
} kra_get_msg_t;
__u32 ram_seq; /* incrementing sequence number */
} kra_msg_t;
-#define RANAL_MSG_MAGIC PTL_PROTO_RA_MAGIC /* unique magic */
+#define RANAL_MSG_MAGIC LNET_PROTO_RA_MAGIC /* unique magic */
#define RANAL_MSG_VERSION 1 /* current protocol version */
#define RANAL_MSG_FENCE 0x80 /* fence RDMA */
{
struct list_head tx_list; /* queue on idle_txs/rac_sendq/rac_waitq */
struct kra_conn *tx_conn; /* owning conn */
- ptl_msg_t *tx_ptlmsg[2]; /* ptl msgs to finalize on completion */
+ lnet_msg_t *tx_lntmsg[2]; /* ptl msgs to finalize on completion */
unsigned long tx_qtime; /* when tx started to wait for something (jiffies) */
int tx_isnblk; /* I'm reserved for non-blocking sends */
int tx_nob; /* # bytes of payload */
return page_to_phys(p);
}
-int kranal_startup (ptl_ni_t *ni);
-void kranal_shutdown (ptl_ni_t *ni);
-int kranal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg);
-int kranal_send (ptl_ni_t *ni, void *private,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr,
- int type, lnet_process_id_t tgt,
- int tgt_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob);
-int kranal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+int kranal_startup (lnet_ni_t *ni);
+void kranal_shutdown (lnet_ni_t *ni);
+int kranal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
+int kranal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+int kranal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
-int kranal_accept(ptl_ni_t *ni, struct socket *sock);
+int kranal_accept(lnet_ni_t *ni, struct socket *sock);
extern void kranal_free_acceptsock (kra_acceptsock_t *ras);
extern int kranal_listener_procint (ctl_table *table,
extern int kranal_reaper (void *arg);
extern int kranal_scheduler (void *arg);
extern void kranal_close_conn_locked (kra_conn_t *conn, int error);
+extern void kranal_close_conn (kra_conn_t *conn, int error);
extern void kranal_terminate_conn_locked (kra_conn_t *conn);
extern void kranal_connect (kra_peer_t *peer);
extern int kranal_conn_handshake (struct socket *sock, kra_peer_t *peer);
LASSERT (tx->tx_buftype == RANAL_BUF_NONE);
LASSERT (tx->tx_msg.ram_type == RANAL_MSG_NONE);
LASSERT (tx->tx_conn == NULL);
- LASSERT (tx->tx_ptlmsg[0] == NULL);
- LASSERT (tx->tx_ptlmsg[1] == NULL);
+ LASSERT (tx->tx_lntmsg[0] == NULL);
+ LASSERT (tx->tx_lntmsg[1] == NULL);
}
spin_unlock_irqrestore(&kranal_data.kra_tx_lock, flags);
}
int
-kranal_setup_immediate_buffer (kra_tx_t *tx, int niov, struct iovec *iov,
+kranal_setup_immediate_buffer (kra_tx_t *tx,
+ unsigned int niov, struct iovec *iov,
int offset, int nob)
{
}
int
-kranal_setup_virt_buffer (kra_tx_t *tx, int niov, struct iovec *iov,
+kranal_setup_virt_buffer (kra_tx_t *tx,
+ unsigned int niov, struct iovec *iov,
int offset, int nob)
{
}
static inline int
-kranal_setup_rdma_buffer (kra_tx_t *tx, int niov,
+kranal_setup_rdma_buffer (kra_tx_t *tx, unsigned int niov,
struct iovec *iov, lnet_kiov_t *kiov,
int offset, int nob)
{
void
kranal_tx_done (kra_tx_t *tx, int completion)
{
- int ptlrc = (completion == 0) ? 0 : -EIO;
unsigned long flags;
int i;
kranal_unmap_buffer(tx);
for (i = 0; i < 2; i++) {
- /* tx may have up to 2 ptlmsgs to finalise */
- if (tx->tx_ptlmsg[i] == NULL)
+ /* tx may have up to 2 lntmsgs to finalise */
+ if (tx->tx_lntmsg[i] == NULL)
continue;
- lnet_finalize(kranal_data.kra_ni, NULL, tx->tx_ptlmsg[i], ptlrc);
- tx->tx_ptlmsg[i] = NULL;
+ lnet_finalize(kranal_data.kra_ni, NULL, tx->tx_lntmsg[i],
+ completion);
+ tx->tx_lntmsg[i] = NULL;
}
tx->tx_buftype = RANAL_BUF_NONE;
}
int
-kranal_send (ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int niov,
- struct iovec *iov,
- lnet_kiov_t *kiov,
- unsigned int offset,
- unsigned int nob)
+kranal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- kra_conn_t *conn;
- kra_tx_t *tx;
- int rc;
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ int target_is_router = lntmsg->msg_target_is_router;
+ int routing = lntmsg->msg_routing;
+ unsigned int niov = lntmsg->msg_niov;
+ struct iovec *iov = lntmsg->msg_iov;
+ lnet_kiov_t *kiov = lntmsg->msg_kiov;
+ unsigned int offset = lntmsg->msg_offset;
+ unsigned int nob = lntmsg->msg_len;
+ kra_conn_t *conn;
+ kra_tx_t *tx;
+ int rc;
/* NB 'private' is different depending on what we're sending.... */
default:
LBUG();
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
LASSERT (nob == 0);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
LASSERT (niov == 0);
LASSERT (nob == 0);
/* We have to consider the eventual sink buffer rather than any
* payload passed here (there isn't any, and strictly, looking
- * inside ptlmsg is a layering violation). We send a simple
+ * inside lntmsg is a layering violation). We send a simple
* IMMEDIATE GET if the sink buffer is mapped already and small
* enough for FMA */
if (routing || target_is_router)
break; /* send IMMEDIATE */
- if ((ptlmsg->msg_md->md_options & LNET_MD_KIOV) == 0 &&
- ptlmsg->msg_md->md_length <= RANAL_FMA_MAX_DATA &&
- ptlmsg->msg_md->md_length <= *kranal_tunables.kra_max_immediate)
+ if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0 &&
+ lntmsg->msg_md->md_length <= RANAL_FMA_MAX_DATA &&
+ lntmsg->msg_md->md_length <= *kranal_tunables.kra_max_immediate)
break; /* send IMMEDIATE */
tx = kranal_new_tx_msg(!in_interrupt(), RANAL_MSG_GET_REQ);
if (tx == NULL)
return -ENOMEM;
- if ((ptlmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
- rc = kranal_setup_virt_buffer(tx, ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.iov,
- 0, ptlmsg->msg_md->md_length);
+ if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
+ rc = kranal_setup_virt_buffer(tx, lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.iov,
+ 0, lntmsg->msg_md->md_length);
else
- rc = kranal_setup_phys_buffer(tx, ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.kiov,
- 0, ptlmsg->msg_md->md_length);
+ rc = kranal_setup_phys_buffer(tx, lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.kiov,
+ 0, lntmsg->msg_md->md_length);
if (rc != 0) {
kranal_tx_done(tx, rc);
return -EIO;
}
- tx->tx_ptlmsg[1] = lnet_create_reply_msg(ni, target.nid, ptlmsg);
- if (tx->tx_ptlmsg[1] == NULL) {
+ tx->tx_lntmsg[1] = lnet_create_reply_msg(ni, lntmsg);
+ if (tx->tx_lntmsg[1] == NULL) {
CERROR("Can't create reply for GET to %s\n",
libcfs_nid2str(target.nid));
kranal_tx_done(tx, rc);
return -EIO;
}
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
tx->tx_msg.ram_u.get.ragm_hdr = *hdr;
/* rest of tx_msg is setup just before it is sent */
kranal_launch_tx(tx, target.nid);
return 0;
- case PTL_MSG_REPLY:
+ case LNET_MSG_REPLY:
/* reply's 'private' is the conn that received the GET_REQ */
conn = private;
}
tx->tx_conn = conn;
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
rc = kranal_map_buffer(tx);
if (rc != 0) {
/* Fall through and handle like PUT */
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
if (kiov == NULL && /* not paged */
nob <= RANAL_FMA_MAX_DATA && /* small enough */
nob <= *kranal_tunables.kra_max_immediate)
break; /* send IMMEDIATE */
tx = kranal_new_tx_msg(!(routing ||
- type == PTL_MSG_REPLY ||
+ type == LNET_MSG_REPLY ||
in_interrupt()),
RANAL_MSG_PUT_REQ);
if (tx == NULL)
return -EIO;
}
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
tx->tx_msg.ram_u.putreq.raprm_hdr = *hdr;
/* rest of tx_msg is setup just before it is sent */
kranal_launch_tx(tx, target.nid);
LASSERT (nob <= RANAL_FMA_MAX_DATA);
tx = kranal_new_tx_msg(!(routing ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY ||
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY ||
in_interrupt()),
RANAL_MSG_IMMEDIATE);
if (tx == NULL)
}
tx->tx_msg.ram_u.immediate.raim_hdr = *hdr;
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
kranal_launch_tx(tx, target.nid);
return 0;
}
int
-kranal_recv (ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+kranal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
kra_conn_t *conn = private;
/* Either all pages or all vaddrs */
LASSERT (!(kiov != NULL && iov != NULL));
- CDEBUG(D_NET, "conn %p, rxmsg %p, ptlmsg %p\n", conn, rxmsg, ptlmsg);
+ CDEBUG(D_NET, "conn %p, rxmsg %p, lntmsg %p\n", conn, rxmsg, lntmsg);
- if (ptlmsg == NULL) {
- /* GET or ACK or portals is discarding */
+ if (rxmsg == NULL) {
+ /* already consumed: must have been a GET_REQ that matched */
LASSERT (mlen == 0);
- lnet_finalize(ni, NULL, ptlmsg, 0);
+ LASSERT (lntmsg == NULL); /* no need to finalise */
return 0;
}
-
+
switch(rxmsg->ram_type) {
default:
LBUG();
- return -EIO;
case RANAL_MSG_IMMEDIATE:
if (mlen == 0) {
buffer = ((char *)iov->iov_base) + offset;
}
rc = kranal_consume_rxmsg(conn, buffer, mlen);
- lnet_finalize(ni, NULL, ptlmsg, (rc == 0) ? 0 : -EIO);
+ lnet_finalize(ni, NULL, lntmsg, (rc == 0) ? 0 : -EIO);
return 0;
case RANAL_MSG_PUT_REQ:
tx = kranal_new_tx_msg(0, RANAL_MSG_PUT_ACK);
- if (tx == NULL)
+ if (tx == NULL) {
+ kranal_consume_rxmsg(conn, NULL, 0);
return -ENOMEM;
-
+ }
+
rc = kranal_setup_rdma_buffer(tx, niov, iov, kiov, offset, mlen);
if (rc != 0) {
kranal_tx_done(tx, rc);
+ kranal_consume_rxmsg(conn, NULL, 0);
return -EIO;
}
rc = kranal_map_buffer(tx);
if (rc != 0) {
kranal_tx_done(tx, rc);
+ kranal_consume_rxmsg(conn, NULL, 0);
return -EIO;
}
(__u64)((unsigned long)tx->tx_buffer);
tx->tx_msg.ram_u.putack.rapam_desc.rard_nob = mlen;
- tx->tx_ptlmsg[0] = ptlmsg; /* finalize this on RDMA_DONE */
+ tx->tx_lntmsg[0] = lntmsg; /* finalize this on RDMA_DONE */
kranal_post_fma(conn, tx);
+ kranal_consume_rxmsg(conn, NULL, 0);
+ return 0;
- /* flag matched by consuming rx message */
+ case RANAL_MSG_GET_REQ:
+ /* This one didn't match anything */
+ tx = kranal_new_tx_msg(0, RANAL_MSG_GET_NAK);
+ if (tx != NULL) {
+ tx->tx_msg.ram_u.completion.racm_cookie =
+ rxmsg->ram_u.get.ragm_cookie;
+ kranal_post_fma(conn, tx);
+ }
+ LASSERT (lntmsg == NULL); /* no need to finalise */
kranal_consume_rxmsg(conn, NULL, 0);
return 0;
}
void *prefix;
RAP_RETURN rrc = RapkFmaGetPrefix(conn->rac_rihandle, &prefix);
kra_peer_t *peer = conn->rac_peer;
+ int rc = 0;
+ int repost = 1;
if (rrc == RAP_NOT_DONE)
return;
if (__swab32(msg->ram_magic) != RANAL_MSG_MAGIC) {
CERROR("Unexpected magic %08x from %s\n",
msg->ram_magic, libcfs_nid2str(peer->rap_nid));
+ rc = -EPROTO;
goto out;
}
if (msg->ram_version != RANAL_MSG_VERSION) {
CERROR("Unexpected protocol version %d from %s\n",
msg->ram_version, libcfs_nid2str(peer->rap_nid));
+ rc = -EPROTO;
goto out;
}
CERROR("Unexpected peer %s from %s\n",
libcfs_nid2str(msg->ram_srcnid),
libcfs_nid2str(peer->rap_nid));
+ rc = -EPROTO;
goto out;
}
" expected) from %s\n",
msg->ram_connstamp, conn->rac_peer_connstamp,
libcfs_nid2str(peer->rap_nid));
+ rc = -EPROTO;
goto out;
}
if (msg->ram_seq != seq) {
CERROR("Unexpected sequence number %d(%d expected) from %s\n",
msg->ram_seq, seq, libcfs_nid2str(peer->rap_nid));
+ rc = -EPROTO;
goto out;
}
if (conn->rac_close_recvd) {
CERROR("Unexpected message %d after CLOSE from %s\n",
msg->ram_type, libcfs_nid2str(conn->rac_peer->rap_nid));
+ rc = -EPROTO;
goto out;
}
case RANAL_MSG_IMMEDIATE:
CDEBUG(D_NET, "RX IMMEDIATE on %p\n", conn);
- lnet_parse(kranal_data.kra_ni, &msg->ram_u.immediate.raim_hdr, conn);
+ rc = lnet_parse(kranal_data.kra_ni, &msg->ram_u.immediate.raim_hdr,
+ conn);
+ repost = rc < 0;
break;
case RANAL_MSG_PUT_REQ:
CDEBUG(D_NET, "RX PUT_REQ on %p\n", conn);
- lnet_parse(kranal_data.kra_ni, &msg->ram_u.putreq.raprm_hdr, conn);
-
- if (conn->rac_rxmsg == NULL) /* lnet_parse matched something */
- break;
-
- tx = kranal_new_tx_msg(0, RANAL_MSG_PUT_NAK);
- if (tx == NULL)
- break;
-
- tx->tx_msg.ram_u.completion.racm_cookie =
- msg->ram_u.putreq.raprm_cookie;
- kranal_post_fma(conn, tx);
+ rc = lnet_parse(kranal_data.kra_ni, &msg->ram_u.putreq.raprm_hdr,
+ conn);
+ repost = rc < 0;
break;
case RANAL_MSG_PUT_NAK:
case RANAL_MSG_GET_REQ:
CDEBUG(D_NET, "RX GET_REQ on %p\n", conn);
- lnet_parse(kranal_data.kra_ni, &msg->ram_u.get.ragm_hdr, conn);
-
- if (conn->rac_rxmsg == NULL) /* lnet_parse matched something */
- break;
-
- tx = kranal_new_tx_msg(0, RANAL_MSG_GET_NAK);
- if (tx == NULL)
- break;
-
- tx->tx_msg.ram_u.completion.racm_cookie = msg->ram_u.get.ragm_cookie;
- kranal_post_fma(conn, tx);
+ rc = lnet_parse(kranal_data.kra_ni, &msg->ram_u.get.ragm_hdr,
+ conn);
+ repost = rc < 0;
break;
case RANAL_MSG_GET_NAK:
break;
}
+ if (rc < 0) /* lnet_parse() detected an error */
+ kranal_close_conn (conn, rc);
+
out:
- if (conn->rac_rxmsg != NULL)
+ if (repost && conn->rac_rxmsg != NULL)
kranal_consume_rxmsg(conn, NULL, 0);
/* check again later */
#include "socklnd.h"
-ptl_nal_t ksocknal_nal = {
- .nal_type = SOCKNAL,
- .nal_startup = ksocknal_startup,
- .nal_shutdown = ksocknal_shutdown,
- .nal_ctl = ksocknal_ctl,
- .nal_send = ksocknal_send,
- .nal_recv = ksocknal_recv,
- .nal_fwd = ksocknal_fwd_packet,
- .nal_notify = ksocknal_notify,
- .nal_accept = ksocknal_accept,
+lnd_t the_ksocklnd = {
+ .lnd_type = SOCKLND,
+ .lnd_startup = ksocknal_startup,
+ .lnd_shutdown = ksocknal_shutdown,
+ .lnd_ctl = ksocknal_ctl,
+ .lnd_send = ksocknal_send,
+ .lnd_recv = ksocknal_recv,
+ .lnd_notify = ksocknal_notify,
+ .lnd_accept = ksocknal_accept,
};
ksock_nal_data_t ksocknal_data;
ksock_interface_t *
-ksocknal_ip2iface(ptl_ni_t *ni, __u32 ip)
+ksocknal_ip2iface(lnet_ni_t *ni, __u32 ip)
{
ksock_net_t *net = ni->ni_data;
int i;
ksock_interface_t *iface;
for (i = 0; i < net->ksnn_ninterfaces; i++) {
- LASSERT(i < PTL_MAX_INTERFACES);
+ LASSERT(i < LNET_MAX_INTERFACES);
iface = &net->ksnn_interfaces[i];
if (iface->ksni_ipaddr == ip)
}
int
-ksocknal_create_peer (ksock_peer_t **peerp, ptl_ni_t *ni, lnet_process_id_t id)
+ksocknal_create_peer (ksock_peer_t **peerp, lnet_ni_t *ni, lnet_process_id_t id)
{
ksock_net_t *net = ni->ni_data;
ksock_peer_t *peer;
}
ksock_peer_t *
-ksocknal_find_peer_locked (ptl_ni_t *ni, lnet_process_id_t id)
+ksocknal_find_peer_locked (lnet_ni_t *ni, lnet_process_id_t id)
{
struct list_head *peer_list = ksocknal_nid2peerlist(id.nid);
struct list_head *tmp;
}
ksock_peer_t *
-ksocknal_find_peer (ptl_ni_t *ni, lnet_process_id_t id)
+ksocknal_find_peer (lnet_ni_t *ni, lnet_process_id_t id)
{
ksock_peer_t *peer;
__u32 ip;
for (i = 0; i < peer->ksnp_n_passive_ips; i++) {
- LASSERT (i < PTL_MAX_INTERFACES);
+ LASSERT (i < LNET_MAX_INTERFACES);
ip = peer->ksnp_passive_ips[i];
ksocknal_ip2iface(peer->ksnp_ni, ip)->ksni_npeers--;
}
int
-ksocknal_get_peer_info (ptl_ni_t *ni, int index,
+ksocknal_get_peer_info (lnet_ni_t *ni, int index,
lnet_process_id_t *id, __u32 *myip, __u32 *peer_ip, int *port,
int *conn_count, int *share_count)
{
}
int
-ksocknal_add_peer (ptl_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
+ksocknal_add_peer (lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
{
unsigned long flags;
struct list_head *tmp;
}
int
-ksocknal_del_peer (ptl_ni_t *ni, lnet_process_id_t id, __u32 ip)
+ksocknal_del_peer (lnet_ni_t *ni, lnet_process_id_t id, __u32 ip)
{
unsigned long flags;
struct list_head *ptmp;
}
ksock_conn_t *
-ksocknal_get_conn_by_idx (ptl_ni_t *ni, int index)
+ksocknal_get_conn_by_idx (lnet_ni_t *ni, int index)
{
ksock_peer_t *peer;
struct list_head *ptmp;
}
int
-ksocknal_local_ipvec (ptl_ni_t *ni, __u32 *ipaddrs)
+ksocknal_local_ipvec (lnet_ni_t *ni, __u32 *ipaddrs)
{
ksock_net_t *net = ni->ni_data;
int i;
read_lock (&ksocknal_data.ksnd_global_lock);
nip = net->ksnn_ninterfaces;
- LASSERT (nip < PTL_MAX_INTERFACES);
+ LASSERT (nip < LNET_MAX_INTERFACES);
for (i = 0; i < nip; i++) {
ipaddrs[i] = net->ksnn_interfaces[i].ksni_ipaddr;
write_lock_irqsave(global_lock, flags);
- LASSERT (n_peerips <= PTL_MAX_INTERFACES);
- LASSERT (net->ksnn_ninterfaces <= PTL_MAX_INTERFACES);
+ LASSERT (n_peerips <= LNET_MAX_INTERFACES);
+ LASSERT (net->ksnn_ninterfaces <= LNET_MAX_INTERFACES);
n_ips = MIN(n_peerips, net->ksnn_ninterfaces);
{
ksock_route_t *newroute = NULL;
rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
- ptl_ni_t *ni = peer->ksnp_ni;
+ lnet_ni_t *ni = peer->ksnp_ni;
ksock_net_t *net = ni->ni_data;
unsigned long flags;
struct list_head *rtmp;
write_lock_irqsave(global_lock, flags);
- LASSERT (npeer_ipaddrs <= PTL_MAX_INTERFACES);
+ LASSERT (npeer_ipaddrs <= LNET_MAX_INTERFACES);
for (i = 0; i < npeer_ipaddrs; i++) {
if (newroute != NULL) {
best_nroutes = 0;
best_netmatch = 0;
- LASSERT (net->ksnn_ninterfaces <= PTL_MAX_INTERFACES);
+ LASSERT (net->ksnn_ninterfaces <= LNET_MAX_INTERFACES);
/* Select interface to connect from */
for (j = 0; j < net->ksnn_ninterfaces; j++) {
}
int
-ksocknal_accept (ptl_ni_t *ni, struct socket *sock)
+ksocknal_accept (lnet_ni_t *ni, struct socket *sock)
{
ksock_connreq_t *cr;
int rc;
return -ENOMEM;
}
- ptl_ni_addref(ni);
+ lnet_ni_addref(ni);
cr->ksncr_ni = ni;
cr->ksncr_sock = sock;
}
int
-ksocknal_create_conn (ptl_ni_t *ni, ksock_route_t *route,
+ksocknal_create_conn (lnet_ni_t *ni, ksock_route_t *route,
struct socket *sock, int type)
{
rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
- __u32 ipaddrs[PTL_MAX_INTERFACES];
+ __u32 ipaddrs[LNET_MAX_INTERFACES];
int nipaddrs;
lnet_process_id_t peerid;
struct list_head *tmp;
ksock_tx_t *tx;
int rc;
- LASSERT (route == NULL == (type == SOCKNAL_CONN_NONE));
+ LASSERT (route == NULL == (type == SOCKLND_CONN_NONE));
rc = ksocknal_lib_setup_sock (sock);
if (rc != 0)
lnet_finalize (conn->ksnc_peer->ksnp_ni, NULL,
conn->ksnc_cookie, -EIO);
break;
- case SOCKNAL_RX_BODY_FWD:
- ksocknal_fmb_callback (conn->ksnc_peer->ksnp_ni,
- conn->ksnc_cookie, -ECONNABORTED);
- break;
case SOCKNAL_RX_HEADER:
case SOCKNAL_RX_SLOP:
break;
}
void
-ksocknal_notify (ptl_ni_t *ni, lnet_nid_t gw_nid, int alive)
+ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive)
{
/* The router is telling me she's been notified of a change in
* gateway state.... */
}
int
-ksocknal_push (ptl_ni_t *ni, lnet_process_id_t id)
+ksocknal_push (lnet_ni_t *ni, lnet_process_id_t id)
{
ksock_peer_t *peer;
struct list_head *tmp;
}
int
-ksocknal_add_interface(ptl_ni_t *ni, __u32 ipaddress, __u32 netmask)
+ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask)
{
ksock_net_t *net = ni->ni_data;
unsigned long flags;
if (iface != NULL) {
/* silently ignore dups */
rc = 0;
- } else if (net->ksnn_ninterfaces == PTL_MAX_INTERFACES) {
+ } else if (net->ksnn_ninterfaces == LNET_MAX_INTERFACES) {
rc = -ENOSPC;
} else {
iface = &net->ksnn_interfaces[net->ksnn_ninterfaces++];
}
int
-ksocknal_del_interface(ptl_ni_t *ni, __u32 ipaddress)
+ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress)
{
ksock_net_t *net = ni->ni_data;
int rc = -ENOENT;
}
int
-ksocknal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg)
+ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
int rc;
}
void
-ksocknal_free_fmbs (ksock_fmb_pool_t *p)
-{
- int npages = p->fmp_buff_pages;
- ksock_fmb_t *fmb;
- int i;
-
- LASSERT (list_empty(&p->fmp_blocked_conns));
- LASSERT (p->fmp_nactive_fmbs == 0);
-
- while (!list_empty(&p->fmp_idle_fmbs)) {
-
- fmb = list_entry(p->fmp_idle_fmbs.next,
- ksock_fmb_t, fmb_list);
-
- for (i = 0; i < npages; i++)
- if (fmb->fmb_kiov[i].kiov_page != NULL)
- cfs_free_page(fmb->fmb_kiov[i].kiov_page);
-
- list_del(&fmb->fmb_list);
- PORTAL_FREE(fmb, offsetof(ksock_fmb_t, fmb_kiov[npages]));
- }
-}
-
-void
ksocknal_free_buffers (void)
{
- ksocknal_free_fmbs(&ksocknal_data.ksnd_small_fmp);
- ksocknal_free_fmbs(&ksocknal_data.ksnd_large_fmp);
-
LASSERT (atomic_read(&ksocknal_data.ksnd_nactive_ltxs) == 0);
if (ksocknal_data.ksnd_schedulers != NULL)
LASSERT (list_empty (&ksocknal_data.ksnd_zombie_conns));
LASSERT (list_empty (&ksocknal_data.ksnd_connd_connreqs));
LASSERT (list_empty (&ksocknal_data.ksnd_connd_routes));
- LASSERT (list_empty (&ksocknal_data.ksnd_small_fmp.fmp_blocked_conns));
- LASSERT (list_empty (&ksocknal_data.ksnd_large_fmp.fmp_blocked_conns));
if (ksocknal_data.ksnd_schedulers != NULL)
for (i = 0; i < ksocknal_data.ksnd_nschedulers; i++) {
{
int rc;
int i;
- int j;
LASSERT (ksocknal_data.ksnd_init == SOCKNAL_INIT_NOTHING);
LASSERT (ksocknal_data.ksnd_nnets == 0);
rwlock_init(&ksocknal_data.ksnd_global_lock);
- spin_lock_init(&ksocknal_data.ksnd_small_fmp.fmp_lock);
- CFS_INIT_LIST_HEAD(&ksocknal_data.ksnd_small_fmp.fmp_idle_fmbs);
- CFS_INIT_LIST_HEAD(&ksocknal_data.ksnd_small_fmp.fmp_blocked_conns);
- ksocknal_data.ksnd_small_fmp.fmp_buff_pages = SOCKNAL_SMALL_FWD_PAGES;
-
- spin_lock_init(&ksocknal_data.ksnd_large_fmp.fmp_lock);
- CFS_INIT_LIST_HEAD(&ksocknal_data.ksnd_large_fmp.fmp_idle_fmbs);
- CFS_INIT_LIST_HEAD(&ksocknal_data.ksnd_large_fmp.fmp_blocked_conns);
- ksocknal_data.ksnd_large_fmp.fmp_buff_pages = SOCKNAL_LARGE_FWD_PAGES;
-
spin_lock_init (&ksocknal_data.ksnd_reaper_lock);
CFS_INIT_LIST_HEAD (&ksocknal_data.ksnd_enomem_conns);
CFS_INIT_LIST_HEAD (&ksocknal_data.ksnd_zombie_conns);
goto failed;
}
- if (lnet_forwarding()) {
- /* Only allocate forwarding buffers if we're a gateway */
-
- for (i = 0; i < (SOCKNAL_SMALL_FWD_NMSGS +
- SOCKNAL_LARGE_FWD_NMSGS); i++) {
- ksock_fmb_t *fmb;
- ksock_fmb_pool_t *pool;
-
-
- if (i < SOCKNAL_SMALL_FWD_NMSGS)
- pool = &ksocknal_data.ksnd_small_fmp;
- else
- pool = &ksocknal_data.ksnd_large_fmp;
-
- PORTAL_ALLOC(fmb, offsetof(ksock_fmb_t,
- fmb_kiov[pool->fmp_buff_pages]));
- if (fmb == NULL)
- goto failed;
-
- fmb->fmb_pool = pool;
-
- for (j = 0; j < pool->fmp_buff_pages; j++) {
- fmb->fmb_kiov[j].kiov_page = cfs_alloc_page(CFS_ALLOC_STD);
-
- if (fmb->fmb_kiov[j].kiov_page == NULL)
- goto failed;
-
- LASSERT(cfs_page_address(fmb->fmb_kiov[j].kiov_page) != NULL);
- }
-
- list_add(&fmb->fmb_list, &pool->fmp_idle_fmbs);
- }
- }
-
/* flag everything initialised */
ksocknal_data.ksnd_init = SOCKNAL_INIT_ALL;
}
void
-ksocknal_shutdown (ptl_ni_t *ni)
+ksocknal_shutdown (lnet_ni_t *ni)
{
ksock_net_t *net = ni->ni_data;
int i;
continue;
}
- if (j == PTL_MAX_INTERFACES) {
+ if (j == LNET_MAX_INTERFACES) {
CWARN("Ignoring interface %s (too many interfaces)\n",
names[i]);
continue;
}
int
-ksocknal_startup (ptl_ni_t *ni)
+ksocknal_startup (lnet_ni_t *ni)
{
ksock_net_t *net;
int rc;
int i;
- LASSERT (ni->ni_nal == &ksocknal_nal);
+ LASSERT (ni->ni_lnd == &the_ksocklnd);
if (ksocknal_data.ksnd_init == SOCKNAL_INIT_NOTHING) {
rc = ksocknal_base_startup();
net->ksnn_ninterfaces = rc;
} else {
- for (i = 0; i < PTL_MAX_INTERFACES; i++) {
+ for (i = 0; i < LNET_MAX_INTERFACES; i++) {
int up;
if (ni->ni_interfaces[i] == NULL)
void __exit
ksocknal_module_fini (void)
{
- lnet_unregister_nal(&ksocknal_nal);
+ lnet_unregister_lnd(&the_ksocklnd);
ksocknal_lib_tunables_fini();
}
{
int rc;
- /* packet descriptor must fit in a router descriptor's scratchpad */
- CLASSERT(sizeof (ksock_tx_t) <= sizeof (kprfd_scratch_t));
/* check ksnr_connected/connecting field large enough */
- CLASSERT(SOCKNAL_CONN_NTYPES <= 4);
+ CLASSERT(SOCKLND_CONN_NTYPES <= 4);
rc = ksocknal_lib_tunables_init();
if (rc != 0)
return rc;
- lnet_register_nal(&ksocknal_nal);
+ lnet_register_lnd(&the_ksocklnd);
return 0;
}
#define SOCKNAL_SMALL_FWD_NMSGS 128 /* # small messages I can be forwarding at any time */
#define SOCKNAL_LARGE_FWD_NMSGS 64 /* # large messages I can be forwarding at any time */
-#define SOCKNAL_SMALL_FWD_PAGES 1 /* # pages in a small message fwd buffer */
-
-#define SOCKNAL_LARGE_FWD_PAGES (PAGE_ALIGN(PTL_MTU) >> PAGE_SHIFT)
- /* # pages in a large message fwd buffer */
-
#define SOCKNAL_RESCHED 100 /* # scheduler loops before reschedule */
#define SOCKNAL_ENOMEM_RETRY CFS_MIN_DELAY /* jiffies between retries */
#endif
/* minimum socket buffer required for connection handshake */
-#define SOCKNAL_MIN_BUFFER (2*(sizeof(ptl_hdr_t) + \
- PTL_MAX_INTERFACES * sizeof(__u32)))
-
-typedef struct /* pool of forwarding buffers */
-{
- spinlock_t fmp_lock; /* serialise */
- struct list_head fmp_idle_fmbs; /* free buffers */
- struct list_head fmp_blocked_conns; /* connections waiting for a buffer */
- int fmp_nactive_fmbs; /* # buffers in use */
- int fmp_buff_pages; /* # pages per buffer */
-} ksock_fmb_pool_t;
-
+#define SOCKNAL_MIN_BUFFER (2*(sizeof(lnet_hdr_t) + \
+ LNET_MAX_INTERFACES * sizeof(__u32)))
typedef struct /* per scheduler state */
{
int ksnn_npeers; /* # peers */
int ksnn_shutdown; /* shutting down? */
int ksnn_ninterfaces; /* IP interfaces */
- ksock_interface_t ksnn_interfaces[PTL_MAX_INTERFACES];
+ ksock_interface_t ksnn_interfaces[LNET_MAX_INTERFACES];
} ksock_net_t;
typedef struct
int ksnd_nschedulers; /* # schedulers */
ksock_sched_t *ksnd_schedulers; /* their state */
- ksock_fmb_pool_t ksnd_small_fmp; /* small message forwarding buffers */
- ksock_fmb_pool_t ksnd_large_fmp; /* large message forwarding buffers */
-
atomic_t ksnd_nactive_ltxs; /* #active ltxs */
struct list_head ksnd_deathrow_conns; /* conns to close: reaper_lock*/
typedef struct /* transmit packet */
{
struct list_head tx_list; /* queue on conn for transmission etc */
- char tx_isfwd; /* forwarding / sourced here */
int tx_nob; /* # packet bytes */
int tx_resid; /* residual bytes */
int tx_niov; /* # packet iovec frags */
struct iovec *tx_iov; /* packet iovec frags */
int tx_nkiov; /* # packet page frags */
- lnet_kiov_t *tx_kiov; /* packet page frags */
+ lnet_kiov_t *tx_kiov; /* packet page frags */
struct ksock_conn *tx_conn; /* owning conn */
- ptl_hdr_t *tx_hdr; /* packet header (for debug only) */
+ lnet_hdr_t *tx_hdr; /* packet header (for debug only) */
#if SOCKNAL_ZC
zccd_t tx_zccd; /* zero copy callback descriptor */
#endif
} ksock_tx_t;
-typedef struct /* forwarded packet */
-{
- ksock_tx_t ftx_tx; /* send info */
- struct iovec ftx_iov; /* hdr iovec */
-} ksock_ftx_t;
-
#define KSOCK_ZCCD_2_TX(ptr) list_entry (ptr, ksock_tx_t, tx_zccd)
/* network zero copy callback descriptor embedded in ksock_tx_t */
ksock_tx_t ltx_tx; /* send info */
void *ltx_private; /* lnet_finalize() callback arg */
void *ltx_cookie; /* lnet_finalize() callback arg */
- ptl_hdr_t ltx_hdr; /* buffer for packet header */
+ lnet_hdr_t ltx_hdr; /* buffer for packet header */
int ltx_desc_size; /* bytes allocated for this desc */
struct iovec ltx_iov[1]; /* iov for hdr + payload */
- lnet_kiov_t ltx_kiov[0]; /* kiov for payload */
+ lnet_kiov_t ltx_kiov[0]; /* kiov for payload */
} ksock_ltx_t;
-#define KSOCK_TX_2_KPR_FWD_DESC(ptr) list_entry ((kprfd_scratch_t *)ptr, kpr_fwd_desc_t, kprfd_scratch)
-/* forwarded packets (router->socknal) embedded in kpr_fwd_desc_t::kprfd_scratch */
-
#define KSOCK_TX_2_KSOCK_LTX(ptr) list_entry (ptr, ksock_ltx_t, ltx_tx)
/* local packets (lib->socknal) embedded in ksock_ltx_t::ltx_tx */
/* NB list_entry() is used here as convenient macro for calculating a
* pointer to a struct from the address of a member. */
-typedef struct /* Kernel portals Socket Forwarding message buffer */
-{ /* (socknal->router) */
- struct list_head fmb_list; /* queue idle */
- kpr_fwd_desc_t fmb_fwd; /* router's descriptor */
- ksock_fmb_pool_t *fmb_pool; /* owning pool */
- struct ksock_peer *fmb_peer; /* peer received from */
- ptl_hdr_t fmb_hdr; /* message header */
- lnet_kiov_t fmb_kiov[0]; /* payload frags */
-} ksock_fmb_t;
-
/* space for the rx frag descriptors; we either read a single contiguous
* header, or up to PTL_MD_MAX_IOV frags of payload of either type. */
typedef union {
} ksock_rxiovspace_t;
#define SOCKNAL_RX_HEADER 1 /* reading header */
-#define SOCKNAL_RX_BODY 2 /* reading body (to deliver here) */
-#define SOCKNAL_RX_BODY_FWD 3 /* reading body (to forward) */
-#define SOCKNAL_RX_SLOP 4 /* skipping body */
-#define SOCKNAL_RX_GET_FMB 5 /* scheduled for forwarding */
-#define SOCKNAL_RX_FMB_SLEEP 6 /* blocked waiting for a fwd desc */
+#define SOCKNAL_RX_PARSE 2 /* Calling lnet_parse() */
+#define SOCKNAL_RX_PARSE_WAIT 3 /* waiting to be told to read the body */
+#define SOCKNAL_RX_BODY 4 /* reading body (to deliver here) */
+#define SOCKNAL_RX_SLOP 5 /* skipping body */
typedef struct ksock_conn
{
int ksnc_rx_niov; /* # iovec frags */
struct iovec *ksnc_rx_iov; /* the iovec frags */
int ksnc_rx_nkiov; /* # page frags */
- lnet_kiov_t *ksnc_rx_kiov; /* the page frags */
+ lnet_kiov_t *ksnc_rx_kiov; /* the page frags */
ksock_rxiovspace_t ksnc_rx_iov_space; /* space for frag descriptors */
void *ksnc_cookie; /* rx lnet_finalize passthru arg */
- ptl_hdr_t ksnc_hdr; /* where I read headers into */
+ lnet_hdr_t ksnc_hdr; /* where I read headers into */
/* WRITER */
struct list_head ksnc_tx_list; /* where I enq waiting for output space */
#endif
} ksock_conn_t;
-#define KSNR_TYPED_ROUTES ((1 << SOCKNAL_CONN_CONTROL) | \
- (1 << SOCKNAL_CONN_BULK_IN) | \
- (1 << SOCKNAL_CONN_BULK_OUT))
+#define KSNR_TYPED_ROUTES ((1 << SOCKLND_CONN_CONTROL) | \
+ (1 << SOCKLND_CONN_BULK_IN) | \
+ (1 << SOCKLND_CONN_BULK_OUT))
typedef struct ksock_route
{
struct list_head ksnp_routes; /* routes */
struct list_head ksnp_tx_queue; /* waiting packets */
cfs_time_t ksnp_last_alive; /* when (in jiffies) I was last alive */
- ptl_ni_t *ksnp_ni; /* which network */
+ lnet_ni_t *ksnp_ni; /* which network */
int ksnp_n_passive_ips; /* # of... */
- __u32 ksnp_passive_ips[PTL_MAX_INTERFACES]; /* preferred local interfaces */
+ __u32 ksnp_passive_ips[LNET_MAX_INTERFACES]; /* preferred local interfaces */
} ksock_peer_t;
typedef struct ksock_connreq
{
struct list_head ksncr_list; /* stash on ksnd_connd_connreqs */
- ptl_ni_t *ksncr_ni; /* chosen NI */
+ lnet_ni_t *ksncr_ni; /* chosen NI */
struct socket *ksncr_sock; /* accepted socket */
} ksock_connreq_t;
}
-int ksocknal_startup (ptl_ni_t *ni);
-void ksocknal_shutdown (ptl_ni_t *ni);
-int ksocknal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg);
-int ksocknal_send (ptl_ni_t *ni, void *private,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr,
- int type, lnet_process_id_t tgt,
- int tgt_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob);
-int ksocknal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+int ksocknal_startup (lnet_ni_t *ni);
+void ksocknal_shutdown (lnet_ni_t *ni);
+int ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
+int ksocknal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+int ksocknal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
-int ksocknal_accept(ptl_ni_t *ni, struct socket *sock);
+int ksocknal_accept(lnet_ni_t *ni, struct socket *sock);
-extern int ksocknal_add_peer(ptl_ni_t *ni, lnet_process_id_t id, __u32 ip, int port);
-extern ksock_peer_t *ksocknal_find_peer_locked (ptl_ni_t *ni, lnet_process_id_t id);
-extern ksock_peer_t *ksocknal_find_peer (ptl_ni_t *ni, lnet_process_id_t id);
-extern int ksocknal_create_conn (ptl_ni_t *ni, ksock_route_t *route,
+extern int ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ip, int port);
+extern ksock_peer_t *ksocknal_find_peer_locked (lnet_ni_t *ni, lnet_process_id_t id);
+extern ksock_peer_t *ksocknal_find_peer (lnet_ni_t *ni, lnet_process_id_t id);
+extern int ksocknal_create_conn (lnet_ni_t *ni, ksock_route_t *route,
struct socket *sock, int type);
extern void ksocknal_close_conn_locked (ksock_conn_t *conn, int why);
extern void ksocknal_terminate_conn (ksock_conn_t *conn);
extern void ksocknal_queue_tx_locked (ksock_tx_t *tx, ksock_conn_t *conn);
extern void ksocknal_tx_done (ksock_peer_t *peer, ksock_tx_t *tx, int asynch);
-extern void ksocknal_fwd_packet (ptl_ni_t *ni, kpr_fwd_desc_t *fwd);
-extern void ksocknal_fmb_callback (ptl_ni_t *ni, void *arg, int error);
-extern void ksocknal_notify (ptl_ni_t *ni, lnet_nid_t gw_nid, int alive);
+extern void ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive);
extern int ksocknal_thread_start (int (*fn)(void *arg), void *arg);
extern void ksocknal_thread_fini (void);
extern int ksocknal_new_packet (ksock_conn_t *conn, int skip);
extern int ksocknal_scheduler (void *arg);
extern int ksocknal_connd (void *arg);
extern int ksocknal_reaper (void *arg);
-extern int ksocknal_send_hello (ptl_ni_t *ni, ksock_conn_t *conn,
+extern int ksocknal_send_hello (lnet_ni_t *ni, ksock_conn_t *conn,
lnet_nid_t peer_nid,
__u32 *ipaddrs, int nipaddrs);
-extern int ksocknal_recv_hello (ptl_ni_t *ni, ksock_conn_t *conn,
+extern int ksocknal_recv_hello (lnet_ni_t *ni, ksock_conn_t *conn,
lnet_process_id_t *id,
__u64 *incarnation, __u32 *ipaddrs);
if (conn->ksnc_rx_nob_wanted == 0) {
/* Completed a message segment (header or payload) */
if ((*ksocknal_tunables.ksnd_eager_ack & conn->ksnc_type) != 0 &&
- (conn->ksnc_rx_state == SOCKNAL_RX_BODY ||
- conn->ksnc_rx_state == SOCKNAL_RX_BODY_FWD)) {
+ conn->ksnc_rx_state == SOCKNAL_RX_BODY) {
/* Remind the socket to ack eagerly... */
ksocknal_lib_eager_ack(conn);
}
#endif
}
- if (tx->tx_isfwd) { /* was a forwarded packet? */
- lnet_fwd_done (peer->ksnp_ni,
- KSOCK_TX_2_KPR_FWD_DESC (tx),
- (tx->tx_resid == 0) ? 0 : -ECONNABORTED);
- EXIT;
- return;
- }
-
- /* local send */
ltx = KSOCK_TX_2_KSOCK_LTX (tx);
lnet_finalize (peer->ksnp_ni,
default:
CERROR("ksnc_type bad: %u\n", c->ksnc_type);
LBUG();
- case SOCKNAL_CONN_ANY:
+ case SOCKLND_CONN_ANY:
break;
- case SOCKNAL_CONN_BULK_IN:
+ case SOCKLND_CONN_BULK_IN:
continue;
- case SOCKNAL_CONN_BULK_OUT:
+ case SOCKLND_CONN_BULK_OUT:
if (tx->tx_nob < *ksocknal_tunables.ksnd_min_bulk)
continue;
break;
- case SOCKNAL_CONN_CONTROL:
+ case SOCKLND_CONN_CONTROL:
if (tx->tx_nob >= *ksocknal_tunables.ksnd_min_bulk)
continue;
break;
continue;
} else {
/* Untyped connection established? */
- if ((bits & (1 << SOCKNAL_CONN_ANY)) != 0)
+ if ((bits & (1 << SOCKLND_CONN_ANY)) != 0)
continue;
}
}
int
-ksocknal_launch_packet (ptl_ni_t *ni, ksock_tx_t *tx, lnet_process_id_t id)
+ksocknal_launch_packet (lnet_ni_t *ni, ksock_tx_t *tx, lnet_process_id_t id)
{
unsigned long flags;
ksock_peer_t *peer;
LASSERT (lnet_iov_nob (tx->tx_niov, tx->tx_iov) +
lnet_kiov_nob (tx->tx_nkiov, tx->tx_kiov) == tx->tx_nob);
LASSERT (tx->tx_niov >= 1);
- LASSERT (tx->tx_iov[0].iov_len >= sizeof (ptl_hdr_t));
+ LASSERT (tx->tx_iov[0].iov_len >= sizeof (lnet_hdr_t));
CDEBUG (D_NET, "packet %p type %d, nob %d niov %d nkiov %d\n",
- tx, ((ptl_hdr_t *)tx->tx_iov[0].iov_base)->type,
+ tx, ((lnet_hdr_t *)tx->tx_iov[0].iov_base)->type,
tx->tx_nob, tx->tx_niov, tx->tx_nkiov);
tx->tx_conn = NULL; /* only set when assigned a conn */
tx->tx_resid = tx->tx_nob;
- tx->tx_hdr = (ptl_hdr_t *)tx->tx_iov[0].iov_base;
+ tx->tx_hdr = (lnet_hdr_t *)tx->tx_iov[0].iov_base;
g_lock = &ksocknal_data.ksnd_global_lock;
}
int
-ksocknal_send(ptl_ni_t *ni,
- void *private,
- ptl_msg_t *cookie,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int payload_niov,
- struct iovec *payload_iov,
- lnet_kiov_t *payload_kiov,
- unsigned int payload_offset,
- unsigned int payload_nob)
+ksocknal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- ksock_ltx_t *ltx;
- int desc_size;
- int rc;
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ unsigned int payload_niov = lntmsg->msg_niov;
+ struct iovec *payload_iov = lntmsg->msg_iov;
+ lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
+ unsigned int payload_offset = lntmsg->msg_offset;
+ unsigned int payload_nob = lntmsg->msg_len;
+ ksock_ltx_t *ltx;
+ int desc_size;
+ int rc;
/* NB 'private' is different depending on what we're sending.
* Just ignore it... */
desc_size = offsetof(ksock_ltx_t, ltx_kiov[payload_niov]);
if (in_interrupt() ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY) {
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY) {
/* Can't block if in interrupt or responding to an incoming
* message */
PORTAL_ALLOC_ATOMIC(ltx, desc_size);
ltx->ltx_hdr = *hdr;
ltx->ltx_private = private;
- ltx->ltx_cookie = cookie;
+ ltx->ltx_cookie = lntmsg;
- ltx->ltx_tx.tx_isfwd = 0;
ltx->ltx_tx.tx_nob = sizeof (*hdr) + payload_nob;
if (payload_iov != NULL) {
return (-EIO);
}
-void
-ksocknal_fwd_packet (ptl_ni_t *ni, kpr_fwd_desc_t *fwd)
-{
- lnet_process_id_t id = {.nid = fwd->kprfd_gateway_nid,
- .pid = LUSTRE_SRV_PTL_PID};
- /* CAVEAT EMPTOR:
- * LUSTRE_SRV_PTL_PID assumes my target is another socknal instance and
- * not a tcpnal (userspace/liblustre) instance. These can't route in
- * any case until we sort out how to make the RPC replies use the same
- * connections as RPC requests. */
- ksock_ftx_t *ftx = (ksock_ftx_t *)&fwd->kprfd_scratch;
- int rc;
-
- CDEBUG (D_NET, "Forwarding [%p] -> %s (%s))\n", fwd,
- libcfs_id2str(id), libcfs_nid2str(fwd->kprfd_target_nid));
-
- /* setup iov for hdr */
- ftx->ftx_iov.iov_base = fwd->kprfd_hdr;
- ftx->ftx_iov.iov_len = sizeof(ptl_hdr_t);
-
- ftx->ftx_tx.tx_isfwd = 1; /* This is a forwarding packet */
- ftx->ftx_tx.tx_nob = sizeof(ptl_hdr_t) + fwd->kprfd_nob;
- ftx->ftx_tx.tx_niov = 1;
- ftx->ftx_tx.tx_iov = &ftx->ftx_iov;
- ftx->ftx_tx.tx_nkiov = fwd->kprfd_niov;
- ftx->ftx_tx.tx_kiov = fwd->kprfd_kiov;
-
- rc = ksocknal_launch_packet (ni, &ftx->ftx_tx, id);
- if (rc != 0)
- lnet_fwd_done (ni, fwd, rc);
-}
-
int
ksocknal_thread_start (int (*fn)(void *arg), void *arg)
{
write_unlock_irqrestore(&ksocknal_data.ksnd_global_lock, flags);
}
-void
-ksocknal_fmb_callback (ptl_ni_t *ni, void *arg, int error)
-{
- ksock_fmb_t *fmb = (ksock_fmb_t *)arg;
- ksock_fmb_pool_t *fmp = fmb->fmb_pool;
- ptl_hdr_t *hdr = &fmb->fmb_hdr;
- ksock_conn_t *conn = NULL;
- ksock_sched_t *sched;
- unsigned long flags;
-
- if (error != 0)
- CERROR("Failed to route packet from %s to %s: %d\n",
- libcfs_nid2str(le64_to_cpu(hdr->src_nid)),
- libcfs_nid2str(le64_to_cpu(hdr->dest_nid)),
- error);
- else
- CDEBUG (D_NET, "routed packet from %s to %s: OK\n",
- libcfs_nid2str(le64_to_cpu(hdr->src_nid)),
- libcfs_nid2str(le64_to_cpu(hdr->dest_nid)));
-
- /* drop peer ref taken on init */
- ksocknal_peer_decref(fmb->fmb_peer);
-
- spin_lock_irqsave (&fmp->fmp_lock, flags);
-
- list_add (&fmb->fmb_list, &fmp->fmp_idle_fmbs);
- fmp->fmp_nactive_fmbs--;
-
- if (!list_empty (&fmp->fmp_blocked_conns)) {
- conn = list_entry (fmb->fmb_pool->fmp_blocked_conns.next,
- ksock_conn_t, ksnc_rx_list);
- list_del (&conn->ksnc_rx_list);
- }
-
- spin_unlock_irqrestore (&fmp->fmp_lock, flags);
-
- if (conn == NULL)
- return;
-
- CDEBUG (D_NET, "Scheduling conn %p\n", conn);
- LASSERT (conn->ksnc_rx_scheduled);
- LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_FMB_SLEEP);
-
- conn->ksnc_rx_state = SOCKNAL_RX_GET_FMB;
-
- sched = conn->ksnc_scheduler;
-
- spin_lock_irqsave (&sched->kss_lock, flags);
-
- list_add_tail (&conn->ksnc_rx_list, &sched->kss_rx_conns);
- cfs_waitq_signal (&sched->kss_waitq);
-
- spin_unlock_irqrestore (&sched->kss_lock, flags);
-}
-
-ksock_fmb_t *
-ksocknal_get_idle_fmb (ksock_conn_t *conn)
-{
- int payload_nob = conn->ksnc_rx_nob_left;
- unsigned long flags;
- ksock_fmb_pool_t *pool;
- ksock_fmb_t *fmb;
-
- LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB);
-
- if (payload_nob <= SOCKNAL_SMALL_FWD_PAGES * CFS_PAGE_SIZE)
- pool = &ksocknal_data.ksnd_small_fmp;
- else
- pool = &ksocknal_data.ksnd_large_fmp;
-
- spin_lock_irqsave (&pool->fmp_lock, flags);
-
- if (!list_empty (&pool->fmp_idle_fmbs)) {
- fmb = list_entry(pool->fmp_idle_fmbs.next,
- ksock_fmb_t, fmb_list);
- list_del (&fmb->fmb_list);
- pool->fmp_nactive_fmbs++;
- spin_unlock_irqrestore (&pool->fmp_lock, flags);
-
- return (fmb);
- }
-
- /* deschedule until fmb free */
-
- conn->ksnc_rx_state = SOCKNAL_RX_FMB_SLEEP;
-
- list_add_tail (&conn->ksnc_rx_list,
- &pool->fmp_blocked_conns);
-
- spin_unlock_irqrestore (&pool->fmp_lock, flags);
- return (NULL);
-}
-
-int
-ksocknal_init_fmb (ksock_conn_t *conn, ksock_fmb_t *fmb)
-{
- int payload_nob = conn->ksnc_rx_nob_left;
- lnet_nid_t src_nid = le64_to_cpu(conn->ksnc_hdr.src_nid);
- lnet_nid_t dest_nid = le64_to_cpu(conn->ksnc_hdr.dest_nid);
- lnet_nid_t sender_nid = conn->ksnc_peer->ksnp_id.nid;
- int niov = 0;
- int nob = payload_nob;
-
- LASSERT (conn->ksnc_rx_scheduled);
- LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB);
- LASSERT (conn->ksnc_rx_nob_wanted == conn->ksnc_rx_nob_left);
- LASSERT (payload_nob >= 0);
- LASSERT (payload_nob <= fmb->fmb_pool->fmp_buff_pages * CFS_PAGE_SIZE);
- LASSERT (sizeof (ptl_hdr_t) < CFS_PAGE_SIZE);
- LASSERT (fmb->fmb_kiov[0].kiov_offset == 0);
-
- /* Take a ref on the conn's peer to prevent module unload before
- * forwarding completes. */
- fmb->fmb_peer = conn->ksnc_peer;
- ksocknal_peer_addref(conn->ksnc_peer);
-
- /* Copy the header we just read into the forwarding buffer. If
- * there's payload, start reading reading it into the buffer,
- * otherwise the forwarding buffer can be kicked off
- * immediately. */
- fmb->fmb_hdr = conn->ksnc_hdr;
-
- while (nob > 0) {
- LASSERT (niov < fmb->fmb_pool->fmp_buff_pages);
- LASSERT (fmb->fmb_kiov[niov].kiov_offset == 0);
- fmb->fmb_kiov[niov].kiov_len = MIN (CFS_PAGE_SIZE, nob);
- nob -= CFS_PAGE_SIZE;
- niov++;
- }
-
- kpr_fwd_init(&fmb->fmb_fwd, dest_nid, sender_nid, src_nid,
- &fmb->fmb_hdr, payload_nob, niov, fmb->fmb_kiov,
- ksocknal_fmb_callback, fmb);
-
- if (payload_nob == 0) { /* got complete packet already */
- CDEBUG (D_NET, "%p %s->%s fwd_start (immediate)\n", conn,
- libcfs_nid2str(src_nid),
- libcfs_nid2str(dest_nid));
-
- lnet_fwd_start (conn->ksnc_peer->ksnp_ni, &fmb->fmb_fwd);
-
- ksocknal_new_packet (conn, 0); /* on to next packet */
- return (1);
- }
-
- conn->ksnc_cookie = fmb; /* stash fmb for later */
- conn->ksnc_rx_state = SOCKNAL_RX_BODY_FWD; /* read in the payload */
-
- /* Set up conn->ksnc_rx_kiov to read the payload into fmb's kiov-ed
- * buffer */
- LASSERT (niov <= sizeof(conn->ksnc_rx_iov_space)/sizeof(lnet_kiov_t));
-
- conn->ksnc_rx_niov = 0;
- conn->ksnc_rx_nkiov = niov;
- conn->ksnc_rx_kiov = conn->ksnc_rx_iov_space.kiov;
- memcpy(conn->ksnc_rx_kiov, fmb->fmb_kiov, niov * sizeof(lnet_kiov_t));
-
- CDEBUG (D_NET, "%p %s->%s %d reading body\n", conn,
- libcfs_nid2str(src_nid), libcfs_nid2str(dest_nid), payload_nob);
- return (0);
-}
-
-int
-ksocknal_fwd_parse (ksock_conn_t *conn)
-{
- lnet_nid_t dest_nid = le64_to_cpu(conn->ksnc_hdr.dest_nid);
- lnet_nid_t src_nid = le64_to_cpu(conn->ksnc_hdr.src_nid);
- int body_len = le32_to_cpu(conn->ksnc_hdr.payload_length);
-
- CDEBUG (D_NET, "%p %s->%s %d parsing header\n", conn,
- libcfs_nid2str(src_nid),
- libcfs_nid2str(dest_nid), conn->ksnc_rx_nob_left);
-
- LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_HEADER);
- LASSERT (conn->ksnc_rx_scheduled);
-
- if (body_len < 0) { /* length corrupt (overflow) */
- CERROR("dropping packet from %s for %s: "
- "packet size %d illegal\n",
- libcfs_nid2str(src_nid),
- libcfs_nid2str(dest_nid),
- body_len);
- ksocknal_new_packet (conn, 0); /* on to new packet */
- return -EIO;
- }
-
- if (body_len > PTL_MTU) { /* too big to forward */
- CERROR ("dropping packet from %s for %s: "
- "packet size %d too big\n",
- libcfs_nid2str(src_nid),
- libcfs_nid2str(dest_nid),
- body_len);
- /* on to new packet (skip this one's body) */
- ksocknal_new_packet (conn, body_len);
- return -EIO;
- }
-
- conn->ksnc_rx_state = SOCKNAL_RX_GET_FMB; /* Getting FMB now */
- conn->ksnc_rx_nob_left = body_len; /* stash packet size */
- conn->ksnc_rx_nob_wanted = body_len; /* (no slop) */
-
- return 0;
-}
-
int
ksocknal_new_packet (ksock_conn_t *conn, int nob_to_skip)
{
static char ksocknal_slop_buffer[4096];
- int nob;
- int niov;
- int skipped;
+ int nob;
+ unsigned int niov;
+ int skipped;
if (nob_to_skip == 0) { /* right at next packet boundary now */
conn->ksnc_rx_started = 0;
mb (); /* racing with timeout thread */
conn->ksnc_rx_state = SOCKNAL_RX_HEADER;
- conn->ksnc_rx_nob_wanted = sizeof (ptl_hdr_t);
- conn->ksnc_rx_nob_left = sizeof (ptl_hdr_t);
+ conn->ksnc_rx_nob_wanted = sizeof (lnet_hdr_t);
+ conn->ksnc_rx_nob_left = sizeof (lnet_hdr_t);
conn->ksnc_rx_iov = (struct iovec *)&conn->ksnc_rx_iov_space;
conn->ksnc_rx_iov[0].iov_base = (char *)&conn->ksnc_hdr;
- conn->ksnc_rx_iov[0].iov_len = sizeof (ptl_hdr_t);
+ conn->ksnc_rx_iov[0].iov_len = sizeof (lnet_hdr_t);
conn->ksnc_rx_niov = 1;
conn->ksnc_rx_kiov = NULL;
int
ksocknal_process_receive (ksock_conn_t *conn)
{
- ksock_fmb_t *fmb;
int rc;
LASSERT (atomic_read(&conn->ksnc_conn_refcount) > 0);
- /* doesn't need a forwarding buffer */
- if (conn->ksnc_rx_state != SOCKNAL_RX_GET_FMB)
- goto try_read;
-
- get_fmb:
- fmb = ksocknal_get_idle_fmb (conn);
- if (fmb == NULL) {
- /* conn descheduled waiting for idle fmb */
- return (0);
- }
-
- if (ksocknal_init_fmb (conn, fmb)) {
- /* packet forwarded */
- return (0);
- }
-
- try_read:
/* NB: sched lock NOT held */
LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_HEADER ||
conn->ksnc_rx_state == SOCKNAL_RX_BODY ||
- conn->ksnc_rx_state == SOCKNAL_RX_BODY_FWD ||
conn->ksnc_rx_state == SOCKNAL_RX_SLOP);
+ again:
+ if (conn->ksnc_rx_nob_wanted != 0) {
+ rc = ksocknal_receive(conn);
- LASSERT (conn->ksnc_rx_nob_wanted > 0);
-
- rc = ksocknal_receive(conn);
-
- if (rc <= 0) {
- LASSERT (rc != -EAGAIN);
-
- if (rc == 0)
- CDEBUG (D_NET, "[%p] EOF from %s ip %d.%d.%d.%d:%d\n",
- conn,
- libcfs_id2str(conn->ksnc_peer->ksnp_id),
- HIPQUAD(conn->ksnc_ipaddr),
- conn->ksnc_port);
- else if (!conn->ksnc_closing)
- CERROR ("[%p] Error %d on read from %s"
- " ip %d.%d.%d.%d:%d\n",
- conn, rc,
- libcfs_id2str(conn->ksnc_peer->ksnp_id),
- HIPQUAD(conn->ksnc_ipaddr),
- conn->ksnc_port);
+ if (rc <= 0) {
+ LASSERT (rc != -EAGAIN);
- ksocknal_close_conn_and_siblings (conn, rc);
- return (rc == 0 ? -ESHUTDOWN : rc);
- }
+ if (rc == 0)
+ CDEBUG (D_NET, "[%p] EOF from %s"
+ " ip %d.%d.%d.%d:%d\n", conn,
+ libcfs_id2str(conn->ksnc_peer->ksnp_id),
+ HIPQUAD(conn->ksnc_ipaddr),
+ conn->ksnc_port);
+ else if (!conn->ksnc_closing)
+ CERROR ("[%p] Error %d on read from %s"
+ " ip %d.%d.%d.%d:%d\n",
+ conn, rc,
+ libcfs_id2str(conn->ksnc_peer->ksnp_id),
+ HIPQUAD(conn->ksnc_ipaddr),
+ conn->ksnc_port);
- if (conn->ksnc_rx_nob_wanted != 0) {
- /* short read */
- return (-EAGAIN);
+ ksocknal_close_conn_and_siblings (conn, rc);
+ return (rc == 0 ? -ESHUTDOWN : rc);
+ }
+
+ if (conn->ksnc_rx_nob_wanted != 0) {
+ /* short read */
+ return (-EAGAIN);
+ }
}
switch (conn->ksnc_rx_state) {
conn->ksnc_hdr.src_pid = cpu_to_le32(id->pid);
conn->ksnc_hdr.src_nid = cpu_to_le64(id->nid);
}
- rc = lnet_parse(conn->ksnc_peer->ksnp_ni, &conn->ksnc_hdr, conn);
- switch (rc) {
- case 0:
- break;
-
- case 1:
- /* This packet isn't for me (still in net byte order) */
- rc = ksocknal_fwd_parse (conn);
- if (rc == 0) {
- switch (conn->ksnc_rx_state) {
- case SOCKNAL_RX_HEADER: /* skipped (zero payload) */
- return (0); /* => come back later */
- case SOCKNAL_RX_SLOP: /* skipping packet's body */
- goto try_read; /* => go read it */
- case SOCKNAL_RX_GET_FMB: /* forwarding */
- goto get_fmb; /* => go get a fwd msg buffer */
- default:
- LBUG ();
- }
- /* Not Reached */
- }
- /* fall through */
- default:
+ conn->ksnc_rx_state = SOCKNAL_RX_PARSE;
+ ksocknal_conn_addref(conn); /* ++ref while parsing */
+
+ rc = lnet_parse(conn->ksnc_peer->ksnp_ni, &conn->ksnc_hdr, conn);
+ if (rc < 0) {
/* I just received garbage: give up on this conn */
+ ksocknal_new_packet(conn, 0);
ksocknal_close_conn_and_siblings (conn, rc);
+ ksocknal_conn_decref(conn);
return (-EPROTO);
}
- if (conn->ksnc_rx_nob_wanted != 0) { /* need to get payload? */
- conn->ksnc_rx_state = SOCKNAL_RX_BODY;
- goto try_read; /* go read the payload */
- }
- /* Fall through (completed packet for me) */
+ /* I'm racing with ksocknal_recv() */
+ LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_PARSE ||
+ conn->ksnc_rx_state == SOCKNAL_RX_BODY);
+
+ if (conn->ksnc_rx_state != SOCKNAL_RX_BODY)
+ return 0;
+
+ /* ksocknal_recv() got called */
+ goto again;
case SOCKNAL_RX_BODY:
/* payload all received */
case SOCKNAL_RX_SLOP:
/* starting new packet? */
if (ksocknal_new_packet (conn, conn->ksnc_rx_nob_left))
- return (0); /* come back later */
- goto try_read; /* try to finish reading slop now */
-
- case SOCKNAL_RX_BODY_FWD:
- /* payload all received */
- CDEBUG (D_NET, "%p %s->%s %d fwd_start (got body)\n", conn,
- libcfs_nid2str(le64_to_cpu(conn->ksnc_hdr.src_nid)),
- libcfs_nid2str(le64_to_cpu(conn->ksnc_hdr.dest_nid)),
- conn->ksnc_rx_nob_left);
-
- /* forward the packet. NB ksocknal_init_fmb() put fmb into
- * conn->ksnc_cookie */
- fmb = (ksock_fmb_t *)conn->ksnc_cookie;
- lnet_fwd_start (conn->ksnc_peer->ksnp_ni, &fmb->fmb_fwd);
-
- /* no slop in forwarded packets */
- LASSERT (conn->ksnc_rx_nob_left == 0);
-
- ksocknal_new_packet (conn, 0); /* on to next packet */
- return (0); /* (later) */
+ return 0; /* come back later */
+ goto again; /* try to finish reading slop now */
default:
break;
}
int
-ksocknal_recv (ptl_ni_t *ni, void *private, ptl_msg_t *msg,
+ksocknal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
- ksock_conn_t *conn = (ksock_conn_t *)private;
+ ksock_conn_t *conn = (ksock_conn_t *)private;
+ ksock_sched_t *sched = conn->ksnc_scheduler;
+ unsigned int flags;
LASSERT (mlen <= rlen);
LASSERT (niov <= PTL_MD_MAX_IOV);
lnet_iov_nob (conn->ksnc_rx_niov, conn->ksnc_rx_iov) +
lnet_kiov_nob (conn->ksnc_rx_nkiov, conn->ksnc_rx_kiov));
+ LASSERT (conn->ksnc_rx_scheduled);
+
+ spin_lock_irqsave(&sched->kss_lock, flags);
+
+ switch (conn->ksnc_rx_state) {
+ case SOCKNAL_RX_PARSE_WAIT:
+ list_add_tail(&conn->ksnc_rx_list, &sched->kss_rx_conns);
+ cfs_waitq_signal (&sched->kss_waitq);
+ LASSERT (conn->ksnc_rx_ready);
+ break;
+
+ case SOCKNAL_RX_PARSE:
+ /* scheduler hasn't noticed I'm parsing yet */
+ break;
+ }
+
+ conn->ksnc_rx_state = SOCKNAL_RX_BODY;
+
+ spin_unlock_irqrestore(&sched->kss_lock, flags);
+ ksocknal_conn_decref(conn);
return (0);
}
if (rc == 0)
conn->ksnc_rx_ready = 1;
- if (conn->ksnc_rx_state == SOCKNAL_RX_FMB_SLEEP ||
- conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB) {
- /* Conn blocked for a forwarding buffer.
- * It will get queued for my attention when
- * one becomes available (and it might just
- * already have been!). Meanwhile my ref
- * on it stays put. */
+ if (conn->ksnc_rx_state == SOCKNAL_RX_PARSE) {
+ /* Conn blocked waiting for ksocknal_recv()
+ * I change its state (under lock) to signal
+ * it can be rescheduled */
+ conn->ksnc_rx_state = SOCKNAL_RX_PARSE_WAIT;
} else if (conn->ksnc_rx_ready) {
/* reschedule for rx */
list_add_tail (&conn->ksnc_rx_list,
}
int
-ksocknal_send_hello (ptl_ni_t *ni, ksock_conn_t *conn, lnet_nid_t peer_nid,
+ksocknal_send_hello (lnet_ni_t *ni, ksock_conn_t *conn, lnet_nid_t peer_nid,
__u32 *ipaddrs, int nipaddrs)
{
/* CAVEAT EMPTOR: this byte flips 'ipaddrs' */
- ksock_net_t *net = (ksock_net_t *)ni->ni_data;
- struct socket *sock = conn->ksnc_sock;
- ptl_hdr_t hdr;
- ptl_magicversion_t *hmv = (ptl_magicversion_t *)&hdr.dest_nid;
- int i;
- int rc;
- lnet_nid_t srcnid;
+ ksock_net_t *net = (ksock_net_t *)ni->ni_data;
+ struct socket *sock = conn->ksnc_sock;
+ lnet_hdr_t hdr;
+ lnet_magicversion_t *hmv = (lnet_magicversion_t *)&hdr.dest_nid;
+ int i;
+ int rc;
+ lnet_nid_t srcnid;
- LASSERT (conn->ksnc_type != SOCKNAL_CONN_NONE);
- LASSERT (0 <= nipaddrs && nipaddrs <= PTL_MAX_INTERFACES);
+ LASSERT (conn->ksnc_type != SOCKLND_CONN_NONE);
+ LASSERT (0 <= nipaddrs && nipaddrs <= LNET_MAX_INTERFACES);
/* No need for getconnsock/putconnsock */
LASSERT (!conn->ksnc_closing);
LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
- hmv->magic = cpu_to_le32 (PTL_PROTO_TCP_MAGIC);
- hmv->version_major = cpu_to_le16 (PTL_PROTO_TCP_VERSION_MAJOR);
- hmv->version_minor = cpu_to_le16 (PTL_PROTO_TCP_VERSION_MINOR);
+ hmv->magic = cpu_to_le32 (LNET_PROTO_TCP_MAGIC);
+ hmv->version_major = cpu_to_le16 (LNET_PROTO_TCP_VERSION_MAJOR);
+ hmv->version_minor = cpu_to_le16 (LNET_PROTO_TCP_VERSION_MINOR);
srcnid = lnet_ptlcompat_srcnid(ni->ni_nid, peer_nid);
hdr.src_nid = cpu_to_le64 (srcnid);
- hdr.src_pid = cpu_to_le64 (lnet_getpid());
- hdr.type = cpu_to_le32 (PTL_MSG_HELLO);
+ hdr.src_pid = cpu_to_le64 (the_lnet.ln_pid);
+ hdr.type = cpu_to_le32 (LNET_MSG_HELLO);
hdr.payload_length = cpu_to_le32 (nipaddrs * sizeof(*ipaddrs));
hdr.msg.hello.type = cpu_to_le32 (conn->ksnc_type);
{
switch (type)
{
- case SOCKNAL_CONN_ANY:
- case SOCKNAL_CONN_CONTROL:
+ case SOCKLND_CONN_ANY:
+ case SOCKLND_CONN_CONTROL:
return (type);
- case SOCKNAL_CONN_BULK_IN:
- return SOCKNAL_CONN_BULK_OUT;
- case SOCKNAL_CONN_BULK_OUT:
- return SOCKNAL_CONN_BULK_IN;
+ case SOCKLND_CONN_BULK_IN:
+ return SOCKLND_CONN_BULK_OUT;
+ case SOCKLND_CONN_BULK_OUT:
+ return SOCKLND_CONN_BULK_IN;
default:
- return (SOCKNAL_CONN_NONE);
+ return (SOCKLND_CONN_NONE);
}
}
int
-ksocknal_recv_hello (ptl_ni_t *ni, ksock_conn_t *conn,
+ksocknal_recv_hello (lnet_ni_t *ni, ksock_conn_t *conn,
lnet_process_id_t *peerid,
__u64 *incarnation, __u32 *ipaddrs)
{
- struct socket *sock = conn->ksnc_sock;
- int active;
- int timeout;
- int rc;
- int nips;
- int i;
- int type;
- ptl_hdr_t hdr;
- lnet_process_id_t recv_id;
- ptl_magicversion_t *hmv;
+ struct socket *sock = conn->ksnc_sock;
+ int active;
+ int timeout;
+ int rc;
+ int nips;
+ int i;
+ int type;
+ lnet_hdr_t hdr;
+ lnet_process_id_t recv_id;
+ lnet_magicversion_t *hmv;
active = (peerid->nid != LNET_NID_ANY);
timeout = active ? *ksocknal_tunables.ksnd_timeout :
lnet_acceptor_timeout();
- hmv = (ptl_magicversion_t *)&hdr.dest_nid;
+ hmv = (lnet_magicversion_t *)&hdr.dest_nid;
LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
rc = libcfs_sock_read(sock, &hmv->magic, sizeof (hmv->magic), timeout);
}
if (!active &&
- hmv->magic != le32_to_cpu (PTL_PROTO_TCP_MAGIC)) {
+ hmv->magic != le32_to_cpu (LNET_PROTO_TCP_MAGIC)) {
/* Is this a generic acceptor connection request? */
rc = lnet_accept(ni, sock, hmv->magic);
if (rc != 0)
}
}
- if (hmv->magic != le32_to_cpu (PTL_PROTO_TCP_MAGIC)) {
+ if (hmv->magic != le32_to_cpu (LNET_PROTO_TCP_MAGIC)) {
CERROR ("Bad magic %#08x (%#08x expected) from %u.%u.%u.%u\n",
- __cpu_to_le32 (hmv->magic), PTL_PROTO_TCP_MAGIC,
+ __cpu_to_le32 (hmv->magic), LNET_PROTO_TCP_MAGIC,
HIPQUAD(conn->ksnc_ipaddr));
return (-EPROTO);
}
return (rc);
}
- if (hmv->version_major != cpu_to_le16 (PTL_PROTO_TCP_VERSION_MAJOR) ||
- hmv->version_minor != cpu_to_le16 (PTL_PROTO_TCP_VERSION_MINOR)) {
+ if (hmv->version_major != cpu_to_le16 (LNET_PROTO_TCP_VERSION_MAJOR) ||
+ hmv->version_minor != cpu_to_le16 (LNET_PROTO_TCP_VERSION_MINOR)) {
CERROR ("Incompatible protocol version %d.%d (%d.%d expected)"
" from %u.%u.%u.%u\n",
le16_to_cpu (hmv->version_major),
le16_to_cpu (hmv->version_minor),
- PTL_PROTO_TCP_VERSION_MAJOR,
- PTL_PROTO_TCP_VERSION_MINOR,
+ LNET_PROTO_TCP_VERSION_MAJOR,
+ LNET_PROTO_TCP_VERSION_MINOR,
HIPQUAD(conn->ksnc_ipaddr));
return (-EPROTO);
}
-#if (PTL_PROTO_TCP_VERSION_MAJOR != 1)
+#if (LNET_PROTO_TCP_VERSION_MAJOR != 1)
# error "This code only understands protocol version 1.x"
#endif
/* version 1 sends magic/version as the dest_nid of a 'hello'
}
/* ...and check we got what we expected */
- if (hdr.type != cpu_to_le32 (PTL_MSG_HELLO)) {
+ if (hdr.type != cpu_to_le32 (LNET_MSG_HELLO)) {
CERROR ("Expecting a HELLO hdr,"
" but got type %d from %u.%u.%u.%u\n",
le32_to_cpu (hdr.type),
return (-EPROTO);
}
- if (conn->ksnc_port > PTL_ACCEPTOR_MAX_RESERVED_PORT) {
+ if (conn->ksnc_port > LNET_ACCEPTOR_MAX_RESERVED_PORT) {
/* Userspace NAL assigns peer process ID from socket */
recv_id.pid = conn->ksnc_port | LNET_PID_USERFLAG;
recv_id.nid = PTL_MKNID(PTL_NIDNET(ni->ni_nid), conn->ksnc_ipaddr);
} else {
recv_id.nid = le64_to_cpu(hdr.src_nid);
- if (lnet_apini.apini_ptlcompat > 1 && /* portals peers may exist */
+ if (the_lnet.ln_ptlcompat > 1 && /* portals peers may exist */
PTL_NIDNET(recv_id.nid) == 0) /* this is one */
- recv_id.pid = lnet_getpid(); /* give it a sensible pid */
+ recv_id.pid = the_lnet.ln_pid; /* give it a sensible pid */
else
recv_id.pid = le32_to_cpu(hdr.src_pid);
type = __le32_to_cpu(hdr.msg.hello.type);
- if (conn->ksnc_type == SOCKNAL_CONN_NONE) {
+ if (conn->ksnc_type == SOCKLND_CONN_NONE) {
/* I've accepted this connection; peer determines type */
conn->ksnc_type = ksocknal_invert_type(type);
- if (conn->ksnc_type == SOCKNAL_CONN_NONE) {
+ if (conn->ksnc_type == SOCKLND_CONN_NONE) {
CERROR ("Unexpected type %d from %s ip %u.%u.%u.%u\n",
type, libcfs_id2str(*peerid),
HIPQUAD(conn->ksnc_ipaddr));
nips = __le32_to_cpu (hdr.payload_length) / sizeof (__u32);
- if (nips > PTL_MAX_INTERFACES ||
+ if (nips > LNET_MAX_INTERFACES ||
nips * sizeof(__u32) != __le32_to_cpu (hdr.payload_length)) {
CERROR("Bad payload length %d from %s ip %u.%u.%u.%u\n",
__le32_to_cpu (hdr.payload_length),
for (;;) {
if (!*ksocknal_tunables.ksnd_typed_conns) {
- if ((route->ksnr_connected & (1<<SOCKNAL_CONN_ANY)) == 0)
- type = SOCKNAL_CONN_ANY;
+ if ((route->ksnr_connected & (1<<SOCKLND_CONN_ANY)) == 0)
+ type = SOCKLND_CONN_ANY;
else
break; /* got connected while route queued */
} else {
- if ((route->ksnr_connected & (1<<SOCKNAL_CONN_CONTROL)) == 0)
- type = SOCKNAL_CONN_CONTROL;
- else if ((route->ksnr_connected & (1<<SOCKNAL_CONN_BULK_IN)) == 0)
- type = SOCKNAL_CONN_BULK_IN;
- else if ((route->ksnr_connected & (1<<SOCKNAL_CONN_BULK_OUT)) == 0)
- type = SOCKNAL_CONN_BULK_OUT;
+ if ((route->ksnr_connected & (1<<SOCKLND_CONN_CONTROL)) == 0)
+ type = SOCKLND_CONN_CONTROL;
+ else if ((route->ksnr_connected & (1<<SOCKLND_CONN_BULK_IN)) == 0)
+ type = SOCKLND_CONN_BULK_IN;
+ else if ((route->ksnr_connected & (1<<SOCKLND_CONN_BULK_OUT)) == 0)
+ type = SOCKLND_CONN_BULK_OUT;
else
break; /* got connected while route queued */
}
flags);
ksocknal_create_conn(cr->ksncr_ni, NULL,
- cr->ksncr_sock, SOCKNAL_CONN_NONE);
- ptl_ni_decref(cr->ksncr_ni);
+ cr->ksncr_sock, SOCKLND_CONN_NONE);
+ lnet_ni_decref(cr->ksncr_ni);
PORTAL_FREE(cr, sizeof(*cr));
spin_lock_irqsave(&ksocknal_data.ksnd_connd_lock,
#if SOCKNAL_SINGLE_FRAG_TX
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_tx_scratch_iov;
- int niov = tx->tx_niov;
+ unsigned int niov = tx->tx_niov;
#endif
struct socket *sock = conn->ksnc_sock;
int nob;
#if SOCKNAL_SINGLE_FRAG_TX || !SOCKNAL_RISK_KMAP_DEADLOCK
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_tx_scratch_iov;
- int niov = tx->tx_nkiov;
+ unsigned int niov = tx->tx_nkiov;
#endif
struct socket *sock = conn->ksnc_sock;
lnet_kiov_t *kiov = tx->tx_kiov;
#if SOCKNAL_SINGLE_FRAG_RX
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_rx_scratch_iov;
- int niov = conn->ksnc_rx_niov;
+ unsigned int niov = conn->ksnc_rx_niov;
#endif
struct iovec *iov = conn->ksnc_rx_iov;
int nob;
#if SOCKNAL_SINGLE_FRAG_RX || !SOCKNAL_RISK_KMAP_DEADLOCK
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_rx_scratch_iov;
- int niov = conn->ksnc_rx_nkiov;
+ unsigned int niov = conn->ksnc_rx_nkiov;
#endif
lnet_kiov_t *kiov = conn->ksnc_rx_kiov;
int nob;
#if CPU_AFFINITY
struct dst_entry *dst;
- if (!ksocknal_tunables.ksnd_irq_affinity)
+ if (!*ksocknal_tunables.ksnd_irq_affinity)
return 0;
dst = sk_dst_get (sock->sk);
#if SOCKNAL_SINGLE_FRAG_TX
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_tx_scratch_iov;
- int niov = tx->tx_niov;
+ unsigned int niov = tx->tx_niov;
#endif
struct msghdr msg = {
.msg_name = NULL,
#if SOCKNAL_SINGLE_FRAG_TX || !SOCKNAL_RISK_KMAP_DEADLOCK
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
#ifdef CONFIG_HIGHMEM
#warning "XXX risk of kmap deadlock on multiple frags..."
#endif
struct iovec *scratchiov = conn->ksnc_tx_scratch_iov;
- int niov = tx->tx_nkiov;
+ unsigned int niov = tx->tx_nkiov;
#endif
struct msghdr msg = {
.msg_name = NULL,
#if SOCKNAL_SINGLE_FRAG_RX
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_rx_scratch_iov;
- int niov = conn->ksnc_rx_niov;
+ unsigned int niov = conn->ksnc_rx_niov;
#endif
struct iovec *iov = conn->ksnc_rx_iov;
struct msghdr msg = {
#if SOCKNAL_SINGLE_FRAG_RX || !SOCKNAL_RISK_KMAP_DEADLOCK
struct iovec scratch;
struct iovec *scratchiov = &scratch;
- int niov = 1;
+ unsigned int niov = 1;
#else
#ifdef CONFIG_HIGHMEM
#warning "XXX risk of kmap deadlock on multiple frags..."
#endif
struct iovec *scratchiov = conn->ksnc_rx_scratch_iov;
- int niov = conn->ksnc_rx_nkiov;
+ unsigned int niov = conn->ksnc_rx_nkiov;
#endif
lnet_kiov_t *kiov = conn->ksnc_rx_kiov;
struct msghdr msg = {
return (rc);
}
- if (!ksocknal_tunables.ksnd_nagle) {
+ if (!*ksocknal_tunables.ksnd_nagle) {
option = 1;
set_fs (KERNEL_DS);
#include "viblnd.h"
-ptl_nal_t kibnal_nal = {
- .nal_type = VIBNAL,
- .nal_startup = kibnal_startup,
- .nal_shutdown = kibnal_shutdown,
- .nal_ctl = kibnal_ctl,
- .nal_send = kibnal_send,
- .nal_recv = kibnal_recv,
+lnd_t the_kiblnd = {
+ .lnd_type = VIBLND,
+ .lnd_startup = kibnal_startup,
+ .lnd_shutdown = kibnal_shutdown,
+ .lnd_ctl = kibnal_ctl,
+ .lnd_send = kibnal_send,
+ .lnd_recv = kibnal_recv,
};
kib_data_t kibnal_data;
}
int
-kibnal_start_listener (ptl_ni_t *ni)
+kibnal_start_listener (lnet_ni_t *ni)
{
static cm_listen_data_t info;
}
void
-kibnal_stop_listener(ptl_ni_t *ni)
+kibnal_stop_listener(lnet_ni_t *ni)
{
cm_return_t cmrc;
}
int
-kibnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg)
+kibnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
int rc = -EINVAL;
}
void
-kibnal_shutdown (ptl_ni_t *ni)
+kibnal_shutdown (lnet_ni_t *ni)
{
int i;
vv_return_t vvrc;
}
int
-kibnal_startup (ptl_ni_t *ni)
+kibnal_startup (lnet_ni_t *ni)
{
char scratch[32];
char ipif_name[32];
vv_request_event_record_t req_er;
vv_return_t vvrc;
- LASSERT (ni->ni_nal == &kibnal_nal);
+ LASSERT (ni->ni_lnd == &the_kiblnd);
/* Only 1 instance supported */
if (kibnal_data.kib_init != IBNAL_INIT_NOTHING) {
return -EPERM;
}
- CLASSERT (PTL_MAX_INTERFACES > 1);
+ CLASSERT (LNET_MAX_INTERFACES > 1);
if (ni->ni_interfaces[0] != NULL) {
/* Use the HCA specified in 'networks=' */
void __exit
kibnal_module_fini (void)
{
- lnet_unregister_nal(&kibnal_nal);
+ lnet_unregister_lnd(&the_kiblnd);
kibnal_tunables_fini();
}
if (rc != 0)
return rc;
- lnet_register_nal(&kibnal_nal);
+ lnet_register_lnd(&the_kiblnd);
return 0;
}
__u64 kib_incarnation; /* which one am I */
int kib_shutdown; /* shut down? */
atomic_t kib_nthreads; /* # live threads */
- ptl_ni_t *kib_ni; /* _the_ nal instance */
+ lnet_ni_t *kib_ni; /* _the_ nal instance */
vv_gid_t kib_port_gid; /* device/port GID */
vv_p_key_t kib_port_pkey; /* device/port pkey */
struct list_head rx_list; /* queue for attention */
struct kib_conn *rx_conn; /* owning conn */
int rx_responded; /* responded to peer? */
- int rx_posted; /* posted? */
+ int rx_nob; /* # bytes received (-1 while posted) */
vv_l_key_t rx_lkey; /* local key */
kib_msg_t *rx_msg; /* pre-mapped buffer (host vaddr) */
vv_wr_t rx_wrq; /* receive work item */
int tx_status; /* completion status */
unsigned long tx_deadline; /* completion deadline */
__u64 tx_cookie; /* completion cookie */
- ptl_msg_t *tx_ptlmsg[2]; /* ptl msgs to finalize on completion */
+ lnet_msg_t *tx_lntmsg[2]; /* ptl msgs to finalize on completion */
vv_l_key_t tx_lkey; /* local key for message buffer */
kib_msg_t *tx_msg; /* message buffer (host vaddr) */
int tx_nwrq; /* # send work items */
extern kib_data_t kibnal_data;
extern kib_tunables_t kibnal_tunables;
-int kibnal_startup (ptl_ni_t *ni);
-void kibnal_shutdown (ptl_ni_t *ni);
-int kibnal_ctl(ptl_ni_t *ni, unsigned int cmd, void *arg);
-int kibnal_send (ptl_ni_t *ni, void *private,
- ptl_msg_t *ptlmsg, ptl_hdr_t *hdr,
- int type, lnet_process_id_t tgt,
- int tgt_is_router, int routing,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int nob);
-int kibnal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+int kibnal_startup (lnet_ni_t *ni);
+void kibnal_shutdown (lnet_ni_t *ni);
+int kibnal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
+int kibnal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+int kibnal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
extern void kibnal_init_msg(kib_msg_t *msg, int type, int body_nob);
void
kibnal_tx_done (kib_tx_t *tx)
{
- int ptlrc = (tx->tx_status == 0) ? 0 : -EIO;
- int i;
+ int rc = tx->tx_status;
+ int i;
LASSERT (!in_interrupt());
LASSERT (!tx->tx_queued); /* mustn't be queued for sending */
#if IBNAL_USE_FMR
if (tx->tx_md.md_fmrcount == 0 ||
- (ptlrc != 0 && tx->tx_md.md_active)) {
+ (rc != 0 && tx->tx_md.md_active)) {
vv_return_t vvrc;
/* mapping must be active (it dropped fmrcount to 0) */
#endif
for (i = 0; i < 2; i++) {
/* tx may have up to 2 ptlmsgs to finalise */
- if (tx->tx_ptlmsg[i] == NULL)
+ if (tx->tx_lntmsg[i] == NULL)
continue;
- lnet_finalize (kibnal_data.kib_ni, NULL, tx->tx_ptlmsg[i], ptlrc);
- tx->tx_ptlmsg[i] = NULL;
+ lnet_finalize (kibnal_data.kib_ni, NULL, tx->tx_lntmsg[i], rc);
+ tx->tx_lntmsg[i] = NULL;
}
if (tx->tx_conn != NULL) {
LASSERT (!tx->tx_waiting);
LASSERT (tx->tx_status == 0);
LASSERT (tx->tx_conn == NULL);
- LASSERT (tx->tx_ptlmsg[0] == NULL);
- LASSERT (tx->tx_ptlmsg[1] == NULL);
+ LASSERT (tx->tx_lntmsg[0] == NULL);
+ LASSERT (tx->tx_lntmsg[1] == NULL);
}
spin_unlock(&kibnal_data.kib_tx_lock);
};
LASSERT (conn->ibc_state >= IBNAL_CONN_INIT);
- LASSERT (!rx->rx_posted);
+ LASSERT (rx->rx_nob >= 0); /* not posted */
CDEBUG(D_NET, "posting rx [%d %x "LPX64"]\n",
rx->rx_wrq.scatgat_list->length,
return 0;
}
- rx->rx_posted = 1;
-
+ rx->rx_nob = -1; /* flag posted */
+
spin_lock(&conn->ibc_lock);
/* Serialise vv_post_receive; it's not re-entrant on the same QP */
vvrc = vv_post_receive(kibnal_data.kib_hca,
tx->tx_status = status;
} else if (txtype == IBNAL_MSG_GET_REQ) {
/* XXX layering violation: set REPLY data length */
- LASSERT (tx->tx_ptlmsg[1] != NULL);
- LASSERT (tx->tx_ptlmsg[1]->msg_ev.type ==
+ LASSERT (tx->tx_lntmsg[1] != NULL);
+ LASSERT (tx->tx_lntmsg[1]->msg_ev.type ==
LNET_EVENT_REPLY);
- tx->tx_ptlmsg[1]->msg_ev.mlength = status;
+ tx->tx_lntmsg[1]->msg_ev.mlength = status;
}
}
kib_conn_t *conn = rx->rx_conn;
int credits = msg->ibm_credits;
kib_tx_t *tx;
- int rc;
+ int rc = 0;
+ int repost = 1;
+ int rc2;
LASSERT (conn->ibc_state >= IBNAL_CONN_ESTABLISHED);
kibnal_check_sends(conn);
}
+ /* clear flag so GET_REQ can see if it caused a REPLY */
+ rx->rx_responded = 0;
+
switch (msg->ibm_type) {
default:
CERROR("Bad IBNAL message type %x from %s\n",
msg->ibm_type, libcfs_nid2str(conn->ibc_peer->ibp_nid));
+ rc = -EPROTO;
break;
case IBNAL_MSG_NOOP:
break;
case IBNAL_MSG_IMMEDIATE:
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.immediate.ibim_hdr, rx);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.immediate.ibim_hdr, rx);
+ repost = rc < 0; /* repost on error */
break;
case IBNAL_MSG_PUT_REQ:
- rx->rx_responded = 0;
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.putreq.ibprm_hdr, rx);
- if (rx->rx_responded)
- break;
-
- /* I wasn't asked to transfer any payload data. This happens
- * if the PUT didn't match, or got truncated. */
- kibnal_send_completion(rx->rx_conn, IBNAL_MSG_PUT_NAK, 0,
- msg->ibm_u.putreq.ibprm_cookie);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.putreq.ibprm_hdr, rx);
+ repost = rc < 0; /* repost on error */
break;
case IBNAL_MSG_PUT_NAK:
if (tx == NULL) {
CERROR("Unmatched PUT_ACK from %s\n",
libcfs_nid2str(conn->ibc_peer->ibp_nid));
- kibnal_close_conn(conn, -EPROTO);
+ rc = -EPROTO;
break;
}
tx->tx_nwrq = 0; /* overwrite PUT_REQ */
- rc = kibnal_init_rdma(tx, IBNAL_MSG_PUT_DONE,
- kibnal_rd_size(&msg->ibm_u.putack.ibpam_rd),
- &msg->ibm_u.putack.ibpam_rd,
- msg->ibm_u.putack.ibpam_dst_cookie);
- if (rc < 0)
+ rc2 = kibnal_init_rdma(tx, IBNAL_MSG_PUT_DONE,
+ kibnal_rd_size(&msg->ibm_u.putack.ibpam_rd),
+ &msg->ibm_u.putack.ibpam_rd,
+ msg->ibm_u.putack.ibpam_dst_cookie);
+ if (rc2 < 0)
CERROR("Can't setup rdma for PUT to %s: %d\n",
libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
spin_lock(&conn->ibc_lock);
- if (tx->tx_status == 0 && rc < 0)
- tx->tx_status = rc;
+ if (tx->tx_status == 0 && rc2 < 0)
+ tx->tx_status = rc2;
tx->tx_waiting = 0; /* clear waiting and queue atomically */
kibnal_queue_tx_locked(tx, conn);
spin_unlock(&conn->ibc_lock);
break;
case IBNAL_MSG_GET_REQ:
- rx->rx_responded = 0;
- lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.get.ibgm_hdr, rx);
- if (rx->rx_responded) /* I responded to the GET_REQ */
- break;
- /* NB GET didn't match (I'd have responded even with no payload
- * data) */
- kibnal_send_completion(rx->rx_conn, IBNAL_MSG_GET_DONE, -ENODATA,
- msg->ibm_u.get.ibgm_cookie);
+ rc = lnet_parse(kibnal_data.kib_ni, &msg->ibm_u.get.ibgm_hdr, rx);
+ repost = rc < 0; /* repost on error */
break;
case IBNAL_MSG_GET_DONE:
break;
}
- kibnal_post_rx(rx, 1);
+ if (rc < 0) /* protocol error */
+ kibnal_close_conn(conn, rc);
+
+ if (repost)
+ kibnal_post_rx(rx, 1);
}
void
int rc;
CDEBUG (D_NET, "rx %p conn %p\n", rx, conn);
- LASSERT (rx->rx_posted);
- rx->rx_posted = 0;
+ LASSERT (rx->rx_nob < 0); /* was posted */
+ rx->rx_nob = 0; /* isn't now */
if (conn->ibc_state > IBNAL_CONN_ESTABLISHED)
goto ignore;
goto failed;
}
+ rx->rx_nob = nob; /* Can trust 'nob' now */
+
if (msg->ibm_srcnid != conn->ibc_peer->ibp_nid ||
!lnet_ptlcompat_matchnid(kibnal_data.kib_ni->ni_nid,
msg->ibm_dstnid) ||
int
kibnal_setup_rd_iov(kib_tx_t *tx, kib_rdma_desc_t *rd,
vv_access_con_bit_mask_t access,
- int niov, struct iovec *iov, int offset, int nob)
+ unsigned int niov, struct iovec *iov, int offset, int nob)
{
/* active if I'm sending */
int
kibnal_setup_rd_iov (kib_tx_t *tx, kib_rdma_desc_t *rd,
vv_access_con_bit_mask_t access,
- int niov, struct iovec *iov, int offset, int nob)
+ unsigned int niov, struct iovec *iov, int offset, int nob)
{
/* active if I'm sending */
}
int
-kibnal_send(ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int payload_niov,
- struct iovec *payload_iov,
- lnet_kiov_t *payload_kiov,
- unsigned int payload_offset,
- unsigned int payload_nob)
+kibnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- kib_msg_t *ibmsg;
- kib_tx_t *tx;
- int nob;
- int rc;
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ int type = lntmsg->msg_type;
+ lnet_process_id_t target = lntmsg->msg_target;
+ int target_is_router = lntmsg->msg_target_is_router;
+ int routing = lntmsg->msg_routing;
+ unsigned int payload_niov = lntmsg->msg_niov;
+ struct iovec *payload_iov = lntmsg->msg_iov;
+ lnet_kiov_t *payload_kiov = lntmsg->msg_kiov;
+ unsigned int payload_offset = lntmsg->msg_offset;
+ unsigned int payload_nob = lntmsg->msg_len;
+ kib_msg_t *ibmsg;
+ kib_tx_t *tx;
+ int nob;
+ int rc;
/* NB 'private' is different depending on what we're sending.... */
LBUG();
return (-EIO);
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
LASSERT (payload_nob == 0);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
if (routing || target_is_router)
break; /* send IMMEDIATE */
/* is the REPLY message too small for RDMA? */
- nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[ptlmsg->msg_md->md_length]);
+ nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[lntmsg->msg_md->md_length]);
if (nob <= IBNAL_MSG_SIZE)
break; /* send IMMEDIATE */
ibmsg->ibm_u.get.ibgm_hdr = *hdr;
ibmsg->ibm_u.get.ibgm_cookie = tx->tx_cookie;
- if ((ptlmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
+ if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
rc = kibnal_setup_rd_iov(tx, &ibmsg->ibm_u.get.ibgm_rd,
vv_acc_r_mem_write,
- ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.iov,
- 0, ptlmsg->msg_md->md_length);
+ lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.iov,
+ 0, lntmsg->msg_md->md_length);
else
rc = kibnal_setup_rd_kiov(tx, &ibmsg->ibm_u.get.ibgm_rd,
vv_acc_r_mem_write,
- ptlmsg->msg_md->md_niov,
- ptlmsg->msg_md->md_iov.kiov,
- 0, ptlmsg->msg_md->md_length);
+ lntmsg->msg_md->md_niov,
+ lntmsg->msg_md->md_iov.kiov,
+ 0, lntmsg->msg_md->md_length);
if (rc != 0) {
CERROR("Can't setup GET sink for %s: %d\n",
libcfs_nid2str(target.nid), rc);
#endif
kibnal_init_tx_msg(tx, IBNAL_MSG_GET_REQ, nob);
- tx->tx_ptlmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
- target.nid, ptlmsg);
- if (tx->tx_ptlmsg[1] == NULL) {
+ tx->tx_lntmsg[1] = lnet_create_reply_msg(kibnal_data.kib_ni,
+ lntmsg);
+ if (tx->tx_lntmsg[1] == NULL) {
CERROR("Can't create reply for GET -> %s\n",
libcfs_nid2str(target.nid));
kibnal_tx_done(tx);
return -EIO;
}
- tx->tx_ptlmsg[0] = ptlmsg; /* finalise ptlmsg[0,1] on completion */
+ tx->tx_lntmsg[0] = lntmsg; /* finalise lntmsg[0,1] on completion */
tx->tx_waiting = 1; /* waiting for GET_DONE */
kibnal_launch_tx(tx, target.nid);
return 0;
- case PTL_MSG_REPLY: {
+ case LNET_MSG_REPLY: {
/* reply's 'private' is the incoming receive */
kib_rx_t *rx = private;
} else if (rc == 0) {
/* No RDMA: local completion may happen now! */
lnet_finalize (kibnal_data.kib_ni, NULL,
- ptlmsg, 0);
+ lntmsg, 0);
} else {
- /* RDMA: lnet_finalize(ptlmsg) when it
+ /* RDMA: lnet_finalize(lntmsg) when it
* completes */
- tx->tx_ptlmsg[0] = ptlmsg;
+ tx->tx_lntmsg[0] = lntmsg;
}
kibnal_queue_tx(tx, rx->rx_conn);
/* fall through to handle like PUT */
}
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
/* Is the payload small enough not to need RDMA? */
nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[payload_nob]);
if (nob <= IBNAL_MSG_SIZE)
break; /* send IMMEDIATE */
/* may block if caller is app thread */
- tx = kibnal_get_idle_tx(!(routing || type == PTL_MSG_REPLY));
+ tx = kibnal_get_idle_tx(!(routing || type == LNET_MSG_REPLY));
if (tx == NULL) {
CERROR("Can't allocate %s txd for %s\n",
- type == PTL_MSG_PUT ? "PUT" : "REPLY",
+ type == LNET_MSG_PUT ? "PUT" : "REPLY",
libcfs_nid2str(target.nid));
return -ENOMEM;
}
ibmsg->ibm_u.putreq.ibprm_cookie = tx->tx_cookie;
kibnal_init_tx_msg(tx, IBNAL_MSG_PUT_REQ, sizeof(kib_putreq_msg_t));
- tx->tx_ptlmsg[0] = ptlmsg; /* finalise ptlmsg on completion */
+ tx->tx_lntmsg[0] = lntmsg; /* finalise lntmsg on completion */
tx->tx_waiting = 1; /* waiting for PUT_{ACK,NAK} */
kibnal_launch_tx(tx, target.nid);
return 0;
<= IBNAL_MSG_SIZE);
tx = kibnal_get_idle_tx(!(routing ||
- type == PTL_MSG_ACK ||
- type == PTL_MSG_REPLY));
+ type == LNET_MSG_ACK ||
+ type == LNET_MSG_REPLY));
if (tx == NULL) {
CERROR ("Can't send %d to %s: tx descs exhausted\n",
type, libcfs_nid2str(target.nid));
ibmsg = tx->tx_msg;
ibmsg->ibm_u.immediate.ibim_hdr = *hdr;
- if (payload_nob > 0) {
- if (payload_kiov != NULL)
- lnet_copy_kiov2buf(ibmsg->ibm_u.immediate.ibim_payload,
- payload_niov, payload_kiov,
- payload_offset, payload_nob);
- else
- lnet_copy_iov2buf(ibmsg->ibm_u.immediate.ibim_payload,
- payload_niov, payload_iov,
- payload_offset, payload_nob);
- }
+ if (payload_kiov != NULL)
+ lnet_copy_kiov2flat(IBNAL_MSG_SIZE, ibmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ payload_niov, payload_kiov,
+ payload_offset, payload_nob);
+ else
+ lnet_copy_iov2flat(IBNAL_MSG_SIZE, ibmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ payload_niov, payload_iov,
+ payload_offset, payload_nob);
nob = offsetof(kib_immediate_msg_t, ibim_payload[payload_nob]);
kibnal_init_tx_msg (tx, IBNAL_MSG_IMMEDIATE, nob);
- tx->tx_ptlmsg[0] = ptlmsg; /* finalise ptlmsg on completion */
+ tx->tx_lntmsg[0] = lntmsg; /* finalise lntmsg on completion */
kibnal_launch_tx(tx, target.nid);
return 0;
}
int
-kibnal_recv (ptl_ni_t *ni, void *private, ptl_msg_t *ptlmsg,
+kibnal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
kib_tx_t *tx;
kib_msg_t *txmsg;
int nob;
- int rc;
+ int rc = 0;
LASSERT (mlen <= rlen);
LASSERT (mlen >= 0);
case IBNAL_MSG_IMMEDIATE:
nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]);
- if (nob > IBNAL_MSG_SIZE) {
- CERROR ("Immediate message from %s too big: %d\n",
+ if (nob > rx->rx_nob) {
+ CERROR ("Immediate message from %s too big: %d(%d)\n",
libcfs_nid2str(rxmsg->ibm_u.immediate.ibim_hdr.src_nid),
- rlen);
- return (-EIO);
+ rlen, rx->rx_nob);
+ rc = -EPROTO;
+ break;
}
if (kiov != NULL)
- lnet_copy_buf2kiov(niov, kiov, offset,
- rxmsg->ibm_u.immediate.ibim_payload,
- mlen);
+ lnet_copy_flat2kiov(niov, kiov, offset,
+ IBNAL_MSG_SIZE, rxmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ mlen);
else
- lnet_copy_buf2iov(niov, iov, offset,
- rxmsg->ibm_u.immediate.ibim_payload,
- mlen);
-
- lnet_finalize (ni, NULL, ptlmsg, 0);
- return (0);
+ lnet_copy_flat2iov(niov, iov, offset,
+ IBNAL_MSG_SIZE, rxmsg,
+ offsetof(kib_msg_t, ibm_u.immediate.ibim_payload),
+ mlen);
+ lnet_finalize (ni, NULL, lntmsg, 0);
+ break;
case IBNAL_MSG_PUT_REQ:
- /* NB handle_rx() will send PUT_NAK when I return to it from
- * here, unless I set rx_responded! */
-
- if (mlen == 0) { /* No payload to RDMA */
- lnet_finalize(ni, NULL, ptlmsg, 0);
- return 0;
+ if (mlen == 0) {
+ lnet_finalize(ni, NULL, lntmsg, 0);
+ kibnal_send_completion(rx->rx_conn, IBNAL_MSG_PUT_NAK, 0,
+ rxmsg->ibm_u.putreq.ibprm_cookie);
+ break;
}
-
+
tx = kibnal_get_idle_tx(0);
if (tx == NULL) {
CERROR("Can't allocate tx for %s\n",
libcfs_nid2str(conn->ibc_peer->ibp_nid));
- return -ENOMEM;
+ /* Not replying will break the connection */
+ rc = -ENOMEM;
+ break;
}
txmsg = tx->tx_msg;
CERROR("Can't setup PUT sink for %s: %d\n",
libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
kibnal_tx_done(tx);
- return -EIO;
+ /* tell peer it's over */
+ kibnal_send_completion(rx->rx_conn, IBNAL_MSG_PUT_NAK, rc,
+ rxmsg->ibm_u.putreq.ibprm_cookie);
+ break;
}
txmsg->ibm_u.putack.ibpam_src_cookie = rxmsg->ibm_u.putreq.ibprm_cookie;
#endif
kibnal_init_tx_msg(tx, IBNAL_MSG_PUT_ACK, nob);
- tx->tx_ptlmsg[0] = ptlmsg; /* finalise ptlmsg on completion */
+ tx->tx_lntmsg[0] = lntmsg; /* finalise lntmsg on completion */
tx->tx_waiting = 1; /* waiting for PUT_DONE */
kibnal_queue_tx(tx, conn);
-
- LASSERT (!rx->rx_responded);
- rx->rx_responded = 1;
- return 0;
+ break;
case IBNAL_MSG_GET_REQ:
- /* We get called here just to discard any junk after the
- * GET hdr. */
- LASSERT (ptlmsg == NULL);
- lnet_finalize (ni, NULL, ptlmsg, 0);
- return (0);
+ LASSERT (lntmsg == NULL); /* no need to finalise */
+ if (!rx->rx_responded) {
+ /* GET didn't match anything */
+ kibnal_send_completion(rx->rx_conn, IBNAL_MSG_GET_DONE,
+ -ENODATA,
+ rxmsg->ibm_u.get.ibgm_cookie);
+ }
+ break;
}
+
+ kibnal_post_rx(rx, 1);
+ return rc;
}
int
typedef struct
{
- ptl_hdr_t ibim_hdr; /* portals header */
+ lnet_hdr_t ibim_hdr; /* portals header */
char ibim_payload[0]; /* piggy-backed payload */
} WIRE_ATTR kib_immediate_msg_t;
typedef struct
{
- ptl_hdr_t ibprm_hdr; /* portals header */
+ lnet_hdr_t ibprm_hdr; /* portals header */
__u64 ibprm_cookie; /* opaque completion cookie */
} WIRE_ATTR kib_putreq_msg_t;
typedef struct
{
- ptl_hdr_t ibgm_hdr; /* portals header */
+ lnet_hdr_t ibgm_hdr; /* portals header */
__u64 ibgm_cookie; /* opaque completion cookie */
kib_rdma_desc_t ibgm_rd; /* rdma descriptor */
} WIRE_ATTR kib_get_msg_t;
* between getting its string and using it.
*/
-#define PTL_NIDSTR_COUNT 128 /* # of nidstrings */
-#define PTL_NIDSTR_SIZE 32 /* size of each one (see below for usage) */
+#define LNET_NIDSTR_COUNT 128 /* # of nidstrings */
+#define LNET_NIDSTR_SIZE 32 /* size of each one (see below for usage) */
-static char libcfs_nidstrings[PTL_NIDSTR_COUNT][PTL_NIDSTR_SIZE];
+static char libcfs_nidstrings[LNET_NIDSTR_COUNT][LNET_NIDSTR_SIZE];
static int libcfs_nidstring_idx = 0;
#ifdef __KERNEL__
static void libcfs_num_addr2str(__u32 addr, char *str);
static int libcfs_num_str2addr(char *str, int nob, __u32 *addr);
-struct nalstrfns {
- int nf_nal;
+struct netstrfns {
+ int nf_lnd;
char *nf_name;
char *nf_modname;
void (*nf_addr2str)(__u32 addr, char *str);
int (*nf_str2addr)(char *str, int nob, __u32 *addr);
};
-static struct nalstrfns libcfs_nalstrfns[] = {
- {.nf_nal = LONAL,
+static struct netstrfns libcfs_netstrfns[] = {
+ {.nf_lnd = LOLND,
.nf_name = "lo",
.nf_modname = "klolnd",
.nf_addr2str = libcfs_num_addr2str,
.nf_str2addr = libcfs_lo_str2addr},
- {.nf_nal = SOCKNAL,
+ {.nf_lnd = SOCKLND,
.nf_name = "tcp",
.nf_modname = "ksocklnd",
.nf_addr2str = libcfs_ip_addr2str,
.nf_str2addr = libcfs_ip_str2addr},
- {.nf_nal = OPENIBNAL,
+ {.nf_lnd = OPENIBLND,
.nf_name = "openib",
.nf_modname = "kopeniblnd",
.nf_addr2str = libcfs_ip_addr2str,
.nf_str2addr = libcfs_ip_str2addr},
- {.nf_nal = IIBNAL,
+ {.nf_lnd = IIBLND,
.nf_name = "iib",
.nf_modname = "kiiblnd",
.nf_addr2str = libcfs_ip_addr2str,
.nf_str2addr = libcfs_ip_str2addr},
- {.nf_nal = VIBNAL,
+ {.nf_lnd = VIBLND,
.nf_name = "vib",
.nf_modname = "kviblnd",
.nf_addr2str = libcfs_ip_addr2str,
.nf_str2addr = libcfs_ip_str2addr},
- {.nf_nal = RANAL,
+ {.nf_lnd = RALND,
.nf_name = "ra",
.nf_modname = "kralnd",
.nf_addr2str = libcfs_ip_addr2str,
.nf_str2addr = libcfs_ip_str2addr},
- {.nf_nal = QSWNAL,
+ {.nf_lnd = QSWLND,
.nf_name = "elan",
.nf_modname = "kqswlnd",
.nf_addr2str = libcfs_num_addr2str,
.nf_str2addr = libcfs_num_str2addr},
- {.nf_nal = GMNAL,
+ {.nf_lnd = GMLND,
.nf_name = "gm",
.nf_modname = "kgmlnd",
.nf_addr2str = libcfs_num_addr2str,
.nf_str2addr = libcfs_num_str2addr},
/* placeholder for net0 alias. It MUST BE THE LAST ENTRY */
- {.nf_nal = -1},
+ {.nf_lnd = -1},
};
-const int libcfs_nnalstrfns = sizeof(libcfs_nalstrfns)/sizeof(libcfs_nalstrfns[0]);
+const int libcfs_nnetstrfns = sizeof(libcfs_netstrfns)/sizeof(libcfs_netstrfns[0]);
int
libcfs_lo_str2addr(char *str, int nob, __u32 *addr)
struct hostent *he = gethostbyaddr(&netip, sizeof(netip), AF_INET);
if (he != NULL) {
- snprintf(str, PTL_NIDSTR_SIZE, "%s", he->h_name);
+ snprintf(str, LNET_NIDSTR_SIZE, "%s", he->h_name);
return;
}
#endif
- snprintf(str, PTL_NIDSTR_SIZE, "%u.%u.%u.%u",
+ snprintf(str, LNET_NIDSTR_SIZE, "%u.%u.%u.%u",
(addr >> 24) & 0xff, (addr >> 16) & 0xff,
(addr >> 8) & 0xff, addr & 0xff);
}
void
libcfs_num_addr2str(__u32 addr, char *str)
{
- snprintf(str, PTL_NIDSTR_SIZE, "%u", addr);
+ snprintf(str, LNET_NIDSTR_SIZE, "%u", addr);
}
int
return 1;
}
-struct nalstrfns *
-libcfs_nal2nalstrfns(int nal)
+struct netstrfns *
+libcfs_lnd2netstrfns(int lnd)
{
int i;
- if (nal >= 0)
- for (i = 0; i < libcfs_nnalstrfns; i++)
- if (nal == libcfs_nalstrfns[i].nf_nal)
- return &libcfs_nalstrfns[i];
+ if (lnd >= 0)
+ for (i = 0; i < libcfs_nnetstrfns; i++)
+ if (lnd == libcfs_netstrfns[i].nf_lnd)
+ return &libcfs_netstrfns[i];
return NULL;
}
-struct nalstrfns *
-libcfs_name2nalstrfns(char *name)
+struct netstrfns *
+libcfs_name2netstrfns(char *name)
{
int i;
- for (i = 0; i < libcfs_nnalstrfns; i++)
- if (libcfs_nalstrfns[i].nf_nal >= 0 &&
- !strcmp(libcfs_nalstrfns[i].nf_name, name))
- return &libcfs_nalstrfns[i];
+ for (i = 0; i < libcfs_nnetstrfns; i++)
+ if (libcfs_netstrfns[i].nf_lnd >= 0 &&
+ !strcmp(libcfs_netstrfns[i].nf_name, name))
+ return &libcfs_netstrfns[i];
return NULL;
}
int
-libcfs_isknown_nal(int nal)
+libcfs_isknown_lnd(int type)
{
- return libcfs_nal2nalstrfns(nal) != NULL;
+ return libcfs_lnd2netstrfns(type) != NULL;
}
char *
-libcfs_nal2modname(int nal)
+libcfs_lnd2modname(int lnd)
{
- struct nalstrfns *nf = libcfs_nal2nalstrfns(nal);
+ struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
return (nf == NULL) ? NULL : nf->nf_modname;
}
char *
-libcfs_nal2str(int nal)
+libcfs_lnd2str(int lnd)
{
char *str;
- struct nalstrfns *nf = libcfs_nal2nalstrfns(nal);
+ struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
if (nf != NULL)
return nf->nf_name;
str = libcfs_next_nidstring();
- snprintf(str, PTL_NIDSTR_SIZE, "?%u?", nal);
+ snprintf(str, LNET_NIDSTR_SIZE, "?%u?", lnd);
return str;
}
int
-libcfs_str2nal(char *str)
+libcfs_str2lnd(char *str)
{
- struct nalstrfns *nf = libcfs_name2nalstrfns(str);
+ struct netstrfns *nf = libcfs_name2netstrfns(str);
if (nf != NULL)
- return nf->nf_nal;
+ return nf->nf_lnd;
return -1;
}
char *
libcfs_net2str(__u32 net)
{
- int nal = PTL_NETNAL(net);
+ int lnd = PTL_NETTYP(net);
int num = PTL_NETNUM(net);
- struct nalstrfns *nf = libcfs_nal2nalstrfns(nal);
+ struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
char *str = libcfs_next_nidstring();
if (nf == NULL)
- snprintf(str, PTL_NIDSTR_SIZE, "<%u:%u>", nal, num);
+ snprintf(str, LNET_NIDSTR_SIZE, "<%u:%u>", lnd, num);
else if (num == 0)
- snprintf(str, PTL_NIDSTR_SIZE, "%s", nf->nf_name);
+ snprintf(str, LNET_NIDSTR_SIZE, "%s", nf->nf_name);
else
- snprintf(str, PTL_NIDSTR_SIZE, "%s%u", nf->nf_name, num);
+ snprintf(str, LNET_NIDSTR_SIZE, "%s%u", nf->nf_name, num);
return str;
}
char *
libcfs_nid2str(lnet_nid_t nid)
{
- __u32 addr = PTL_NIDADDR(nid);
- __u32 net = PTL_NIDNET(nid);
- int nal = PTL_NETNAL(net);
- int nnum = PTL_NETNUM(net);
- struct nalstrfns *nf;
- char *str;
- int nob;
+ __u32 addr = PTL_NIDADDR(nid);
+ __u32 net = PTL_NIDNET(nid);
+ int lnd = PTL_NETTYP(net);
+ int nnum = PTL_NETNUM(net);
+ struct netstrfns *nf;
+ char *str;
+ int nob;
if (nid == LNET_NID_ANY)
return "LNET_NID_ANY";
- nf = libcfs_nal2nalstrfns(PTL_NETNAL(net));
+ nf = libcfs_lnd2netstrfns(PTL_NETTYP(net));
str = libcfs_next_nidstring();
if (nf == NULL)
- snprintf(str, PTL_NIDSTR_SIZE, "%x@<%u:%u>", addr, nal, nnum);
+ snprintf(str, LNET_NIDSTR_SIZE, "%x@<%u:%u>", addr, lnd, nnum);
else {
nf->nf_addr2str(addr, str);
nob = strlen(str);
if (nnum == 0)
- snprintf(str + nob, PTL_NIDSTR_SIZE - nob, "@%s",
+ snprintf(str + nob, LNET_NIDSTR_SIZE - nob, "@%s",
nf->nf_name);
else
- snprintf(str + nob, PTL_NIDSTR_SIZE - nob, "@%s%u",
+ snprintf(str + nob, LNET_NIDSTR_SIZE - nob, "@%s%u",
nf->nf_name, nnum);
}
return str;
}
-static struct nalstrfns *
-libcfs_str2net_internal(char *str, __u32 *net)
+static struct netstrfns *
+libcfs_str2net_interlnd(char *str, __u32 *net)
{
- struct nalstrfns *nf;
+ struct netstrfns *nf;
int nob;
int netnum;
unsigned int i;
- for (i = 0; i < libcfs_nnalstrfns; i++) {
- nf = &libcfs_nalstrfns[i];
+ for (i = 0; i < libcfs_nnetstrfns; i++) {
+ nf = &libcfs_netstrfns[i];
if (!strncmp(str, nf->nf_name, strlen(nf->nf_name)))
break;
}
- if (i == libcfs_nnalstrfns)
+ if (i == libcfs_nnetstrfns)
return NULL;
nob = strlen(nf->nf_name);
if (strlen(str) == nob) {
netnum = 0;
} else {
- if (nf->nf_nal == LONAL) /* net number not allowed */
+ if (nf->nf_lnd == LOLND) /* net number not allowed */
return NULL;
str += nob;
return NULL;
}
- *net = PTL_MKNET(nf->nf_nal, netnum);
+ *net = PTL_MKNET(nf->nf_lnd, netnum);
return nf;
}
{
__u32 net;
- if (libcfs_str2net_internal(str, &net) != NULL)
+ if (libcfs_str2net_interlnd(str, &net) != NULL)
return net;
return PTL_NIDNET(LNET_NID_ANY);
libcfs_str2nid(char *str)
{
char *sep = strchr(str, '@');
- struct nalstrfns *nf;
+ struct netstrfns *nf;
__u32 net;
__u32 addr;
if (sep != NULL) {
- nf = libcfs_str2net_internal(sep + 1, &net);
+ nf = libcfs_str2net_interlnd(sep + 1, &net);
if (nf == NULL)
return LNET_NID_ANY;
} else {
sep = str + strlen(str);
- net = PTL_MKNET(SOCKNAL, 0);
- nf = libcfs_nal2nalstrfns(SOCKNAL);
+ net = PTL_MKNET(SOCKLND, 0);
+ nf = libcfs_lnd2netstrfns(SOCKLND);
LASSERT (nf != NULL);
}
{
char *str = libcfs_next_nidstring();
- snprintf(str, PTL_NIDSTR_SIZE, "%s%u-%s",
+ snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
((id.pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
(id.pid & ~LNET_PID_USERFLAG), libcfs_nid2str(id.nid));
return str;
#ifdef __KERNEL__
void
-libcfs_setnet0alias(int nal)
+libcfs_setnet0alias(int lnd)
{
- struct nalstrfns *nf = libcfs_nal2nalstrfns(nal);
- struct nalstrfns *nf0 = &libcfs_nalstrfns[libcfs_nnalstrfns - 1];
+ struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
+ struct netstrfns *nf0 = &libcfs_netstrfns[libcfs_nnetstrfns - 1];
/* Ghastly hack to allow LNET to inter-operate with portals.
* NET type 0 becomes an alias for whatever local network we have, and
* this assignment here means we can parse and print its NIDs */
LASSERT (nf != NULL);
- LASSERT (nf0->nf_nal < 0);
+ LASSERT (nf0->nf_lnd < 0);
nf0->nf_name = "zero";//nf->nf_name;
nf0->nf_modname = nf->nf_modname;
nf0->nf_addr2str = nf->nf_addr2str;
nf0->nf_str2addr = nf->nf_str2addr;
mb();
- nf0->nf_nal = 0;
+ nf0->nf_lnd = 0;
}
-EXPORT_SYMBOL(libcfs_isknown_nal);
-EXPORT_SYMBOL(libcfs_nal2modname);
-EXPORT_SYMBOL(libcfs_nal2str);
-EXPORT_SYMBOL(libcfs_str2nal);
+EXPORT_SYMBOL(libcfs_isknown_lnd);
+EXPORT_SYMBOL(libcfs_lnd2modname);
+EXPORT_SYMBOL(libcfs_lnd2str);
+EXPORT_SYMBOL(libcfs_str2lnd);
EXPORT_SYMBOL(libcfs_net2str);
EXPORT_SYMBOL(libcfs_nid2str);
EXPORT_SYMBOL(libcfs_str2net);
EXPORT_SYMBOL(libcfs_setnet0alias);
#else /* __KERNEL__ */
void
-libcfs_setnet0alias(int nal)
+libcfs_setnet0alias(int lnd)
{
LCONSOLE_ERROR("Liblustre cannot interoperate with old Portals.\n"
"portals_compatibility must be set to 'none'.\n");
CFS_MODULE_PARM(accept_timeout, "i", int, 0644,
"Acceptor's timeout (seconds)");
-static int accept_proto_version = PTL_PROTO_ACCEPTOR_VERSION;
+static int accept_proto_version = LNET_PROTO_ACCEPTOR_VERSION;
CFS_MODULE_PARM(accept_proto_version, "i", int, 0444,
"Acceptor protocol version (outgoing connection requests)");
CLASSERT (sizeof(cr) <= 16); /* not too big to be on the stack */
- for (port = PTL_ACCEPTOR_MAX_RESERVED_PORT;
- port >= PTL_ACCEPTOR_MIN_RESERVED_PORT;
+ for (port = LNET_ACCEPTOR_MAX_RESERVED_PORT;
+ port >= LNET_ACCEPTOR_MIN_RESERVED_PORT;
--port) {
/* Iterate through reserved ports. */
goto failed_sock;
}
- CLASSERT (PTL_PROTO_ACCEPTOR_VERSION == 1);
+ CLASSERT (LNET_PROTO_ACCEPTOR_VERSION == 1);
- if (accept_proto_version == PTL_PROTO_ACCEPTOR_VERSION) {
+ if (accept_proto_version == LNET_PROTO_ACCEPTOR_VERSION) {
- LASSERT (lnet_apini.apini_ptlcompat < 2); /* no portals peers */
+ LASSERT (the_lnet.ln_ptlcompat < 2); /* no portals peers */
- cr.acr_magic = PTL_PROTO_ACCEPTOR_MAGIC;
- cr.acr_version = PTL_PROTO_ACCEPTOR_VERSION;
+ cr.acr_magic = LNET_PROTO_ACCEPTOR_MAGIC;
+ cr.acr_version = LNET_PROTO_ACCEPTOR_VERSION;
cr.acr_nid = peer_nid;
rc = libcfs_sock_write(sock, &cr, sizeof(cr), 0);
}
int
-lnet_accept(ptl_ni_t *blind_ni, struct socket *sock, __u32 magic)
+lnet_accept(lnet_ni_t *blind_ni, struct socket *sock, __u32 magic)
{
lnet_acceptor_connreq_t cr;
__u32 peer_ip;
int peer_port;
int rc;
int flip;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
char *str;
/* CAVEAT EMPTOR: I may be called by a NAL in any thread's context if I
rc = libcfs_sock_getaddr(sock, 1, &peer_ip, &peer_port);
LASSERT (rc == 0); /* we succeeded before */
- if (!lnet_accept_magic(magic, PTL_PROTO_ACCEPTOR_MAGIC)) {
+ if (!lnet_accept_magic(magic, LNET_PROTO_ACCEPTOR_MAGIC)) {
- if (magic == le32_to_cpu(PTL_PROTO_TCP_MAGIC))
+ if (magic == le32_to_cpu(LNET_PROTO_TCP_MAGIC))
str = "'old' socknal/tcpnal";
- else if (lnet_accept_magic(magic, PTL_PROTO_RA_MAGIC))
+ else if (lnet_accept_magic(magic, LNET_PROTO_RA_MAGIC))
str = "'old' ranal";
- else if (lnet_accept_magic(magic, PTL_PROTO_OPENIB_MAGIC))
+ else if (lnet_accept_magic(magic, LNET_PROTO_OPENIB_MAGIC))
str = "'old' openibnal";
else
str = "unrecognised";
return -EPROTO;
}
- flip = magic != PTL_PROTO_ACCEPTOR_MAGIC;
+ flip = magic != LNET_PROTO_ACCEPTOR_MAGIC;
/* FTTB, we only have 1 acceptor protocol version. When this changes,
* we'll have to read the version number first before we know how much
__swab64s(&cr.acr_nid);
}
- if (cr.acr_version != PTL_PROTO_ACCEPTOR_VERSION) {
+ if (cr.acr_version != LNET_PROTO_ACCEPTOR_VERSION) {
LCONSOLE_ERROR("Refusing connection from %u.%u.%u.%u: "
" unrecognised protocol version %d\n",
HIPQUAD(peer_ip), cr.acr_version);
if (ni == NULL || /* no matching net */
ni->ni_nid != cr.acr_nid) /* right NET, but wrong NID! */ {
if (ni != NULL)
- ptl_ni_decref(ni);
+ lnet_ni_decref(ni);
LCONSOLE_ERROR("Refusing connection from %u.%u.%u.%u for %s: "
" No matching NI\n",
HIPQUAD(peer_ip), libcfs_nid2str(cr.acr_nid));
return -EPERM;
}
- if (ni->ni_nal->nal_accept == NULL) {
- ptl_ni_decref(ni);
+ if (ni->ni_lnd->lnd_accept == NULL) {
+ lnet_ni_decref(ni);
LCONSOLE_ERROR("Refusing connection from %u.%u.%u.%u for %s: "
" NI doesn not accept IP connections\n",
HIPQUAD(peer_ip), libcfs_nid2str(cr.acr_nid));
blind_ni == NULL ? "" : " (blind)");
if (blind_ni == NULL) {
- rc = ni->ni_nal->nal_accept(ni, sock);
+ rc = ni->ni_lnd->lnd_accept(ni, sock);
if (rc != 0)
CERROR("NI %s refused connection from %u.%u.%u.%u\n",
libcfs_nid2str(ni->ni_nid), HIPQUAD(peer_ip));
rc = 0;
}
- ptl_ni_decref(ni);
+ lnet_ni_decref(ni);
return rc;
}
EXPORT_SYMBOL(lnet_accept);
__u32 magic;
__u32 peer_ip;
int peer_port;
- ptl_ni_t *blind_ni;
+ lnet_ni_t *blind_ni;
int secure = (int)((unsigned long)arg);
LASSERT (lnet_acceptor_state.pta_sock == NULL);
* connections "blind". Otherwise I'll have to read the bytestream to
* see which NI the connection is for. NB I don't get to run at all if
* there are 0 acceptor_nis... */
- n_acceptor_nis = ptl_count_acceptor_nis(&blind_ni);
+ n_acceptor_nis = lnet_count_acceptor_nis(&blind_ni);
LASSERT (n_acceptor_nis > 0);
if (n_acceptor_nis > 1) {
- ptl_ni_decref(blind_ni);
+ lnet_ni_decref(blind_ni);
blind_ni = NULL;
}
goto failed;
}
- if (secure && peer_port > PTL_ACCEPTOR_MAX_RESERVED_PORT) {
+ if (secure && peer_port > LNET_ACCEPTOR_MAX_RESERVED_PORT) {
CERROR("Refusing connection from %u.%u.%u.%u: "
"insecure port %d\n",
HIPQUAD(peer_ip), peer_port);
}
if (blind_ni != NULL) {
- rc = blind_ni->ni_nal->nal_accept(blind_ni, newsock);
+ rc = blind_ni->ni_lnd->lnd_accept(blind_ni, newsock);
if (rc != 0) {
CERROR("NI %s refused 'blind' connection from "
"%u.%u.%u.%u\n",
lnet_acceptor_state.pta_sock = NULL;
if (blind_ni != NULL)
- ptl_ni_decref(blind_ni);
+ lnet_ni_decref(blind_ni);
LCONSOLE(0,"Acceptor stopping\n");
/* If we're talking to any portals (pre-LNET) nodes we force the old
* acceptor protocol on outgoing connections */
- if (lnet_apini.apini_ptlcompat > 1)
+ if (the_lnet.ln_ptlcompat > 1)
accept_proto_version = 0;
LASSERT (lnet_acceptor_state.pta_sock == NULL);
return -EINVAL;
}
- if (ptl_count_acceptor_nis(NULL) == 0) /* not required */
+ if (lnet_count_acceptor_nis(NULL) == 0) /* not required */
return 0;
pid = cfs_kernel_thread(lnet_acceptor, (void *)secure, 0);
CFS_MODULE_PARM(portals_compatibility, "s", charp, 0444,
"wire protocol compatibility: 'strong'|'weak'|'none'");
-lnet_apini_t lnet_apini; /* THE network interface (at the API) */
+lnet_t the_lnet; /* THE state of the network */
-void ptl_assert_wire_constants (void)
+void lnet_assert_wire_constants (void)
{
/* Wire protocol assertions generated by 'wirecheck'
* running on Linux robert.bartonsoftware.com 2.6.8-1.521
* with gcc version 3.3.3 20040412 (Red Hat Linux 3.3.3-7) */
/* Constants... */
- CLASSERT (PTL_PROTO_TCP_MAGIC == 0xeebc0ded);
- CLASSERT (PTL_PROTO_TCP_VERSION_MAJOR == 1);
- CLASSERT (PTL_PROTO_TCP_VERSION_MINOR == 0);
- CLASSERT (PTL_MSG_ACK == 0);
- CLASSERT (PTL_MSG_PUT == 1);
- CLASSERT (PTL_MSG_GET == 2);
- CLASSERT (PTL_MSG_REPLY == 3);
- CLASSERT (PTL_MSG_HELLO == 4);
+ CLASSERT (LNET_PROTO_TCP_MAGIC == 0xeebc0ded);
+ CLASSERT (LNET_PROTO_TCP_VERSION_MAJOR == 1);
+ CLASSERT (LNET_PROTO_TCP_VERSION_MINOR == 0);
+ CLASSERT (LNET_MSG_ACK == 0);
+ CLASSERT (LNET_MSG_PUT == 1);
+ CLASSERT (LNET_MSG_GET == 2);
+ CLASSERT (LNET_MSG_REPLY == 3);
+ CLASSERT (LNET_MSG_HELLO == 4);
/* Checks for struct ptl_handle_wire_t */
- CLASSERT ((int)sizeof(ptl_handle_wire_t) == 16);
- CLASSERT ((int)offsetof(ptl_handle_wire_t, wh_interface_cookie) == 0);
- CLASSERT ((int)sizeof(((ptl_handle_wire_t *)0)->wh_interface_cookie) == 8);
- CLASSERT ((int)offsetof(ptl_handle_wire_t, wh_object_cookie) == 8);
- CLASSERT ((int)sizeof(((ptl_handle_wire_t *)0)->wh_object_cookie) == 8);
-
- /* Checks for struct ptl_magicversion_t */
- CLASSERT ((int)sizeof(ptl_magicversion_t) == 8);
- CLASSERT ((int)offsetof(ptl_magicversion_t, magic) == 0);
- CLASSERT ((int)sizeof(((ptl_magicversion_t *)0)->magic) == 4);
- CLASSERT ((int)offsetof(ptl_magicversion_t, version_major) == 4);
- CLASSERT ((int)sizeof(((ptl_magicversion_t *)0)->version_major) == 2);
- CLASSERT ((int)offsetof(ptl_magicversion_t, version_minor) == 6);
- CLASSERT ((int)sizeof(((ptl_magicversion_t *)0)->version_minor) == 2);
-
- /* Checks for struct ptl_hdr_t */
- CLASSERT ((int)sizeof(ptl_hdr_t) == 72);
- CLASSERT ((int)offsetof(ptl_hdr_t, dest_nid) == 0);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->dest_nid) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, src_nid) == 8);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->src_nid) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, dest_pid) == 16);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->dest_pid) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, src_pid) == 20);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->src_pid) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, type) == 24);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->type) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, payload_length) == 28);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->payload_length) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg) == 32);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg) == 40);
+ CLASSERT ((int)sizeof(lnet_handle_wire_t) == 16);
+ CLASSERT ((int)offsetof(lnet_handle_wire_t, wh_interface_cookie) == 0);
+ CLASSERT ((int)sizeof(((lnet_handle_wire_t *)0)->wh_interface_cookie) == 8);
+ CLASSERT ((int)offsetof(lnet_handle_wire_t, wh_object_cookie) == 8);
+ CLASSERT ((int)sizeof(((lnet_handle_wire_t *)0)->wh_object_cookie) == 8);
+
+ /* Checks for struct lnet_magicversion_t */
+ CLASSERT ((int)sizeof(lnet_magicversion_t) == 8);
+ CLASSERT ((int)offsetof(lnet_magicversion_t, magic) == 0);
+ CLASSERT ((int)sizeof(((lnet_magicversion_t *)0)->magic) == 4);
+ CLASSERT ((int)offsetof(lnet_magicversion_t, version_major) == 4);
+ CLASSERT ((int)sizeof(((lnet_magicversion_t *)0)->version_major) == 2);
+ CLASSERT ((int)offsetof(lnet_magicversion_t, version_minor) == 6);
+ CLASSERT ((int)sizeof(((lnet_magicversion_t *)0)->version_minor) == 2);
+
+ /* Checks for struct lnet_hdr_t */
+ CLASSERT ((int)sizeof(lnet_hdr_t) == 72);
+ CLASSERT ((int)offsetof(lnet_hdr_t, dest_nid) == 0);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->dest_nid) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, src_nid) == 8);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->src_nid) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, dest_pid) == 16);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->dest_pid) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, src_pid) == 20);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->src_pid) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, type) == 24);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->type) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, payload_length) == 28);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->payload_length) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg) == 32);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg) == 40);
/* Ack */
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.ack.dst_wmd) == 32);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.ack.dst_wmd) == 16);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.ack.match_bits) == 48);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.ack.match_bits) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.ack.mlength) == 56);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.ack.mlength) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.ack.dst_wmd) == 32);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.ack.dst_wmd) == 16);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.ack.match_bits) == 48);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.ack.match_bits) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.ack.mlength) == 56);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.ack.mlength) == 4);
/* Put */
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.put.ack_wmd) == 32);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.put.ack_wmd) == 16);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.put.match_bits) == 48);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.put.match_bits) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.put.hdr_data) == 56);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.put.hdr_data) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.put.ptl_index) == 64);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.put.ptl_index) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.put.offset) == 68);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.put.offset) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.put.ack_wmd) == 32);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.put.ack_wmd) == 16);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.put.match_bits) == 48);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.put.match_bits) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.put.hdr_data) == 56);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.put.hdr_data) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.put.ptl_index) == 64);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.put.ptl_index) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.put.offset) == 68);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.put.offset) == 4);
/* Get */
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.get.return_wmd) == 32);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.get.return_wmd) == 16);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.get.match_bits) == 48);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.get.match_bits) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.get.ptl_index) == 56);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.get.ptl_index) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.get.src_offset) == 60);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.get.src_offset) == 4);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.get.sink_length) == 64);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.get.sink_length) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.get.return_wmd) == 32);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.get.return_wmd) == 16);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.get.match_bits) == 48);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.get.match_bits) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.get.ptl_index) == 56);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.get.ptl_index) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.get.src_offset) == 60);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.get.src_offset) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.get.sink_length) == 64);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.get.sink_length) == 4);
/* Reply */
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.reply.dst_wmd) == 32);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.reply.dst_wmd) == 16);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.reply.dst_wmd) == 32);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.reply.dst_wmd) == 16);
/* Hello */
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.hello.incarnation) == 32);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.hello.incarnation) == 8);
- CLASSERT ((int)offsetof(ptl_hdr_t, msg.hello.type) == 40);
- CLASSERT ((int)sizeof(((ptl_hdr_t *)0)->msg.hello.type) == 4);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.hello.incarnation) == 32);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.hello.incarnation) == 8);
+ CLASSERT ((int)offsetof(lnet_hdr_t, msg.hello.type) == 40);
+ CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.hello.type) == 4);
}
-ptl_nal_t *
-ptl_find_nal_by_type (int type)
+lnd_t *
+lnet_find_lnd_by_type (int type)
{
- ptl_nal_t *nal;
+ lnd_t *lnd;
struct list_head *tmp;
- /* holding nal mutex */
- list_for_each (tmp, &lnet_apini.apini_nals) {
- nal = list_entry(tmp, ptl_nal_t, nal_list);
+ /* holding lnd mutex */
+ list_for_each (tmp, &the_lnet.ln_lnds) {
+ lnd = list_entry(tmp, lnd_t, lnd_list);
- if (nal->nal_type == type)
- return nal;
+ if (lnd->lnd_type == type)
+ return lnd;
}
return NULL;
}
void
-lnet_register_nal (ptl_nal_t *nal)
+lnet_register_lnd (lnd_t *lnd)
{
- PTL_MUTEX_DOWN(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_lnd_mutex);
- LASSERT (lnet_apini.apini_init);
- LASSERT (libcfs_isknown_nal(nal->nal_type));
- LASSERT (ptl_find_nal_by_type(nal->nal_type) == NULL);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (libcfs_isknown_lnd(lnd->lnd_type));
+ LASSERT (lnet_find_lnd_by_type(lnd->lnd_type) == NULL);
- list_add (&nal->nal_list, &lnet_apini.apini_nals);
- nal->nal_refcount = 0;
+ list_add (&lnd->lnd_list, &the_lnet.ln_lnds);
+ lnd->lnd_refcount = 0;
- if (nal->nal_type != LONAL)
+ if (lnd->lnd_type != LOLND)
LCONSOLE(0, "%s LND registered\n",
- libcfs_nal2str(nal->nal_type));
+ libcfs_lnd2str(lnd->lnd_type));
- PTL_MUTEX_UP(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_UP(&the_lnet.ln_lnd_mutex);
}
void
-lnet_unregister_nal (ptl_nal_t *nal)
+lnet_unregister_lnd (lnd_t *lnd)
{
- PTL_MUTEX_DOWN(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_lnd_mutex);
- LASSERT (lnet_apini.apini_init);
- LASSERT (ptl_find_nal_by_type(nal->nal_type) == nal);
- LASSERT (nal->nal_refcount == 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (lnet_find_lnd_by_type(lnd->lnd_type) == lnd);
+ LASSERT (lnd->lnd_refcount == 0);
- list_del (&nal->nal_list);
- if (nal->nal_type != LONAL)
+ list_del (&lnd->lnd_list);
+ if (lnd->lnd_type != LOLND)
LCONSOLE(0, "%s LND unregistered\n",
- libcfs_nal2str(nal->nal_type));
+ libcfs_lnd2str(lnd->lnd_type));
- PTL_MUTEX_UP(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_UP(&the_lnet.ln_lnd_mutex);
}
-#ifndef PTL_USE_LIB_FREELIST
+#ifndef LNET_USE_LIB_FREELIST
int
-ptl_descriptor_setup (void)
+lnet_descriptor_setup (void)
{
return 0;
}
void
-ptl_descriptor_cleanup (void)
+lnet_descriptor_cleanup (void)
{
}
#else
int
-ptl_freelist_init (ptl_freelist_t *fl, int n, int size)
+lnet_freelist_init (lnet_freelist_t *fl, int n, int size)
{
char *space;
LASSERT (n > 0);
- size += offsetof (ptl_freeobj_t, fo_contents);
+ size += offsetof (lnet_freeobj_t, fo_contents);
PORTAL_ALLOC(space, n * size);
if (space == NULL)
}
void
-ptl_freelist_fini (ptl_freelist_t *fl)
+lnet_freelist_fini (lnet_freelist_t *fl)
{
struct list_head *el;
int count;
}
int
-ptl_descriptor_setup (void)
+lnet_descriptor_setup (void)
{
- /* NB on failure caller must still call ptl_descriptor_cleanup */
- /* ****** */
+ /* NB on failure caller must still call lnet_descriptor_cleanup */
+ /* ****** */
int rc;
- memset (&lnet_apini.apini_free_mes, 0, sizeof (lnet_apini.apini_free_mes));
- memset (&lnet_apini.apini_free_msgs, 0, sizeof (lnet_apini.apini_free_msgs));
- memset (&lnet_apini.apini_free_mds, 0, sizeof (lnet_apini.apini_free_mds));
- memset (&lnet_apini.apini_free_eqs, 0, sizeof (lnet_apini.apini_free_eqs));
+ memset (&the_lnet.ln_free_mes, 0, sizeof (the_lnet.ln_free_mes));
+ memset (&the_lnet.ln_free_msgs, 0, sizeof (the_lnet.ln_free_msgs));
+ memset (&the_lnet.ln_free_mds, 0, sizeof (the_lnet.ln_free_mds));
+ memset (&the_lnet.ln_free_eqs, 0, sizeof (the_lnet.ln_free_eqs));
- rc = ptl_freelist_init (&lnet_apini.apini_free_mes,
- MAX_MES, sizeof (ptl_me_t));
+ rc = lnet_freelist_init(&the_lnet.ln_free_mes,
+ MAX_MES, sizeof (lnet_me_t));
if (rc != 0)
return (rc);
- rc = ptl_freelist_init (&lnet_apini.apini_free_msgs,
- MAX_MSGS, sizeof (ptl_msg_t));
+ rc = lnet_freelist_init(&the_lnet.ln_free_msgs,
+ MAX_MSGS, sizeof (lnet_msg_t));
if (rc != 0)
return (rc);
- rc = ptl_freelist_init (&lnet_apini.apini_free_mds,
- MAX_MDS, sizeof (ptl_libmd_t));
+ rc = lnet_freelist_init(&the_lnet.ln_free_mds,
+ MAX_MDS, sizeof (lnet_libmd_t));
if (rc != 0)
return (rc);
- rc = ptl_freelist_init (&lnet_apini.apini_free_eqs,
- MAX_EQS, sizeof (ptl_eq_t));
+ rc = lnet_freelist_init(&the_lnet.ln_free_eqs,
+ MAX_EQS, sizeof (lnet_eq_t));
return (rc);
}
void
-ptl_descriptor_cleanup (void)
+lnet_descriptor_cleanup (void)
{
- ptl_freelist_fini (&lnet_apini.apini_free_mes);
- ptl_freelist_fini (&lnet_apini.apini_free_msgs);
- ptl_freelist_fini (&lnet_apini.apini_free_mds);
- ptl_freelist_fini (&lnet_apini.apini_free_eqs);
+ lnet_freelist_fini (&the_lnet.ln_free_mes);
+ lnet_freelist_fini (&the_lnet.ln_free_msgs);
+ lnet_freelist_fini (&the_lnet.ln_free_mds);
+ lnet_freelist_fini (&the_lnet.ln_free_eqs);
}
#endif
__u64
-ptl_create_interface_cookie (void)
+lnet_create_interface_cookie (void)
{
/* NB the interface cookie in wire handles guards against delayed
* replies and ACKs appearing valid after reboot. Initialisation time,
}
int
-ptl_setup_handle_hash (void)
+lnet_setup_handle_hash (void)
{
int i;
/* Arbitrary choice of hash table size */
#ifdef __KERNEL__
- lnet_apini.apini_lh_hash_size = PAGE_SIZE / sizeof (struct list_head);
+ the_lnet.ln_lh_hash_size = PAGE_SIZE / sizeof (struct list_head);
#else
- lnet_apini.apini_lh_hash_size = (MAX_MES + MAX_MDS + MAX_EQS)/4;
+ the_lnet.ln_lh_hash_size = (MAX_MES + MAX_MDS + MAX_EQS)/4;
#endif
- PORTAL_ALLOC(lnet_apini.apini_lh_hash_table,
- lnet_apini.apini_lh_hash_size * sizeof (struct list_head));
- if (lnet_apini.apini_lh_hash_table == NULL)
+ PORTAL_ALLOC(the_lnet.ln_lh_hash_table,
+ the_lnet.ln_lh_hash_size * sizeof (struct list_head));
+ if (the_lnet.ln_lh_hash_table == NULL)
return (-ENOMEM);
- for (i = 0; i < lnet_apini.apini_lh_hash_size; i++)
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_lh_hash_table[i]);
+ for (i = 0; i < the_lnet.ln_lh_hash_size; i++)
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_lh_hash_table[i]);
- lnet_apini.apini_next_object_cookie = PTL_COOKIE_TYPES;
+ the_lnet.ln_next_object_cookie = LNET_COOKIE_TYPES;
return (0);
}
void
-ptl_cleanup_handle_hash (void)
+lnet_cleanup_handle_hash (void)
{
- if (lnet_apini.apini_lh_hash_table == NULL)
+ if (the_lnet.ln_lh_hash_table == NULL)
return;
- PORTAL_FREE(lnet_apini.apini_lh_hash_table,
- lnet_apini.apini_lh_hash_size * sizeof (struct list_head));
+ PORTAL_FREE(the_lnet.ln_lh_hash_table,
+ the_lnet.ln_lh_hash_size * sizeof (struct list_head));
}
-ptl_libhandle_t *
-ptl_lookup_cookie (__u64 cookie, int type)
+lnet_libhandle_t *
+lnet_lookup_cookie (__u64 cookie, int type)
{
- /* ALWAYS called with PTL_LOCK held */
+ /* ALWAYS called with LNET_LOCK held */
struct list_head *list;
struct list_head *el;
unsigned int hash;
- if ((cookie & (PTL_COOKIE_TYPES - 1)) != type)
+ if ((cookie & (LNET_COOKIE_TYPES - 1)) != type)
return (NULL);
- hash = ((unsigned int)cookie) % lnet_apini.apini_lh_hash_size;
- list = &lnet_apini.apini_lh_hash_table[hash];
+ hash = ((unsigned int)cookie) % the_lnet.ln_lh_hash_size;
+ list = &the_lnet.ln_lh_hash_table[hash];
list_for_each (el, list) {
- ptl_libhandle_t *lh = list_entry (el, ptl_libhandle_t,
+ lnet_libhandle_t *lh = list_entry (el, lnet_libhandle_t,
lh_hash_chain);
if (lh->lh_cookie == cookie)
}
void
-ptl_initialise_handle (ptl_libhandle_t *lh, int type)
+lnet_initialise_handle (lnet_libhandle_t *lh, int type)
{
- /* ALWAYS called with PTL_LOCK held */
+ /* ALWAYS called with LNET_LOCK held */
unsigned int hash;
- LASSERT (type >= 0 && type < PTL_COOKIE_TYPES);
- lh->lh_cookie = lnet_apini.apini_next_object_cookie | type;
- lnet_apini.apini_next_object_cookie += PTL_COOKIE_TYPES;
+ LASSERT (type >= 0 && type < LNET_COOKIE_TYPES);
+ lh->lh_cookie = the_lnet.ln_next_object_cookie | type;
+ the_lnet.ln_next_object_cookie += LNET_COOKIE_TYPES;
- hash = ((unsigned int)lh->lh_cookie) % lnet_apini.apini_lh_hash_size;
- list_add (&lh->lh_hash_chain, &lnet_apini.apini_lh_hash_table[hash]);
+ hash = ((unsigned int)lh->lh_cookie) % the_lnet.ln_lh_hash_size;
+ list_add (&lh->lh_hash_chain, &the_lnet.ln_lh_hash_table[hash]);
}
void
-ptl_invalidate_handle (ptl_libhandle_t *lh)
+lnet_invalidate_handle (lnet_libhandle_t *lh)
{
- /* ALWAYS called with PTL_LOCK held */
+ /* ALWAYS called with LNET_LOCK held */
list_del (&lh->lh_hash_chain);
}
int
-lnet_apini_init(lnet_pid_t requested_pid)
+lnet_init(lnet_pid_t requested_pid)
{
int rc = 0;
int i;
ENTRY;
- LASSERT (lnet_apini.apini_refcount == 0);
+ LASSERT (the_lnet.ln_refcount == 0);
- lnet_apini.apini_pid = requested_pid;
+ the_lnet.ln_pid = requested_pid;
#ifdef __KERNEL__
LASSERT ((requested_pid & LNET_PID_USERFLAG) == 0);
#else
- lnet_apini.apini_pid |= LNET_PID_USERFLAG;
+ the_lnet.ln_pid |= LNET_PID_USERFLAG;
#endif
- rc = ptl_descriptor_setup ();
+ rc = lnet_descriptor_setup ();
if (rc != 0)
goto out;
- memset(&lnet_apini.apini_counters, 0,
- sizeof(lnet_apini.apini_counters));
+ memset(&the_lnet.ln_counters, 0,
+ sizeof(the_lnet.ln_counters));
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_active_msgs);
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_active_mds);
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_active_eqs);
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_test_peers);
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_nis);
- CFS_INIT_LIST_HEAD (&lnet_apini.apini_zombie_nis);
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_active_msgs);
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_active_mds);
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_active_eqs);
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_test_peers);
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_nis);
+ CFS_INIT_LIST_HEAD (&the_lnet.ln_zombie_nis);
- lnet_apini.apini_interface_cookie = ptl_create_interface_cookie();
+ the_lnet.ln_interface_cookie = lnet_create_interface_cookie();
- rc = ptl_setup_handle_hash ();
+ rc = lnet_setup_handle_hash ();
if (rc != 0)
goto out;
- lnet_apini.apini_nportals = MAX_PORTALS;
- PORTAL_ALLOC(lnet_apini.apini_portals,
- lnet_apini.apini_nportals *
- sizeof(*lnet_apini.apini_portals));
- if (lnet_apini.apini_portals == NULL) {
+ the_lnet.ln_nportals = MAX_PORTALS;
+ PORTAL_ALLOC(the_lnet.ln_portals,
+ the_lnet.ln_nportals *
+ sizeof(*the_lnet.ln_portals));
+ if (the_lnet.ln_portals == NULL) {
rc = -ENOMEM;
goto out;
}
- for (i = 0; i < lnet_apini.apini_nportals; i++)
- CFS_INIT_LIST_HEAD(&(lnet_apini.apini_portals[i]));
+ for (i = 0; i < the_lnet.ln_nportals; i++)
+ CFS_INIT_LIST_HEAD(&(the_lnet.ln_portals[i]));
out:
if (rc != 0) {
- ptl_cleanup_handle_hash ();
- ptl_descriptor_cleanup ();
+ lnet_cleanup_handle_hash ();
+ lnet_descriptor_cleanup ();
}
RETURN (rc);
}
int
-lnet_apini_fini (void)
+lnet_fini (void)
{
int idx;
- /* NB no PTL_LOCK since this is the last reference. All NAL instances
+ /* NB no LNET_LOCK since this is the last reference. All LND instances
* have shut down already, so it is safe to unlink and free all
* descriptors, even those that appear committed to a network op (eg MD
* with non-zero pending count) */
- ptl_fail_nid(LNET_NID_ANY, 0);
+ lnet_fail_nid(LNET_NID_ANY, 0);
- LASSERT (list_empty(&lnet_apini.apini_test_peers));
- LASSERT (lnet_apini.apini_refcount == 0);
- LASSERT (list_empty(&lnet_apini.apini_nis));
- LASSERT (list_empty(&lnet_apini.apini_zombie_nis));
- LASSERT (lnet_apini.apini_nzombie_nis == 0);
+ LASSERT (list_empty(&the_lnet.ln_test_peers));
+ LASSERT (the_lnet.ln_refcount == 0);
+ LASSERT (list_empty(&the_lnet.ln_nis));
+ LASSERT (list_empty(&the_lnet.ln_zombie_nis));
+ LASSERT (the_lnet.ln_nzombie_nis == 0);
- for (idx = 0; idx < lnet_apini.apini_nportals; idx++)
- while (!list_empty (&lnet_apini.apini_portals[idx])) {
- ptl_me_t *me = list_entry (lnet_apini.apini_portals[idx].next,
- ptl_me_t, me_list);
+ for (idx = 0; idx < the_lnet.ln_nportals; idx++)
+ while (!list_empty (&the_lnet.ln_portals[idx])) {
+ lnet_me_t *me = list_entry (the_lnet.ln_portals[idx].next,
+ lnet_me_t, me_list);
CERROR ("Active me %p on exit\n", me);
list_del (&me->me_list);
- ptl_me_free (me);
+ lnet_me_free (me);
}
- while (!list_empty (&lnet_apini.apini_active_mds)) {
- ptl_libmd_t *md = list_entry (lnet_apini.apini_active_mds.next,
- ptl_libmd_t, md_list);
+ while (!list_empty (&the_lnet.ln_active_mds)) {
+ lnet_libmd_t *md = list_entry (the_lnet.ln_active_mds.next,
+ lnet_libmd_t, md_list);
CERROR ("Active md %p on exit\n", md);
list_del (&md->md_list);
- ptl_md_free (md);
+ lnet_md_free (md);
}
- while (!list_empty (&lnet_apini.apini_active_eqs)) {
- ptl_eq_t *eq = list_entry (lnet_apini.apini_active_eqs.next,
- ptl_eq_t, eq_list);
+ while (!list_empty (&the_lnet.ln_active_eqs)) {
+ lnet_eq_t *eq = list_entry (the_lnet.ln_active_eqs.next,
+ lnet_eq_t, eq_list);
CERROR ("Active eq %p on exit\n", eq);
list_del (&eq->eq_list);
- ptl_eq_free (eq);
+ lnet_eq_free (eq);
}
- while (!list_empty (&lnet_apini.apini_active_msgs)) {
- ptl_msg_t *msg = list_entry (lnet_apini.apini_active_msgs.next,
- ptl_msg_t, msg_list);
+ while (!list_empty (&the_lnet.ln_active_msgs)) {
+ lnet_msg_t *msg = list_entry (the_lnet.ln_active_msgs.next,
+ lnet_msg_t, msg_activelist);
CERROR ("Active msg %p on exit\n", msg);
- list_del (&msg->msg_list);
- ptl_msg_free (msg);
+ list_del (&msg->msg_activelist);
+ lnet_msg_free (msg);
}
- PORTAL_FREE(lnet_apini.apini_portals,
- lnet_apini.apini_nportals * sizeof(*lnet_apini.apini_portals));
+ PORTAL_FREE(the_lnet.ln_portals,
+ the_lnet.ln_nportals * sizeof(*the_lnet.ln_portals));
- ptl_cleanup_handle_hash ();
- ptl_descriptor_cleanup ();
+ lnet_cleanup_handle_hash ();
+ lnet_descriptor_cleanup ();
#ifndef __KERNEL__
- pthread_mutex_destroy(&lnet_apini.apini_mutex);
- pthread_cond_destroy(&lnet_apini.apini_cond);
+ pthread_mutex_destroy(&the_lnet.ln_mutex);
+ pthread_cond_destroy(&the_lnet.ln_cond);
#endif
return (0);
}
-ptl_ni_t *
+lnet_ni_t *
lnet_net2ni (__u32 net)
{
struct list_head *tmp;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
unsigned long flags;
- PTL_LOCK(flags);
- list_for_each (tmp, &lnet_apini.apini_nis) {
- ni = list_entry(tmp, ptl_ni_t, ni_list);
+ LNET_LOCK(flags);
+ list_for_each (tmp, &the_lnet.ln_nis) {
+ ni = list_entry(tmp, lnet_ni_t, ni_list);
if (PTL_NIDNET(ni->ni_nid) == net ||
- (lnet_apini.apini_ptlcompat > 0 &&
+ (the_lnet.ln_ptlcompat > 0 &&
net == 0 &&
- PTL_NETNAL(PTL_NIDNET(ni->ni_nid)) != LONAL)) {
- ptl_ni_addref_locked(ni);
- PTL_UNLOCK(flags);
+ PTL_NETTYP(PTL_NIDNET(ni->ni_nid)) != LOLND)) {
+ lnet_ni_addref_locked(ni);
+ LNET_UNLOCK(flags);
return ni;
}
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return NULL;
}
int
-ptl_count_acceptor_nis (ptl_ni_t **first_ni)
+lnet_count_acceptor_nis (lnet_ni_t **first_ni)
{
/* Return the # of NIs that need the acceptor. Return the first one in
* *first_ni so the acceptor can pass it connections "blind" to retain
#ifdef __KERNEL__
unsigned long flags;
struct list_head *tmp;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
- PTL_LOCK(flags);
- list_for_each (tmp, &lnet_apini.apini_nis) {
- ni = list_entry(tmp, ptl_ni_t, ni_list);
+ LNET_LOCK(flags);
+ list_for_each (tmp, &the_lnet.ln_nis) {
+ ni = list_entry(tmp, lnet_ni_t, ni_list);
- if (ni->ni_nal->nal_accept != NULL) {
- /* This NAL uses the acceptor */
+ if (ni->ni_lnd->lnd_accept != NULL) {
+ /* This LND uses the acceptor */
if (count == 0 && first_ni != NULL) {
- ptl_ni_addref_locked(ni);
+ lnet_ni_addref_locked(ni);
*first_ni = ni;
}
count++;
}
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
#endif
return count;
}
int
-ptl_islocalnid (lnet_nid_t nid)
+lnet_islocalnid (lnet_nid_t nid)
{
struct list_head *tmp;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
unsigned long flags;
int islocal = 0;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- list_for_each (tmp, &lnet_apini.apini_nis) {
- ni = list_entry(tmp, ptl_ni_t, ni_list);
+ list_for_each (tmp, &the_lnet.ln_nis) {
+ ni = list_entry(tmp, lnet_ni_t, ni_list);
if (ni->ni_nid == nid) {
islocal = 1;
}
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return islocal;
}
int
-ptl_islocalnet (__u32 net, int *orderp)
+lnet_islocalnet (__u32 net, int *orderp)
{
struct list_head *tmp;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
unsigned long flags;
int order = 0;
int islocal = 0;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- list_for_each (tmp, &lnet_apini.apini_nis) {
- ni = list_entry(tmp, ptl_ni_t, ni_list);
+ list_for_each (tmp, &the_lnet.ln_nis) {
+ ni = list_entry(tmp, lnet_ni_t, ni_list);
if (PTL_NIDNET(ni->ni_nid) == net) {
islocal = 1;
order++;
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return islocal;
}
void
-ptl_shutdown_nalnis (void)
+lnet_shutdown_lndnis (void)
{
int i;
int islo;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
unsigned long flags;
/* NB called holding the global mutex */
/* All quiet on the API front */
- LASSERT (lnet_apini.apini_refcount == 0);
- LASSERT (list_empty(&lnet_apini.apini_zombie_nis));
- LASSERT (lnet_apini.apini_nzombie_nis == 0);
+ LASSERT (the_lnet.ln_refcount == 0);
+ LASSERT (list_empty(&the_lnet.ln_zombie_nis));
+ LASSERT (the_lnet.ln_nzombie_nis == 0);
/* First unlink the NIs from the global list and drop its ref. When
* the last ref goes, the NI is queued on apini_zombie_nis....*/
- PTL_LOCK(flags);
- while (!list_empty(&lnet_apini.apini_nis)) {
- ni = list_entry(lnet_apini.apini_nis.next,
- ptl_ni_t, ni_list);
+ LNET_LOCK(flags);
+ while (!list_empty(&the_lnet.ln_nis)) {
+ ni = list_entry(the_lnet.ln_nis.next,
+ lnet_ni_t, ni_list);
list_del (&ni->ni_list);
ni->ni_shutdown = 1;
- lnet_apini.apini_nzombie_nis++;
+ the_lnet.ln_nzombie_nis++;
- ptl_ni_decref_locked(ni); /* drop apini's ref (shutdown on last ref) */
+ lnet_ni_decref_locked(ni); /* drop apini's ref (shutdown on last ref) */
}
/* Drop the cached loopback NI. */
- if (ptl_loni != NULL) {
- ptl_ni_decref_locked(ptl_loni);
- ptl_loni = NULL;
+ if (lnet_loni != NULL) {
+ lnet_ni_decref_locked(lnet_loni);
+ lnet_loni = NULL;
}
/* Now wait for the NI's I just nuked to show up on apini_zombie_nis
* and shut them down in guaranteed thread context */
i = 2;
- while (lnet_apini.apini_nzombie_nis != 0) {
+ while (the_lnet.ln_nzombie_nis != 0) {
- while (list_empty(&lnet_apini.apini_zombie_nis)) {
- PTL_UNLOCK(flags);
+ while (list_empty(&the_lnet.ln_zombie_nis)) {
+ LNET_UNLOCK(flags);
++i;
if ((i & (-i)) == i)
CDEBUG(D_WARNING,"Waiting for %d zombie NIs\n",
- lnet_apini.apini_nzombie_nis);
+ the_lnet.ln_nzombie_nis);
cfs_pause(cfs_time_seconds(1));
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
}
- ni = list_entry(lnet_apini.apini_zombie_nis.next,
- ptl_ni_t, ni_list);
+ ni = list_entry(the_lnet.ln_zombie_nis.next,
+ lnet_ni_t, ni_list);
list_del(&ni->ni_list);
- ni->ni_nal->nal_refcount--;
+ ni->ni_lnd->lnd_refcount--;
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- islo = ni->ni_nal->nal_type == LONAL;
+ islo = ni->ni_lnd->lnd_type == LOLND;
LASSERT (!in_interrupt());
- (ni->ni_nal->nal_shutdown)(ni);
+ (ni->ni_lnd->lnd_shutdown)(ni);
- /* can't deref nal anymore now; it might have unregistered
+ /* can't deref lnd anymore now; it might have unregistered
* itself... */
if (!islo)
PORTAL_FREE(ni, sizeof(*ni));
- PTL_LOCK(flags);
- lnet_apini.apini_nzombie_nis--;
+ LNET_LOCK(flags);
+ the_lnet.ln_nzombie_nis--;
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- if (lnet_apini.apini_network_tokens != NULL) {
- PORTAL_FREE(lnet_apini.apini_network_tokens,
- lnet_apini.apini_network_tokens_nob);
- lnet_apini.apini_network_tokens = NULL;
+ if (the_lnet.ln_network_tokens != NULL) {
+ PORTAL_FREE(the_lnet.ln_network_tokens,
+ the_lnet.ln_network_tokens_nob);
+ the_lnet.ln_network_tokens = NULL;
}
}
int
-ptl_startup_nalnis (void)
+lnet_startup_lndnis (void)
{
- ptl_nal_t *nal;
- ptl_ni_t *ni;
+ lnd_t *lnd;
+ lnet_ni_t *ni;
struct list_head nilist;
- int rc = 0;
+ int rc = 0;
unsigned long flags;
- int nal_type;
+ int lnd_type;
int retry;
INIT_LIST_HEAD(&nilist);
goto failed;
while (!list_empty(&nilist)) {
- ni = list_entry(nilist.next, ptl_ni_t, ni_list);
- nal_type = PTL_NETNAL(PTL_NIDNET(ni->ni_nid));
+ ni = list_entry(nilist.next, lnet_ni_t, ni_list);
+ lnd_type = PTL_NETTYP(PTL_NIDNET(ni->ni_nid));
- LASSERT (libcfs_isknown_nal(nal_type));
+ LASSERT (libcfs_isknown_lnd(lnd_type));
- PTL_MUTEX_DOWN(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_lnd_mutex);
for (retry = 0;; retry = 1) {
- nal = ptl_find_nal_by_type(nal_type);
- if (nal != NULL)
+ lnd = lnet_find_lnd_by_type(lnd_type);
+ if (lnd != NULL)
break;
- PTL_MUTEX_UP(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_UP(&the_lnet.ln_lnd_mutex);
#ifdef __KERNEL__
if (retry) {
- CERROR("Can't load NAL %s, module %s\n",
- libcfs_nal2str(nal_type),
- libcfs_nal2modname(nal_type));
+ CERROR("Can't load LND %s, module %s\n",
+ libcfs_lnd2str(lnd_type),
+ libcfs_lnd2modname(lnd_type));
goto failed;
}
- request_module(libcfs_nal2modname(nal_type));
+ request_module(libcfs_lnd2modname(lnd_type));
#else
- CERROR("NAL %s not supported\n",
- libcfs_nal2str(nal_type));
+ CERROR("LND %s not supported\n",
+ libcfs_lnd2str(lnd_type));
goto failed;
#endif
- PTL_MUTEX_DOWN(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_lnd_mutex);
}
ni->ni_refcount = 1;
- PTL_LOCK(flags);
- nal->nal_refcount++;
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ lnd->lnd_refcount++;
+ LNET_UNLOCK(flags);
- ni->ni_nal = nal;
+ ni->ni_lnd = lnd;
- rc = (nal->nal_startup)(ni);
+ rc = (lnd->lnd_startup)(ni);
- PTL_MUTEX_UP(&lnet_apini.apini_nal_mutex);
+ LNET_MUTEX_UP(&the_lnet.ln_lnd_mutex);
if (rc != 0) {
CERROR("Error %d starting up NI %s\n",
- rc, libcfs_nal2str(nal->nal_type));
- PTL_LOCK(flags);
- nal->nal_refcount--;
- PTL_UNLOCK(flags);
+ rc, libcfs_lnd2str(lnd->lnd_type));
+ LNET_LOCK(flags);
+ lnd->lnd_refcount--;
+ LNET_UNLOCK(flags);
goto failed;
}
- if (nal->nal_type != LONAL) {
+ if (lnd->lnd_type != LOLND) {
LCONSOLE(0, "Added NI %s\n",
libcfs_nid2str(ni->ni_nid));
/* Handle nidstrings for network 0 just like this one */
- if (lnet_apini.apini_ptlcompat > 0)
- libcfs_setnet0alias(nal->nal_type);
+ if (the_lnet.ln_ptlcompat > 0)
+ libcfs_setnet0alias(lnd->lnd_type);
}
list_del(&ni->ni_list);
- PTL_LOCK(flags);
- list_add_tail(&ni->ni_list, &lnet_apini.apini_nis);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ list_add_tail(&ni->ni_list, &the_lnet.ln_nis);
+ LNET_UNLOCK(flags);
}
- ptl_loni = lnet_net2ni(PTL_MKNET(LONAL, 0));
- LASSERT (ptl_loni != NULL);
+ lnet_loni = lnet_net2ni(PTL_MKNET(LOLND, 0));
+ LASSERT (lnet_loni != NULL);
return 0;
failed:
- ptl_shutdown_nalnis();
+ lnet_shutdown_lndnis();
while (!list_empty(&nilist)) {
- ni = list_entry(nilist.next, ptl_ni_t, ni_list);
+ ni = list_entry(nilist.next, lnet_ni_t, ni_list);
list_del(&ni->ni_list);
PORTAL_FREE(ni, sizeof(*ni));
}
}
#ifndef __KERNEL__
-extern ptl_nal_t tcpnal_nal;
+extern lnd_t the_tcplnd;
#endif
int
LNetInit(void)
{
- ptl_assert_wire_constants ();
+ lnet_assert_wire_constants ();
- LASSERT (!lnet_apini.apini_init);
+ LASSERT (!the_lnet.ln_init);
- lnet_apini.apini_refcount = 0;
- CFS_INIT_LIST_HEAD(&lnet_apini.apini_nals);
+ the_lnet.ln_refcount = 0;
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_lnds);
#ifdef __KERNEL__
- spin_lock_init (&lnet_apini.apini_lock);
- cfs_waitq_init (&lnet_apini.apini_waitq);
- init_mutex(&lnet_apini.apini_nal_mutex);
- init_mutex(&lnet_apini.apini_api_mutex);
+ spin_lock_init (&the_lnet.ln_lock);
+ cfs_waitq_init (&the_lnet.ln_waitq);
+ init_mutex(&the_lnet.ln_lnd_mutex);
+ init_mutex(&the_lnet.ln_api_mutex);
#else
- pthread_mutex_init(&lnet_apini.apini_mutex, NULL);
- pthread_cond_init(&lnet_apini.apini_cond, NULL);
- pthread_mutex_init(&lnet_apini.apini_nal_mutex, NULL);
- pthread_mutex_init(&lnet_apini.apini_api_mutex, NULL);
+ pthread_mutex_init(&the_lnet.ln_mutex, NULL);
+ pthread_cond_init(&the_lnet.ln_cond, NULL);
+ pthread_mutex_init(&the_lnet.ln_lnd_mutex, NULL);
+ pthread_mutex_init(&the_lnet.ln_api_mutex, NULL);
#endif
- lnet_apini.apini_init = 1;
+ the_lnet.ln_init = 1;
if (!strcmp(portals_compatibility, "none")) {
- lnet_apini.apini_ptlcompat = 0;
+ the_lnet.ln_ptlcompat = 0;
} else if (!strcmp(portals_compatibility, "weak")) {
- lnet_apini.apini_ptlcompat = 1;
+ the_lnet.ln_ptlcompat = 1;
LCONSOLE_WARN("Starting in weak portals-compatible mode\n");
} else if (!strcmp(portals_compatibility, "strong")) {
- lnet_apini.apini_ptlcompat = 2;
+ the_lnet.ln_ptlcompat = 2;
LCONSOLE_WARN("Starting in strong portals-compatible mode\n");
} else {
LCONSOLE_ERROR("portals_compatibility=\"%s\" not supported\n",
* loads, and unregister themselves when their module is unloaded.
* Otherwise they are plugged in explicitly here... */
- lnet_register_nal (&ptl_lonal);
+ lnet_register_lnd (&the_lolnd);
#ifndef __KERNEL__
- lnet_register_nal (&tcpnal_nal);
+ lnet_register_lnd (&the_tcplnd);
#endif
return 0;
}
void
LNetFini(void)
{
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount == 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount == 0);
- /* See comment where tcpnal_nal registers itself */
+ /* See comment where the_tcplnd registers itself */
#ifndef __KERNEL__
- lnet_unregister_nal(&tcpnal_nal);
+ lnet_unregister_lnd(&the_tcplnd);
#endif
- lnet_unregister_nal(&ptl_lonal);
+ lnet_unregister_lnd(&the_lolnd);
- LASSERT (list_empty(&lnet_apini.apini_nals));
+ LASSERT (list_empty(&the_lnet.ln_lnds));
- lnet_apini.apini_init = 0;
+ the_lnet.ln_init = 0;
}
int
{
int rc;
- PTL_MUTEX_DOWN(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_api_mutex);
- LASSERT (lnet_apini.apini_init);
- CDEBUG(D_OTHER, "refs %d\n", lnet_apini.apini_refcount);
+ LASSERT (the_lnet.ln_init);
+ CDEBUG(D_OTHER, "refs %d\n", the_lnet.ln_refcount);
- if (lnet_apini.apini_refcount > 0) {
- rc = lnet_apini.apini_refcount++;
+ if (the_lnet.ln_refcount > 0) {
+ rc = the_lnet.ln_refcount++;
goto out;
}
- rc = lnet_apini_init(requested_pid);
+ rc = lnet_init(requested_pid);
if (rc != 0)
goto out;
rc = kpr_initialise();
if (rc != 0) {
- lnet_apini_fini();
+ lnet_fini();
goto out;
}
- rc = ptl_startup_nalnis();
+ rc = lnet_startup_lndnis();
if (rc != 0) {
kpr_finalise();
- lnet_apini_fini();
+ lnet_fini();
goto out;
}
rc = lnet_acceptor_start();
if (rc != 0) {
- ptl_shutdown_nalnis();
+ lnet_shutdown_lndnis();
kpr_finalise();
- lnet_apini_fini();
+ lnet_fini();
goto out;
}
- lnet_apini.apini_refcount = 1;
+ the_lnet.ln_refcount = 1;
out:
- PTL_MUTEX_UP(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_UP(&the_lnet.ln_api_mutex);
return rc;
}
int
LNetNIFini()
{
- PTL_MUTEX_DOWN(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_api_mutex);
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- lnet_apini.apini_refcount--;
- if (lnet_apini.apini_refcount == 0) {
+ the_lnet.ln_refcount--;
+ if (the_lnet.ln_refcount == 0) {
lnet_acceptor_stop();
- ptl_shutdown_nalnis();
+ lnet_shutdown_lndnis();
kpr_finalise();
- lnet_apini_fini();
+ lnet_fini();
}
- PTL_MUTEX_UP(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_UP(&the_lnet.ln_api_mutex);
return 0;
}
{
struct portal_ioctl_data *data = arg;
lnet_process_id_t id;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
int rc;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
switch (cmd) {
case IOC_PORTAL_GET_NI:
return rc;
case IOC_PORTAL_FAIL_NID:
- return ptl_fail_nid(data->ioc_nid, data->ioc_count);
+ return lnet_fail_nid(data->ioc_nid, data->ioc_count);
case IOC_PORTAL_ADD_ROUTE:
case IOC_PORTAL_DEL_ROUTE:
return kpr_ctl(cmd, arg);
case IOC_PORTAL_PORTALS_COMPATIBILITY:
- return lnet_apini.apini_ptlcompat;
+ return the_lnet.ln_ptlcompat;
default:
ni = lnet_net2ni(data->ioc_net);
if (ni == NULL)
return -EINVAL;
- if (ni->ni_nal->nal_ctl == NULL)
+ if (ni->ni_lnd->lnd_ctl == NULL)
rc = -EINVAL;
else
- rc = ni->ni_nal->nal_ctl(ni, cmd, arg);
+ rc = ni->ni_lnd->lnd_ctl(ni, cmd, arg);
- ptl_ni_decref(ni);
+ lnet_ni_decref(ni);
return rc;
}
/* not reached */
int
LNetGetId(unsigned int index, lnet_process_id_t *id)
{
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
unsigned long flags;
struct list_head *tmp;
int rc = -ENOENT;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- list_for_each(tmp, &lnet_apini.apini_nis) {
+ list_for_each(tmp, &the_lnet.ln_nis) {
if (index-- != 0)
continue;
- ni = list_entry(tmp, ptl_ni_t, ni_list);
+ ni = list_entry(tmp, lnet_ni_t, ni_list);
id->nid = ni->ni_nid;
- id->pid = lnet_apini.apini_pid;
+ id->pid = the_lnet.ln_pid;
rc = 0;
break;
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return rc;
}
struct list_head ptb_list; /* stash on lists */
int ptb_size; /* allocated size */
char ptb_text[0]; /* text buffer */
-} ptl_text_buf_t;
+} lnet_text_buf_t;
-static int ptl_tbnob = 0; /* track text buf allocation */
-#define PTL_MAX_TEXTBUF_NOB (64<<10) /* bound allocation */
-#define PTL_SINGLE_TEXTBUF_NOB (4<<10)
+static int lnet_tbnob = 0; /* track text buf allocation */
+#define LNET_MAX_TEXTBUF_NOB (64<<10) /* bound allocation */
+#define LNET_SINGLE_TEXTBUF_NOB (4<<10)
void
-ptl_syntax(char *name, char *str, int offset, int width)
+lnet_syntax(char *name, char *str, int offset, int width)
{
const char *dots = "................................"
"................................"
}
int
-ptl_issep (char c)
+lnet_issep (char c)
{
switch (c) {
case '\n':
}
int
-ptl_iswhite (char c)
+lnet_iswhite (char c)
{
switch (c) {
case ' ':
}
char *
-ptl_trimwhite(char *str)
+lnet_trimwhite(char *str)
{
char *end;
- while (ptl_iswhite(*str))
+ while (lnet_iswhite(*str))
str++;
end = str + strlen(str);
while (end > str) {
- if (!ptl_iswhite(end[-1]))
+ if (!lnet_iswhite(end[-1]))
break;
end--;
}
}
int
-ptl_net_unique(__u32 net, struct list_head *nilist)
+lnet_net_unique(__u32 net, struct list_head *nilist)
{
struct list_head *tmp;
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
list_for_each (tmp, nilist) {
- ni = list_entry(tmp, ptl_ni_t, ni_list);
+ ni = list_entry(tmp, lnet_ni_t, ni_list);
if (PTL_NIDNET(ni->ni_nid) == net)
return 0;
return 1;
}
-ptl_ni_t *
-ptl_new_ni(__u32 net, struct list_head *nilist)
+lnet_ni_t *
+lnet_new_ni(__u32 net, struct list_head *nilist)
{
- ptl_ni_t *ni;
+ lnet_ni_t *ni;
- if (!ptl_net_unique(net, nilist)) {
+ if (!lnet_net_unique(net, nilist)) {
LCONSOLE_ERROR("Duplicate network specified: %s\n",
libcfs_net2str(net));
return NULL;
int
lnet_parse_networks(struct list_head *nilist, char *networks)
{
- int tokensize = strlen(networks) + 1;
- char *tokens;
- char *str;
- ptl_ni_t *ni;
- __u32 net;
- int count = 0;
-
- if (strlen(networks) > PTL_SINGLE_TEXTBUF_NOB) {
+ int tokensize = strlen(networks) + 1;
+ char *tokens;
+ char *str;
+ lnet_ni_t *ni;
+ __u32 net;
+ int count = 0;
+
+ if (strlen(networks) > LNET_SINGLE_TEXTBUF_NOB) {
/* _WAY_ conservative */
LCONSOLE_ERROR("Can't parse networks: string too long\n");
return -EINVAL;
return -ENOMEM;
}
- lnet_apini.apini_network_tokens = tokens;
- lnet_apini.apini_network_tokens_nob = tokensize;
+ the_lnet.ln_network_tokens = tokens;
+ the_lnet.ln_network_tokens_nob = tokensize;
memcpy (tokens, networks, tokensize);
str = tokens;
/* Add in the loopback network */
- ni = ptl_new_ni(PTL_MKNET(LONAL, 0), nilist);
+ ni = lnet_new_ni(PTL_MKNET(LOLND, 0), nilist);
if (ni == NULL)
goto failed;
if (comma != NULL)
*comma++ = 0;
- net = libcfs_str2net(ptl_trimwhite(str));
+ net = libcfs_str2net(lnet_trimwhite(str));
if (net == PTL_NIDNET(LNET_NID_ANY)) {
- ptl_syntax("networks", networks,
- str - tokens, strlen(str));
+ lnet_syntax("networks", networks,
+ str - tokens, strlen(str));
goto failed;
}
- if (ptl_new_ni(net, nilist) == NULL)
+ if (lnet_new_ni(net, nilist) == NULL)
goto failed;
str = comma;
}
*bracket = 0;
- net = libcfs_str2net(ptl_trimwhite(str));
+ net = libcfs_str2net(lnet_trimwhite(str));
if (net == PTL_NIDNET(LNET_NID_ANY)) {
- ptl_syntax("networks", networks,
- str - tokens, strlen(str));
+ lnet_syntax("networks", networks,
+ str - tokens, strlen(str));
goto failed;
}
goto failed;
}
- ni = ptl_new_ni(net, nilist);
+ ni = lnet_new_ni(net, nilist);
if (ni == NULL)
goto failed;
bracket = strchr(iface, ')');
if (bracket == NULL) {
- ptl_syntax ("networks", networks,
+ lnet_syntax("networks", networks,
iface - tokens, strlen(iface));
goto failed;
}
if (comma != NULL)
*comma++ = 0;
- iface = ptl_trimwhite(iface);
+ iface = lnet_trimwhite(iface);
if (*iface == 0) {
- ptl_syntax("networks", networks,
- iface - tokens, strlen(iface));
+ lnet_syntax("networks", networks,
+ iface - tokens, strlen(iface));
goto failed;
}
- if (niface == PTL_MAX_INTERFACES) {
+ if (niface == LNET_MAX_INTERFACES) {
LCONSOLE_ERROR("Too many interfaces for net %s\n",
libcfs_net2str(net));
goto failed;
comma = strchr(bracket + 1, ',');
if (comma != NULL) {
*comma = 0;
- str = ptl_trimwhite(str);
+ str = lnet_trimwhite(str);
if (*str != 0) {
- ptl_syntax ("networks", networks,
+ lnet_syntax("networks", networks,
str - tokens, strlen(str));
goto failed;
}
continue;
}
- str = ptl_trimwhite(str);
+ str = lnet_trimwhite(str);
if (*str != 0) {
- ptl_syntax ("networks", networks,
+ lnet_syntax("networks", networks,
str - tokens, strlen(str));
goto failed;
}
failed:
while (!list_empty(nilist)) {
- ni = list_entry(nilist->next, ptl_ni_t, ni_list);
+ ni = list_entry(nilist->next, lnet_ni_t, ni_list);
list_del(&ni->ni_list);
PORTAL_FREE(ni, sizeof(*ni));
}
PORTAL_FREE(tokens, tokensize);
- lnet_apini.apini_network_tokens = NULL;
+ the_lnet.ln_network_tokens = NULL;
return -EINVAL;
}
-ptl_text_buf_t *
-ptl_new_text_buf (int str_len)
+lnet_text_buf_t *
+lnet_new_text_buf (int str_len)
{
- ptl_text_buf_t *ptb;
- int nob;
+ lnet_text_buf_t *ptb;
+ int nob;
- nob = offsetof(ptl_text_buf_t, ptb_text[str_len + 1]);
- if (nob > PTL_SINGLE_TEXTBUF_NOB) {
+ nob = offsetof(lnet_text_buf_t, ptb_text[str_len + 1]);
+ if (nob > LNET_SINGLE_TEXTBUF_NOB) {
/* _way_ conservative for "route net gateway..." */
CERROR("text buffer too big\n");
return NULL;
}
- if (ptl_tbnob + nob > PTL_MAX_TEXTBUF_NOB) {
+ if (lnet_tbnob + nob > LNET_MAX_TEXTBUF_NOB) {
CERROR("Too many text buffers\n");
return NULL;
}
return NULL;
ptb->ptb_size = nob;
- ptl_tbnob += nob;
+ lnet_tbnob += nob;
return ptb;
}
void
-ptl_free_text_buf (ptl_text_buf_t *ptb)
+lnet_free_text_buf (lnet_text_buf_t *ptb)
{
PORTAL_FREE(ptb, ptb->ptb_size);
- ptl_tbnob -= ptb->ptb_size;
+ lnet_tbnob -= ptb->ptb_size;
}
void
-ptl_free_text_bufs(struct list_head *tbs)
+lnet_free_text_bufs(struct list_head *tbs)
{
- ptl_text_buf_t *ptb;
+ lnet_text_buf_t *ptb;
while (!list_empty(tbs)) {
- ptb = list_entry(tbs->next, ptl_text_buf_t, ptb_list);
+ ptb = list_entry(tbs->next, lnet_text_buf_t, ptb_list);
list_del(&ptb->ptb_list);
- ptl_free_text_buf(ptb);
+ lnet_free_text_buf(ptb);
}
}
void
-ptl_print_text_bufs(struct list_head *tbs)
+lnet_print_text_bufs(struct list_head *tbs)
{
struct list_head *tmp;
- ptl_text_buf_t *ptb;
+ lnet_text_buf_t *ptb;
list_for_each (tmp, tbs) {
- ptb = list_entry(tmp, ptl_text_buf_t, ptb_list);
+ ptb = list_entry(tmp, lnet_text_buf_t, ptb_list);
CDEBUG(D_WARNING, "%s\n", ptb->ptb_text);
}
- CDEBUG(D_WARNING, "%d allocated\n", ptl_tbnob);
+ CDEBUG(D_WARNING, "%d allocated\n", lnet_tbnob);
}
int
-ptl_str2tbs_sep (struct list_head *tbs, char *str)
+lnet_str2tbs_sep (struct list_head *tbs, char *str)
{
struct list_head pending;
char *sep;
int nob;
int i;
- ptl_text_buf_t *ptb;
+ lnet_text_buf_t *ptb;
INIT_LIST_HEAD(&pending);
/* Split 'str' into separate commands */
for (;;) {
/* skip leading whitespace */
- while (ptl_iswhite(*str))
+ while (lnet_iswhite(*str))
str++;
/* scan for separator or comment */
for (sep = str; *sep != 0; sep++)
- if (ptl_issep(*sep) || *sep == '#')
+ if (lnet_issep(*sep) || *sep == '#')
break;
nob = sep - str;
if (nob > 0) {
- ptb = ptl_new_text_buf(nob + 1);
+ ptb = lnet_new_text_buf(nob + 1);
if (ptb == NULL) {
- ptl_free_text_bufs(&pending);
+ lnet_free_text_bufs(&pending);
return -1;
}
for (i = 0; i < nob; i++)
- if (ptl_iswhite(str[i]))
+ if (lnet_iswhite(str[i]))
ptb->ptb_text[i] = ' ';
else
ptb->ptb_text[i] = str[i];
/* scan for separator */
do {
sep++;
- } while (*sep != 0 && !ptl_issep(*sep));
+ } while (*sep != 0 && !lnet_issep(*sep));
}
if (*sep == 0)
}
int
-ptl_expand1tb (struct list_head *list,
+lnet_expand1tb (struct list_head *list,
char *str, char *sep1, char *sep2,
char *item, int itemlen)
{
int len1 = sep1 - str;
int len2 = strlen(sep2 + 1);
- ptl_text_buf_t *ptb;
+ lnet_text_buf_t *ptb;
LASSERT (*sep1 == '[');
LASSERT (*sep2 == ']');
- ptb = ptl_new_text_buf(len1 + itemlen + len2 + 1);
+ ptb = lnet_new_text_buf(len1 + itemlen + len2 + 1);
if (ptb == NULL)
return -ENOMEM;
}
int
-ptl_str2tbs_expand (struct list_head *tbs, char *str)
+lnet_str2tbs_expand (struct list_head *tbs, char *str)
{
char num[16];
struct list_head pending;
if (sscanf(parsed, "%d-%d%n", &lo, &hi, &scanned) < 2) {
/* simple string enumeration */
- if (ptl_expand1tb(&pending, str, sep, sep2,
- parsed, enditem - parsed) != 0)
+ if (lnet_expand1tb(&pending, str, sep, sep2,
+ parsed, enditem - parsed) != 0)
goto failed;
continue;
if (nob + 1 == sizeof(num))
goto failed;
- if (ptl_expand1tb(&pending, str, sep, sep2,
- num, nob) != 0)
+ if (lnet_expand1tb(&pending, str, sep, sep2,
+ num, nob) != 0)
goto failed;
}
}
return 1;
failed:
- ptl_free_text_bufs(&pending);
+ lnet_free_text_bufs(&pending);
return -1;
}
lnet_parse_route (char *str)
{
/* static scratch buffer OK (single threaded) */
- static char cmd[PTL_SINGLE_TEXTBUF_NOB];
+ static char cmd[LNET_SINGLE_TEXTBUF_NOB];
struct list_head nets;
struct list_head gateways;
struct list_head *tmp2;
__u32 net;
lnet_nid_t nid;
- ptl_text_buf_t *ptb;
+ lnet_text_buf_t *ptb;
int rc;
char *sep;
char *token = str;
sep = str;
for (;;) {
/* scan for token start */
- while (ptl_iswhite(*sep))
+ while (lnet_iswhite(*sep))
sep++;
if (*sep == 0) {
if (ntokens < (got_hops ? 3 : 2))
token = sep++;
/* scan for token end */
- while (*sep != 0 && !ptl_iswhite(*sep))
+ while (*sep != 0 && !lnet_iswhite(*sep))
sep++;
if (*sep != 0)
*sep++ = 0;
tmp2 = &gateways; /* expanding gateways */
}
- ptb = ptl_new_text_buf(strlen(token));
+ ptb = lnet_new_text_buf(strlen(token));
if (ptb == NULL)
goto out;
list_add_tail(tmp1, tmp2);
while (tmp1 != tmp2) {
- ptb = list_entry(tmp1, ptl_text_buf_t, ptb_list);
+ ptb = list_entry(tmp1, lnet_text_buf_t, ptb_list);
- rc = ptl_str2tbs_expand(tmp1->next, ptb->ptb_text);
+ rc = lnet_str2tbs_expand(tmp1->next, ptb->ptb_text);
if (rc < 0)
goto token_error;
if (rc > 0) { /* expanded! */
list_del(&ptb->ptb_list);
- ptl_free_text_buf(ptb);
+ lnet_free_text_buf(ptb);
continue;
}
LASSERT (!list_empty(&gateways));
list_for_each (tmp1, &nets) {
- ptb = list_entry(tmp1, ptl_text_buf_t, ptb_list);
+ ptb = list_entry(tmp1, lnet_text_buf_t, ptb_list);
net = libcfs_str2net(ptb->ptb_text);
LASSERT (net != PTL_NIDNET(LNET_NID_ANY));
list_for_each (tmp2, &gateways) {
- ptb = list_entry(tmp2, ptl_text_buf_t, ptb_list);
+ ptb = list_entry(tmp2, lnet_text_buf_t, ptb_list);
nid = libcfs_str2nid(ptb->ptb_text);
LASSERT (nid != LNET_NID_ANY);
goto out;
token_error:
- ptl_syntax("routes", cmd, token - str, strlen(token));
+ lnet_syntax("routes", cmd, token - str, strlen(token));
out:
- ptl_free_text_bufs(&nets);
- ptl_free_text_bufs(&gateways);
+ lnet_free_text_bufs(&nets);
+ lnet_free_text_bufs(&gateways);
return myrc;
}
int
lnet_parse_route_tbs(struct list_head *tbs)
{
- ptl_text_buf_t *ptb;
+ lnet_text_buf_t *ptb;
while (!list_empty(tbs)) {
- ptb = list_entry(tbs->next, ptl_text_buf_t, ptb_list);
+ ptb = list_entry(tbs->next, lnet_text_buf_t, ptb_list);
if (lnet_parse_route(ptb->ptb_text) < 0) {
- ptl_free_text_bufs(tbs);
+ lnet_free_text_bufs(tbs);
return -EINVAL;
}
list_del(&ptb->ptb_list);
- ptl_free_text_buf(ptb);
+ lnet_free_text_buf(ptb);
}
return 0;
struct list_head tbs;
int rc = 0;
- if (lnet_apini.apini_ptlcompat > 0 &&
+ if (the_lnet.ln_ptlcompat > 0 &&
routes[0] != 0) {
/* Can't route when running in compatibility mode */
LCONSOLE_ERROR("Route tables are not supported when "
INIT_LIST_HEAD(&tbs);
- if (ptl_str2tbs_sep(&tbs, routes) < 0) {
+ if (lnet_str2tbs_sep(&tbs, routes) < 0) {
CERROR("Error parsing routes\n");
rc = -EINVAL;
} else {
rc = lnet_parse_route_tbs(&tbs);
}
- LASSERT (ptl_tbnob == 0);
+ LASSERT (lnet_tbnob == 0);
return rc;
}
#ifdef __KERNEL__
int
-lnet_set_ip_niaddr (ptl_ni_t *ni)
+lnet_set_ip_niaddr (lnet_ni_t *ni)
{
__u32 net = PTL_NIDNET(ni->ni_nid);
char **names;
if (ni->ni_interfaces[0] != NULL) {
- CLASSERT (PTL_MAX_INTERFACES > 1);
+ CLASSERT (LNET_MAX_INTERFACES > 1);
if (ni->ni_interfaces[1] != NULL) {
CERROR("Net %s doesn't support multiple interfaces\n",
LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
lnet_handle_eq_t *handle)
{
- ptl_eq_t *eq;
+ lnet_eq_t *eq;
unsigned long flags;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
/* We need count to be a power of 2 so that when eq_{enq,deq}_seq
* overflow, they don't skip entries, so the queue has the same
if (count == 0) /* catch bad parameter / overflow on roundup */
return (-EINVAL);
- eq = ptl_eq_alloc();
+ eq = lnet_eq_alloc();
if (eq == NULL)
return (-ENOMEM);
PORTAL_ALLOC(eq->eq_events, count * sizeof(lnet_event_t));
if (eq->eq_events == NULL) {
- PTL_LOCK(flags);
- ptl_eq_free (eq);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ lnet_eq_free (eq);
+ LNET_UNLOCK(flags);
}
/* NB this resets all event sequence numbers to 0, to be earlier
eq->eq_refcount = 0;
eq->eq_callback = callback;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- ptl_initialise_handle (&eq->eq_lh, PTL_COOKIE_TYPE_EQ);
- list_add (&eq->eq_list, &lnet_apini.apini_active_eqs);
+ lnet_initialise_handle (&eq->eq_lh, LNET_COOKIE_TYPE_EQ);
+ list_add (&eq->eq_list, &the_lnet.ln_active_eqs);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- ptl_eq2handle(handle, eq);
+ lnet_eq2handle(handle, eq);
return (0);
}
int
LNetEQFree(lnet_handle_eq_t eqh)
{
- ptl_eq_t *eq;
+ lnet_eq_t *eq;
int size;
- lnet_event_t *events;
+ lnet_event_t *events;
unsigned long flags;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- eq = ptl_handle2eq(&eqh);
+ eq = lnet_handle2eq(&eqh);
if (eq == NULL) {
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (-ENOENT);
}
if (eq->eq_refcount != 0) {
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (-EBUSY);
}
events = eq->eq_events;
size = eq->eq_size;
- ptl_invalidate_handle (&eq->eq_lh);
+ lnet_invalidate_handle (&eq->eq_lh);
list_del (&eq->eq_list);
- ptl_eq_free (eq);
+ lnet_eq_free (eq);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
PORTAL_FREE(events, size * sizeof (lnet_event_t));
}
int
-lib_get_event (ptl_eq_t *eq, lnet_event_t *ev)
+lib_get_event (lnet_eq_t *eq, lnet_event_t *ev)
{
- int new_index = eq->eq_deq_seq & (eq->eq_size - 1);
+ int new_index = eq->eq_deq_seq & (eq->eq_size - 1);
lnet_event_t *new_event = &eq->eq_events[new_index];
- int rc;
+ int rc;
ENTRY;
CDEBUG(D_INFO, "event: %p, sequence: %lu, eq->size: %u\n",
int
LNetEQPoll (lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
- lnet_event_t *event, int *which)
+ lnet_event_t *event, int *which)
{
unsigned long flags;
int i;
#endif
ENTRY;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
if (neq < 1)
RETURN(-ENOENT);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
for (;;) {
for (i = 0; i < neq; i++) {
- ptl_eq_t *eq = ptl_handle2eq(&eventqs[i]);
+ lnet_eq_t *eq = lnet_handle2eq(&eventqs[i]);
rc = lib_get_event (eq, event);
if (rc != 0) {
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
*which = i;
RETURN(rc);
}
}
if (timeout_ms == 0) {
- PTL_UNLOCK (flags);
+ LNET_UNLOCK (flags);
RETURN (0);
}
#ifdef __KERNEL__
cfs_waitlink_init(&wl);
set_current_state(TASK_INTERRUPTIBLE);
- cfs_waitq_add(&lnet_apini.apini_waitq, &wl);
+ cfs_waitq_add(&the_lnet.ln_waitq, &wl);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
if (timeout_ms < 0) {
cfs_waitq_wait (&wl);
timeout_ms = 0;
}
- PTL_LOCK(flags);
- cfs_waitq_del(&lnet_apini.apini_waitq, &wl);
+ LNET_LOCK(flags);
+ cfs_waitq_del(&the_lnet.ln_waitq, &wl);
#else
if (timeout_ms < 0) {
- pthread_cond_wait(&lnet_apini.apini_cond,
- &lnet_apini.apini_mutex);
+ pthread_cond_wait(&the_lnet.ln_cond,
+ &the_lnet.ln_mutex);
} else {
gettimeofday(&then, NULL);
ts.tv_nsec -= 1000000000;
}
- pthread_cond_timedwait(&lnet_apini.apini_cond,
- &lnet_apini.apini_mutex, &ts);
+ pthread_cond_timedwait(&the_lnet.ln_cond,
+ &the_lnet.ln_mutex, &ts);
gettimeofday(&now, NULL);
timeout_ms -= (now.tv_sec - then.tv_sec) * 1000 +
#include <lnet/lib-lnet.h>
-/* must be called with PTL_LOCK held */
+/* must be called with LNET_LOCK held */
void
-ptl_md_unlink(ptl_libmd_t *md)
+lnet_md_unlink(lnet_libmd_t *md)
{
- if ((md->md_flags & PTL_MD_FLAG_ZOMBIE) == 0) {
+ if ((md->md_flags & LNET_MD_FLAG_ZOMBIE) == 0) {
/* first unlink attempt... */
- ptl_me_t *me = md->md_me;
+ lnet_me_t *me = md->md_me;
- md->md_flags |= PTL_MD_FLAG_ZOMBIE;
+ md->md_flags |= LNET_MD_FLAG_ZOMBIE;
/* Disassociate from ME (if any), and unlink it if it was created
* with LNET_UNLINK */
if (me != NULL) {
me->me_md = NULL;
if (me->me_unlink == LNET_UNLINK)
- ptl_me_unlink(me);
+ lnet_me_unlink(me);
}
/* emsure all future handle lookups fail */
- ptl_invalidate_handle(&md->md_lh);
+ lnet_invalidate_handle(&md->md_lh);
}
if (md->md_pending != 0) {
}
list_del (&md->md_list);
- ptl_md_free(md);
+ lnet_md_free(md);
}
-/* must be called with PTL_LOCK held */
+/* must be called with LNET_LOCK held */
static int
-lib_md_build(ptl_libmd_t *lmd, lnet_md_t *umd, int unlink)
+lib_md_build(lnet_libmd_t *lmd, lnet_md_t *umd, int unlink)
{
- ptl_eq_t *eq = NULL;
- int i;
- int niov;
- int total_length = 0;
+ lnet_eq_t *eq = NULL;
+ int i;
+ unsigned int niov;
+ int total_length = 0;
/* NB we are passed an allocated, but uninitialised/active md.
- * if we return success, caller may ptl_md_unlink() it.
- * otherwise caller may only ptl_md_free() it.
+ * if we return success, caller may lnet_md_unlink() it.
+ * otherwise caller may only lnet_md_free() it.
*/
if (!LNetHandleIsEqual (umd->eq_handle, LNET_EQ_NONE)) {
- eq = ptl_handle2eq(&umd->eq_handle);
+ eq = lnet_handle2eq(&umd->eq_handle);
if (eq == NULL)
return -ENOENT;
}
lmd->md_eq = eq;
lmd->md_threshold = umd->threshold;
lmd->md_pending = 0;
- lmd->md_flags = (unlink == LNET_UNLINK) ? PTL_MD_FLAG_AUTO_UNLINK : 0;
+ lmd->md_flags = (unlink == LNET_UNLINK) ? LNET_MD_FLAG_AUTO_UNLINK : 0;
if ((umd->options & LNET_MD_IOVEC) != 0) {
eq->eq_refcount++;
/* It's good; let handle2md succeed and add to active mds */
- ptl_initialise_handle (&lmd->md_lh, PTL_COOKIE_TYPE_MD);
- list_add (&lmd->md_list, &lnet_apini.apini_active_mds);
+ lnet_initialise_handle (&lmd->md_lh, LNET_COOKIE_TYPE_MD);
+ list_add (&lmd->md_list, &the_lnet.ln_active_mds);
return 0;
}
-/* must be called with PTL_LOCK held */
+/* must be called with LNET_LOCK held */
void
-ptl_md_deconstruct(ptl_libmd_t *lmd, lnet_md_t *umd)
+lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd)
{
/* NB this doesn't copy out all the iov entries so when a
* discontiguous MD is copied out, the target gets to know the
umd->max_size = lmd->md_max_size;
umd->options = lmd->md_options;
umd->user_ptr = lmd->md_user_ptr;
- ptl_eq2handle(&umd->eq_handle, lmd->md_eq);
+ lnet_eq2handle(&umd->eq_handle, lmd->md_eq);
}
int
LNetMDAttach(lnet_handle_me_t meh, lnet_md_t umd,
- lnet_unlink_t unlink, lnet_handle_md_t *handle)
+ lnet_unlink_t unlink, lnet_handle_md_t *handle)
{
- ptl_me_t *me;
- ptl_libmd_t *md;
- unsigned long flags;
- int rc;
+ lnet_me_t *me;
+ lnet_libmd_t *md;
+ unsigned long flags;
+ int rc;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
if ((umd.options & (LNET_MD_KIOV | LNET_MD_IOVEC)) != 0 &&
umd.length > PTL_MD_MAX_IOV) /* too many fragments */
return -EINVAL;
- md = ptl_md_alloc(&umd);
+ md = lnet_md_alloc(&umd);
if (md == NULL)
return -ENOMEM;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- me = ptl_handle2me(&meh);
+ me = lnet_handle2me(&meh);
if (me == NULL) {
rc = -ENOENT;
} else if (me->me_md != NULL) {
me->me_md = md;
md->md_me = me;
- ptl_md2handle(handle, md);
+ lnet_md2handle(handle, md);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (0);
}
}
- ptl_md_free (md);
+ lnet_md_free (md);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (rc);
}
int
LNetMDBind(lnet_md_t umd, lnet_unlink_t unlink, lnet_handle_md_t *handle)
{
- ptl_libmd_t *md;
- unsigned long flags;
- int rc;
+ lnet_libmd_t *md;
+ unsigned long flags;
+ int rc;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
if ((umd.options & (LNET_MD_KIOV | LNET_MD_IOVEC)) != 0 &&
umd.length > PTL_MD_MAX_IOV) /* too many fragments */
return -EINVAL;
- md = ptl_md_alloc(&umd);
+ md = lnet_md_alloc(&umd);
if (md == NULL)
return -ENOMEM;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
rc = lib_md_build(md, &umd, unlink);
if (rc == 0) {
- ptl_md2handle(handle, md);
+ lnet_md2handle(handle, md);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (0);
}
- ptl_md_free (md);
+ lnet_md_free (md);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (rc);
}
int
LNetMDUnlink (lnet_handle_md_t mdh)
{
- lnet_event_t ev;
- ptl_libmd_t *md;
+ lnet_event_t ev;
+ lnet_libmd_t *md;
unsigned long flags;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- md = ptl_handle2md(&mdh);
+ md = lnet_handle2md(&mdh);
if (md == NULL) {
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return -ENOENT;
}
- /* If the MD is busy, ptl_md_unlink just marks it for deletion, and
+ /* If the MD is busy, lnet_md_unlink just marks it for deletion, and
* when the NAL is done, the completion event flags that the MD was
* unlinked. Otherwise, we enqueue an event now... */
ev.type = LNET_EVENT_UNLINK;
ev.status = 0;
ev.unlinked = 1;
- ptl_md_deconstruct(md, &ev.md);
- ptl_md2handle(&ev.md_handle, md);
+ lnet_md_deconstruct(md, &ev.md);
+ lnet_md2handle(&ev.md_handle, md);
- ptl_enq_event_locked(NULL, md->md_eq, &ev);
+ lnet_enq_event_locked(NULL, md->md_eq, &ev);
}
- ptl_md_unlink(md);
+ lnet_md_unlink(md);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return 0;
}
lnet_unlink_t unlink, lnet_ins_pos_t pos,
lnet_handle_me_t *handle)
{
- ptl_me_t *me;
+ lnet_me_t *me;
unsigned long flags;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- if (portal >= lnet_apini.apini_nportals)
+ if (portal >= the_lnet.ln_nportals)
return -EINVAL;
- me = ptl_me_alloc();
+ me = lnet_me_alloc();
if (me == NULL)
return -ENOMEM;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
me->me_match_id = match_id;
me->me_match_bits = match_bits;
me->me_unlink = unlink;
me->me_md = NULL;
- ptl_initialise_handle (&me->me_lh, PTL_COOKIE_TYPE_ME);
+ lnet_initialise_handle (&me->me_lh, LNET_COOKIE_TYPE_ME);
if (pos == LNET_INS_AFTER)
- list_add_tail(&me->me_list, &(lnet_apini.apini_portals[portal]));
+ list_add_tail(&me->me_list, &(the_lnet.ln_portals[portal]));
else
- list_add(&me->me_list, &(lnet_apini.apini_portals[portal]));
+ list_add(&me->me_list, &(the_lnet.ln_portals[portal]));
- ptl_me2handle(handle, me);
+ lnet_me2handle(handle, me);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return 0;
}
int
LNetMEInsert(lnet_handle_me_t current_meh,
- lnet_process_id_t match_id,
- __u64 match_bits, __u64 ignore_bits,
- lnet_unlink_t unlink, lnet_ins_pos_t pos,
- lnet_handle_me_t *handle)
+ lnet_process_id_t match_id,
+ __u64 match_bits, __u64 ignore_bits,
+ lnet_unlink_t unlink, lnet_ins_pos_t pos,
+ lnet_handle_me_t *handle)
{
- ptl_me_t *current_me;
- ptl_me_t *new_me;
+ lnet_me_t *current_me;
+ lnet_me_t *new_me;
unsigned long flags;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- new_me = ptl_me_alloc();
+ new_me = lnet_me_alloc();
if (new_me == NULL)
return -ENOMEM;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- current_me = ptl_handle2me(¤t_meh);
+ current_me = lnet_handle2me(¤t_meh);
if (current_me == NULL) {
- ptl_me_free (new_me);
+ lnet_me_free (new_me);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return -ENOENT;
}
new_me->me_unlink = unlink;
new_me->me_md = NULL;
- ptl_initialise_handle (&new_me->me_lh, PTL_COOKIE_TYPE_ME);
+ lnet_initialise_handle (&new_me->me_lh, LNET_COOKIE_TYPE_ME);
if (pos == LNET_INS_AFTER)
list_add_tail(&new_me->me_list, ¤t_me->me_list);
else
list_add(&new_me->me_list, ¤t_me->me_list);
- ptl_me2handle(handle, new_me);
+ lnet_me2handle(handle, new_me);
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return 0;
}
LNetMEUnlink(lnet_handle_me_t meh)
{
unsigned long flags;
- ptl_me_t *me;
+ lnet_me_t *me;
int rc;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- me = ptl_handle2me(&meh);
+ me = lnet_handle2me(&meh);
if (me == NULL) {
rc = -ENOENT;
} else {
- ptl_me_unlink(me);
+ lnet_me_unlink(me);
rc = 0;
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return (rc);
}
-/* call with PTL_LOCK please */
+/* call with LNET_LOCK please */
void
-ptl_me_unlink(ptl_me_t *me)
+lnet_me_unlink(lnet_me_t *me)
{
list_del (&me->me_list);
if (me->me_md) {
me->me_md->md_me = NULL;
- ptl_md_unlink(me->me_md);
+ lnet_md_unlink(me->me_md);
}
- ptl_invalidate_handle (&me->me_lh);
- ptl_me_free(me);
+ lnet_invalidate_handle (&me->me_lh);
+ lnet_me_free(me);
}
#if 0
static void
-lib_me_dump(ptl_me_t *me)
+lib_me_dump(lnet_me_t *me)
{
CWARN("Match Entry %p ("LPX64")\n", me,
me->me_lh.lh_cookie);
CWARN("\tMD\t= %p\n", me->md);
CWARN("\tprev\t= %p\n",
- list_entry(me->me_list.prev, ptl_me_t, me_list));
+ list_entry(me->me_list.prev, lnet_me_t, me_list));
CWARN("\tnext\t= %p\n",
- list_entry(me->me_list.next, ptl_me_t, me_list));
+ list_entry(me->me_list.next, lnet_me_t, me_list));
}
#endif
"Boolean: substitute 0@lo when sending to any local NID");
/* forward ref */
-static void ptl_commit_md (ptl_libmd_t *md, ptl_msg_t *msg);
+static void lnet_commit_md (lnet_libmd_t *md, lnet_msg_t *msg);
-static ptl_libmd_t *
-ptl_match_md(int index, int op_mask, lnet_process_id_t src,
- unsigned int rlength, unsigned int roffset,
- __u64 match_bits, ptl_msg_t *msg,
- unsigned int *mlength_out, unsigned int *offset_out)
+static lnet_libmd_t *
+lnet_match_md(int index, int op_mask, lnet_process_id_t src,
+ unsigned int rlength, unsigned int roffset,
+ __u64 match_bits, lnet_msg_t *msg,
+ unsigned int *mlength_out, unsigned int *offset_out)
{
- struct list_head *match_list = &lnet_apini.apini_portals[index];
+ struct list_head *match_list = &the_lnet.ln_portals[index];
struct list_head *tmp;
- ptl_me_t *me;
- ptl_libmd_t *md;
+ lnet_me_t *me;
+ lnet_libmd_t *md;
unsigned int mlength;
unsigned int offset;
ENTRY;
CDEBUG (D_NET, "Request from %s of length %d into portal %d "
"MB="LPX64"\n", libcfs_id2str(src), rlength, index, match_bits);
- if (index < 0 || index >= lnet_apini.apini_nportals) {
+ if (index < 0 || index >= the_lnet.ln_nportals) {
CERROR("Invalid portal %d not in [0-%d]\n",
- index, lnet_apini.apini_nportals);
+ index, the_lnet.ln_nportals);
goto failed;
}
list_for_each (tmp, match_list) {
- me = list_entry(tmp, ptl_me_t, me_list);
+ me = list_entry(tmp, lnet_me_t, me_list);
md = me->me_md;
/* ME attached but MD not attached yet */
continue;
/* MD exhausted */
- if (ptl_md_exhausted(md))
+ if (lnet_md_exhausted(md))
continue;
/* mismatched ME nid/pid? */
index, libcfs_id2str(src), mlength, rlength,
md->md_lh.lh_cookie, md->md_niov, offset);
- ptl_commit_md(md, msg);
+ lnet_commit_md(md, msg);
md->md_offset = offset + mlength;
/* NB Caller sets ev.type and ev.hdr_data */
msg->msg_ev.mlength = mlength;
msg->msg_ev.offset = offset;
- ptl_md_deconstruct(md, &msg->msg_ev.md);
- ptl_md2handle(&msg->msg_ev.md_handle, md);
+ lnet_md_deconstruct(md, &msg->msg_ev.md);
+ lnet_md2handle(&msg->msg_ev.md_handle, md);
*offset_out = offset;
*mlength_out = mlength;
/* Auto-unlink NOW, so the ME gets unlinked if required.
* We bumped md->pending above so the MD just gets flagged
* for unlink when it is finalized. */
- if ((md->md_flags & PTL_MD_FLAG_AUTO_UNLINK) != 0 &&
- ptl_md_exhausted(md))
- ptl_md_unlink(md);
+ if ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) != 0 &&
+ lnet_md_exhausted(md))
+ lnet_md_unlink(md);
RETURN (md);
}
}
int
-ptl_fail_nid (lnet_nid_t nid, unsigned int threshold)
+lnet_fail_nid (lnet_nid_t nid, unsigned int threshold)
{
- ptl_test_peer_t *tp;
+ lnet_test_peer_t *tp;
unsigned long flags;
struct list_head *el;
struct list_head *next;
struct list_head cull;
- LASSERT (lnet_apini.apini_init);
+ LASSERT (the_lnet.ln_init);
if (threshold != 0) {
/* Adding a new entry */
tp->tp_nid = nid;
tp->tp_threshold = threshold;
- PTL_LOCK(flags);
- list_add_tail (&tp->tp_list, &lnet_apini.apini_test_peers);
- PTL_UNLOCK(flags);
+ LNET_LOCK(flags);
+ list_add_tail (&tp->tp_list, &the_lnet.ln_test_peers);
+ LNET_UNLOCK(flags);
return 0;
}
/* removing entries */
CFS_INIT_LIST_HEAD (&cull);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- list_for_each_safe (el, next, &lnet_apini.apini_test_peers) {
- tp = list_entry (el, ptl_test_peer_t, tp_list);
+ list_for_each_safe (el, next, &the_lnet.ln_test_peers) {
+ tp = list_entry (el, lnet_test_peer_t, tp_list);
if (tp->tp_threshold == 0 || /* needs culling anyway */
nid == LNET_NID_ANY || /* removing all entries */
}
}
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
while (!list_empty (&cull)) {
- tp = list_entry (cull.next, ptl_test_peer_t, tp_list);
+ tp = list_entry (cull.next, lnet_test_peer_t, tp_list);
list_del (&tp->tp_list);
PORTAL_FREE(tp, sizeof (*tp));
static int
fail_peer (lnet_nid_t nid, int outgoing)
{
- ptl_test_peer_t *tp;
+ lnet_test_peer_t *tp;
struct list_head *el;
struct list_head *next;
unsigned long flags;
CFS_INIT_LIST_HEAD (&cull);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- list_for_each_safe (el, next, &lnet_apini.apini_test_peers) {
- tp = list_entry (el, ptl_test_peer_t, tp_list);
+ list_for_each_safe (el, next, &the_lnet.ln_test_peers) {
+ tp = list_entry (el, lnet_test_peer_t, tp_list);
if (tp->tp_threshold == 0) {
/* zombie entry */
}
}
- PTL_UNLOCK (flags);
+ LNET_UNLOCK (flags);
while (!list_empty (&cull)) {
- tp = list_entry (cull.next, ptl_test_peer_t, tp_list);
+ tp = list_entry (cull.next, lnet_test_peer_t, tp_list);
list_del (&tp->tp_list);
PORTAL_FREE(tp, sizeof (*tp));
}
unsigned int
-lnet_iov_nob (int niov, struct iovec *iov)
+lnet_iov_nob (unsigned int niov, struct iovec *iov)
{
unsigned int nob = 0;
}
void
-lnet_copy_iov2buf (char *dest, int niov, struct iovec *iov,
- unsigned int offset, unsigned int len)
+lnet_copy_iov2iov (unsigned int ndiov, struct iovec *diov, unsigned int doffset,
+ unsigned int nsiov, struct iovec *siov, unsigned int soffset,
+ unsigned int nob)
{
- unsigned int nob;
+ /* NB diov, siov are READ-ONLY */
+ unsigned int this_nob;
- if (len == 0)
+ if (nob == 0)
return;
- /* skip complete frags before 'offset' */
- LASSERT (niov > 0);
- while (offset >= iov->iov_len) {
- offset -= iov->iov_len;
- iov++;
- niov--;
- LASSERT (niov > 0);
+ /* skip complete frags before 'doffset' */
+ LASSERT (ndiov > 0);
+ while (doffset >= diov->iov_len) {
+ doffset -= diov->iov_len;
+ diov++;
+ ndiov--;
+ LASSERT (ndiov > 0);
}
-
- do {
- LASSERT (niov > 0);
- nob = MIN (iov->iov_len - offset, len);
- memcpy (dest, iov->iov_base + offset, nob);
-
- len -= nob;
- dest += nob;
- niov--;
- iov++;
- offset = 0;
- } while (len > 0);
-}
-
-void
-lnet_copy_buf2iov (int niov, struct iovec *iov, unsigned int offset,
- char *src, unsigned int len)
-{
- unsigned int nob;
-
- if (len == 0)
- return;
-
- /* skip complete frags before 'offset' */
- LASSERT (niov > 0);
- while (offset >= iov->iov_len) {
- offset -= iov->iov_len;
- iov++;
- niov--;
- LASSERT (niov > 0);
+
+ /* skip complete frags before 'soffset' */
+ LASSERT (nsiov > 0);
+ while (soffset >= siov->iov_len) {
+ soffset -= siov->iov_len;
+ siov++;
+ nsiov--;
+ LASSERT (nsiov > 0);
}
do {
- LASSERT (niov > 0);
- nob = MIN (iov->iov_len - offset, len);
- memcpy (iov->iov_base + offset, src, nob);
-
- len -= nob;
- src += nob;
- niov--;
- iov++;
- offset = 0;
- } while (len > 0);
+ LASSERT (ndiov > 0);
+ LASSERT (nsiov > 0);
+ this_nob = MIN(diov->iov_len - doffset,
+ siov->iov_len - soffset);
+ this_nob = MIN(this_nob, nob);
+
+ memcpy (diov->iov_base + doffset,
+ siov->iov_base + soffset, this_nob);
+ nob -= this_nob;
+
+ if (diov->iov_len < doffset + this_nob) {
+ doffset += this_nob;
+ } else {
+ diov++;
+ doffset = 0;
+ }
+
+ if (siov->iov_len < soffset + this_nob) {
+ soffset += this_nob;
+ } else {
+ siov++;
+ soffset = 0;
+ }
+ } while (nob > 0);
}
int
* for exactly 'len' bytes, and return the number of entries.
* NB not destructive to 'src' */
unsigned int frag_len;
- int niov;
+ unsigned int niov;
if (len == 0) /* no data => */
return (0); /* no frags */
#ifndef __KERNEL__
unsigned int
-lnet_kiov_nob (int niov, lnet_kiov_t *kiov)
+lnet_kiov_nob (unsigned int niov, lnet_kiov_t *kiov)
{
LASSERT (0);
return (0);
}
void
-lnet_copy_kiov2buf (char *dest, int niov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int len)
+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)
+{
+ LASSERT (0);
+}
+
+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)
{
LASSERT (0);
}
void
-lnet_copy_buf2kiov (int niov, lnet_kiov_t *kiov, unsigned int offset,
- char *src, unsigned int len)
+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)
{
LASSERT (0);
}
#else /* __KERNEL__ */
unsigned int
-lnet_kiov_nob (int niov, lnet_kiov_t *kiov)
+lnet_kiov_nob (unsigned int niov, lnet_kiov_t *kiov)
{
unsigned int nob = 0;
}
void
-lnet_copy_kiov2buf (char *dest, int niov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int len)
+lnet_copy_kiov2kiov (unsigned int ndiov, lnet_kiov_t *diov, unsigned int doffset,
+ unsigned int nsiov, lnet_kiov_t *siov, unsigned int soffset,
+ unsigned int nob)
{
- unsigned int nob;
- char *addr;
+ /* NB diov, siov are READ-ONLY */
+ unsigned int this_nob;
+ char *daddr = NULL;
+ char *saddr = NULL;
- if (len == 0)
+ if (nob == 0)
+ return;
+
+ LASSERT (!in_interrupt ());
+
+ LASSERT (ndiov > 0);
+ while (doffset > diov->kiov_len) {
+ doffset -= diov->kiov_len;
+ diov++;
+ ndiov--;
+ LASSERT (ndiov > 0);
+ }
+
+ LASSERT (nsiov > 0);
+ while (soffset > siov->kiov_len) {
+ soffset -= siov->kiov_len;
+ siov++;
+ nsiov--;
+ LASSERT (nsiov > 0);
+ }
+
+ do {
+ LASSERT (ndiov > 0);
+ LASSERT (nsiov > 0);
+ this_nob = MIN(diov->kiov_len - doffset,
+ siov->kiov_len - soffset);
+ this_nob = MIN(this_nob, nob);
+
+ if (daddr == NULL)
+ daddr = ((char *)cfs_kmap(diov->kiov_page)) +
+ diov->kiov_offset + doffset;
+ if (saddr == NULL)
+ saddr = ((char *)cfs_kmap(siov->kiov_page)) +
+ siov->kiov_offset + soffset;
+
+ /* Vanishing risk of kmap deadlock when mapping 2 pages.
+ * However in practice at least one of the kiovs will be mapped
+ * kernel pages and the map/unmap will be NOOPs */
+
+ memcpy (daddr, saddr, this_nob);
+ nob -= this_nob;
+
+ if (diov->kiov_len > doffset + this_nob) {
+ daddr += this_nob;
+ doffset += this_nob;
+ } else {
+ cfs_kunmap(diov->kiov_page);
+ daddr = NULL;
+ diov++;
+ doffset = 0;
+ }
+
+ if (siov->kiov_len > soffset + this_nob) {
+ saddr += this_nob;
+ soffset += this_nob;
+ } else {
+ cfs_kunmap(siov->kiov_page);
+ saddr = NULL;
+ siov++;
+ soffset = 0;
+ }
+ } while (nob > 0);
+
+ if (daddr != NULL)
+ cfs_kunmap(diov->kiov_page);
+ if (saddr != NULL)
+ cfs_kunmap(siov->kiov_page);
+}
+
+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)
+{
+ /* NB iov, kiov are READ-ONLY */
+ unsigned int this_nob;
+ char *addr = NULL;
+
+ if (nob == 0)
return;
LASSERT (!in_interrupt ());
LASSERT (niov > 0);
- while (offset > kiov->kiov_len) {
- offset -= kiov->kiov_len;
- kiov++;
+ while (iovoffset > iov->iov_len) {
+ iovoffset -= iov->iov_len;
+ iov++;
niov--;
LASSERT (niov > 0);
}
+ LASSERT (nkiov > 0);
+ while (kiovoffset > kiov->kiov_len) {
+ kiovoffset -= kiov->kiov_len;
+ kiov++;
+ nkiov--;
+ LASSERT (nkiov > 0);
+ }
+
do {
LASSERT (niov > 0);
- nob = MIN (kiov->kiov_len - offset, len);
+ LASSERT (nkiov > 0);
+ this_nob = MIN(iov->iov_len - iovoffset,
+ kiov->kiov_len - kiovoffset);
+ this_nob = MIN(this_nob, nob);
- addr = ((char *)cfs_kmap(kiov->kiov_page)) + kiov->kiov_offset +
- offset;
- memcpy (dest, addr, nob);
- cfs_kunmap (kiov->kiov_page);
+ if (addr == NULL)
+ addr = ((char *)cfs_kmap(kiov->kiov_page)) +
+ kiov->kiov_offset + kiovoffset;
- len -= nob;
- dest += nob;
- niov--;
- kiov++;
- offset = 0;
- } while (len > 0);
+ memcpy (iov->iov_base + iovoffset, addr, this_nob);
+ nob -= this_nob;
+
+ if (iov->iov_len < iovoffset + this_nob) {
+ iovoffset += this_nob;
+ } else {
+ iov++;
+ iovoffset = 0;
+ }
+
+ if (kiov->kiov_len < kiovoffset + this_nob) {
+ addr += this_nob;
+ kiovoffset += this_nob;
+ } else {
+ cfs_kunmap(kiov->kiov_page);
+ addr = NULL;
+ kiov++;
+ kiovoffset = 0;
+ }
+
+ } while (nob > 0);
+
+ if (addr != NULL)
+ cfs_kunmap(kiov->kiov_page);
}
void
-lnet_copy_buf2kiov (int niov, lnet_kiov_t *kiov, unsigned int offset,
- char *src, unsigned int len)
+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)
{
- unsigned int nob;
- char *addr;
+ /* NB kiov, iov are READ-ONLY */
+ unsigned int this_nob;
+ char *addr = NULL;
- if (len == 0)
+ if (nob == 0)
return;
LASSERT (!in_interrupt ());
- LASSERT (niov > 0);
- while (offset >= kiov->kiov_len) {
- offset -= kiov->kiov_len;
+ LASSERT (nkiov > 0);
+ while (kiovoffset > kiov->kiov_len) {
+ kiovoffset -= kiov->kiov_len;
kiov++;
+ nkiov--;
+ LASSERT (nkiov > 0);
+ }
+
+ LASSERT (niov > 0);
+ while (iovoffset > iov->iov_len) {
+ iovoffset -= iov->iov_len;
+ iov++;
niov--;
LASSERT (niov > 0);
}
do {
+ LASSERT (nkiov > 0);
LASSERT (niov > 0);
- nob = MIN (kiov->kiov_len - offset, len);
+ this_nob = MIN(kiov->kiov_len - kiovoffset,
+ iov->iov_len - iovoffset);
+ this_nob = MIN(this_nob, nob);
- addr = ((char *)cfs_kmap(kiov->kiov_page)) + kiov->kiov_offset +
- offset;
- memcpy (addr, src, nob);
- cfs_kunmap (kiov->kiov_page);
+ if (addr == NULL)
+ addr = ((char *)cfs_kmap(kiov->kiov_page)) +
+ kiov->kiov_offset + kiovoffset;
- len -= nob;
- src += nob;
- niov--;
- kiov++;
- offset = 0;
- } while (len > 0);
+ memcpy (addr, iov->iov_base + iovoffset, this_nob);
+ nob -= this_nob;
+
+ if (kiov->kiov_len < kiovoffset + this_nob) {
+ addr += this_nob;
+ kiovoffset += this_nob;
+ } else {
+ cfs_kunmap(kiov->kiov_page);
+ addr = NULL;
+ kiov++;
+ kiovoffset = 0;
+ }
+
+ if (iov->iov_len < iovoffset + this_nob) {
+ iovoffset += this_nob;
+ } else {
+ iov++;
+ iovoffset = 0;
+ }
+ } while (nob > 0);
+
+ if (addr != NULL)
+ cfs_kunmap(kiov->kiov_page);
}
int
* for exactly 'len' bytes, and return the number of entries.
* NB not destructive to 'src' */
unsigned int frag_len;
- int niov;
+ unsigned int niov;
if (len == 0) /* no data => */
return (0); /* no frags */
}
#endif
-int
-ptl_recv (ptl_ni_t *ni, void *private, ptl_msg_t *msg, ptl_libmd_t *md,
+void
+lnet_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
unsigned int offset, unsigned int mlen, unsigned int rlen)
{
- int niov = 0;
+ unsigned int niov = 0;
struct iovec *iov = NULL;
lnet_kiov_t *kiov = NULL;
+ int rc;
if (mlen != 0) {
+ lnet_libmd_t *md = msg->msg_md;
+
niov = md->md_niov;
- if (((md->md_options) & LNET_MD_KIOV) != 0)
+ if ((md->md_options & LNET_MD_KIOV) != 0)
kiov = md->md_iov.kiov;
else
iov = md->md_iov.iov;
}
- return (ni->ni_nal->nal_recv)(ni, private, msg,
- niov, iov, kiov, offset, mlen, rlen);
+ rc = (ni->ni_lnd->lnd_recv)(ni, private, msg, delayed,
+ niov, iov, kiov, offset, mlen, rlen);
+ if (rc != 0)
+ lnet_finalize(ni, private, msg, rc);
}
int
-ptl_send (ptl_ni_t *ni, void *private, ptl_msg_t *msg,
- ptl_hdr_t *hdr, int type, lnet_process_id_t target,
- ptl_libmd_t *md, unsigned int offset, unsigned int len)
+lnet_send(lnet_ni_t *ni, void *private, lnet_msg_t *msg,
+ int type, lnet_process_id_t target,
+ lnet_libmd_t *md, unsigned int offset, unsigned int len)
{
unsigned long flags;
lnet_nid_t gw_nid;
lnet_nid_t src_nid;
- int niov = 0;
- struct iovec *iov = NULL;
- lnet_kiov_t *kiov = NULL;
- int target_is_router = 0;
int rc;
/* CAVEAT EMPTOR! ni != NULL == interface pre-determined (ACK) */
- gw_nid = lnet_lookup (&ni, target.nid, sizeof(*hdr) + len);
+ gw_nid = lnet_lookup (&ni, target.nid, sizeof(lnet_hdr_t) + len);
if (gw_nid == LNET_NID_ANY) {
CERROR("No route to %s\n", libcfs_id2str(target));
LCONSOLE_ERROR("Cannot send to %s: %s is not a local network "
}
/* set the completion event's initiator.nid now we know it */
- if (type == PTL_MSG_PUT || type == PTL_MSG_GET)
+ if (type == LNET_MSG_PUT || type == LNET_MSG_GET)
msg->msg_ev.initiator.nid = ni->ni_nid;
src_nid = lnet_ptlcompat_srcnid(ni->ni_nid, target.nid);
+
+ msg->msg_type = type;
+ msg->msg_target = target;
+ msg->msg_target_is_router = 0;
+ msg->msg_routing = 0;
- hdr->type = cpu_to_le32(type);
- hdr->dest_nid = cpu_to_le64(target.nid);
- hdr->dest_pid = cpu_to_le32(target.pid);
- hdr->src_nid = cpu_to_le64(src_nid);
- hdr->src_pid = cpu_to_le64(lnet_apini.apini_pid);
- hdr->payload_length = cpu_to_le32(len);
-
- if (PTL_NETNAL(PTL_NIDNET(ni->ni_nid)) != LONAL) {
+ msg->msg_hdr.type = cpu_to_le32(type);
+ msg->msg_hdr.dest_nid = cpu_to_le64(target.nid);
+ msg->msg_hdr.dest_pid = cpu_to_le32(target.pid);
+ msg->msg_hdr.src_nid = cpu_to_le64(src_nid);
+ msg->msg_hdr.src_pid = cpu_to_le64(the_lnet.ln_pid);
+ msg->msg_hdr.payload_length = cpu_to_le32(len);
+
+ if (PTL_NETTYP(PTL_NIDNET(ni->ni_nid)) != LOLND) {
if (!lnet_ptlcompat_matchnid(ni->ni_nid, gw_nid)) {
/* it's not for me: will the gateway have to forward? */
if (gw_nid != target.nid &&
- lnet_apini.apini_ptlcompat == 0) {
- target_is_router = 1;
- target.pid = LUSTRE_SRV_PTL_PID;
- target.nid = gw_nid;
+ the_lnet.ln_ptlcompat == 0) {
+ msg->msg_target_is_router = 1;
+ msg->msg_target.pid = LUSTRE_SRV_PTL_PID;
+ msg->msg_target.nid = gw_nid;
}
} else if (implicit_loopback) { /* its for me: force lonal? */
- PTL_LOCK(flags);
- ptl_ni_decref_locked(ni);
- ni = ptl_loni;
+ LNET_LOCK(flags);
+ lnet_ni_decref_locked(ni);
+ ni = lnet_loni;
if (ni != NULL)
- ptl_ni_addref_locked(ni);
- PTL_UNLOCK(flags);
+ lnet_ni_addref_locked(ni);
+ LNET_UNLOCK(flags);
if (ni == NULL) /* shutdown in progress */
return -ENETDOWN;
}
}
+
+ msg->msg_len = len;
+ msg->msg_offset = offset;
+ msg->msg_niov = 0;
+ msg->msg_iov = NULL;
+ msg->msg_kiov = NULL;
- if (len != 0) {
- niov = md->md_niov;
+ if (len > 0) {
+ msg->msg_niov = md->md_niov;
+
if (((md->md_options) & LNET_MD_KIOV) != 0)
- kiov = md->md_iov.kiov;
+ msg->msg_kiov = md->md_iov.kiov;
else
- iov = md->md_iov.iov;
+ msg->msg_iov = md->md_iov.iov;
}
- rc = (ni->ni_nal->nal_send)(ni, private, msg, hdr, type, target,
- target_is_router, 0,
- niov, iov, kiov, offset, len);
+ rc = (ni->ni_lnd->lnd_send)(ni, private, msg);
- ptl_ni_decref(ni); /* lose ref from lnet_lookup */
+ lnet_ni_decref(ni); /* lose ref from lnet_lookup */
return rc;
}
static void
-ptl_commit_md (ptl_libmd_t *md, ptl_msg_t *msg)
+lnet_commit_md (lnet_libmd_t *md, lnet_msg_t *msg)
{
- /* ALWAYS called holding the PTL_LOCK */
+ /* ALWAYS called holding the LNET_LOCK */
/* Here, we commit the MD to a network OP by marking it busy and
* decrementing its threshold. Come what may, the network "owns"
* the MD until a call to lnet_finalize() signals completion. */
md->md_threshold--;
}
- lnet_apini.apini_counters.msgs_alloc++;
- if (lnet_apini.apini_counters.msgs_alloc >
- lnet_apini.apini_counters.msgs_max)
- lnet_apini.apini_counters.msgs_max =
- lnet_apini.apini_counters.msgs_alloc;
+ the_lnet.ln_counters.msgs_alloc++;
+ if (the_lnet.ln_counters.msgs_alloc >
+ the_lnet.ln_counters.msgs_max)
+ the_lnet.ln_counters.msgs_max =
+ the_lnet.ln_counters.msgs_alloc;
- list_add (&msg->msg_list, &lnet_apini.apini_active_msgs);
+ list_add (&msg->msg_activelist, &the_lnet.ln_active_msgs);
}
-static void
-ptl_drop_message (ptl_ni_t *ni, void *private, ptl_hdr_t *hdr)
+void
+lnet_drop_message (lnet_ni_t *ni, void *private, unsigned int nob)
{
unsigned long flags;
- /* CAVEAT EMPTOR: this only drops messages that we've not committed
- * to receive (init_msg() not called) and therefore can't cause an
- * event. */
-
- PTL_LOCK(flags);
- lnet_apini.apini_counters.drop_count++;
- lnet_apini.apini_counters.drop_length += hdr->payload_length;
- PTL_UNLOCK(flags);
-
- /* NULL msg => if NAL calls lnet_finalize it will be a noop */
- (void) ptl_recv(ni, private, NULL, NULL, 0, 0,
- hdr->payload_length);
+ LNET_LOCK(flags);
+ the_lnet.ln_counters.drop_count++;
+ the_lnet.ln_counters.drop_length += nob;
+ LNET_UNLOCK(flags);
+
+ lnet_recv(ni, private, NULL, 0, 0, 0, nob);
}
-/*
- * Incoming messages have a ptl_msg_t object associated with them
- * by the library. This object encapsulates the state of the
- * message and allows the NAL to do non-blocking receives or sends
- * of long messages.
- *
- */
static int
-lnet_parse_put(ptl_ni_t *ni, ptl_hdr_t *hdr, void *private, ptl_msg_t *msg)
+lnet_parse_put(lnet_ni_t *ni, lnet_hdr_t *hdr, void *private, lnet_msg_t *msg)
{
+ unsigned int rlength = hdr->payload_length;
unsigned int mlength = 0;
unsigned int offset = 0;
lnet_process_id_t src = {.nid = hdr->src_nid,
.pid = hdr->src_pid};
- int rc;
- ptl_libmd_t *md;
+ lnet_libmd_t *md;
unsigned long flags;
/* Convert put fields to host byte order */
hdr->msg.put.ptl_index = le32_to_cpu(hdr->msg.put.ptl_index);
hdr->msg.put.offset = le32_to_cpu(hdr->msg.put.offset);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- md = ptl_match_md(hdr->msg.put.ptl_index, LNET_MD_OP_PUT, src,
- hdr->payload_length, hdr->msg.put.offset,
- hdr->msg.put.match_bits, msg,
- &mlength, &offset);
+ md = lnet_match_md(hdr->msg.put.ptl_index, LNET_MD_OP_PUT, src,
+ rlength, hdr->msg.put.offset,
+ hdr->msg.put.match_bits, msg,
+ &mlength, &offset);
if (md == NULL) {
- PTL_UNLOCK(flags);
- return (-ENOENT);
+ LNET_UNLOCK(flags);
+ return ENOENT; /* +ve: OK but no match */
}
msg->msg_ev.type = LNET_EVENT_PUT;
msg->msg_ev.hdr_data = hdr->msg.put.hdr_data;
- if (!ptl_is_wire_handle_none(&hdr->msg.put.ack_wmd) &&
+ if (!lnet_is_wire_handle_none(&hdr->msg.put.ack_wmd) &&
!(md->md_options & LNET_MD_ACK_DISABLE)) {
msg->msg_ack_wmd = hdr->msg.put.ack_wmd;
}
- lnet_apini.apini_counters.recv_count++;
- lnet_apini.apini_counters.recv_length += mlength;
-
- PTL_UNLOCK(flags);
+ the_lnet.ln_counters.recv_count++;
+ the_lnet.ln_counters.recv_length += mlength;
- rc = ptl_recv(ni, private, msg, md, offset, mlength,
- hdr->payload_length);
-
- if (rc != 0)
- CERROR("%s: error on receiving PUT from %s: %d\n",
- libcfs_nid2str(ni->ni_nid), libcfs_id2str(src), rc);
+ LNET_UNLOCK(flags);
- return (rc);
+ lnet_recv(ni, private, msg, 0, offset, mlength, rlength);
+ return 0;
}
static int
-lnet_parse_get(ptl_ni_t *ni, ptl_hdr_t *hdr, void *private, ptl_msg_t *msg)
+lnet_parse_get(lnet_ni_t *ni, lnet_hdr_t *hdr, void *private, lnet_msg_t *msg)
{
unsigned int mlength = 0;
unsigned int offset = 0;
lnet_process_id_t src = {.nid = hdr->src_nid,
.pid = hdr->src_pid};
- ptl_libmd_t *md;
- ptl_hdr_t reply;
+ lnet_libmd_t *md;
unsigned long flags;
int rc;
hdr->msg.get.sink_length = le32_to_cpu(hdr->msg.get.sink_length);
hdr->msg.get.src_offset = le32_to_cpu(hdr->msg.get.src_offset);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- md = ptl_match_md(hdr->msg.get.ptl_index, LNET_MD_OP_GET, src,
- hdr->msg.get.sink_length, hdr->msg.get.src_offset,
- hdr->msg.get.match_bits, msg,
- &mlength, &offset);
+ md = lnet_match_md(hdr->msg.get.ptl_index, LNET_MD_OP_GET, src,
+ hdr->msg.get.sink_length, hdr->msg.get.src_offset,
+ hdr->msg.get.match_bits, msg,
+ &mlength, &offset);
if (md == NULL) {
- PTL_UNLOCK(flags);
- return (-ENOENT);
+ LNET_UNLOCK(flags);
+ return ENOENT; /* +ve: OK but no match */
}
msg->msg_ev.type = LNET_EVENT_GET;
msg->msg_ev.hdr_data = 0;
- lnet_apini.apini_counters.send_count++;
- lnet_apini.apini_counters.send_length += mlength;
+ the_lnet.ln_counters.send_count++;
+ the_lnet.ln_counters.send_length += mlength;
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- memset (&reply, 0, sizeof (reply));
- reply.msg.reply.dst_wmd = hdr->msg.get.return_wmd;
+ memset (&msg->msg_hdr, 0, sizeof (msg->msg_hdr));
+ msg->msg_hdr.msg.reply.dst_wmd = hdr->msg.get.return_wmd;
- /* NB call ptl_send() _BEFORE_ ptl_recv() completes the incoming
+ /* NB call lnet_send() _BEFORE_ lnet_recv() completes the incoming
* message. Some NALs _require_ this to implement optimized GET */
- rc = ptl_send (ni, private, msg, &reply, PTL_MSG_REPLY, src,
+ rc = lnet_send(ni, private, msg, LNET_MSG_REPLY, src,
md, offset, mlength);
- if (rc != 0)
+ if (rc != 0) {
+ /* LND won't lnet_finalize()... */
CERROR("%s: Unable to send REPLY for GET from %s: %d\n",
libcfs_nid2str(ni->ni_nid), libcfs_id2str(src), rc);
+ lnet_finalize(ni, private, msg, rc);
+ }
- /* Discard any junk after the hdr */
- (void) ptl_recv(ni, private, NULL, NULL, 0, 0,
- hdr->payload_length);
- return (rc);
+ lnet_recv(ni, private, NULL, 0, 0, 0, 0);
+ return 0;
}
static int
-lnet_parse_reply(ptl_ni_t *ni, ptl_hdr_t *hdr, void *private, ptl_msg_t *msg)
+lnet_parse_reply(lnet_ni_t *ni, lnet_hdr_t *hdr, void *private, lnet_msg_t *msg)
{
lnet_process_id_t src = {.nid = hdr->src_nid,
- .pid = hdr->src_pid};
- ptl_libmd_t *md;
- int rlength;
- int length;
- unsigned long flags;
- int rc;
+ .pid = hdr->src_pid};
+ lnet_libmd_t *md;
+ int rlength;
+ int mlength;
+ unsigned long flags;
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
/* NB handles only looked up by creator (no flips) */
- md = ptl_wire_handle2md(&hdr->msg.reply.dst_wmd);
+ md = lnet_wire_handle2md(&hdr->msg.reply.dst_wmd);
if (md == NULL || md->md_threshold == 0) {
CERROR ("%s: Dropping REPLY from %s for %s "
"MD "LPX64"."LPX64"\n",
hdr->msg.reply.dst_wmd.wh_interface_cookie,
hdr->msg.reply.dst_wmd.wh_object_cookie);
- PTL_UNLOCK(flags);
- return (-EIO);
+ LNET_UNLOCK(flags);
+ return ENOENT; /* +ve: OK but no match */
}
LASSERT (md->md_offset == 0);
- length = rlength = hdr->payload_length;
-
- if (length > md->md_length) {
- if ((md->md_options & LNET_MD_TRUNCATE) == 0) {
- CERROR ("%s: Dropping REPLY from %s length %d "
- "for MD "LPX64" would overflow (%d)\n",
- libcfs_nid2str(ni->ni_nid), libcfs_id2str(src),
- length, hdr->msg.reply.dst_wmd.wh_object_cookie,
- md->md_length);
- PTL_UNLOCK(flags);
- return (-EIO);
- }
- length = md->md_length;
+ rlength = hdr->payload_length;
+ mlength = MIN(rlength, md->md_length);
+
+ if (mlength < rlength &&
+ (md->md_options & LNET_MD_TRUNCATE) == 0) {
+ CERROR ("%s: Dropping REPLY from %s length %d "
+ "for MD "LPX64" would overflow (%d)\n",
+ libcfs_nid2str(ni->ni_nid), libcfs_id2str(src),
+ rlength, hdr->msg.reply.dst_wmd.wh_object_cookie,
+ mlength);
+ LNET_UNLOCK(flags);
+ return ENOENT; /* +ve: OK but no match */
}
CDEBUG(D_NET, "%s: Reply from %s of length %d/%d into md "LPX64"\n",
libcfs_nid2str(ni->ni_nid), libcfs_id2str(src),
- length, rlength, hdr->msg.reply.dst_wmd.wh_object_cookie);
+ mlength, rlength, hdr->msg.reply.dst_wmd.wh_object_cookie);
- ptl_commit_md(md, msg);
+ lnet_commit_md(md, msg);
msg->msg_ev.type = LNET_EVENT_REPLY;
msg->msg_ev.initiator = src;
msg->msg_ev.rlength = rlength;
- msg->msg_ev.mlength = length;
+ msg->msg_ev.mlength = mlength;
msg->msg_ev.offset = 0;
- ptl_md_deconstruct(md, &msg->msg_ev.md);
- ptl_md2handle(&msg->msg_ev.md_handle, md);
-
- lnet_apini.apini_counters.recv_count++;
- lnet_apini.apini_counters.recv_length += length;
+ lnet_md_deconstruct(md, &msg->msg_ev.md);
+ lnet_md2handle(&msg->msg_ev.md_handle, md);
- PTL_UNLOCK(flags);
+ the_lnet.ln_counters.recv_count++;
+ the_lnet.ln_counters.recv_length += mlength;
- rc = ptl_recv(ni, private, msg, md, 0, length, rlength);
- if (rc != 0)
- CERROR("%s: error on receiving REPLY from %s: %d\n",
- libcfs_nid2str(ni->ni_nid), libcfs_id2str(src), rc);
+ LNET_UNLOCK(flags);
- return (rc);
+ lnet_recv(ni, private, msg, 0, 0, mlength, rlength);
+ return 0;
}
static int
-lnet_parse_ack(ptl_ni_t *ni, ptl_hdr_t *hdr, void *private, ptl_msg_t *msg)
+lnet_parse_ack(lnet_ni_t *ni, lnet_hdr_t *hdr, void *private, lnet_msg_t *msg)
{
lnet_process_id_t src = {.nid = hdr->src_nid,
- .pid = hdr->src_pid};
- ptl_libmd_t *md;
+ .pid = hdr->src_pid};
+ lnet_libmd_t *md;
unsigned long flags;
/* Convert ack fields to host byte order */
hdr->msg.ack.match_bits = le64_to_cpu(hdr->msg.ack.match_bits);
hdr->msg.ack.mlength = le32_to_cpu(hdr->msg.ack.mlength);
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
/* NB handles only looked up by creator (no flips) */
- md = ptl_wire_handle2md(&hdr->msg.ack.dst_wmd);
+ md = lnet_wire_handle2md(&hdr->msg.ack.dst_wmd);
if (md == NULL || md->md_threshold == 0) {
+#if 0
+ /* Don't moan; this is expected */
CERROR ("%s: Dropping ACK from %s to %s MD "LPX64"."LPX64"\n",
libcfs_nid2str(ni->ni_nid), libcfs_id2str(src),
(md == NULL) ? "invalid" : "inactive",
hdr->msg.ack.dst_wmd.wh_interface_cookie,
hdr->msg.ack.dst_wmd.wh_object_cookie);
-
- PTL_UNLOCK(flags);
- return (-EIO);
+#endif
+ LNET_UNLOCK(flags);
+ return ENOENT; /* +ve! */
}
CDEBUG(D_NET, "%s: ACK from %s into md "LPX64"\n",
libcfs_nid2str(ni->ni_nid), libcfs_id2str(src),
hdr->msg.ack.dst_wmd.wh_object_cookie);
- ptl_commit_md(md, msg);
+ lnet_commit_md(md, msg);
msg->msg_ev.type = LNET_EVENT_ACK;
msg->msg_ev.initiator = src;
msg->msg_ev.mlength = hdr->msg.ack.mlength;
msg->msg_ev.match_bits = hdr->msg.ack.match_bits;
- ptl_md_deconstruct(md, &msg->msg_ev.md);
- ptl_md2handle(&msg->msg_ev.md_handle, md);
+ lnet_md_deconstruct(md, &msg->msg_ev.md);
+ lnet_md2handle(&msg->msg_ev.md_handle, md);
- lnet_apini.apini_counters.recv_count++;
+ the_lnet.ln_counters.recv_count++;
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- /* We have received and matched up the ack OK, create the
- * completion event now... */
lnet_finalize(ni, private, msg, 0);
- /* ...and now discard any junk after the hdr */
- (void) ptl_recv(ni, private, NULL, NULL, 0, 0, hdr->payload_length);
-
- return (0);
+ lnet_recv(ni, private, NULL, 0, 0, 0, 0);
+ return 0;
}
static char *
-hdr_type_string (ptl_hdr_t *hdr)
+hdr_type_string (lnet_hdr_t *hdr)
{
switch (hdr->type) {
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
return ("ACK");
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
return ("PUT");
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
return ("GET");
- case PTL_MSG_REPLY:
+ case LNET_MSG_REPLY:
return ("REPLY");
- case PTL_MSG_HELLO:
+ case LNET_MSG_HELLO:
return ("HELLO");
default:
return ("<UNKNOWN>");
}
void
-ptl_print_hdr(ptl_hdr_t * hdr)
+lnet_print_hdr(lnet_hdr_t * hdr)
{
lnet_process_id_t src = {.nid = hdr->src_nid,
- .pid = hdr->src_pid};
+ .pid = hdr->src_pid};
lnet_process_id_t dst = {.nid = hdr->dest_nid,
- .pid = hdr->dest_pid};
+ .pid = hdr->dest_pid};
char *type_str = hdr_type_string (hdr);
CWARN("P3 Header at %p of type %s\n", hdr, type_str);
default:
break;
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
CWARN(" Ptl index %d, ack md "LPX64"."LPX64", "
"match bits "LPX64"\n",
hdr->msg.put.ptl_index,
hdr->msg.put.hdr_data);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
CWARN(" Ptl index %d, return md "LPX64"."LPX64", "
"match bits "LPX64"\n", hdr->msg.get.ptl_index,
hdr->msg.get.return_wmd.wh_interface_cookie,
hdr->msg.get.src_offset);
break;
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
CWARN(" dst md "LPX64"."LPX64", "
"manipulated length %d\n",
hdr->msg.ack.dst_wmd.wh_interface_cookie,
hdr->msg.ack.mlength);
break;
- case PTL_MSG_REPLY:
+ case LNET_MSG_REPLY:
CWARN(" dst md "LPX64"."LPX64", "
"length %d\n",
hdr->msg.reply.dst_wmd.wh_interface_cookie,
int
-lnet_parse(ptl_ni_t *ni, ptl_hdr_t *hdr, void *private)
+lnet_parse(lnet_ni_t *ni, lnet_hdr_t *hdr, void *private)
{
unsigned long flags;
- int rc;
+ int rc = 0;
int for_me;
- ptl_msg_t *msg;
+ lnet_msg_t *msg;
lnet_nid_t dest_nid;
__u32 type = le32_to_cpu(hdr->type);
/* NB we return 0 if we manage to parse the header and believe
* it looks OK. Anything that goes wrong with receiving the
- * message after that point is the responsibility of the NAL.
+ * message after that point is the responsibility of the LND.
* If we don't think the packet is for us, return 1 */
dest_nid = le64_to_cpu(hdr->dest_nid);
- for_me = (PTL_NETNAL(PTL_NIDNET(ni->ni_nid)) == LONAL ||
+ for_me = (PTL_NETTYP(PTL_NIDNET(ni->ni_nid)) == LOLND ||
lnet_ptlcompat_matchnid(ni->ni_nid, dest_nid));
if (!for_me) {
- if (lnet_apini.apini_ptlcompat > 0) {
+ if (the_lnet.ln_ptlcompat > 0) {
CERROR ("%s: Dropping message from %s: wrong nid %s\n",
libcfs_nid2str(ni->ni_nid),
libcfs_nid2str(le64_to_cpu(hdr->src_nid)),
libcfs_nid2str(dest_nid));
- return -EIO;
+ return -EPROTO;
}
- if (!ptl_islocalnid(dest_nid)) /* tell NAL to use the router */
+ if (!lnet_islocalnid(dest_nid)) /* tell LND to use the router */
return 1; /* to forward */
/* dest_nid is one of my NIs */
libcfs_nid2str(ni->ni_nid),
libcfs_nid2str(le64_to_cpu(hdr->src_nid)),
libcfs_nid2str(dest_nid));
- return -EIO;
+ return -EPROTO;
}
}
hdr->payload_length = le32_to_cpu(hdr->payload_length);
switch (type) {
- case PTL_MSG_ACK:
- case PTL_MSG_PUT:
- case PTL_MSG_GET:
- case PTL_MSG_REPLY:
+ case LNET_MSG_ACK:
+ case LNET_MSG_GET:
+ if (hdr->payload_length > 0) {
+ CERROR("%s: Bad %s from %s: "
+ "payload size %d sent (0 expected)\n",
+ libcfs_nid2str(ni->ni_nid),
+ hdr_type_string(hdr),
+ libcfs_nid2str(hdr->src_nid),
+ hdr->payload_length);
+ return -EPROTO;
+ }
+ break;
+
+ case LNET_MSG_PUT:
+ case LNET_MSG_REPLY:
+ if (hdr->payload_length > PTL_MTU) {
+ CERROR("%s: Bad %s from %s: "
+ "payload size %d sent (%d max expected)\n",
+ libcfs_nid2str(ni->ni_nid),
+ hdr_type_string(hdr),
+ libcfs_nid2str(hdr->src_nid),
+ hdr->payload_length, PTL_MTU);
+ return -EPROTO;
+ }
break;
default:
CERROR("%s: Bad message type 0x%x from %s\n",
libcfs_nid2str(ni->ni_nid), hdr->type,
libcfs_nid2str(hdr->src_nid));
-
- return -EIO;
+ return -EPROTO;
}
- /* We've decided we're not receiving garbage since we can parse the
- * header. We will return 0 come what may... */
-
- if (!list_empty (&lnet_apini.apini_test_peers) && /* normally we don't */
+ if (!list_empty (&the_lnet.ln_test_peers) && /* normally we don't */
fail_peer (hdr->src_nid, 0)) /* shall we now? */
{
CERROR("%s: Dropping incoming %s from %s: simulated failure\n",
- libcfs_nid2str(ni->ni_nid), hdr_type_string (hdr),
+ libcfs_nid2str(ni->ni_nid), hdr_type_string(hdr),
libcfs_nid2str(hdr->src_nid));
- ptl_drop_message(ni, private, hdr);
- return 0;
+ goto drop;
}
- msg = ptl_msg_alloc();
+ msg = lnet_msg_alloc();
if (msg == NULL) {
CERROR("%s: Dropping incoming %s from %s: "
- "can't allocate a ptl_msg_t\n",
- libcfs_nid2str(ni->ni_nid), hdr_type_string (hdr),
+ "can't allocate a lnet_msg_t\n",
+ libcfs_nid2str(ni->ni_nid), hdr_type_string(hdr),
libcfs_nid2str(hdr->src_nid));
- ptl_drop_message(ni, private, hdr);
- return 0;
+ goto drop;
}
switch (hdr->type) {
- case PTL_MSG_ACK:
+ case LNET_MSG_ACK:
rc = lnet_parse_ack(ni, hdr, private, msg);
break;
- case PTL_MSG_PUT:
+ case LNET_MSG_PUT:
rc = lnet_parse_put(ni, hdr, private, msg);
break;
- case PTL_MSG_GET:
+ case LNET_MSG_GET:
rc = lnet_parse_get(ni, hdr, private, msg);
break;
- case PTL_MSG_REPLY:
+ case LNET_MSG_REPLY:
rc = lnet_parse_reply(ni, hdr, private, msg);
break;
default:
LASSERT(0);
- rc = -EIO; /* no compiler warning please */
break;
}
- if (rc != 0) {
- if (msg->msg_md != NULL) {
- /* committed... */
- lnet_finalize(ni, private, msg, rc);
- } else {
- PTL_LOCK(flags);
- ptl_msg_free(msg); /* expects PTL_LOCK held */
- PTL_UNLOCK(flags);
-
- ptl_drop_message(ni, private, hdr);
- }
- }
-
- return 0;
- /* That's "OK I can parse it", not "OK I like it" :) */
+ if (rc == 0)
+ return 0;
+
+ LASSERT (rc == ENOENT);
+ LASSERT (msg->msg_md == NULL);
+
+ LNET_LOCK(flags);
+ lnet_msg_free(msg); /* expects LNET_LOCK held */
+ LNET_UNLOCK(flags);
+ drop:
+ lnet_drop_message(ni, private, hdr->payload_length);
+ return ENOENT;
}
int
__u64 match_bits, unsigned int offset,
__u64 hdr_data)
{
- ptl_msg_t *msg;
- ptl_hdr_t hdr;
- ptl_libmd_t *md;
+ lnet_msg_t *msg;
+ lnet_libmd_t *md;
unsigned long flags;
int rc;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- if (!list_empty (&lnet_apini.apini_test_peers) && /* normally we don't */
+ if (!list_empty (&the_lnet.ln_test_peers) && /* normally we don't */
fail_peer (target.nid, 1)) /* shall we now? */
{
CERROR("Dropping PUT to %s: simulated failure\n",
return -EIO;
}
- msg = ptl_msg_alloc();
+ msg = lnet_msg_alloc();
if (msg == NULL) {
- CERROR("Dropping PUT to %s: ENOMEM on ptl_msg_t\n",
+ CERROR("Dropping PUT to %s: ENOMEM on lnet_msg_t\n",
libcfs_id2str(target));
return -ENOMEM;
}
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- md = ptl_handle2md(&mdh);
+ md = lnet_handle2md(&mdh);
if (md == NULL || md->md_threshold == 0) {
- ptl_msg_free(msg);
- PTL_UNLOCK(flags);
+ lnet_msg_free(msg);
+ LNET_UNLOCK(flags);
CERROR("Dropping PUT to %s: MD invalid\n",
libcfs_id2str(target));
CDEBUG(D_NET, "LNetPut -> %s\n", libcfs_id2str(target));
- memset (&hdr, 0, sizeof (hdr));
+ memset (&msg->msg_hdr, 0, sizeof (msg->msg_hdr));
/* NB handles only looked up by creator (no flips) */
if (ack == LNET_ACK_REQ) {
- hdr.msg.put.ack_wmd.wh_interface_cookie =
- lnet_apini.apini_interface_cookie;
- hdr.msg.put.ack_wmd.wh_object_cookie = md->md_lh.lh_cookie;
+ msg->msg_hdr.msg.put.ack_wmd.wh_interface_cookie =
+ the_lnet.ln_interface_cookie;
+ msg->msg_hdr.msg.put.ack_wmd.wh_object_cookie =
+ md->md_lh.lh_cookie;
} else {
- hdr.msg.put.ack_wmd = PTL_WIRE_HANDLE_NONE;
+ msg->msg_hdr.msg.put.ack_wmd = LNET_WIRE_HANDLE_NONE;
}
- hdr.msg.put.match_bits = cpu_to_le64(match_bits);
- hdr.msg.put.ptl_index = cpu_to_le32(portal);
- hdr.msg.put.offset = cpu_to_le32(offset);
- hdr.msg.put.hdr_data = hdr_data;
+ msg->msg_hdr.msg.put.match_bits = cpu_to_le64(match_bits);
+ msg->msg_hdr.msg.put.ptl_index = cpu_to_le32(portal);
+ msg->msg_hdr.msg.put.offset = cpu_to_le32(offset);
+ msg->msg_hdr.msg.put.hdr_data = hdr_data;
- ptl_commit_md(md, msg);
+ lnet_commit_md(md, msg);
msg->msg_ev.type = LNET_EVENT_SEND;
msg->msg_ev.initiator.nid = LNET_NID_ANY;
- msg->msg_ev.initiator.pid = lnet_apini.apini_pid;
+ msg->msg_ev.initiator.pid = the_lnet.ln_pid;
msg->msg_ev.pt_index = portal;
msg->msg_ev.match_bits = match_bits;
msg->msg_ev.rlength = md->md_length;
msg->msg_ev.offset = offset;
msg->msg_ev.hdr_data = hdr_data;
- ptl_md_deconstruct(md, &msg->msg_ev.md);
- ptl_md2handle(&msg->msg_ev.md_handle, md);
+ lnet_md_deconstruct(md, &msg->msg_ev.md);
+ lnet_md2handle(&msg->msg_ev.md_handle, md);
- lnet_apini.apini_counters.send_count++;
- lnet_apini.apini_counters.send_length += md->md_length;
+ the_lnet.ln_counters.send_count++;
+ the_lnet.ln_counters.send_length += md->md_length;
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- rc = ptl_send (NULL, NULL, msg, &hdr, PTL_MSG_PUT, target,
+ rc = lnet_send(NULL, NULL, msg, LNET_MSG_PUT, target,
md, 0, md->md_length);
if (rc != 0) {
CERROR("Error sending PUT to %s: %d\n",
return 0;
}
-ptl_msg_t *
-lnet_create_reply_msg (ptl_ni_t *ni, lnet_nid_t peer_nid, ptl_msg_t *getmsg)
+lnet_msg_t *
+lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *getmsg)
{
- /* The NAL can DMA direct to the GET md (i.e. no REPLY msg). This
- * returns a msg for the NAL to pass to lnet_finalize() when the sink
+ /* The LND can DMA direct to the GET md (i.e. no REPLY msg). This
+ * returns a msg for the LND to pass to lnet_finalize() when the sink
* data has been received.
*
* CAVEAT EMPTOR: 'getmsg' is the original GET, which is freed when
- * lnet_finalize() is called on it, so the NAL must call this first */
+ * lnet_finalize() is called on it, so the LND must call this first */
- ptl_msg_t *msg = ptl_msg_alloc();
- ptl_libmd_t *getmd = getmsg->msg_md;
+ lnet_msg_t *msg = lnet_msg_alloc();
+ lnet_libmd_t *getmd = getmsg->msg_md;
+ lnet_nid_t peer_nid = getmsg->msg_target.nid;
unsigned long flags;
- PTL_LOCK(flags);
+ LASSERT (!getmsg->msg_target_is_router);
+ LASSERT (!getmsg->msg_routing);
+
+ LNET_LOCK(flags);
LASSERT (getmd->md_pending > 0);
CDEBUG(D_NET, "%s: Reply from %s md %p\n",
libcfs_nid2str(ni->ni_nid), libcfs_nid2str(peer_nid), getmd);
- ptl_commit_md (getmd, msg);
+ lnet_commit_md (getmd, msg);
msg->msg_ev.type = LNET_EVENT_REPLY;
msg->msg_ev.initiator.nid = peer_nid;
msg->msg_ev.rlength = msg->msg_ev.mlength = getmd->md_length;
msg->msg_ev.offset = 0;
- ptl_md_deconstruct(getmd, &msg->msg_ev.md);
- ptl_md2handle(&msg->msg_ev.md_handle, getmd);
+ lnet_md_deconstruct(getmd, &msg->msg_ev.md);
+ lnet_md2handle(&msg->msg_ev.md_handle, getmd);
- lnet_apini.apini_counters.recv_count++;
- lnet_apini.apini_counters.recv_length += getmd->md_length;
+ the_lnet.ln_counters.recv_count++;
+ the_lnet.ln_counters.recv_length += getmd->md_length;
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
return msg;
drop_msg:
- ptl_msg_free(msg);
+ lnet_msg_free(msg);
drop:
- lnet_apini.apini_counters.drop_count++;
- lnet_apini.apini_counters.drop_length += getmd->md_length;
+ the_lnet.ln_counters.drop_count++;
+ the_lnet.ln_counters.drop_length += getmd->md_length;
- PTL_UNLOCK (flags);
+ LNET_UNLOCK (flags);
return NULL;
}
lnet_process_id_t target, unsigned int portal,
__u64 match_bits, unsigned int offset)
{
- ptl_msg_t *msg;
- ptl_hdr_t hdr;
- ptl_libmd_t *md;
+ lnet_msg_t *msg;
+ lnet_libmd_t *md;
unsigned long flags;
int rc;
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
- if (!list_empty (&lnet_apini.apini_test_peers) && /* normally we don't */
+ if (!list_empty (&the_lnet.ln_test_peers) && /* normally we don't */
fail_peer (target.nid, 1)) /* shall we now? */
{
CERROR("Dropping GET to %s: simulated failure\n",
return -EIO;
}
- msg = ptl_msg_alloc();
+ msg = lnet_msg_alloc();
if (msg == NULL) {
- CERROR("Dropping GET to %s: ENOMEM on ptl_msg_t\n",
+ CERROR("Dropping GET to %s: ENOMEM on lnet_msg_t\n",
libcfs_id2str(target));
return -ENOMEM;
}
- PTL_LOCK(flags);
+ LNET_LOCK(flags);
- md = ptl_handle2md(&mdh);
+ md = lnet_handle2md(&mdh);
if (md == NULL || md->md_threshold == 0) {
- ptl_msg_free(msg);
- PTL_UNLOCK(flags);
+ lnet_msg_free(msg);
+ LNET_UNLOCK(flags);
CERROR("Dropping GET to %s: MD invalid\n",
libcfs_id2str(target));
CDEBUG(D_NET, "LNetGet -> %s\n", libcfs_id2str(target));
- memset (&hdr, 0, sizeof (hdr));
+ memset (&msg->msg_hdr, 0, sizeof (msg->msg_hdr));
/* NB handles only looked up by creator (no flips) */
- hdr.msg.get.return_wmd.wh_interface_cookie =
- lnet_apini.apini_interface_cookie;
- hdr.msg.get.return_wmd.wh_object_cookie = md->md_lh.lh_cookie;
+ msg->msg_hdr.msg.get.return_wmd.wh_interface_cookie =
+ the_lnet.ln_interface_cookie;
+ msg->msg_hdr.msg.get.return_wmd.wh_object_cookie =
+ md->md_lh.lh_cookie;
- hdr.msg.get.match_bits = cpu_to_le64(match_bits);
- hdr.msg.get.ptl_index = cpu_to_le32(portal);
- hdr.msg.get.src_offset = cpu_to_le32(offset);
- hdr.msg.get.sink_length = cpu_to_le32(md->md_length);
+ msg->msg_hdr.msg.get.match_bits = cpu_to_le64(match_bits);
+ msg->msg_hdr.msg.get.ptl_index = cpu_to_le32(portal);
+ msg->msg_hdr.msg.get.src_offset = cpu_to_le32(offset);
+ msg->msg_hdr.msg.get.sink_length = cpu_to_le32(md->md_length);
- ptl_commit_md(md, msg);
+ lnet_commit_md(md, msg);
msg->msg_ev.type = LNET_EVENT_SEND;
msg->msg_ev.initiator.nid = LNET_NID_ANY;
- msg->msg_ev.initiator.pid = lnet_apini.apini_pid;
+ msg->msg_ev.initiator.pid = the_lnet.ln_pid;
msg->msg_ev.pt_index = portal;
msg->msg_ev.match_bits = match_bits;
msg->msg_ev.rlength = md->md_length;
msg->msg_ev.offset = offset;
msg->msg_ev.hdr_data = 0;
- ptl_md_deconstruct(md, &msg->msg_ev.md);
- ptl_md2handle(&msg->msg_ev.md_handle, md);
+ lnet_md_deconstruct(md, &msg->msg_ev.md);
+ lnet_md2handle(&msg->msg_ev.md_handle, md);
- lnet_apini.apini_counters.send_count++;
+ the_lnet.ln_counters.send_count++;
- PTL_UNLOCK(flags);
+ LNET_UNLOCK(flags);
- rc = ptl_send (NULL, NULL, msg, &hdr, PTL_MSG_GET, target,
+ rc = lnet_send(NULL, NULL, msg, LNET_MSG_GET, target,
NULL, 0, 0);
if (rc != 0) {
CERROR("error sending GET to %s: %d\n",
int
LNetDist (lnet_nid_t nid, int *order)
{
- LASSERT (lnet_apini.apini_init);
- LASSERT (lnet_apini.apini_refcount > 0);
+ LASSERT (the_lnet.ln_init);
+ LASSERT (the_lnet.ln_refcount > 0);
return kpr_distance(nid, order);
}
#include <lnet/lib-lnet.h>
void
-ptl_enq_event_locked (void *private, ptl_eq_t *eq, lnet_event_t *ev)
+lnet_enq_event_locked (void *private, lnet_eq_t *eq, lnet_event_t *ev)
{
lnet_event_t *eq_slot;
eq_slot = eq->eq_events + (ev->sequence & (eq->eq_size - 1));
/* There is no race since both event consumers and event producers
- * take the PTL_LOCK, so we don't screw around with memory
+ * take the LNET_LOCK, so we don't screw around with memory
* barriers, setting the sequence number last or wierd structure
* layout assertions. */
*eq_slot = *ev;
/* Wake anyone sleeping for an event (see lib-eq.c) */
#ifdef __KERNEL__
- if (cfs_waitq_active(&lnet_apini.apini_waitq))
- cfs_waitq_broadcast(&lnet_apini.apini_waitq);
+ if (cfs_waitq_active(&the_lnet.ln_waitq))
+ cfs_waitq_broadcast(&the_lnet.ln_waitq);
#else
- pthread_cond_broadcast(&lnet_apini.apini_cond);
+ pthread_cond_broadcast(&the_lnet.ln_cond);
#endif
}
void
-lnet_finalize (ptl_ni_t *ni, void *private, ptl_msg_t *msg, int status)
+lnet_finalize (lnet_ni_t *ni, void *private, lnet_msg_t *msg, int status)
{
- ptl_libmd_t *md;
+ lnet_libmd_t *md;
int unlink;
unsigned long flags;
int rc;
- ptl_hdr_t ack;
+ int send_ack;
if (msg == NULL)
return;
- /* Only send an ACK if the PUT completed successfully */
- if (status == 0 &&
- !ptl_is_wire_handle_none(&msg->msg_ack_wmd)) {
-
- LASSERT(msg->msg_ev.type == LNET_EVENT_PUT);
-
- memset (&ack, 0, sizeof (ack));
- ack.msg.ack.dst_wmd = msg->msg_ack_wmd;
- ack.msg.ack.match_bits = msg->msg_ev.match_bits;
- ack.msg.ack.mlength = cpu_to_le32(msg->msg_ev.mlength);
-
- rc = ptl_send (ni, private, NULL, &ack, PTL_MSG_ACK,
- msg->msg_ev.initiator, NULL, 0, 0);
- if (rc != 0) {
- /* send failed: there's nothing else to clean up. */
- CERROR("Error %d sending ACK to %s\n",
- rc, libcfs_id2str(msg->msg_ev.initiator));
- }
- }
+ LNET_LOCK(flags);
md = msg->msg_md;
+ if (md != NULL) {
+ /* Now it's safe to drop my caller's ref */
+ md->md_pending--;
+ LASSERT (md->md_pending >= 0);
+
+ /* Should I unlink this MD? */
+ if (md->md_pending != 0) /* other refs */
+ unlink = 0;
+ else if ((md->md_flags & LNET_MD_FLAG_ZOMBIE) != 0)
+ unlink = 1;
+ else if ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) == 0)
+ unlink = 0;
+ else
+ unlink = lnet_md_exhausted(md);
+
+ msg->msg_ev.status = status;
+ msg->msg_ev.unlinked = unlink;
+
+ if (md->md_eq != NULL)
+ lnet_enq_event_locked(private, md->md_eq, &msg->msg_ev);
+
+ if (unlink)
+ lnet_md_unlink(md);
+
+ msg->msg_md = NULL;
+ }
+
+ /* Only send an ACK if the PUT completed successfully */
+ send_ack = (status == 0 &&
+ !lnet_is_wire_handle_none(&msg->msg_ack_wmd));
- PTL_LOCK(flags);
-
- /* Now it's safe to drop my caller's ref */
- md->md_pending--;
- LASSERT (md->md_pending >= 0);
-
- /* Should I unlink this MD? */
- if (md->md_pending != 0) /* other refs */
- unlink = 0;
- else if ((md->md_flags & PTL_MD_FLAG_ZOMBIE) != 0)
- unlink = 1;
- else if ((md->md_flags & PTL_MD_FLAG_AUTO_UNLINK) == 0)
- unlink = 0;
- else
- unlink = ptl_md_exhausted(md);
-
- msg->msg_ev.status = status;
- msg->msg_ev.unlinked = unlink;
-
- if (md->md_eq != NULL)
- ptl_enq_event_locked(private, md->md_eq, &msg->msg_ev);
-
- if (unlink)
- ptl_md_unlink(md);
-
- list_del (&msg->msg_list);
- lnet_apini.apini_counters.msgs_alloc--;
- ptl_msg_free(msg);
-
- PTL_UNLOCK(flags);
-}
+ if (!send_ack) {
+ list_del (&msg->msg_activelist);
+ the_lnet.ln_counters.msgs_alloc--;
+ lnet_msg_free(msg);
-lnet_pid_t lnet_getpid(void)
-{
- return lnet_apini.apini_pid;
+ LNET_UNLOCK(flags);
+ return;
+ }
+
+ LNET_UNLOCK(flags);
+
+ LASSERT(msg->msg_ev.type == LNET_EVENT_PUT);
+
+ memset (&msg->msg_hdr, 0, sizeof(msg->msg_hdr));
+ msg->msg_hdr.msg.ack.dst_wmd = msg->msg_ack_wmd;
+ msg->msg_hdr.msg.ack.match_bits = msg->msg_ev.match_bits;
+ msg->msg_hdr.msg.ack.mlength = cpu_to_le32(msg->msg_ev.mlength);
+
+ msg->msg_ack_wmd = LNET_WIRE_HANDLE_NONE;
+
+ rc = lnet_send(ni, private, msg, LNET_MSG_ACK,
+ msg->msg_ev.initiator, NULL, 0, 0);
+ if (rc != 0) {
+ /* send failed: there's nothing else to clean up. */
+ CERROR("Error %d sending ACK to %s\n",
+ rc, libcfs_id2str(msg->msg_ev.initiator));
+
+ LNET_LOCK(flags);
+ list_del (&msg->msg_activelist);
+ the_lnet.ln_counters.msgs_alloc--;
+ lnet_msg_free(msg);
+ LNET_UNLOCK(flags);
+ }
}
#include <lnet/lib-lnet.h>
int
-lonal_send (ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int target_is_router,
- int routing,
- unsigned int payload_niov,
- struct iovec *payload_iov,
- lnet_kiov_t *payload_kiov,
- unsigned int payload_offset,
- unsigned int payload_nob)
+lolnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
- lo_desc_t lod = { .lod_niov = payload_niov,
- .lod_offset = payload_offset,
- .lod_nob = payload_nob};
int rc;
- LASSERT (!routing);
+ LASSERT (!lntmsg->msg_routing);
+ LASSERT (!lntmsg->msg_target_is_router);
- if (payload_nob == 0 || payload_iov != NULL) {
- lod.lod_type = LOD_IOV;
- lod.lod_iov.iov = payload_iov;
- } else {
-#ifndef __KERNEL__
- LBUG();
-#else
- lod.lod_type = LOD_KIOV;
- lod.lod_iov.kiov = payload_kiov;
-#endif
- }
-
- rc = lnet_parse(ni, hdr, &lod);
- if (rc == 0)
- lnet_finalize(ni, private, ptlmsg, 0);
+ rc = lnet_parse(ni, &lntmsg->msg_hdr, lntmsg);
+ if (rc >= 0)
+ lnet_finalize(ni, private, lntmsg, 0);
return rc;
}
-void
-lonal_copy_iov(lo_desc_t *lod,
- unsigned int niov,
- struct iovec *iov,
- unsigned int offset,
- unsigned int mlen)
-{
- /* I only copy iovec->iovec */
- LASSERT(lod->lod_type == LOD_IOV);
- LASSERT(mlen > 0);
-
- while (offset >= iov->iov_len) {
- offset -= iov->iov_len;
- iov++;
- niov--;
- LASSERT(niov > 0);
- }
-
- while (lod->lod_offset >= lod->lod_iov.iov->iov_len) {
- lod->lod_offset -= lod->lod_iov.iov->iov_len;
- lod->lod_iov.iov++;
- lod->lod_niov--;
- LASSERT(lod->lod_niov > 0);
- }
-
- do {
- int fraglen = MIN(iov->iov_len - offset,
- lod->lod_iov.iov->iov_len - lod->lod_offset);
-
- LASSERT(niov > 0);
- LASSERT(lod->lod_niov > 0);
-
- if (fraglen > mlen)
- fraglen = mlen;
-
- memcpy((void *)((unsigned long)iov->iov_base + offset),
- (void *)((unsigned long)lod->lod_iov.iov->iov_base +
- lod->lod_offset),
- fraglen);
-
- if (offset + fraglen < iov->iov_len) {
- offset += fraglen;
- } else {
- offset = 0;
- iov++;
- niov--;
- }
-
- if (lod->lod_offset + fraglen < lod->lod_iov.iov->iov_len ) {
- lod->lod_offset += fraglen;
- } else {
- lod->lod_offset = 0;
- lod->lod_iov.iov++;
- lod->lod_niov--;
- }
-
- mlen -= fraglen;
- } while (mlen > 0);
-}
-
-void
-lonal_copy_kiov(lo_desc_t *lod,
- unsigned int niov,
- lnet_kiov_t *kiov,
- unsigned int offset,
- unsigned int mlen)
+int
+lolnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
+ unsigned int offset, unsigned int mlen, unsigned int rlen)
{
-#ifndef __KERNEL__
- LBUG();
-#else
- void *srcaddr = NULL;
- void *dstaddr = NULL;
- unsigned long srcfrag = 0;
- unsigned long dstfrag = 0;
- unsigned long fraglen;
-
- /* I only copy kiov->kiov */
- LASSERT(lod->lod_type == LOD_KIOV);
- LASSERT(mlen > 0);
-
- while (offset >= kiov->kiov_len) {
- offset -= kiov->kiov_len;
- kiov++;
- niov--;
- LASSERT(niov > 0);
- }
-
- while (lod->lod_offset >= lod->lod_iov.kiov->kiov_len) {
- lod->lod_offset -= lod->lod_iov.kiov->kiov_len;
- lod->lod_iov.kiov++;
- lod->lod_niov--;
- LASSERT(lod->lod_niov > 0);
- }
-
- do {
- /* CAVEAT EMPTOR: I kmap 2 pages at once == slight risk of deadlock */
- LASSERT(niov > 0);
- if (dstaddr == NULL) {
- dstaddr = (void *)((unsigned long)kmap(kiov->kiov_page) +
- kiov->kiov_offset + offset);
- dstfrag = kiov->kiov_len - offset;
- }
-
- LASSERT(lod->lod_niov > 0);
- if (srcaddr == NULL) {
- srcaddr = (void *)((unsigned long)kmap(lod->lod_iov.kiov->kiov_page) +
- lod->lod_iov.kiov->kiov_offset + lod->lod_offset);
- srcfrag = lod->lod_iov.kiov->kiov_len - lod->lod_offset;
- }
-
- fraglen = MIN(srcfrag, dstfrag);
- if (fraglen > mlen)
- fraglen = mlen;
-
- memcpy(dstaddr, srcaddr, fraglen);
-
- if (fraglen < dstfrag) {
- dstfrag -= fraglen;
- dstaddr = (void *)((unsigned long)dstaddr + fraglen);
- } else {
- kunmap(kiov->kiov_page);
- dstaddr = NULL;
- offset = 0;
- kiov++;
- niov--;
- }
-
- if (fraglen < srcfrag) {
- srcfrag -= fraglen;
- srcaddr = (void *)((unsigned long)srcaddr + fraglen);
- } else {
- kunmap(lod->lod_iov.kiov->kiov_page);
- srcaddr = NULL;
- lod->lod_offset = 0;
- lod->lod_iov.kiov++;
- lod->lod_niov--;
- }
+ lnet_msg_t *sendmsg = private;
- mlen -= fraglen;
- } while (mlen > 0);
+ LASSERT (!delayed);
- if (dstaddr != NULL)
- kunmap(kiov->kiov_page);
+ if (lntmsg == NULL) /* discarding */
+ return 0;
- if (srcaddr != NULL)
- kunmap(lod->lod_iov.kiov->kiov_page);
-#endif
-}
-
-int
-lonal_recv(ptl_ni_t *ni,
- void *private,
- ptl_msg_t *ptlmsg,
- unsigned int niov,
- struct iovec *iov,
- lnet_kiov_t *kiov,
- unsigned int offset,
- unsigned int mlen,
- unsigned int rlen)
-{
- lo_desc_t *lod = (lo_desc_t *)private;
-
- if (mlen != 0) {
+ if (sendmsg->msg_iov != NULL) {
if (iov != NULL)
- lonal_copy_iov(lod, niov, iov, offset, mlen);
+ lnet_copy_iov2iov(niov, iov, offset,
+ sendmsg->msg_niov, sendmsg->msg_iov,
+ sendmsg->msg_offset, mlen);
else
- lonal_copy_kiov(lod, niov, kiov, offset, mlen);
+ lnet_copy_iov2kiov(niov, kiov, offset,
+ sendmsg->msg_niov, sendmsg->msg_iov,
+ sendmsg->msg_offset, mlen);
+ } else {
+ if (iov != NULL)
+ lnet_copy_kiov2iov(niov, iov, offset,
+ sendmsg->msg_niov, sendmsg->msg_kiov,
+ sendmsg->msg_offset, mlen);
+ else
+ lnet_copy_kiov2kiov(niov, kiov, offset,
+ sendmsg->msg_niov, sendmsg->msg_kiov,
+ sendmsg->msg_offset, mlen);
}
- lnet_finalize(ni, private, ptlmsg, 0);
+ lnet_finalize(ni, private, lntmsg, 0);
return 0;
}
-
-static int lonal_instanced;
+static int lolnd_instanced;
void
-lonal_shutdown(ptl_ni_t *ni)
+lolnd_shutdown(lnet_ni_t *ni)
{
CDEBUG (D_NET, "shutdown\n");
- LASSERT (lonal_instanced);
+ LASSERT (lolnd_instanced);
- lonal_instanced = 0;
+ lolnd_instanced = 0;
}
int
-lonal_startup (ptl_ni_t *ni)
+lolnd_startup (lnet_ni_t *ni)
{
- LASSERT (ni->ni_nal == &ptl_lonal);
- LASSERT (!lonal_instanced);
- lonal_instanced = 1;
+ LASSERT (ni->ni_lnd == &the_lolnd);
+ LASSERT (!lolnd_instanced);
+ lolnd_instanced = 1;
return (0);
}
-ptl_nal_t ptl_lonal = {
- .nal_type = LONAL,
- .nal_startup = lonal_startup,
- .nal_shutdown = lonal_shutdown,
- .nal_send = lonal_send,
- .nal_recv = lonal_recv,
+lnd_t the_lolnd = {
+ .lnd_type = LOLND,
+ .lnd_startup = lolnd_startup,
+ .lnd_shutdown = lolnd_shutdown,
+ .lnd_send = lolnd_send,
+ .lnd_recv = lolnd_recv,
};
-ptl_ni_t *ptl_loni;
+lnet_ni_t *lnet_loni;
CFS_MODULE_PARM(config_on_load, "i", int, 0444,
"configure network at module load");
-static int kportal_ioctl(unsigned int cmd, struct portal_ioctl_data *data)
+static int lnet_ioctl(unsigned int cmd, struct portal_ioctl_data *data)
{
int initrc;
int rc;
if (cmd == IOC_PORTAL_UNCONFIGURE) {
/* ghastly hack to prevent repeated net config */
- PTL_MUTEX_DOWN(&lnet_apini.apini_api_mutex);
- initrc = lnet_apini.apini_niinit_self;
- lnet_apini.apini_niinit_self = 0;
- rc = lnet_apini.apini_refcount;
- PTL_MUTEX_UP(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_api_mutex);
+ initrc = the_lnet.ln_niinit_self;
+ the_lnet.ln_niinit_self = 0;
+ rc = the_lnet.ln_refcount;
+ LNET_MUTEX_UP(&the_lnet.ln_api_mutex);
if (initrc) {
rc--;
rc = LNetCtl(cmd, data);
if (initrc == 0) {
- PTL_MUTEX_DOWN(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_api_mutex);
/* I instantiated the network */
- lnet_apini.apini_niinit_self = 1;
- PTL_MUTEX_UP(&lnet_apini.apini_api_mutex);
+ the_lnet.ln_niinit_self = 1;
+ LNET_MUTEX_UP(&the_lnet.ln_api_mutex);
} else {
LNetNIFini();
}
return rc;
}
-DECLARE_IOCTL_HANDLER(kportal_ioctl_handler, kportal_ioctl);
+DECLARE_IOCTL_HANDLER(lnet_ioctl_handler, lnet_ioctl);
-static int init_kportals_module(void)
+static int init_lnet(void)
{
int rc;
ENTRY;
}
if (config_on_load) {
- PTL_MUTEX_DOWN(&lnet_apini.apini_api_mutex);
- lnet_apini.apini_niinit_self = 1;
- PTL_MUTEX_UP(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_api_mutex);
+ the_lnet.ln_niinit_self = 1;
+ LNET_MUTEX_UP(&the_lnet.ln_api_mutex);
rc = LNetNIInit(LUSTRE_SRV_PTL_PID);
if (rc != 0) {
/* Can't LNetFini or fail now if I loaded NALs */
- PTL_MUTEX_DOWN(&lnet_apini.apini_api_mutex);
- lnet_apini.apini_niinit_self = 0;
- PTL_MUTEX_UP(&lnet_apini.apini_api_mutex);
+ LNET_MUTEX_DOWN(&the_lnet.ln_api_mutex);
+ the_lnet.ln_niinit_self = 0;
+ LNET_MUTEX_UP(&the_lnet.ln_api_mutex);
}
}
- rc = libcfs_register_ioctl(&kportal_ioctl_handler);
+ rc = libcfs_register_ioctl(&lnet_ioctl_handler);
LASSERT (rc == 0);
RETURN(rc);
}
-static void exit_kportals_module(void)
+static void fini_lnet(void)
{
int rc;
- rc = libcfs_deregister_ioctl(&kportal_ioctl_handler);
+ rc = libcfs_deregister_ioctl(&lnet_ioctl_handler);
LASSERT (rc == 0);
LNetFini();
}
-EXPORT_SYMBOL(lnet_register_nal);
-EXPORT_SYMBOL(lnet_unregister_nal);
+EXPORT_SYMBOL(lnet_register_lnd);
+EXPORT_SYMBOL(lnet_unregister_lnd);
EXPORT_SYMBOL(LNetMEAttach);
EXPORT_SYMBOL(LNetMEInsert);
EXPORT_SYMBOL(LNetMDBind);
EXPORT_SYMBOL(LNetDist);
EXPORT_SYMBOL(LNetCtl);
-EXPORT_SYMBOL(lnet_apini);
+EXPORT_SYMBOL(the_lnet);
EXPORT_SYMBOL(lnet_iov_nob);
-EXPORT_SYMBOL(lnet_copy_iov2buf);
-EXPORT_SYMBOL(lnet_copy_buf2iov);
EXPORT_SYMBOL(lnet_extract_iov);
EXPORT_SYMBOL(lnet_kiov_nob);
-EXPORT_SYMBOL(lnet_copy_kiov2buf);
-EXPORT_SYMBOL(lnet_copy_buf2kiov);
EXPORT_SYMBOL(lnet_extract_kiov);
+EXPORT_SYMBOL(lnet_copy_iov2iov);
+EXPORT_SYMBOL(lnet_copy_iov2kiov);
+EXPORT_SYMBOL(lnet_copy_kiov2iov);
+EXPORT_SYMBOL(lnet_copy_kiov2kiov);
EXPORT_SYMBOL(lnet_finalize);
EXPORT_SYMBOL(lnet_parse);
EXPORT_SYMBOL(lnet_create_reply_msg);
EXPORT_SYMBOL(lnet_net2ni);
-EXPORT_SYMBOL(lnet_getpid);
MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
MODULE_DESCRIPTION("Portals v3.1");
MODULE_LICENSE("GPL");
-cfs_module(portals, "1.0.0", init_kportals_module, exit_kportals_module);
+cfs_module(portals, "1.0.0", init_lnet, fini_lnet);
}
int
-lnet_notify (ptl_ni_t *ni, lnet_nid_t gateway_nid, int alive, time_t when)
+lnet_notify (lnet_ni_t *ni, lnet_nid_t gateway_nid, int alive, time_t when)
{
unsigned long flags;
int found;
/* userland notified me: notify NAL? */
ni = lnet_net2ni(PTL_NIDNET(gateway_nid));
if (ni != NULL) {
- ni->ni_nal->nal_notify(ni, gateway_nid, alive);
- ptl_ni_decref(ni);
+ ni->ni_lnd->lnd_notify(ni, gateway_nid, alive);
+ lnet_ni_decref(ni);
}
} else {
/* It wasn't userland that notified me... */
void
kpr_update_weight (kpr_gateway_entry_t *ge, int nob)
{
- int weight = 1 + (nob + sizeof (ptl_hdr_t)/2)/sizeof (ptl_hdr_t);
+ int weight = 1 + (nob + sizeof (lnet_hdr_t)/2)/sizeof (lnet_hdr_t);
/* We've chosen this route entry (i.e. gateway) to forward payload
* of length 'nob'; update the route's weight to make it less
}
lnet_nid_t
-lnet_lookup (ptl_ni_t **nip, lnet_nid_t target_nid, int nob)
+lnet_lookup (lnet_ni_t **nip, lnet_nid_t target_nid, int nob)
{
- ptl_ni_t *ni = *nip;
+ lnet_ni_t *ni = *nip;
lnet_nid_t gwnid;
struct list_head *e;
kpr_net_entry_t *ne = NULL;
kpr_route_entry_t *re;
int found;
unsigned long flags;
- ptl_ni_t *gwni = NULL;
+ lnet_ni_t *gwni = NULL;
kpr_gateway_entry_t *ge = NULL;
__u32 target_net = PTL_NIDNET(target_nid);
__u32 gateway_net;
return target_nid;
}
} else { /* ni already determined */
- if (PTL_NETNAL(PTL_NIDNET(ni->ni_nid)) == LONAL ||
+ if (PTL_NETTYP(PTL_NIDNET(ni->ni_nid)) == LOLND ||
target_net == PTL_NIDNET(ni->ni_nid) ||
- (lnet_apini.apini_ptlcompat > 0 &&
- PTL_NETNAL(target_net) == 0)) {
- ptl_ni_addref(ni); /* extra ref so caller can drop blindly */
+ (the_lnet.ln_ptlcompat > 0 &&
+ PTL_NETTYP(target_net) == 0)) {
+ lnet_ni_addref(ni); /* extra ref so caller can drop blindly */
return target_nid;
}
}
kpr_ge_isbetter (ge, re->kpre_gateway))
continue;
- } else if (!ptl_islocalnet(gateway_net, NULL)) {
+ } else if (!lnet_islocalnet(gateway_net, NULL)) {
continue; /* not on a local net */
} else if (ge != NULL) {
/* already got 1 candidate gateway */
LASSERT ((gwni == NULL) != (ni == NULL));
if (ni != NULL)
- ptl_ni_addref(ni); /* extra ref so caller can drop blindly */
+ lnet_ni_addref(ni); /* extra ref so caller can drop blindly */
else
*nip = gwni; /* already got a ref */
int dist = -ENETUNREACH;
int order = 0;
- if (ptl_islocalnet(net, orderp))
+ if (lnet_islocalnet(net, orderp))
return 0;
read_lock_irqsave(&kpr_state.kpr_rwlock, flags);
return dist;
}
-void
-lnet_fwd_start (ptl_ni_t *src_ni, kpr_fwd_desc_t *fwd)
-{
- lnet_nid_t target_nid = fwd->kprfd_target_nid;
- __u32 target_net = PTL_NIDNET(target_nid);
- __u32 receiver_net = PTL_NIDNET(src_ni->ni_nid);
- int nob = fwd->kprfd_nob;
- kpr_gateway_entry_t *ge;
- ptl_ni_t *dst_ni;
- ptl_ni_t *tmp_ni;
- unsigned long flags;
- struct list_head *e;
- kpr_net_entry_t *ne = NULL;
- kpr_route_entry_t *re;
- int rc;
- int found;
-
- CDEBUG (D_NET, "src %s sender %s receiver %s target %s\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid),
- libcfs_nid2str(target_nid));
-
- LASSERT (nob == lnet_kiov_nob (fwd->kprfd_niov, fwd->kprfd_kiov));
-
- /* it's not for any local NID (i.e. it's going to get sent) */
- LASSERT (!ptl_islocalnid(target_nid));
-
- fwd->kprfd_src_ni = src_ni; /* stash calling ni */
-
- read_lock_irqsave(&kpr_state.kpr_rwlock, flags);
-
- spin_lock(&kpr_state.kpr_stats_lock);
- kpr_state.kpr_fwd_packets++;
- kpr_state.kpr_fwd_bytes += nob + sizeof(ptl_hdr_t);
- spin_unlock(&kpr_state.kpr_stats_lock);
-
- rc = -EDESTADDRREQ;
- if (target_net == receiver_net) {
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
- LCONSOLE_ERROR("Refusing to forward message from %s for %s "
- "received from %s on %s: it should have been "
- "sent directly\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_target_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid));
- goto failed;
- }
-
- rc = -ESHUTDOWN;
- if (src_ni->ni_shutdown) { /* caller is shutting down */
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
- LCONSOLE_ERROR("Refusing to forward message from %s for %s "
- "received from %s on %s: system shutting down\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_target_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid));
- goto failed;
- }
-
- rc = -ENETUNREACH;
- if (!lnet_forwarding()) { /* I'm not a router */
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
- LCONSOLE_ERROR("Refusing to forward message from %s for %s "
- "received from %s on %s: forwarding disabled!\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_target_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid));
- goto failed;
- }
-
- /* Is the target_nid on a local network? */
- dst_ni = lnet_net2ni(target_net);
- if (dst_ni != NULL) {
- if (dst_ni->ni_nal->nal_fwd == NULL) {
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
- LCONSOLE_ERROR("Refusing to forward message from %s for %s "
- "received from %s on %s: "
- "net %s doesn't route!\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_target_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid),
- libcfs_net2str(PTL_NIDNET(dst_ni->ni_nid)));
- goto failed;
- }
-
- fwd->kprfd_gateway_nid = target_nid;
- atomic_inc (&kpr_state.kpr_queue_depth);
-
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
-
- CDEBUG (D_NET, "forward [%p] %s: src ni %s dst ni %s\n",
- fwd, libcfs_nid2str(target_nid),
- libcfs_nid2str(src_ni->ni_nid),
- libcfs_nid2str(dst_ni->ni_nid));
-
- dst_ni->ni_nal->nal_fwd(dst_ni, fwd);
- ptl_ni_decref(dst_ni);
- return;
- }
-
- /* Search nets */
- found = 0;
- list_for_each (e, &kpr_state.kpr_nets) {
- ne = list_entry (e, kpr_net_entry_t, kpne_list);
-
- found = (ne->kpne_net == target_net);
- if (found)
- break;
- }
-
- if (!found) {
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
- LCONSOLE_ERROR("Can't forward message from %s for %s "
- "received from %s on %s: "
- "no routes to destination network!\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_target_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid));
- goto failed;
- }
-
- /* Search routes for one that has a gateway to target_nid NOT on the caller's network */
- dst_ni = NULL;
- ge = NULL;
- list_for_each (e, &ne->kpne_routes) {
- re = list_entry (e, kpr_route_entry_t, kpre_list);
-
- if (PTL_NIDNET(re->kpre_gateway->kpge_nid) == receiver_net)
- continue; /* don't route to same net */
-
- if (!re->kpre_gateway->kpge_alive)
- continue; /* gateway is dead */
-
- tmp_ni = lnet_net2ni(PTL_NIDNET(re->kpre_gateway->kpge_nid));
- if (tmp_ni == NULL)
- continue;
-
- if (tmp_ni->ni_nal->nal_fwd == NULL) {
- ptl_ni_decref(tmp_ni); /* doesn't forward */
- continue;
- }
-
- if (ge != NULL &&
- kpr_ge_isbetter(ge, re->kpre_gateway)) {
- ptl_ni_decref(tmp_ni);
- continue;
- }
-
- if (dst_ni != NULL)
- ptl_ni_decref(dst_ni);
-
- dst_ni = tmp_ni;
- ge = re->kpre_gateway;
- }
-
- LASSERT ((ge == NULL) == (dst_ni == NULL));
-
- if (ge == NULL) {
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
- LCONSOLE_ERROR("Can't forward message from %s for %s "
- "received from %s on %s: "
- "all relevant gateways are down!\n",
- libcfs_nid2str(fwd->kprfd_source_nid),
- libcfs_nid2str(fwd->kprfd_target_nid),
- libcfs_nid2str(fwd->kprfd_sender_nid),
- libcfs_nid2str(src_ni->ni_nid));
- goto failed;
- }
-
- kpr_update_weight (ge, nob);
-
- fwd->kprfd_gateway_nid = ge->kpge_nid;
- atomic_inc (&kpr_state.kpr_queue_depth);
-
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
-
- CDEBUG (D_NET, "forward [%p] %s: src ni %s dst ni %s gw %s\n",
- fwd, libcfs_nid2str(target_nid),
- libcfs_nid2str(src_ni->ni_nid),
- libcfs_nid2str(dst_ni->ni_nid),
- libcfs_nid2str(fwd->kprfd_gateway_nid));
-
- dst_ni->ni_nal->nal_fwd(dst_ni, fwd);
- ptl_ni_decref(dst_ni);
- return;
-
- failed:
- spin_lock_irqsave(&kpr_state.kpr_stats_lock, flags);
- kpr_state.kpr_fwd_errors++;
- spin_unlock_irqrestore(&kpr_state.kpr_stats_lock, flags);
-
- read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
-
- CDEBUG (D_NET, "Failed to forward [%p] %s from %s\n", fwd,
- libcfs_nid2str(target_nid), libcfs_nid2str(src_ni->ni_nid));
-
- (fwd->kprfd_callback)(src_ni, fwd->kprfd_callback_arg, rc);
-}
-
-void
-lnet_fwd_done (ptl_ni_t *dst_ni, kpr_fwd_desc_t *fwd, int error)
-{
- ptl_ni_t *src_ni = fwd->kprfd_src_ni;
-
- CDEBUG (D_NET, "complete(1) [%p] from %s to %s: %d\n", fwd,
- libcfs_nid2str(src_ni->ni_nid),
- libcfs_nid2str(dst_ni->ni_nid), error);
-
- (fwd->kprfd_callback)(src_ni, fwd->kprfd_callback_arg, error);
-
- atomic_dec (&kpr_state.kpr_queue_depth);
-}
-
int
kpr_add_route (__u32 net, unsigned int hops, lnet_nid_t gateway_nid)
{
*hops = ne->kpne_hops;
*gateway_nid = ge->kpge_nid;
*alive = ge->kpge_alive;
- *ignored = ptl_islocalnet(ne->kpne_net, NULL) ||
- !ptl_islocalnet(PTL_NIDNET(ge->kpge_nid), NULL);
+ *ignored = lnet_islocalnet(ne->kpne_net, NULL) ||
+ !lnet_islocalnet(PTL_NIDNET(ge->kpge_nid), NULL);
read_unlock_irqrestore(&kpr_state.kpr_rwlock,
flags);
EXPORT_SYMBOL(lnet_forwarding);
EXPORT_SYMBOL(lnet_lookup);
-EXPORT_SYMBOL(lnet_fwd_start);
-EXPORT_SYMBOL(lnet_fwd_done);
EXPORT_SYMBOL(lnet_notify);
#else
lnet_nid_t
-lnet_lookup (ptl_ni_t **nip, lnet_nid_t target_nid, int nob)
+lnet_lookup (lnet_ni_t **nip, lnet_nid_t target_nid, int nob)
{
- ptl_ni_t *ni = *nip;
- ptl_ni_t *gwni;
- __u32 target_net = PTL_NIDNET(target_nid);
+ lnet_ni_t *ni = *nip;
+ lnet_ni_t *gwni;
+ __u32 target_net = PTL_NIDNET(target_nid);
if (ni == NULL) { /* ni not determined yet */
gwni = lnet_net2ni(target_net); /* is it a local network? */
}
} else { /* ni already determined */
if (target_net == PTL_NIDNET(ni->ni_nid)) {
- ptl_ni_addref(ni); /* extra ref so caller can drop blindly */
+ lnet_ni_addref(ni); /* extra ref so caller can drop blindly */
return target_nid;
}
}
*
*/
-#ifndef _KPTLROUTER_H
-#define _KPTLROUTER_H
+#ifndef _KLNETROUTER_H
+#define _KLNETROUTER_H
#ifndef EXPORT_SYMTAB
# define EXPORT_SYMTAB
#endif
hops = sri->sri_net->kpne_hops;
nid = sri->sri_route->kpre_gateway->kpge_nid;
alive = sri->sri_route->kpre_gateway->kpge_alive;
- ignored = ptl_islocalnet(sri->sri_net->kpne_net, NULL) ||
- !ptl_islocalnet(sri->sri_route->kpre_gateway->kpge_nid, NULL);
+ ignored = lnet_islocalnet(sri->sri_net->kpne_net, NULL) ||
+ !lnet_islocalnet(sri->sri_route->kpre_gateway->kpge_nid, NULL);
read_unlock_irqrestore(&kpr_state.kpr_rwlock, flags);
typedef struct bridge {
int alive;
- ptl_ni_t *b_ni;
+ lnet_ni_t *b_ni;
void *lower;
void *local;
/* this doesn't really belong here */
/* tunables (via environment) */
int tcpnal_acceptor_port = 988;
-int tcpnal_buffer_size = 2 * (PTL_MTU + sizeof(ptl_hdr_t));
+int tcpnal_buffer_size = 2 * (PTL_MTU + sizeof(lnet_hdr_t));
int tcpnal_nagle = 0;
int
*/
static int compare_connection(void *arg1, void *arg2)
{
- connection c = arg1;
+ connection c = arg1;
lnet_nid_t *nid = arg2;
return (c->peer_nid == *nid);
static connection
allocate_connection(manager m,
- lnet_nid_t nid,
+ lnet_nid_t nid,
int fd)
{
connection c=malloc(sizeof(struct connection));
int
tcpnal_hello (int sockfd, lnet_nid_t nid)
{
- struct timeval tv;
- __u64 incarnation;
- int rc;
- int nob;
+ struct timeval tv;
+ __u64 incarnation;
+ int rc;
+ int nob;
lnet_acceptor_connreq_t cr;
- ptl_hdr_t hdr;
- ptl_magicversion_t hmv;
+ lnet_hdr_t hdr;
+ lnet_magicversion_t hmv;
gettimeofday(&tv, NULL);
incarnation = (((__u64)tv.tv_sec) * 1000000) + tv.tv_usec;
memset(&cr, 0, sizeof(cr));
- cr.acr_magic = PTL_PROTO_ACCEPTOR_MAGIC;
- cr.acr_version = PTL_PROTO_ACCEPTOR_VERSION;
+ cr.acr_magic = LNET_PROTO_ACCEPTOR_MAGIC;
+ cr.acr_version = LNET_PROTO_ACCEPTOR_VERSION;
cr.acr_nid = nid;
/* hmv initialised and copied separately into hdr; compiler "optimize"
* likely due to confusion about pointer alias of hmv and hdr when this
* was done in-place. */
- hmv.magic = cpu_to_le32(PTL_PROTO_TCP_MAGIC);
- hmv.version_major = cpu_to_le32(PTL_PROTO_TCP_VERSION_MAJOR);
- hmv.version_minor = cpu_to_le32(PTL_PROTO_TCP_VERSION_MINOR);
+ hmv.magic = cpu_to_le32(LNET_PROTO_TCP_MAGIC);
+ hmv.version_major = cpu_to_le32(LNET_PROTO_TCP_VERSION_MAJOR);
+ hmv.version_minor = cpu_to_le32(LNET_PROTO_TCP_VERSION_MINOR);
memset (&hdr, 0, sizeof (hdr));
/* hdr.src_nid/src_pid are ignored at dest */
- hdr.type = cpu_to_le32(PTL_MSG_HELLO);
- hdr.msg.hello.type = cpu_to_le32(SOCKNAL_CONN_ANY);
+ hdr.type = cpu_to_le32(LNET_MSG_HELLO);
+ hdr.msg.hello.type = cpu_to_le32(SOCKLND_CONN_ANY);
hdr.msg.hello.incarnation = cpu_to_le64(incarnation);
/* I don't send any interface info */
if (rc != 0)
return -1;
- if (hmv.magic != le32_to_cpu(PTL_PROTO_TCP_MAGIC)) {
+ if (hmv.magic != le32_to_cpu(LNET_PROTO_TCP_MAGIC)) {
CERROR ("Bad magic %#08x (%#08x expected) from %s\n",
- cpu_to_le32(hmv.magic), PTL_PROTO_TCP_MAGIC,
+ cpu_to_le32(hmv.magic), LNET_PROTO_TCP_MAGIC,
libcfs_nid2str(nid));
return -1;
}
- if (hmv.version_major != cpu_to_le16 (PTL_PROTO_TCP_VERSION_MAJOR) ||
- hmv.version_minor != cpu_to_le16 (PTL_PROTO_TCP_VERSION_MINOR)) {
+ if (hmv.version_major != cpu_to_le16 (LNET_PROTO_TCP_VERSION_MAJOR) ||
+ hmv.version_minor != cpu_to_le16 (LNET_PROTO_TCP_VERSION_MINOR)) {
CERROR ("Incompatible protocol version %d.%d (%d.%d expected)"
" from %s\n",
le16_to_cpu (hmv.version_major),
le16_to_cpu (hmv.version_minor),
- PTL_PROTO_TCP_VERSION_MAJOR,
- PTL_PROTO_TCP_VERSION_MINOR,
+ LNET_PROTO_TCP_VERSION_MAJOR,
+ LNET_PROTO_TCP_VERSION_MINOR,
libcfs_nid2str(nid));
return -1;
}
-#if (PTL_PROTO_TCP_VERSION_MAJOR != 1)
+#if (LNET_PROTO_TCP_VERSION_MAJOR != 1)
# error "This code only understands protocol version 1.x"
#endif
/* version 1 sends magic/version as the dest_nid of a 'hello' header,
return -1;
/* ...and check we got what we expected */
- if (hdr.type != cpu_to_le32 (PTL_MSG_HELLO)) {
+ if (hdr.type != cpu_to_le32 (LNET_MSG_HELLO)) {
CERROR ("Expecting a HELLO hdr "
" but got type %d with %d payload from %s\n",
le32_to_cpu (hdr.type),
* Returns: an allocated connection structure, either
* a pre-existing one, or a new connection
*/
-connection force_tcp_connection(manager m,
+connection force_tcp_connection(manager m,
lnet_nid_t nid,
procbridge pb)
{
syscall(SYS_write, p->notifier[0], buf, sizeof(buf));
}
-ptl_nal_t tcpnal_nal = {
- .nal_type = SOCKNAL,
- .nal_startup = procbridge_startup,
- .nal_shutdown = procbridge_shutdown,
- .nal_send = tcpnal_send,
- .nal_recv = tcpnal_recv,
+lnd_t the_tcplnd = {
+ .lnd_type = SOCKLND,
+ .lnd_startup = procbridge_startup,
+ .lnd_shutdown = procbridge_shutdown,
+ .lnd_send = tcpnal_send,
+ .lnd_recv = tcpnal_recv,
};
int tcpnal_running;
* its state using PTL_FINI codepoint
*/
void
-procbridge_shutdown(ptl_ni_t *ni)
+procbridge_shutdown(lnet_ni_t *ni)
{
bridge b=(bridge)ni->ni_data;
procbridge p=(procbridge)b->local;
* error wrapper to cut down clutter.
*/
int
-procbridge_startup (ptl_ni_t *ni)
+procbridge_startup (lnet_ni_t *ni)
{
procbridge p;
bridge b;
* which assigns the src nid/pid on incoming non-privileged connections
* (i.e. us), and we don't accept connections. */
- LASSERT (ni->ni_nal == &tcpnal_nal);
+ LASSERT (ni->ni_lnd == &the_tcplnd);
LASSERT (!tcpnal_running); /* only single instance supported */
LASSERT (ni->ni_interfaces[0] == NULL); /* explicit interface(s) not supported */
extern void procbridge_wakeup_nal(procbridge p);
-extern int procbridge_startup (ptl_ni_t *);
-extern void procbridge_shutdown (ptl_ni_t *);
-
-extern int tcpnal_send(ptl_ni_t *ni, void *private, ptl_msg_t *cookie,
- ptl_hdr_t *hdr, int type, lnet_process_id_t target,
- int routing, unsigned int niov,
- struct iovec *iov, lnet_kiov_t *kiov,
- unsigned int offset, unsigned int len);
-int tcpnal_recv(ptl_ni_t *ni, void *private, ptl_msg_t *cookie,
- unsigned int niov, struct iovec *iov, lnet_kiov_t *kiov,
+extern int procbridge_startup (lnet_ni_t *);
+extern void procbridge_shutdown (lnet_ni_t *);
+
+extern int tcpnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
+int tcpnal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *cookie,
+ int delayed, unsigned int niov,
+ struct iovec *iov, lnet_kiov_t *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
#include <syscall.h>
#endif
-int tcpnal_send(ptl_ni_t *ni,
- void *private,
- ptl_msg_t *cookie,
- ptl_hdr_t *hdr,
- int type,
- lnet_process_id_t target,
- int routing,
- unsigned int niov,
- struct iovec *iov,
- lnet_kiov_t *kiov,
- unsigned int offset,
- unsigned int len)
+/*
+ * sends a packet to the peer, after insuring that a connection exists
+ */
+int tcpnal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
{
+ lnet_hdr_t *hdr = &lntmsg->msg_hdr;
+ lnet_process_id_t target = lntmsg->msg_target;
+ unsigned int niov = lntmsg->msg_niov;
+ struct iovec *iov = lntmsg->msg_iov;
+ unsigned int offset = lntmsg->msg_offset;
+ unsigned int len = lntmsg->msg_len;
+
connection c;
bridge b=(bridge)ni->ni_data;
struct iovec tiov[257];
int ntiov;
int i;
- if (routing) {
- CERROR("Can't route\n");
- return -EIO;
- }
-
if (!(c=force_tcp_connection((manager)b->lower, target.nid,
b->local)))
return(-EIO);
LASSERT (len == 0 || iov != NULL); /* I don't understand kiovs */
tiov[0].iov_base = hdr;
- tiov[0].iov_len = sizeof(ptl_hdr_t);
+ tiov[0].iov_len = sizeof(lnet_hdr_t);
ntiov = 1 + lnet_extract_iov(256, &tiov[1], niov, iov, offset, len);
pthread_mutex_lock(&send_lock);
#endif
#if 0
fprintf (stderr, "sent %s total %d in %d frags\n",
- hdr->type == PTL_MSG_ACK ? "ACK" :
- hdr->type == PTL_MSG_PUT ? "PUT" :
- hdr->type == PTL_MSG_GET ? "GET" :
- hdr->type == PTL_MSG_REPLY ? "REPLY" :
- hdr->type == PTL_MSG_HELLO ? "HELLO" : "UNKNOWN",
+ hdr->type == LNET_MSG_ACK ? "ACK" :
+ hdr->type == LNET_MSG_PUT ? "PUT" :
+ hdr->type == LNET_MSG_GET ? "GET" :
+ hdr->type == LNET_MSG_REPLY ? "REPLY" :
+ hdr->type == LNET_MSG_HELLO ? "HELLO" : "UNKNOWN",
total, niov + 1);
#endif
pthread_mutex_unlock(&send_lock);
if (rc == 0) {
/* NB the NAL only calls lnet_finalize() if it returns 0
* from cb_send() */
- lnet_finalize(ni, private, cookie, 0);
+ lnet_finalize(ni, private, lntmsg, 0);
}
return(rc);
}
-int tcpnal_recv(ptl_ni_t *ni,
+int tcpnal_recv(lnet_ni_t *ni,
void *private,
- ptl_msg_t *cookie,
+ lnet_msg_t *cookie,
+ int delayed,
unsigned int niov,
struct iovec *iov,
lnet_kiov_t *kiov,
if (mlen == 0)
goto finalize;
- LASSERT(mlen);
- LASSERT(rlen);
- LASSERT(rlen >= mlen);
LASSERT(iov != NULL); /* I don't understand kiovs */
ntiov = lnet_extract_iov(256, tiov, niov, iov, offset, mlen);
/* FIXME; we always assume success here... */
lnet_finalize(ni, private, cookie, 0);
+ LASSERT(rlen >= mlen);
+
if (mlen!=rlen){
char *trash=malloc(rlen-mlen);
{
connection c = d;
bridge b = a;
- ptl_hdr_t hdr;
+ lnet_hdr_t hdr;
int rc;
if (read_connection(c, (unsigned char *)&hdr, sizeof(hdr))){
/* replace dest_nid,pid (socknal sets its own) */
hdr.dest_nid = cpu_to_le64(b->b_ni->ni_nid);
- hdr.dest_pid = cpu_to_le32(lnet_getpid());
+ hdr.dest_pid = cpu_to_le32(the_lnet.ln_pid);
rc = lnet_parse(b->b_ni, &hdr, c);
- if (rc != 0) {
+ if (rc < 0) {
CERROR("Error %d from lnet_parse\n", rc);
return 0;
}
do {
nal = va_arg (ap, int);
- if (nal == PTL_NETNAL(g_net)) {
+ if (nal == PTL_NETTYP(g_net)) {
va_end (ap);
return 1;
}
fprintf (stderr,
"Command %s not compatible with %s NAL\n",
cmd,
- libcfs_nal2str(PTL_NETNAL(g_net)));
+ libcfs_lnd2str(PTL_NETTYP(g_net)));
return 0;
}
int index;
int rc;
- if (!g_net_is_compatible (argv[0], SOCKNAL, 0))
+ if (!g_net_is_compatible (argv[0], SOCKLND, 0))
return -1;
for (index = 0;;index++) {
return 0;
}
- if (!g_net_is_compatible(argv[0], SOCKNAL, 0))
+ if (!g_net_is_compatible(argv[0], SOCKLND, 0))
return -1;
if (lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
return 0;
}
- if (!g_net_is_compatible(argv[0], SOCKNAL, 0))
+ if (!g_net_is_compatible(argv[0], SOCKLND, 0))
return -1;
if (argc == 2 &&
int index;
int rc;
- if (!g_net_is_compatible (argv[0], SOCKNAL, RANAL,
- OPENIBNAL, IIBNAL, VIBNAL, 0))
+ if (!g_net_is_compatible (argv[0], SOCKLND, RALND,
+ OPENIBLND, IIBLND, VIBLND, 0))
return -1;
for (index = 0;;index++) {
if (rc != 0)
break;
- if (g_net_is_compatible(NULL, SOCKNAL, 0)) {
+ if (g_net_is_compatible(NULL, SOCKLND, 0)) {
id.nid = data.ioc_nid;
id.pid = data.ioc_u32[4];
printf ("%-20s [%d]%s->%s:%d #%d\n",
ptl_ipaddr_2_str (data.ioc_u32[0], buffer[1], 1), /* peer ip */
data.ioc_u32[1], /* peer port */
data.ioc_u32[3]); /* conn_count */
- } else if (g_net_is_compatible(NULL, RANAL, OPENIBNAL, VIBNAL, 0)) {
+ } else if (g_net_is_compatible(NULL, RALND, OPENIBLND, VIBLND, 0)) {
printf ("%-20s [%d]@%s:%d\n",
libcfs_nid2str(data.ioc_nid),
data.ioc_count,
int port = 0;
int rc;
- if (!g_net_is_compatible (argv[0], SOCKNAL, RANAL,
- OPENIBNAL, IIBNAL, VIBNAL, 0))
+ if (!g_net_is_compatible (argv[0], SOCKLND, RALND,
+ OPENIBLND, IIBLND, VIBLND, 0))
return -1;
- if (g_net_is_compatible(NULL, SOCKNAL, OPENIBNAL, RANAL, 0)) {
+ if (g_net_is_compatible(NULL, SOCKLND, OPENIBLND, RALND, 0)) {
if (argc != 4) {
fprintf (stderr, "usage(tcp,openib,ra): %s nid ipaddr port\n",
argv[0]);
return 0;
}
- } else if (g_net_is_compatible(NULL, VIBNAL, 0)) {
+ } else if (g_net_is_compatible(NULL, VIBLND, 0)) {
if (argc != 3) {
fprintf (stderr, "usage(vib): %s nid ipaddr\n",
argv[0]);
return -1;
}
- if (g_net_is_compatible (NULL, SOCKNAL, OPENIBNAL, VIBNAL, RANAL, 0) &&
+ if (g_net_is_compatible (NULL, SOCKLND, OPENIBLND, VIBLND, RALND, 0) &&
lnet_parse_ipaddr (&ip, argv[2]) != 0) {
fprintf (stderr, "Can't parse ip addr: %s\n", argv[2]);
return -1;
}
- if (g_net_is_compatible (NULL, SOCKNAL, OPENIBNAL, RANAL, 0) &&
+ if (g_net_is_compatible (NULL, SOCKLND, OPENIBLND, RALND, 0) &&
lnet_parse_port (&port, argv[3]) != 0) {
fprintf (stderr, "Can't parse port: %s\n", argv[3]);
return -1;
__u32 ip = 0;
int rc;
- if (!g_net_is_compatible (argv[0], SOCKNAL, RANAL,
- OPENIBNAL, IIBNAL, VIBNAL, 0))
+ if (!g_net_is_compatible (argv[0], SOCKLND, RALND,
+ OPENIBLND, IIBLND, VIBLND, 0))
return -1;
- if (g_net_is_compatible(NULL, SOCKNAL, 0)) {
+ if (g_net_is_compatible(NULL, SOCKLND, 0)) {
if (argc > 3) {
fprintf (stderr, "usage: %s [nid] [ipaddr]\n",
argv[0]);
return -1;
}
- if (g_net_is_compatible(NULL, SOCKNAL, 0)) {
+ if (g_net_is_compatible(NULL, SOCKLND, 0)) {
if (argc > 2 &&
lnet_parse_ipaddr (&ip, argv[2]) != 0) {
fprintf (stderr, "Can't parse ip addr: %s\n",
int index;
int rc;
- if (!g_net_is_compatible (argv[0], SOCKNAL, RANAL,
- OPENIBNAL, IIBNAL, VIBNAL, 0))
+ if (!g_net_is_compatible (argv[0], SOCKLND, RALND,
+ OPENIBLND, IIBLND, VIBLND, 0))
return -1;
for (index = 0; ; index++) {
if (rc != 0)
break;
- if (g_net_is_compatible (NULL, SOCKNAL, 0)) {
+ if (g_net_is_compatible (NULL, SOCKLND, 0)) {
id.nid = data.ioc_nid;
id.pid = data.ioc_u32[6];
printf ("%-20s %s[%d]%s->%s:%d %d/%d %s\n",
libcfs_id2str(id),
- (data.ioc_u32[3] == SOCKNAL_CONN_ANY) ? "A" :
- (data.ioc_u32[3] == SOCKNAL_CONN_CONTROL) ? "C" :
- (data.ioc_u32[3] == SOCKNAL_CONN_BULK_IN) ? "I" :
- (data.ioc_u32[3] == SOCKNAL_CONN_BULK_OUT) ? "O" : "?",
+ (data.ioc_u32[3] == SOCKLND_CONN_ANY) ? "A" :
+ (data.ioc_u32[3] == SOCKLND_CONN_CONTROL) ? "C" :
+ (data.ioc_u32[3] == SOCKLND_CONN_BULK_IN) ? "I" :
+ (data.ioc_u32[3] == SOCKLND_CONN_BULK_OUT) ? "O" : "?",
data.ioc_u32[4], /* scheduler */
ptl_ipaddr_2_str (data.ioc_u32[2], buffer[0], 1), /* local IP addr */
ptl_ipaddr_2_str (data.ioc_u32[0], buffer[1], 1), /* remote IP addr */
data.ioc_count, /* tx buffer size */
data.ioc_u32[5], /* rx buffer size */
data.ioc_flags ? "nagle" : "nonagle");
- } else if (g_net_is_compatible (NULL, RANAL, 0)) {
+ } else if (g_net_is_compatible (NULL, RALND, 0)) {
printf ("%-20s [%d]\n",
libcfs_nid2str(data.ioc_nid),
data.ioc_u32[0] /* device id */);
return 0;
}
- if (!g_net_is_compatible (NULL, SOCKNAL, RANAL,
- OPENIBNAL, IIBNAL, VIBNAL, 0))
+ if (!g_net_is_compatible (NULL, SOCKLND, RALND,
+ OPENIBLND, IIBLND, VIBLND, 0))
return 0;
if (argc >= 2 &&
return -1;
}
- if (g_net_is_compatible (NULL, SOCKNAL, 0) &&
+ if (g_net_is_compatible (NULL, SOCKLND, 0) &&
argc >= 3 &&
lnet_parse_ipaddr (&ipaddr, argv[2]) != 0) {
fprintf (stderr, "Can't parse ip addr %s\n", argv[2]);
return 0;
}
- if (!g_net_is_compatible (argv[0], SOCKNAL, 0))
+ if (!g_net_is_compatible (argv[0], SOCKLND, 0))
return -1;
if (argc > 1 &&
int index;
int rc;
- if (!g_net_is_compatible (argv[0], QSWNAL, 0))
+ if (!g_net_is_compatible (argv[0], QSWLND, 0))
return -1;
for (index = 0;;index++) {
} while (0)
void
-check_ptl_handle_wire (void)
+check_lnet_handle_wire (void)
{
- CHECK_STRUCT (ptl_handle_wire_t);
- CHECK_MEMBER (ptl_handle_wire_t, wh_interface_cookie);
- CHECK_MEMBER (ptl_handle_wire_t, wh_object_cookie);
+ CHECK_STRUCT (lnet_handle_wire_t);
+ CHECK_MEMBER (lnet_handle_wire_t, wh_interface_cookie);
+ CHECK_MEMBER (lnet_handle_wire_t, wh_object_cookie);
}
void
-check_ptl_magicversion (void)
+check_lnet_magicversion (void)
{
- CHECK_STRUCT (ptl_magicversion_t);
- CHECK_MEMBER (ptl_magicversion_t, magic);
- CHECK_MEMBER (ptl_magicversion_t, version_major);
- CHECK_MEMBER (ptl_magicversion_t, version_minor);
+ CHECK_STRUCT (lnet_magicversion_t);
+ CHECK_MEMBER (lnet_magicversion_t, magic);
+ CHECK_MEMBER (lnet_magicversion_t, version_major);
+ CHECK_MEMBER (lnet_magicversion_t, version_minor);
}
void
-check_ptl_hdr (void)
+check_lnet_hdr (void)
{
- CHECK_STRUCT (ptl_hdr_t);
- CHECK_MEMBER (ptl_hdr_t, dest_nid);
- CHECK_MEMBER (ptl_hdr_t, src_nid);
- CHECK_MEMBER (ptl_hdr_t, dest_pid);
- CHECK_MEMBER (ptl_hdr_t, src_pid);
- CHECK_MEMBER (ptl_hdr_t, type);
- CHECK_MEMBER (ptl_hdr_t, payload_length);
- CHECK_MEMBER (ptl_hdr_t, msg);
+ CHECK_STRUCT (lnet_hdr_t);
+ CHECK_MEMBER (lnet_hdr_t, dest_nid);
+ CHECK_MEMBER (lnet_hdr_t, src_nid);
+ CHECK_MEMBER (lnet_hdr_t, dest_pid);
+ CHECK_MEMBER (lnet_hdr_t, src_pid);
+ CHECK_MEMBER (lnet_hdr_t, type);
+ CHECK_MEMBER (lnet_hdr_t, payload_length);
+ CHECK_MEMBER (lnet_hdr_t, msg);
BLANK_LINE ();
COMMENT ("Ack");
- CHECK_MEMBER (ptl_hdr_t, msg.ack.dst_wmd);
- CHECK_MEMBER (ptl_hdr_t, msg.ack.match_bits);
- CHECK_MEMBER (ptl_hdr_t, msg.ack.mlength);
+ CHECK_MEMBER (lnet_hdr_t, msg.ack.dst_wmd);
+ CHECK_MEMBER (lnet_hdr_t, msg.ack.match_bits);
+ CHECK_MEMBER (lnet_hdr_t, msg.ack.mlength);
BLANK_LINE ();
COMMENT ("Put");
- CHECK_MEMBER (ptl_hdr_t, msg.put.ack_wmd);
- CHECK_MEMBER (ptl_hdr_t, msg.put.match_bits);
- CHECK_MEMBER (ptl_hdr_t, msg.put.hdr_data);
- CHECK_MEMBER (ptl_hdr_t, msg.put.ptl_index);
- CHECK_MEMBER (ptl_hdr_t, msg.put.offset);
+ CHECK_MEMBER (lnet_hdr_t, msg.put.ack_wmd);
+ CHECK_MEMBER (lnet_hdr_t, msg.put.match_bits);
+ CHECK_MEMBER (lnet_hdr_t, msg.put.hdr_data);
+ CHECK_MEMBER (lnet_hdr_t, msg.put.ptl_index);
+ CHECK_MEMBER (lnet_hdr_t, msg.put.offset);
BLANK_LINE ();
COMMENT ("Get");
- CHECK_MEMBER (ptl_hdr_t, msg.get.return_wmd);
- CHECK_MEMBER (ptl_hdr_t, msg.get.match_bits);
- CHECK_MEMBER (ptl_hdr_t, msg.get.ptl_index);
- CHECK_MEMBER (ptl_hdr_t, msg.get.src_offset);
- CHECK_MEMBER (ptl_hdr_t, msg.get.sink_length);
+ CHECK_MEMBER (lnet_hdr_t, msg.get.return_wmd);
+ CHECK_MEMBER (lnet_hdr_t, msg.get.match_bits);
+ CHECK_MEMBER (lnet_hdr_t, msg.get.ptl_index);
+ CHECK_MEMBER (lnet_hdr_t, msg.get.src_offset);
+ CHECK_MEMBER (lnet_hdr_t, msg.get.sink_length);
BLANK_LINE ();
COMMENT ("Reply");
- CHECK_MEMBER (ptl_hdr_t, msg.reply.dst_wmd);
+ CHECK_MEMBER (lnet_hdr_t, msg.reply.dst_wmd);
BLANK_LINE ();
COMMENT ("Hello");
- CHECK_MEMBER (ptl_hdr_t, msg.hello.incarnation);
- CHECK_MEMBER (ptl_hdr_t, msg.hello.type);
+ CHECK_MEMBER (lnet_hdr_t, msg.hello.incarnation);
+ CHECK_MEMBER (lnet_hdr_t, msg.hello.type);
}
void
system_string("uname -a", unameinfo, sizeof(unameinfo));
system_string("gcc -v 2>&1 | tail -1", gccinfo, sizeof(gccinfo));
- printf ("void ptl_assert_wire_constants (void)\n"
+ printf ("void lnet_assert_wire_constants (void)\n"
"{\n"
" /* Wire protocol assertions generated by 'wirecheck'\n"
" * running on %s\n"
COMMENT ("Constants...");
- CHECK_DEFINE (PTL_PROTO_OPENIB_MAGIC);
- CHECK_DEFINE (PTL_PROTO_RA_MAGIC);
+ CHECK_DEFINE (LNET_PROTO_OPENIB_MAGIC);
+ CHECK_DEFINE (LNET_PROTO_RA_MAGIC);
- CHECK_DEFINE (PTL_PROTO_TCP_MAGIC);
- CHECK_DEFINE (PTL_PROTO_TCP_VERSION_MAJOR);
- CHECK_DEFINE (PTL_PROTO_TCP_VERSION_MINOR);
+ CHECK_DEFINE (LNET_PROTO_TCP_MAGIC);
+ CHECK_DEFINE (LNET_PROTO_TCP_VERSION_MAJOR);
+ CHECK_DEFINE (LNET_PROTO_TCP_VERSION_MINOR);
- CHECK_VALUE (PTL_MSG_ACK);
- CHECK_VALUE (PTL_MSG_PUT);
- CHECK_VALUE (PTL_MSG_GET);
- CHECK_VALUE (PTL_MSG_REPLY);
- CHECK_VALUE (PTL_MSG_HELLO);
+ CHECK_VALUE (LNET_MSG_ACK);
+ CHECK_VALUE (LNET_MSG_PUT);
+ CHECK_VALUE (LNET_MSG_GET);
+ CHECK_VALUE (LNET_MSG_REPLY);
+ CHECK_VALUE (LNET_MSG_HELLO);
- check_ptl_handle_wire ();
- check_ptl_magicversion ();
- check_ptl_hdr ();
+ check_lnet_handle_wire ();
+ check_lnet_magicversion ();
+ check_lnet_hdr ();
printf ("}\n\n");
git://git.whamcloud.com / fs / lustre-release.git / commitdiff