X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lnet%2Finclude%2Flnet%2Flib-lnet.h;h=28b69e6f2f70bcc92fb0573eab1179bda329946c;hb=c3a57ec36441c75df03cfbec8f718e053aaad12a;hp=65591d35eca77ef89ad0f6724f59f4c9edb1d366;hpb=004cc2b4c6eb32672985e2f4b4bbf9413e314547;p=fs%2Flustre-release.git

diff --git a/lnet/include/lnet/lib-lnet.h b/lnet/include/lnet/lib-lnet.h
index 65591d3..28b69e6 100644
--- a/lnet/include/lnet/lib-lnet.h
+++ b/lnet/include/lnet/lib-lnet.h
@@ -1,6 +1,4 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
  * GPL HEADER START
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -26,7 +24,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  */
 /*
@@ -88,13 +86,20 @@ static inline int lnet_md_unlinkable (lnet_libmd_t *md)
                 lnet_md_exhausted(md));
 }
 
+static inline unsigned int
+lnet_match_to_hash(lnet_process_id_t id, __u64 mbits)
+{
+        mbits += id.nid + id.pid;
+        return cfs_hash_long((unsigned long)mbits, LNET_PORTAL_HASH_BITS);
+}
+
 #ifdef __KERNEL__
 #define LNET_LOCK()        cfs_spin_lock(&the_lnet.ln_lock)
 #define LNET_UNLOCK()      cfs_spin_unlock(&the_lnet.ln_lock)
-#define LNET_MUTEX_DOWN(m) cfs_mutex_down(m)
-#define LNET_MUTEX_UP(m)   cfs_mutex_up(m)
+#define LNET_MUTEX_LOCK(m)   cfs_mutex_lock(m)
+#define LNET_MUTEX_UNLOCK(m) cfs_mutex_unlock(m)
 #else
-# ifndef HAVE_PTHREAD
+# ifndef HAVE_LIBPTHREAD
 #define LNET_SINGLE_THREADED_LOCK(l)            \
 do {                                            \
         LASSERT ((l) == 0);                     \
@@ -109,24 +114,29 @@ do {                                            \
 
 #define LNET_LOCK()        LNET_SINGLE_THREADED_LOCK(the_lnet.ln_lock)
 #define LNET_UNLOCK()      LNET_SINGLE_THREADED_UNLOCK(the_lnet.ln_lock)
-#define LNET_MUTEX_DOWN(m) LNET_SINGLE_THREADED_LOCK(*(m))
-#define LNET_MUTEX_UP(m)   LNET_SINGLE_THREADED_UNLOCK(*(m))
+#define LNET_MUTEX_LOCK(m)     LNET_SINGLE_THREADED_LOCK(*(m))
+#define LNET_MUTEX_UNLOCK(m)   LNET_SINGLE_THREADED_UNLOCK(*(m))
 # else
 #define LNET_LOCK()        pthread_mutex_lock(&the_lnet.ln_lock)
 #define LNET_UNLOCK()      pthread_mutex_unlock(&the_lnet.ln_lock)
-#define LNET_MUTEX_DOWN(m) pthread_mutex_lock(m)
-#define LNET_MUTEX_UP(m)   pthread_mutex_unlock(m)
+#define LNET_MUTEX_LOCK(m)     pthread_mutex_lock(m)
+#define LNET_MUTEX_UNLOCK(m)   pthread_mutex_unlock(m)
 # endif
 #endif
 
 #define MAX_PORTALS     64
 
+/* these are only used by code with LNET_USE_LIB_FREELIST, but we still
+ * exported them to !LNET_USE_LIB_FREELIST for easy implemetation */
+#define LNET_FL_MAX_MES		2048
+#define LNET_FL_MAX_MDS		2048
+#define LNET_FL_MAX_EQS		512
+#define LNET_FL_MAX_MSGS	2048    /* Outstanding messages */
+
 #ifdef LNET_USE_LIB_FREELIST
 
-#define MAX_MES         2048
-#define MAX_MDS         2048
-#define MAX_MSGS        2048    /* Outstanding messages */
-#define MAX_EQS         512
+int lnet_freelist_init(lnet_freelist_t *fl, int n, int size);
+void lnet_freelist_fini(lnet_freelist_t *fl);
 
 static inline void *
 lnet_freelist_alloc (lnet_freelist_t *fl)
@@ -155,64 +165,97 @@ lnet_freelist_free (lnet_freelist_t *fl, void *obj)
 static inline lnet_eq_t *
 lnet_eq_alloc (void)
 {
-        /* NEVER called with liblock held */
-        lnet_eq_t     *eq;
+	/* NEVER called with resource lock held */
+	struct lnet_res_container *rec = &the_lnet.ln_eq_container;
+	lnet_eq_t		  *eq;
 
-        LNET_LOCK();
-        eq = (lnet_eq_t *)lnet_freelist_alloc(&the_lnet.ln_free_eqs);
-        LNET_UNLOCK();
+	LNET_LOCK();
+	eq = (lnet_eq_t *)lnet_freelist_alloc(&rec->rec_freelist);
+	LNET_UNLOCK();
 
-        return (eq);
+	return eq;
 }
 
 static inline void
-lnet_eq_free (lnet_eq_t *eq)
+lnet_eq_free_locked(lnet_eq_t *eq)
 {
-        /* ALWAYS called with liblock held */
-        lnet_freelist_free(&the_lnet.ln_free_eqs, eq);
+	/* ALWAYS called with resource lock held */
+	struct lnet_res_container *rec = &the_lnet.ln_eq_container;
+
+	lnet_freelist_free(&rec->rec_freelist, eq);
+}
+
+static inline void
+lnet_eq_free(lnet_eq_t *eq)
+{
+	LNET_LOCK();
+	lnet_eq_free_locked(eq);
+	LNET_UNLOCK();
 }
 
 static inline lnet_libmd_t *
 lnet_md_alloc (lnet_md_t *umd)
 {
-        /* NEVER called with liblock held */
-        lnet_libmd_t  *md;
+	/* NEVER called with resource lock held */
+	struct lnet_res_container *rec = &the_lnet.ln_md_container;
+	lnet_libmd_t		  *md;
 
-        LNET_LOCK();
-        md = (lnet_libmd_t *)lnet_freelist_alloc(&the_lnet.ln_free_mds);
-        LNET_UNLOCK();
+	LNET_LOCK();
+	md = (lnet_libmd_t *)lnet_freelist_alloc(&rec->rec_freelist);
+	LNET_UNLOCK();
 
-        if (md != NULL)
-                CFS_INIT_LIST_HEAD(&md->md_list);
+	if (md != NULL)
+		CFS_INIT_LIST_HEAD(&md->md_list);
 
-        return (md);
+	return md;
 }
 
 static inline void
-lnet_md_free (lnet_libmd_t *md)
+lnet_md_free_locked(lnet_libmd_t *md)
 {
-        /* ALWAYS called with liblock held */
-        lnet_freelist_free (&the_lnet.ln_free_mds, md);
+	/* ALWAYS called with resource lock held */
+	struct lnet_res_container *rec = &the_lnet.ln_md_container;
+
+	lnet_freelist_free(&rec->rec_freelist, md);
+}
+
+static inline void
+lnet_md_free(lnet_libmd_t *md)
+{
+	LNET_LOCK();
+	lnet_md_free_locked(md);
+	LNET_UNLOCK();
 }
 
 static inline lnet_me_t *
