#endif
lnet_t the_lnet; /* THE state of the network */
+EXPORT_SYMBOL(the_lnet);
#ifdef __KERNEL__
void
lnet_init_locks(void)
{
- cfs_spin_lock_init(&the_lnet.ln_lock);
cfs_spin_lock_init(&the_lnet.ln_eq_wait_lock);
cfs_waitq_init(&the_lnet.ln_eq_waitq);
cfs_mutex_init(&the_lnet.ln_lnd_mutex);
void lnet_init_locks(void)
{
- the_lnet.ln_lock = 0;
the_lnet.ln_eq_wait_lock = 0;
the_lnet.ln_lnd_mutex = 0;
the_lnet.ln_api_mutex = 0;
{
LASSERT(the_lnet.ln_api_mutex == 0);
LASSERT(the_lnet.ln_lnd_mutex == 0);
- LASSERT(the_lnet.ln_lock == 0);
LASSERT(the_lnet.ln_eq_wait_lock == 0);
}
void lnet_init_locks(void)
{
pthread_cond_init(&the_lnet.ln_eq_cond, NULL);
- pthread_mutex_init(&the_lnet.ln_lock, 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);
{
pthread_mutex_destroy(&the_lnet.ln_api_mutex);
pthread_mutex_destroy(&the_lnet.ln_lnd_mutex);
- pthread_mutex_destroy(&the_lnet.ln_lock);
pthread_mutex_destroy(&the_lnet.ln_eq_wait_lock);
pthread_cond_destroy(&the_lnet.ln_eq_cond);
}
lnet_init_locks();
the_lnet.ln_res_lock = cfs_percpt_lock_alloc(lnet_cpt_table());
- if (the_lnet.ln_res_lock != NULL)
- return 0;
+ if (the_lnet.ln_res_lock == NULL)
+ goto failed;
+
+ the_lnet.ln_net_lock = cfs_percpt_lock_alloc(lnet_cpt_table());
+ if (the_lnet.ln_net_lock == NULL)
+ goto failed;
+ return 0;
+
+ failed:
lnet_fini_locks();
return -ENOMEM;
}
the_lnet.ln_res_lock = NULL;
}
+ if (the_lnet.ln_net_lock != NULL) {
+ cfs_percpt_lock_free(the_lnet.ln_net_lock);
+ the_lnet.ln_net_lock = NULL;
+ }
+
lnet_fini_locks();
}
LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
}
+EXPORT_SYMBOL(lnet_register_lnd);
void
lnet_unregister_lnd (lnd_t *lnd)
LNET_MUTEX_UNLOCK(&the_lnet.ln_lnd_mutex);
}
+EXPORT_SYMBOL(lnet_unregister_lnd);
+
+void
+lnet_counters_get(lnet_counters_t *counters)
+{
+ lnet_counters_t *ctr;
+ int i;
+
+ memset(counters, 0, sizeof(*counters));
+
+ lnet_net_lock(LNET_LOCK_EX);
+
+ cfs_percpt_for_each(ctr, i, the_lnet.ln_counters) {
+ counters->msgs_max += ctr->msgs_max;
+ counters->msgs_alloc += ctr->msgs_alloc;
+ counters->errors += ctr->errors;
+ counters->send_count += ctr->send_count;
+ counters->recv_count += ctr->recv_count;
+ counters->route_count += ctr->route_count;
+ counters->drop_length += ctr->drop_length;
+ counters->send_length += ctr->send_length;
+ counters->recv_length += ctr->recv_length;
+ counters->route_length += ctr->route_length;
+ counters->drop_length += ctr->drop_length;
+
+ }
+ lnet_net_unlock(LNET_LOCK_EX);
+}
+EXPORT_SYMBOL(lnet_counters_get);
+
+void
+lnet_counters_reset(void)
+{
+ lnet_counters_t *counters;
+ int i;
+
+ lnet_net_lock(LNET_LOCK_EX);
+
+ cfs_percpt_for_each(counters, i, the_lnet.ln_counters)
+ memset(counters, 0, sizeof(lnet_counters_t));
+
+ lnet_net_unlock(LNET_LOCK_EX);
+}
+EXPORT_SYMBOL(lnet_counters_reset);
#ifdef LNET_USE_LIB_FREELIST
{
int count = 0;
- if (rec->rec_type == 0) /* not set yet, it's a uninitialized */
+ if (rec->rec_type == 0) /* not set yet, it's uninitialized */
return;
while (!cfs_list_empty(&rec->rec_active)) {
lnet_libhandle_t *lh;
unsigned int hash;
- if ((cookie & (LNET_COOKIE_TYPES - 1)) != rec->rec_type)
+ if ((cookie & LNET_COOKIE_MASK) != rec->rec_type)
return NULL;
hash = cookie >> (LNET_COOKIE_TYPE_BITS + LNET_CPT_BITS);
}
#endif
+int lnet_unprepare(void);
+
int
lnet_prepare(lnet_pid_t requested_pid)
{
- /* Prepare to bring up the network */
+ /* Prepare to bring up the network */
struct lnet_res_container **recs;
int rc = 0;
}
#endif
- memset(&the_lnet.ln_counters, 0,
- sizeof(the_lnet.ln_counters));
-
- 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);
- CFS_INIT_LIST_HEAD (&the_lnet.ln_remote_nets);
- CFS_INIT_LIST_HEAD (&the_lnet.ln_routers);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_test_peers);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_nis);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_nis_cpt);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_nis_zombie);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_remote_nets);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_routers);
- the_lnet.ln_interface_cookie = lnet_create_interface_cookie();
+ the_lnet.ln_interface_cookie = lnet_create_interface_cookie();
- lnet_init_rtrpools();
+ the_lnet.ln_counters = cfs_percpt_alloc(lnet_cpt_table(),
+ sizeof(lnet_counters_t));
+ if (the_lnet.ln_counters == NULL) {
+ CERROR("Failed to allocate counters for LNet\n");
+ rc = -ENOMEM;
+ goto failed;
+ }
- rc = lnet_peer_table_create();
- if (rc != 0)
- goto failed0;
+ rc = lnet_peer_tables_create();
+ if (rc != 0)
+ goto failed;
- /* NB: we will have instance of message container per CPT soon */
- rc = lnet_msg_container_setup(&the_lnet.ln_msg_container);
+ rc = lnet_msg_containers_create();
if (rc != 0)
- goto failed1;
+ 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));
if (rc != 0)
- goto failed2;
+ goto failed;
recs = lnet_res_containers_create(LNET_COOKIE_TYPE_ME, LNET_FL_MAX_MES,
sizeof(lnet_me_t));
if (recs == NULL)
- goto failed3;
+ goto failed;
the_lnet.ln_me_containers = recs;
- /* NB: we will have instance of MD container per CPT soon */
recs = lnet_res_containers_create(LNET_COOKIE_TYPE_MD, LNET_FL_MAX_MDS,
sizeof(lnet_libmd_t));
if (recs == NULL)
- goto failed3;
+ goto failed;
the_lnet.ln_md_containers = recs;
rc = lnet_portals_create();
if (rc != 0) {
CERROR("Failed to create portals for LNet: %d\n", rc);
- goto failed3;
+ goto failed;
}
return 0;
- failed3:
- /* NB: lnet_res_container_cleanup is safe to call for
- * uninitialized container */
- if (the_lnet.ln_md_containers != NULL) {
- lnet_res_containers_destroy(the_lnet.ln_md_containers);
- the_lnet.ln_md_containers = NULL;
- }
- if (the_lnet.ln_me_containers != NULL) {
- lnet_res_containers_destroy(the_lnet.ln_me_containers);
- the_lnet.ln_me_containers = NULL;
- }
- lnet_res_container_cleanup(&the_lnet.ln_eq_container);
- failed2:
- lnet_msg_container_cleanup(&the_lnet.ln_msg_container);
- failed1:
- lnet_peer_table_destroy();
- failed0:
+ failed:
+ lnet_unprepare();
return rc;
}
* descriptors, even those that appear committed to a network op (eg MD
* with non-zero pending count) */
- lnet_fail_nid(LNET_NID_ANY, 0);
+ lnet_fail_nid(LNET_NID_ANY, 0);
- LASSERT (cfs_list_empty(&the_lnet.ln_test_peers));
- LASSERT (the_lnet.ln_refcount == 0);
- LASSERT (cfs_list_empty(&the_lnet.ln_nis));
- LASSERT (cfs_list_empty(&the_lnet.ln_zombie_nis));
- LASSERT (the_lnet.ln_nzombie_nis == 0);
+ LASSERT(the_lnet.ln_refcount == 0);
+ LASSERT(cfs_list_empty(&the_lnet.ln_test_peers));
+ LASSERT(cfs_list_empty(&the_lnet.ln_nis));
+ LASSERT(cfs_list_empty(&the_lnet.ln_nis_cpt));
+ LASSERT(cfs_list_empty(&the_lnet.ln_nis_zombie));
lnet_portals_destroy();
lnet_res_container_cleanup(&the_lnet.ln_eq_container);
- lnet_free_rtrpools();
- lnet_msg_container_cleanup(&the_lnet.ln_msg_container);
- lnet_peer_table_destroy();
+ lnet_msg_containers_destroy();
+ lnet_peer_tables_destroy();
+ lnet_rtrpools_free();
+
+ if (the_lnet.ln_counters != NULL) {
+ cfs_percpt_free(the_lnet.ln_counters);
+ the_lnet.ln_counters = NULL;
+ }
return 0;
}
lnet_ni_t *
-lnet_net2ni_locked (__u32 net)
+lnet_net2ni_locked(__u32 net, int cpt)
{
- cfs_list_t *tmp;
- lnet_ni_t *ni;
+ cfs_list_t *tmp;
+ lnet_ni_t *ni;
- cfs_list_for_each (tmp, &the_lnet.ln_nis) {
- ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
+ LASSERT(cpt != LNET_LOCK_EX);
- if (LNET_NIDNET(ni->ni_nid) == net) {
- lnet_ni_addref_locked(ni);
- return ni;
- }
- }
+ cfs_list_for_each(tmp, &the_lnet.ln_nis) {
+ ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
- return NULL;
+ if (LNET_NIDNET(ni->ni_nid) == net) {
+ lnet_ni_addref_locked(ni, cpt);
+ return ni;
+ }
+ }
+
+ return NULL;
}
-unsigned int
-lnet_nid_cpt_hash(lnet_nid_t nid)
+lnet_ni_t *
+lnet_net2ni(__u32 net)
+{
+ lnet_ni_t *ni;
+
+ lnet_net_lock(0);
+ ni = lnet_net2ni_locked(net, 0);
+ lnet_net_unlock(0);
+
+ return ni;
+}
+EXPORT_SYMBOL(lnet_net2ni);
+
+static unsigned int
+lnet_nid_cpt_hash(lnet_nid_t nid, unsigned int number)
{
__u64 key = nid;
unsigned int val;
+ LASSERT(number >= 1 && number <= LNET_CPT_NUMBER);
+
+ if (number == 1)
+ return 0;
+
val = cfs_hash_long(key, LNET_CPT_BITS);
/* NB: LNET_CP_NUMBER doesn't have to be PO2 */
- if (val < LNET_CPT_NUMBER)
+ if (val < number)
return val;
- return (unsigned int)((key + val + (val >> 1)) % LNET_CPT_NUMBER);
+ return (unsigned int)(key + val + (val >> 1)) % number;
+}
+
+int
+lnet_cpt_of_nid_locked(lnet_nid_t nid)
+{
+ struct lnet_ni *ni;
+
+ /* must called with hold of lnet_net_lock */
+ if (LNET_CPT_NUMBER == 1)
+ return 0; /* the only one */
+
+ /* take lnet_net_lock(any) would be OK */
+ if (!cfs_list_empty(&the_lnet.ln_nis_cpt)) {
+ cfs_list_for_each_entry(ni, &the_lnet.ln_nis_cpt, ni_cptlist) {
+ if (LNET_NIDNET(ni->ni_nid) != LNET_NIDNET(nid))
+ continue;
+
+ LASSERT(ni->ni_cpts != NULL);
+ return ni->ni_cpts[lnet_nid_cpt_hash
+ (nid, ni->ni_ncpts)];
+ }
+ }
+
+ return lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
}
int
lnet_cpt_of_nid(lnet_nid_t nid)
{
+ int cpt;
+ int cpt2;
+
if (LNET_CPT_NUMBER == 1)
return 0; /* the only one */
- return lnet_nid_cpt_hash(nid);
+ if (cfs_list_empty(&the_lnet.ln_nis_cpt))
+ return lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
+
+ cpt = lnet_net_lock_current();
+ cpt2 = lnet_cpt_of_nid_locked(nid);
+ lnet_net_unlock(cpt);
+
+ return cpt2;
}
EXPORT_SYMBOL(lnet_cpt_of_nid);
int
-lnet_islocalnet (__u32 net)
+lnet_islocalnet(__u32 net)
{
- lnet_ni_t *ni;
+ struct lnet_ni *ni;
+ int cpt;
+
+ cpt = lnet_net_lock_current();
+
+ ni = lnet_net2ni_locked(net, cpt);
+ if (ni != NULL)
+ lnet_ni_decref_locked(ni, cpt);
- LNET_LOCK();
- ni = lnet_net2ni_locked(net);
- if (ni != NULL)
- lnet_ni_decref_locked(ni);
- LNET_UNLOCK();
+ lnet_net_unlock(cpt);
- return ni != NULL;
+ return ni != NULL;
}
lnet_ni_t *
-lnet_nid2ni_locked (lnet_nid_t nid)
+lnet_nid2ni_locked(lnet_nid_t nid, int cpt)
{
- cfs_list_t *tmp;
- lnet_ni_t *ni;
+ struct lnet_ni *ni;
+ cfs_list_t *tmp;
- cfs_list_for_each (tmp, &the_lnet.ln_nis) {
- ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
+ LASSERT(cpt != LNET_LOCK_EX);
- if (ni->ni_nid == nid) {
- lnet_ni_addref_locked(ni);
- return ni;
- }
- }
+ cfs_list_for_each(tmp, &the_lnet.ln_nis) {
+ ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
- return NULL;
+ if (ni->ni_nid == nid) {
+ lnet_ni_addref_locked(ni, cpt);
+ return ni;
+ }
+ }
+
+ return NULL;
}
int
-lnet_islocalnid (lnet_nid_t nid)
+lnet_islocalnid(lnet_nid_t nid)
{
- lnet_ni_t *ni;
+ struct lnet_ni *ni;
+ int cpt;
- LNET_LOCK();
- ni = lnet_nid2ni_locked(nid);
- if (ni != NULL)
- lnet_ni_decref_locked(ni);
- LNET_UNLOCK();
+ cpt = lnet_net_lock_current();
+ ni = lnet_nid2ni_locked(nid, cpt);
+ if (ni != NULL)
+ lnet_ni_decref_locked(ni, cpt);
+ lnet_net_unlock(cpt);
- return ni != NULL;
+ return ni != NULL;
}
int
lnet_count_acceptor_nis (void)
{
- /* Return the # of NIs that need the acceptor. */
- int count = 0;
+ /* Return the # of NIs that need the acceptor. */
+ int count = 0;
#if defined(__KERNEL__) || defined(HAVE_LIBPTHREAD)
- cfs_list_t *tmp;
- lnet_ni_t *ni;
+ cfs_list_t *tmp;
+ struct lnet_ni *ni;
+ int cpt;
- LNET_LOCK();
- cfs_list_for_each (tmp, &the_lnet.ln_nis) {
- ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
+ cpt = lnet_net_lock_current();
+ cfs_list_for_each(tmp, &the_lnet.ln_nis) {
+ ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
- if (ni->ni_lnd->lnd_accept != NULL)
- count++;
- }
+ if (ni->ni_lnd->lnd_accept != NULL)
+ count++;
+ }
- LNET_UNLOCK();
+ lnet_net_unlock(cpt);
#endif /* defined(__KERNEL__) || defined(HAVE_LIBPTHREAD) */
- return count;
+ return count;
+}
+
+static int
+lnet_ni_tq_credits(lnet_ni_t *ni)
+{
+ int credits;
+
+ LASSERT(ni->ni_ncpts >= 1);
+
+ if (ni->ni_ncpts == 1)
+ return ni->ni_maxtxcredits;
+
+ credits = ni->ni_maxtxcredits / ni->ni_ncpts;
+ credits = max(credits, 8 * ni->ni_peertxcredits);
+ credits = min(credits, ni->ni_maxtxcredits);
+
+ return credits;
}
void
/* NB called holding the global mutex */
/* All quiet on the API front */
- LASSERT (!the_lnet.ln_shutdown);
- LASSERT (the_lnet.ln_refcount == 0);
- LASSERT (cfs_list_empty(&the_lnet.ln_zombie_nis));
- LASSERT (the_lnet.ln_nzombie_nis == 0);
- LASSERT (cfs_list_empty(&the_lnet.ln_remote_nets));
-
- LNET_LOCK();
- the_lnet.ln_shutdown = 1; /* flag shutdown */
-
- /* Unlink NIs from the global table */
- while (!cfs_list_empty(&the_lnet.ln_nis)) {
- ni = cfs_list_entry(the_lnet.ln_nis.next,
- lnet_ni_t, ni_list);
- cfs_list_del (&ni->ni_list);
-
- the_lnet.ln_nzombie_nis++;
- lnet_ni_decref_locked(ni); /* drop ln_nis' ref */
- }
+ LASSERT(!the_lnet.ln_shutdown);
+ LASSERT(the_lnet.ln_refcount == 0);
+ LASSERT(cfs_list_empty(&the_lnet.ln_nis_zombie));
+ LASSERT(cfs_list_empty(&the_lnet.ln_remote_nets));
+
+ lnet_net_lock(LNET_LOCK_EX);
+ the_lnet.ln_shutdown = 1; /* flag shutdown */
+
+ /* Unlink NIs from the global table */
+ while (!cfs_list_empty(&the_lnet.ln_nis)) {
+ ni = cfs_list_entry(the_lnet.ln_nis.next,
+ lnet_ni_t, ni_list);
+ /* move it to zombie list and nobody can find it anymore */
+ cfs_list_move(&ni->ni_list, &the_lnet.ln_nis_zombie);
+ lnet_ni_decref_locked(ni, 0); /* drop ln_nis' ref */
+
+ if (!cfs_list_empty(&ni->ni_cptlist)) {
+ cfs_list_del_init(&ni->ni_cptlist);
+ lnet_ni_decref_locked(ni, 0);
+ }
+ }
- /* Drop the cached eqwait NI. */
+ /* Drop the cached eqwait NI. */
if (the_lnet.ln_eq_waitni != NULL) {
- lnet_ni_decref_locked(the_lnet.ln_eq_waitni);
+ lnet_ni_decref_locked(the_lnet.ln_eq_waitni, 0);
the_lnet.ln_eq_waitni = NULL;
}
- /* Drop the cached loopback NI. */
- if (the_lnet.ln_loni != NULL) {
- lnet_ni_decref_locked(the_lnet.ln_loni);
- the_lnet.ln_loni = NULL;
- }
+ /* Drop the cached loopback NI. */
+ if (the_lnet.ln_loni != NULL) {
+ lnet_ni_decref_locked(the_lnet.ln_loni, 0);
+ the_lnet.ln_loni = NULL;
+ }
- LNET_UNLOCK();
+ lnet_net_unlock(LNET_LOCK_EX);
/* Clear lazy portals and drop delayed messages which hold refs
* on their lnet_msg_t::msg_rxpeer */
/* Clear the peer table and wait for all peers to go (they hold refs on
* their NIs) */
- lnet_peer_table_cleanup();
-
- LNET_LOCK();
- /* Now wait for the NI's I just nuked to show up on ln_zombie_nis
- * and shut them down in guaranteed thread context */
- i = 2;
- while (the_lnet.ln_nzombie_nis != 0) {
-
- while (cfs_list_empty(&the_lnet.ln_zombie_nis)) {
- LNET_UNLOCK();
- ++i;
- if ((i & (-i)) == i)
- CDEBUG(D_WARNING,"Waiting for %d zombie NIs\n",
- the_lnet.ln_nzombie_nis);
- cfs_pause(cfs_time_seconds(1));
- LNET_LOCK();
- }
+ lnet_peer_tables_cleanup();
+
+ lnet_net_lock(LNET_LOCK_EX);
+ /* Now wait for the NI's I just nuked to show up on ln_zombie_nis
+ * and shut them down in guaranteed thread context */
+ i = 2;
+ while (!cfs_list_empty(&the_lnet.ln_nis_zombie)) {
+ int *ref;
+ int j;
+
+ ni = cfs_list_entry(the_lnet.ln_nis_zombie.next,
+ lnet_ni_t, ni_list);
+ cfs_list_del_init(&ni->ni_list);
+ cfs_percpt_for_each(ref, j, ni->ni_refs) {
+ if (*ref == 0)
+ continue;
+ /* still busy, add it back to zombie list */
+ cfs_list_add(&ni->ni_list, &the_lnet.ln_nis_zombie);
+ break;
+ }
- ni = cfs_list_entry(the_lnet.ln_zombie_nis.next,
- lnet_ni_t, ni_list);
- cfs_list_del(&ni->ni_list);
- ni->ni_lnd->lnd_refcount--;
+ while (!cfs_list_empty(&ni->ni_list)) {
+ lnet_net_unlock(LNET_LOCK_EX);
+ ++i;
+ if ((i & (-i)) == i) {
+ CDEBUG(D_WARNING,
+ "Waiting for zombie LNI %s\n",
+ libcfs_nid2str(ni->ni_nid));
+ }
+ cfs_pause(cfs_time_seconds(1));
+ lnet_net_lock(LNET_LOCK_EX);
+ continue;
+ }
- LNET_UNLOCK();
+ ni->ni_lnd->lnd_refcount--;
+ lnet_net_unlock(LNET_LOCK_EX);
islo = ni->ni_lnd->lnd_type == LOLND;
CDEBUG(D_LNI, "Removed LNI %s\n",
libcfs_nid2str(ni->ni_nid));
- LIBCFS_FREE(ni, sizeof(*ni));
-
- LNET_LOCK();
- the_lnet.ln_nzombie_nis--;
- }
+ lnet_ni_free(ni);
+ lnet_net_lock(LNET_LOCK_EX);
+ }
- the_lnet.ln_shutdown = 0;
- LNET_UNLOCK();
+ the_lnet.ln_shutdown = 0;
+ lnet_net_unlock(LNET_LOCK_EX);
- if (the_lnet.ln_network_tokens != NULL) {
- LIBCFS_FREE(the_lnet.ln_network_tokens,
- the_lnet.ln_network_tokens_nob);
- the_lnet.ln_network_tokens = NULL;
- }
+ if (the_lnet.ln_network_tokens != NULL) {
+ LIBCFS_FREE(the_lnet.ln_network_tokens,
+ the_lnet.ln_network_tokens_nob);
+ the_lnet.ln_network_tokens = NULL;
+ }
}
int
lnet_startup_lndnis (void)
{
- lnd_t *lnd;
- lnet_ni_t *ni;
- cfs_list_t nilist;
+ lnd_t *lnd;
+ struct lnet_ni *ni;
+ struct lnet_tx_queue *tq;
+ cfs_list_t nilist;
+ int i;
int rc = 0;
int lnd_type;
int nicount = 0;
}
#endif
- ni->ni_refcount = 1;
-
- LNET_LOCK();
- lnd->lnd_refcount++;
- LNET_UNLOCK();
+ lnet_net_lock(LNET_LOCK_EX);
+ lnd->lnd_refcount++;
+ lnet_net_unlock(LNET_LOCK_EX);
ni->ni_lnd = lnd;
LCONSOLE_ERROR_MSG(0x105, "Error %d starting up LNI %s"
"\n",
rc, libcfs_lnd2str(lnd->lnd_type));
- LNET_LOCK();
- lnd->lnd_refcount--;
- LNET_UNLOCK();
+ lnet_net_lock(LNET_LOCK_EX);
+ lnd->lnd_refcount--;
+ lnet_net_unlock(LNET_LOCK_EX);
goto failed;
}
cfs_list_del(&ni->ni_list);
- LNET_LOCK();
- cfs_list_add_tail(&ni->ni_list, &the_lnet.ln_nis);
- LNET_UNLOCK();
+ lnet_net_lock(LNET_LOCK_EX);
+ /* refcount for ln_nis */
+ lnet_ni_addref_locked(ni, 0);
+ cfs_list_add_tail(&ni->ni_list, &the_lnet.ln_nis);
+ if (ni->ni_cpts != NULL) {
+ cfs_list_add_tail(&ni->ni_cptlist,
+ &the_lnet.ln_nis_cpt);
+ lnet_ni_addref_locked(ni, 0);
+ }
+
+ lnet_net_unlock(LNET_LOCK_EX);
if (lnd->lnd_type == LOLND) {
lnet_ni_addref(ni);
goto failed;
}
- ni->ni_txcredits = ni->ni_mintxcredits = ni->ni_maxtxcredits;
+ 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);
+ }
- CDEBUG(D_LNI, "Added LNI %s [%d/%d/%d/%d]\n",
- libcfs_nid2str(ni->ni_nid),
- ni->ni_peertxcredits, ni->ni_txcredits,
- ni->ni_peerrtrcredits, ni->ni_peertimeout);
+ 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);
- nicount++;
- }
+ nicount++;
+ }
if (the_lnet.ln_eq_waitni != NULL && nicount > 1) {
lnd_type = the_lnet.ln_eq_waitni->ni_lnd->lnd_type;
while (!cfs_list_empty(&nilist)) {
ni = cfs_list_entry(nilist.next, lnet_ni_t, ni_list);
cfs_list_del(&ni->ni_list);
- LIBCFS_FREE(ni, sizeof(*ni));
- }
+ lnet_ni_free(ni);
+ }
- return -ENETDOWN;
+ return -ENETDOWN;
}
/**
{
int rc;
- lnet_assert_wire_constants ();
- LASSERT (!the_lnet.ln_init);
+ lnet_assert_wire_constants();
+ LASSERT(!the_lnet.ln_init);
- memset(&the_lnet, 0, sizeof(the_lnet));
+ memset(&the_lnet, 0, sizeof(the_lnet));
/* refer to global cfs_cpt_table for now */
the_lnet.ln_cpt_table = cfs_cpt_table;
return -1;
}
- the_lnet.ln_refcount = 0;
- the_lnet.ln_init = 1;
- LNetInvalidateHandle(&the_lnet.ln_rc_eqh);
- CFS_INIT_LIST_HEAD(&the_lnet.ln_lnds);
+ the_lnet.ln_refcount = 0;
+ the_lnet.ln_init = 1;
+ LNetInvalidateHandle(&the_lnet.ln_rc_eqh);
+ CFS_INIT_LIST_HEAD(&the_lnet.ln_lnds);
CFS_INIT_LIST_HEAD(&the_lnet.ln_rcd_zombie);
CFS_INIT_LIST_HEAD(&the_lnet.ln_rcd_deathrow);
#else
/* Register LNDs
* NB the order here determines default 'networks=' order */
-# ifdef CRAY_XT3
- LNET_REGISTER_ULND(the_ptllnd);
-# endif
# ifdef HAVE_LIBPTHREAD
LNET_REGISTER_ULND(the_tcplnd);
# endif
lnet_register_lnd(&the_lolnd);
return 0;
}
+EXPORT_SYMBOL(LNetInit);
/**
* Finalize LNet library.
the_lnet.ln_init = 0;
}
+EXPORT_SYMBOL(LNetFini);
/**
* Set LNet PID and start LNet interfaces, routing, and forwarding.
if (rc != 0)
goto failed2;
- rc = lnet_alloc_rtrpools(im_a_router);
+ rc = lnet_rtrpools_alloc(im_a_router);
if (rc != 0)
goto failed2;
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
return rc;
}
+EXPORT_SYMBOL(LNetNIInit);
/**
* Stop LNet interfaces, routing, and forwarding.
LNET_MUTEX_UNLOCK(&the_lnet.ln_api_mutex);
return 0;
}
+EXPORT_SYMBOL(LNetNIFini);
/**
* This is an ugly hack to export IOC_LIBCFS_DEBUG_PEER and
return 0;
case IOC_LIBCFS_TESTPROTOCOMPAT:
- LNET_LOCK();
- the_lnet.ln_testprotocompat = data->ioc_flags;
- LNET_UNLOCK();
+ lnet_net_lock(LNET_LOCK_EX);
+ the_lnet.ln_testprotocompat = data->ioc_flags;
+ lnet_net_unlock(LNET_LOCK_EX);
return 0;
case IOC_LIBCFS_PING:
}
/* not reached */
}
+EXPORT_SYMBOL(LNetCtl);
/**
* Retrieve the lnet_process_id_t ID of LNet interface at \a index. Note that
int
LNetGetId(unsigned int index, lnet_process_id_t *id)
{
- lnet_ni_t *ni;
- cfs_list_t *tmp;
- int rc = -ENOENT;
+ struct lnet_ni *ni;
+ cfs_list_t *tmp;
+ int cpt;
+ int rc = -ENOENT;
- LASSERT (the_lnet.ln_init);
- LASSERT (the_lnet.ln_refcount > 0);
+ LASSERT(the_lnet.ln_init);
+ LASSERT(the_lnet.ln_refcount > 0);
- LNET_LOCK();
+ cpt = lnet_net_lock_current();
cfs_list_for_each(tmp, &the_lnet.ln_nis) {
if (index-- != 0)
break;
}
- LNET_UNLOCK();
-
- return rc;
+ lnet_net_unlock(cpt);
+ return rc;
}
+EXPORT_SYMBOL(LNetGetId);
/**
* Print a string representation of handle \a h into buffer \a str of
{
snprintf(str, len, LPX64, h.cookie);
}
+EXPORT_SYMBOL(LNetSnprintHandle);
static int
lnet_create_ping_info(void)
pinfo->pi_nnis = n;
pinfo->pi_pid = the_lnet.ln_pid;
pinfo->pi_magic = LNET_PROTO_PING_MAGIC;
- pinfo->pi_version = LNET_PROTO_PING_VERSION;
+ pinfo->pi_features = LNET_PING_FEAT_NI_STATUS;
for (i = 0; i < n; i++) {
lnet_ni_status_t *ns = &pinfo->pi_ni[i];
ns->ns_nid = id.nid;
ns->ns_status = LNET_NI_STATUS_UP;
- LNET_LOCK();
+ lnet_net_lock(0);
- ni = lnet_nid2ni_locked(id.nid);
- LASSERT (ni != NULL);
- LASSERT (ni->ni_status == NULL);
- ni->ni_status = ns;
- lnet_ni_decref_locked(ni);
+ ni = lnet_nid2ni_locked(id.nid, 0);
+ LASSERT(ni != NULL);
- LNET_UNLOCK();
- }
+ lnet_ni_lock(ni);
+ LASSERT(ni->ni_status == NULL);
+ ni->ni_status = ns;
+ lnet_ni_unlock(ni);
- the_lnet.ln_ping_info = pinfo;
- return 0;
+ lnet_ni_decref_locked(ni, 0);
+ lnet_net_unlock(0);
+ }
+
+ the_lnet.ln_ping_info = pinfo;
+ return 0;
}
static void
lnet_destroy_ping_info(void)
{
- lnet_ni_t *ni;
+ struct lnet_ni *ni;
- LNET_LOCK();
+ lnet_net_lock(0);
- cfs_list_for_each_entry (ni, &the_lnet.ln_nis, ni_list) {
- ni->ni_status = NULL;
- }
+ cfs_list_for_each_entry(ni, &the_lnet.ln_nis, ni_list) {
+ lnet_ni_lock(ni);
+ ni->ni_status = NULL;
+ lnet_ni_unlock(ni);
+ }
- LNET_UNLOCK();
+ lnet_net_unlock(0);
LIBCFS_FREE(the_lnet.ln_ping_info,
offsetof(lnet_ping_info_t,
goto out_1;
}
- if (info->pi_version != LNET_PROTO_PING_VERSION) {
- CERROR("%s: Unexpected version 0x%x\n",
- libcfs_id2str(id), info->pi_version);
- goto out_1;
- }
+ if ((info->pi_features & LNET_PING_FEAT_NI_STATUS) == 0) {
+ CERROR("%s: ping w/o NI status: 0x%x\n",
+ libcfs_id2str(id), info->pi_features);
+ goto out_1;
+ }
if (nob < offsetof(lnet_ping_info_t, pi_ni[0])) {
CERROR("%s: Short reply %d(%d min)\n", libcfs_id2str(id),