From nobody Mon Sep 16 19:06:46 2024 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2F9E716C85B; Wed, 12 Jun 2024 12:55:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718196943; cv=none; b=aolEtczejCcHnxhmJ+U11H2lwlxwWB97FyYlQ5o0bgLOQUB/LidMm4Pycg7Z5NrAtPHNt4zbB/sU6vQ1LE1+Q11iEvJY+anOD7SjCWvN0PUH1fRrf4gNrtCZ6GRKAYAn7mVnvmUAaQMiNv36NQbVkv27UsDrc5s2U5mGqxavxxU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718196943; c=relaxed/simple; bh=Z69GMNHCn7CE4MuWDGlwFJrT2cCioB4/n8eGiH0Or4g=; h=Subject:To:Cc:From:Date:In-Reply-To:Message-ID:MIME-Version: Content-Type; b=qyXThHAVGILTcvuC+Xyit9Gr8EJsN0hbFCnNQb2/3czmDfqQZSZln+9yiYzBQ6ZW5uTqjDo9Z22h+eCzPHO0Unkn1tKPjuEGCcXXXeZkfC5nPQ61EIgtO7jAUGNQivvDbPGGgKbPpsRQIWsBCAnd+yO3gGdl8GRVyFAF4XzzEFw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linuxfoundation.org header.i=@linuxfoundation.org header.b=Z4ZMdBm1; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linuxfoundation.org header.i=@linuxfoundation.org header.b="Z4ZMdBm1" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4878BC3277B; Wed, 12 Jun 2024 12:55:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=linuxfoundation.org; s=korg; t=1718196942; bh=Z69GMNHCn7CE4MuWDGlwFJrT2cCioB4/n8eGiH0Or4g=; h=Subject:To:Cc:From:Date:In-Reply-To:From; b=Z4ZMdBm1XAvXN5e81v9Ounb8H9SNj2dyRNG2JrT/a7Pw3PQvhNVpjPDteoXkeMuif ui/nkiFpQefhqYPGoN4Guub9nAv/27Gy/Zqt5P2BkmqY/vge3SbXXeFQCJaLbu2hSG g8yfn3wT/tgODTz9ucIjWK85lzhnI0rxgIFYR17U= Subject: Patch "mptcp: fix full TCP keep-alive support" has been added to the 6.1-stable tree To: gregkh@linuxfoundation.org,kuba@kernel.org,martineau@kernel.org,matttbe@kernel.org,mptcp@lists.linux.dev,pabeni@redhat.com,sashal@kernel.org Cc: From: Date: Wed, 12 Jun 2024 14:55:32 +0200 In-Reply-To: <20240529100022.3373664-8-matttbe@kernel.org> Message-ID: <2024061232-monitor-life-3b94@gregkh> Precedence: bulk X-Mailing-List: mptcp@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-stable: commit X-Patchwork-Hint: ignore Content-Type: text/plain; charset="utf-8" This is a note to let you know that I've just added the patch titled mptcp: fix full TCP keep-alive support to the 6.1-stable tree which can be found at: http://www.kernel.org/git/?p=3Dlinux/kernel/git/stable/stable-queue.git= ;a=3Dsummary The filename of the patch is: mptcp-fix-full-tcp-keep-alive-support.patch and it can be found in the queue-6.1 subdirectory. If you, or anyone else, feels it should not be added to the stable tree, please let know about it. From stable+bounces-47629-greg=3Dkroah.com@vger.kernel.org Wed May 29 12:00= :40 2024 From: "Matthieu Baerts (NGI0)" Date: Wed, 29 May 2024 12:00:26 +0200 Subject: mptcp: fix full TCP keep-alive support To: mptcp@lists.linux.dev, stable@vger.kernel.org, gregkh@linuxfoundation.o= rg, sashal@kernel.org Cc: "Matthieu Baerts (NGI0)" , Paolo Abeni , Mat Martineau , Jakub Kicinski Message-ID: <20240529100022.3373664-8-matttbe@kernel.org> From: "Matthieu Baerts (NGI0)" commit bd11dc4fb969ec148e50cd87f88a78246dbc4d0b upstream. 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_PRIORIT= Y") Link: https://github.com/golang/go/issues/56539 [1] Acked-by: Paolo Abeni Signed-off-by: Matthieu Baerts (NGI0) Signed-off-by: Mat Martineau Link: https://lore.kernel.org/r/20240514011335.176158-3-martineau@kernel.org Signed-off-by: Jakub Kicinski [ Conflicts in the same context, because commit 29b5e5ef8739 ("mptcp: implement TCP_NOTSENT_LOWAT support") (new feature) and commit 013e3179dbd2 ("mptcp: fix rcv space initialization") (not backported because of the various conflicts, and because the race fixed by this commit "does not produce ill effects in practice") are not in this version. Also, TCP_KEEPINTVL and TCP_KEEPCNT value had to be set without lock, the same way it was done on TCP side prior commit 6fd70a6b4e6f ("tcp: set TCP_KEEPINTVL locklessly") and commit 84485080cbc1 ("tcp: set TCP_KEEPCNT locklessly"). ] Signed-off-by: Matthieu Baerts (NGI0) Signed-off-by: Greg Kroah-Hartman --- net/mptcp/protocol.h | 3 + net/mptcp/sockopt.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++= +++++ 2 files changed, 82 insertions(+) --- a/net/mptcp/protocol.h +++ b/net/mptcp/protocol.h @@ -288,6 +288,9 @@ struct mptcp_sock { fastopening:1, in_accept_queue:1, free_first:1; + 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; --- a/net/mptcp/sockopt.c +++ b/net/mptcp/sockopt.c @@ -616,6 +616,52 @@ static int mptcp_setsockopt_sol_tcp_cong return ret; } =20 +static int __tcp_sock_set_keepintvl(struct sock *sk, int val) +{ + if (val < 1 || val > MAX_TCP_KEEPINTVL) + return -EINVAL; + + WRITE_ONCE(tcp_sk(sk)->keepalive_intvl, val * HZ); + + return 0; +} + +static int __tcp_sock_set_keepcnt(struct sock *sk, int val) +{ + if (val < 1 || val > MAX_TCP_KEEPCNT) + return -EINVAL; + + /* Paired with READ_ONCE() in keepalive_probes() */ + WRITE_ONCE(tcp_sk(sk)->keepalive_probes, val); + + return 0; +} + +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 =3D 0; + + mptcp_for_each_subflow(msk, subflow) { + struct sock *ssk =3D mptcp_subflow_tcp_sock(subflow); + int ret; + + lock_sock(ssk); + ret =3D set_val(ssk, val); + err =3D err ? : ret; + release_sock(ssk); + } + + if (!err) { + *msk_val =3D 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; @@ -805,6 +851,22 @@ static int mptcp_setsockopt_sol_tcp(stru case TCP_NODELAY: ret =3D __mptcp_setsockopt_sol_tcp_nodelay(msk, val); break; + case TCP_KEEPIDLE: + ret =3D __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPIDLE, + &tcp_sock_set_keepidle_locked, + &msk->keepalive_idle, val); + break; + case TCP_KEEPINTVL: + ret =3D __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPINTVL, + &__tcp_sock_set_keepintvl, + &msk->keepalive_intvl, val); + break; + case TCP_KEEPCNT: + ret =3D __mptcp_setsockopt_set_val(msk, MAX_TCP_KEEPCNT, + &__tcp_sock_set_keepcnt, + &msk->keepalive_cnt, + val); + break; default: ret =3D -ENOPROTOOPT; } @@ -1163,6 +1225,8 @@ static int mptcp_put_int_option(struct m static int mptcp_getsockopt_sol_tcp(struct mptcp_sock *msk, int optname, char __user *optval, int __user *optlen) { + struct sock *sk =3D (void *)msk; + switch (optname) { case TCP_ULP: case TCP_CONGESTION: @@ -1178,6 +1242,18 @@ static int mptcp_getsockopt_sol_tcp(stru 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)); } return -EOPNOTSUPP; } @@ -1282,6 +1358,9 @@ static void sync_socket_options(struct m 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); =20 inet_sk(ssk)->transparent =3D inet_sk(sk)->transparent; inet_sk(ssk)->freebind =3D inet_sk(sk)->freebind; Patches currently in stable-queue which might be from kroah.com@vger.kernel= .org are queue-6.1/mptcp-fix-full-tcp-keep-alive-support.patch queue-6.1/mptcp-cleanup-sol_tcp-handling.patch queue-6.1/mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch