tcp: rehash onto different local ECMP path on retransmit timeout
Subsystems (6)
v8 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 so the connection uses the same local ECMP decision.
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, two dst rebuild consistency tests (normal and syncookie) verifying that natural route invalidation does not cause unintended path changes, and a syncookie server path consistency test verifying that the SYN-ACK and post-cookie ACKs use the same ECMP nexthop.
I'd like guidance on whether to use the ISN as txhash when using syncookies; it keeps the SYN-ACK and subsequent data path consistent, but one could argue that this consistency doesn't matter because no reordering is possible.
Changes since v7: https://lore.kernel.org/netdev/[email protected]/
Patch 1:
- Remove #if IS_ENABLED(CONFIG_IPV6) guards around __sk_dst_reset()
in tcp_plb.c and tcp_timer.c (Eric Dumazet)
- Guard mp_hash in inet6_csk_route_socket() on sk_protocol == IPPROTO_TCP instead of txhash != 0, since non-TCP callers like L2TP set sk_txhash
in __ip6_datagram_connect() and should retain flow-key-based ECMP
- Use the syncookie (ISN) as txhash for both the SYN-ACK route lookup
and cookie_v6_check() socket creation, so the server's ECMP selection is consistent across the stateless SYN-ACK and the subsequent full socket. Move cookie_init_sequence() before route_req() in tcp_conn_request()
so the SYN-ACK dst is computed with the cookie-derived txhash; derive txhash from snt_isn in cookie_tcp_reqsk_init() to match
Patch 2:
- Invalidate dst via dummy route add/del instead of route replace to
avoid a transient single-nexthop state during multipath replacement
- Add syncookie server path consistency test verifying the SYN-ACK and post-cookie ACKs use the same ECMP path
- Strengthen policy 1 negative test to wait for multiple rehash attempts
and verify SYNs landed on exactly one interface
Changes since v6: https://lore.kernel.org/netdev/[email protected]/
- Guard mp_hash assignment so that non-TCP callers of inet6_csk_route_socket() fall through to rt6_multipath_hash()
(superseded in v8 by sk_protocol == IPPROTO_TCP guard)
- Initialize txhash in bpf_sk_assign_tcp_reqsk() to avoid reading uninitialized slab memory in inet6_csk_route_req()
- Check post-rebuild busywait return status to avoid silent false pass
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/core/filter.c | 1 + net/ipv4/tcp_input.c | 6 +- net/ipv4/tcp_plb.c | 5 +- net/ipv4/tcp_timer.c | 2 + net/ipv6/af_inet6.c | 3 + net/ipv6/inet6_connection_sock.c | 7 + net/ipv6/syncookies.c | 4 + 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 | 952 +++++++++++++++++++++ 11 files changed, 990 insertions(+), 5 deletions(-) create mode 100755 tools/testing/selftests/net/ecmp_rehash.sh
--
2.53.0-Meta
PATCH v8 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 mp_hash assignment in inet6_csk_route_socket() is guarded by sk_protocol == IPPROTO_TCP so that non-TCP callers (e.g., L2TP via inet6_csk_xmit) fall through to rt6_multipath_hash() and retain their existing flow-key-based ECMP behavior. The expression uses (txhash >> 1) ?: 1 so that the rare txhash == 1 still produces a valid non-zero mp_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. For syncookies, txhash is set to the cookie (ISN) before route_req() so the SYN-ACK uses the same ECMP path that cookie_v6_check() will select when the ACK arrives and the full socket is created. cookie_tcp_reqsk_init() likewise derives txhash from the cookie rather than calling net_tx_rndhash(), since the original request socket (and its txhash) was freed after the SYN-ACK. The ecn_ok clear for syncookies without timestamps stays after tcp_ecn_create_request() so it takes precedence.
bpf_sk_assign_tcp_reqsk() is updated to initialize txhash via net_tx_rndhash(), matching cookie_tcp_reqsk_alloc(). Without this, inet6_csk_route_req() would read uninitialized slab memory from request sockets created by BPF syncookies.
--- net/core/filter.c | 1 + net/ipv4/syncookies.c | 8 +++++++- net/ipv4/tcp_input.c | 18 +++++++++++------- net/ipv4/tcp_plb.c | 5 ++++- net/ipv4/tcp_timer.c | 2 ++ net/ipv6/af_inet6.c | 3 +++ net/ipv6/inet6_connection_sock.c | 8 ++++++++ net/ipv6/syncookies.c | 4 ++++ net/ipv6/tcp_ipv6.c | 13 +++++++++++-- 9 files changed, 51 insertions(+), 11 deletions(-)
net/core/filter.c +1 -0
@@ -12301,6 +12301,7 @@ __bpf_kfunc int bpf_sk_assign_tcp_reqsk(struct __sk_buff *s, struct sock *sk, treq->req_usec_ts = !!attrs->usec_ts_ok; treq->ts_off = tsoff; + treq->txhash =net_tx_rndhash ();skb_orphan (skb); skb->sk =req_to_sk (req);
net/ipv4/syncookies.c +7 -1
@@ -280,9 +280,15 @@ static int cookie_tcp_reqsk_init(struct sock *sk, struct sk_buff *skb, treq->snt_synack =0 ; treq->snt_tsval_first =0 ; treq->tfo_listener = false; - treq->txhash =net_tx_rndhash (); treq->rcv_isn =ntohl (th->seq) -1 ; treq->snt_isn =ntohl (th->ack_seq) -1 ; +/* Use the cookie as txhash so the ECMP path matches the +* SYN-ACK, where txhash was also set to the cookie. A +* random txhash would be inconsistent because the original +* request socket (and its txhash) was freed after sending +* the SYN-ACK. +*/ + treq->txhash = treq->snt_isn; treq->syn_tos =TCP_SKB_CB (skb)->ip_dsfield;#if IS_ENABLED (CONFIG_MPTCP )
net/ipv4/tcp_input.c +11 -7
@@ -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
@@ -7659,6 +7662,11 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,/* Note: tcp_v6_init_req() might override ir_iif for link locals */ inet_rsk (req)->ir_iif =inet_request_bound_dev_if (sk, skb); +if (want_cookie) { + isn =cookie_init_sequence (af_ops, sk, skb, &req->mss); +tcp_rsk (req)->txhash = isn; + } + dst = af_ops->route_req (sk, skb, &fl, req, isn);if (!dst) goto drop_and_free;
@@ -7698,11 +7706,8 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,tcp_ecn_create_request (req, skb, sk, dst); -if (want_cookie) { - isn =cookie_init_sequence (af_ops, sk, skb, &req->mss); -if (!tmp_opt.tstamp_ok) -inet_rsk (req)->ecn_ok =0 ; - } +if (want_cookie && !tmp_opt.tstamp_ok) +inet_rsk (req)->ecn_ok =0 ;#ifdef CONFIG_TCP_AO if (tcp_parse_auth_options (tcp_hdr (skb),NULL , &aoh))
@@ -7717,7 +7722,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 +4 -1
@@ -78,7 +78,10 @@ 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 (sk->sk_family ==AF_INET6 ) +__sk_dst_reset (sk); + } 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 +2 -0
@@ -300,6 +300,8 @@ 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 (sk->sk_family ==AF_INET6 ) +__sk_dst_reset (sk); }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 && sk->sk_txhash) + 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 +8 -0
@@ -48,6 +48,10 @@ 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 && +tcp_rsk (req)->txhash) + 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 +74,10 @@ 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 (sk->sk_protocol ==IPPROTO_TCP && +ip6_multipath_hash_policy (sock_net (sk)) ==0 && sk->sk_txhash) + 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 +4 -0
@@ -245,6 +245,10 @@ 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 && +tcp_rsk (req)->txhash) + 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 && sk->sk_txhash) + 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 v8 2/2 selftests: net: add local ECMP rehash test
In reply to Neil SpringAdd ecmp_rehash.sh with ten 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 (dst invalidation does not change path)
- Dst rebuild consistency with syncookies (server socket created via cookie_v6_check instead of the normal three-way handshake)
- Syncookie server path consistency (SYN-ACK and post-cookie ACKs use the same ECMP path)
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, invalidate the cached dst by adding and removing a dummy route (bumping the fib6_node sernum), and verify that traffic stays on the same path. The sernum change causes ip6_dst_check() to fail on the next transmit, triggering a fresh route lookup via inet6_csk_route_socket(). ECMP_REBUILD_ROUNDS=10 repeats the check to reduce the probability of a buggy kernel passing by chance with 2-way ECMP.
The syncookie server path consistency test verifies that the server's SYN-ACK and subsequent ACKs use the same ECMP path. With syncookies, the request socket is freed after the SYN-ACK, so cookie_tcp_reqsk_init() must derive the same txhash (from the cookie) that was used for the SYN-ACK's route lookup.
--- tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/config | 1 + tools/testing/selftests/net/ecmp_rehash.sh | 1036 ++++++++++++++++++++ 3 files changed, 1038 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 +1036 -0
1,036 lines not on this page · raw message
Signature · 1 line
2.53.0-Meta
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] IPv6 flowlabel reflection (REPFLOW) is broken for SYN-ACKs when syncookies are triggered. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] IPv6 flowlabel reflection (REPFLOW) is broken for SYN-ACKs when syncookies are triggered. --
commit b64f3a9b6e1ac0e884a330cb07667e97df46001c
Author: Neil Spring <[email protected]>
tcp: rehash onto different local ECMP path on retransmit timeout
This commit updates the TCP transmit hashing logic to re-roll the txhash on RTO, PLB, and spurious retransmission events. It additionally ensures the cached destination route is invalidated and sets up the routing lookup to use the new txhash for selecting a different local ECMP path.
Quoted 3 lines
net/ipv4/tcp_input.c +0
-0
[ ... ]
net/ipv4/tcp_input.c int tcp_conn_request(struct request_sock_ops *rsk_ops, · line 7667
Quoted 10 lines
net/ipv4/tcp_input.c +5
-0@@ -7656,6 +7659,11 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,/* Note: tcp_v6_init_req() might override ir_iif for link locals */ inet_rsk (req)->ir_iif =inet_request_bound_dev_if (sk, skb); +if (want_cookie) { + isn =cookie_init_sequence (af_ops, sk, skb, &req->mss); +tcp_rsk (req)->txhash = isn; + } + dst = af_ops->route_req (sk, skb, &fl, req, isn);
[Severity: High]
Could this change break IPv6 flowlabel reflection (REPFLOW) for SYN-ACKs when syncookies are active?
By moving the cookie initialization before the route_req() call, isn is now a non-zero cookie value rather than zero when a SYN flood is detected.
For IPv6, af_ops->route_req() maps to tcp_v6_route_req(), which passes this isn value as the tw_isn parameter to tcp_v6_init_req().
Because tw_isn is now the generated syncookie (a non-zero value) rather than 0, the if (!tw_isn && ...) check inside tcp_v6_init_req() evaluates to false. This causes it to skip saving the SYN packet's ireq->pktopts.
Later, when tcp_v6_send_synack() attempts to send the SYN-ACK, it checks:
if (inet6_test_bit(REPFLOW, sk) && ireq->pktopts)
Since ireq->pktopts was not saved and is NULL, the SYN-ACK fails to reflect the IPv6 flowlabel during SYN floods.
Quoted 2 lines
net/ipv4/tcp_input.c +0
-0if (!dst) goto drop_and_free;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1