-lnet_me_alloc (void)
+lnet_me_alloc(void)
 {
-        /* NEVER called with liblock held */
-        lnet_me_t     *me;
+	/* NEVER called with resource lock held */
+	struct lnet_res_container *rec = &the_lnet.ln_me_container;
+	lnet_me_t		  *me;
 
-        LNET_LOCK();
-        me = (lnet_me_t *)lnet_freelist_alloc(&the_lnet.ln_free_mes);
-        LNET_UNLOCK();
+	LNET_LOCK();
+	me = (lnet_me_t *)lnet_freelist_alloc(&rec->rec_freelist);
+	LNET_UNLOCK();
 
-        return (me);
+	return me;
 }
 
 static inline void
-lnet_me_free (lnet_me_t *me)
+lnet_me_free_locked(lnet_me_t *me)
 {
-        /* ALWAYS called with liblock held */
-        lnet_freelist_free (&the_lnet.ln_free_mes, me);
+	/* ALWAYS called with resource lock held */
+	struct lnet_res_container *rec = &the_lnet.ln_me_container;
+
+	lnet_freelist_free(&rec->rec_freelist, me);
+}
+
+static inline void
+lnet_me_free(lnet_me_t *me)
+{
+	LNET_LOCK();
+	lnet_me_free_locked(me);
+	LNET_UNLOCK();
 }
 
 static inline lnet_msg_t *
@@ -236,14 +279,22 @@ lnet_msg_alloc (void)
 }
 
 static inline void
+lnet_msg_free_locked(lnet_msg_t *msg)
+{
+	/* ALWAYS called with network lock held */
+	LASSERT(!msg->msg_onactivelist);
+	lnet_freelist_free(&the_lnet.ln_free_msgs, msg);
+}
+
+static inline void
 lnet_msg_free (lnet_msg_t *msg)
 {
-        /* ALWAYS called with liblock held */
-        LASSERT (!msg->msg_onactivelist);
-        lnet_freelist_free(&the_lnet.ln_free_msgs, msg);
+	LNET_LOCK();
+	lnet_msg_free_locked(msg);
+	LNET_UNLOCK();
 }
 
-#else
+#else /* !LNET_USE_LIB_FREELIST */
 
 static inline lnet_eq_t *
 lnet_eq_alloc (void)
@@ -256,10 +307,10 @@ lnet_eq_alloc (void)
 }
 
 static inline void
-lnet_eq_free (lnet_eq_t *eq)
+lnet_eq_free(lnet_eq_t *eq)
 {
-        /* ALWAYS called with liblock held */
-        LIBCFS_FREE(eq, sizeof(*eq));
+	/* ALWAYS called with resource lock held */
+	LIBCFS_FREE(eq, sizeof(*eq));
 }
 
 static inline lnet_libmd_t *
@@ -292,17 +343,17 @@ lnet_md_alloc (lnet_md_t *umd)
 }
 
 static inline void
-lnet_md_free (lnet_libmd_t *md)
+lnet_md_free(lnet_libmd_t *md)
 {
-        /* ALWAYS called with liblock held */
-        unsigned int  size;
+	/* ALWAYS called with resource lock held */
+	unsigned int  size;
 
-        if ((md->md_options & LNET_MD_KIOV) != 0)
-                size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]);
-        else
-                size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]);
+	if ((md->md_options & LNET_MD_KIOV) != 0)
+		size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]);
+	else
+		size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]);
 
-        LIBCFS_FREE(md, size);
+	LIBCFS_FREE(md, size);
 }
 
 static inline lnet_me_t *
@@ -318,8 +369,8 @@ lnet_me_alloc (void)
 static inline void
 lnet_me_free(lnet_me_t *me)
 {
-        /* ALWAYS called with liblock held */
-        LIBCFS_FREE(me, sizeof(*me));
+	/* ALWAYS called with resource lock held */
+	LIBCFS_FREE(me, sizeof(*me));
 }
 
 static inline lnet_msg_t *
@@ -330,28 +381,41 @@ lnet_msg_alloc(void)
 
         LIBCFS_ALLOC(msg, sizeof(*msg));
 
