X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=inline;f=lnet%2Fklnds%2Fsocklnd%2Fsocklnd.c;h=cdc15e91e7a8e40050a4e7c8a04e7f191c963e30;hb=71b2476e4ddb95aa42f4a0ea3f23b1826017bfa5;hp=4d3b7a4c4b08ed5d5d6f66402b238990a1c3e1ba;hpb=fdce7be68eb7ab2fc7945e81d2dc49f3595ec790;p=fs%2Flustre-release.git

diff --git a/lnet/klnds/socklnd/socklnd.c b/lnet/klnds/socklnd/socklnd.c
index 4d3b7a4..cdc15e9 100644
--- a/lnet/klnds/socklnd/socklnd.c
+++ b/lnet/klnds/socklnd/socklnd.c
@@ -27,7 +27,6 @@
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
  *
  * lnet/klnds/socklnd/socklnd.c
  *
@@ -48,16 +47,12 @@ static struct ksock_interface *
 ksocknal_ip2iface(struct lnet_ni *ni, struct sockaddr *addr)
 {
 	struct ksock_net *net = ni->ni_data;
-	int i;
 	struct ksock_interface *iface;
 
-	for (i = 0; i < net->ksnn_ninterfaces; i++) {
-		LASSERT(i < LNET_INTERFACES_NUM);
-		iface = &net->ksnn_interfaces[i];
+	iface = &net->ksnn_interface;
 
-		if (rpc_cmp_addr((struct sockaddr *)&iface->ksni_addr, addr))
-			return iface;
-	}
+	if (rpc_cmp_addr((struct sockaddr *)&iface->ksni_addr, addr))
+		return iface;
 
 	return NULL;
 }
@@ -66,16 +61,12 @@ static struct ksock_interface *
 ksocknal_index2iface(struct lnet_ni *ni, int index)
 {
 	struct ksock_net *net = ni->ni_data;
-	int i;
 	struct ksock_interface *iface;
 
-	for (i = 0; i < net->ksnn_ninterfaces; i++) {
-		LASSERT(i < LNET_INTERFACES_NUM);
-		iface = &net->ksnn_interfaces[i];
+	iface = &net->ksnn_interface;
 
-		if (iface->ksni_index == index)
-			return iface;
-	}
+	if (iface->ksni_index == index)
+		return iface;
 
 	return NULL;
 }
@@ -119,40 +110,43 @@ static int ksocknal_ip2index(struct sockaddr *addr, struct lnet_ni *ni)
 	return ret;
 }
 
-static struct ksock_route *
-ksocknal_create_route(struct sockaddr *addr)
+static struct ksock_conn_cb *
+ksocknal_create_conn_cb(struct sockaddr *addr)
 {
-	struct ksock_route *route;
-
-	LIBCFS_ALLOC (route, sizeof (*route));
-	if (route == NULL)
-		return (NULL);
-
-	refcount_set(&route->ksnr_refcount, 1);
-	route->ksnr_peer = NULL;
-	route->ksnr_retry_interval = 0;         /* OK to connect at any time */
-	rpc_copy_addr((struct sockaddr *)&route->ksnr_addr, addr);
-	rpc_set_port((struct sockaddr *)&route->ksnr_addr, rpc_get_port(addr));
-	route->ksnr_myiface = -1;
-	route->ksnr_scheduled = 0;
-	route->ksnr_connecting = 0;
-	route->ksnr_connected = 0;
-	route->ksnr_deleted = 0;
-	route->ksnr_conn_count = 0;
-	route->ksnr_share_count = 0;
-
-	return route;
+	struct ksock_conn_cb *conn_cb;
+
+	LIBCFS_ALLOC(conn_cb, sizeof(*conn_cb));
+	if (!conn_cb)
+		return NULL;
+
+	refcount_set(&conn_cb->ksnr_refcount, 1);
+	conn_cb->ksnr_peer = NULL;
+	conn_cb->ksnr_retry_interval = 0;         /* OK to connect at any time */
+	rpc_copy_addr((struct sockaddr *)&conn_cb->ksnr_addr, addr);
+	rpc_set_port((struct sockaddr *)&conn_cb->ksnr_addr,
+		     rpc_get_port(addr));
+	conn_cb->ksnr_myiface = -1;
+	conn_cb->ksnr_scheduled = 0;
+	conn_cb->ksnr_connecting = 0;
+	conn_cb->ksnr_connected = 0;
+	conn_cb->ksnr_deleted = 0;
+	conn_cb->ksnr_conn_count = 0;
+	conn_cb->ksnr_ctrl_conn_count = 0;
+	conn_cb->ksnr_blki_conn_count = 0;
+	conn_cb->ksnr_blko_conn_count = 0;
+
+	return conn_cb;
 }
 
 void
-ksocknal_destroy_route(struct ksock_route *route)
+ksocknal_destroy_conn_cb(struct ksock_conn_cb *conn_cb)
 {
-	LASSERT(refcount_read(&route->ksnr_refcount) == 0);
+	LASSERT(refcount_read(&conn_cb->ksnr_refcount) == 0);
 
-	if (route->ksnr_peer != NULL)
-		ksocknal_peer_decref(route->ksnr_peer);
+	if (conn_cb->ksnr_peer)
+		ksocknal_peer_decref(conn_cb->ksnr_peer);
 
-	LIBCFS_FREE (route, sizeof (*route));
+	LIBCFS_FREE(conn_cb, sizeof(*conn_cb));
 }
 
 static struct ksock_peer_ni *
@@ -185,9 +179,9 @@ ksocknal_create_peer(struct lnet_ni *ni, struct lnet_process_id id)
 	peer_ni->ksnp_proto = NULL;
 	peer_ni->ksnp_last_alive = 0;
 	peer_ni->ksnp_zc_next_cookie = SOCKNAL_KEEPALIVE_PING + 1;
+	peer_ni->ksnp_conn_cb = NULL;
 
 	INIT_LIST_HEAD(&peer_ni->ksnp_conns);
-	INIT_LIST_HEAD(&peer_ni->ksnp_routes);
 	INIT_LIST_HEAD(&peer_ni->ksnp_tx_queue);
 	INIT_LIST_HEAD(&peer_ni->ksnp_zc_req_list);
 	spin_lock_init(&peer_ni->ksnp_lock);
@@ -206,13 +200,13 @@ ksocknal_destroy_peer(struct ksock_peer_ni *peer_ni)
 	LASSERT(refcount_read(&peer_ni->ksnp_refcount) == 0);
 	LASSERT(peer_ni->ksnp_accepting == 0);
 	LASSERT(list_empty(&peer_ni->ksnp_conns));
-	LASSERT(list_empty(&peer_ni->ksnp_routes));
+	LASSERT(peer_ni->ksnp_conn_cb == NULL);
 	LASSERT(list_empty(&peer_ni->ksnp_tx_queue));
 	LASSERT(list_empty(&peer_ni->ksnp_zc_req_list));
 
 	LIBCFS_FREE(peer_ni, sizeof(*peer_ni));
 
