RDS: Rework path specific indirections

Refactor code to avoid separate indirections for single-path
and multipath transports. All transports (both single and mp-capable)
will get a pointer to the rds_conn_path, and can trivially derive
the rds_connection from the ->cp_conn.

Acked-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>
Signed-off-by: Sowmini Varadhan <sowmini.varadhan@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/rds/connection.c b/net/rds/connection.c
index a4b07c899d898aa6efeec711f1cc8fb61bf399fc..17c2f2591ac4502e229cf770d5b173bf7b112e2e 100644 (file)
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -326,10 +326,7 @@ 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);
+               conn->c_trans->conn_path_shutdown(cp);
                rds_conn_path_reset(cp);
 
                if (!rds_conn_path_transition(cp, RDS_CONN_DISCONNECTING,

diff --git a/net/rds/ib.c b/net/rds/ib.c
index 44946a681a8c66ef491ba304a46489763e821c64..1b29ec9445fcb9b2eeba844fbf663467fb336cd4 100644 (file)
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -381,7 +381,7 @@ 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,
@@ -389,7 +389,7 @@ struct rds_transport rds_ib_transport = {
        .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_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,

diff --git a/net/rds/ib.h b/net/rds/ib.h
index 627fb79aee65b24baa7820d93b63cc3a02f2c6f5..2051f4bd7a66ff4958609b6a298c829d9089b844 100644 (file)
--- a/net/rds/ib.h
+++ b/net/rds/ib.h
@@ -329,7 +329,7 @@ extern struct list_head ib_nodev_conns;
 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);
+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);
@@ -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);

diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index e48bb1ba3dfc3413a2bbc16971be58274812e34e..e34ea0b5c16a03d5af1057108287c7161058b4ba 100644 (file)
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -731,8 +731,9 @@ out:
  * 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;
 

diff --git a/net/rds/ib_send.c b/net/rds/ib_send.c
index 6e4110aa513593cdc972468c87aaac7f843ba393..84d90c97332f9178552f34f2e13973a351f6213a 100644 (file)
--- a/net/rds/ib_send.c
+++ b/net/rds/ib_send.c
@@ -980,8 +980,9 @@ out:
        return ret;
 }
 
