queue-6.6/mptcp-don-t-overwrite-sock_ops-in-mptcp_is_tcpsk.patch

   1 From 8e2b8a9fa512709e6fee744dcd4e2a20ee7f5c56 Mon Sep 17 00:00:00 2001
   2 From: Davide Caratti <dcaratti@redhat.com>
   3 Date: Tue, 19 Dec 2023 22:31:04 +0100
   4 Subject: mptcp: don't overwrite sock_ops in mptcp_is_tcpsk()
   5
   6 From: Davide Caratti <dcaratti@redhat.com>
   7
   8 commit 8e2b8a9fa512709e6fee744dcd4e2a20ee7f5c56 upstream.
   9
  10 Eric Dumazet suggests:
  11
  12  > The fact that mptcp_is_tcpsk() was able to write over sock->ops was a
  13  > bit strange to me.
  14  > mptcp_is_tcpsk() should answer a question, with a read-only argument.
  15
  16 re-factor code to avoid overwriting sock_ops inside that function. Also,
  17 change the helper name to reflect the semantics and to disambiguate from
  18 its dual, sk_is_mptcp(). While at it, collapse mptcp_stream_accept() and
  19 mptcp_accept() into a single function, where fallback / non-fallback are
  20 separated into a single sk_is_mptcp() conditional.
  21
  22 Link: https://github.com/multipath-tcp/mptcp_net-next/issues/432
  23 Suggested-by: Eric Dumazet <edumazet@google.com>
  24 Signed-off-by: Davide Caratti <dcaratti@redhat.com>
  25 Acked-by: Paolo Abeni <pabeni@redhat.com>
  26 Signed-off-by: Matthieu Baerts <matttbe@kernel.org>
  27 Signed-off-by: David S. Miller <davem@davemloft.net>
  28 Signed-off-by: Matthieu Baerts (NGI0) <matttbe@kernel.org>
  29 Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
  30 ---
  31  net/mptcp/protocol.c |  108 ++++++++++++++++++++-------------------------------
  32  1 file changed, 44 insertions(+), 64 deletions(-)
  33
  34 --- a/net/mptcp/protocol.c
  35 +++ b/net/mptcp/protocol.c
  36 @@ -55,28 +55,14 @@ static u64 mptcp_wnd_end(const struct mp
  37         return READ_ONCE(msk->wnd_end);
  38  }
  39
  40 -static bool mptcp_is_tcpsk(struct sock *sk)
  41 +static const struct proto_ops *mptcp_fallback_tcp_ops(const struct sock *sk)
  42  {
  43 -       struct socket *sock = sk->sk_socket;
  44 -
  45 -       if (unlikely(sk->sk_prot == &tcp_prot)) {
  46 -               /* we are being invoked after mptcp_accept() has
  47 -                * accepted a non-mp-capable flow: sk is a tcp_sk,
  48 -                * not an mptcp one.
  49 -                *
  50 -                * Hand the socket over to tcp so all further socket ops
  51 -                * bypass mptcp.
  52 -                */
  53 -               WRITE_ONCE(sock->ops, &inet_stream_ops);
  54 -               return true;
  55  #if IS_ENABLED(CONFIG_MPTCP_IPV6)
  56 -       } else if (unlikely(sk->sk_prot == &tcpv6_prot)) {
  57 -               WRITE_ONCE(sock->ops, &inet6_stream_ops);
  58 -               return true;
  59 +       if (sk->sk_prot == &tcpv6_prot)
  60 +               return &inet6_stream_ops;
  61  #endif
  62 -       }
  63 -
  64 -       return false;
  65 +       WARN_ON_ONCE(sk->sk_prot != &tcp_prot);
  66 +       return &inet_stream_ops;
  67  }
  68
  69  static int __mptcp_socket_create(struct mptcp_sock *msk)
  70 @@ -3328,44 +3314,6 @@ void mptcp_rcv_space_init(struct mptcp_s
  71                 msk->rcvq_space.space = TCP_INIT_CWND * TCP_MSS_DEFAULT;
  72  }
  73
  74 -static struct sock *mptcp_accept(struct sock *ssk, int flags, int *err,
  75 -                                bool kern)
  76 -{
  77 -       struct sock *newsk;
  78 -
  79 -       pr_debug("ssk=%p, listener=%p", ssk, mptcp_subflow_ctx(ssk));
  80 -       newsk = inet_csk_accept(ssk, flags, err, kern);
  81 -       if (!newsk)
  82 -               return NULL;
  83 -
  84 -       pr_debug("newsk=%p, subflow is mptcp=%d", newsk, sk_is_mptcp(newsk));
  85 -       if (sk_is_mptcp(newsk)) {
  86 -               struct mptcp_subflow_context *subflow;
  87 -               struct sock *new_mptcp_sock;
  88 -
  89 -               subflow = mptcp_subflow_ctx(newsk);
  90 -               new_mptcp_sock = subflow->conn;
  91 -
  92 -               /* is_mptcp should be false if subflow->conn is missing, see
  93 -                * subflow_syn_recv_sock()
  94 -                */
  95 -               if (WARN_ON_ONCE(!new_mptcp_sock)) {
  96 -                       tcp_sk(newsk)->is_mptcp = 0;
  97 -                       goto out;
  98 -               }
  99 -
 100 -               newsk = new_mptcp_sock;
 101 -               MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_MPCAPABLEPASSIVEACK);
 102 -       } else {
 103 -               MPTCP_INC_STATS(sock_net(ssk),
 104 -                               MPTCP_MIB_MPCAPABLEPASSIVEFALLBACK);
 105 -       }
 106 -
 107 -out:
 108 -       newsk->sk_kern_sock = kern;
 109 -       return newsk;
 110 -}
 111 -
 112  void mptcp_destroy_common(struct mptcp_sock *msk, unsigned int flags)
 113  {
 114         struct mptcp_subflow_context *subflow, *tmp;
 115 @@ -3802,7 +3750,6 @@ static struct proto mptcp_prot = {
 116         .connect        = mptcp_connect,
 117         .disconnect     = mptcp_disconnect,
 118         .close          = mptcp_close,
 119 -       .accept         = mptcp_accept,
 120         .setsockopt     = mptcp_setsockopt,
 121         .getsockopt     = mptcp_getsockopt,
 122         .shutdown       = mptcp_shutdown,
 123 @@ -3912,18 +3859,36 @@ static int mptcp_stream_accept(struct so
 124         if (!ssk)
 125                 return -EINVAL;
 126
 127 -       newsk = mptcp_accept(ssk, flags, &err, kern);
 128 +       pr_debug("ssk=%p, listener=%p", ssk, mptcp_subflow_ctx(ssk));
 129 +       newsk = inet_csk_accept(ssk, flags, &err, kern);
 130         if (!newsk)
 131                 return err;
 132
 133 -       lock_sock(newsk);
 134 -
 135 -       __inet_accept(sock, newsock, newsk);
 136 -       if (!mptcp_is_tcpsk(newsock->sk)) {
 137 -               struct mptcp_sock *msk = mptcp_sk(newsk);
 138 +       pr_debug("newsk=%p, subflow is mptcp=%d", newsk, sk_is_mptcp(newsk));
 139 +       if (sk_is_mptcp(newsk)) {
 140                 struct mptcp_subflow_context *subflow;
 141 +               struct sock *new_mptcp_sock;
 142 +
 143 +               subflow = mptcp_subflow_ctx(newsk);
 144 +               new_mptcp_sock = subflow->conn;
 145 +
 146 +               /* is_mptcp should be false if subflow->conn is missing, see
 147 +                * subflow_syn_recv_sock()
 148 +                */
 149 +               if (WARN_ON_ONCE(!new_mptcp_sock)) {
 150 +                       tcp_sk(newsk)->is_mptcp = 0;
 151 +                       goto tcpfallback;
 152 +               }
 153 +
 154 +               newsk = new_mptcp_sock;
 155 +               MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_MPCAPABLEPASSIVEACK);
 156 +
 157 +               newsk->sk_kern_sock = kern;
 158 +               lock_sock(newsk);
 159 +               __inet_accept(sock, newsock, newsk);
 160
 161                 set_bit(SOCK_CUSTOM_SOCKOPT, &newsock->flags);
 162 +               msk = mptcp_sk(newsk);
 163                 msk->in_accept_queue = 0;
 164
 165                 /* set ssk->sk_socket of accept()ed flows to mptcp socket.
 166 @@ -3945,6 +3910,21 @@ static int mptcp_stream_accept(struct so
 167                         if (unlikely(list_is_singular(&msk->conn_list)))
 168                                 mptcp_set_state(newsk, TCP_CLOSE);
 169                 }
 170 +       } else {
 171 +               MPTCP_INC_STATS(sock_net(ssk),
 172 +                               MPTCP_MIB_MPCAPABLEPASSIVEFALLBACK);
 173 +tcpfallback:
 174 +               newsk->sk_kern_sock = kern;
 175 +               lock_sock(newsk);
 176 +               __inet_accept(sock, newsock, newsk);
 177 +               /* we are being invoked after accepting a non-mp-capable
 178 +                * flow: sk is a tcp_sk, not an mptcp one.
 179 +                *
 180 +                * Hand the socket over to tcp so all further socket ops
 181 +                * bypass mptcp.
 182 +                */
 183 +               WRITE_ONCE(newsock->sk->sk_socket->ops,
 184 +                          mptcp_fallback_tcp_ops(newsock->sk));
 185         }
 186         release_sock(newsk);
 187