* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define DEBUG_SUBSYSTEM S_LNET
#include <lnet/lib-lnet.h>
#include <lnet/lib-dlc.h>
-#ifdef __KERNEL__
#include <linux/log2.h>
-#endif
-#ifdef __KERNEL__
#define D_LNI D_CONSOLE
-#else
-#define D_LNI D_CONFIG
-#endif
lnet_t the_lnet; /* THE state of the network */
EXPORT_SYMBOL(the_lnet);
-#ifdef __KERNEL__
-
static char *ip2nets = "";
CFS_MODULE_PARM(ip2nets, "s", charp, 0444,
"LNET network <- IP table");
CFS_MODULE_PARM(rnet_htable_size, "i", int, 0444,
"size of remote network hash table");
-static void lnet_ping_target_fini(void);
static int lnet_ping(lnet_process_id_t id, int timeout_ms,
lnet_process_id_t *ids, int n_ids);
{
spin_lock_init(&the_lnet.ln_eq_wait_lock);
init_waitqueue_head(&the_lnet.ln_eq_waitq);
+ init_waitqueue_head(&the_lnet.ln_rc_waitq);
mutex_init(&the_lnet.ln_lnd_mutex);
mutex_init(&the_lnet.ln_api_mutex);
}
{
}
-#else
-
-static char *
-lnet_get_routes(void)
-{
- char *str = getenv("LNET_ROUTES");
-
- return (str == NULL) ? "" : str;
-}
-
-static char *
-lnet_get_networks (void)
-{
- static char default_networks[256];
- char *networks = getenv("LNET_NETWORKS");
- char *str;
- char *sep;
- int len;
- int nob;
- struct list_head *tmp;
-
- if (networks != NULL)
- return networks;
-
- /* In userland, the default 'networks=' is the list of known net types */
- len = sizeof(default_networks);
- str = default_networks;
- *str = 0;
- sep = "";
-
- list_for_each(tmp, &the_lnet.ln_lnds) {
- lnd_t *lnd = list_entry(tmp, lnd_t, lnd_list);
-
- nob = snprintf(str, len, "%s%s", sep,
- libcfs_lnd2str(lnd->lnd_type));
- if (nob >= len) {
- /* overflowed the string; leave it where it was */
- *str = 0;
- break;
- }
- len -= nob;
- str += nob;
- sep = ",";
- }
-
- return default_networks;
-}
-
-# ifndef HAVE_LIBPTHREAD
-
-static void lnet_init_locks(void)
-{
- the_lnet.ln_eq_wait_lock = 0;
- the_lnet.ln_lnd_mutex = 0;
- the_lnet.ln_api_mutex = 0;
-}
-
-static void lnet_fini_locks(void)
-{
- LASSERT(the_lnet.ln_api_mutex == 0);
- LASSERT(the_lnet.ln_lnd_mutex == 0);
- LASSERT(the_lnet.ln_eq_wait_lock == 0);
-}
-
-# else
-
-static void lnet_init_locks(void)
-{
- pthread_cond_init(&the_lnet.ln_eq_cond, NULL);
- pthread_mutex_init(&the_lnet.ln_eq_wait_lock, NULL);
- pthread_mutex_init(&the_lnet.ln_lnd_mutex, NULL);
- pthread_mutex_init(&the_lnet.ln_api_mutex, NULL);
-}
-
-static void lnet_fini_locks(void)
-{
- pthread_mutex_destroy(&the_lnet.ln_api_mutex);
- pthread_mutex_destroy(&the_lnet.ln_lnd_mutex);
- pthread_mutex_destroy(&the_lnet.ln_eq_wait_lock);
- pthread_cond_destroy(&the_lnet.ln_eq_cond);
-}
-
-# endif
-#endif
-
static int
lnet_create_remote_nets_table(void)
{
CLASSERT ((int)sizeof(((lnet_hdr_t *)0)->msg.hello.type) == 4);
}
-static lnd_t *
-lnet_find_lnd_by_type (int type)
+static lnd_t *lnet_find_lnd_by_type(__u32 type)
{
lnd_t *lnd;
struct list_head *tmp;
list_for_each(tmp, &the_lnet.ln_lnds) {
lnd = list_entry(tmp, lnd_t, lnd_list);
- if ((int)lnd->lnd_type == type)
+ if (lnd->lnd_type == type)
return lnd;
}
return NULL;
{
LNET_MUTEX_LOCK(&the_lnet.ln_lnd_mutex);
- LASSERT(the_lnet.ln_init);
LASSERT(libcfs_isknown_lnd(lnd->lnd_type));
LASSERT(lnet_find_lnd_by_type(lnd->lnd_type) == NULL);
{
LNET_MUTEX_LOCK(&the_lnet.ln_lnd_mutex);
- LASSERT(the_lnet.ln_init);
LASSERT(lnet_find_lnd_by_type(lnd->lnd_type) == lnd);
LASSERT(lnd->lnd_refcount == 0);
}
EXPORT_SYMBOL(lnet_counters_reset);
-#ifdef LNET_USE_LIB_FREELIST
-
-int
-lnet_freelist_init(lnet_freelist_t *fl, int n, int size)
-{
- char *space;
-
- LASSERT (n > 0);
-
- size += offsetof (lnet_freeobj_t, fo_contents);
-
- LIBCFS_ALLOC(space, n * size);
- if (space == NULL)
- return (-ENOMEM);
-
- INIT_LIST_HEAD(&fl->fl_list);
- fl->fl_objs = space;
- fl->fl_nobjs = n;
- fl->fl_objsize = size;
-
- do {
- list_add((struct list_head *)space, &fl->fl_list);
- space += size;
- } while (--n != 0);
-
- return 0;
-}
-
-void
-lnet_freelist_fini(lnet_freelist_t *fl)
-{
- struct list_head *el;
- int count;
-
- if (fl->fl_nobjs == 0)
- return;
-
- count = 0;
- for (el = fl->fl_list.next; el != &fl->fl_list; el = el->next)
- count++;
-
- LASSERT (count == fl->fl_nobjs);
-
- LIBCFS_FREE(fl->fl_objs, fl->fl_nobjs * fl->fl_objsize);
- memset (fl, 0, sizeof (*fl));
-}
-
-#endif /* LNET_USE_LIB_FREELIST */
-
static __u64 lnet_create_interface_cookie(void)
{
/* NB the interface cookie in wire handles guards against delayed
* easily good enough. */
struct timeval tv;
__u64 cookie;
-#ifndef __KERNEL__
- int rc = gettimeofday (&tv, NULL);
- LASSERT (rc == 0);
-#else
do_gettimeofday(&tv);
-#endif
cookie = tv.tv_sec;
cookie *= 1000000;
cookie += tv.tv_usec;
count, lnet_res_type2str(rec->rec_type));
}
-#ifdef LNET_USE_LIB_FREELIST
- lnet_freelist_fini(&rec->rec_freelist);
-#endif
if (rec->rec_lh_hash != NULL) {
LIBCFS_FREE(rec->rec_lh_hash,
LNET_LH_HASH_SIZE * sizeof(rec->rec_lh_hash[0]));
}
static int
-lnet_res_container_setup(struct lnet_res_container *rec,
- int cpt, int type, int objnum, int objsz)
+lnet_res_container_setup(struct lnet_res_container *rec, int cpt, int type)
{
int rc = 0;
int i;
rec->rec_type = type;
INIT_LIST_HEAD(&rec->rec_active);
-#ifdef LNET_USE_LIB_FREELIST
- memset(&rec->rec_freelist, 0, sizeof(rec->rec_freelist));
- rc = lnet_freelist_init(&rec->rec_freelist, objnum, objsz);
- if (rc != 0)
- goto out;
-#endif
rec->rec_lh_cookie = (cpt << LNET_COOKIE_TYPE_BITS) | type;
/* Arbitrary choice of hash table size */
}
static struct lnet_res_container **
-lnet_res_containers_create(int type, int objnum, int objsz)
+lnet_res_containers_create(int type)
{
struct lnet_res_container **recs;
struct lnet_res_container *rec;
}
cfs_percpt_for_each(rec, i, recs) {
- rc = lnet_res_container_setup(rec, i, type, objnum, objsz);
+ rc = lnet_res_container_setup(rec, i, type);
if (rc != 0) {
lnet_res_containers_destroy(recs);
return NULL;
list_add(&lh->lh_hash_chain, &rec->rec_lh_hash[hash]);
}
-#ifndef __KERNEL__
-/**
- * Reserved API - do not use.
- * Temporary workaround to allow uOSS and test programs force server
- * mode in userspace. See comments near ln_server_mode_flag in
- * lnet/lib-types.h */
-
-void
-lnet_server_mode() {
- the_lnet.ln_server_mode_flag = 1;
-}
-#endif
-
static int lnet_unprepare(void);
static int
return -ENETDOWN;
}
- LASSERT (the_lnet.ln_refcount == 0);
-
- the_lnet.ln_routing = 0;
-
-#ifdef __KERNEL__
- LASSERT ((requested_pid & LNET_PID_USERFLAG) == 0);
- the_lnet.ln_pid = requested_pid;
-#else
- if (the_lnet.ln_server_mode_flag) {/* server case (uOSS) */
- LASSERT ((requested_pid & LNET_PID_USERFLAG) == 0);
+ LASSERT(the_lnet.ln_refcount == 0);
- if (current_uid() != 0) /* Only root can run user-space server */
- return -EPERM;
- the_lnet.ln_pid = requested_pid;
+ the_lnet.ln_routing = 0;
- } else {/* client case (liblustre) */
-
- /* My PID must be unique on this node and flag I'm userspace */
- the_lnet.ln_pid = getpid() | LNET_PID_USERFLAG;
- }
-#endif
+ LASSERT((requested_pid & LNET_PID_USERFLAG) == 0);
+ the_lnet.ln_pid = requested_pid;
INIT_LIST_HEAD(&the_lnet.ln_test_peers);
INIT_LIST_HEAD(&the_lnet.ln_nis);
INIT_LIST_HEAD(&the_lnet.ln_nis_zombie);
INIT_LIST_HEAD(&the_lnet.ln_routers);
INIT_LIST_HEAD(&the_lnet.ln_drop_rules);
+ INIT_LIST_HEAD(&the_lnet.ln_delay_rules);
rc = lnet_create_remote_nets_table();
if (rc != 0)
goto failed;
rc = lnet_res_container_setup(&the_lnet.ln_eq_container, 0,
- LNET_COOKIE_TYPE_EQ, LNET_FL_MAX_EQS,
- sizeof(lnet_eq_t));
+ LNET_COOKIE_TYPE_EQ);
if (rc != 0)
goto failed;
- recs = lnet_res_containers_create(LNET_COOKIE_TYPE_ME, LNET_FL_MAX_MES,
- sizeof(lnet_me_t));
- if (recs == NULL)
+ recs = lnet_res_containers_create(LNET_COOKIE_TYPE_ME);
+ if (recs == NULL) {
+ rc = -ENOMEM;
goto failed;
+ }
the_lnet.ln_me_containers = recs;
- recs = lnet_res_containers_create(LNET_COOKIE_TYPE_MD, LNET_FL_MAX_MDS,
- sizeof(lnet_libmd_t));
- if (recs == NULL)
+ recs = lnet_res_containers_create(LNET_COOKIE_TYPE_MD);
+ if (recs == NULL) {
+ rc = -ENOMEM;
goto failed;
+ }
the_lnet.ln_md_containers = recs;
{
/* Return the # of NIs that need the acceptor. */
int count = 0;
-#if defined(__KERNEL__) || defined(HAVE_LIBPTHREAD)
struct list_head *tmp;
struct lnet_ni *ni;
int cpt;
lnet_net_unlock(cpt);
-#endif /* defined(__KERNEL__) || defined(HAVE_LIBPTHREAD) */
return count;
}
{
lnet_handle_me_t me_handle;
lnet_process_id_t id = {LNET_NID_ANY, LNET_PID_ANY};
- lnet_md_t md = {0};
+ lnet_md_t md = {NULL};
int rc, rc2;
if (set_eq) {
}
static void
+lnet_ni_unlink_locked(lnet_ni_t *ni)
+{
+ if (!list_empty(&ni->ni_cptlist)) {
+ list_del_init(&ni->ni_cptlist);
+ lnet_ni_decref_locked(ni, 0);
+ }
+
+ /* move it to zombie list and nobody can find it anymore */
+ LASSERT(!list_empty(&ni->ni_list));
+ list_move(&ni->ni_list, &the_lnet.ln_nis_zombie);
+ lnet_ni_decref_locked(ni, 0); /* drop ln_nis' ref */
+}
+
+static void
lnet_clear_zombies_nis_locked(void)
{
int i;
while (!list_empty(&the_lnet.ln_nis)) {
ni = list_entry(the_lnet.ln_nis.next,
lnet_ni_t, ni_list);
- /* move it to zombie list and nobody can find it anymore */
- list_move(&ni->ni_list, &the_lnet.ln_nis_zombie);
- lnet_ni_decref_locked(ni, 0); /* drop ln_nis' ref */
-
- if (!list_empty(&ni->ni_cptlist)) {
- list_del_init(&ni->ni_cptlist);
- lnet_ni_decref_locked(ni, 0);
- }
- }
-
- /* Drop the cached eqwait NI. */
- if (the_lnet.ln_eq_waitni != NULL) {
- lnet_ni_decref_locked(the_lnet.ln_eq_waitni, 0);
- the_lnet.ln_eq_waitni = NULL;
+ lnet_ni_unlink_locked(ni);
}
/* Drop the cached loopback NI. */
lnet_net_unlock(LNET_LOCK_EX);
}
-int
-lnet_shutdown_lndni(__u32 net)
+/* shutdown down the NI and release refcount */
+static void
+lnet_shutdown_lndni(struct lnet_ni *ni)
{
- lnet_ping_info_t *pinfo;
- lnet_handle_md_t md_handle;
- lnet_ni_t *found_ni = NULL;
- int ni_count;
- int rc;
-
- if (LNET_NETTYP(net) == LOLND)
- return -EINVAL;
-
- ni_count = lnet_get_ni_count();
-
- /* create and link a new ping info, before removing the old one */
- rc = lnet_ping_info_setup(&pinfo, &md_handle, ni_count - 1, false);
- if (rc != 0)
- return rc;
+ int i;
- /* proceed with shutting down the NI */
lnet_net_lock(LNET_LOCK_EX);
-
- found_ni = lnet_net2ni_locked(net, 0);
- if (found_ni == NULL) {
- lnet_net_unlock(LNET_LOCK_EX);
- lnet_ping_md_unlink(pinfo, &md_handle);
- lnet_ping_info_free(pinfo);
- return -EINVAL;
- }
-
- /* decrement the reference counter on found_ni which was
- * incremented when we called lnet_net2ni_locked() */
- lnet_ni_decref_locked(found_ni, 0);
-
- /* Move ni to zombie list so nobody can find it anymore */
- list_move(&found_ni->ni_list, &the_lnet.ln_nis_zombie);
-
- /* Drop the lock reference for the ln_nis ref. */
- lnet_ni_decref_locked(found_ni, 0);
-
- if (!list_empty(&found_ni->ni_cptlist)) {
- list_del_init(&found_ni->ni_cptlist);
- lnet_ni_decref_locked(found_ni, 0);
- }
-
+ lnet_ni_unlink_locked(ni);
lnet_net_unlock(LNET_LOCK_EX);
+ /* clear messages for this NI on the lazy portal */
+ for (i = 0; i < the_lnet.ln_nportals; i++)
+ lnet_clear_lazy_portal(ni, i, "Shutting down NI");
+
/* Do peer table cleanup for this ni */
- lnet_peer_tables_cleanup(found_ni);
+ lnet_peer_tables_cleanup(ni);
lnet_net_lock(LNET_LOCK_EX);
lnet_clear_zombies_nis_locked();
lnet_net_unlock(LNET_LOCK_EX);
-
- lnet_ping_target_update(pinfo, md_handle);
-
- return 0;
}
static int
-lnet_startup_lndnis(struct list_head *nilist, __s32 peer_timeout,
- __s32 peer_cr, __s32 peer_buf_cr, __s32 credits,
- int *ni_count)
+lnet_startup_lndni(struct lnet_ni *ni, __s32 peer_timeout,
+ __s32 peer_cr, __s32 peer_buf_cr, __s32 credits)
{
- int rc = 0;
- struct lnet_ni *ni;
- int lnd_type;
+ int rc = -EINVAL;
+ __u32 lnd_type;
lnd_t *lnd;
struct lnet_tx_queue *tq;
int i;
- while (!list_empty(nilist)) {
- ni = list_entry(nilist->next, lnet_ni_t, ni_list);
- lnd_type = LNET_NETTYP(LNET_NIDNET(ni->ni_nid));
+ lnd_type = LNET_NETTYP(LNET_NIDNET(ni->ni_nid));
- if (!libcfs_isknown_lnd(lnd_type))
- goto failed;
+ LASSERT(libcfs_isknown_lnd(lnd_type));
- if (lnd_type == CIBLND ||
- lnd_type == OPENIBLND ||
- lnd_type == IIBLND ||
- lnd_type == VIBLND) {
- CERROR("LND %s obsoleted\n",
- libcfs_lnd2str(lnd_type));
- goto failed;
- }
+ if (lnd_type == CIBLND || lnd_type == OPENIBLND ||
+ lnd_type == IIBLND || lnd_type == VIBLND) {
+ CERROR("LND %s obsoleted\n", libcfs_lnd2str(lnd_type));
+ goto failed0;
+ }
- /* Make sure this new NI is unique. */
- lnet_net_lock(LNET_LOCK_EX);
- if (!lnet_net_unique(LNET_NIDNET(ni->ni_nid),
- &the_lnet.ln_nis)) {
- if (lnd_type == LOLND) {
- lnet_net_unlock(LNET_LOCK_EX);
- list_del(&ni->ni_list);
- lnet_ni_free(ni);
- continue;
- }
+ /* Make sure this new NI is unique. */
+ lnet_net_lock(LNET_LOCK_EX);
+ rc = lnet_net_unique(LNET_NIDNET(ni->ni_nid), &the_lnet.ln_nis);
+ lnet_net_unlock(LNET_LOCK_EX);
- CERROR("Net %s is not unique\n",
- libcfs_net2str(LNET_NIDNET(ni->ni_nid)));
- lnet_net_unlock(LNET_LOCK_EX);
- goto failed;
+ if (!rc) {
+ if (lnd_type == LOLND) {
+ lnet_ni_free(ni);
+ return 0;
}
- lnet_net_unlock(LNET_LOCK_EX);
+ CERROR("Net %s is not unique\n",
+ libcfs_net2str(LNET_NIDNET(ni->ni_nid)));
+
+ rc = -EEXIST;
+ goto failed0;
+ }
+
+ LNET_MUTEX_LOCK(&the_lnet.ln_lnd_mutex);
+ lnd = lnet_find_lnd_by_type(lnd_type);
+
+ if (lnd == NULL) {
+ LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
+ rc = request_module("%s", libcfs_lnd2modname(lnd_type));
LNET_MUTEX_LOCK(&the_lnet.ln_lnd_mutex);
- lnd = lnet_find_lnd_by_type(lnd_type);
-#ifdef __KERNEL__
+ lnd = lnet_find_lnd_by_type(lnd_type);
if (lnd == NULL) {
LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
- rc = request_module("%s",
- libcfs_lnd2modname(lnd_type));
- LNET_MUTEX_LOCK(&the_lnet.ln_lnd_mutex);
-
- lnd = lnet_find_lnd_by_type(lnd_type);
- if (lnd == NULL) {
- LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
- CERROR("Can't load LND %s, module %s, rc=%d\n",
- libcfs_lnd2str(lnd_type),
- libcfs_lnd2modname(lnd_type), rc);
+ CERROR("Can't load LND %s, module %s, rc=%d\n",
+ libcfs_lnd2str(lnd_type),
+ libcfs_lnd2modname(lnd_type), rc);
#ifndef HAVE_MODULE_LOADING_SUPPORT
- LCONSOLE_ERROR_MSG(0x104, "Your kernel must be "
- "compiled with kernel module "
- "loading support.");
+ LCONSOLE_ERROR_MSG(0x104, "Your kernel must be "
+ "compiled with kernel module "
+ "loading support.");
#endif
- goto failed;
- }
- }
-#else
- if (lnd == NULL) {
- LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
- CERROR("LND %s not supported\n",
- libcfs_lnd2str(lnd_type));
- goto failed;
+ rc = -EINVAL;
+ goto failed0;
}
-#endif
-
- lnet_net_lock(LNET_LOCK_EX);
- lnd->lnd_refcount++;
- lnet_net_unlock(LNET_LOCK_EX);
-
- ni->ni_lnd = lnd;
+ }
- rc = (lnd->lnd_startup)(ni);
+ lnet_net_lock(LNET_LOCK_EX);
+ lnd->lnd_refcount++;
+ lnet_net_unlock(LNET_LOCK_EX);
- LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
+ ni->ni_lnd = lnd;
- if (rc != 0) {
- LCONSOLE_ERROR_MSG(0x105, "Error %d starting up LNI %s"
- "\n",
- rc, libcfs_lnd2str(lnd->lnd_type));
- lnet_net_lock(LNET_LOCK_EX);
- lnd->lnd_refcount--;
- lnet_net_unlock(LNET_LOCK_EX);
- goto failed;
- }
+ rc = (lnd->lnd_startup)(ni);
- /* If given some LND tunable parameters, parse those now to
- * override the values in the NI structure. */
- if (peer_buf_cr >= 0)
- ni->ni_peerrtrcredits = peer_buf_cr;
- if (peer_timeout >= 0)
- ni->ni_peertimeout = peer_timeout;
- /*
- * TODO
- * Note: For now, don't allow the user to change
- * peertxcredits as this number is used in the
- * IB LND to control queue depth.
- * if (peer_cr != -1)
- * ni->ni_peertxcredits = peer_cr;
- */
- if (credits >= 0)
- ni->ni_maxtxcredits = credits;
+ LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
- LASSERT(ni->ni_peertimeout <= 0 || lnd->lnd_query != NULL);
+ if (rc != 0) {
+ LCONSOLE_ERROR_MSG(0x105, "Error %d starting up LNI %s\n",
+ rc, libcfs_lnd2str(lnd->lnd_type));
+ lnet_net_lock(LNET_LOCK_EX);
+ lnd->lnd_refcount--;
+ lnet_net_unlock(LNET_LOCK_EX);
+ goto failed0;
+ }
- list_del(&ni->ni_list);
+ /* If given some LND tunable parameters, parse those now to
+ * override the values in the NI structure. */
+ if (peer_buf_cr >= 0)
+ ni->ni_peerrtrcredits = peer_buf_cr;
+ if (peer_timeout >= 0)
+ ni->ni_peertimeout = peer_timeout;
+ /*
+ * TODO
+ * Note: For now, don't allow the user to change
+ * peertxcredits as this number is used in the
+ * IB LND to control queue depth.
+ * if (peer_cr != -1)
+ * ni->ni_peertxcredits = peer_cr;
+ */
+ if (credits >= 0)
+ ni->ni_maxtxcredits = credits;
+
+ LASSERT(ni->ni_peertimeout <= 0 || lnd->lnd_query != NULL);
- lnet_net_lock(LNET_LOCK_EX);
- /* refcount for ln_nis */
+ lnet_net_lock(LNET_LOCK_EX);
+ /* refcount for ln_nis */
+ lnet_ni_addref_locked(ni, 0);
+ list_add_tail(&ni->ni_list, &the_lnet.ln_nis);
+ if (ni->ni_cpts != NULL) {
lnet_ni_addref_locked(ni, 0);
- list_add_tail(&ni->ni_list, &the_lnet.ln_nis);
- if (ni->ni_cpts != NULL) {
- list_add_tail(&ni->ni_cptlist,
- &the_lnet.ln_nis_cpt);
- lnet_ni_addref_locked(ni, 0);
- }
+ list_add_tail(&ni->ni_cptlist, &the_lnet.ln_nis_cpt);
+ }
- lnet_net_unlock(LNET_LOCK_EX);
+ lnet_net_unlock(LNET_LOCK_EX);
+
+ if (lnd->lnd_type == LOLND) {
+ lnet_ni_addref(ni);
+ LASSERT(the_lnet.ln_loni == NULL);
+ the_lnet.ln_loni = ni;
+ return 0;
+ }
- /* increment the ni_count here to account for the LOLND as
- * well. If we increment past this point then the number
- * of count will be missing the LOLND, and then ping and
- * will not report the LOLND
+ if (ni->ni_peertxcredits == 0 || ni->ni_maxtxcredits == 0) {
+ LCONSOLE_ERROR_MSG(0x107, "LNI %s has no %scredits\n",
+ libcfs_lnd2str(lnd->lnd_type),
+ ni->ni_peertxcredits == 0 ?
+ "" : "per-peer ");
+ /* shutdown the NI since if we get here then it must've already
+ * been started
*/
- if (ni_count != NULL)
- (*ni_count)++;
+ lnet_shutdown_lndni(ni);
+ return -EINVAL;
+ }
- if (lnd->lnd_type == LOLND) {
- lnet_ni_addref(ni);
- LASSERT(the_lnet.ln_loni == NULL);
- the_lnet.ln_loni = ni;
- continue;
- }
+ cfs_percpt_for_each(tq, i, ni->ni_tx_queues) {
+ tq->tq_credits_min =
+ tq->tq_credits_max =
+ tq->tq_credits = lnet_ni_tq_credits(ni);
+ }
-#ifndef __KERNEL__
- if (lnd->lnd_wait != NULL) {
- if (the_lnet.ln_eq_waitni == NULL) {
- lnet_ni_addref(ni);
- the_lnet.ln_eq_waitni = ni;
- }
- } else {
-# ifndef HAVE_LIBPTHREAD
- LCONSOLE_ERROR_MSG(0x106, "LND %s not supported in a "
- "single-threaded runtime\n",
- libcfs_lnd2str(lnd_type));
- goto failed;
-# endif
- }
-#endif
- if (ni->ni_peertxcredits == 0 ||
- ni->ni_maxtxcredits == 0) {
- LCONSOLE_ERROR_MSG(0x107, "LNI %s has no %scredits\n",
- libcfs_lnd2str(lnd->lnd_type),
- ni->ni_peertxcredits == 0 ?
- "" : "per-peer ");
- goto failed;
- }
+ CDEBUG(D_LNI, "Added LNI %s [%d/%d/%d/%d]\n",
+ libcfs_nid2str(ni->ni_nid), ni->ni_peertxcredits,
+ lnet_ni_tq_credits(ni) * LNET_CPT_NUMBER,
+ ni->ni_peerrtrcredits, ni->ni_peertimeout);
- cfs_percpt_for_each(tq, i, ni->ni_tx_queues) {
- tq->tq_credits_min =
- tq->tq_credits_max =
- tq->tq_credits = lnet_ni_tq_credits(ni);
- }
+ return 0;
+failed0:
+ lnet_ni_free(ni);
+ return rc;
+}
- CDEBUG(D_LNI, "Added LNI %s [%d/%d/%d/%d]\n",
- libcfs_nid2str(ni->ni_nid), ni->ni_peertxcredits,
- lnet_ni_tq_credits(ni) * LNET_CPT_NUMBER,
- ni->ni_peerrtrcredits, ni->ni_peertimeout);
- }
+static int
+lnet_startup_lndnis(struct list_head *nilist)
+{
+ struct lnet_ni *ni;
+ int rc;
+ int ni_count = 0;
- return 0;
-failed:
while (!list_empty(nilist)) {
ni = list_entry(nilist->next, lnet_ni_t, ni_list);
list_del(&ni->ni_list);
- lnet_ni_free(ni);
+ rc = lnet_startup_lndni(ni, -1, -1, -1, -1);
+
+ if (rc < 0)
+ goto failed;
+
+ ni_count++;
}
- return -EINVAL;
+
+ return ni_count;
+failed:
+ lnet_shutdown_lndnis();
+
+ return rc;
}
/**
* Initialize LNet library.
*
- * Only userspace program needs to call this function - it's automatically
- * called in the kernel at module loading time. Caller has to call LNetFini()
- * after a call to LNetInit(), if and only if the latter returned 0. It must
- * be called exactly once.
+ * Automatically called at module loading time. Caller has to call
+ * lnet_fini() after a call to lnet_init(), if and only if the latter
+ * returned 0. It must be called exactly once.
*
* \return 0 on success, and -ve on failures.
*/
int
-LNetInit(void)
+lnet_init(void)
{
int rc;
lnet_assert_wire_constants();
- LASSERT(!the_lnet.ln_init);
memset(&the_lnet, 0, sizeof(the_lnet));
}
the_lnet.ln_refcount = 0;
- the_lnet.ln_init = 1;
LNetInvalidateHandle(&the_lnet.ln_rc_eqh);
INIT_LIST_HEAD(&the_lnet.ln_lnds);
INIT_LIST_HEAD(&the_lnet.ln_rcd_zombie);
INIT_LIST_HEAD(&the_lnet.ln_rcd_deathrow);
-#ifdef __KERNEL__
/* The hash table size is the number of bits it takes to express the set
* ln_num_routes, minus 1 (better to under estimate than over so we
* don't waste memory). */
/* All LNDs apart from the LOLND are in separate modules. They
* register themselves when their module loads, and unregister
* themselves when their module is unloaded. */
-#else
- the_lnet.ln_remote_nets_hbits = 8;
-
- /* Register LNDs
- * NB the order here determines default 'networks=' order */
-# ifdef HAVE_LIBPTHREAD
- LNET_REGISTER_ULND(the_tcplnd);
-# endif
-#endif
lnet_register_lnd(&the_lolnd);
return 0;
}
-EXPORT_SYMBOL(LNetInit);
/**
* Finalize LNet library.
*
- * Only userspace program needs to call this function. It can be called
- * at most once.
- *
- * \pre LNetInit() called with success.
+ * \pre lnet_init() called with success.
* \pre All LNet users called LNetNIFini() for matching LNetNIInit() calls.
*/
void
-LNetFini(void)
+lnet_fini(void)
{
- LASSERT(the_lnet.ln_init);
LASSERT(the_lnet.ln_refcount == 0);
while (!list_empty(&the_lnet.ln_lnds))
lnet_unregister_lnd(list_entry(the_lnet.ln_lnds.next,
lnd_t, lnd_list));
lnet_destroy_locks();
-
- the_lnet.ln_init = 0;
}
-EXPORT_SYMBOL(LNetFini);
/**
* Set LNet PID and start LNet interfaces, routing, and forwarding.
*
- * Userspace program should call this after a successful call to LNetInit().
* Users must call this function at least once before any other functions.
* For each successful call there must be a corresponding call to
* LNetNIFini(). For subsequent calls to LNetNIInit(), \a requested_pid is
{
int im_a_router = 0;
int rc;
- int ni_count = 0;
- int lnd_type;
- struct lnet_ni *ni;
+ int ni_count;
lnet_ping_info_t *pinfo;
lnet_handle_md_t md_handle;
struct list_head net_head;
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
- LASSERT(the_lnet.ln_init);
CDEBUG(D_OTHER, "refs %d\n", the_lnet.ln_refcount);
if (the_lnet.ln_refcount > 0) {
}
rc = lnet_prepare(requested_pid);
- if (rc != 0)
- goto failed0;
+ if (rc != 0) {
+ LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
+ return rc;
+ }
- rc = lnet_parse_networks(&net_head,
- !the_lnet.ln_nis_from_mod_params ?
- lnet_get_networks() : "");
- if (rc < 0)
- goto failed1;
+ /* Add in the loopback network */
+ if (lnet_ni_alloc(LNET_MKNET(LOLND, 0), NULL, &net_head) == NULL) {
+ rc = -ENOMEM;
+ goto failed0;
+ }
- rc = lnet_startup_lndnis(&net_head, -1, -1, -1, -1, &ni_count);
- if (rc != 0)
- goto failed1;
+ /* If LNet is being initialized via DLC it is possible
+ * that the user requests not to load module parameters (ones which
+ * are supported by DLC) on initialization. Therefore, make sure not
+ * to load networks, routes and forwarding from module parameters
+ * in this case. On cleanup in case of failure only clean up
+ * routes if it has been loaded */
+ if (!the_lnet.ln_nis_from_mod_params) {
+ rc = lnet_parse_networks(&net_head,
+ lnet_get_networks());
+ if (rc < 0)
+ goto failed0;
+ }
- if (the_lnet.ln_eq_waitni != NULL && ni_count > 1) {
- lnd_type = the_lnet.ln_eq_waitni->ni_lnd->lnd_type;
- LCONSOLE_ERROR_MSG(0x109, "LND %s can only run single-network"
- "\n",
- libcfs_lnd2str(lnd_type));
- goto failed2;
+ ni_count = lnet_startup_lndnis(&net_head);
+ if (ni_count < 0) {
+ rc = ni_count;
+ goto failed0;
}
- rc = lnet_parse_routes(lnet_get_routes(), &im_a_router);
- if (rc != 0)
- goto failed2;
+ if (!the_lnet.ln_nis_from_mod_params) {
+ rc = lnet_parse_routes(lnet_get_routes(), &im_a_router);
+ if (rc != 0)
+ goto failed1;
- rc = lnet_check_routes();
- if (rc != 0)
- goto failed2;
+ rc = lnet_check_routes();
+ if (rc != 0)
+ goto failed2;
- rc = lnet_rtrpools_alloc(im_a_router);
- if (rc != 0)
- goto failed2;
+ rc = lnet_rtrpools_alloc(im_a_router);
+ if (rc != 0)
+ goto failed2;
+ }
rc = lnet_acceptor_start();
if (rc != 0)
return 0;
failed4:
- the_lnet.ln_refcount = 0;
- lnet_ping_md_unlink(pinfo, &md_handle);
- lnet_ping_info_free(pinfo);
+ lnet_ping_target_fini();
failed3:
+ the_lnet.ln_refcount = 0;
lnet_acceptor_stop();
- rc = LNetEQFree(the_lnet.ln_ping_target_eq);
- LASSERT(rc == 0);
failed2:
- lnet_destroy_routes();
- lnet_shutdown_lndnis();
+ if (!the_lnet.ln_nis_from_mod_params)
+ lnet_destroy_routes();
failed1:
- lnet_unprepare();
+ lnet_shutdown_lndnis();
failed0:
+ lnet_unprepare();
LASSERT(rc < 0);
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
while (!list_empty(&net_head)) {
+ struct lnet_ni *ni;
ni = list_entry(net_head.next, struct lnet_ni, ni_list);
list_del_init(&ni->ni_list);
lnet_ni_free(ni);
{
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
- LASSERT (the_lnet.ln_init);
LASSERT (the_lnet.ln_refcount > 0);
if (the_lnet.ln_refcount != 1) {
struct lnet_ni *ni;
struct list_head net_head;
int rc;
+ lnet_remotenet_t *rnet;
INIT_LIST_HEAD(&net_head);
/* Create a ni structure for the network string */
rc = lnet_parse_networks(&net_head, nets);
- if (rc < 0)
- return rc;
+ if (rc <= 0)
+ return rc == 0 ? -EINVAL : rc;
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
goto failed0;
}
+ ni = list_entry(net_head.next, struct lnet_ni, ni_list);
+
+ lnet_net_lock(LNET_LOCK_EX);
+ rnet = lnet_find_net_locked(LNET_NIDNET(ni->ni_nid));
+ lnet_net_unlock(LNET_LOCK_EX);
+ /* make sure that the net added doesn't invalidate the current
+ * configuration LNet is keeping */
+ if (rnet != NULL) {
+ CERROR("Adding net %s will invalidate routing configuration\n",
+ nets);
+ rc = -EUSERS;
+ goto failed0;
+ }
+
rc = lnet_ping_info_setup(&pinfo, &md_handle, 1 + lnet_get_ni_count(),
false);
if (rc != 0)
goto failed0;
- rc = lnet_startup_lndnis(&net_head, peer_timeout, peer_cr,
- peer_buf_cr, credits, NULL);
+ list_del_init(&ni->ni_list);
+
+ rc = lnet_startup_lndni(ni, peer_timeout, peer_cr,
+ peer_buf_cr, credits);
if (rc != 0)
goto failed1;
+ if (ni->ni_lnd->lnd_accept != NULL) {
+ rc = lnet_acceptor_start();
+ if (rc < 0) {
+ /* shutdown the ni that we just started */
+ CERROR("Failed to start up acceptor thread\n");
+ lnet_shutdown_lndni(ni);
+ goto failed1;
+ }
+ }
+
lnet_ping_target_update(pinfo, md_handle);
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
int
lnet_dyn_del_ni(__u32 net)
{
- int rc;
+ lnet_ni_t *ni;
+ lnet_ping_info_t *pinfo;
+ lnet_handle_md_t md_handle;
+ int rc;
+
+ /* don't allow userspace to shutdown the LOLND */
+ if (LNET_NETTYP(net) == LOLND)
+ return -EINVAL;
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
- rc = lnet_shutdown_lndni(net);
+ /* create and link a new ping info, before removing the old one */
+ rc = lnet_ping_info_setup(&pinfo, &md_handle,
+ lnet_get_ni_count() - 1, false);
+ if (rc != 0)
+ goto out;
+
+ ni = lnet_net2ni(net);
+ if (ni == NULL) {
+ rc = -EINVAL;
+ goto failed;
+ }
+
+ /* decrement the reference counter taken by lnet_net2ni() */
+ lnet_ni_decref_locked(ni, 0);
+
+ lnet_shutdown_lndni(ni);
+
+ if (lnet_count_acceptor_nis() == 0)
+ lnet_acceptor_stop();
+
+ lnet_ping_target_update(pinfo, md_handle);
+ goto out;
+failed:
+ lnet_ping_md_unlink(pinfo, &md_handle);
+ lnet_ping_info_free(pinfo);
+out:
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
return rc;
CLASSERT(LIBCFS_IOC_DATA_MAX >= sizeof(struct lnet_ioctl_net_config) +
sizeof(struct lnet_ioctl_config_data));
- LASSERT(the_lnet.ln_init);
switch (cmd) {
case IOC_LIBCFS_GET_NI:
case IOC_LIBCFS_ADD_ROUTE:
config = arg;
+
+ if (config->cfg_hdr.ioc_len < sizeof(*config))
+ return -EINVAL;
+
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
rc = lnet_add_route(config->cfg_net,
config->cfg_config_u.cfg_route.rtr_hop,
config->cfg_nid,
config->cfg_config_u.cfg_route.
rtr_priority);
+ if (rc == 0) {
+ rc = lnet_check_routes();
+ if (rc != 0)
+ lnet_del_route(config->cfg_net,
+ config->cfg_nid);
+ }
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
- return (rc != 0) ? rc : lnet_check_routes();
+ return rc;
case IOC_LIBCFS_DEL_ROUTE:
config = arg;
+
+ if (config->cfg_hdr.ioc_len < sizeof(*config))
+ return -EINVAL;
+
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
rc = lnet_del_route(config->cfg_net, config->cfg_nid);
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
case IOC_LIBCFS_GET_ROUTE:
config = arg;
+
+ if (config->cfg_hdr.ioc_len < sizeof(*config))
+ return -EINVAL;
+
return lnet_get_route(config->cfg_count,
&config->cfg_net,
&config->cfg_config_u.cfg_route.rtr_hop,
case IOC_LIBCFS_GET_NET: {
struct lnet_ioctl_net_config *net_config;
+ size_t total = sizeof(*config) + sizeof(*net_config);
+
config = arg;
+
+ if (config->cfg_hdr.ioc_len < total)
+ return -EINVAL;
+
net_config = (struct lnet_ioctl_net_config *)
config->cfg_bulk;
if (config == NULL || net_config == NULL)
{
struct lnet_ioctl_lnet_stats *lnet_stats = arg;
+ if (lnet_stats->st_hdr.ioc_len < sizeof(*lnet_stats))
+ return -EINVAL;
+
lnet_counters_get(&lnet_stats->st_cntrs);
return 0;
}
-#if defined(__KERNEL__) && defined(LNET_ROUTER)
case IOC_LIBCFS_CONFIG_RTR:
config = arg;
+
+ if (config->cfg_hdr.ioc_len < sizeof(*config))
+ return -EINVAL;
+
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
if (config->cfg_config_u.cfg_buffers.buf_enable) {
rc = lnet_rtrpools_enable();
case IOC_LIBCFS_ADD_BUF:
config = arg;
+
+ if (config->cfg_hdr.ioc_len < sizeof(*config))
+ return -EINVAL;
+
LNET_MUTEX_LOCK(&the_lnet.ln_api_mutex);
rc = lnet_rtrpools_adjust(config->cfg_config_u.cfg_buffers.
buf_tiny,
buf_large);
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
return rc;
-#endif
case IOC_LIBCFS_GET_BUF: {
struct lnet_ioctl_pool_cfg *pool_cfg;
+ size_t total = sizeof(*config) + sizeof(*pool_cfg);
+
config = arg;
+
+ if (config->cfg_hdr.ioc_len < total)
+ return -EINVAL;
+
pool_cfg = (struct lnet_ioctl_pool_cfg *)config->cfg_bulk;
return lnet_get_rtr_pool_cfg(config->cfg_count, pool_cfg);
}
case IOC_LIBCFS_GET_PEER_INFO: {
struct lnet_ioctl_peer *peer_info = arg;
+
+ if (peer_info->pr_hdr.ioc_len < sizeof(*peer_info))
+ return -EINVAL;
+
return lnet_get_peer_info(
peer_info->pr_count,
&peer_info->pr_nid,
int cpt;
int rc = -ENOENT;
- LASSERT(the_lnet.ln_init);
LASSERT(the_lnet.ln_refcount > 0);
cpt = lnet_net_lock_current();
lnet_handle_eq_t eqh;
lnet_handle_md_t mdh;
lnet_event_t event;
- lnet_md_t md = {0};
+ lnet_md_t md = { NULL };
int which;
int unlinked = 0;
int replied = 0;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff