* [PATCH net-next v3 1/3] tcp: avoid wrapping Fast Open blackhole timeout
2026-11-16 16:46 [PATCH net-next v3 0/3] tcp/mptcp: prevent blackhole timeout arithmetic wraparound Yingjie Wang
@ 2026-11-16 16:46 ` Yingjie Wang
2026-11-20 21:29 ` Matthieu Baerts
2026-11-16 16:46 ` [PATCH net-next v3 2/3] mptcp: avoid wrapping " Yingjie Wang
2026-11-16 16:46 ` [PATCH net-next v3 3/3] mptcp: limit blackhole_timeout to one day Yingjie Wang
2 siblings, 1 reply; 7+ messages in thread
From: Yingjie Wang @ 2026-11-16 16:46 UTC (permalink / raw)
To: netdev@vger.kernel.org
Cc: mptcp@lists.linux.dev, linux-kernel@vger.kernel.org,
corbet@lwn.net, skhan@linuxfoundation.org, rdunlap@infradead.org,
linux-doc@vger.kernel.org, edumazet@kernel.org,
ncardwell@google.com, gang.yan@linux.dev, kuniyu@google.com,
davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org, matttbe@kernel.org, martineau@kernel.org,
geliang@kernel.org, ycheng@google.com, weiwan@google.com
tcp_fastopen_active_should_disable() calculates the active-disable
interval as multiplier * tfo_bh_timeout * HZ. Since all operands are
32-bit, a large tcp_fastopen_blackhole_timeout_sec can wrap the delay,
even on 64-bit kernels, and re-enable active Fast Open too soon.
With HZ=1000 and the maximum multiplier of 64, any timeout above 67108
seconds wraps. For example, 67109 seconds should produce 4,294,976,000
jiffies (about 50 days), but the calculation truncates it to 8,704
jiffies (8.7 seconds).
This issue was found using a static analysis tool. It was confirmed with
a loopback reproducer that induces 12 Fast Open blackholes and opens
another connection 10 seconds later: with a 67109 second timeout, the
unpatched kernel retried active Fast Open. The reproducer needs neither
kernel modifications nor error injection.
Compute the interval in u64 and cap it at MAX_JIFFY_OFFSET before adding
it to the saved timestamp. On 32-bit kernels, the cap keeps the interval
within the range that time_before() can compare, which limits the longest
backoff there to about 12.4 days at HZ=1000.
Also limit the writable initial timeout to one day, so the exponential
backoff does not start from an impractically long period. Writes above
86400 seconds, which were previously accepted, now fail with -EINVAL and
leave the current value unchanged. The wider calculation is still needed
below that limit, as the 67109 second example shows.
With this patch, the same reproducer kept active Fast Open disabled, and
the sysctl accepts 86400 and rejects 86401. The TCP selftests were not
run; none of them sets this sysctl.
Fixes: cf1ef3f0719b ("net/tcp_fastopen: Disable active side TFO in certain scenarios")
Signed-off-by: Yingjie Wang <x-professor@outlook.com>
---
Documentation/networking/ip-sysctl.rst | 1 +
net/ipv4/sysctl_net_ipv4.c | 1 +
net/ipv4/tcp_fastopen.c | 12 +++++++++---
3 files changed, 11 insertions(+), 3 deletions(-)
diff --git a/Documentation/networking/ip-sysctl.rst b/Documentation/networking/ip-sysctl.rst
index 0b7bfbd98a92..dc33f82a8997 100644
--- a/Documentation/networking/ip-sysctl.rst
+++ b/Documentation/networking/ip-sysctl.rst
@@ -1055,6 +1055,7 @@ tcp_fastopen_blackhole_timeout_sec - INTEGER
get detected right after Fastopen is re-enabled and will reset to
initial value when the blackhole issue goes away.
0 to disable the blackhole detection.
+ The maximum value is one day (86400 seconds).
By default, it is set to 0 (feature is disabled).
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 9df93ad219db..fb0f3124836d 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -1152,6 +1152,7 @@ static const struct ctl_table ipv4_net_table[] = {
.mode = 0644,
.proc_handler = proc_tfo_blackhole_detect_timeout,
.extra1 = SYSCTL_ZERO,
+ .extra2 = &one_day_secs,
},
#ifdef CONFIG_IP_ROUTE_MULTIPATH
{
diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
index 7f7eb3cc1c04..883f0f1e7e07 100644
--- a/net/ipv4/tcp_fastopen.c
+++ b/net/ipv4/tcp_fastopen.c
@@ -613,6 +613,7 @@ bool tcp_fastopen_active_should_disable(struct sock *sk)
unsigned long timeout;
int tfo_da_times;
int multiplier;
+ u64 delay;
if (!tfo_bh_timeout)
return false;
@@ -624,12 +625,17 @@ bool tcp_fastopen_active_should_disable(struct sock *sk)
/* Paired with smp_mb__before_atomic() in tcp_fastopen_active_disable() */
smp_rmb();
- /* Limit timeout to max: 2^6 * initial timeout */
+ /* Limit the backoff multiplier to 64. */
multiplier = 1 << min(tfo_da_times - 1, 6);
+ delay = (u64)multiplier * tfo_bh_timeout * HZ;
- /* Paired with the WRITE_ONCE() in tcp_fastopen_active_disable(). */
+ /*
+ * Cap the delay for safe jiffies comparisons on 32-bit systems.
+ * The timestamp read is paired with WRITE_ONCE() in
+ * tcp_fastopen_active_disable().
+ */
timeout = READ_ONCE(sock_net(sk)->ipv4.tfo_active_disable_stamp) +
- multiplier * tfo_bh_timeout * HZ;
+ min(delay, MAX_JIFFY_OFFSET);
if (time_before(jiffies, timeout))
return true;
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* Re: [PATCH net-next v3 1/3] tcp: avoid wrapping Fast Open blackhole timeout
2026-11-16 16:46 ` [PATCH net-next v3 1/3] tcp: avoid wrapping Fast Open blackhole timeout Yingjie Wang
@ 2026-11-20 21:29 ` Matthieu Baerts
0 siblings, 0 replies; 7+ messages in thread
From: Matthieu Baerts @ 2026-11-20 21:29 UTC (permalink / raw)
To: Yingjie Wang
Cc: netdev@vger.kernel.org, mptcp@lists.linux.dev,
linux-kernel@vger.kernel.org, corbet@lwn.net,
skhan@linuxfoundation.org, rdunlap@infradead.org,
linux-doc@vger.kernel.org, edumazet@kernel.org,
ncardwell@google.com, gang.yan@linux.dev, kuniyu@google.com,
davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org, martineau@kernel.org, geliang@kernel.org,
ycheng@google.com, weiwan@google.com
Hi Yingjie,
On 16/11/2026 17:46, Yingjie Wang wrote:
> tcp_fastopen_active_should_disable() calculates the active-disable
> interval as multiplier * tfo_bh_timeout * HZ. Since all operands are
> 32-bit, a large tcp_fastopen_blackhole_timeout_sec can wrap the delay,
> even on 64-bit kernels, and re-enable active Fast Open too soon.
>
> With HZ=1000 and the maximum multiplier of 64, any timeout above 67108
> seconds wraps. For example, 67109 seconds should produce 4,294,976,000
> jiffies (about 50 days), but the calculation truncates it to 8,704
> jiffies (8.7 seconds).
>
> This issue was found using a static analysis tool. It was confirmed with
> a loopback reproducer that induces 12 Fast Open blackholes and opens
> another connection 10 seconds later: with a 67109 second timeout, the
> unpatched kernel retried active Fast Open. The reproducer needs neither
> kernel modifications nor error injection.
>
> Compute the interval in u64 and cap it at MAX_JIFFY_OFFSET before adding
> it to the saved timestamp. On 32-bit kernels, the cap keeps the interval
> within the range that time_before() can compare, which limits the longest
> backoff there to about 12.4 days at HZ=1000.
>
> Also limit the writable initial timeout to one day, so the exponential
> backoff does not start from an impractically long period. Writes above
> 86400 seconds, which were previously accepted, now fail with -EINVAL and
> leave the current value unchanged. The wider calculation is still needed
> below that limit, as the 67109 second example shows.
>
> With this patch, the same reproducer kept active Fast Open disabled, and
> the sysctl accepts 86400 and rejects 86401. The TCP selftests were not
> run; none of them sets this sysctl.
>
> Fixes: cf1ef3f0719b ("net/tcp_fastopen: Disable active side TFO in certain scenarios")
I guess you can drop the Fixes tag, not to backport this to stable as it
somehow changes the behaviour as Eric said in the v2. Same ton the later
patches.
> Signed-off-by: Yingjie Wang <x-professor@outlook.com>
> ---
> Documentation/networking/ip-sysctl.rst | 1 +
> net/ipv4/sysctl_net_ipv4.c | 1 +
> net/ipv4/tcp_fastopen.c | 12 +++++++++---
> 3 files changed, 11 insertions(+), 3 deletions(-)
>
> diff --git a/Documentation/networking/ip-sysctl.rst b/Documentation/networking/ip-sysctl.rst
> index 0b7bfbd98a92..dc33f82a8997 100644
> --- a/Documentation/networking/ip-sysctl.rst
> +++ b/Documentation/networking/ip-sysctl.rst
> @@ -1055,6 +1055,7 @@ tcp_fastopen_blackhole_timeout_sec - INTEGER
> get detected right after Fastopen is re-enabled and will reset to
> initial value when the blackhole issue goes away.
> 0 to disable the blackhole detection.
> + The maximum value is one day (86400 seconds).
>
> By default, it is set to 0 (feature is disabled).
>
> diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
> index 9df93ad219db..fb0f3124836d 100644
> --- a/net/ipv4/sysctl_net_ipv4.c
> +++ b/net/ipv4/sysctl_net_ipv4.c
> @@ -1152,6 +1152,7 @@ static const struct ctl_table ipv4_net_table[] = {
> .mode = 0644,
> .proc_handler = proc_tfo_blackhole_detect_timeout,
> .extra1 = SYSCTL_ZERO,
> + .extra2 = &one_day_secs,
> },
> #ifdef CONFIG_IP_ROUTE_MULTIPATH
> {
> diff --git a/net/ipv4/tcp_fastopen.c b/net/ipv4/tcp_fastopen.c
> index 7f7eb3cc1c04..883f0f1e7e07 100644
> --- a/net/ipv4/tcp_fastopen.c
> +++ b/net/ipv4/tcp_fastopen.c
> @@ -613,6 +613,7 @@ bool tcp_fastopen_active_should_disable(struct sock *sk)
> unsigned long timeout;
> int tfo_da_times;
> int multiplier;
> + u64 delay;
>
> if (!tfo_bh_timeout)
> return false;
> @@ -624,12 +625,17 @@ bool tcp_fastopen_active_should_disable(struct sock *sk)
> /* Paired with smp_mb__before_atomic() in tcp_fastopen_active_disable() */
> smp_rmb();
>
> - /* Limit timeout to max: 2^6 * initial timeout */
> + /* Limit the backoff multiplier to 64. */
> multiplier = 1 << min(tfo_da_times - 1, 6);
> + delay = (u64)multiplier * tfo_bh_timeout * HZ;
>
> - /* Paired with the WRITE_ONCE() in tcp_fastopen_active_disable(). */
> + /*
> + * Cap the delay for safe jiffies comparisons on 32-bit systems.
> + * The timestamp read is paired with WRITE_ONCE() in
> + * tcp_fastopen_active_disable().
> + */
I don't think modifying the comment is worth it. If someone wants more
details about the capping, they can already you long message, no need to
add noise everywhere with long LLM generated comments.
> timeout = READ_ONCE(sock_net(sk)->ipv4.tfo_active_disable_stamp) +
> - multiplier * tfo_bh_timeout * HZ;
> + min(delay, MAX_JIFFY_OFFSET);
> if (time_before(jiffies, timeout))
> return true;
>
Cheers,
Matt
--
Sponsored by the NGI0 Core fund.
^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH net-next v3 2/3] mptcp: avoid wrapping blackhole timeout
2026-11-16 16:46 [PATCH net-next v3 0/3] tcp/mptcp: prevent blackhole timeout arithmetic wraparound Yingjie Wang
2026-11-16 16:46 ` [PATCH net-next v3 1/3] tcp: avoid wrapping Fast Open blackhole timeout Yingjie Wang
@ 2026-11-16 16:46 ` Yingjie Wang
2026-11-20 21:30 ` Matthieu Baerts
2026-11-16 16:46 ` [PATCH net-next v3 3/3] mptcp: limit blackhole_timeout to one day Yingjie Wang
2 siblings, 1 reply; 7+ messages in thread
From: Yingjie Wang @ 2026-11-16 16:46 UTC (permalink / raw)
To: netdev@vger.kernel.org
Cc: mptcp@lists.linux.dev, linux-kernel@vger.kernel.org,
corbet@lwn.net, skhan@linuxfoundation.org, rdunlap@infradead.org,
linux-doc@vger.kernel.org, edumazet@kernel.org,
ncardwell@google.com, gang.yan@linux.dev, kuniyu@google.com,
davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org, matttbe@kernel.org, martineau@kernel.org,
geliang@kernel.org, ycheng@google.com, weiwan@google.com,
Gang Yan
mptcp_active_should_disable() calculates the active-disable interval as
multiplier * blackhole_timeout * HZ. Since all operands are 32-bit, a
large blackhole_timeout can wrap the delay, even on 64-bit kernels, and
make active MPTCP available again while the blackhole is still present.
With HZ=1000 and the maximum multiplier of 64, any timeout above 67108
seconds wraps. For example, 67109 seconds should produce 4,294,976,000
jiffies (about 50 days), but the calculation truncates it to 8,704
jiffies (8.7 seconds).
This issue was found using a static analysis tool. It was confirmed with
a loopback reproducer that induces 12 MPTCP blackholes and opens another
connection 10 seconds later: with a 67109 second timeout, the unpatched
kernel retried MP_CAPABLE. The reproducer needs neither kernel
modifications nor error injection.
Compute the interval in u64 and cap it at MAX_JIFFY_OFFSET before adding
it to the saved timestamp. On 32-bit kernels, the cap keeps the interval
within the range that time_before() can compare. The sysctl input range
is unchanged; values whose interval exceeds the cap are shortened to it.
With this patch, the same reproducer fell back to TCP without retrying
MP_CAPABLE. The MPTCP selftests were not run; none of them sets this
sysctl.
Fixes: 27069e7cb3d1 ("mptcp: disable active MPTCP in case of blackhole")
Reviewed-by: Gang Yan <yangang@kylinos.cn>
Signed-off-by: Yingjie Wang <x-professor@outlook.com>
---
net/mptcp/ctrl.c | 12 +++++++++---
1 file changed, 9 insertions(+), 3 deletions(-)
diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c
index 63c5747f0f63..0b10e94e7f43 100644
--- a/net/mptcp/ctrl.c
+++ b/net/mptcp/ctrl.c
@@ -487,6 +487,7 @@ bool mptcp_active_should_disable(struct sock *ssk)
unsigned long timeout;
int disable_times;
int multiplier;
+ u64 delay;
pernet = mptcp_get_pernet(net);
blackhole_timeout = READ_ONCE(pernet->blackhole_timeout);
@@ -501,12 +502,17 @@ bool mptcp_active_should_disable(struct sock *ssk)
/* Paired with smp_mb__before_atomic() in mptcp_active_disable() */
smp_rmb();
- /* Limit timeout to max: 2^6 * initial timeout */
+ /* Limit the backoff multiplier to 64. */
multiplier = 1 << min(disable_times - 1, 6);
+ delay = (u64)multiplier * blackhole_timeout * HZ;
- /* Paired with the WRITE_ONCE() in mptcp_active_disable(). */
+ /*
+ * Cap the delay for safe jiffies comparisons on 32-bit systems.
+ * The timestamp read is paired with WRITE_ONCE() in
+ * mptcp_active_disable().
+ */
timeout = READ_ONCE(pernet->active_disable_stamp) +
- multiplier * blackhole_timeout * HZ;
+ min(delay, MAX_JIFFY_OFFSET);
return time_before(jiffies, timeout);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* Re: [PATCH net-next v3 2/3] mptcp: avoid wrapping blackhole timeout
2026-11-16 16:46 ` [PATCH net-next v3 2/3] mptcp: avoid wrapping " Yingjie Wang
@ 2026-11-20 21:30 ` Matthieu Baerts
0 siblings, 0 replies; 7+ messages in thread
From: Matthieu Baerts @ 2026-11-20 21:30 UTC (permalink / raw)
To: Yingjie Wang
Cc: netdev@vger.kernel.org, mptcp@lists.linux.dev,
linux-kernel@vger.kernel.org, corbet@lwn.net,
skhan@linuxfoundation.org, rdunlap@infradead.org,
linux-doc@vger.kernel.org, edumazet@kernel.org,
ncardwell@google.com, gang.yan@linux.dev, kuniyu@google.com,
davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org, martineau@kernel.org, geliang@kernel.org,
ycheng@google.com, weiwan@google.com, Gang Yan
Hi Yingjie,
On 16/11/2026 17:46, Yingjie Wang wrote:
> mptcp_active_should_disable() calculates the active-disable interval as
> multiplier * blackhole_timeout * HZ. Since all operands are 32-bit, a
> large blackhole_timeout can wrap the delay, even on 64-bit kernels, and
> make active MPTCP available again while the blackhole is still present.
>
> With HZ=1000 and the maximum multiplier of 64, any timeout above 67108
> seconds wraps. For example, 67109 seconds should produce 4,294,976,000
> jiffies (about 50 days), but the calculation truncates it to 8,704
> jiffies (8.7 seconds).
>
> This issue was found using a static analysis tool. It was confirmed with
> a loopback reproducer that induces 12 MPTCP blackholes and opens another
> connection 10 seconds later: with a 67109 second timeout, the unpatched
> kernel retried MP_CAPABLE. The reproducer needs neither kernel
> modifications nor error injection.
>
> Compute the interval in u64 and cap it at MAX_JIFFY_OFFSET before adding
> it to the saved timestamp. On 32-bit kernels, the cap keeps the interval
> within the range that time_before() can compare. The sysctl input range
> is unchanged; values whose interval exceeds the cap are shortened to it.
>
> With this patch, the same reproducer fell back to TCP without retrying
> MP_CAPABLE. The MPTCP selftests were not run; none of them sets this
> sysctl.
>
> Fixes: 27069e7cb3d1 ("mptcp: disable active MPTCP in case of blackhole")
> Reviewed-by: Gang Yan <yangang@kylinos.cn>
> Signed-off-by: Yingjie Wang <x-professor@outlook.com>
> ---
> net/mptcp/ctrl.c | 12 +++++++++---
> 1 file changed, 9 insertions(+), 3 deletions(-)
>
> diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c
> index 63c5747f0f63..0b10e94e7f43 100644
> --- a/net/mptcp/ctrl.c
> +++ b/net/mptcp/ctrl.c
> @@ -487,6 +487,7 @@ bool mptcp_active_should_disable(struct sock *ssk)
> unsigned long timeout;
> int disable_times;
> int multiplier;
> + u64 delay;
>
> pernet = mptcp_get_pernet(net);
> blackhole_timeout = READ_ONCE(pernet->blackhole_timeout);
> @@ -501,12 +502,17 @@ bool mptcp_active_should_disable(struct sock *ssk)
> /* Paired with smp_mb__before_atomic() in mptcp_active_disable() */
> smp_rmb();
>
> - /* Limit timeout to max: 2^6 * initial timeout */
> + /* Limit the backoff multiplier to 64. */
> multiplier = 1 << min(disable_times - 1, 6);
> + delay = (u64)multiplier * blackhole_timeout * HZ;
>
> - /* Paired with the WRITE_ONCE() in mptcp_active_disable(). */
> + /*
> + * Cap the delay for safe jiffies comparisons on 32-bit systems.
> + * The timestamp read is paired with WRITE_ONCE() in
> + * mptcp_active_disable().
> + */
Same here: no need to modify the comment here.
pw-bot: cr
> timeout = READ_ONCE(pernet->active_disable_stamp) +
> - multiplier * blackhole_timeout * HZ;
> + min(delay, MAX_JIFFY_OFFSET);
>
> return time_before(jiffies, timeout);
> }
Cheers,
Matt
--
Sponsored by the NGI0 Core fund.
^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH net-next v3 3/3] mptcp: limit blackhole_timeout to one day
2026-11-16 16:46 [PATCH net-next v3 0/3] tcp/mptcp: prevent blackhole timeout arithmetic wraparound Yingjie Wang
2026-11-16 16:46 ` [PATCH net-next v3 1/3] tcp: avoid wrapping Fast Open blackhole timeout Yingjie Wang
2026-11-16 16:46 ` [PATCH net-next v3 2/3] mptcp: avoid wrapping " Yingjie Wang
@ 2026-11-16 16:46 ` Yingjie Wang
2026-11-20 21:30 ` Matthieu Baerts
2 siblings, 1 reply; 7+ messages in thread
From: Yingjie Wang @ 2026-11-16 16:46 UTC (permalink / raw)
To: netdev@vger.kernel.org
Cc: mptcp@lists.linux.dev, linux-kernel@vger.kernel.org,
corbet@lwn.net, skhan@linuxfoundation.org, rdunlap@infradead.org,
linux-doc@vger.kernel.org, edumazet@kernel.org,
ncardwell@google.com, gang.yan@linux.dev, kuniyu@google.com,
davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org, matttbe@kernel.org, martineau@kernel.org,
geliang@kernel.org, ycheng@google.com, weiwan@google.com
net.mptcp.blackhole_timeout accepts any non-negative int as the initial
period for disabling active MPTCP after a blackhole, and the period can
then grow 64-fold. A multi-day initial period is not useful, and on
32-bit kernels, values above about 1,073,741 seconds at HZ=1000 are
shortened by the MAX_JIFFY_OFFSET cap even on the first blackhole.
Limit the writable value to one day, matching
net.ipv4.tcp_fastopen_blackhole_timeout_sec, and document the limit. The
default of 3600 seconds is unchanged.
Writes above 86400 seconds, which were previously accepted, now fail
with -EINVAL and leave the current value unchanged.
Suggested-by: Eric Dumazet <edumazet@kernel.org>
Signed-off-by: Yingjie Wang <x-professor@outlook.com>
---
Documentation/networking/mptcp-sysctl.rst | 1 +
net/mptcp/ctrl.c | 2 ++
2 files changed, 3 insertions(+)
diff --git a/Documentation/networking/mptcp-sysctl.rst b/Documentation/networking/mptcp-sysctl.rst
index b9b5f58e0625..ca00253c8ae9 100644
--- a/Documentation/networking/mptcp-sysctl.rst
+++ b/Documentation/networking/mptcp-sysctl.rst
@@ -63,6 +63,7 @@ blackhole_timeout - INTEGER (seconds)
blackhole issue goes away.
0 to disable the blackhole detection. This is a per-namespace sysctl.
+ The maximum value is one day (86400 seconds).
Default: 3600
diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c
index 0b10e94e7f43..1f167f72c1f5 100644
--- a/net/mptcp/ctrl.c
+++ b/net/mptcp/ctrl.c
@@ -20,6 +20,7 @@ static int mptcp_pernet_id;
#ifdef CONFIG_SYSCTL
static int mptcp_pm_type_max = __MPTCP_PM_TYPE_MAX;
+static int mptcp_blackhole_timeout_max = 24 * 3600;
#endif
struct mptcp_pernet {
@@ -350,6 +351,7 @@ static struct ctl_table mptcp_sysctl_table[] = {
.mode = 0644,
.proc_handler = proc_blackhole_detect_timeout,
.extra1 = SYSCTL_ZERO,
+ .extra2 = &mptcp_blackhole_timeout_max,
},
{
.procname = "syn_retrans_before_tcp_fallback",
--
2.43.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* Re: [PATCH net-next v3 3/3] mptcp: limit blackhole_timeout to one day
2026-11-16 16:46 ` [PATCH net-next v3 3/3] mptcp: limit blackhole_timeout to one day Yingjie Wang
@ 2026-11-20 21:30 ` Matthieu Baerts
0 siblings, 0 replies; 7+ messages in thread
From: Matthieu Baerts @ 2026-11-20 21:30 UTC (permalink / raw)
To: Yingjie Wang
Cc: netdev@vger.kernel.org, mptcp@lists.linux.dev,
linux-kernel@vger.kernel.org, corbet@lwn.net,
skhan@linuxfoundation.org, rdunlap@infradead.org,
linux-doc@vger.kernel.org, edumazet@kernel.org,
ncardwell@google.com, gang.yan@linux.dev, kuniyu@google.com,
davem@davemloft.net, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org, martineau@kernel.org, geliang@kernel.org,
ycheng@google.com, weiwan@google.com
Hi Yingjie,
On 16/11/2026 17:46, Yingjie Wang wrote:
> net.mptcp.blackhole_timeout accepts any non-negative int as the initial
> period for disabling active MPTCP after a blackhole, and the period can
> then grow 64-fold. A multi-day initial period is not useful, and on
> 32-bit kernels, values above about 1,073,741 seconds at HZ=1000 are
> shortened by the MAX_JIFFY_OFFSET cap even on the first blackhole.
>
> Limit the writable value to one day, matching
> net.ipv4.tcp_fastopen_blackhole_timeout_sec, and document the limit. The
> default of 3600 seconds is unchanged.
>
> Writes above 86400 seconds, which were previously accepted, now fail
> with -EINVAL and leave the current value unchanged.
Why did you split this patch in 2 for MPTCP, while it is in a single
patch for TCP? Can you avoid the split for MPTCP.
> Suggested-by: Eric Dumazet <edumazet@kernel.org>
> Signed-off-by: Yingjie Wang <x-professor@outlook.com>
> ---
> Documentation/networking/mptcp-sysctl.rst | 1 +
> net/mptcp/ctrl.c | 2 ++
> 2 files changed, 3 insertions(+)
>
> diff --git a/Documentation/networking/mptcp-sysctl.rst b/Documentation/networking/mptcp-sysctl.rst
> index b9b5f58e0625..ca00253c8ae9 100644
> --- a/Documentation/networking/mptcp-sysctl.rst
> +++ b/Documentation/networking/mptcp-sysctl.rst
> @@ -63,6 +63,7 @@ blackhole_timeout - INTEGER (seconds)
> blackhole issue goes away.
>
> 0 to disable the blackhole detection. This is a per-namespace sysctl.
> + The maximum value is one day (86400 seconds).
>
> Default: 3600
>
> diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c
> index 0b10e94e7f43..1f167f72c1f5 100644
> --- a/net/mptcp/ctrl.c
> +++ b/net/mptcp/ctrl.c
> @@ -20,6 +20,7 @@ static int mptcp_pernet_id;
>
> #ifdef CONFIG_SYSCTL
> static int mptcp_pm_type_max = __MPTCP_PM_TYPE_MAX;
> +static int mptcp_blackhole_timeout_max = 24 * 3600;
> #endif
>
> struct mptcp_pernet {
> @@ -350,6 +351,7 @@ static struct ctl_table mptcp_sysctl_table[] = {
> .mode = 0644,
> .proc_handler = proc_blackhole_detect_timeout,
> .extra1 = SYSCTL_ZERO,
> + .extra2 = &mptcp_blackhole_timeout_max,
Could we also use a variable called one_day_secs like with TCP?
> },
> {
> .procname = "syn_retrans_before_tcp_fallback",
Cheers,
Matt
--
Sponsored by the NGI0 Core fund.
^ permalink raw reply [flat|nested] 7+ messages in thread