-/* -*- 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() spin_lock(&the_lnet.ln_lock)
-#define LNET_UNLOCK() spin_unlock(&the_lnet.ln_lock)
-#define LNET_MUTEX_DOWN(m) mutex_down(m)
-#define LNET_MUTEX_UP(m) mutex_up(m)
+#define LNET_LOCK() cfs_spin_lock(&the_lnet.ln_lock)
+#define LNET_UNLOCK() cfs_spin_unlock(&the_lnet.ln_lock)
+#define LNET_MUTEX_LOCK(m) cfs_mutex_lock(m)
+#define LNET_MUTEX_UNLOCK(m) cfs_mutex_unlock(m)
#else
# ifndef HAVE_LIBPTHREAD
#define LNET_SINGLE_THREADED_LOCK(l) \
#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)
/* ALWAYS called with liblock held */
lnet_freeobj_t *o;
- if (list_empty (&fl->fl_list))
+ if (cfs_list_empty (&fl->fl_list))
return (NULL);
- o = list_entry (fl->fl_list.next, lnet_freeobj_t, fo_list);
- list_del (&o->fo_list);
+ o = cfs_list_entry (fl->fl_list.next, lnet_freeobj_t, fo_list);
+ cfs_list_del (&o->fo_list);
return ((void *)&o->fo_contents);
}
lnet_freelist_free (lnet_freelist_t *fl, void *obj)
{
/* ALWAYS called with liblock held */
- lnet_freeobj_t *o = list_entry (obj, lnet_freeobj_t, fo_contents);
+ lnet_freeobj_t *o = cfs_list_entry (obj, lnet_freeobj_t, fo_contents);
- list_add (&o->fo_list, &fl->fl_list);
+ cfs_list_add (&o->fo_list, &fl->fl_list);
}
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;
- return (lh_entry (lh, lnet_eq_t, eq_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);
}
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;
- return (lh_entry (lh, lnet_libmd_t, md_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);
}
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;
+
+ 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));
+ 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)
{
LASSERT (ni->ni_refcount > 0);
ni->ni_refcount--;
if (ni->ni_refcount == 0)
- list_add_tail(&ni->ni_list, &the_lnet.ln_zombie_nis);
+ cfs_list_add_tail(&ni->ni_list, &the_lnet.ln_zombie_nis);
}
static inline void
LNET_UNLOCK();
}
-static inline struct list_head *
+static inline cfs_list_t *
lnet_nid2peerhash (lnet_nid_t nid)
{
unsigned int idx = LNET_NIDADDR(nid) % LNET_PEER_HASHSIZE;
return ni;
}
-int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, time_t when);
+int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, cfs_time_t when);
+void lnet_notify_locked(lnet_peer_t *lp, int notifylnd, int alive, cfs_time_t when);
int lnet_add_route(__u32 net, unsigned int hops, lnet_nid_t gateway_nid);
int lnet_check_routes(void);
int lnet_del_route(__u32 net, lnet_nid_t gw_nid);
int lnet_count_acceptor_nis(void);
int lnet_acceptor_timeout(void);
int lnet_acceptor_port(void);
+#else
+void lnet_router_checker(void);
#endif
#ifdef HAVE_LIBPTHREAD
int lnet_acceptor_start(void);
void lnet_acceptor_stop(void);
+void lnet_get_tunables(void);
int lnet_peers_start_down(void);
+int lnet_peer_buffer_credits(lnet_ni_t *ni);
+
int lnet_router_checker_start(void);
void lnet_router_checker_stop(void);
+void lnet_swap_pinginfo(lnet_ping_info_t *info);
+int lnet_router_down_ni(lnet_peer_t *rtr, __u32 net);
int lnet_ping_target_init(void);
void lnet_ping_target_fini(void);
int lnet_parse_ip2nets (char **networksp, char *ip2nets);
int lnet_parse_routes (char *route_str, int *im_a_router);
-int lnet_parse_networks (struct list_head *nilist, char *networks);
+int lnet_parse_networks (cfs_list_t *nilist, char *networks);
int lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid);
lnet_peer_t *lnet_find_peer_locked (lnet_nid_t nid);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff