net/smc: Send directly when TCP_CORK is cleared

[ Upstream commit ea785a1a573b390a150010b3c5b81e1ccd8c98a8 ]

According to the man page of TCP_CORK [1], if set, don't send out
partial frames. All queued partial frames are sent when option is
cleared again.

When applications call setsockopt to disable TCP_CORK, this call is
protected by lock_sock(), and tries to mod_delayed_work() to 0, in order
to send pending data right now. However, the delayed work smc_tx_work is
also protected by lock_sock(). There introduces lock contention for
sending data.

To fix it, send pending data directly which acts like TCP, without
lock_sock() protected in the context of setsockopt (already lock_sock()ed),
and cancel unnecessary dealyed work, which is protected by lock.

[1] https://linux.die.net/man/7/tcp

Signed-off-by: Tony Lu <tonylu@linux.alibaba.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
index 5c4c0320e822af75fdfea609ede906c6533bf34b..183b122807b66b5b5c4b53f29ca1f6ebaccae10f 100644 (file)
--- a/net/smc/af_smc.c
+++ b/net/smc/af_smc.c
@@ -2430,8 +2430,8 @@ static int smc_setsockopt(struct socket *sock, int level, int optname,
                    sk->sk_state != SMC_CLOSED) {
                        if (!val) {
                                SMC_STAT_INC(smc, cork_cnt);
-                               mod_delayed_work(smc->conn.lgr->tx_wq,
-                                                &smc->conn.tx_work, 0);
+                               smc_tx_pending(&smc->conn);
+                               cancel_delayed_work(&smc->conn.tx_work);
                        }
                }
                break;

diff --git a/net/smc/smc_tx.c b/net/smc/smc_tx.c
index 738a4a99c82797b7b5d28afaba5208135e1983ad..31ee76131a79ed7c4333f10b22c1a065c0d7129f 100644 (file)
--- a/net/smc/smc_tx.c
+++ b/net/smc/smc_tx.c
@@ -594,27 +594,32 @@ int smc_tx_sndbuf_nonempty(struct smc_connection *conn)
        return rc;
 }
 
-/* Wakeup sndbuf consumers from process context
- * since there is more data to transmit
- */
-void smc_tx_work(struct work_struct *work)
+void smc_tx_pending(struct smc_connection *conn)
 {
-       struct smc_connection *conn = container_of(to_delayed_work(work),
-                                                  struct smc_connection,
-                                                  tx_work);
        struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
        int rc;
 
-       lock_sock(&smc->sk);
        if (smc->sk.sk_err)
-               goto out;
+               return;
 
        rc = smc_tx_sndbuf_nonempty(conn);
        if (!rc && conn->local_rx_ctrl.prod_flags.write_blocked &&
            !atomic_read(&conn->bytes_to_rcv))
                conn->local_rx_ctrl.prod_flags.write_blocked = 0;
+}
+
+/* Wakeup sndbuf consumers from process context
+ * since there is more data to transmit
+ */
+void smc_tx_work(struct work_struct *work)
+{
+       struct smc_connection *conn = container_of(to_delayed_work(work),
+                                                  struct smc_connection,
+                                                  tx_work);
+       struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
 
-out:
+       lock_sock(&smc->sk);
+       smc_tx_pending(conn);
        release_sock(&smc->sk);
 }
 

diff --git a/net/smc/smc_tx.h b/net/smc/smc_tx.h
index 07e6ad76224a0cd1b2fe5bb91d7acaa4eb977534..a59f370b8b43279adc4437c64938ff2fc419623a 100644 (file)
--- a/net/smc/smc_tx.h
+++ b/net/smc/smc_tx.h
@@ -27,6 +27,7 @@ static inline int smc_tx_prepared_sends(struct smc_connection *conn)
        return smc_curs_diff(conn->sndbuf_desc->len, &sent, &prep);
 }
 
+void smc_tx_pending(struct smc_connection *conn);
 void smc_tx_work(struct work_struct *work);
 void smc_tx_init(struct smc_sock *smc);
 int smc_tx_sendmsg(struct smc_sock *smc, struct msghdr *msg, size_t len);