X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lnet%2Flnet%2Fapi-ni.c;h=f8310e4753fce1d8fb1845bafb279284f3aa79a9;hp=d6e5e3d5b9bcbe04a160d6b1c549329289791319;hb=d2631a28541ee0cdc8aef3bee8ebb329b048a42c;hpb=6062999295090244874594db69a3dffa6f4f8a53

diff --git a/lnet/lnet/api-ni.c b/lnet/lnet/api-ni.c
index d6e5e3d..f8310e4 100644
--- a/lnet/lnet/api-ni.c
+++ b/lnet/lnet/api-ni.c
@@ -37,6 +37,9 @@
 #include <linux/ktime.h>
 #include <linux/moduleparam.h>
 #include <linux/uaccess.h>
+#ifdef HAVE_SCHED_HEADERS
+#include <linux/sched/signal.h>
+#endif
 
 #include <lnet/lib-lnet.h>
 
@@ -180,7 +183,7 @@ MODULE_PARM_DESC(lnet_drop_asym_route,
 		 "Set to 1 to drop asymmetrical route messages.");
 
 #define LNET_TRANSACTION_TIMEOUT_NO_HEALTH_DEFAULT 50
-#define LNET_TRANSACTION_TIMEOUT_HEALTH_DEFAULT 10
+#define LNET_TRANSACTION_TIMEOUT_HEALTH_DEFAULT 50
 
 unsigned lnet_transaction_timeout = LNET_TRANSACTION_TIMEOUT_HEALTH_DEFAULT;
 static int transaction_to_set(const char *val, cfs_kernel_param_arg_t *kp);
@@ -200,7 +203,7 @@ module_param_call(lnet_transaction_timeout, transaction_to_set, param_get_int,
 MODULE_PARM_DESC(lnet_transaction_timeout,
 		"Maximum number of seconds to wait for a peer response.");
 
-#define LNET_RETRY_COUNT_HEALTH_DEFAULT 3
+#define LNET_RETRY_COUNT_HEALTH_DEFAULT 2
 unsigned lnet_retry_count = LNET_RETRY_COUNT_HEALTH_DEFAULT;
 static int retry_count_set(const char *val, cfs_kernel_param_arg_t *kp);
 #ifdef HAVE_KERNEL_PARAM_OPS
@@ -545,22 +548,18 @@ lnet_init_locks(void)
 {
 	spin_lock_init(&the_lnet.ln_eq_wait_lock);
 	spin_lock_init(&the_lnet.ln_msg_resend_lock);
-	init_waitqueue_head(&the_lnet.ln_eq_waitq);
 	init_completion(&the_lnet.ln_mt_wait_complete);
 	mutex_init(&the_lnet.ln_lnd_mutex);
 }
 
-static void
-lnet_fini_locks(void)
-{
-}
-
 struct kmem_cache *lnet_mes_cachep;	   /* MEs kmem_cache */
 struct kmem_cache *lnet_small_mds_cachep;  /* <= LNET_SMALL_MD_SIZE bytes
 					    *  MDs kmem_cache */
+struct kmem_cache *lnet_rspt_cachep;	   /* response tracker cache */
+struct kmem_cache *lnet_msg_cachep;
 
 static int
-lnet_descriptor_setup(void)
+lnet_slab_setup(void)
 {
 	/* create specific kmem_cache for MEs and small MDs (i.e., originally
 	 * allocated in <size-xxx> kmem_cache).
@@ -576,12 +575,32 @@ lnet_descriptor_setup(void)
 	if (!lnet_small_mds_cachep)
 		return -ENOMEM;
 
+	lnet_rspt_cachep = kmem_cache_create("lnet_rspt", sizeof(struct lnet_rsp_tracker),
+					    0, 0, NULL);
+	if (!lnet_rspt_cachep)
+		return -ENOMEM;
+
+	lnet_msg_cachep = kmem_cache_create("lnet_msg", sizeof(struct lnet_msg),
+					    0, 0, NULL);
+	if (!lnet_msg_cachep)
+		return -ENOMEM;
+
 	return 0;
 }
 
 static void
-lnet_descriptor_cleanup(void)
+lnet_slab_cleanup(void)
 {
+	if (lnet_msg_cachep) {
+		kmem_cache_destroy(lnet_msg_cachep);
+		lnet_msg_cachep = NULL;
+	}
+
+
+	if (lnet_rspt_cachep) {
+		kmem_cache_destroy(lnet_rspt_cachep);
+		lnet_rspt_cachep = NULL;
+	}
 
 	if (lnet_small_mds_cachep) {
 		kmem_cache_destroy(lnet_small_mds_cachep);
@@ -602,7 +621,7 @@ lnet_create_remote_nets_table(void)
 
 	LASSERT(the_lnet.ln_remote_nets_hash == NULL);
 	LASSERT(the_lnet.ln_remote_nets_hbits > 0);
-	LIBCFS_ALLOC(hash, LNET_REMOTE_NETS_HASH_SIZE * sizeof(*hash));
+	CFS_ALLOC_PTR_ARRAY(hash, LNET_REMOTE_NETS_HASH_SIZE);
 	if (hash == NULL) {
 		CERROR("Failed to create remote nets hash table\n");
 		return -ENOMEM;
@@ -625,9 +644,8 @@ lnet_destroy_remote_nets_table(void)
 	for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++)
 		LASSERT(list_empty(&the_lnet.ln_remote_nets_hash[i]));
 
-	LIBCFS_FREE(the_lnet.ln_remote_nets_hash,
-		    LNET_REMOTE_NETS_HASH_SIZE *
-		    sizeof(the_lnet.ln_remote_nets_hash[0]));
+	CFS_FREE_PTR_ARRAY(the_lnet.ln_remote_nets_hash,
+			   LNET_REMOTE_NETS_HASH_SIZE);
 	the_lnet.ln_remote_nets_hash = NULL;
 }
 
@@ -643,8 +661,6 @@ lnet_destroy_locks(void)
 		cfs_percpt_lock_free(the_lnet.ln_net_lock);
 		the_lnet.ln_net_lock = NULL;
 	}
-
-	lnet_fini_locks();
 }
 
 static int
@@ -675,141 +691,142 @@ static void lnet_assert_wire_constants(void)
 	 * with gcc version 3.3.3 20040412 (Red Hat Linux 3.3.3-7) */
 
 	/* Constants... */
-	CLASSERT(LNET_PROTO_TCP_MAGIC == 0xeebc0ded);
-	CLASSERT(LNET_PROTO_TCP_VERSION_MAJOR == 1);
-	CLASSERT(LNET_PROTO_TCP_VERSION_MINOR == 0);
-	CLASSERT(LNET_MSG_ACK == 0);
-	CLASSERT(LNET_MSG_PUT == 1);
-	CLASSERT(LNET_MSG_GET == 2);
-	CLASSERT(LNET_MSG_REPLY == 3);
-	CLASSERT(LNET_MSG_HELLO == 4);
+	BUILD_BUG_ON(LNET_PROTO_TCP_MAGIC != 0xeebc0ded);
+	BUILD_BUG_ON(LNET_PROTO_TCP_VERSION_MAJOR != 1);
+	BUILD_BUG_ON(LNET_PROTO_TCP_VERSION_MINOR != 0);
+	BUILD_BUG_ON(LNET_MSG_ACK != 0);
+	BUILD_BUG_ON(LNET_MSG_PUT != 1);
+	BUILD_BUG_ON(LNET_MSG_GET != 2);
+	BUILD_BUG_ON(LNET_MSG_REPLY != 3);
+	BUILD_BUG_ON(LNET_MSG_HELLO != 4);
 
 	/* Checks for struct lnet_handle_wire */
-	CLASSERT((int)sizeof(struct lnet_handle_wire) == 16);
-	CLASSERT((int)offsetof(struct lnet_handle_wire, wh_interface_cookie) == 0);
-	CLASSERT((int)sizeof(((struct lnet_handle_wire *)0)->wh_interface_cookie) == 8);
-	CLASSERT((int)offsetof(struct lnet_handle_wire, wh_object_cookie) == 8);
-	CLASSERT((int)sizeof(((struct lnet_handle_wire *)0)->wh_object_cookie) == 8);
+	BUILD_BUG_ON((int)sizeof(struct lnet_handle_wire) != 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_handle_wire,
+				   wh_interface_cookie) != 0);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_handle_wire *)0)->wh_interface_cookie) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_handle_wire,
+				   wh_object_cookie) != 8);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_handle_wire *)0)->wh_object_cookie) != 8);
 
 	/* Checks for struct struct lnet_magicversion */