-	/* NB a peer_ni's connections and routes keep a reference on their
+	/* NB a peer_ni's connections and conn_cb keep a reference on their
 	 * peer_ni until they are destroyed, so we can be assured that _all_
 	 * state to do with this peer_ni has been cleaned up when its refcount
 	 * drops to zero.
@@ -284,7 +278,7 @@ ksocknal_unlink_peer_locked(struct ksock_peer_ni *peer_ni)
 	}
 
 	LASSERT(list_empty(&peer_ni->ksnp_conns));
-	LASSERT(list_empty(&peer_ni->ksnp_routes));
+	LASSERT(peer_ni->ksnp_conn_cb == NULL);
 	LASSERT(!peer_ni->ksnp_closing);
 	peer_ni->ksnp_closing = 1;
 	hlist_del(&peer_ni->ksnp_list);
@@ -298,8 +292,7 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index,
 		       int *port, int *conn_count, int *share_count)
 {
 	struct ksock_peer_ni *peer_ni;
-	struct ksock_route *route;
-	struct list_head *rtmp;
+	struct ksock_conn_cb *conn_cb;
 	int i;
 	int j;
 	int rc = -ENOENT;
@@ -312,7 +305,7 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index,
 			continue;
 
 		if (peer_ni->ksnp_n_passive_ips == 0 &&
-		    list_empty(&peer_ni->ksnp_routes)) {
+		    peer_ni->ksnp_conn_cb == NULL) {
 			if (index-- > 0)
 				continue;
 
@@ -340,22 +333,21 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index,
 			goto out;
 		}
 
-		list_for_each(rtmp, &peer_ni->ksnp_routes) {
+		if (peer_ni->ksnp_conn_cb) {
 			if (index-- > 0)
 				continue;
 
-			route = list_entry(rtmp, struct ksock_route,
-					   ksnr_list);
+			conn_cb = peer_ni->ksnp_conn_cb;
 
 			*id = peer_ni->ksnp_id;
-			if (route->ksnr_addr.ss_family == AF_INET) {
+			if (conn_cb->ksnr_addr.ss_family == AF_INET) {
 				struct sockaddr_in *sa =
-					(void *)&route->ksnr_addr;
-				rc = choose_ipv4_src(
-					myip,
-					route->ksnr_myiface,
-					ntohl(sa->sin_addr.s_addr),
-					ni->ni_net_ns);
+					(void *)&conn_cb->ksnr_addr;
+
+				rc = choose_ipv4_src(myip,
+						     conn_cb->ksnr_myiface,
+						     ntohl(sa->sin_addr.s_addr),
+						     ni->ni_net_ns);
 				*peer_ip = ntohl(sa->sin_addr.s_addr);
 				*port = ntohs(sa->sin_port);
 			} else {
@@ -364,8 +356,8 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index,
 				*port = 0;
 				rc = -ENOTSUPP;
 			}
-			*conn_count = route->ksnr_conn_count;
-			*share_count = route->ksnr_share_count;
+			*conn_count = conn_cb->ksnr_conn_count;
+			*share_count = 1;
 			goto out;
 		}
 	}
@@ -374,139 +366,191 @@ out:
 	return rc;
 }
 
+static unsigned int
+ksocknal_get_conn_count_by_type(struct ksock_conn_cb *conn_cb,
+				int type)
+{
+	unsigned int count = 0;
+
+	switch (type) {
+	case SOCKLND_CONN_CONTROL:
+		count = conn_cb->ksnr_ctrl_conn_count;
+		break;
+	case SOCKLND_CONN_BULK_IN:
+		count = conn_cb->ksnr_blki_conn_count;
+		break;
+	case SOCKLND_CONN_BULK_OUT:
+		count = conn_cb->ksnr_blko_conn_count;
+		break;
+	case SOCKLND_CONN_ANY:
+		count = conn_cb->ksnr_conn_count;
+		break;
+	default:
+		LBUG();
+		break;
+	}
+
+	return count;
+}
+
 static void
-ksocknal_associate_route_conn_locked(struct ksock_route *route,
-				     struct ksock_conn *conn)
+ksocknal_incr_conn_count(struct ksock_conn_cb *conn_cb,
+			 int type)
 {
-	struct ksock_peer_ni *peer_ni = route->ksnr_peer;
+	conn_cb->ksnr_conn_count++;
+
+	/* check if all connections of the given type got created */
+	switch (type) {
+	case SOCKLND_CONN_CONTROL:
+		conn_cb->ksnr_ctrl_conn_count++;
+		/* there's a single control connection per peer */
+		conn_cb->ksnr_connected |= BIT(type);
+		break;
+	case SOCKLND_CONN_BULK_IN:
+		conn_cb->ksnr_blki_conn_count++;
+		if (conn_cb->ksnr_blki_conn_count >=
+		    *ksocknal_tunables.ksnd_conns_per_peer)
+			conn_cb->ksnr_connected |= BIT(type);
+		break;
+	case SOCKLND_CONN_BULK_OUT:
+		conn_cb->ksnr_blko_conn_count++;
+		if (conn_cb->ksnr_blko_conn_count >=
+		    *ksocknal_tunables.ksnd_conns_per_peer)
+			conn_cb->ksnr_connected |= BIT(type);
+		break;
+	case SOCKLND_CONN_ANY:
+		if (conn_cb->ksnr_conn_count >=
+		    *ksocknal_tunables.ksnd_conns_per_peer)
+			conn_cb->ksnr_connected |= BIT(type);
+		break;
+	default:
+		LBUG();
+		break;
+
+	}
+
+	CDEBUG(D_NET, "Add conn type %d, ksnr_connected %x conns_per_peer %d\n",
+	       type, conn_cb->ksnr_connected, *ksocknal_tunables.ksnd_conns_per_peer);
+}
+
+static void
+ksocknal_associate_cb_conn_locked(struct ksock_conn_cb *conn_cb,
+				  struct ksock_conn *conn)
+{
+	struct ksock_peer_ni *peer_ni = conn_cb->ksnr_peer;
 	int type = conn->ksnc_type;
 	struct ksock_interface *iface;
-	int conn_iface =
-		ksocknal_ip2index((struct sockaddr *)&conn->ksnc_myaddr,
-				  route->ksnr_peer->ksnp_ni);
+	int conn_iface;
 
-	conn->ksnc_route = route;
-	ksocknal_route_addref(route);
+	conn_iface = ksocknal_ip2index((struct sockaddr *)&conn->ksnc_myaddr,
+				       peer_ni->ksnp_ni);
+	conn->ksnc_conn_cb = conn_cb;
+	ksocknal_conn_cb_addref(conn_cb);
 
-	if (route->ksnr_myiface != conn_iface) {
-		if (route->ksnr_myiface < 0) {
+	if (conn_cb->ksnr_myiface != conn_iface) {
+		if (conn_cb->ksnr_myiface < 0) {
 			/* route wasn't bound locally yet (the initial route) */
 			CDEBUG(D_NET, "Binding %s %pIS to interface %d\n",
 			       libcfs_id2str(peer_ni->ksnp_id),
-			       &route->ksnr_addr,
+			       &conn_cb->ksnr_addr,
 			       conn_iface);
 		} else {
 			CDEBUG(D_NET,
 			       "Rebinding %s %pIS from interface %d to %d\n",
 			       libcfs_id2str(peer_ni->ksnp_id),
-			       &route->ksnr_addr,
-			       route->ksnr_myiface,
+			       &conn_cb->ksnr_addr,
+			       conn_cb->ksnr_myiface,
 			       conn_iface);
 
-			iface = ksocknal_index2iface(route->ksnr_peer->ksnp_ni,
-						     route->ksnr_myiface);
+			iface = ksocknal_index2iface(peer_ni->ksnp_ni,
+						     conn_cb->ksnr_myiface);
 			if (iface)
 				iface->ksni_nroutes--;
 		}
-		route->ksnr_myiface = conn_iface;
-		iface = ksocknal_index2iface(route->ksnr_peer->ksnp_ni,
-					     route->ksnr_myiface);
+		conn_cb->ksnr_myiface = conn_iface;
+		iface = ksocknal_index2iface(peer_ni->ksnp_ni,
+					     conn_cb->ksnr_myiface);
 		if (iface)
 			iface->ksni_nroutes++;
 	}
 
-	route->ksnr_connected |= (1<<type);
-	route->ksnr_conn_count++;
+	ksocknal_incr_conn_count(conn_cb, type);
 
 	/* Successful connection => further attempts can
 	 * proceed immediately
 	 */
-	route->ksnr_retry_interval = 0;
+	conn_cb->ksnr_retry_interval = 0;
 }
 
 static void
-ksocknal_add_route_locked(struct ksock_peer_ni *peer_ni, struct ksock_route *route)
+ksocknal_add_conn_cb_locked(struct ksock_peer_ni *peer_ni,
+			    struct ksock_conn_cb *conn_cb)
 {
 	struct list_head *tmp;
 	struct ksock_conn *conn;
-	struct ksock_route *route2;
 	struct ksock_net *net = peer_ni->ksnp_ni->ni_data;
 
 	LASSERT(!peer_ni->ksnp_closing);
-	LASSERT(route->ksnr_peer == NULL);
-	LASSERT(!route->ksnr_scheduled);
-	LASSERT(!route->ksnr_connecting);
-	LASSERT(route->ksnr_connected == 0);
-	LASSERT(net->ksnn_ninterfaces > 0);
-
-	/* LASSERT(unique) */
-	list_for_each(tmp, &peer_ni->ksnp_routes) {
-		route2 = list_entry(tmp, struct ksock_route, ksnr_list);
-
-		if (rpc_cmp_addr((struct sockaddr *)&route2->ksnr_addr,
-				 (struct sockaddr *)&route->ksnr_addr)) {
-			CERROR("Duplicate route %s %pI4h\n",
-			       libcfs_id2str(peer_ni->ksnp_id),
-			       &route->ksnr_addr);
-			LBUG();
-		}
-	}
+	LASSERT(!conn_cb->ksnr_peer);
+	LASSERT(!conn_cb->ksnr_scheduled);
+	LASSERT(!conn_cb->ksnr_connecting);
+	LASSERT(conn_cb->ksnr_connected == 0);
 
-	route->ksnr_peer = peer_ni;
+	conn_cb->ksnr_peer = peer_ni;
 	ksocknal_peer_addref(peer_ni);
 
-	/* set the route's interface to the current net's interface */
-	route->ksnr_myiface = net->ksnn_interfaces[0].ksni_index;
-	net->ksnn_interfaces[0].ksni_nroutes++;
+	/* set the conn_cb's interface to the current net's interface */
+	conn_cb->ksnr_myiface = net->ksnn_interface.ksni_index;
+	net->ksnn_interface.ksni_nroutes++;
 
-	/* peer_ni's routelist takes over my ref on 'route' */
-	list_add_tail(&route->ksnr_list, &peer_ni->ksnp_routes);
+	/* peer_ni's route list takes over my ref on 'route' */
+	peer_ni->ksnp_conn_cb = conn_cb;
 
 	list_for_each(tmp, &peer_ni->ksnp_conns) {
 		conn = list_entry(tmp, struct ksock_conn, ksnc_list);
 
 		if (!rpc_cmp_addr((struct sockaddr *)&conn->ksnc_peeraddr,
-				  (struct sockaddr *)&route->ksnr_addr))
+				  (struct sockaddr *)&conn_cb->ksnr_addr))
 			continue;
 
-		ksocknal_associate_route_conn_locked(route, conn);
-		/* keep going (typed routes) */
+		ksocknal_associate_cb_conn_locked(conn_cb, conn);
+		/* keep going (typed conns) */
 	}
 }
 
 static void
-ksocknal_del_route_locked(struct ksock_route *route)
+ksocknal_del_conn_cb_locked(struct ksock_conn_cb *conn_cb)
 {
-	struct ksock_peer_ni *peer_ni = route->ksnr_peer;
+	struct ksock_peer_ni *peer_ni = conn_cb->ksnr_peer;
 	struct ksock_interface *iface;
 	struct ksock_conn *conn;
 	struct ksock_conn *cnxt;
 
-	LASSERT(!route->ksnr_deleted);
+	LASSERT(!conn_cb->ksnr_deleted);
 
 	/* Close associated conns */
 	list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns, ksnc_list) {
-		if (conn->ksnc_route != route)
+		if (conn->ksnc_conn_cb != conn_cb)
 			continue;
 
 		ksocknal_close_conn_locked(conn, 0);
 	}
 
