mptcp: fix full TCP keep-alive support

SO_KEEPALIVE support has been added a while ago, as part of a series
"adding SOL_SOCKET" support. To have a full control of this keep-alive
feature, it is important to also support TCP_KEEP* socket options at the
SOL_TCP level.

Supporting them on the setsockopt() part is easy, it is just a matter of
remembering each value in the MPTCP sock structure, and calling
tcp_sock_set_keep*() helpers on each subflow. If the value is not
modified (0), calling these helpers will not do anything. For the
getsockopt() part, the corresponding value from the MPTCP sock structure
or the default one is simply returned. All of this is very similar to
other TCP_* socket options supported by MPTCP.

It looks important for kernels supporting SO_KEEPALIVE, to also support
TCP_KEEP* options as well: some apps seem to (wrongly) consider that if
the former is supported, the latter ones will be supported as well. But
also, not having this simple and isolated change is preventing MPTCP
support in some apps, and libraries like GoLang [1]. This is why this
patch is seen as a fix.

Closes: https://github.com/multipath-tcp/mptcp_net-next/issues/383
Fixes: 1b3e7ede1365 ("mptcp: setsockopt: handle SO_KEEPALIVE and SO_PRIORITY")
Link: https://github.com/golang/go/issues/56539
Acked-by: Paolo Abeni <pabeni@redhat.com>
Signed-off-by: Matthieu Baerts (NGI0) <matttbe@kernel.org>
Signed-off-by: Mat Martineau <martineau@kernel.org>
Link: https://lore.kernel.org/r/20240514011335.176158-3-martineau@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h
index cfc5f9c3f1134892b028cb4156306ce74dc54118..4dcce3641d1d95609a7f335c077e0415f7643636 100644 (file)
--- a/net/mptcp/protocol.h
+++ b/net/mptcp/protocol.h
@@ -312,6 +312,9 @@ struct mptcp_sock {
                        free_first:1,
                        rcvspace_init:1;
        u32             notsent_lowat;
+       int             keepalive_cnt;
+       int             keepalive_idle;
+       int             keepalive_intvl;
        struct work_struct work;
        struct sk_buff  *ooo_last_skb;
        struct rb_root  out_of_order_queue;

diff --git a/net/mptcp/sockopt.c b/net/mptcp/sockopt.c
index 5ab506c966092d6b50452d25a6c6cff3a3f4eab9..fcca9433c85839dee4a613b655c812c17be19c66 100644 (file)
--- a/net/mptcp/sockopt.c
+++ b/net/mptcp/sockopt.c
@@ -622,6 +622,31 @@ static int mptcp_setsockopt_sol_tcp_congestion(struct mptcp_sock *msk, sockptr_t
        return ret;
 }
 
+static int __mptcp_setsockopt_set_val(struct mptcp_sock *msk, int max,
+                                     int (*set_val)(struct sock *, int),
+                                     int *msk_val, int val)
+{
+       struct mptcp_subflow_context *subflow;
+       int err = 0;
+
+       mptcp_for_each_subflow(msk, subflow) {
+               struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
+               int ret;
+
+               lock_sock(ssk);
+               ret = set_val(ssk, val);
+               err = err ? : ret;
+               release_sock(ssk);
+       }
+
+       if (!err) {
+               *msk_val = val;
+               sockopt_seq_inc(msk);
+       }
+
+       return err;
+}
+
 static int __mptcp_setsockopt_sol_tcp_cork(struct mptcp_sock *msk, int val)
 {
        struct mptcp_subflow_context *subflow;
@@ -818,6 +843,22 @@ static int mptcp_setsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
        case TCP_NODELAY:
                ret = __mptcp_setsockopt_sol_tcp_nodelay(msk, val);
                break;
+       case TCP_KEEPIDLE:
+               ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPIDLE,
+                                                &tcp_sock_set_keepidle_locked,
+                                                &msk->keepalive_idle, val);
+               break;
+       case TCP_KEEPINTVL:
+               ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPINTVL,
+                                                &tcp_sock_set_keepintvl,
+                                                &msk->keepalive_intvl, val);
+               break;
+       case TCP_KEEPCNT:
+               ret = __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPCNT,
+                                                &tcp_sock_set_keepcnt,
+                                                &msk->keepalive_cnt,
+                                                val);
+               break;
        default:
                ret = -ENOPROTOOPT;
        }
@@ -1326,6 +1367,8 @@ static int mptcp_put_int_option(struct mptcp_sock *msk, char __user *optval,
 static int mptcp_getsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
                                    char __user *optval, int __user *optlen)
 {
+       struct sock *sk = (void *)msk;
+
        switch (optname) {
        case TCP_ULP:
        case TCP_CONGESTION:
@@ -1344,6 +1387,18 @@ static int mptcp_getsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
                return mptcp_put_int_option(msk, optval, optlen, msk->cork);
        case TCP_NODELAY:
                return mptcp_put_int_option(msk, optval, optlen, msk->nodelay);
+       case TCP_KEEPIDLE:
+               return mptcp_put_int_option(msk, optval, optlen,
+                                           msk->keepalive_idle ? :
+                                           READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_time) / HZ);
+       case TCP_KEEPINTVL:
+               return mptcp_put_int_option(msk, optval, optlen,
+                                           msk->keepalive_intvl ? :
+                                           READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_intvl) / HZ);
+       case TCP_KEEPCNT:
+               return mptcp_put_int_option(msk, optval, optlen,
+                                           msk->keepalive_cnt ? :
+                                           READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_keepalive_probes));
        case TCP_NOTSENT_LOWAT:
                return mptcp_put_int_option(msk, optval, optlen, msk->notsent_lowat);
        case TCP_IS_MPTCP:
@@ -1463,6 +1518,9 @@ static void sync_socket_options(struct mptcp_sock *msk, struct sock *ssk)
                tcp_set_congestion_control(ssk, msk->ca_name, false, true);
        __tcp_sock_set_cork(ssk, !!msk->cork);
        __tcp_sock_set_nodelay(ssk, !!msk->nodelay);
+       tcp_sock_set_keepidle_locked(ssk, msk->keepalive_idle);
+       tcp_sock_set_keepintvl(ssk, msk->keepalive_intvl);
+       tcp_sock_set_keepcnt(ssk, msk->keepalive_cnt);
 
        inet_assign_bit(TRANSPARENT, ssk, inet_test_bit(TRANSPARENT, sk));
        inet_assign_bit(FREEBIND, ssk, inet_test_bit(FREEBIND, sk));