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

Commit 1364db42 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'rds-multipath-datastructures' 



Sowmini Varadhan says:

====================
RDS:TCP data structure changes for multipath support

The second installment of changes to enable multipath support in
RDS-TCP. This series implements the changes in rds-tcp so that the
rds_conn_path has a pointer to the rds_tcp_connection in cp_transport_data.
Struct rds_tcp_connection keeps track of the inet_sk per path in
t_sock. The ->sk_user_data in turn is a pointer to the rds_conn_path.
With this set of changes, rds_tcp has the needed plumbing to handle
multiple paths(socket) per rds_connection.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents dc9a2002 11bb62f7

net/rds/connection.c

+17 −22
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;
@@ -326,9 +329,6 @@ void rds_conn_shutdown(struct rds_conn_path *cp) 
		wait_event(cp->cp_waitq,

			   !test_bit(RDS_RECV_REFILL, &cp->cp_flags));



		if (!conn->c_trans->t_mp_capable)

			conn->c_trans->conn_shutdown(conn);

		else

		conn->c_trans->conn_path_shutdown(cp);

		rds_conn_path_reset(cp);
@@ -355,8 +355,6 @@ void rds_conn_shutdown(struct rds_conn_path *cp) 
	rcu_read_lock();

	if (!hlist_unhashed(&conn->c_hash_node)) {

		rcu_read_unlock();

		if (conn->c_trans->t_type != RDS_TRANS_TCP ||

		    cp->cp_outgoing == 1)

		rds_queue_reconnect(cp);

	} else {

		rcu_read_unlock();
@@ -370,6 +368,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);
@@ -401,6 +402,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,
@@ -413,19 +416,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/ib.c

+4 −4
Original line number Diff line number Diff line
@@ -381,15 +381,15 @@ void rds_ib_exit(void) 


struct rds_transport rds_ib_transport = {

	.laddr_check		= rds_ib_laddr_check,

	.xmit_complete		= rds_ib_xmit_complete,

	.xmit_path_complete	= rds_ib_xmit_path_complete,

	.xmit			= rds_ib_xmit,

	.xmit_rdma		= rds_ib_xmit_rdma,

	.xmit_atomic		= rds_ib_xmit_atomic,

	.recv			= rds_ib_recv,

	.recv_path		= rds_ib_recv_path,

	.conn_alloc		= rds_ib_conn_alloc,

	.conn_free		= rds_ib_conn_free,

	.conn_connect		= rds_ib_conn_connect,

	.conn_shutdown		= rds_ib_conn_shutdown,

	.conn_path_connect	= rds_ib_conn_path_connect,

	.conn_path_shutdown	= rds_ib_conn_path_shutdown,

	.inc_copy_to_user	= rds_ib_inc_copy_to_user,

	.inc_free		= rds_ib_inc_free,

	.cm_initiate_connect	= rds_ib_cm_initiate_connect,

net/rds/ib.h

+4 −4
Original line number Diff line number Diff line
@@ -328,8 +328,8 @@ extern struct list_head ib_nodev_conns; 
/* ib_cm.c */

int rds_ib_conn_alloc(struct rds_connection *conn, gfp_t gfp);

void rds_ib_conn_free(void *arg);

int rds_ib_conn_connect(struct rds_connection *conn);

void rds_ib_conn_shutdown(struct rds_connection *conn);

int rds_ib_conn_path_connect(struct rds_conn_path *cp);

void rds_ib_conn_path_shutdown(struct rds_conn_path *cp);

void rds_ib_state_change(struct sock *sk);

int rds_ib_listen_init(void);

void rds_ib_listen_stop(void);
@@ -354,7 +354,7 @@ void rds_ib_mr_cqe_handler(struct rds_ib_connection *ic, struct ib_wc *wc); 
/* ib_recv.c */

int rds_ib_recv_init(void);

void rds_ib_recv_exit(void);

int rds_ib_recv(struct rds_connection *conn);

int rds_ib_recv_path(struct rds_conn_path *conn);

int rds_ib_recv_alloc_caches(struct rds_ib_connection *ic);

void rds_ib_recv_free_caches(struct rds_ib_connection *ic);

void rds_ib_recv_refill(struct rds_connection *conn, int prefill, gfp_t gfp);
@@ -384,7 +384,7 @@ u32 rds_ib_ring_completed(struct rds_ib_work_ring *ring, u32 wr_id, u32 oldest); 
extern wait_queue_head_t rds_ib_ring_empty_wait;



/* ib_send.c */

void rds_ib_xmit_complete(struct rds_connection *conn);

void rds_ib_xmit_path_complete(struct rds_conn_path *cp);

int rds_ib_xmit(struct rds_connection *conn, struct rds_message *rm,

		unsigned int hdr_off, unsigned int sg, unsigned int off);

void rds_ib_send_cqe_handler(struct rds_ib_connection *ic, struct ib_wc *wc);

net/rds/ib_cm.c

+4 −2
Original line number Diff line number Diff line
@@ -685,8 +685,9 @@ int rds_ib_cm_initiate_connect(struct rdma_cm_id *cm_id) 
	return ret;

}



int rds_ib_conn_connect(struct rds_connection *conn)

int rds_ib_conn_path_connect(struct rds_conn_path *cp)

{

	struct rds_connection *conn = cp->cp_conn;

	struct rds_ib_connection *ic = conn->c_transport_data;

	struct sockaddr_in src, dest;

	int ret;
@@ -731,8 +732,9 @@ int rds_ib_conn_connect(struct rds_connection *conn) 
 * so that it can be called at any point during startup.  In fact it

 * can be called multiple times for a given connection.

 */

void rds_ib_conn_shutdown(struct rds_connection *conn)

void rds_ib_conn_path_shutdown(struct rds_conn_path *cp)

{

	struct rds_connection *conn = cp->cp_conn;

	struct rds_ib_connection *ic = conn->c_transport_data;

	int err = 0;

net/rds/ib_recv.c

+2 −1
Original line number Diff line number Diff line
@@ -1009,8 +1009,9 @@ void rds_ib_recv_cqe_handler(struct rds_ib_connection *ic, 
		rds_ib_recv_refill(conn, 0, GFP_NOWAIT);

}



int rds_ib_recv(struct rds_connection *conn)

int rds_ib_recv_path(struct rds_conn_path *cp)

{

	struct rds_connection *conn = cp->cp_conn;

	struct rds_ib_connection *ic = conn->c_transport_data;

	int ret = 0;