-	CLASSERT((int)sizeof(struct lnet_magicversion) == 8);
-	CLASSERT((int)offsetof(struct lnet_magicversion, magic) == 0);
-	CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->magic) == 4);
-	CLASSERT((int)offsetof(struct lnet_magicversion, version_major) == 4);
-	CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->version_major) == 2);
-	CLASSERT((int)offsetof(struct lnet_magicversion, version_minor) == 6);
-	CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->version_minor) == 2);
+	BUILD_BUG_ON((int)sizeof(struct lnet_magicversion) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_magicversion, magic) != 0);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_magicversion *)0)->magic) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_magicversion, version_major) != 4);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_magicversion *)0)->version_major) != 2);
+	BUILD_BUG_ON((int)offsetof(struct lnet_magicversion,
+				   version_minor) != 6);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_magicversion *)0)->version_minor) != 2);
 
 	/* Checks for struct struct lnet_hdr */
-	CLASSERT((int)sizeof(struct lnet_hdr) == 72);
-	CLASSERT((int)offsetof(struct lnet_hdr, dest_nid) == 0);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->dest_nid) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, src_nid) == 8);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->src_nid) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, dest_pid) == 16);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->dest_pid) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, src_pid) == 20);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->src_pid) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, type) == 24);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->type) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, payload_length) == 28);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->payload_length) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg) == 32);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg) == 40);
+	BUILD_BUG_ON((int)sizeof(struct lnet_hdr) != 72);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, dest_nid) != 0);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->dest_nid) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, src_nid) != 8);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->src_nid) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, dest_pid) != 16);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->dest_pid) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, src_pid) != 20);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->src_pid) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, type) != 24);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->type) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, payload_length) != 28);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->payload_length) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg) != 32);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg) != 40);
 
 	/* Ack */
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.dst_wmd) == 32);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.dst_wmd) == 16);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.match_bits) == 48);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.match_bits) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.mlength) == 56);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.mlength) == 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.ack.dst_wmd) != 32);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.ack.dst_wmd) != 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.ack.match_bits) != 48);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.ack.match_bits) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.ack.mlength) != 56);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.ack.mlength) != 4);
 
 	/* Put */
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.put.ack_wmd) == 32);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.ack_wmd) == 16);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.put.match_bits) == 48);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.match_bits) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.put.hdr_data) == 56);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.hdr_data) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.put.ptl_index) == 64);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.ptl_index) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.put.offset) == 68);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.offset) == 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.ack_wmd) != 32);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.ack_wmd) != 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.match_bits) != 48);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.match_bits) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.hdr_data) != 56);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.hdr_data) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.ptl_index) != 64);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.ptl_index) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.put.offset) != 68);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.put.offset) != 4);
 
 	/* Get */
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.get.return_wmd) == 32);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.return_wmd) == 16);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.get.match_bits) == 48);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.match_bits) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.get.ptl_index) == 56);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.ptl_index) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.get.src_offset) == 60);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.src_offset) == 4);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.get.sink_length) == 64);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.sink_length) == 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.return_wmd) != 32);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.return_wmd) != 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.match_bits) != 48);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.match_bits) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.ptl_index) != 56);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.ptl_index) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.src_offset) != 60);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.src_offset) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.get.sink_length) != 64);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.get.sink_length) != 4);
 
 	/* Reply */
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.reply.dst_wmd) == 32);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.reply.dst_wmd) == 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.reply.dst_wmd) != 32);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.reply.dst_wmd) != 16);
 
 	/* Hello */
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.hello.incarnation) == 32);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.hello.incarnation) == 8);
-	CLASSERT((int)offsetof(struct lnet_hdr, msg.hello.type) == 40);
-	CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.hello.type) == 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.hello.incarnation) != 32);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.hello.incarnation) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_hdr, msg.hello.type) != 40);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_hdr *)0)->msg.hello.type) != 4);
 
 	/* Checks for struct lnet_ni_status and related constants */