-        if (msg != NULL) {
-                /* NULL pointers, clear flags etc */
-                memset (msg, 0, sizeof (*msg));
+        /* no need to zero, LIBCFS_ALLOC does for us */
+
 #ifdef CRAY_XT3
+        if (msg != NULL) {
                 msg->msg_ev.uid = LNET_UID_ANY;
-#endif
         }
+#endif
         return (msg);
 }
 
 static inline void
 lnet_msg_free(lnet_msg_t *msg)
 {
-        /* ALWAYS called with liblock held */
-        LASSERT (!msg->msg_onactivelist);
-        LIBCFS_FREE(msg, sizeof(*msg));
+	/* ALWAYS called with network lock held */
+	LASSERT(!msg->msg_onactivelist);
+	LIBCFS_FREE(msg, sizeof(*msg));
 }
-#endif
 
-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);
+#define lnet_eq_free_locked(eq)		lnet_eq_free(eq)
+#define lnet_md_free_locked(md)		lnet_md_free(md)
+#define lnet_me_free_locked(me)		lnet_me_free(me)
+#define lnet_msg_free_locked(msg)	lnet_msg_free(msg)
+
+#endif /* LNET_USE_LIB_FREELIST */
+
+lnet_libhandle_t *lnet_res_lh_lookup(struct lnet_res_container *rec,
+				     __u64 cookie);
+void lnet_res_lh_initialize(struct lnet_res_container *rec,
+			    lnet_libhandle_t *lh);
+static inline void
+lnet_res_lh_invalidate(lnet_libhandle_t *lh)
+{
+	/* ALWAYS called with resource lock held */
+	cfs_list_del(&lh->lh_hash_chain);
+}
 
 static inline void
 lnet_eq2handle (lnet_handle_eq_t *handle, lnet_eq_t *eq)
@@ -365,15 +429,16 @@ lnet_eq2handle (lnet_handle_eq_t *handle, lnet_eq_t *eq)
 }
 
 static inline lnet_eq_t *
-lnet_handle2eq (lnet_handle_eq_t *handle)
+lnet_handle2eq(lnet_handle_eq_t *handle)
 {
-        /* ALWAYS called with liblock held */
-        lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
-                                                  LNET_COOKIE_TYPE_EQ);
-        if (lh == NULL)
-                return (NULL);
+	/* ALWAYS called with resource lock held */
+	lnet_libhandle_t *lh;
+
+	lh = lnet_res_lh_lookup(&the_lnet.ln_eq_container, handle->cookie);
+	if (lh == NULL)
+		return NULL;
 
-        return (lh_entry (lh, lnet_eq_t, eq_lh));
+	return lh_entry(lh, lnet_eq_t, eq_lh);
 }
 
 static inline void
@@ -383,32 +448,33 @@ lnet_md2handle (lnet_handle_md_t *handle, lnet_libmd_t *md)
 }
 
 static inline lnet_libmd_t *
-lnet_handle2md (lnet_handle_md_t *handle)
+lnet_handle2md(lnet_handle_md_t *handle)
 {
-        /* ALWAYS called with liblock held */
-        lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
-                                                  LNET_COOKIE_TYPE_MD);
-        if (lh == NULL)
-                return (NULL);
+	/* ALWAYS called with resource lock held */
+	lnet_libhandle_t *lh;
+
+	lh = lnet_res_lh_lookup(&the_lnet.ln_md_container, handle->cookie);
+	if (lh == NULL)
+		return NULL;
 
-        return (lh_entry (lh, lnet_libmd_t, md_lh));
+	return lh_entry(lh, lnet_libmd_t, md_lh);
 }
 
 static inline lnet_libmd_t *
-lnet_wire_handle2md (lnet_handle_wire_t *wh)
+lnet_wire_handle2md(lnet_handle_wire_t *wh)
 {
-        /* ALWAYS called with liblock held */
-        lnet_libhandle_t *lh;
+	/* ALWAYS called with resource lock held */
+	lnet_libhandle_t *lh;
 
-        if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie)
-                return (NULL);
+	if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie)
+		return NULL;
 
