Merge branch 'topic/uek-4.1/ofed.rds-p2' into topic/uek-4.1/ofed

* topic/uek-4.1/ofed.rds-p2:
  RDS-TCP: Reset tcp callbacks if re-using an outgoing socket in rds_tcp_accept_one()
  RDS: Invoke ->laddr_check() in rds_bind() for explicitly bound transports.
  RDS: rds_conn_lookup() should factor in the struct net for a match
  RDS: Use a single TCP socket for both send and receive.
  RDS-TCP: Do not bloat sndbuf/rcvbuf in rds_tcp_tune
  RDS-TCP: Set up MSG_MORE and MSG_SENDPAGE_NOTLAST as appropriate in rds_tcp_
  Revert "rds_rdma: rds_sendmsg should return EAGAIN if connection not setup"
  rds: make sure base connection is up on both sides
  rds_ib/iw: fixed big endianness conversion issue for dp->dp_ack_seq
  RDS: fix race condition when sending a message on unbound socket.
  RDS: verify the underlying transport exists before creating a connection

Author: Mukesh Kacker

net/rds/af_rds.c

@@ -325,7 +325,8 @@ static int rds_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 				sizeof(struct rds_reset)))
 		return -EFAULT;
 
-	conn = rds_conn_find(reset.src.s_addr, reset.dst.s_addr,
+	conn = rds_conn_find(sock_net(rds_rs_to_sk(rs)),
+			     reset.src.s_addr, reset.dst.s_addr,
 			rs->rs_transport, reset.tos);
 
 	if (conn) {

net/rds/bind.c

@@ -198,7 +198,14 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 		goto out;
 
 	if (rs->rs_transport) { /* previously bound */
-		ret = 0;
+		trans = rs->rs_transport;
+		if (trans->laddr_check(sock_net(sock->sk),
+				       sin->sin_addr.s_addr) != 0) {
+			ret = -ENOPROTOOPT;
+			rds_remove_bound(rs);
+		} else {
+			ret = 0;
+		}
 		goto out;
 	}
 	trans = rds_trans_get_preferred(sock_net(sock->sk),

net/rds/connection.c

@@ -69,7 +69,8 @@ static struct hlist_head *rds_conn_bucket(__be32 laddr, __be32 faddr)
 } while (0)
 
 /* rcu read lock must be held or the connection spinlock */
-static struct rds_connection *rds_conn_lookup(struct hlist_head *head,
+static struct rds_connection *rds_conn_lookup(struct net *net,
+					      struct hlist_head *head,
 					      __be32 laddr, __be32 faddr,
 					      struct rds_transport *trans,
 					      u8 tos)
@@ -79,7 +80,8 @@ static struct rds_connection *rds_conn_lookup(struct hlist_head *head,
 	hlist_for_each_entry_rcu(conn, head, c_hash_node) {
 		if (conn->c_faddr == faddr && conn->c_laddr == laddr &&
 				conn->c_tos == tos &&
-				conn->c_trans == trans) {
+				conn->c_trans == trans &&
+		    net == rds_conn_net(conn)) {
 			ret = conn;
 			break;
 		}
@@ -129,12 +131,9 @@ static struct rds_connection *__rds_conn_create(struct net *net,
 	struct rds_transport *loop_trans;
 	unsigned long flags;
 	int ret;
-	struct rds_transport *otrans = trans;
 
-	if (!is_outgoing && otrans->t_type == RDS_TRANS_TCP)
-		goto new_conn;
 	rcu_read_lock();
-	conn = rds_conn_lookup(head, laddr, faddr, trans, tos);
+	conn = rds_conn_lookup(net, head, laddr, faddr, trans, tos);
 	if (conn
 	 && conn->c_loopback
 	 && conn->c_trans != &rds_loop_transport
@@ -151,7 +150,6 @@ static struct rds_connection *__rds_conn_create(struct net *net,
 	if (conn)
 		goto out;
 
-new_conn:
 	conn = kmem_cache_alloc(rds_conn_slab, gfp);
 	if (!conn) {
 		conn = ERR_PTR(-ENOMEM);
@@ -209,6 +207,7 @@ static struct rds_connection *__rds_conn_create(struct net *net,
 
 	atomic_set(&conn->c_state, RDS_CONN_DOWN);
 	conn->c_send_gen = 0;
+	conn->c_outgoing = (is_outgoing ? 1 : 0);
 	conn->c_reconnect_jiffies = 0;
 	conn->c_reconnect_start = get_seconds();
 	conn->c_reconnect_warn = 1;
@@ -255,22 +254,13 @@ static struct rds_connection *__rds_conn_create(struct net *net,
 		/* Creating normal conn */
 		struct rds_connection *found;
 
-		if (!is_outgoing && otrans->t_type == RDS_TRANS_TCP)
-			found = NULL;
-		else
-			found = rds_conn_lookup(head, laddr, faddr, trans, tos);
+		found = rds_conn_lookup(net, head, laddr, faddr, trans, tos);
 		if (found) {
 			trans->conn_free(conn->c_transport_data);
 			kmem_cache_free(rds_conn_slab, conn);
 			conn = found;
 		} else {
-			if ((is_outgoing && otrans->t_type == RDS_TRANS_TCP) ||
-			    (otrans->t_type != RDS_TRANS_TCP)) {
-				/* Only the active side should be added to
-				 * reconnect list for RDS-TCP.
-				 */
-				hlist_add_head_rcu(&conn->c_hash_node, head);
-			}
+			hlist_add_head_rcu(&conn->c_hash_node, head);
 			rds_cong_add_conn(conn);
 			rds_conn_count++;
 		}
@@ -299,14 +289,15 @@ struct rds_connection *rds_conn_create_outgoing(struct net *net,
 }
 EXPORT_SYMBOL_GPL(rds_conn_create_outgoing);
 
-struct rds_connection *rds_conn_find(__be32 laddr, __be32 faddr,
-					struct rds_transport *trans, u8 tos)
+struct rds_connection *rds_conn_find(struct net *net, __be32 laddr,
+				     __be32 faddr, struct rds_transport *trans,
+				     u8 tos)
 {
 	struct rds_connection *conn;
 	struct hlist_head *head = rds_conn_bucket(laddr, faddr);
 
 	rcu_read_lock();
-	conn = rds_conn_lookup(head, laddr, faddr, trans, tos);
+	conn = rds_conn_lookup(net, head, laddr, faddr, trans, tos);
 	rcu_read_unlock();
 
 	return conn;
@@ -369,11 +360,16 @@ void rds_conn_shutdown(struct rds_connection *conn, int restart)
 	rcu_read_lock();
 	if (!hlist_unhashed(&conn->c_hash_node) && restart) {
 		rcu_read_unlock();
-		rds_rtd(RDS_RTD_CM_EXT,
-			"queueing reconnect request... <%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
-			NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr),
-			conn->c_tos);
-		rds_queue_reconnect(conn);
+		if (conn->c_trans->t_type != RDS_TRANS_TCP ||
+		    conn->c_outgoing == 1) {
+			rds_rtd(RDS_RTD_CM_EXT,
+				"queueing reconnect request... "
+				"<%u.%u.%u.%u,%u.%u.%u.%u,%d>\n",
+				NIPQUAD(conn->c_laddr),
+				NIPQUAD(conn->c_faddr),
+				conn->c_tos);
+			rds_queue_reconnect(conn);
+		}
 	} else {
 		rcu_read_unlock();
 	}

net/rds/ib_cm.c

@@ -290,7 +290,7 @@ static void rds_ib_cm_fill_conn_param(struct rds_connection *conn,
 		dp->dp_protocol_major = RDS_PROTOCOL_MAJOR(protocol_version);
 		dp->dp_protocol_minor = RDS_PROTOCOL_MINOR(protocol_version);
 		dp->dp_protocol_minor_mask = cpu_to_be16(RDS_IB_SUPPORTED_PROTOCOLS);
-		dp->dp_ack_seq = rds_ib_piggyb_ack(ic);
+		dp->dp_ack_seq = cpu_to_be64(rds_ib_piggyb_ack(ic));
 		dp->dp_tos = conn->c_tos;
 
 		/* Advertise flow control */
@@ -822,6 +822,20 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
 		}
 	}
 
+	/*
+	 * Make sure to have zero lane connection up on both sides,
+	 * to avoid establishing connection on non-ideal path records.
+	 */
+	if (dp->dp_tos && rds_conn_state(conn->c_base_conn) != RDS_CONN_UP) {
+		printk(KERN_INFO "RDS/IB: connection "
+				"<%u.%u.%u.%u,%u.%u.%u.%u,%d> "
+				"incoming REQ with base connection down, retry\n",
+				NIPQUAD(conn->c_laddr),
+				NIPQUAD(conn->c_faddr),
+				conn->c_tos);
+		rds_conn_drop(conn);
+	}
+
 	/*
 	 * The connection request may occur while the
 	 * previous connection exist, e.g. in case of failover.

net/rds/iw_cm.c

@@ -121,7 +121,7 @@ static void rds_iw_cm_fill_conn_param(struct rds_connection *conn,
 		dp->dp_protocol_major = RDS_PROTOCOL_MAJOR(protocol_version);
 		dp->dp_protocol_minor = RDS_PROTOCOL_MINOR(protocol_version);
 		dp->dp_protocol_minor_mask = cpu_to_be16(RDS_IW_SUPPORTED_PROTOCOLS);
-		dp->dp_ack_seq = rds_iw_piggyb_ack(ic);
+		dp->dp_ack_seq = cpu_to_be64(rds_iw_piggyb_ack(ic));
 
 		/* Advertise flow control */
 		if (ic->i_flowctl) {

net/rds/rds.h

@@ -99,7 +99,9 @@ struct rds_connection {
 	struct hlist_node	c_hash_node;
 	__be32			c_laddr;
 	__be32			c_faddr;
-	unsigned int		c_loopback:1;
+	unsigned int		c_loopback:1,
+				c_outgoing:1,
+				c_pad_to_32:30;
 	struct rds_connection	*c_passive;
 
 	struct rds_cong_map	*c_lcong;
@@ -706,7 +708,8 @@ struct rds_connection *rds_conn_create_outgoing(struct net *net,
 						__be32 laddr, __be32 faddr,
 				struct rds_transport *trans,
 				u8 tos, gfp_t gfp);
-struct rds_connection *rds_conn_find(__be32 laddr, __be32 faddr,
+struct rds_connection *rds_conn_find(struct net *net, __be32 laddr,
+				     __be32 faddr,
 					struct rds_transport *trans, u8 tos);
 void rds_conn_shutdown(struct rds_connection *conn, int restart);
 void rds_conn_destroy(struct rds_connection *conn);

net/rds/recv.c

@@ -358,7 +358,8 @@ rds_recv_route(struct rds_connection *conn, struct rds_incoming *inc,
 		nconn = conn;
 	} else {
 		/* reroute to a new conn structure, possibly the same one */
-		nconn = rds_conn_find(dst->saddr, dst->daddr, conn->c_trans,
+		nconn = rds_conn_find(rds_conn_net(conn),
+				      dst->saddr, dst->daddr, conn->c_trans,
 				      conn->c_tos);
 	}
 

net/rds/send.c

@@ -1228,6 +1228,11 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
 
 	rm->m_daddr = daddr;
 
+	/* Parse any control messages the user may have included. */
+	ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
+	if (ret)
+		goto out;
+
 	if (rm->rdma.op_active)
 		total_payload_len += rm->rdma.op_bytes;
 
@@ -1322,16 +1327,6 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
 		goto out;
 	}
 
-	if (!rds_conn_up(conn)) {
-		ret = -EAGAIN;
-		goto out;
-	}
-
-	/* Parse any control messages the user may have included. */
-	ret = rds_cmsg_send(rs, rm, msg, &allocated_mr);
-	if (ret)
-		goto out;
-
 	while (!rds_send_queue_rm(rs, conn, rm, rs->rs_bound_port,
 				  dport, &queued)) {
 		rds_stats_inc(s_send_queue_full);

net/rds/tcp.c

@@ -65,21 +65,13 @@ void rds_tcp_nonagle(struct socket *sock)
 	set_fs(oldfs);
 }
 
+/* All module specific customizations to the RDS-TCP socket should be done in
+ * rds_tcp_tune() and applied after socket creation. In general these
+ * customizations should be tunable via module_param()
+ */
 void rds_tcp_tune(struct socket *sock)
 {
-	struct sock *sk = sock->sk;
-
 	rds_tcp_nonagle(sock);
-
-	/*
-	 * We're trying to saturate gigabit with the default,
-	 * see svc_sock_setbufsize().
-	 */
-	lock_sock(sk);
-	sk->sk_sndbuf = RDS_TCP_DEFAULT_BUFSIZE;
-	sk->sk_rcvbuf = RDS_TCP_DEFAULT_BUFSIZE;
-	sk->sk_userlocks |= SOCK_SNDBUF_LOCK|SOCK_RCVBUF_LOCK;
-	release_sock(sk);
 }
 
 u32 rds_tcp_snd_nxt(struct rds_tcp_connection *tc)

net/rds/tcp_listen.c

@@ -109,28 +109,27 @@ int rds_tcp_accept_one(struct socket *sock)
 		goto out;
 	}
 	/* An incoming SYN request came in, and TCP just accepted it.
-	 * We always create a new conn for listen side of TCP, and do not
-	 * add it to the c_hash_list.
 	 *
 	 * If the client reboots, this conn will need to be cleaned up.
 	 * rds_tcp_state_change() will do that cleanup
 	 */
 	rs_tcp = (struct rds_tcp_connection *)conn->c_transport_data;
-	WARN_ON(!rs_tcp || rs_tcp->t_sock);
-
-	/*
-	 * see the comment above rds_queue_delayed_reconnect()
-	 */
-	if (!rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING)) {
-		if (rds_conn_state(conn) == RDS_CONN_UP)
-			rds_tcp_stats_inc(s_tcp_listen_closed_stale);
-		else
-			rds_tcp_stats_inc(s_tcp_connect_raced);
-		rds_conn_drop(conn);
+	if (rs_tcp->t_sock &&
+	    ntohl(inet->inet_saddr) < ntohl(inet->inet_daddr)) {
+		struct sock *nsk = new_sock->sk;
+
+		nsk->sk_user_data = NULL;
+		nsk->sk_prot->disconnect(nsk, 0);
+		tcp_done(nsk);
+		new_sock = NULL;
 		ret = 0;
 		goto out;
+	} else if (rs_tcp->t_sock) {
+		rds_tcp_restore_callbacks(rs_tcp->t_sock, rs_tcp);
+		conn->c_outgoing = 0;
 	}
 
+	rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING);
 	rds_tcp_set_callbacks(new_sock, conn);
 	rds_connect_complete(conn);
 	new_sock = NULL;

net/rds/tcp_send.c

@@ -83,6 +83,7 @@ int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
 	struct rds_tcp_connection *tc = conn->c_transport_data;
 	int done = 0;
 	int ret = 0;
+	int more;
 
 	if (hdr_off == 0) {
 		/*
@@ -116,12 +117,15 @@ int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
 			goto out;
 	}
 
+	more = rm->data.op_nents > 1 ? (MSG_MORE | MSG_SENDPAGE_NOTLAST) : 0;
 	while (sg < rm->data.op_nents) {
+		int flags = MSG_DONTWAIT | MSG_NOSIGNAL | more;
+
 		ret = tc->t_sock->ops->sendpage(tc->t_sock,
 						sg_page(&rm->data.op_sg[sg]),
 						rm->data.op_sg[sg].offset + off,
 						rm->data.op_sg[sg].length - off,
-						MSG_DONTWAIT|MSG_NOSIGNAL);
+						flags);
 		rdsdebug("tcp sendpage %p:%u:%u ret %d\n", (void *)sg_page(&rm->data.op_sg[sg]),
 			 rm->data.op_sg[sg].offset + off, rm->data.op_sg[sg].length - off,
 			 ret);
@@ -134,6 +138,8 @@ int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
 			off = 0;
 			sg++;
 		}
+		if (sg == rm->data.op_nents - 1)
+			more = 0;
 	}
 
 out: