tcp: rehash onto different local ECMP path on retransmit timeout
Subsystems (4)
v6 cover tcp: rehash onto different local ECMP path on retransmit timeout
Currently sk_rethink_txhash() re-rolls the socket's txhash on RTO, PLB, and spurious-retransmission events, but the new hash is not propagated into the IPv6 ECMP path selection logic. The cached route is reused and fib6_select_path() is never re-invoked, so the connection stays on the same ECMP path.
This series adds the two missing pieces:
1. __sk_dst_reset() alongside sk_rethink_txhash() so the cached dst is invalidated and the next transmit triggers a fresh route lookup.
2. fl6->mp_hash set from sk_txhash before each route lookup so fib6_select_path() picks a path based on the (potentially re-rolled) hash. This is conditioned on fib_multipath_hash_policy == 0 (L3) because policies 1-3 compute a deterministic hash from the flow keys which must not be overridden.
Patch 1 is the kernel change; patch 2 adds selftests covering SYN rehash, SYN/ACK rehash, midstream RTO rehash, midstream ACK rehash (spurious retransmission), PLB rehash, a policy 1 negative test, a flowlabel leak regression test, and two dst rebuild consistency tests (normal and syncookie) verifying that natural route invalidation does not cause unintended path changes.
Changes since v5: https://lore.kernel.org/netdev/[email protected]/
- Improve selftest reliability: suppress __dst_negative_advice() via tcp_retries1=255 in dst rebuild tests so a real RTO cannot trigger
an unintended rehash; add internal retry to midstream and ACK
rehash tests to tolerate probabilistic ECMP path selection; fix
midstream baseline capture to account for packets that bypass tc
filters during the prio qdisc's TCQ_F_CAN_BYPASS window
- Increase ECMP_REBUILD_ROUNDS default to 10 for reliable regression detection with 2-way ECMP; replace sleep with busywait
- Use tcp_allowed_congestion_control instead of changing the host's
default congestion control for PLB test
- Use (txhash >> 1) ?: 1 to guarantee non-zero mp_hash, since zero
falls back to rt6_multipath_hash()
Changes since v4: https://lore.kernel.org/netdev/[email protected]/
- Condition fl6->mp_hash on fib_multipath_hash_policy == 0 to preserve deterministic hash policies 1-3 (e.g., symmetric 5-tuple for policy 1)
- Set fl6->mp_hash in tcp_v6_connect() and cookie_v6_check() for
initial route lookup consistency; move sk_set_txhash() earlier
(Jakub Kicinski)
- Add policy 1 negative test; improve sysctl save/restore
- Add flowlabel leak test confirming mp_hash does not alter the
on-wire IPv6 flow label
- Add dst rebuild consistency tests (normal and syncookie) verifying
that route table changes do not cause unintended ECMP path changes
Changes since v3: https://lore.kernel.org/netdev/[email protected]/
- Use __sk_dst_reset() instead of sk_dst_reset() since the socket lock
is held in all three call sites (Eric Dumazet)
- Guard __sk_dst_reset() with sk->sk_family == AF_INET6 since IPv4 ECMP
does not use sk_txhash for path selection
- Guard __sk_dst_reset() in tcp_plb_check_rehash() with the return value
of sk_rethink_txhash()
- Move tcp_rsk(req)->txhash initialization before route_req() in tcp_conn_request() to avoid reading uninitialized memory
- Add CONFIG_TCP_CONG_DCTCP=m to selftests/net/config for PLB test
- Skip PLB test gracefully if DCTCP is not available
- Save and restore original congestion control algorithm in PLB test
- Default get_netstat_counter() to 0 when counter is not found
- Skip all tests if tcp_syn_linear_timeouts is not available
- Replace bash/pipe data sources with socat OPEN:/dev/zero for
cleaner process cleanup
- Fix shellcheck warnings
Changes since v2: https://lore.kernel.org/netdev/[email protected]/
- Retitle "ECMP" to "local ECMP" to distinguish from remote ECMP
(Neal Cardwell)
- Add fl6->mp_hash propagation in inet6_sk_rebuild_header() (af_inet6.c), covering the dst rebuild path used on established sockets
- Remove incorrect ir_iif update from tcp_check_req() in tcp_minisocks.c;
the SYN/ACK rehash is already handled by tcp_rtx_synack() re-rolling
txhash which feeds into inet6_csk_route_req()'s mp_hash
(Eric Dumazet)
- Add ACK rehash and PLB rehash selftests
- Improve selftest reliability
Changes since v1: https://lore.kernel.org/netdev/[email protected]/
- Use tcp_rsk(req)->txhash instead of jhash_1word(req->num_retrans, ...)
for ECMP path selection in inet6_csk_route_req(), making the request
socket path consistent with the established socket path (Eric Dumazet)
- Add comments explaining the >> 1 shift for 31-bit mp_hash range
- Use socat -u (unidirectional) in selftest to avoid SIGPIPE race
- Increase tcp_syn_retries and tcp_syn_linear_timeouts to 25 for
better rehash coverage
Neil Spring (2):
tcp: rehash onto different local ECMP path on retransmit timeout
selftests: net: add local ECMP rehash test
net/ipv4/tcp_input.c | 6 +- net/ipv4/tcp_plb.c | 7 +- net/ipv4/tcp_timer.c | 4 + net/ipv6/af_inet6.c | 3 + net/ipv6/inet6_connection_sock.c | 6 + net/ipv6/syncookies.c | 3 + net/ipv6/tcp_ipv6.c | 13 +- tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/config | 1 + tools/testing/selftests/net/ecmp_rehash.sh | 923 +++++++++++++++++++++ 10 files changed, 962 insertions(+), 5 deletions(-) create mode 100755 tools/testing/selftests/net/ecmp_rehash.sh
--
2.53.0-Meta
PATCH v6 1/2 tcp: rehash onto different local ECMP path on retransmit timeout
Currently sk_rethink_txhash() re-rolls the socket's txhash on RTO, PLB, and spurious-retransmission events, but the cached route is reused and the new hash is not propagated into the ECMP path selection logic. Two changes are needed to make rehash select a different local ECMP path:
1. Add __sk_dst_reset() alongside sk_rethink_txhash() in tcp_write_timeout(), tcp_rcv_spurious_retrans(), and tcp_plb_check_rehash() so the cached dst is invalidated and the next transmit triggers a fresh route lookup.
2. Set fl6->mp_hash from sk_txhash (or tcp_rsk(req)->txhash for SYN/ACK retransmits and syncookies) in tcp_v6_connect(), inet6_sk_rebuild_header(), inet6_csk_route_req(), inet6_csk_route_socket(), and cookie_v6_check() so fib6_select_path() picks a path based on the new hash.
The expression uses (txhash >> 1) ?: 1 to guarantee a non-zero mp_hash, since fib6_select_path() treats zero as unset and falls back to rt6_multipath_hash().
This is conditioned on fib_multipath_hash_policy == 0 (L3) because policies 1-3 compute a deterministic hash from the flow keys (e.g., symmetric 5-tuple for policy 1) which must not be overridden by a random txhash.
It is necessary to update mp_hash explicitly because the default ECMP hash derives from fl6->flowlabel via np->flow_label, which is not updated from sk_txhash (REPFLOW is off by default). ip6_make_flowlabel() cannot help either, as it runs after the route lookup.
sk_set_txhash() is moved before ip6_dst_lookup_flow() in tcp_v6_connect() so the initial ECMP path is selected by the same txhash that subsequent route rebuilds will use. This avoids unintended path changes when the cached dst is naturally invalidated (e.g., by PMTU discovery or route changes).
The dst reset is guarded by sk->sk_family == AF_INET6 since IPv4 ECMP does not currently use sk_txhash for path selection. For IPv4-mapped IPv6 sockets this produces a redundant dst reset on a cold path (RTO/PLB); the subsequent IPv4 route lookup returns the same result.
tcp_rsk(req)->txhash initialization is moved before route_req() in tcp_conn_request() so that inet6_csk_route_req() reads a valid hash on the initial SYN/ACK.
--- net/ipv4/tcp_input.c | 6 ++++-- net/ipv4/tcp_plb.c | 7 ++++++- net/ipv4/tcp_timer.c | 4 ++++ net/ipv6/af_inet6.c | 3 +++ net/ipv6/inet6_connection_sock.c | 6 ++++++ net/ipv6/syncookies.c | 3 +++ net/ipv6/tcp_ipv6.c | 13 +++++++++++-- 7 files changed, 37 insertions(+), 5 deletions(-)
net/ipv4/tcp_input.c +4 -2
@@ -5020,8 +5020,10 @@ static void tcp_rcv_spurious_retrans(struct sock *sk, skb->protocol == htons(ETH_P_IPV6) && (tcp_sk(sk)->inet_conn.icsk_ack.lrcv_flowlabel != ntohl(ip6_flowlabel(ipv6_hdr(skb)))) && - sk_rethink_txhash(sk)) + sk_rethink_txhash(sk)) {NET_INC_STATS (sock_net (sk),LINUX_MIB_TCPDUPLICATEDATAREHASH ); +__sk_dst_reset (sk); + }/* Save last flowlabel after a spurious retrans. */ tcp_save_lrcv_flowlabel (sk, skb);
@@ -7636,6 +7638,7 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,tcp_rsk (req)->af_specific = af_ops;tcp_rsk (req)->ts_off =0 ;tcp_rsk (req)->req_usec_ts = false; +tcp_rsk (req)->txhash =net_tx_rndhash ();#if IS_ENABLED (CONFIG_MPTCP )tcp_rsk (req)->is_mptcp =0 ;#endif
@@ -7717,7 +7720,6 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops, }#endif tcp_rsk (req)->snt_isn = isn; -tcp_rsk (req)->txhash =net_tx_rndhash ();tcp_rsk (req)->syn_tos =TCP_SKB_CB (skb)->ip_dsfield;tcp_openreq_init_rwin (req, sk, dst);sk_rx_queue_set (req_to_sk (req), skb);
net/ipv4/tcp_plb.c +6 -1
@@ -78,7 +78,12 @@ void tcp_plb_check_rehash(struct sock *sk, struct tcp_plb_state *plb)if (plb->pause_until)return ; -sk_rethink_txhash (sk); +if (sk_rethink_txhash (sk)) { +#if IS_ENABLED (CONFIG_IPV6 ) +if (sk->sk_family ==AF_INET6 ) +__sk_dst_reset (sk); +#endif + } plb->consec_cong_rounds =0 ;WRITE_ONCE (tcp_sk (sk)->plb_rehash,tcp_sk (sk)->plb_rehash +1 );NET_INC_STATS (sock_net (sk),LINUX_MIB_TCPPLBREHASH );
net/ipv4/tcp_timer.c +4 -0
@@ -300,6 +300,10 @@ static int tcp_write_timeout(struct sock *sk)if (sk_rethink_txhash (sk)) {WRITE_ONCE (tp->timeout_rehash, tp->timeout_rehash +1 );__NET_INC_STATS (sock_net (sk),LINUX_MIB_TCPTIMEOUTREHASH ); +#if IS_ENABLED (CONFIG_IPV6 ) +if (sk->sk_family ==AF_INET6 ) +__sk_dst_reset (sk); +#endif }return 0 ;
net/ipv6/af_inet6.c +3 -0
@@ -823,6 +823,9 @@ int inet6_sk_rebuild_header(struct sock *sk) fl6->flowi6_uid =sk_uid (sk);security_sk_classify_flow (sk,flowi6_to_flowi_common (fl6)); +if (ip6_multipath_hash_policy (sock_net (sk)) ==0 ) + fl6->mp_hash = (sk->sk_txhash >>1 ) ?:1 ; +rcu_read_lock (); final_p =fl6_update_dst (fl6,rcu_dereference (np->opt), &np->final);rcu_read_unlock ();
net/ipv6/inet6_connection_sock.c +6 -0
@@ -48,6 +48,9 @@ struct dst_entry *inet6_csk_route_req(const struct sock *sk, fl6->flowi6_uid =sk_uid (sk);security_req_classify_flow (req,flowi6_to_flowi_common (fl6)); +if (ip6_multipath_hash_policy (sock_net (sk)) ==0 ) + fl6->mp_hash = (tcp_rsk (req)->txhash >>1 ) ?:1 ; +if (!dst) { dst =ip6_dst_lookup_flow (sock_net (sk), sk, fl6, final_p);if (IS_ERR (dst))
@@ -70,6 +73,9 @@ struct dst_entry *inet6_csk_route_socket(struct sock *sk, fl6->saddr = np->saddr; fl6->flowlabel = np->flow_label;IP6_ECN_flow_xmit (sk, fl6->flowlabel); + +if (ip6_multipath_hash_policy (sock_net (sk)) ==0 ) + fl6->mp_hash = (sk->sk_txhash >>1 ) ?:1 ; fl6->flowi6_oif = sk->sk_bound_dev_if; fl6->flowi6_mark = sk->sk_mark; fl6->fl6_sport = inet->inet_sport;
net/ipv6/syncookies.c +3 -0
@@ -245,6 +245,9 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb) fl6.flowi6_uid =sk_uid (sk);security_req_classify_flow (req,flowi6_to_flowi_common (&fl6)); +if (ip6_multipath_hash_policy (net) ==0 ) + fl6.mp_hash = (tcp_rsk (req)->txhash >>1 ) ?:1 ; + dst =ip6_dst_lookup_flow (net, sk, &fl6, final_p);if (IS_ERR (dst)) {SKB_DR_SET (reason,IP_OUTNOROUTES );
net/ipv6/tcp_ipv6.c +11 -2
@@ -258,6 +258,8 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr_unsized *uaddr,if (!ipv6_addr_any (&sk->sk_v6_rcv_saddr)) saddr = &sk->sk_v6_rcv_saddr; +sk_set_txhash (sk); + fl6->flowi6_proto =IPPROTO_TCP ; fl6->daddr = sk->sk_v6_daddr; fl6->saddr = saddr ? *saddr : np->saddr;
@@ -275,6 +277,15 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr_unsized *uaddr,security_sk_classify_flow (sk,flowi6_to_flowi_common (fl6)); +/* Non-zero mp_hash bypasses rt6_multipath_hash() in +* fib6_select_path(), letting txhash control ECMP path +* selection so that sk_rethink_txhash() rehashes onto a +* different path. Policies 1-3 derive a deterministic +* hash from the flow keys and must not be overridden. +*/ +if (ip6_multipath_hash_policy (net) ==0 ) + fl6->mp_hash = (sk->sk_txhash >>1 ) ?:1 ; + dst =ip6_dst_lookup_flow (net, sk, fl6, final_p);if (IS_ERR (dst)) { err =PTR_ERR (dst);
@@ -313,8 +324,6 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr_unsized *uaddr,if (err) goto late_failure; -sk_set_txhash (sk); -if (likely (!tp->repair)) {union tcp_seq_and_ts_off st;
Signature · 1 line
2.53.0-Meta
PATCH v6 2/2 selftests: net: add local ECMP rehash test
In reply to Neil SpringAdd ecmp_rehash.sh with nine scenarios verifying that TCP rehash selects a different local ECMP path for IPv6:
- SYN retransmission (forward path blocked during setup)
- SYN/ACK retransmission (reverse path blocked during setup)
- Midstream RTO (forward path blocked on established connection)
- Midstream ACK rehash (reverse path blocked on established connection)
- PLB rehash (ECN-driven congestion on established connection)
- Hash policy 1 negative test (rehash attempted but path unchanged)
- No flowlabel leak (client mp_hash does not alter on-wire flowlabel)
- Dst rebuild consistency (route replace does not change path)
- Dst rebuild consistency with syncookies (same via cookie_v6_check)
The policy 1 test verifies that fib_multipath_hash_policy=1 computes a deterministic 5-tuple hash, so txhash re-rolls do not change the ECMP path while TcpTimeoutRehash still increments.
The flowlabel leak test sets auto_flowlabels=0 on the client and installs tc filters on client egress that drop TCP packets with nonzero flowlabel, confirming that the client's fl6->mp_hash does not leak into the on-wire IPv6 flow label.
The dst rebuild tests stream data, replace the ECMP route with identical nexthops, and verify that traffic stays on the same path. The route replace creates a new fib6_info, causing ip6_dst_check() to fail on the next transmit and trigger a fresh route lookup via inet6_csk_route_socket() (or cookie_v6_check() for syncookies). ECMP_REBUILD_ROUNDS=10 repeats the check to reduce the probability of a buggy kernel passing by chance with 2-way ECMP.
--- tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/config | 1 + tools/testing/selftests/net/ecmp_rehash.sh | 923 +++++++++++++++++++++ 3 files changed, 925 insertions(+) create mode 100755 tools/testing/selftests/net/ecmp_rehash.sh
tools/testing/selftests/net/Makefile +1 -0
@@ -26,6 +26,7 @@ TEST_PROGS := \ cmsg_time.sh \ double_udp_encap.sh \ drop_monitor_tests.sh \ + ecmp_rehash.sh \ fcnal-ipv4.sh \ fcnal-ipv6.sh \ fcnal-other.sh \
tools/testing/selftests/net/config +1 -0
@@ -122,6 +122,7 @@ CONFIG_PSAMPLE=m CONFIG_RPS=y CONFIG_SYSFS=y CONFIG_TAP=m +CONFIG_TCP_CONG_DCTCP=m CONFIG_TCP_MD5SIG=y CONFIG_TEST_BLACKHOLE_DEV=m CONFIG_TEST_BPF=m
tools/testing/selftests/net/ecmp_rehash.sh new file +923 -0
923 lines not on this page · raw message
Signature · 1 line
2.53.0-Meta
Jakub Kicinski
maintainerQuoted 17 lines · On Sun, 17 May 2026 10:45:20 -0700 Neil Spring wrote:
Currently
sk_rethink_txhash()re-rolls the socket's txhash on RTO, PLB, and spurious-retransmission events, but the new hash is not propagated into the IPv6 ECMP path selection logic. The cached route is reused andfib6_select_path()is never re-invoked, so the connection stays on the same ECMP path.This series adds the two missing pieces:
1.
__sk_dst_reset()alongsidesk_rethink_txhash()so the cached dst is invalidated and the next transmit triggers a fresh route lookup.2.
fl6->mp_hashset fromsk_txhashbefore each route lookup sofib6_select_path()picks a path based on the (potentially re-rolled) hash. This is conditioned onfib_multipath_hash_policy== 0 (L3) because policies 1-3 compute a deterministic hash from the flow keys which must not be overridden.
Quoted 6 lines
Patch 1 is the kernel change; patch 2 adds selftests covering SYN rehash, SYN/ACK rehash, midstream RTO rehash, midstream ACK rehash (spurious retransmission), PLB rehash, a policy 1 negative test, a flowlabel leak regression test, and two dst rebuild consistency tests (normal and syncookie) verifying that natural route invalidation does not cause unintended path changes.
Still flakes:
https://netdev-ctrl.bots.linux.dev/logs/vmksft/net/results/652122/44-ecmp-rehash-sh/stdout
https://netdev-ctrl.bots.linux.dev/logs/vmksft/net-dbg/results/652122/34-ecmp-rehash-sh/stdout
Signature · 1 line
pw-bot: cr