-	CLASSERT(LNET_NI_STATUS_INVALID == 0x00000000);
-	CLASSERT(LNET_NI_STATUS_UP == 0x15aac0de);
-	CLASSERT(LNET_NI_STATUS_DOWN == 0xdeadface);
+	BUILD_BUG_ON(LNET_NI_STATUS_INVALID != 0x00000000);
+	BUILD_BUG_ON(LNET_NI_STATUS_UP != 0x15aac0de);
+	BUILD_BUG_ON(LNET_NI_STATUS_DOWN != 0xdeadface);
 
 	/* Checks for struct lnet_ni_status */
-	CLASSERT((int)sizeof(struct lnet_ni_status) == 16);
-	CLASSERT((int)offsetof(struct lnet_ni_status, ns_nid) == 0);
-	CLASSERT((int)sizeof(((struct lnet_ni_status *)0)->ns_nid) == 8);
-	CLASSERT((int)offsetof(struct lnet_ni_status, ns_status) == 8);
-	CLASSERT((int)sizeof(((struct lnet_ni_status *)0)->ns_status) == 4);
-	CLASSERT((int)offsetof(struct lnet_ni_status, ns_unused) == 12);
-	CLASSERT((int)sizeof(((struct lnet_ni_status *)0)->ns_unused) == 4);
+	BUILD_BUG_ON((int)sizeof(struct lnet_ni_status) != 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ni_status, ns_nid) != 0);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_nid) != 8);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ni_status, ns_status) != 8);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_status) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ni_status, ns_unused) != 12);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_unused) != 4);
 
 	/* Checks for struct lnet_ping_info and related constants */
-	CLASSERT(LNET_PROTO_PING_MAGIC == 0x70696E67);
-	CLASSERT(LNET_PING_FEAT_INVAL == 0);
-	CLASSERT(LNET_PING_FEAT_BASE == 1);
-	CLASSERT(LNET_PING_FEAT_NI_STATUS == 2);
-	CLASSERT(LNET_PING_FEAT_RTE_DISABLED == 4);
-	CLASSERT(LNET_PING_FEAT_MULTI_RAIL == 8);
-	CLASSERT(LNET_PING_FEAT_DISCOVERY == 16);
-	CLASSERT(LNET_PING_FEAT_BITS == 31);
+	BUILD_BUG_ON(LNET_PROTO_PING_MAGIC != 0x70696E67);
+	BUILD_BUG_ON(LNET_PING_FEAT_INVAL != 0);
+	BUILD_BUG_ON(LNET_PING_FEAT_BASE != 1);
+	BUILD_BUG_ON(LNET_PING_FEAT_NI_STATUS != 2);
+	BUILD_BUG_ON(LNET_PING_FEAT_RTE_DISABLED != 4);
+	BUILD_BUG_ON(LNET_PING_FEAT_MULTI_RAIL != 8);
+	BUILD_BUG_ON(LNET_PING_FEAT_DISCOVERY != 16);
+	BUILD_BUG_ON(LNET_PING_FEAT_BITS != 31);
 
 	/* Checks for struct lnet_ping_info */
-	CLASSERT((int)sizeof(struct lnet_ping_info) == 16);
-	CLASSERT((int)offsetof(struct lnet_ping_info, pi_magic) == 0);
-	CLASSERT((int)sizeof(((struct lnet_ping_info *)0)->pi_magic) == 4);
-	CLASSERT((int)offsetof(struct lnet_ping_info, pi_features) == 4);
-	CLASSERT((int)sizeof(((struct lnet_ping_info *)0)->pi_features) == 4);
-	CLASSERT((int)offsetof(struct lnet_ping_info, pi_pid) == 8);
-	CLASSERT((int)sizeof(((struct lnet_ping_info *)0)->pi_pid) == 4);
-	CLASSERT((int)offsetof(struct lnet_ping_info, pi_nnis) == 12);
-	CLASSERT((int)sizeof(((struct lnet_ping_info *)0)->pi_nnis) == 4);
-	CLASSERT((int)offsetof(struct lnet_ping_info, pi_ni) == 16);
-	CLASSERT((int)sizeof(((struct lnet_ping_info *)0)->pi_ni) == 0);
+	BUILD_BUG_ON((int)sizeof(struct lnet_ping_info) != 16);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ping_info, pi_magic) != 0);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ping_info *)0)->pi_magic) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ping_info, pi_features) != 4);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ping_info *)0)->pi_features) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ping_info, pi_pid) != 8);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ping_info *)0)->pi_pid) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ping_info, pi_nnis) != 12);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ping_info *)0)->pi_nnis) != 4);
+	BUILD_BUG_ON((int)offsetof(struct lnet_ping_info, pi_ni) != 16);
+	BUILD_BUG_ON((int)sizeof(((struct lnet_ping_info *)0)->pi_ni) != 0);
 }
 
-static struct lnet_lnd *lnet_find_lnd_by_type(__u32 type)
+static const struct lnet_lnd *lnet_find_lnd_by_type(__u32 type)
 {
-	struct lnet_lnd *lnd;
-	struct list_head *tmp;
+	const struct lnet_lnd *lnd;
 
 	/* holding lnd mutex */
-	list_for_each(tmp, &the_lnet.ln_lnds) {
-		lnd = list_entry(tmp, struct lnet_lnd, lnd_list);
+	if (type >= NUM_LNDS)
+		return NULL;
+	lnd = the_lnet.ln_lnds[type];
+	LASSERT(!lnd || lnd->lnd_type == type);
 
-		if (lnd->lnd_type == type)
-			return lnd;
-	}
-	return NULL;
+	return lnd;
 }
 
 unsigned int
@@ -820,14 +837,14 @@ lnet_get_lnd_timeout(void)
 EXPORT_SYMBOL(lnet_get_lnd_timeout);
 
 void