-	if (route->ksnr_myiface >= 0) {
-		iface = ksocknal_index2iface(route->ksnr_peer->ksnp_ni,
-					     route->ksnr_myiface);
+	if (conn_cb->ksnr_myiface >= 0) {
+		iface = ksocknal_index2iface(peer_ni->ksnp_ni,
+					     conn_cb->ksnr_myiface);
 		if (iface)
 			iface->ksni_nroutes--;
 	}
 
-	route->ksnr_deleted = 1;
-	list_del(&route->ksnr_list);
-	ksocknal_route_decref(route);		/* drop peer_ni's ref */
+	conn_cb->ksnr_deleted = 1;
+	ksocknal_conn_cb_decref(conn_cb);		/* drop peer_ni's ref */
+	peer_ni->ksnp_conn_cb = NULL;
 
-	if (list_empty(&peer_ni->ksnp_routes) &&
-	    list_empty(&peer_ni->ksnp_conns)) {
+	if (list_empty(&peer_ni->ksnp_conns)) {
 		/* I've just removed the last route to a peer_ni with no active
-		 * connections */
+		 * connections
+		 */
 		ksocknal_unlink_peer_locked(peer_ni);
 	}
 }
@@ -515,11 +559,9 @@ int
 ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id,
 		  struct sockaddr *addr)
 {
-	struct list_head *tmp;
 	struct ksock_peer_ni *peer_ni;
 	struct ksock_peer_ni *peer2;
-	struct ksock_route *route;
-	struct ksock_route *route2;
+	struct ksock_conn_cb *conn_cb;
 
 	if (id.nid == LNET_NID_ANY ||
 	    id.pid == LNET_PID_ANY)
@@ -530,10 +572,10 @@ ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id,
 	if (IS_ERR(peer_ni))
 		return PTR_ERR(peer_ni);
 
-	route = ksocknal_create_route(addr);
-	if (route == NULL) {
+	conn_cb = ksocknal_create_conn_cb(addr);
+	if (!conn_cb) {
 		ksocknal_peer_decref(peer_ni);
-		return (-ENOMEM);
+		return -ENOMEM;
 	}
 
 	write_lock_bh(&ksocknal_data.ksnd_global_lock);
@@ -551,22 +593,7 @@ ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id,
 		hash_add(ksocknal_data.ksnd_peers, &peer_ni->ksnp_list, id.nid);
 	}
 
-	route2 = NULL;
-	list_for_each(tmp, &peer_ni->ksnp_routes) {
-		route2 = list_entry(tmp, struct ksock_route, ksnr_list);
-
-		if (rpc_cmp_addr(addr, (struct sockaddr *)&route2->ksnr_addr))
-			break;
-
-		route2 = NULL;
-	}
-	if (route2 == NULL) {
-		ksocknal_add_route_locked(peer_ni, route);
-		route->ksnr_share_count++;
-	} else {
-		ksocknal_route_decref(route);
-		route2->ksnr_share_count++;
-	}
+	ksocknal_add_conn_cb_locked(peer_ni, conn_cb);
 
 	write_unlock_bh(&ksocknal_data.ksnd_global_lock);
 
@@ -578,53 +605,22 @@ ksocknal_del_peer_locked(struct ksock_peer_ni *peer_ni, __u32 ip)
 {
 	struct ksock_conn *conn;
 	struct ksock_conn *cnxt;
-	struct ksock_route *route;
-	struct ksock_route *rnxt;
-	int nshared;
+	struct ksock_conn_cb *conn_cb;
 
 	LASSERT(!peer_ni->ksnp_closing);
 
 	/* Extra ref prevents peer_ni disappearing until I'm done with it */
 	ksocknal_peer_addref(peer_ni);
+	conn_cb = peer_ni->ksnp_conn_cb;
+	if (conn_cb)
+		ksocknal_del_conn_cb_locked(conn_cb);
 
-	list_for_each_entry_safe(route, rnxt, &peer_ni->ksnp_routes,
-				 ksnr_list) {
-		/* no match */
-		if (ip) {
-			if (route->ksnr_addr.ss_family != AF_INET)
-				continue;
-			if (((struct sockaddr_in *)&route->ksnr_addr)
-					->sin_addr.s_addr != htonl(ip))
-				continue;
-		}
-
-		route->ksnr_share_count = 0;
-		/* This deletes associated conns too */
-		ksocknal_del_route_locked(route);
-	}
-
-	nshared = 0;
-	list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list)
-		nshared += route->ksnr_share_count;
-
-	if (nshared == 0) {
-		/* remove everything else if there are no explicit entries
-		 * left
-		 */
-		list_for_each_entry_safe(route, rnxt, &peer_ni->ksnp_routes,
-					 ksnr_list) {
-			/* we should only be removing auto-entries */
-			LASSERT(route->ksnr_share_count == 0);
-			ksocknal_del_route_locked(route);
-		}
-
-		list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns,
-					 ksnc_list)
-			ksocknal_close_conn_locked(conn, 0);
-	}
+	list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns,
+				 ksnc_list)
+		ksocknal_close_conn_locked(conn, 0);
 
 	ksocknal_peer_decref(peer_ni);
-	/* NB peer_ni unlinks itself when last conn/route is removed */
+	/* NB peer_ni unlinks itself when last conn/conn_cb is removed */
 }
 
 static int
@@ -668,7 +664,7 @@ ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip)
 			if (peer_ni->ksnp_closing &&
 			    !list_empty(&peer_ni->ksnp_tx_queue)) {
 				LASSERT(list_empty(&peer_ni->ksnp_conns));
-				LASSERT(list_empty(&peer_ni->ksnp_routes));
+				LASSERT(peer_ni->ksnp_conn_cb == NULL);
 
 				list_splice_init(&peer_ni->ksnp_tx_queue,
 						 &zombies);
@@ -739,333 +735,6 @@ ksocknal_choose_scheduler_locked(unsigned int cpt)
 	return sched;
 }
 