-void rds_ib_xmit_complete(struct rds_connection *conn)
+void rds_ib_xmit_path_complete(struct rds_conn_path *cp)
 {
+       struct rds_connection *conn = cp->cp_conn;
        struct rds_ib_connection *ic = conn->c_transport_data;
 
        /* We may have a pending ACK or window update we were unable

diff --git a/net/rds/loop.c b/net/rds/loop.c
index 15f83db78f0c2180a2c09492abf881c9c424aed6..318c21d7d8d46ff643181729e7238afcfd393fe5 100644 (file)
--- a/net/rds/loop.c
+++ b/net/rds/loop.c
@@ -156,7 +156,7 @@ static int rds_loop_conn_connect(struct rds_connection *conn)
        return 0;
 }
 
-static void rds_loop_conn_shutdown(struct rds_connection *conn)
+static void rds_loop_conn_path_shutdown(struct rds_conn_path *cp)
 {
 }
 
@@ -189,7 +189,7 @@ struct rds_transport rds_loop_transport = {
        .conn_alloc             = rds_loop_conn_alloc,
        .conn_free              = rds_loop_conn_free,
        .conn_connect           = rds_loop_conn_connect,
-       .conn_shutdown          = rds_loop_conn_shutdown,
+       .conn_path_shutdown     = rds_loop_conn_path_shutdown,
        .inc_copy_to_user       = rds_message_inc_copy_to_user,
        .inc_free               = rds_loop_inc_free,
        .t_name                 = "loopback",

diff --git a/net/rds/rds.h b/net/rds/rds.h
index 2e35b738176f35bdad33a32196e298bc9ee9824c..5bbad08262f58e96f20104f901d53b9a447c7b2c 100644 (file)
--- a/net/rds/rds.h
+++ b/net/rds/rds.h
@@ -455,11 +455,8 @@ struct rds_transport {
        int (*conn_alloc)(struct rds_connection *conn, gfp_t gfp);
        void (*conn_free)(void *data);
        int (*conn_connect)(struct rds_connection *conn);
-       void (*conn_shutdown)(struct rds_connection *conn);
        void (*conn_path_shutdown)(struct rds_conn_path *conn);
-       void (*xmit_prepare)(struct rds_connection *conn);
        void (*xmit_path_prepare)(struct rds_conn_path *cp);
-       void (*xmit_complete)(struct rds_connection *conn);
        void (*xmit_path_complete)(struct rds_conn_path *cp);
        int (*xmit)(struct rds_connection *conn, struct rds_message *rm,
                    unsigned int hdr_off, unsigned int sg, unsigned int off);

diff --git a/net/rds/send.c b/net/rds/send.c
index ee43d6b2ea8f75a3d73c1f26b792a359edcab05f..5a9caf1da89630181615c418206fb33eef7ab4be 100644 (file)
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -183,12 +183,8 @@ restart:
                goto out;
        }
 
-       if (conn->c_trans->t_mp_capable) {
-               if (conn->c_trans->xmit_path_prepare)
-                       conn->c_trans->xmit_path_prepare(cp);
-       } else if (conn->c_trans->xmit_prepare) {
-               conn->c_trans->xmit_prepare(conn);
-       }
+       if (conn->c_trans->xmit_path_prepare)
+               conn->c_trans->xmit_path_prepare(cp);
 
        /*
         * spin trying to push headers and data down the connection until
@@ -403,12 +399,8 @@ restart:
        }
 
 over_batch:
-       if (conn->c_trans->t_mp_capable) {
-               if (conn->c_trans->xmit_path_complete)
-                       conn->c_trans->xmit_path_complete(cp);
-       } else if (conn->c_trans->xmit_complete) {
-               conn->c_trans->xmit_complete(conn);
-       }
+       if (conn->c_trans->xmit_path_complete)
+               conn->c_trans->xmit_path_complete(cp);
        release_in_xmit(cp);
 
        /* Nuke any messages we decided not to retransmit. */

diff --git a/net/rds/tcp.c b/net/rds/tcp.c
index 5217d49ce6d69356f11db383a95fab25f8f6d903..b139630daaa4eaa1196f9e7aa4959ab4b94e771a 100644 (file)
--- a/net/rds/tcp.c
+++ b/net/rds/tcp.c
@@ -340,14 +340,14 @@ static void rds_tcp_exit(void);
 
 struct rds_transport rds_tcp_transport = {
        .laddr_check            = rds_tcp_laddr_check,
-       .xmit_prepare           = rds_tcp_xmit_prepare,
-       .xmit_complete          = rds_tcp_xmit_complete,
+       .xmit_path_prepare      = rds_tcp_xmit_path_prepare,
+       .xmit_path_complete     = rds_tcp_xmit_path_complete,
        .xmit                   = rds_tcp_xmit,
        .recv                   = rds_tcp_recv,
        .conn_alloc             = rds_tcp_conn_alloc,
        .conn_free              = rds_tcp_conn_free,
        .conn_connect           = rds_tcp_conn_connect,
-       .conn_shutdown          = rds_tcp_conn_shutdown,
+       .conn_path_shutdown     = rds_tcp_conn_path_shutdown,
        .inc_copy_to_user       = rds_tcp_inc_copy_to_user,
        .inc_free               = rds_tcp_inc_free,
        .stats_info_copy        = rds_tcp_stats_info_copy,

diff --git a/net/rds/tcp.h b/net/rds/tcp.h
index 7940babf6c718617c729247ac348b2b6ed68a53a..728abe22c9a36e16113421999dd068e81313da55 100644 (file)
--- a/net/rds/tcp.h
+++ b/net/rds/tcp.h
@@ -61,7 +61,7 @@ void rds_tcp_accept_work(struct sock *sk);
 
 /* tcp_connect.c */
 int rds_tcp_conn_connect(struct rds_connection *conn);
-void rds_tcp_conn_shutdown(struct rds_connection *conn);
+void rds_tcp_conn_path_shutdown(struct rds_conn_path *conn);
 void rds_tcp_state_change(struct sock *sk);
 
 /* tcp_listen.c */
@@ -80,8 +80,8 @@ void rds_tcp_inc_free(struct rds_incoming *inc);
 int rds_tcp_inc_copy_to_user(struct rds_incoming *inc, struct iov_iter *to);
 
 /* tcp_send.c */
-void rds_tcp_xmit_prepare(struct rds_connection *conn);
-void rds_tcp_xmit_complete(struct rds_connection *conn);
+void rds_tcp_xmit_path_prepare(struct rds_conn_path *cp);
+void rds_tcp_xmit_path_complete(struct rds_conn_path *cp);
 int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
                 unsigned int hdr_off, unsigned int sg, unsigned int off);
 void rds_tcp_write_space(struct sock *sk);

diff --git a/net/rds/tcp_connect.c b/net/rds/tcp_connect.c
index 96c2c4d17909488aa0c8c2a23d6166536eba3d8b..aa65c1631c4b4d78fa4bfe0e9f08b46e4956fda6 100644 (file)
--- a/net/rds/tcp_connect.c
+++ b/net/rds/tcp_connect.c
@@ -144,12 +144,13 @@ out:
  * callbacks to those set by TCP.  Our callbacks won't execute again once we
  * hold the sock lock.
  */
-void rds_tcp_conn_shutdown(struct rds_connection *conn)
+void rds_tcp_conn_path_shutdown(struct rds_conn_path *cp)
 {
-       struct rds_tcp_connection *tc = conn->c_transport_data;
+       struct rds_tcp_connection *tc = cp->cp_transport_data;
        struct socket *sock = tc->t_sock;
 
-       rdsdebug("shutting down conn %p tc %p sock %p\n", conn, tc, sock);
+       rdsdebug("shutting down conn %p tc %p sock %p\n",
+                cp->cp_conn, tc, sock);
 
        if (sock) {
                sock->ops->shutdown(sock, RCV_SHUTDOWN | SEND_SHUTDOWN);

diff --git a/net/rds/tcp_send.c b/net/rds/tcp_send.c
index 710f1aae97ad336fc04a17e17022cfab73b83fad..52cda947457b7b948f9df495457db1ff8dd8fe0f 100644 (file)
--- a/net/rds/tcp_send.c
+++ b/net/rds/tcp_send.c
@@ -49,16 +49,16 @@ static void rds_tcp_cork(struct socket *sock, int val)
        set_fs(oldfs);
 }
 
-void rds_tcp_xmit_prepare(struct rds_connection *conn)
+void rds_tcp_xmit_path_prepare(struct rds_conn_path *cp)
 {
-       struct rds_tcp_connection *tc = conn->c_transport_data;
+       struct rds_tcp_connection *tc = cp->cp_transport_data;
 
        rds_tcp_cork(tc->t_sock, 1);
 }
 
-void rds_tcp_xmit_complete(struct rds_connection *conn)
+void rds_tcp_xmit_path_complete(struct rds_conn_path *cp)
 {
-       struct rds_tcp_connection *tc = conn->c_transport_data;
+       struct rds_tcp_connection *tc = cp->cp_transport_data;
 
        rds_tcp_cork(tc->t_sock, 0);
 }