Merge branch 'core-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[deliverable/linux.git] / net / rds / tcp_send.c

diff --git a/net/rds/tcp_send.c b/net/rds/tcp_send.c
index 22d0f2020a79f834d3a2a6536253e16c690baa41..89d09b481f47f4b790ce5ebd2c456ae0e9549b6b 100644 (file)
--- a/net/rds/tcp_send.c
+++ b/net/rds/tcp_send.c
@@ -34,6 +34,7 @@
 #include <linux/in.h>
 #include <net/tcp.h>
 
+#include "rds_single_path.h"
 #include "rds.h"
 #include "tcp.h"
 
@@ -48,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);
 }
@@ -66,21 +67,22 @@ void rds_tcp_xmit_complete(struct rds_connection *conn)
 static int rds_tcp_sendmsg(struct socket *sock, void *data, unsigned int len)
 {
        struct kvec vec = {
-                .iov_base = data,
-                .iov_len = len,
+               .iov_base = data,
+               .iov_len = len,
+       };
+       struct msghdr msg = {
+               .msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL,
        };
-        struct msghdr msg = {
-                .msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL,
-        };
 
        return kernel_sendmsg(sock, &msg, &vec, 1, vec.iov_len);
 }
 
 /* the core send_sem serializes this with other xmit and shutdown */
 int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
-                unsigned int hdr_off, unsigned int sg, unsigned int off)
+                unsigned int hdr_off, unsigned int sg, unsigned int off)
 {
-       struct rds_tcp_connection *tc = conn->c_transport_data;
+       struct rds_conn_path *cp = rm->m_inc.i_conn_path;
+       struct rds_tcp_connection *tc = cp->cp_transport_data;
        int done = 0;
        int ret = 0;
        int more;
@@ -149,10 +151,17 @@ out:
                        rds_tcp_stats_inc(s_tcp_sndbuf_full);
                        ret = 0;
                } else {
-                       printk(KERN_WARNING "RDS/tcp: send to %pI4 "
-                              "returned %d, disconnecting and reconnecting\n",
-                              &conn->c_faddr, ret);
-                       rds_conn_drop(conn);
+                       /* No need to disconnect/reconnect if path_drop
+                        * has already been triggered, because, e.g., of
+                        * an incoming RST.
+                        */
+                       if (rds_conn_path_up(cp)) {
+                               pr_warn("RDS/tcp: send to %pI4 on cp [%d]"
+                                       "returned %d, "
+                                       "disconnecting and reconnecting\n",
+                                       &conn->c_faddr, cp->cp_index, ret);
+                               rds_conn_path_drop(cp);
+                       }
                }
        }
        if (done == 0)
@@ -177,27 +186,27 @@ static int rds_tcp_is_acked(struct rds_message *rm, uint64_t ack)
 void rds_tcp_write_space(struct sock *sk)
 {
        void (*write_space)(struct sock *sk);
-       struct rds_connection *conn;
+       struct rds_conn_path *cp;
        struct rds_tcp_connection *tc;
 
        read_lock_bh(&sk->sk_callback_lock);
-       conn = sk->sk_user_data;
-       if (!conn) {
+       cp = sk->sk_user_data;
+       if (!cp) {
                write_space = sk->sk_write_space;
                goto out;
        }
 
-       tc = conn->c_transport_data;
+       tc = cp->cp_transport_data;
        rdsdebug("write_space for tc %p\n", tc);
        write_space = tc->t_orig_write_space;
        rds_tcp_stats_inc(s_tcp_write_space_calls);
 
        rdsdebug("tcp una %u\n", rds_tcp_snd_una(tc));
        tc->t_last_seen_una = rds_tcp_snd_una(tc);
-       rds_send_drop_acked(conn, rds_tcp_snd_una(tc), rds_tcp_is_acked);
+       rds_send_path_drop_acked(cp, rds_tcp_snd_una(tc), rds_tcp_is_acked);
 
-        if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf)
-               queue_delayed_work(rds_wq, &conn->c_send_w, 0);
+       if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf)
+               queue_delayed_work(rds_wq, &cp->cp_send_w, 0);
 
 out:
        read_unlock_bh(&sk->sk_callback_lock);