-static int
-ksocknal_local_ipvec(struct lnet_ni *ni, __u32 *ipaddrs)
-{
-	struct ksock_net *net = ni->ni_data;
-	int i, j;
-	int nip;
-
-	read_lock(&ksocknal_data.ksnd_global_lock);
-
-	nip = net->ksnn_ninterfaces;
-	LASSERT(nip <= LNET_INTERFACES_NUM);
-
-	for (i = 0, j = 0; i < nip; i++)
-		if (net->ksnn_interfaces[i].ksni_addr.ss_family == AF_INET) {
-			struct sockaddr_in *sa =
-				(void *)&net->ksnn_interfaces[i].ksni_addr;
-
-			ipaddrs[j] = ntohl(sa->sin_addr.s_addr);
-			LASSERT(ipaddrs[j] != 0);
-			j += 1;
-		}
-	nip = j;
-
-	read_unlock(&ksocknal_data.ksnd_global_lock);
-	/*
-	 * Only offer interfaces for additional connections if I have
-	 * more than one.
-	 */
-	return nip < 2 ? 0 : nip;
-}
-
-static int
-ksocknal_match_peerip(struct ksock_interface *iface, __u32 *ips, int nips)
-{
-	int best_netmatch = 0;
-	int best_xor = 0;
-	int best = -1;
-	int this_xor;
-	int this_netmatch;
-	int i;
-	struct sockaddr_in *sa;
-	__u32 ip;
-
-	sa = (struct sockaddr_in *)&iface->ksni_addr;
-	LASSERT(sa->sin_family == AF_INET);
-	ip = ntohl(sa->sin_addr.s_addr);
-
-	for (i = 0; i < nips; i++) {
-		if (ips[i] == 0)
-			continue;
-
-		this_xor = ips[i] ^ ip;
-		this_netmatch = ((this_xor & iface->ksni_netmask) == 0) ? 1 : 0;
-
-		if (!(best < 0 ||
-		      best_netmatch < this_netmatch ||
-		      (best_netmatch == this_netmatch &&
-		       best_xor > this_xor)))
-			continue;
-
-		best = i;
-		best_netmatch = this_netmatch;
-		best_xor = this_xor;
-	}
-
-	LASSERT(best >= 0);
-	return best;
-}
-
-static int
-ksocknal_select_ips(struct ksock_peer_ni *peer_ni, __u32 *peerips, int n_peerips)
-{
-	rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
-	struct ksock_net *net = peer_ni->ksnp_ni->ni_data;
-	struct ksock_interface *iface;
-	struct ksock_interface *best_iface;
-	int n_ips;
-	int i;
-	int j;
-	int k;
-	u32 ip;
-	u32 xor;
-	int this_netmatch;
-	int best_netmatch;
-	int best_npeers;
-
-        /* CAVEAT EMPTOR: We do all our interface matching with an
-         * exclusive hold of global lock at IRQ priority.  We're only
-         * expecting to be dealing with small numbers of interfaces, so the
-         * O(n**3)-ness shouldn't matter */
-
-        /* Also note that I'm not going to return more than n_peerips
-         * interfaces, even if I have more myself */
-
-	write_lock_bh(global_lock);
-
-	LASSERT(n_peerips <= LNET_INTERFACES_NUM);
-	LASSERT(net->ksnn_ninterfaces <= LNET_INTERFACES_NUM);
-
-	/* Only match interfaces for additional connections
-	 * if I have > 1 interface
-	 */
-	n_ips = (net->ksnn_ninterfaces < 2) ? 0 :
-		min(n_peerips, net->ksnn_ninterfaces);
-
-        for (i = 0; peer_ni->ksnp_n_passive_ips < n_ips; i++) {
-                /*              ^ yes really... */
-
-                /* If we have any new interfaces, first tick off all the
-                 * peer_ni IPs that match old interfaces, then choose new
-                 * interfaces to match the remaining peer_ni IPS.
-                 * We don't forget interfaces we've stopped using; we might
-                 * start using them again... */
-
-		if (i < peer_ni->ksnp_n_passive_ips) {
-			/* Old interface. */
-			struct sockaddr_in sa = { .sin_family = AF_INET};
-
-			sa.sin_addr.s_addr =
-				htonl(peer_ni->ksnp_passive_ips[i]);
-			best_iface = ksocknal_ip2iface(peer_ni->ksnp_ni,
-						       (struct sockaddr *)&sa);
-
-			/* peer_ni passive ips are kept up to date */
-			LASSERT(best_iface != NULL);
-                } else {
-                        /* choose a new interface */
-			struct sockaddr_in *sa;
-
-                        LASSERT (i == peer_ni->ksnp_n_passive_ips);
-
-                        best_iface = NULL;
-                        best_netmatch = 0;
-                        best_npeers = 0;
-
-			for (j = 0; j < net->ksnn_ninterfaces; j++) {
-				iface = &net->ksnn_interfaces[j];
-				sa = (void *)&iface->ksni_addr;
-				if (sa->sin_family != AF_INET)
-					continue;
-				ip = ntohl(sa->sin_addr.s_addr);
-
-                                for (k = 0; k < peer_ni->ksnp_n_passive_ips; k++)
-                                        if (peer_ni->ksnp_passive_ips[k] == ip)
-                                                break;
-
-                                if (k < peer_ni->ksnp_n_passive_ips) /* using it already */
-                                        continue;
-
-                                k = ksocknal_match_peerip(iface, peerips, n_peerips);
-                                xor = (ip ^ peerips[k]);
-                                this_netmatch = ((xor & iface->ksni_netmask) == 0) ? 1 : 0;
-
-                                if (!(best_iface == NULL ||
-                                      best_netmatch < this_netmatch ||
-                                      (best_netmatch == this_netmatch &&
-                                       best_npeers > iface->ksni_npeers)))
-                                        continue;
-
-                                best_iface = iface;
-                                best_netmatch = this_netmatch;
-                                best_npeers = iface->ksni_npeers;
-                        }
-
-			LASSERT(best_iface != NULL);
-
-			best_iface->ksni_npeers++;
-			sa = (void *)&best_iface->ksni_addr;
-			ip = ntohl(sa->sin_addr.s_addr);
-			peer_ni->ksnp_passive_ips[i] = ip;
-			peer_ni->ksnp_n_passive_ips = i+1;
-                }
-
-                /* mark the best matching peer_ni IP used */
-                j = ksocknal_match_peerip(best_iface, peerips, n_peerips);
-                peerips[j] = 0;
-        }
-
-        /* Overwrite input peer_ni IP addresses */
-        memcpy(peerips, peer_ni->ksnp_passive_ips, n_ips * sizeof(*peerips));
-
-	write_unlock_bh(global_lock);
-
-        return (n_ips);
-}
-
-static void
-ksocknal_create_routes(struct ksock_peer_ni *peer_ni, int port,
-                       __u32 *peer_ipaddrs, int npeer_ipaddrs)
-{
-	struct ksock_route	*newroute = NULL;
-	rwlock_t		*global_lock = &ksocknal_data.ksnd_global_lock;
-	struct lnet_ni *ni = peer_ni->ksnp_ni;
-	struct ksock_net		*net = ni->ni_data;
-	struct list_head	*rtmp;
-	struct ksock_route		*route;
-	struct ksock_interface	*iface;
-	struct ksock_interface	*best_iface;
-	int			best_netmatch;
-	int			this_netmatch;
-	int			best_nroutes;
-	int			i;
-	int			j;
-
-        /* CAVEAT EMPTOR: We do all our interface matching with an
-         * exclusive hold of global lock at IRQ priority.  We're only
-         * expecting to be dealing with small numbers of interfaces, so the
-         * O(n**3)-ness here shouldn't matter */
-
-	write_lock_bh(global_lock);
-
-        if (net->ksnn_ninterfaces < 2) {
-		/* Only create additional connections
-                 * if I have > 1 interface */
-		write_unlock_bh(global_lock);
-                return;
-        }
-
-	LASSERT(npeer_ipaddrs <= LNET_INTERFACES_NUM);
-
-	for (i = 0; i < npeer_ipaddrs; i++) {
-		if (newroute) {
-			struct sockaddr_in *sa = (void *)&newroute->ksnr_addr;
-
-			memset(sa, 0, sizeof(*sa));
-			sa->sin_family = AF_INET;
-			sa->sin_addr.s_addr = htonl(peer_ipaddrs[i]);
-		} else {
-			struct sockaddr_in sa = {.sin_family = AF_INET};
-
-			write_unlock_bh(global_lock);
-
-			sa.sin_addr.s_addr = htonl(peer_ipaddrs[i]);
-			sa.sin_port = htons(port);
-			newroute =
-				ksocknal_create_route((struct sockaddr *)&sa);
-			if (!newroute)
-				return;
-
-			write_lock_bh(global_lock);
-		}
-
-		if (peer_ni->ksnp_closing) {
-			/* peer_ni got closed under me */
-			break;
-		}
-
-		/* Already got a route? */
-		route = NULL;
-		list_for_each(rtmp, &peer_ni->ksnp_routes) {
-			route = list_entry(rtmp, struct ksock_route, ksnr_list);
-
-			if (rpc_cmp_addr(
-				    (struct sockaddr *)&route->ksnr_addr,
-				    (struct sockaddr *)&newroute->ksnr_addr))
-				break;
-
-			route = NULL;
-		}
-		if (route != NULL)
-			continue;
-
-		best_iface = NULL;
-		best_nroutes = 0;
-		best_netmatch = 0;
-
-		LASSERT(net->ksnn_ninterfaces <= LNET_INTERFACES_NUM);
-
-		/* Select interface to connect from */
-		for (j = 0; j < net->ksnn_ninterfaces; j++) {
-			__u32 iface_ip, route_ip;
-
-			iface = &net->ksnn_interfaces[j];
-
-			/* Using this interface already? */
-			list_for_each(rtmp, &peer_ni->ksnp_routes) {
-				route = list_entry(rtmp, struct ksock_route,
-						   ksnr_list);
-
-				if (route->ksnr_myiface == iface->ksni_index)
-					break;
-
-				route = NULL;
-			}
-			if (route != NULL)
-				continue;
-			if (iface->ksni_addr.ss_family != AF_INET)
-				continue;
-			if (newroute->ksnr_addr.ss_family != AF_INET)
-				continue;
-
-			iface_ip =
-				ntohl(((struct sockaddr_in *)
-				       &iface->ksni_addr)->sin_addr.s_addr);
-			route_ip =
-				ntohl(((struct sockaddr_in *)
-				       &newroute->ksnr_addr)->sin_addr.s_addr);
-
-			this_netmatch = (((iface_ip ^ route_ip) &
-					  iface->ksni_netmask) == 0) ? 1 : 0;
-
-			if (!(best_iface == NULL ||
-			      best_netmatch < this_netmatch ||
-			      (best_netmatch == this_netmatch &&
-			       best_nroutes > iface->ksni_nroutes)))
-				continue;
-
-			best_iface = iface;
-			best_netmatch = this_netmatch;
-			best_nroutes = iface->ksni_nroutes;
-		}
-
-		if (best_iface == NULL)
-			continue;
-
-		newroute->ksnr_myiface = best_iface->ksni_index;
-		best_iface->ksni_nroutes++;
-
-		ksocknal_add_route_locked(peer_ni, newroute);
-		newroute = NULL;
-	}
-
-	write_unlock_bh(global_lock);
-	if (newroute != NULL)
-		ksocknal_route_decref(newroute);
-}
-
 int
 ksocknal_accept(struct lnet_ni *ni, struct socket *sock)
 {
@@ -1098,19 +767,16 @@ ksocknal_accept(struct lnet_ni *ni, struct socket *sock)
 }
 
 static int
-ksocknal_connecting(struct ksock_peer_ni *peer_ni, struct sockaddr *sa)
+ksocknal_connecting(struct ksock_conn_cb *conn_cb, struct sockaddr *sa)
 {
-	struct ksock_route *route;
-
-	list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) {
-		if (rpc_cmp_addr((struct sockaddr *)&route->ksnr_addr, sa))
-			return route->ksnr_connecting;
-	}
+	if (conn_cb &&
+	    rpc_cmp_addr((struct sockaddr *)&conn_cb->ksnr_addr, sa))
+		return conn_cb->ksnr_connecting;
 	return 0;
 }
 
 int
-ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
+ksocknal_create_conn(struct lnet_ni *ni, struct ksock_conn_cb *conn_cb,
 		     struct socket *sock, int type)
 {
 	rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
@@ -1130,21 +796,22 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 	int rc;
 	int rc2;
 	int active;
+	int num_dup = 0;
 	char *warn = NULL;
 
-        active = (route != NULL);
+	active = (conn_cb != NULL);
 
-        LASSERT (active == (type != SOCKLND_CONN_NONE));
+	LASSERT(active == (type != SOCKLND_CONN_NONE));
 
-        LIBCFS_ALLOC(conn, sizeof(*conn));
-        if (conn == NULL) {
-                rc = -ENOMEM;
-                goto failed_0;
-        }
+	LIBCFS_ALLOC(conn, sizeof(*conn));
+	if (conn == NULL) {
+		rc = -ENOMEM;
+		goto failed_0;
+	}
 
-        conn->ksnc_peer = NULL;
-        conn->ksnc_route = NULL;
-        conn->ksnc_sock = sock;
+	conn->ksnc_peer = NULL;
+	conn->ksnc_conn_cb = NULL;
+	conn->ksnc_sock = sock;
 	/* 2 ref, 1 for conn, another extra ref prevents socket
 	 * being closed before establishment of connection */
 	refcount_set(&conn->ksnc_sock_refcount, 2);
@@ -1163,61 +830,62 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 
 	LIBCFS_ALLOC(hello, offsetof(struct ksock_hello_msg,
 				     kshm_ips[LNET_INTERFACES_NUM]));
-        if (hello == NULL) {
-                rc = -ENOMEM;
-                goto failed_1;
-        }
+	if (hello == NULL) {
+		rc = -ENOMEM;
+		goto failed_1;
+	}
 
-        /* stash conn's local and remote addrs */
-        rc = ksocknal_lib_get_conn_addrs (conn);
-        if (rc != 0)
-                goto failed_1;
+	/* stash conn's local and remote addrs */
+	rc = ksocknal_lib_get_conn_addrs(conn);
+	if (rc != 0)
+		goto failed_1;
 
-        /* Find out/confirm peer_ni's NID and connection type and get the
-         * vector of interfaces she's willing to let me connect to.
-         * Passive connections use the listener timeout since the peer_ni sends
-         * eagerly */
+	/* Find out/confirm peer_ni's NID and connection type and get the
+	 * vector of interfaces she's willing to let me connect to.
+	 * Passive connections use the listener timeout since the peer_ni sends
+	 * eagerly
+	 */
 
-        if (active) {
-                peer_ni = route->ksnr_peer;
-                LASSERT(ni == peer_ni->ksnp_ni);
+	if (active) {
+		peer_ni = conn_cb->ksnr_peer;
+		LASSERT(ni == peer_ni->ksnp_ni);
 
-                /* Active connection sends HELLO eagerly */
-                hello->kshm_nips = ksocknal_local_ipvec(ni, hello->kshm_ips);
-                peerid = peer_ni->ksnp_id;
+		/* Active connection sends HELLO eagerly */
+		hello->kshm_nips = 0;
+		peerid = peer_ni->ksnp_id;
 
 		write_lock_bh(global_lock);
-                conn->ksnc_proto = peer_ni->ksnp_proto;
+		conn->ksnc_proto = peer_ni->ksnp_proto;
 		write_unlock_bh(global_lock);
 
-                if (conn->ksnc_proto == NULL) {
-                         conn->ksnc_proto = &ksocknal_protocol_v3x;
+		if (conn->ksnc_proto == NULL) {
+			conn->ksnc_proto = &ksocknal_protocol_v3x;
 #if SOCKNAL_VERSION_DEBUG
-                         if (*ksocknal_tunables.ksnd_protocol == 2)
-                                 conn->ksnc_proto = &ksocknal_protocol_v2x;
-                         else if (*ksocknal_tunables.ksnd_protocol == 1)
-                                 conn->ksnc_proto = &ksocknal_protocol_v1x;
+			if (*ksocknal_tunables.ksnd_protocol == 2)
+				conn->ksnc_proto = &ksocknal_protocol_v2x;
+			else if (*ksocknal_tunables.ksnd_protocol == 1)
+				conn->ksnc_proto = &ksocknal_protocol_v1x;
 #endif
-                }
+		}
 
-                rc = ksocknal_send_hello (ni, conn, peerid.nid, hello);
-                if (rc != 0)
-                        goto failed_1;
-        } else {
-                peerid.nid = LNET_NID_ANY;
-                peerid.pid = LNET_PID_ANY;
+		rc = ksocknal_send_hello(ni, conn, peerid.nid, hello);
+		if (rc != 0)
+			goto failed_1;
+	} else {
+		peerid.nid = LNET_NID_ANY;
+		peerid.pid = LNET_PID_ANY;
 
-                /* Passive, get protocol from peer_ni */
-                conn->ksnc_proto = NULL;
-        }
+		/* Passive, get protocol from peer_ni */
+		conn->ksnc_proto = NULL;
+	}
 
-        rc = ksocknal_recv_hello (ni, conn, hello, &peerid, &incarnation);
-        if (rc < 0)
-                goto failed_1;
+	rc = ksocknal_recv_hello(ni, conn, hello, &peerid, &incarnation);
+	if (rc < 0)
+		goto failed_1;
 
-        LASSERT (rc == 0 || active);
-        LASSERT (conn->ksnc_proto != NULL);
-        LASSERT (peerid.nid != LNET_NID_ANY);
+	LASSERT(rc == 0 || active);
+	LASSERT(conn->ksnc_proto != NULL);
+	LASSERT(peerid.nid != LNET_NID_ANY);
 
 	cpt = lnet_cpt_of_nid(peerid.nid, ni);
 
@@ -1247,28 +915,28 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 			peer_ni = peer2;
 		}
 
-                /* +1 ref for me */
-                ksocknal_peer_addref(peer_ni);
-                peer_ni->ksnp_accepting++;
+		/* +1 ref for me */
+		ksocknal_peer_addref(peer_ni);
+		peer_ni->ksnp_accepting++;
 
 		/* Am I already connecting to this guy?  Resolve in
 		 * favour of higher NID...
 		 */
 		if (peerid.nid < ni->ni_nid &&
-		    ksocknal_connecting(peer_ni, ((struct sockaddr *)
-						  &conn->ksnc_peeraddr))) {
+		    ksocknal_connecting(peer_ni->ksnp_conn_cb,
+					((struct sockaddr *) &conn->ksnc_peeraddr))) {
 			rc = EALREADY;
 			warn = "connection race resolution";
 			goto failed_2;
 		}
-        }
+	}
 
-        if (peer_ni->ksnp_closing ||
-            (active && route->ksnr_deleted)) {
-                /* peer_ni/route got closed under me */
-                rc = -ESTALE;
-                warn = "peer_ni/route removed";
-                goto failed_2;
+	if (peer_ni->ksnp_closing ||
+	    (active && conn_cb->ksnr_deleted)) {
+		/* peer_ni/conn_cb got closed under me */
+		rc = -ESTALE;
+		warn = "peer_ni/conn_cb removed";
+		goto failed_2;
         }
 
 	if (peer_ni->ksnp_proto == NULL) {
@@ -1295,18 +963,18 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 		goto failed_2;
 	}
 
-        switch (rc) {
-        default:
-                LBUG();
-        case 0:
-                break;
-        case EALREADY:
-                warn = "lost conn race";
-                goto failed_2;
-        case EPROTO:
-                warn = "retry with different protocol version";
-                goto failed_2;
-        }
+	switch (rc) {
+	default:
+		LBUG();
+	case 0:
+		break;
+	case EALREADY:
+		warn = "lost conn race";
+		goto failed_2;
+	case EPROTO:
+		warn = "retry with different protocol version";
+		goto failed_2;
+	}
 
 	/* Refuse to duplicate an existing connection, unless this is a
 	 * loopback connection */
@@ -1324,43 +992,44 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 			    conn2->ksnc_type != conn->ksnc_type)
 				continue;
 
-                        /* Reply on a passive connection attempt so the peer_ni
-                         * realises we're connected. */
-                        LASSERT (rc == 0);
-                        if (!active)
-                                rc = EALREADY;
+			num_dup++;
+			if (num_dup < *ksocknal_tunables.ksnd_conns_per_peer)
+				continue;
 
-                        warn = "duplicate";
-                        goto failed_2;
-                }
-        }
+			/* Reply on a passive connection attempt so the peer_ni
+			 * realises we're connected.
+			 */
+			LASSERT(rc == 0);
+			if (!active)
+				rc = EALREADY;
 
-        /* If the connection created by this route didn't bind to the IP
-         * address the route connected to, the connection/route matching
-         * code below probably isn't going to work. */
-        if (active &&
-	    !rpc_cmp_addr((struct sockaddr *)&route->ksnr_addr,
+			warn = "duplicate";
+			goto failed_2;
+		}
+	}
+	/* If the connection created by this route didn't bind to the IP
+	 * address the route connected to, the connection/route matching
+	 * code below probably isn't going to work.
+	 */
+	if (active &&
+	    !rpc_cmp_addr((struct sockaddr *)&conn_cb->ksnr_addr,
 			  (struct sockaddr *)&conn->ksnc_peeraddr)) {
 		CERROR("Route %s %pIS connected to %pIS\n",
 		       libcfs_id2str(peer_ni->ksnp_id),
-		       &route->ksnr_addr,
+		       &conn_cb->ksnr_addr,
 		       &conn->ksnc_peeraddr);
-        }
+	}
 
-	/* Search for a route corresponding to the new connection and
+	/* Search for a conn_cb corresponding to the new connection and
 	 * create an association.  This allows incoming connections created
-	 * by routes in my peer_ni to match my own route entries so I don't
-	 * continually create duplicate routes. */
-	list_for_each(tmp, &peer_ni->ksnp_routes) {
-		route = list_entry(tmp, struct ksock_route, ksnr_list);
+	 * by conn_cbs in my peer_ni to match my own conn_cb entries so I don't
+	 * continually create duplicate conn_cbs.
+	 */
+	conn_cb = peer_ni->ksnp_conn_cb;
 
-		if (!rpc_cmp_addr((struct sockaddr *)&route->ksnr_addr,
-				  (struct sockaddr *)&conn->ksnc_peeraddr))
-			continue;
-
-		ksocknal_associate_route_conn_locked(route, conn);
-		break;
-	}
+	if (conn_cb && rpc_cmp_addr((struct sockaddr *)&conn->ksnc_peeraddr,
+				    (struct sockaddr *)&conn_cb->ksnr_addr))
+		ksocknal_associate_cb_conn_locked(conn_cb, conn);
 
 	conn->ksnc_peer = peer_ni;                 /* conn takes my ref on peer_ni */
 	peer_ni->ksnp_last_alive = ktime_get_seconds();
@@ -1377,8 +1046,8 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 	 * native scheduler. So use the scheduler's cpt instead.
 	 */
 	cpt = sched->kss_cpt;
-        sched->kss_nconns++;
-        conn->ksnc_scheduler = sched;
+	sched->kss_nconns++;
+	conn->ksnc_scheduler = sched;
 
 	conn->ksnc_tx_last_post = ktime_get_seconds();
 	/* Set the deadline for the outgoing HELLO to drain */
@@ -1392,7 +1061,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 
 	ksocknal_new_packet(conn, 0);
 
-        conn->ksnc_zc_capable = ksocknal_lib_zc_capable(conn);
+	conn->ksnc_zc_capable = ksocknal_lib_zc_capable(conn);
 
 	/* Take packets blocking for this connection. */
 	list_for_each_entry_safe(tx, txtmp, &peer_ni->ksnp_tx_queue, tx_list) {
@@ -1406,13 +1075,13 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 
 	write_unlock_bh(global_lock);
 
-        /* We've now got a new connection.  Any errors from here on are just
-         * like "normal" comms errors and we close the connection normally.
-         * NB (a) we still have to send the reply HELLO for passive
+	/* We've now got a new connection.  Any errors from here on are just
+	 * like "normal" comms errors and we close the connection normally.
+	 * NB (a) we still have to send the reply HELLO for passive
 	 *        connections,
-         *    (b) normal I/O on the conn is blocked until I setup and call the
-         *        socket callbacks.
-         */
+	 *    (b) normal I/O on the conn is blocked until I setup and call the
+	 *        socket callbacks.
+	 */
 
 	CDEBUG(D_NET, "New conn %s p %d.x %pIS -> %pISp"
 	       " incarnation:%lld sched[%d]\n",
@@ -1420,89 +1089,85 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route,
 	       &conn->ksnc_myaddr, &conn->ksnc_peeraddr,
 	       incarnation, cpt);
 
-	if (active) {
-		/* additional routes after interface exchange? */
-		ksocknal_create_routes(
-			peer_ni,
-			rpc_get_port((struct sockaddr *)&conn->ksnc_peeraddr),
-			hello->kshm_ips, hello->kshm_nips);
-        } else {
-                hello->kshm_nips = ksocknal_select_ips(peer_ni, hello->kshm_ips,
-                                                       hello->kshm_nips);
-                rc = ksocknal_send_hello(ni, conn, peerid.nid, hello);
-        }
+	if (!active) {
+		hello->kshm_nips = 0;
+		rc = ksocknal_send_hello(ni, conn, peerid.nid, hello);
+	}
 
 	LIBCFS_FREE(hello, offsetof(struct ksock_hello_msg,
 				    kshm_ips[LNET_INTERFACES_NUM]));
 
-        /* setup the socket AFTER I've received hello (it disables
-         * SO_LINGER).  I might call back to the acceptor who may want
-         * to send a protocol version response and then close the
-         * socket; this ensures the socket only tears down after the
-         * response has been sent. */
-        if (rc == 0)
-                rc = ksocknal_lib_setup_sock(sock);
+	/* setup the socket AFTER I've received hello (it disables
+	 * SO_LINGER).  I might call back to the acceptor who may want
+	 * to send a protocol version response and then close the
+	 * socket; this ensures the socket only tears down after the
+	 * response has been sent.
+	 */
+	if (rc == 0)
+		rc = ksocknal_lib_setup_sock(sock);
 
 	write_lock_bh(global_lock);
 
-        /* NB my callbacks block while I hold ksnd_global_lock */
-        ksocknal_lib_set_callback(sock, conn);
+	/* NB my callbacks block while I hold ksnd_global_lock */
+	ksocknal_lib_set_callback(sock, conn);
 
-        if (!active)
-                peer_ni->ksnp_accepting--;
+	if (!active)
+		peer_ni->ksnp_accepting--;
 
 	write_unlock_bh(global_lock);
 
-        if (rc != 0) {
+	if (rc != 0) {
 		write_lock_bh(global_lock);
-                if (!conn->ksnc_closing) {
-                        /* could be closed by another thread */
-                        ksocknal_close_conn_locked(conn, rc);
-                }
+		if (!conn->ksnc_closing) {
+			/* could be closed by another thread */
+			ksocknal_close_conn_locked(conn, rc);
+		}
 		write_unlock_bh(global_lock);
-        } else if (ksocknal_connsock_addref(conn) == 0) {
-                /* Allow I/O to proceed. */
-                ksocknal_read_callback(conn);
-                ksocknal_write_callback(conn);
-                ksocknal_connsock_decref(conn);
-        }
+	} else if (ksocknal_connsock_addref(conn) == 0) {
+		/* Allow I/O to proceed. */
+		ksocknal_read_callback(conn);
+		ksocknal_write_callback(conn);
+		ksocknal_connsock_decref(conn);
+	}
 
-        ksocknal_connsock_decref(conn);
-        ksocknal_conn_decref(conn);
-        return rc;
+	ksocknal_connsock_decref(conn);
+	ksocknal_conn_decref(conn);
+	return rc;
 
 failed_2:
+
 	if (!peer_ni->ksnp_closing &&
 	    list_empty(&peer_ni->ksnp_conns) &&
-	    list_empty(&peer_ni->ksnp_routes)) {
+	    peer_ni->ksnp_conn_cb == NULL) {
 		list_splice_init(&peer_ni->ksnp_tx_queue, &zombies);
 		ksocknal_unlink_peer_locked(peer_ni);
 	}
 
 	write_unlock_bh(global_lock);
 
-        if (warn != NULL) {
-                if (rc < 0)
-                        CERROR("Not creating conn %s type %d: %s\n",
-                               libcfs_id2str(peerid), conn->ksnc_type, warn);
-                else
-                        CDEBUG(D_NET, "Not creating conn %s type %d: %s\n",
-                              libcfs_id2str(peerid), conn->ksnc_type, warn);
-        }
+	if (warn != NULL) {
+		if (rc < 0)
+			CERROR("Not creating conn %s type %d: %s\n",
+			       libcfs_id2str(peerid), conn->ksnc_type, warn);
+		else
+			CDEBUG(D_NET, "Not creating conn %s type %d: %s\n",
+			       libcfs_id2str(peerid), conn->ksnc_type, warn);
+	}
 
-        if (!active) {
-                if (rc > 0) {
+	if (!active) {
+		if (rc > 0) {
 			/* Request retry by replying with CONN_NONE
-                         * ksnc_proto has been set already */
-                        conn->ksnc_type = SOCKLND_CONN_NONE;
-                        hello->kshm_nips = 0;
-                        ksocknal_send_hello(ni, conn, peerid.nid, hello);
-                }
+			 * ksnc_proto has been set already
+			 */
+			conn->ksnc_type = SOCKLND_CONN_NONE;
+			hello->kshm_nips = 0;
+			ksocknal_send_hello(ni, conn, peerid.nid, hello);
+		}
 
 		write_lock_bh(global_lock);
-                peer_ni->ksnp_accepting--;
+		peer_ni->ksnp_accepting--;
 		write_unlock_bh(global_lock);
-        }
+	}
 
 	/*
 	 * If we get here without an error code, just use -EALREADY.
@@ -1511,7 +1176,7 @@ failed_2:
 	 */
 	rc2 = (rc == 0 ? -EALREADY : (rc > 0 ? -rc : rc));
 	ksocknal_txlist_done(ni, &zombies, rc2);
-        ksocknal_peer_decref(peer_ni);
+	ksocknal_peer_decref(peer_ni);
 
 failed_1:
 	if (hello != NULL)
@@ -1522,6 +1187,7 @@ failed_1:
 
 failed_0:
 	sock_release(sock);
+
 	return rc;
 }
 
@@ -1532,7 +1198,7 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error)
          * connection for the reaper to terminate.
          * Caller holds ksnd_global_lock exclusively in irq context */
 	struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
-	struct ksock_route *route;
+	struct ksock_conn_cb *conn_cb;
 	struct ksock_conn *conn2;
 	struct list_head *tmp;
 
@@ -1543,28 +1209,36 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error)
 	/* ksnd_deathrow_conns takes over peer_ni's ref */
 	list_del(&conn->ksnc_list);
 
-	route = conn->ksnc_route;
-	if (route != NULL) {
-		/* dissociate conn from route... */
-		LASSERT(!route->ksnr_deleted);
-		LASSERT((route->ksnr_connected & BIT(conn->ksnc_type)) != 0);
+	conn_cb = conn->ksnc_conn_cb;
+	if (conn_cb != NULL) {
+		/* dissociate conn from cb... */
+		LASSERT(!conn_cb->ksnr_deleted);
+
+		/* connected bit is set only if all connections
+		 * of the given type got created
+		 */
+		if (ksocknal_get_conn_count_by_type(conn_cb, conn->ksnc_type) ==
+		    *ksocknal_tunables.ksnd_conns_per_peer)
+			LASSERT((conn_cb->ksnr_connected &
+				BIT(conn->ksnc_type)) != 0);
 
 		conn2 = NULL;
 		list_for_each(tmp, &peer_ni->ksnp_conns) {
 			conn2 = list_entry(tmp, struct ksock_conn, ksnc_list);
 
-			if (conn2->ksnc_route == route &&
+			if (conn2->ksnc_conn_cb == conn_cb &&
 			    conn2->ksnc_type == conn->ksnc_type)
 				break;
 
 			conn2 = NULL;
 		}
 		if (conn2 == NULL)
-			route->ksnr_connected &= ~BIT(conn->ksnc_type);
+			conn_cb->ksnr_connected &= ~BIT(conn->ksnc_type);
 
-		conn->ksnc_route = NULL;
+		conn->ksnc_conn_cb = NULL;
 
-		ksocknal_route_decref(route);	/* drop conn's ref on route */
+		/* drop conn's ref on conn_cb */
+		ksocknal_conn_cb_decref(conn_cb);
 	}
 
 	if (list_empty(&peer_ni->ksnp_conns)) {
@@ -1592,9 +1266,10 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error)
 		/* stash last conn close reason */
 		peer_ni->ksnp_error = error;
 
-		if (list_empty(&peer_ni->ksnp_routes)) {
+		if (peer_ni->ksnp_conn_cb == NULL) {
 			/* I've just closed last conn belonging to a
-			 * peer_ni with no routes to it */
+			 * peer_ni with no connections to it
+			 */
 			ksocknal_unlink_peer_locked(peer_ni);
 		}
 	}
@@ -1622,7 +1297,7 @@ ksocknal_peer_failed(struct ksock_peer_ni *peer_ni)
 	if ((peer_ni->ksnp_id.pid & LNET_PID_USERFLAG) == 0 &&
 	     list_empty(&peer_ni->ksnp_conns) &&
 	     peer_ni->ksnp_accepting == 0 &&
-	     ksocknal_find_connecting_route_locked(peer_ni) == NULL) {
+	     !ksocknal_find_connecting_conn_cb_locked(peer_ni)) {
 		notify = true;
 		last_alive = peer_ni->ksnp_last_alive;
 	}
@@ -1697,7 +1372,7 @@ ksocknal_terminate_conn(struct ksock_conn *conn)
 		/* extra ref for scheduler */
 		ksocknal_conn_addref(conn);
 
-		wake_up (&sched->kss_waitq);
+		wake_up(&sched->kss_waitq);
 	}
 
 	spin_unlock_bh(&sched->kss_lock);
@@ -1752,14 +1427,14 @@ ksocknal_destroy_conn(struct ksock_conn *conn)
 	time64_t last_rcv;
 
 	/* Final coup-de-grace of the reaper */
-	CDEBUG (D_NET, "connection %p\n", conn);
+	CDEBUG(D_NET, "connection %p\n", conn);
 
 	LASSERT(refcount_read(&conn->ksnc_conn_refcount) == 0);
 	LASSERT(refcount_read(&conn->ksnc_sock_refcount) == 0);
-	LASSERT (conn->ksnc_sock == NULL);
-	LASSERT (conn->ksnc_route == NULL);
-	LASSERT (!conn->ksnc_tx_scheduled);
-	LASSERT (!conn->ksnc_rx_scheduled);
+	LASSERT(conn->ksnc_sock == NULL);
+	LASSERT(conn->ksnc_conn_cb == NULL);
+	LASSERT(!conn->ksnc_tx_scheduled);
+	LASSERT(!conn->ksnc_rx_scheduled);
 	LASSERT(list_empty(&conn->ksnc_tx_queue));
 
         /* complete current receive if any */
@@ -1996,181 +1671,26 @@ ksocknal_push(struct lnet_ni *ni, struct lnet_process_id id)
 	return rc;
 }
 
-static int
-ksocknal_add_interface(struct lnet_ni *ni, __u32 ipaddress, __u32 netmask)
-{
-	struct ksock_net *net = ni->ni_data;
-	struct ksock_interface *iface;
-	struct sockaddr_in sa = { .sin_family = AF_INET };
-	int rc;
-	int i;
-	int j;
-	struct ksock_peer_ni *peer_ni;
-	struct list_head *rtmp;
-	struct ksock_route *route;
-
-	if (ipaddress == 0 ||
-	    netmask == 0)
-		return -EINVAL;
-
-	write_lock_bh(&ksocknal_data.ksnd_global_lock);
-
-	sa.sin_addr.s_addr = htonl(ipaddress);
-	iface = ksocknal_ip2iface(ni, (struct sockaddr *)&sa);
-	if (iface != NULL) {
-		/* silently ignore dups */
-		rc = 0;
-	} else if (net->ksnn_ninterfaces == LNET_INTERFACES_NUM) {
-		rc = -ENOSPC;
-	} else {
-		iface = &net->ksnn_interfaces[net->ksnn_ninterfaces++];
-
-		iface->ksni_index = ksocknal_ip2index((struct sockaddr *)&sa,
-						      ni);
-		rpc_copy_addr((struct sockaddr *)&iface->ksni_addr,
-			      (struct sockaddr *)&sa);
-		iface->ksni_netmask = netmask;
-		iface->ksni_nroutes = 0;
-		iface->ksni_npeers = 0;
-
-		hash_for_each(ksocknal_data.ksnd_peers, i, peer_ni, ksnp_list) {
-			for (j = 0; j < peer_ni->ksnp_n_passive_ips; j++)
-				if (peer_ni->ksnp_passive_ips[j] == ipaddress)
-					iface->ksni_npeers++;
-
-			list_for_each(rtmp, &peer_ni->ksnp_routes) {
-				route = list_entry(rtmp,
-						   struct ksock_route,
-						   ksnr_list);
-
-				if (route->ksnr_myiface ==
-					    iface->ksni_index)
-					iface->ksni_nroutes++;
-			}
-		}
-
-		rc = 0;
-		/* NB only new connections will pay attention to the new
-		 * interface!
-		 */
-	}
-
-	write_unlock_bh(&ksocknal_data.ksnd_global_lock);
-
-	return rc;
-}
-
-static void
-ksocknal_peer_del_interface_locked(struct ksock_peer_ni *peer_ni,
-				   __u32 ipaddr, int index)
-{
-	struct ksock_route *route;
-	struct ksock_route *rnxt;
-	struct ksock_conn *conn;
-	struct ksock_conn *cnxt;
-	int i;
-	int j;
-
-        for (i = 0; i < peer_ni->ksnp_n_passive_ips; i++)
-                if (peer_ni->ksnp_passive_ips[i] == ipaddr) {
-                        for (j = i+1; j < peer_ni->ksnp_n_passive_ips; j++)
-                                peer_ni->ksnp_passive_ips[j-1] =
-                                        peer_ni->ksnp_passive_ips[j];
-                        peer_ni->ksnp_n_passive_ips--;
-                        break;
-                }
-
-	list_for_each_entry_safe(route, rnxt, &peer_ni->ksnp_routes,
-				 ksnr_list) {
-		if (route->ksnr_myiface != index)
-			continue;
-
-		if (route->ksnr_share_count != 0) {
-			/* Manually created; keep, but unbind */
-			route->ksnr_myiface = -1;
-		} else {
-			ksocknal_del_route_locked(route);
-		}
-	}
-
-	list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns, ksnc_list)
-		if (conn->ksnc_route->ksnr_myiface == index)
-			ksocknal_close_conn_locked (conn, 0);
-}
-
-static int
-ksocknal_del_interface(struct lnet_ni *ni, __u32 ipaddress)
-{
-	struct ksock_net *net = ni->ni_data;
-	int rc = -ENOENT;
-	struct hlist_node *nxt;
-	struct ksock_peer_ni *peer_ni;
-	u32 this_ip;
-	struct sockaddr_in sa = {.sin_family = AF_INET };
-	int index;
-	int i;
-	int j;
-
-	sa.sin_addr.s_addr = htonl(ipaddress);
-	index = ksocknal_ip2index((struct sockaddr *)&sa, ni);
-
-	write_lock_bh(&ksocknal_data.ksnd_global_lock);
-
-	for (i = 0; i < net->ksnn_ninterfaces; i++) {
-		struct sockaddr_in *sa =
-			(void *)&net->ksnn_interfaces[i].ksni_addr;
-
-		if (sa->sin_family != AF_INET)
-			continue;
-		this_ip = ntohl(sa->sin_addr.s_addr);
-
-		if (!(ipaddress == 0 ||
-		      ipaddress == this_ip))
-			continue;
-
-		rc = 0;
-
-		for (j = i+1; j < net->ksnn_ninterfaces; j++)
-			net->ksnn_interfaces[j-1] =
-				net->ksnn_interfaces[j];
-
-		net->ksnn_ninterfaces--;
-
-		hash_for_each_safe(ksocknal_data.ksnd_peers, j,
-				   nxt, peer_ni, ksnp_list) {
-			if (peer_ni->ksnp_ni != ni)
-				continue;
-
-			ksocknal_peer_del_interface_locked(peer_ni,
-							   this_ip, index);
-		}
-	}
-
-	write_unlock_bh(&ksocknal_data.ksnd_global_lock);
-
-	return rc;
-}
-
 int
 ksocknal_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg)
 {
 	struct lnet_process_id id = {0};
-        struct libcfs_ioctl_data *data = arg;
-        int rc;
+	struct libcfs_ioctl_data *data = arg;
+	int rc;
 
-        switch(cmd) {
-        case IOC_LIBCFS_GET_INTERFACE: {
+	switch(cmd) {
+	case IOC_LIBCFS_GET_INTERFACE: {
 		struct ksock_net *net = ni->ni_data;
 		struct ksock_interface *iface;
 		struct sockaddr_in *sa;
 
 		read_lock(&ksocknal_data.ksnd_global_lock);
 
-                if (data->ioc_count >= (__u32)net->ksnn_ninterfaces) {
-                        rc = -ENOENT;
-                } else {
-                        rc = 0;
-                        iface = &net->ksnn_interfaces[data->ioc_count];
+		if (data->ioc_count >= 1) {
+			rc = -ENOENT;
+		} else {
+			rc = 0;
+			iface = &net->ksnn_interface;
 
 			sa = (void *)&iface->ksni_addr;
 			if (sa->sin_family == AF_INET)
@@ -2183,18 +1703,9 @@ ksocknal_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg)
 		}
 
 		read_unlock(&ksocknal_data.ksnd_global_lock);
-                return rc;
+		return rc;
         }
 
-        case IOC_LIBCFS_ADD_INTERFACE:
-                return ksocknal_add_interface(ni,
-                                              data->ioc_u32[0], /* IP address */
-                                              data->ioc_u32[1]); /* net mask */
-
-        case IOC_LIBCFS_DEL_INTERFACE:
-                return ksocknal_del_interface(ni,
-                                              data->ioc_u32[0]); /* IP address */
-
         case IOC_LIBCFS_GET_PEER: {
                 __u32            myip = 0;
                 __u32            ip = 0;
@@ -2362,7 +1873,7 @@ ksocknal_base_shutdown(void)
 		/* flag threads to terminate; wake and wait for them to die */
 		ksocknal_data.ksnd_shuttingdown = 1;
 		wake_up_all(&ksocknal_data.ksnd_connd_waitq);
-		wake_up_all(&ksocknal_data.ksnd_reaper_waitq);
+		wake_up(&ksocknal_data.ksnd_reaper_waitq);
 
 		if (ksocknal_data.ksnd_schedulers != NULL) {
 			cfs_percpt_for_each(sched, i,
@@ -2517,7 +2028,7 @@ ksocknal_debug_peerhash(struct lnet_ni *ni)
 	read_lock(&ksocknal_data.ksnd_global_lock);
 
 	hash_for_each(ksocknal_data.ksnd_peers, i, peer_ni, ksnp_list) {
-		struct ksock_route *route;
+		struct ksock_conn_cb *conn_cb;
 		struct ksock_conn *conn;
 
 		if (peer_ni->ksnp_ni != ni)
@@ -2533,11 +2044,12 @@ ksocknal_debug_peerhash(struct lnet_ni *ni)
 		      !list_empty(&peer_ni->ksnp_tx_queue),
 		      !list_empty(&peer_ni->ksnp_zc_req_list));
 
-		list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) {
-			CWARN("Route: ref %d, schd %d, conn %d, cnted %d, del %d\n",
-			      refcount_read(&route->ksnr_refcount),
-			      route->ksnr_scheduled, route->ksnr_connecting,
-			      route->ksnr_connected, route->ksnr_deleted);
+		conn_cb = peer_ni->ksnp_conn_cb;
+		if (conn_cb) {
+			CWARN("ConnCB: ref %d, schd %d, conn %d, cnted %d, del %d\n",
+			      refcount_read(&conn_cb->ksnr_refcount),
+			      conn_cb->ksnr_scheduled, conn_cb->ksnr_connecting,
+			      conn_cb->ksnr_connected, conn_cb->ksnr_deleted);
 		}
 
 		list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) {
@@ -2561,7 +2073,6 @@ ksocknal_shutdown(struct lnet_ni *ni)
 		.nid = LNET_NID_ANY,
 		.pid = LNET_PID_ANY,
 	};
-	int i;
 
 	LASSERT(ksocknal_data.ksnd_init == SOCKNAL_INIT_ALL);
 	LASSERT(ksocknal_data.ksnd_nnets > 0);
@@ -2581,10 +2092,8 @@ ksocknal_shutdown(struct lnet_ni *ni)
 			       atomic_read(&net->ksnn_npeers) -
 			       SOCKNAL_SHUTDOWN_BIAS);
 
-	for (i = 0; i < net->ksnn_ninterfaces; i++) {
-		LASSERT(net->ksnn_interfaces[i].ksni_npeers == 0);
-		LASSERT(net->ksnn_interfaces[i].ksni_nroutes == 0);
-	}
+	LASSERT(net->ksnn_interface.ksni_npeers == 0);
+	LASSERT(net->ksnn_interface.ksni_nroutes == 0);
 
 	list_del(&net->ksnn_list);
 	LIBCFS_FREE(net, sizeof(*net));
@@ -2598,41 +2107,30 @@ static int
 ksocknal_search_new_ipif(struct ksock_net *net)
 {
 	int new_ipif = 0;
-	int i;
+	char *ifnam = &net->ksnn_interface.ksni_name[0];
+	char *colon = strchr(ifnam, ':');
+	bool found = false;
+	struct ksock_net *tmp;
 
-	for (i = 0; i < net->ksnn_ninterfaces; i++) {
-		char *ifnam = &net->ksnn_interfaces[i].ksni_name[0];
-		char *colon = strchr(ifnam, ':');
-		bool found  = false;
-		struct ksock_net *tmp;
-		int j;
-
-		if (colon != NULL) /* ignore alias device */
-			*colon = 0;
-
-		list_for_each_entry(tmp, &ksocknal_data.ksnd_nets,
-				    ksnn_list) {
-			for (j = 0; !found && j < tmp->ksnn_ninterfaces; j++) {
-				char *ifnam2 = &tmp->ksnn_interfaces[j].\
-					ksni_name[0];
-				char *colon2 = strchr(ifnam2, ':');
-
-				if (colon2 != NULL)
-					*colon2 = 0;
-
-				found = strcmp(ifnam, ifnam2) == 0;
-				if (colon2 != NULL)
-					*colon2 = ':';
-			}
-			if (found)
-				break;
-		}
+	if (colon != NULL)
+		*colon = 0;
+
+	list_for_each_entry(tmp, &ksocknal_data.ksnd_nets, ksnn_list) {
+		char *ifnam2 = &tmp->ksnn_interface.ksni_name[0];
+		char *colon2 = strchr(ifnam2, ':');
 
-		new_ipif += !found;
-		if (colon != NULL)
-			*colon = ':';
+		if (colon2 != NULL)
+			*colon2 = 0;
+
+		found = strcmp(ifnam, ifnam2) == 0;
+		if (colon2 != NULL)
+			*colon2 = ':';
 	}
 
+	new_ipif += !found;
+	if (colon != NULL)
+		*colon = ':';
+
 	return new_ipif;
 }
 
@@ -2715,25 +2213,22 @@ ksocknal_startup(struct lnet_ni *ni)
 	struct lnet_ioctl_config_lnd_cmn_tunables *net_tunables;
 	struct ksock_interface *ksi = NULL;
 	struct lnet_inetdev *ifaces = NULL;
+	struct sockaddr_in *sa;
 	int i = 0;
 	int rc;
 
         LASSERT (ni->ni_net->net_lnd == &the_ksocklnd);
-
         if (ksocknal_data.ksnd_init == SOCKNAL_INIT_NOTHING) {
                 rc = ksocknal_base_startup();
                 if (rc != 0)
                         return rc;
         }
-
 	LIBCFS_ALLOC(net, sizeof(*net));
 	if (net == NULL)
 		goto fail_0;
-
 	net->ksnn_incarnation = ktime_get_real_ns();
 	ni->ni_data = net;
 	net_tunables = &ni->ni_net->net_tunables;
-
 	if (net_tunables->lct_peer_timeout == -1)
 		net_tunables->lct_peer_timeout =
 			*ksocknal_tunables.ksnd_peertimeout;
@@ -2759,82 +2254,31 @@ ksocknal_startup(struct lnet_ni *ni)
 	if (rc < 0)
 		goto fail_1;
 
-	if (!ni->ni_interfaces[0]) {
-		struct sockaddr_in *sa;
-
-		ksi = &net->ksnn_interfaces[0];
-		sa = (void *)&ksi->ksni_addr;
-
-		/* Use the first discovered interface */
-		net->ksnn_ninterfaces = 1;
-		ni->ni_dev_cpt = ifaces[0].li_cpt;
-		memset(sa, 0, sizeof(*sa));
-		sa->sin_family = AF_INET;
-		sa->sin_addr.s_addr = htonl(ifaces[0].li_ipaddr);
-		ksi->ksni_index = ksocknal_ip2index((struct sockaddr *)sa, ni);
-		ksi->ksni_netmask = ifaces[0].li_netmask;
-		strlcpy(ksi->ksni_name, ifaces[0].li_name,
-			sizeof(ksi->ksni_name));
-	} else {
-		/* Before Multi-Rail ksocklnd would manage
-		 * multiple interfaces with its own tcp bonding.
-		 * If we encounter an old configuration using
-		 * this tcp bonding approach then we need to
-		 * handle more than one ni_interfaces.
-		 *
-		 * In Multi-Rail configuration only ONE ni_interface
-		 * should exist. Each IP alias should be mapped to
-		 * each 'struct net_ni'.
-		 */
-		for (i = 0; i < LNET_INTERFACES_NUM; i++) {
-			int j;
+	ksi = &net->ksnn_interface;
 
-			if (!ni->ni_interfaces[i])
+	/* Use the first discovered interface or look in the list */
+	if (ni->ni_interface) {
+		for (i = 0; i < rc; i++)
+			if (strcmp(ifaces[i].li_name, ni->ni_interface) == 0)
 				break;
 
-			for (j = 0; j < LNET_INTERFACES_NUM;  j++) {
-				if (i != j && ni->ni_interfaces[j] &&
-				    strcmp(ni->ni_interfaces[i],
-					   ni->ni_interfaces[j]) == 0) {
-					rc = -EEXIST;
-					CERROR("ksocklnd: found duplicate %s at %d and %d, rc = %d\n",
-					       ni->ni_interfaces[i], i, j, rc);
-					goto fail_1;
-				}
-			}
-
-			for (j = 0; j < rc; j++) {
-				struct sockaddr_in *sa;
-
-				if (strcmp(ifaces[j].li_name,
-					   ni->ni_interfaces[i]) != 0)
-					continue;
-
-				ksi =
-				  &net->ksnn_interfaces[net->ksnn_ninterfaces];
-				sa = (void *)&ksi->ksni_addr;
-				ni->ni_dev_cpt = ifaces[j].li_cpt;
-				memset(sa, 0, sizeof(*sa));
-				sa->sin_family = AF_INET;
-				sa->sin_addr.s_addr =
-					htonl(ifaces[j].li_ipaddr);
-				ksi->ksni_index = ksocknal_ip2index(
-					(struct sockaddr *)sa, ni);
-				ksi->ksni_netmask = ifaces[j].li_netmask;
-				strlcpy(ksi->ksni_name, ifaces[j].li_name,
-					sizeof(ksi->ksni_name));
-				net->ksnn_ninterfaces++;
-				break;
-			}
-		}
-		/* ni_interfaces don't map to all network interfaces */
-		if (!ksi || net->ksnn_ninterfaces != i) {
-			CERROR("ksocklnd: requested %d but only %d interfaces found\n",
-			       i, net->ksnn_ninterfaces);
+		/* ni_interfaces doesn't contain the interface we want */
+		if (i == rc) {
+			CERROR("ksocklnd: failed to find interface %s\n",
+			       ni->ni_interface);
 			goto fail_1;
 		}
 	}
 
+	ni->ni_dev_cpt = ifaces[i].li_cpt;
+	sa = (void *)&ksi->ksni_addr;
+	memset(sa, 0, sizeof(*sa));
+	sa->sin_family = AF_INET;
+	sa->sin_addr.s_addr = htonl(ifaces[i].li_ipaddr);
+	ksi->ksni_index = ksocknal_ip2index((struct sockaddr *)sa, ni);
+	ksi->ksni_netmask = ifaces[i].li_netmask;
+	strlcpy(ksi->ksni_name, ifaces[i].li_name, sizeof(ksi->ksni_name));
+
 	/* call it before add it to ksocknal_data.ksnd_nets */
 	rc = ksocknal_net_start_threads(net, ni->ni_cpts, ni->ni_ncpts);
 	if (rc != 0)
@@ -2847,7 +2291,6 @@ ksocknal_startup(struct lnet_ni *ni)
 		ntohl(((struct sockaddr_in *)
 		       &ksi->ksni_addr)->sin_addr.s_addr));
 	list_add(&net->ksnn_list, &ksocknal_data.ksnd_nets);
-
 	ksocknal_data.ksnd_nnets++;
 
 	return 0;