-        lh = lnet_lookup_cookie(wh->wh_object_cookie,
-                                LNET_COOKIE_TYPE_MD);
-        if (lh == NULL)
-                return (NULL);
+	lh = lnet_res_lh_lookup(&the_lnet.ln_md_container,
+				wh->wh_object_cookie);
+	if (lh == NULL)
+		return NULL;
 
-        return (lh_entry (lh, lnet_libmd_t, md_lh));
+	return lh_entry(lh, lnet_libmd_t, md_lh);
 }
 
 static inline void
@@ -418,17 +484,74 @@ lnet_me2handle (lnet_handle_me_t *handle, lnet_me_t *me)
 }
 
 static inline lnet_me_t *
-lnet_handle2me (lnet_handle_me_t *handle)
+lnet_handle2me(lnet_handle_me_t *handle)
 {
-        /* ALWAYS called with liblock held */
-        lnet_libhandle_t *lh = lnet_lookup_cookie(handle->cookie,
-                                                  LNET_COOKIE_TYPE_ME);
-        if (lh == NULL)
-                return (NULL);
+	/* ALWAYS called with resource lock held */
+	lnet_libhandle_t *lh;
 
-        return (lh_entry (lh, lnet_me_t, me_lh));
+	lh = lnet_res_lh_lookup(&the_lnet.ln_me_container, handle->cookie);
+	if (lh == NULL)
+		return NULL;
+
+	return lh_entry(lh, lnet_me_t, me_lh);
+}
+
+static inline int
+lnet_portal_is_lazy(lnet_portal_t *ptl)
+{
+        return !!(ptl->ptl_options & LNET_PTL_LAZY);
 }
 
+static inline int
+lnet_portal_is_unique(lnet_portal_t *ptl)
+{
+        return !!(ptl->ptl_options & LNET_PTL_MATCH_UNIQUE); 
+}
+
+static inline int
+lnet_portal_is_wildcard(lnet_portal_t *ptl)
+{
+        return !!(ptl->ptl_options & LNET_PTL_MATCH_WILDCARD);
+}
+
+static inline void
+lnet_portal_setopt(lnet_portal_t *ptl, int opt)
+{
+        ptl->ptl_options |= opt;
+}
+
+static inline void
+lnet_portal_unsetopt(lnet_portal_t *ptl, int opt)
+{
+        ptl->ptl_options &= ~opt;
+}
+
+static inline int
+lnet_match_is_unique(lnet_process_id_t match_id,
+                     __u64 match_bits, __u64 ignore_bits)
+{
+        return ignore_bits == 0 &&
+               match_id.nid != LNET_NID_ANY &&
+               match_id.pid != LNET_PID_ANY;
+}
+
+static inline cfs_list_t *
+lnet_portal_me_head(int index, lnet_process_id_t id, __u64 mbits)
+{
+        lnet_portal_t *ptl = &the_lnet.ln_portals[index];
+
+        if (lnet_portal_is_wildcard(ptl)) {
+                return &ptl->ptl_mlist;
+        } else if (lnet_portal_is_unique(ptl)) {
+                LASSERT (ptl->ptl_mhash != NULL);
+                return &ptl->ptl_mhash[lnet_match_to_hash(id, mbits)];
+        }
+        return NULL;
+}
+
+cfs_list_t *lnet_portal_mhash_alloc(void);
+void lnet_portal_mhash_free(cfs_list_t *mhash);
+
 static inline void
 lnet_peer_addref_locked(lnet_peer_t *lp)
 {
@@ -662,7 +785,7 @@ int lnet_acceptor_port(void);
 void lnet_router_checker(void);
 #endif
 
-#ifdef HAVE_PTHREAD
+#ifdef HAVE_LIBPTHREAD
 int lnet_count_acceptor_nis(void);
 int lnet_acceptor_port(void);
 #endif