-/* -*- 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.
* 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.
*/
/*
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); \
#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)
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 *
}
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)
}
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 *
}
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 *
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 *
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)
}
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
}
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
}
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)
{
void lnet_router_checker(void);
#endif
-#ifdef HAVE_PTHREAD
+#ifdef HAVE_LIBPTHREAD
int lnet_count_acceptor_nis(void);
int lnet_acceptor_port(void);
#endif
git://git.whamcloud.com / fs / lustre-release.git / blobdiff