From 59ba30af8b9bfa1074493e772890491059b7f27a Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Wed, 12 Jun 2024 14:55:41 +0200 Subject: [PATCH] 6.6-stable patches added patches: erofs-avoid-allocating-deflate-streams-before-mounting.patch mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch mptcp-cleanup-sol_tcp-handling.patch mptcp-fix-full-tcp-keep-alive-support.patch --- ...ting-deflate-streams-before-mounting.patch | 110 ++++++++++++ ...icate-code-in-socket-option-handling.patch | 65 ++++++++ .../mptcp-cleanup-sol_tcp-handling.patch | 144 ++++++++++++++++ ...ptcp-fix-full-tcp-keep-alive-support.patch | 156 ++++++++++++++++++ queue-6.6/series | 4 + 5 files changed, 479 insertions(+) create mode 100644 queue-6.6/erofs-avoid-allocating-deflate-streams-before-mounting.patch create mode 100644 queue-6.6/mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch create mode 100644 queue-6.6/mptcp-cleanup-sol_tcp-handling.patch create mode 100644 queue-6.6/mptcp-fix-full-tcp-keep-alive-support.patch diff --git a/queue-6.6/erofs-avoid-allocating-deflate-streams-before-mounting.patch b/queue-6.6/erofs-avoid-allocating-deflate-streams-before-mounting.patch new file mode 100644 index 00000000000..1d8ccb87a00 --- /dev/null +++ b/queue-6.6/erofs-avoid-allocating-deflate-streams-before-mounting.patch @@ -0,0 +1,110 @@ +From 80eb4f62056d6ae709bdd0636ab96ce660f494b2 Mon Sep 17 00:00:00 2001 +From: Gao Xiang +Date: Mon, 20 May 2024 17:01:06 +0800 +Subject: erofs: avoid allocating DEFLATE streams before mounting + +From: Gao Xiang + +commit 80eb4f62056d6ae709bdd0636ab96ce660f494b2 upstream. + +Currently, each DEFLATE stream takes one 32 KiB permanent internal +window buffer even if there is no running instance which uses DEFLATE +algorithm. + +It's unexpected and wasteful on embedded devices with limited resources +and servers with hundreds of CPU cores if DEFLATE is enabled but unused. + +Fixes: ffa09b3bd024 ("erofs: DEFLATE compression support") +Cc: # 6.6+ +Reviewed-by: Sandeep Dhavale +Signed-off-by: Gao Xiang +Link: https://lore.kernel.org/r/20240520090106.2898681-1-hsiangkao@linux.alibaba.com +[ Gao Xiang: resolve trivial conflicts. ] +Signed-off-by: Gao Xiang +Signed-off-by: Greg Kroah-Hartman +--- + fs/erofs/decompressor_deflate.c | 57 +++++++++++++++++++++------------------- + 1 file changed, 30 insertions(+), 27 deletions(-) + +--- a/fs/erofs/decompressor_deflate.c ++++ b/fs/erofs/decompressor_deflate.c +@@ -47,39 +47,15 @@ int __init z_erofs_deflate_init(void) + /* by default, use # of possible CPUs instead */ + if (!z_erofs_deflate_nstrms) + z_erofs_deflate_nstrms = num_possible_cpus(); +- +- for (; z_erofs_deflate_avail_strms < z_erofs_deflate_nstrms; +- ++z_erofs_deflate_avail_strms) { +- struct z_erofs_deflate *strm; +- +- strm = kzalloc(sizeof(*strm), GFP_KERNEL); +- if (!strm) +- goto out_failed; +- +- /* XXX: in-kernel zlib cannot shrink windowbits currently */ +- strm->z.workspace = vmalloc(zlib_inflate_workspacesize()); +- if (!strm->z.workspace) { +- kfree(strm); +- goto out_failed; +- } +- +- spin_lock(&z_erofs_deflate_lock); +- strm->next = z_erofs_deflate_head; +- z_erofs_deflate_head = strm; +- spin_unlock(&z_erofs_deflate_lock); +- } + return 0; +- +-out_failed: +- pr_err("failed to allocate zlib workspace\n"); +- z_erofs_deflate_exit(); +- return -ENOMEM; + } + + int z_erofs_load_deflate_config(struct super_block *sb, + struct erofs_super_block *dsb, void *data, int size) + { + struct z_erofs_deflate_cfgs *dfl = data; ++ static DEFINE_MUTEX(deflate_resize_mutex); ++ static bool inited; + + if (!dfl || size < sizeof(struct z_erofs_deflate_cfgs)) { + erofs_err(sb, "invalid deflate cfgs, size=%u", size); +@@ -90,9 +66,36 @@ int z_erofs_load_deflate_config(struct s + erofs_err(sb, "unsupported windowbits %u", dfl->windowbits); + return -EOPNOTSUPP; + } +- ++ mutex_lock(&deflate_resize_mutex); ++ if (!inited) { ++ for (; z_erofs_deflate_avail_strms < z_erofs_deflate_nstrms; ++ ++z_erofs_deflate_avail_strms) { ++ struct z_erofs_deflate *strm; ++ ++ strm = kzalloc(sizeof(*strm), GFP_KERNEL); ++ if (!strm) ++ goto failed; ++ /* XXX: in-kernel zlib cannot customize windowbits */ ++ strm->z.workspace = vmalloc(zlib_inflate_workspacesize()); ++ if (!strm->z.workspace) { ++ kfree(strm); ++ goto failed; ++ } ++ ++ spin_lock(&z_erofs_deflate_lock); ++ strm->next = z_erofs_deflate_head; ++ z_erofs_deflate_head = strm; ++ spin_unlock(&z_erofs_deflate_lock); ++ } ++ inited = true; ++ } ++ mutex_unlock(&deflate_resize_mutex); + erofs_info(sb, "EXPERIMENTAL DEFLATE feature in use. Use at your own risk!"); + return 0; ++failed: ++ mutex_unlock(&deflate_resize_mutex); ++ z_erofs_deflate_exit(); ++ return -ENOMEM; + } + + int z_erofs_deflate_decompress(struct z_erofs_decompress_req *rq, diff --git a/queue-6.6/mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch b/queue-6.6/mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch new file mode 100644 index 00000000000..e68585221e1 --- /dev/null +++ b/queue-6.6/mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch @@ -0,0 +1,65 @@ +From stable+bounces-47623-greg=kroah.com@vger.kernel.org Wed May 29 11:58:36 2024 +From: "Matthieu Baerts (NGI0)" +Date: Wed, 29 May 2024 11:58:19 +0200 +Subject: mptcp: avoid some duplicate code in socket option handling +To: mptcp@lists.linux.dev, stable@vger.kernel.org, gregkh@linuxfoundation.org, sashal@kernel.org +Cc: Paolo Abeni , Mat Martineau , Matthieu Baerts , "David S . Miller" +Message-ID: <20240529095817.3370953-6-matttbe@kernel.org> + +From: Paolo Abeni + +commit a74762675f700a5473ebe54a671a0788a5b23cc9 upstream. + +The mptcp_get_int_option() helper is needless open-coded in a +couple of places, replace the duplicate code with the helper +call. + +Signed-off-by: Paolo Abeni +Reviewed-by: Mat Martineau +Signed-off-by: Matthieu Baerts (NGI0) +Signed-off-by: David S. Miller +Stable-dep-of: bd11dc4fb969 ("mptcp: fix full TCP keep-alive support") +Signed-off-by: Matthieu Baerts (NGI0) +Signed-off-by: Greg Kroah-Hartman +--- + net/mptcp/sockopt.c | 20 ++++++++------------ + 1 file changed, 8 insertions(+), 12 deletions(-) + +--- a/net/mptcp/sockopt.c ++++ b/net/mptcp/sockopt.c +@@ -626,13 +626,11 @@ static int mptcp_setsockopt_sol_tcp_cork + { + struct mptcp_subflow_context *subflow; + struct sock *sk = (struct sock *)msk; +- int val; ++ int val, ret; + +- if (optlen < sizeof(int)) +- return -EINVAL; +- +- if (copy_from_sockptr(&val, optval, sizeof(val))) +- return -EFAULT; ++ ret = mptcp_get_int_option(msk, optval, optlen, &val); ++ if (ret) ++ return ret; + + lock_sock(sk); + sockopt_seq_inc(msk); +@@ -656,13 +654,11 @@ static int mptcp_setsockopt_sol_tcp_node + { + struct mptcp_subflow_context *subflow; + struct sock *sk = (struct sock *)msk; +- int val; +- +- if (optlen < sizeof(int)) +- return -EINVAL; ++ int val, ret; + +- if (copy_from_sockptr(&val, optval, sizeof(val))) +- return -EFAULT; ++ ret = mptcp_get_int_option(msk, optval, optlen, &val); ++ if (ret) ++ return ret; + + lock_sock(sk); + sockopt_seq_inc(msk); diff --git a/queue-6.6/mptcp-cleanup-sol_tcp-handling.patch b/queue-6.6/mptcp-cleanup-sol_tcp-handling.patch new file mode 100644 index 00000000000..ce6ef4452e6 --- /dev/null +++ b/queue-6.6/mptcp-cleanup-sol_tcp-handling.patch @@ -0,0 +1,144 @@ +From stable+bounces-47624-greg=kroah.com@vger.kernel.org Wed May 29 11:58:39 2024 +From: "Matthieu Baerts (NGI0)" +Date: Wed, 29 May 2024 11:58:20 +0200 +Subject: mptcp: cleanup SOL_TCP handling +To: mptcp@lists.linux.dev, stable@vger.kernel.org, gregkh@linuxfoundation.org, sashal@kernel.org +Cc: Paolo Abeni , Mat Martineau , Matthieu Baerts , "David S . Miller" +Message-ID: <20240529095817.3370953-7-matttbe@kernel.org> + +From: Paolo Abeni + +commit 7f71a337b5152ea0e7bef408d1af53778a919316 upstream. + +Most TCP-level socket options get an integer from user space, and +set the corresponding field under the msk-level socket lock. + +Reduce the code duplication moving such operations in the common code. + +Signed-off-by: Paolo Abeni +Reviewed-by: Mat Martineau +Signed-off-by: Matthieu Baerts (NGI0) +Signed-off-by: David S. Miller +Stable-dep-of: bd11dc4fb969 ("mptcp: fix full TCP keep-alive support") +[ Without TCP_NOTSENT_LOWAT support, as it is not in this version, see + commit 29b5e5ef8739 ("mptcp: implement TCP_NOTSENT_LOWAT support") ] +Signed-off-by: Matthieu Baerts (NGI0) +Signed-off-by: Greg Kroah-Hartman +--- + net/mptcp/sockopt.c | 61 ++++++++++++++++++++++------------------------------ + 1 file changed, 26 insertions(+), 35 deletions(-) + +--- a/net/mptcp/sockopt.c ++++ b/net/mptcp/sockopt.c +@@ -621,18 +621,11 @@ static int mptcp_setsockopt_sol_tcp_cong + return ret; + } + +-static int mptcp_setsockopt_sol_tcp_cork(struct mptcp_sock *msk, sockptr_t optval, +- unsigned int optlen) ++static int __mptcp_setsockopt_sol_tcp_cork(struct mptcp_sock *msk, int val) + { + struct mptcp_subflow_context *subflow; + struct sock *sk = (struct sock *)msk; +- int val, ret; + +- ret = mptcp_get_int_option(msk, optval, optlen, &val); +- if (ret) +- return ret; +- +- lock_sock(sk); + sockopt_seq_inc(msk); + msk->cork = !!val; + mptcp_for_each_subflow(msk, subflow) { +@@ -644,23 +637,15 @@ static int mptcp_setsockopt_sol_tcp_cork + } + if (!val) + mptcp_check_and_set_pending(sk); +- release_sock(sk); + + return 0; + } + +-static int mptcp_setsockopt_sol_tcp_nodelay(struct mptcp_sock *msk, sockptr_t optval, +- unsigned int optlen) ++static int __mptcp_setsockopt_sol_tcp_nodelay(struct mptcp_sock *msk, int val) + { + struct mptcp_subflow_context *subflow; + struct sock *sk = (struct sock *)msk; +- int val, ret; +- +- ret = mptcp_get_int_option(msk, optval, optlen, &val); +- if (ret) +- return ret; + +- lock_sock(sk); + sockopt_seq_inc(msk); + msk->nodelay = !!val; + mptcp_for_each_subflow(msk, subflow) { +@@ -672,8 +657,6 @@ static int mptcp_setsockopt_sol_tcp_node + } + if (val) + mptcp_check_and_set_pending(sk); +- release_sock(sk); +- + return 0; + } + +@@ -786,25 +769,10 @@ static int mptcp_setsockopt_sol_tcp(stru + int ret, val; + + switch (optname) { +- case TCP_INQ: +- ret = mptcp_get_int_option(msk, optval, optlen, &val); +- if (ret) +- return ret; +- if (val < 0 || val > 1) +- return -EINVAL; +- +- lock_sock(sk); +- msk->recvmsg_inq = !!val; +- release_sock(sk); +- return 0; + case TCP_ULP: + return -EOPNOTSUPP; + case TCP_CONGESTION: + return mptcp_setsockopt_sol_tcp_congestion(msk, optval, optlen); +- case TCP_CORK: +- return mptcp_setsockopt_sol_tcp_cork(msk, optval, optlen); +- case TCP_NODELAY: +- return mptcp_setsockopt_sol_tcp_nodelay(msk, optval, optlen); + case TCP_DEFER_ACCEPT: + /* See tcp.c: TCP_DEFER_ACCEPT does not fail */ + mptcp_setsockopt_first_sf_only(msk, SOL_TCP, optname, optval, optlen); +@@ -817,7 +785,30 @@ static int mptcp_setsockopt_sol_tcp(stru + optval, optlen); + } + +- return -EOPNOTSUPP; ++ ret = mptcp_get_int_option(msk, optval, optlen, &val); ++ if (ret) ++ return ret; ++ ++ lock_sock(sk); ++ switch (optname) { ++ case TCP_INQ: ++ if (val < 0 || val > 1) ++ ret = -EINVAL; ++ else ++ msk->recvmsg_inq = !!val; ++ break; ++ case TCP_CORK: ++ ret = __mptcp_setsockopt_sol_tcp_cork(msk, val); ++ break; ++ case TCP_NODELAY: ++ ret = __mptcp_setsockopt_sol_tcp_nodelay(msk, val); ++ break; ++ default: ++ ret = -ENOPROTOOPT; ++ } ++ ++ release_sock(sk); ++ return ret; + } + + int mptcp_setsockopt(struct sock *sk, int level, int optname, diff --git a/queue-6.6/mptcp-fix-full-tcp-keep-alive-support.patch b/queue-6.6/mptcp-fix-full-tcp-keep-alive-support.patch new file mode 100644 index 00000000000..d8cb16c153b --- /dev/null +++ b/queue-6.6/mptcp-fix-full-tcp-keep-alive-support.patch @@ -0,0 +1,156 @@ +From stable+bounces-47625-greg=kroah.com@vger.kernel.org Wed May 29 11:58:44 2024 +From: "Matthieu Baerts (NGI0)" +Date: Wed, 29 May 2024 11:58:21 +0200 +Subject: mptcp: fix full TCP keep-alive support +To: mptcp@lists.linux.dev, stable@vger.kernel.org, gregkh@linuxfoundation.org, sashal@kernel.org +Cc: "Matthieu Baerts (NGI0)" , Paolo Abeni , Mat Martineau , Jakub Kicinski +Message-ID: <20240529095817.3370953-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_PRIORITY") +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") is not in this version ] +Signed-off-by: Matthieu Baerts (NGI0) +Signed-off-by: Greg Kroah-Hartman +--- + net/mptcp/protocol.h | 3 ++ + net/mptcp/sockopt.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 61 insertions(+) + +--- a/net/mptcp/protocol.h ++++ b/net/mptcp/protocol.h +@@ -303,6 +303,9 @@ struct mptcp_sock { + in_accept_queue:1, + free_first:1, + rcvspace_init: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 +@@ -621,6 +621,31 @@ static int mptcp_setsockopt_sol_tcp_cong + 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; +@@ -803,6 +828,22 @@ static int mptcp_setsockopt_sol_tcp(stru + 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; + } +@@ -1303,6 +1344,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 = (void *)msk; ++ + switch (optname) { + case TCP_ULP: + case TCP_CONGESTION: +@@ -1321,6 +1364,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; + } +@@ -1430,6 +1485,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); + + inet_assign_bit(TRANSPARENT, ssk, inet_test_bit(TRANSPARENT, sk)); + inet_assign_bit(FREEBIND, ssk, inet_test_bit(FREEBIND, sk)); diff --git a/queue-6.6/series b/queue-6.6/series index 0bdf7bdf9d1..e9edd25a880 100644 --- a/queue-6.6/series +++ b/queue-6.6/series @@ -3,3 +3,7 @@ mmc-core-do-not-force-a-retune-before-rpmb-switch.patch afs-don-t-cross-.backup-mountpoint-from-backup-volume.patch net-sfp-bus-fix-sfp-mode-detect-from-bitrate.patch riscv-signal-handle-syscall-restart-before-get_signal.patch +mptcp-avoid-some-duplicate-code-in-socket-option-handling.patch +mptcp-cleanup-sol_tcp-handling.patch +mptcp-fix-full-tcp-keep-alive-support.patch +erofs-avoid-allocating-deflate-streams-before-mounting.patch -- 2.47.3