-lnet_register_lnd(struct lnet_lnd *lnd)
+lnet_register_lnd(const struct lnet_lnd *lnd)
 {
 	mutex_lock(&the_lnet.ln_lnd_mutex);
 
 	LASSERT(libcfs_isknown_lnd(lnd->lnd_type));
 	LASSERT(lnet_find_lnd_by_type(lnd->lnd_type) == NULL);
 
-	list_add_tail(&lnd->lnd_list, &the_lnet.ln_lnds);
+	the_lnet.ln_lnds[lnd->lnd_type] = lnd;
 
 	CDEBUG(D_NET, "%s LND registered\n", libcfs_lnd2str(lnd->lnd_type));
 
@@ -836,13 +853,13 @@ lnet_register_lnd(struct lnet_lnd *lnd)
 EXPORT_SYMBOL(lnet_register_lnd);
 
 void
-lnet_unregister_lnd(struct lnet_lnd *lnd)
+lnet_unregister_lnd(const struct lnet_lnd *lnd)
 {
 	mutex_lock(&the_lnet.ln_lnd_mutex);
 
 	LASSERT(lnet_find_lnd_by_type(lnd->lnd_type) == lnd);
 
-	list_del(&lnd->lnd_list);
+	the_lnet.ln_lnds[lnd->lnd_type] = NULL;
 	CDEBUG(D_NET, "%s LND unregistered\n", libcfs_lnd2str(lnd->lnd_type));
 
 	mutex_unlock(&the_lnet.ln_lnd_mutex);
@@ -960,10 +977,7 @@ lnet_res_container_cleanup(struct lnet_res_container *rec)
 		struct list_head *e = rec->rec_active.next;
 
 		list_del_init(e);
-		if (rec->rec_type == LNET_COOKIE_TYPE_EQ) {
-			lnet_eq_free(list_entry(e, struct lnet_eq, eq_list));
-
-		} else if (rec->rec_type == LNET_COOKIE_TYPE_MD) {
+		if (rec->rec_type == LNET_COOKIE_TYPE_MD) {
 			lnet_md_free(list_entry(e, struct lnet_libmd, md_list));
 
 		} else { /* NB: Active MEs should be attached on portals */
@@ -981,8 +995,7 @@ lnet_res_container_cleanup(struct lnet_res_container *rec)
 	}
 
 	if (rec->rec_lh_hash != NULL) {
-		LIBCFS_FREE(rec->rec_lh_hash,
-			    LNET_LH_HASH_SIZE * sizeof(rec->rec_lh_hash[0]));
+		CFS_FREE_PTR_ARRAY(rec->rec_lh_hash, LNET_LH_HASH_SIZE);
 		rec->rec_lh_hash = NULL;
 	}
 
@@ -1151,10 +1164,10 @@ lnet_prepare(lnet_pid_t requested_pid)
 	INIT_LIST_HEAD(&the_lnet.ln_mt_localNIRecovq);
 	INIT_LIST_HEAD(&the_lnet.ln_mt_peerNIRecovq);
 	init_waitqueue_head(&the_lnet.ln_dc_waitq);
-	LNetInvalidateEQHandle(&the_lnet.ln_mt_eqh);
+	the_lnet.ln_mt_eq = NULL;
 	init_completion(&the_lnet.ln_started);
 
-	rc = lnet_descriptor_setup();
+	rc = lnet_slab_setup();
 	if (rc != 0)
 		goto failed;
 
@@ -1189,14 +1202,6 @@ lnet_prepare(lnet_pid_t requested_pid)
 	if (rc != 0)
 		goto failed;
 
-	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);
 	if (recs == NULL) {
 		rc = -ENOMEM;
@@ -1245,9 +1250,9 @@ lnet_unprepare (void)
 		the_lnet.ln_mt_zombie_rstqs = NULL;
 	}
 
-	if (!LNetEQHandleIsInvalid(the_lnet.ln_mt_eqh)) {
-		rc = LNetEQFree(the_lnet.ln_mt_eqh);
-		LNetInvalidateEQHandle(&the_lnet.ln_mt_eqh);
+	if (the_lnet.ln_mt_eq) {
+		rc = LNetEQFree(the_lnet.ln_mt_eq);
+		the_lnet.ln_mt_eq = NULL;
 		LASSERT(rc == 0);
 	}
 
@@ -1258,11 +1263,6 @@ lnet_unprepare (void)
 		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);
 
 	lnet_msg_containers_destroy();
@@ -1274,7 +1274,7 @@ lnet_unprepare (void)
 		the_lnet.ln_counters = NULL;
 	}
 	lnet_destroy_remote_nets_table();
-	lnet_descriptor_cleanup();
+	lnet_slab_cleanup();
 
 	return 0;
 }
@@ -1510,7 +1510,7 @@ lnet_ping_buffer_alloc(int nnis, gfp_t gfp)
 void
 lnet_ping_buffer_free(struct lnet_ping_buffer *pbuf)
 {
-	LASSERT(lnet_ping_buffer_numref(pbuf) == 0);
+	LASSERT(atomic_read(&pbuf->pb_refcnt) == 0);
 	LIBCFS_FREE(pbuf, LNET_PING_BUFFER_SIZE(pbuf->pb_nnis));
 }
 
@@ -1672,14 +1672,15 @@ lnet_ping_target_setup(struct lnet_ping_buffer **ppbuf,
 		.nid = LNET_NID_ANY,
 		.pid = LNET_PID_ANY
 	};
-	struct lnet_handle_me me_handle;
+	struct lnet_me *me;
 	struct lnet_md md = { NULL };
 	int rc, rc2;
 
 	if (set_eq) {
-		rc = LNetEQAlloc(0, lnet_ping_target_event_handler,
-				 &the_lnet.ln_ping_target_eq);
-		if (rc != 0) {
+		the_lnet.ln_ping_target_eq =
+			LNetEQAlloc(lnet_ping_target_event_handler);
+		if (IS_ERR(the_lnet.ln_ping_target_eq)) {
+			rc = PTR_ERR(the_lnet.ln_ping_target_eq);
 			CERROR("Can't allocate ping buffer EQ: %d\n", rc);
 			return rc;
 		}
@@ -1692,11 +1693,11 @@ lnet_ping_target_setup(struct lnet_ping_buffer **ppbuf,
 	}
 
 	/* Ping target ME/MD */
-	rc = LNetMEAttach(LNET_RESERVED_PORTAL, id,
+	me = LNetMEAttach(LNET_RESERVED_PORTAL, id,
 			  LNET_PROTO_PING_MATCHBITS, 0,
-			  LNET_UNLINK, LNET_INS_AFTER,
-			  &me_handle);
-	if (rc != 0) {
+			  LNET_UNLINK, LNET_INS_AFTER);
+	if (IS_ERR(me)) {
+		rc = PTR_ERR(me);
 		CERROR("Can't create ping target ME: %d\n", rc);
 		goto fail_decref_ping_buffer;
 	}
@@ -1711,7 +1712,7 @@ lnet_ping_target_setup(struct lnet_ping_buffer **ppbuf,
 	md.eq_handle = the_lnet.ln_ping_target_eq;
 	md.user_ptr  = *ppbuf;
 
-	rc = LNetMDAttach(me_handle, md, LNET_RETAIN, ping_mdh);
+	rc = LNetMDAttach(me, md, LNET_RETAIN, ping_mdh);
 	if (rc != 0) {
 		CERROR("Can't attach ping target MD: %d\n", rc);
 		goto fail_unlink_ping_me;
@@ -1721,10 +1722,9 @@ lnet_ping_target_setup(struct lnet_ping_buffer **ppbuf,
 	return 0;
 
 fail_unlink_ping_me:
-	rc2 = LNetMEUnlink(me_handle);
-	LASSERT(rc2 == 0);
+	LNetMEUnlink(me);
 fail_decref_ping_buffer:
-	LASSERT(lnet_ping_buffer_numref(*ppbuf) == 1);
+	LASSERT(atomic_read(&(*ppbuf)->pb_refcnt) == 1);
 	lnet_ping_buffer_decref(*ppbuf);
 	*ppbuf = NULL;
 fail_free_eq:
@@ -1739,19 +1739,14 @@ static void
 lnet_ping_md_unlink(struct lnet_ping_buffer *pbuf,
 		    struct lnet_handle_md *ping_mdh)
 {
-	sigset_t	blocked = cfs_block_allsigs();
-
 	LNetMDUnlink(*ping_mdh);
 	LNetInvalidateMDHandle(ping_mdh);
 
 	/* NB the MD could be busy; this just starts the unlink */
-	while (lnet_ping_buffer_numref(pbuf) > 1) {
+	while (atomic_read(&pbuf->pb_refcnt) > 1) {
 		CDEBUG(D_NET, "Still waiting for ping data MD to unlink\n");
-		set_current_state(TASK_UNINTERRUPTIBLE);
-		schedule_timeout(cfs_time_seconds(1));
+		schedule_timeout_uninterruptible(cfs_time_seconds(1));
 	}
-
-	cfs_restore_sigs(blocked);
 }
 
 static void
@@ -1854,30 +1849,33 @@ int lnet_push_target_resize(void)
 {
 	struct lnet_process_id id = { LNET_NID_ANY, LNET_PID_ANY };
 	struct lnet_md md = { NULL };
-	struct lnet_handle_me meh;
+	struct lnet_me *me;
 	struct lnet_handle_md mdh;
 	struct lnet_handle_md old_mdh;
 	struct lnet_ping_buffer *pbuf;
 	struct lnet_ping_buffer *old_pbuf;
-	int nnis = the_lnet.ln_push_target_nnis;
+	int nnis;
 	int rc;
 
+again:
+	nnis = the_lnet.ln_push_target_nnis;
 	if (nnis <= 0) {
 		rc = -EINVAL;
 		goto fail_return;
 	}
-again:
+
 	pbuf = lnet_ping_buffer_alloc(nnis, GFP_NOFS);
 	if (!pbuf) {
 		rc = -ENOMEM;
 		goto fail_return;
 	}
 
-	rc = LNetMEAttach(LNET_RESERVED_PORTAL, id,
+	me = LNetMEAttach(LNET_RESERVED_PORTAL, id,
 			  LNET_PROTO_PING_MATCHBITS, 0,
-			  LNET_UNLINK, LNET_INS_AFTER,
-			  &meh);
-	if (rc) {
+			  LNET_UNLINK, LNET_INS_AFTER);
+
+	if (IS_ERR(me)) {
+		rc = PTR_ERR(me);
 		CERROR("Can't create push target ME: %d\n", rc);
 		goto fail_decref_pbuf;
 	}
@@ -1892,10 +1890,10 @@ again:
 	md.user_ptr  = pbuf;
 	md.eq_handle = the_lnet.ln_push_target_eq;
 
-	rc = LNetMDAttach(meh, md, LNET_RETAIN, &mdh);
+	rc = LNetMDAttach(me, md, LNET_RETAIN, &mdh);
 	if (rc) {
 		CERROR("Can't attach push MD: %d\n", rc);
-		goto fail_unlink_meh;
+		goto fail_unlink_me;
 	}
 	lnet_ping_buffer_addref(pbuf);
 
@@ -1918,8 +1916,8 @@ again:
 
 	return 0;
 
-fail_unlink_meh:
-	LNetMEUnlink(meh);
+fail_unlink_me:
+	LNetMEUnlink(me);
 fail_decref_pbuf:
 	lnet_ping_buffer_decref(pbuf);
 fail_return:
@@ -1947,9 +1945,10 @@ static int lnet_push_target_init(void)
 	if (the_lnet.ln_push_target)
 		return -EALREADY;
 
-	rc = LNetEQAlloc(0, lnet_push_target_event_handler,
-			 &the_lnet.ln_push_target_eq);
-	if (rc) {
+	the_lnet.ln_push_target_eq =
+		LNetEQAlloc(lnet_push_target_event_handler);
+	if (IS_ERR(the_lnet.ln_push_target_eq)) {
+		rc = PTR_ERR(the_lnet.ln_push_target_eq);
 		CERROR("Can't allocated push target EQ: %d\n", rc);
 		return rc;
 	}
@@ -1961,7 +1960,7 @@ static int lnet_push_target_init(void)
 
 	if (rc) {
 		LNetEQFree(the_lnet.ln_push_target_eq);
-		LNetInvalidateEQHandle(&the_lnet.ln_push_target_eq);
+		the_lnet.ln_push_target_eq = NULL;
 	}
 
 	return rc;
@@ -1978,10 +1977,9 @@ static void lnet_push_target_fini(void)
 	LNetInvalidateMDHandle(&the_lnet.ln_push_target_md);
 
 	/* Wait for the unlink to complete. */
-	while (lnet_ping_buffer_numref(the_lnet.ln_push_target) > 1) {
+	while (atomic_read(&the_lnet.ln_push_target->pb_refcnt) > 1) {
 		CDEBUG(D_NET, "Still waiting for ping data MD to unlink\n");
-		set_current_state(TASK_UNINTERRUPTIBLE);
-		schedule_timeout(cfs_time_seconds(1));
+		schedule_timeout_uninterruptible(cfs_time_seconds(1));
 	}
 
 	lnet_ping_buffer_decref(the_lnet.ln_push_target);
@@ -1989,7 +1987,7 @@ static void lnet_push_target_fini(void)
 	the_lnet.ln_push_target_nnis = 0;
 
 	LNetEQFree(the_lnet.ln_push_target_eq);
-	LNetInvalidateEQHandle(&the_lnet.ln_push_target_eq);
+	the_lnet.ln_push_target_eq = NULL;
 }
 
 static int
@@ -2057,8 +2055,7 @@ lnet_clear_zombies_nis_locked(struct lnet_net *net)
 				       "Waiting for zombie LNI %s\n",
 				       libcfs_nid2str(ni->ni_nid));
 			}
-			set_current_state(TASK_UNINTERRUPTIBLE);
-			schedule_timeout(cfs_time_seconds(1));
+			schedule_timeout_uninterruptible(cfs_time_seconds(1));
 			lnet_net_lock(LNET_LOCK_EX);
 			continue;
 		}
@@ -2068,7 +2065,14 @@ lnet_clear_zombies_nis_locked(struct lnet_net *net)
 		islo = ni->ni_net->net_lnd->lnd_type == LOLND;
 
 		LASSERT(!in_interrupt());
+		/* Holding the mutex makes it safe for lnd_shutdown
+		 * to call module_put(). Module unload cannot finish
+		 * until lnet_unregister_lnd() completes, and that
+		 * requires the mutex.
+		 */
+		mutex_lock(&the_lnet.ln_lnd_mutex);
 		(net->net_lnd->lnd_shutdown)(ni);
+		mutex_unlock(&the_lnet.ln_lnd_mutex);
 
 		if (!islo)
 			CDEBUG(D_LNI, "Removed LNI %s\n",
@@ -2133,11 +2137,9 @@ static void
 lnet_shutdown_lndnets(void)
 {
 	struct lnet_net *net;
-	struct list_head resend;
+	LIST_HEAD(resend);
 	struct lnet_msg *msg, *tmp;
 
-	INIT_LIST_HEAD(&resend);
-
 	/* NB called holding the global mutex */
 
 	/* All quiet on the API front */
@@ -2147,16 +2149,12 @@ lnet_shutdown_lndnets(void)
 	lnet_net_lock(LNET_LOCK_EX);
 	the_lnet.ln_state = LNET_STATE_STOPPING;
 
-	while (!list_empty(&the_lnet.ln_nets)) {
-		/*
-		 * move the nets to the zombie list to avoid them being
-		 * picked up for new work. LONET is also included in the
-		 * Nets that will be moved to the zombie list
-		 */
-		net = list_entry(the_lnet.ln_nets.next,
-				 struct lnet_net, net_list);
-		list_move(&net->net_list, &the_lnet.ln_net_zombie);
-	}
+	/*
+	 * move the nets to the zombie list to avoid them being
+	 * picked up for new work. LONET is also included in the
+	 * Nets that will be moved to the zombie list
+	 */
+	list_splice_init(&the_lnet.ln_nets, &the_lnet.ln_net_zombie);
 
 	/* Drop the cached loopback Net. */
 	if (the_lnet.ln_loni != NULL) {
@@ -2268,21 +2266,19 @@ static int
 lnet_startup_lndnet(struct lnet_net *net, struct lnet_lnd_tunables *tun)
 {
 	struct lnet_ni *ni;
-	struct lnet_net	*net_l = NULL;
-	struct list_head	local_ni_list;
-	int			rc;
-	int			ni_count = 0;
-	__u32			lnd_type;
-	struct lnet_lnd *lnd;
-	int			peer_timeout =
+	struct lnet_net *net_l = NULL;
+	LIST_HEAD(local_ni_list);
+	int rc;
+	int ni_count = 0;
+	__u32 lnd_type;
+	const struct lnet_lnd  *lnd;
+	int peer_timeout =
 		net->net_tunables.lct_peer_timeout;
-	int			maxtxcredits =
+	int maxtxcredits =
 		net->net_tunables.lct_max_tx_credits;
-	int			peerrtrcredits =
+	int peerrtrcredits =
 		net->net_tunables.lct_peer_rtr_credits;
 
-	INIT_LIST_HEAD(&local_ni_list);
-
 	/*
 	 * make sure that this net is unique. If it isn't then
 	 * we are adding interfaces to an already existing network, and
@@ -2377,9 +2373,6 @@ lnet_startup_lndnet(struct lnet_net *net, struct lnet_lnd_tunables *tun)
 
 		rc = lnet_startup_lndni(ni, tun);
 
-		LASSERT(ni->ni_net->net_tunables.lct_peer_timeout <= 0 ||
-			ni->ni_net->net_lnd->lnd_query != NULL);
-
 		if (rc < 0)
 			goto failed1;
 
@@ -2495,8 +2488,8 @@ int lnet_lib_init(void)
 	lnet_assert_wire_constants();
 
 	/* refer to global cfs_cpt_table for now */
-	the_lnet.ln_cpt_table	= cfs_cpt_table;
-	the_lnet.ln_cpt_number	= cfs_cpt_number(cfs_cpt_table);
+	the_lnet.ln_cpt_table = cfs_cpt_tab;
+	the_lnet.ln_cpt_number = cfs_cpt_number(cfs_cpt_tab);
 
 	LASSERT(the_lnet.ln_cpt_number > 0);
 	if (the_lnet.ln_cpt_number > LNET_CPT_MAX) {
@@ -2517,7 +2510,6 @@ int lnet_lib_init(void)
 	}
 
 	the_lnet.ln_refcount = 0;
-	INIT_LIST_HEAD(&the_lnet.ln_lnds);
 	INIT_LIST_HEAD(&the_lnet.ln_net_zombie);
 	INIT_LIST_HEAD(&the_lnet.ln_msg_resend);
 
@@ -2543,14 +2535,18 @@ int lnet_lib_init(void)
  *
  * \pre lnet_lib_init() called with success.
  * \pre All LNet users called LNetNIFini() for matching LNetNIInit() calls.
+ *
+ * As this happens at module-unload, all lnds must already be unloaded,
+ * so they must already be unregistered.
  */
 void lnet_lib_exit(void)
 {
-	LASSERT(the_lnet.ln_refcount == 0);
+	int i;
 
-	while (!list_empty(&the_lnet.ln_lnds))
-		lnet_unregister_lnd(list_entry(the_lnet.ln_lnds.next,
-					       struct lnet_lnd, lnd_list));
+	LASSERT(the_lnet.ln_refcount == 0);
+	lnet_unregister_lnd(&the_lolnd);
+	for (i = 0; i < NUM_LNDS; i++)
+		LASSERT(!the_lnet.ln_lnds[i]);
 	lnet_destroy_locks();
 }
 
@@ -2577,11 +2573,9 @@ LNetNIInit(lnet_pid_t requested_pid)
 	int			ni_count;
 	struct lnet_ping_buffer	*pbuf;
 	struct lnet_handle_md	ping_mdh;
-	struct list_head	net_head;
+	LIST_HEAD(net_head);
 	struct lnet_net		*net;
 
-	INIT_LIST_HEAD(&net_head);
-
 	mutex_lock(&the_lnet.ln_api_mutex);
 
 	CDEBUG(D_OTHER, "refs %d\n", the_lnet.ln_refcount);
@@ -2653,8 +2647,9 @@ LNetNIInit(lnet_pid_t requested_pid)
 
 	lnet_ping_target_update(pbuf, ping_mdh);
 
-	rc = LNetEQAlloc(0, lnet_mt_event_handler, &the_lnet.ln_mt_eqh);
-	if (rc != 0) {
+	the_lnet.ln_mt_eq = LNetEQAlloc(lnet_mt_event_handler);
+	if (IS_ERR(the_lnet.ln_mt_eq)) {
+		rc = PTR_ERR(the_lnet.ln_mt_eq);
 		CERROR("Can't allocate monitor thread EQ: %d\n", rc);
 		goto err_stop_ping;
 	}
@@ -3168,9 +3163,7 @@ static int lnet_handle_legacy_ip2nets(char *ip2nets,
 	struct lnet_net *net;
 	char *nets;
 	int rc;
-	struct list_head net_head;
-
-	INIT_LIST_HEAD(&net_head);
+	LIST_HEAD(net_head);
 
 	rc = lnet_parse_ip2nets(&nets, ip2nets);
 	if (rc < 0)
@@ -3349,14 +3342,12 @@ unlock_api_mutex:
 int
 lnet_dyn_add_net(struct lnet_ioctl_config_data *conf)
 {
-	struct lnet_net		*net;
-	struct list_head	net_head;
-	int			rc;
+	struct lnet_net *net;
+	LIST_HEAD(net_head);
+	int rc;
 	struct lnet_ioctl_config_lnd_tunables tun;
 	char *nets = conf->cfg_config_u.cfg_net.net_intf;
 
-	INIT_LIST_HEAD(&net_head);
-
 	/* Create a net/ni structures for the network string */
 	rc = lnet_parse_networks(&net_head, nets, use_tcp_bonding);
 	if (rc <= 0)
@@ -3912,9 +3903,7 @@ LNetCtl(unsigned int cmd, void *arg)
 		return 0;
 
 	case IOC_LIBCFS_TESTPROTOCOMPAT:
-		lnet_net_lock(LNET_LOCK_EX);
 		the_lnet.ln_testprotocompat = data->ioc_flags;
-		lnet_net_unlock(LNET_LOCK_EX);
 		return 0;
 
 	case IOC_LIBCFS_LNET_FAULT:
@@ -4089,24 +4078,45 @@ LNetGetId(unsigned int index, struct lnet_process_id *id)
 }
 EXPORT_SYMBOL(LNetGetId);
 
+struct ping_data {
+	int rc;
+	int replied;
+	struct lnet_handle_md mdh;
+	struct completion completion;
+};
+
+static void
+lnet_ping_event_handler(struct lnet_event *event)
+{
+	struct ping_data *pd = event->md.user_ptr;
+
+	CDEBUG(D_NET, "ping event (%d %d)%s\n",
+	       event->type, event->status,
+	       event->unlinked ? " unlinked" : "");
+
+	if (event->status) {
+		if (!pd->rc)
+			pd->rc = event->status;
+	} else if (event->type == LNET_EVENT_REPLY) {
+		pd->replied = 1;
+		pd->rc = event->mlength;
+	}
+	if (event->unlinked)
+		complete(&pd->completion);
+}
+
 static int lnet_ping(struct lnet_process_id id, signed long timeout,
 		     struct lnet_process_id __user *ids, int n_ids)
 {
-	struct lnet_handle_eq eqh;
-	struct lnet_handle_md mdh;
-	struct lnet_event event;
+	struct lnet_eq *eq;
 	struct lnet_md md = { NULL };
-	int which;
-	int unlinked = 0;
-	int replied = 0;
-	const signed long a_long_time = cfs_time_seconds(60);
+	struct ping_data pd = { 0 };
 	struct lnet_ping_buffer *pbuf;
 	struct lnet_process_id tmpid;
 	int i;
 	int nob;
 	int rc;
 	int rc2;
-	sigset_t blocked;
 
 	/* n_ids limit is arbitrary */
 	if (n_ids <= 0 || id.nid == LNET_NID_ANY)
@@ -4126,9 +4136,9 @@ static int lnet_ping(struct lnet_process_id id, signed long timeout,
 	if (!pbuf)
 		return -ENOMEM;
 
-	/* NB 2 events max (including any unlink event) */
-	rc = LNetEQAlloc(2, LNET_EQ_HANDLER_NONE, &eqh);
-	if (rc != 0) {
+	eq = LNetEQAlloc(lnet_ping_event_handler);
+	if (IS_ERR(eq)) {
+		rc = PTR_ERR(eq);
 		CERROR("Can't allocate EQ: %d\n", rc);
 		goto fail_ping_buffer_decref;
 	}
@@ -4139,79 +4149,40 @@ static int lnet_ping(struct lnet_process_id id, signed long timeout,
 	md.threshold = 2; /* GET/REPLY */
 	md.max_size  = 0;
 	md.options   = LNET_MD_TRUNCATE;
-	md.user_ptr  = NULL;
-	md.eq_handle = eqh;
+	md.user_ptr  = &pd;
+	md.eq_handle = eq;
+
+	init_completion(&pd.completion);
 
-	rc = LNetMDBind(md, LNET_UNLINK, &mdh);
+	rc = LNetMDBind(md, LNET_UNLINK, &pd.mdh);
 	if (rc != 0) {
 		CERROR("Can't bind MD: %d\n", rc);
 		goto fail_free_eq;
 	}
 
-	rc = LNetGet(LNET_NID_ANY, mdh, id,
+	rc = LNetGet(LNET_NID_ANY, pd.mdh, id,
 		     LNET_RESERVED_PORTAL,
 		     LNET_PROTO_PING_MATCHBITS, 0, false);
 
 	if (rc != 0) {
 		/* Don't CERROR; this could be deliberate! */
-		rc2 = LNetMDUnlink(mdh);
+		rc2 = LNetMDUnlink(pd.mdh);
 		LASSERT(rc2 == 0);
 
 		/* NB must wait for the UNLINK event below... */
-		unlinked = 1;
-		timeout = a_long_time;
-	}
-
-	do {
-		/* MUST block for unlink to complete */
-		if (unlinked)
-			blocked = cfs_block_allsigs();
-
-		rc2 = LNetEQPoll(&eqh, 1, timeout, &event, &which);
-
-		if (unlinked)
-			cfs_restore_sigs(blocked);
-
-		CDEBUG(D_NET, "poll %d(%d %d)%s\n", rc2,
-		       (rc2 <= 0) ? -1 : event.type,
-		       (rc2 <= 0) ? -1 : event.status,
-		       (rc2 > 0 && event.unlinked) ? " unlinked" : "");
-
-		LASSERT(rc2 != -EOVERFLOW);	/* can't miss anything */
-
-		if (rc2 <= 0 || event.status != 0) {
-			/* timeout or error */
-			if (!replied && rc == 0)
-				rc = (rc2 < 0) ? rc2 :
-				     (rc2 == 0) ? -ETIMEDOUT :
-				     event.status;
-
-			if (!unlinked) {
-				/* Ensure completion in finite time... */
-				LNetMDUnlink(mdh);
-				/* No assertion (racing with network) */
-				unlinked = 1;
-				timeout = a_long_time;
-			} else if (rc2 == 0) {
-				/* timed out waiting for unlink */
-				CWARN("ping %s: late network completion\n",
-				      libcfs_id2str(id));
-			}
-		} else if (event.type == LNET_EVENT_REPLY) {
-			replied = 1;
-			rc = event.mlength;
-		}
-	} while (rc2 <= 0 || !event.unlinked);
+	}
 
-	if (!replied) {
-		if (rc >= 0)
-			CWARN("%s: Unexpected rc >= 0 but no reply!\n",
-			      libcfs_id2str(id));
+	if (wait_for_completion_timeout(&pd.completion, timeout) == 0) {
+		/* Ensure completion in finite time... */
+		LNetMDUnlink(pd.mdh);
+		wait_for_completion(&pd.completion);
+	}
+	if (!pd.replied) {
 		rc = -EIO;
 		goto fail_free_eq;
 	}
 
-	nob = rc;
+	nob = pd.rc;
 	LASSERT(nob >= 0 && nob <= LNET_PING_INFO_SIZE(n_ids));
 
 	rc = -EPROTO;		/* if I can't parse... */
@@ -4265,7 +4236,7 @@ static int lnet_ping(struct lnet_process_id id, signed long timeout,
 	rc = pbuf->pb_info.pi_nnis;
 
  fail_free_eq:
-	rc2 = LNetEQFree(eqh);
+	rc2 = LNetEQFree(eq);
 	if (rc2 != 0)
 		CERROR("rc2 %d\n", rc2);
 	LASSERT(rc2 == 0);
@@ -4287,7 +4258,6 @@ lnet_discover(struct lnet_process_id id, __u32 force,
 	int i;
 	int rc;
 	int max_intf = lnet_interfaces_max;
-	size_t buf_size;
 
 	if (n_ids <= 0 ||
 	    id.nid == LNET_NID_ANY)
@@ -4303,9 +4273,7 @@ lnet_discover(struct lnet_process_id id, __u32 force,
 	if (n_ids > max_intf)
 		n_ids = max_intf;
 
-	buf_size = n_ids * sizeof(*buf);
-
-	LIBCFS_ALLOC(buf, buf_size);
+	CFS_ALLOC_PTR_ARRAY(buf, n_ids);
 	if (!buf)
 		return -ENOMEM;
 
@@ -4358,7 +4326,7 @@ out_decref:
 out:
 	lnet_net_unlock(cpt);
 
-	LIBCFS_FREE(buf, buf_size);
+	CFS_FREE_PTR_ARRAY(buf, n_ids);
 
 	return rc;
 }