Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 02105b2c authored by Sowmini Varadhan's avatar Sowmini Varadhan Committed by David S. Miller
Browse files

RDS: TCP: Make rds_tcp_connection track the rds_conn_path 



The struct rds_tcp_connection is the transport-specific private
data structure that tracks TCP information per rds_conn_path.
Modify this structure to have a back-pointer to the rds_conn_path
for which it is the ->cp_transport_data.

Acked-by: default avatarSantosh Shilimkar <santosh.shilimkar@oracle.com>
Signed-off-by: default avatarSowmini Varadhan <sowmini.varadhan@oracle.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 26e4e6bb

net/rds/connection.c

+15 −15
Original line number Diff line number Diff line
@@ -253,9 +253,12 @@ static struct rds_connection *__rds_conn_create(struct net *net, 


			for (i = 0; i < RDS_MPATH_WORKERS; i++) {

				cp = &conn->c_path[i];

				/* The ->conn_alloc invocation may have

				 * allocated resource for all paths, so all

				 * of them may have to be freed here.

				 */

				if (cp->cp_transport_data)

					trans->conn_free(cp->cp_transport_data);

				if (!trans->t_mp_capable)

					break;

			}

			kmem_cache_free(rds_conn_slab, conn);

			conn = found;
@@ -367,6 +370,9 @@ static void rds_conn_path_destroy(struct rds_conn_path *cp) 
{

	struct rds_message *rm, *rtmp;



	if (!cp->cp_transport_data)

		return;



	rds_conn_path_drop(cp);

	flush_work(&cp->cp_down_w);
@@ -398,6 +404,8 @@ static void rds_conn_path_destroy(struct rds_conn_path *cp) 
void rds_conn_destroy(struct rds_connection *conn)

{

	unsigned long flags;

	int i;

	struct rds_conn_path *cp;



	rdsdebug("freeing conn %p for %pI4 -> "

		 "%pI4\n", conn, &conn->c_laddr,
@@ -410,19 +418,11 @@ void rds_conn_destroy(struct rds_connection *conn) 
	synchronize_rcu();



	/* shut the connection down */

	if (!conn->c_trans->t_mp_capable) {

		rds_conn_path_destroy(&conn->c_path[0]);

		BUG_ON(!list_empty(&conn->c_path[0].cp_retrans));

	} else {

		int i;

		struct rds_conn_path *cp;



	for (i = 0; i < RDS_MPATH_WORKERS; i++) {

		cp = &conn->c_path[i];

		rds_conn_path_destroy(cp);

		BUG_ON(!list_empty(&cp->cp_retrans));

	}

	}



	/*

	 * The congestion maps aren't freed up here.  They're

net/rds/tcp.c

+25 −19
Original line number Diff line number Diff line
@@ -221,7 +221,7 @@ void rds_tcp_set_callbacks(struct socket *sock, struct rds_connection *conn) 
		sock->sk->sk_data_ready = sock->sk->sk_user_data;



	tc->t_sock = sock;

	tc->conn = conn;

	tc->t_cpath = &conn->c_path[0];

	tc->t_orig_data_ready = sock->sk->sk_data_ready;

	tc->t_orig_write_space = sock->sk->sk_write_space;

	tc->t_orig_state_change = sock->sk->sk_state_change;
@@ -284,24 +284,29 @@ static int rds_tcp_laddr_check(struct net *net, __be32 addr) 
static int rds_tcp_conn_alloc(struct rds_connection *conn, gfp_t gfp)

{

	struct rds_tcp_connection *tc;

	int i;



	for (i = 0; i < RDS_MPATH_WORKERS; i++) {

		tc = kmem_cache_alloc(rds_tcp_conn_slab, gfp);

		if (!tc)

			return -ENOMEM;



	mutex_init(&tc->t_conn_lock);

		mutex_init(&tc->t_conn_path_lock);

		tc->t_sock = NULL;

		tc->t_tinc = NULL;

		tc->t_tinc_hdr_rem = sizeof(struct rds_header);

		tc->t_tinc_data_rem = 0;



	conn->c_transport_data = tc;

		conn->c_path[i].cp_transport_data = tc;

		tc->t_cpath = &conn->c_path[i];



		spin_lock_irq(&rds_tcp_conn_lock);

		list_add_tail(&tc->t_tcp_node, &rds_tcp_conn_list);

		spin_unlock_irq(&rds_tcp_conn_lock);

		rdsdebug("rds_conn_path [%d] tc %p\n", i,

			 conn->c_path[i].cp_transport_data);

	}



	rdsdebug("alloced tc %p\n", conn->c_transport_data);

	return 0;

}
@@ -330,7 +335,7 @@ static void rds_tcp_destroy_conns(void) 
	spin_unlock_irq(&rds_tcp_conn_lock);



	list_for_each_entry_safe(tc, _tc, &tmp_list, t_tcp_node)

		rds_conn_destroy(tc->conn);

		rds_conn_destroy(tc->t_cpath->cp_conn);

}



static void rds_tcp_exit(void);
@@ -498,7 +503,7 @@ static void rds_tcp_kill_sock(struct net *net) 
	flush_work(&rtn->rds_tcp_accept_w);

	spin_lock_irq(&rds_tcp_conn_lock);

	list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) {

		struct net *c_net = read_pnet(&tc->conn->c_net);

		struct net *c_net = read_pnet(&tc->t_cpath->cp_conn->c_net);



		if (net != c_net || !tc->t_sock)

			continue;
@@ -509,7 +514,7 @@ static void rds_tcp_kill_sock(struct net *net) 
		sk = tc->t_sock->sk;

		sk->sk_prot->disconnect(sk, 0);

		tcp_done(sk);

		rds_conn_destroy(tc->conn);

		rds_conn_destroy(tc->t_cpath->cp_conn);

	}

}
@@ -547,12 +552,13 @@ static void rds_tcp_sysctl_reset(struct net *net) 


	spin_lock_irq(&rds_tcp_conn_lock);

	list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) {

		struct net *c_net = read_pnet(&tc->conn->c_net);

		struct net *c_net = read_pnet(&tc->t_cpath->cp_conn->c_net);



		if (net != c_net || !tc->t_sock)

			continue;



		rds_conn_drop(tc->conn); /* reconnect with new parameters */

		/* reconnect with new parameters */

		rds_conn_path_drop(tc->t_cpath);

	}

	spin_unlock_irq(&rds_tcp_conn_lock);

}

net/rds/tcp.h

+3 −3
Original line number Diff line number Diff line
@@ -11,11 +11,11 @@ struct rds_tcp_incoming { 
struct rds_tcp_connection {



	struct list_head	t_tcp_node;

	struct rds_connection   *conn;

	/* t_conn_lock synchronizes the connection establishment between

	struct rds_conn_path	*t_cpath;

	/* t_conn_path_lock synchronizes the connection establishment between

	 * rds_tcp_accept_one and rds_tcp_conn_connect

	 */

	struct mutex		t_conn_lock;

	struct mutex		t_conn_path_lock;

	struct socket		*t_sock;

	void			*t_orig_write_space;

	void			*t_orig_data_ready;

net/rds/tcp_connect.c

+3 −3
Original line number Diff line number Diff line
@@ -82,10 +82,10 @@ int rds_tcp_conn_connect(struct rds_connection *conn) 
	int ret;

	struct rds_tcp_connection *tc = conn->c_transport_data;



	mutex_lock(&tc->t_conn_lock);

	mutex_lock(&tc->t_conn_path_lock);



	if (rds_conn_up(conn)) {

		mutex_unlock(&tc->t_conn_lock);

		mutex_unlock(&tc->t_conn_path_lock);

		return 0;

	}

	ret = sock_create_kern(rds_conn_net(conn), PF_INET,
@@ -129,7 +129,7 @@ int rds_tcp_conn_connect(struct rds_connection *conn) 
	}



out:

	mutex_unlock(&tc->t_conn_lock);

	mutex_unlock(&tc->t_conn_path_lock);

	if (sock)

		sock_release(sock);

	return ret;

net/rds/tcp_listen.c

+2 −2
Original line number Diff line number Diff line
@@ -121,7 +121,7 @@ int rds_tcp_accept_one(struct socket *sock) 
	 */

	rs_tcp = (struct rds_tcp_connection *)conn->c_transport_data;

	rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING);

	mutex_lock(&rs_tcp->t_conn_lock);

	mutex_lock(&rs_tcp->t_conn_path_lock);

	conn_state = rds_conn_state(conn);

	if (conn_state != RDS_CONN_CONNECTING && conn_state != RDS_CONN_UP)

		goto rst_nsk;
@@ -156,7 +156,7 @@ int rds_tcp_accept_one(struct socket *sock) 
	ret = 0;

out:

	if (rs_tcp)

		mutex_unlock(&rs_tcp->t_conn_lock);

		mutex_unlock(&rs_tcp->t_conn_path_lock);

	if (new_sock)

		sock_release(new_sock);

	return ret;