* [PATCH v9 net-next 00/15] AccECN protocol patch series
@ 2025-06-21 19:37 chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 01/15] tcp: reorganize SYN ECN code chia-yu.chang
` (14 more replies)
0 siblings, 15 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Hello,
Please find the v9 AccECN protocol patch series, which covers the core
functionality of Accurate ECN, AccECN negotiation, AccECN TCP options,
and AccECN failure handling. The Accurate ECN draft can be found in
https://datatracker.ietf.org/doc/html/draft-ietf-tcpm-accurate-ecn-28
This patch series is part of the full AccECN patch series, which is available at
https://github.com/L4STeam/linux-net-next/commits/upstream_l4steam/
Best Regards,
Chia-Yu
---
v9 (21-Jun-2025)
- Use tcp_data_ecn_check() to set TCP_ECN_SEE flag only for RFC3168 ECN (Paolo Abeni <pabeni@redhat.com>)
- Add comments about setting TCP_ECN_SEEN flag for RFC3168 and Accruate ECN (Paolo Abeni <pabeni@redhat.com>)
- Restruct the code in the for loop of tcp_accecn_process_option() (Paolo Abeni <pabeni@redhat.com>)
- Remove ecn_bytes and add use_synack_ecn_bytes flag to identify whether syn_ack_bytes or received_ecn_bytes is used (Paolo Abeni <pabeni@redhat.com>)
- Replace leftover_bytes and leftover_size with leftover_highbyte and leftover_lowbyte and add comments in tcp_options_write() (Paolo Abeni <pabeni@redhat.com>)
- Add comments and commit message about the 1st retx SYN still attempt AccECN negotiation (Paolo Abeni <pabeni@redhat.com>)
v8 (10-Jun-2025)
- Add new helper function tcp_ecn_received_counters_payload() in #6 (Paolo Abeni <pabeni@redhat.com>)
- Set opts->num_sack_blocks=0 to avoid potential undefined value in #8 (Paolo Abeni <pabeni@redhat.com>)
- Reset leftover_size to 2 once leftover_bytes is used in #9 (Paolo Abeni <pabeni@redhat.com>)
- Add new helper function tcp_accecn_opt_demand_min() in #10 (Paolo Abeni <pabeni@redhat.com>)
- Add new helper function tcp_accecn_saw_opt_fail_recv() in #11 (Paolo Abeni <pabeni@redhat.com>)
- Update tcp_options_fit_accecn() to avoid using recursion in #14 (Paolo Abeni <pabeni@redhat.com>)
v7 (14-May-2025)
- Modify group sizes of tcp_sock_write_txrx and tcp_sock_write_rx in #3 based on pahole results (Paolo Abeni <pabeni@redhat.com>)
- Fix the issue in #4 and #5 where the RFC3168 ECN behavior in tcp_ecn_send() is changed (Paolo Abeni <pabeni@redhat.com>)
- Modify group size of tcp_sock_write_txrx in #4 and #6 based on pahole results (Paolo Abeni <pabeni@redhat.com>)
- Update commit message for #9 to explain the increase in tcp_sock_write_rx group size
- Modify group size of tcp_sock_write_tx in #10 based on pahole results
v6 (09-May-2025)
- Add #3 to utilize exisintg holes of tcp_sock_write_txrx group for later patches (#4, #9, #10) with new u8 members (Paolo Abeni <pabeni@redhat.com>)
- Add pahole outcomes before and after commit in #4, #5, #6, #9, #10, #15 (Paolo Abeni <pabeni@redhat.com>)
- Define new helper function tcp_send_ack_reflect_ect() for sending ACK with reflected ECT in #5 (Paolo Abeni <pabeni@redhat.com>)
- Add comments for function tcp_ecn_rcv_synack() in #5 (Paolo Abeni <pabeni@redhat.com>)
- Add enum/define to be used by sysctl_tcp_ecn in #5, sysctl_tcp_ecn_option in #9, and sysctl_tcp_ecn_option_beacon in #10 (Paolo Abeni <pabeni@redhat.com>)
- Move accecn_fail_mode and saw_accecn_opt in #5 and #11 to use exisintg holes of tcp_sock (Paolo Abeni <pabeni@redhat.com>)
- Change data type of new members of tcp_request_sock and move them to the end of struct in #5 and #11 (Paolo Abeni <pabeni@redhat.com>)
- Move new members of tcp_info to the end of struct in #6 (Paolo Abeni <pabeni@redhat.com>)
- Merge previous #7 into #9 (Paolo Abeni <pabeni@redhat.com>)
- Mask ecnfield with INET_ECN_MASK to remove WARN_ONCE in #9 (Paolo Abeni <pabeni@redhat.com>)
- Reduce the indentation levels for reabability in #9 and #10 (Paolo Abeni <pabeni@redhat.com>)
- Move delivered_ecn_bytes to the RX group in #9, accecn_opt_tstamp to the TX group in #10, pkts_acked_ewma to the RX group in #15 (Paolo Abeni <pabeni@redhat.com>)
- Add changes in Documentation/networking/net_cachelines/tcp_sock.rst for new tcp_sock members in #3, #5, #6, #9, #10, #15
v5 (22-Apr-2025)
- Further fix for 32-bit ARM alignment in tcp.c (Simon Horman <horms@kernel.org>)
v4 (18-Apr-2025)
- Fix 32-bit ARM assertion for alignment requirement (Simon Horman <horms@kernel.org>)
v3 (14-Apr-2025)
- Fix patch apply issue in v2 (Jakub Kicinski <kuba@kernel.org>)
v2 (18-Mar-2025)
- Add one missing patch from the previous AccECN protocol preparation patch series to this patch series.
---
Chia-Yu Chang (3):
tcp: reorganize tcp_sock_write_txrx group for variables later
tcp: accecn: AccECN option failure handling
tcp: accecn: try to fit AccECN option with SACK
Ilpo Järvinen (12):
tcp: reorganize SYN ECN code
tcp: fast path functions later
tcp: AccECN core
tcp: accecn: AccECN negotiation
tcp: accecn: add AccECN rx byte counters
tcp: accecn: AccECN needs to know delivered bytes
tcp: sack option handling improvements
tcp: accecn: AccECN option
tcp: accecn: AccECN option send control
tcp: accecn: AccECN option ceb/cep heuristic
tcp: accecn: AccECN ACE field multi-wrap heuristic
tcp: try to avoid safer when ACKs are thinned
.../networking/net_cachelines/tcp_sock.rst | 14 +
include/linux/tcp.h | 34 +-
include/net/netns/ipv4.h | 2 +
include/net/tcp.h | 225 ++++++-
include/uapi/linux/tcp.h | 7 +
net/ipv4/syncookies.c | 3 +
net/ipv4/sysctl_net_ipv4.c | 19 +
net/ipv4/tcp.c | 30 +-
net/ipv4/tcp_input.c | 622 +++++++++++++++++-
net/ipv4/tcp_ipv4.c | 7 +-
net/ipv4/tcp_minisocks.c | 91 ++-
net/ipv4/tcp_output.c | 325 ++++++++-
net/ipv6/syncookies.c | 1 +
net/ipv6/tcp_ipv6.c | 1 +
14 files changed, 1285 insertions(+), 96 deletions(-)
--
2.34.1
^ permalink raw reply [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 01/15] tcp: reorganize SYN ECN code
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 02/15] tcp: fast path functions later chia-yu.chang
` (13 subsequent siblings)
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
Prepare for AccECN that needs to have access here on IP ECN
field value which is only available after INET_ECN_xmit().
No functional changes.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
---
net/ipv4/tcp_output.c | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 28f840724fe8..974e4062be88 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -350,10 +350,11 @@ static void tcp_ecn_send_syn(struct sock *sk, struct sk_buff *skb)
tp->ecn_flags = 0;
if (use_ecn) {
- TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
- tcp_ecn_mode_set(tp, TCP_ECN_MODE_RFC3168);
if (tcp_ca_needs_ecn(sk) || bpf_needs_ecn)
INET_ECN_xmit(sk);
+
+ TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_RFC3168);
}
}
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 02/15] tcp: fast path functions later
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 01/15] tcp: reorganize SYN ECN code chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-23 14:24 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 03/15] tcp: reorganize tcp_sock_write_txrx group for variables later chia-yu.chang
` (12 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
The following patch will use tcp_ecn_mode_accecn(),
TCP_ACCECN_CEP_INIT_OFFSET, TCP_ACCECN_CEP_ACE_MASK in
__tcp_fast_path_on() to make new flag for AccECN.
No functional changes.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
include/net/tcp.h | 54 +++++++++++++++++++++++------------------------
1 file changed, 27 insertions(+), 27 deletions(-)
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 761c4a0ad386..ed01ae4be7a9 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -812,33 +812,6 @@ static inline u32 __tcp_set_rto(const struct tcp_sock *tp)
return usecs_to_jiffies((tp->srtt_us >> 3) + tp->rttvar_us);
}
-static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
-{
- /* mptcp hooks are only on the slow path */
- if (sk_is_mptcp((struct sock *)tp))
- return;
-
- tp->pred_flags = htonl((tp->tcp_header_len << 26) |
- ntohl(TCP_FLAG_ACK) |
- snd_wnd);
-}
-
-static inline void tcp_fast_path_on(struct tcp_sock *tp)
-{
- __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
-}
-
-static inline void tcp_fast_path_check(struct sock *sk)
-{
- struct tcp_sock *tp = tcp_sk(sk);
-
- if (RB_EMPTY_ROOT(&tp->out_of_order_queue) &&
- tp->rcv_wnd &&
- atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
- !tp->urg_data)
- tcp_fast_path_on(tp);
-}
-
u32 tcp_delack_max(const struct sock *sk);
/* Compute the actual rto_min value */
@@ -1798,6 +1771,33 @@ static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt,
return true;
}
+static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
+{
+ /* mptcp hooks are only on the slow path */
+ if (sk_is_mptcp((struct sock *)tp))
+ return;
+
+ tp->pred_flags = htonl((tp->tcp_header_len << 26) |
+ ntohl(TCP_FLAG_ACK) |
+ snd_wnd);
+}
+
+static inline void tcp_fast_path_on(struct tcp_sock *tp)
+{
+ __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
+}
+
+static inline void tcp_fast_path_check(struct sock *sk)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ if (RB_EMPTY_ROOT(&tp->out_of_order_queue) &&
+ tp->rcv_wnd &&
+ atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
+ !tp->urg_data)
+ tcp_fast_path_on(tp);
+}
+
bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
int mib_idx, u32 *last_oow_ack_time);
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 03/15] tcp: reorganize tcp_sock_write_txrx group for variables later
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 01/15] tcp: reorganize SYN ECN code chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 02/15] tcp: fast path functions later chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-23 14:37 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 04/15] tcp: AccECN core chia-yu.chang
` (11 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Use the first 3-byte hole at the beginning of the tcp_sock_write_txrx
group for 'noneagle'/'rate_app_limited' to fill in the existing hole
in later patches. Therefore, the group size of tcp_sock_write_txrx is
reduced from 92 + 4 to 91 + 4. In addition, the group size of
tcp_sock_write_rx is changed to 96 to fit in the pahole outcome.
Below are the trimmed pahole outcomes before and after this patch:
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
__cacheline_group_begin__tcp_sock_write_txrx[0]; /* 2585 0 */
/* XXX 3 bytes hole, try to pack */
[...]
struct tcp_options_received rx_opt; /* 2652 24 */
u8 nonagle:4; /* 2676: 0 1 */
u8 rate_app_limited:1; /* 2676: 4 1 */
/* XXX 3 bits hole, try to pack */
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2677 0 */
/* XXX 3 bytes hole, try to pack */
__cacheline_group_begin__tcp_sock_write_rx[0] __attribute__((__aligned__(8))); /* 2680 0 */
[...]
__cacheline_group_end__tcp_sock_write_rx[0]; /* 2776 0 */
[...]
/* size: 3264, cachelines: 51, members: 163 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
__cacheline_group_begin__tcp_sock_write_txrx[0]; /* 2585 0 */
u8 nonagle:4; /* 2585: 0 1 */
u8 rate_app_limited:1; /* 2585: 4 1 */
/* XXX 3 bits hole, try to pack */
/* XXX 2 bytes hole, try to pack */
[...]
struct tcp_options_received rx_opt; /* 2652 24 */
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2676 0 */
/* XXX 4 bytes hole, try to pack */
__cacheline_group_begin__tcp_sock_write_rx[0] __attribute__((__aligned__(8))); /* 2680 0 */
[...]
__cacheline_group_end__tcp_sock_write_rx[0]; /* 2776 0 */
[...]
/* size: 3264, cachelines: 51, members: 163 */
}
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
include/linux/tcp.h | 4 ++--
net/ipv4/tcp.c | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 1a5737b3753d..bd692764d039 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -285,6 +285,8 @@ struct tcp_sock {
* Header prediction flags
* 0x5?10 << 16 + snd_wnd in net byte order
*/
+ u8 nonagle : 4,/* Disable Nagle algorithm? */
+ rate_app_limited:1; /* rate_{delivered,interval_us} limited? */
__be32 pred_flags;
u64 tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */
u64 tcp_mstamp; /* most recent packet received/sent */
@@ -303,8 +305,6 @@ struct tcp_sock {
* Options received (usually on last packet, some only on SYN packets).
*/
struct tcp_options_received rx_opt;
- u8 nonagle : 4,/* Disable Nagle algorithm? */
- rate_app_limited:1; /* rate_{delivered,interval_us} limited? */
__cacheline_group_end(tcp_sock_write_txrx);
/* RX read-write hotpath cache lines */
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 8a3c99246d2e..18b6cb7dc02e 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -5125,7 +5125,7 @@ static void __init tcp_struct_check(void)
/* 32bit arches with 8byte alignment on u64 fields might need padding
* before tcp_clock_cache.
*/
- CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 92 + 4);
+ CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 91 + 4);
/* RX read-write hotpath cache lines */
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_received);
@@ -5142,7 +5142,7 @@ static void __init tcp_struct_check(void)
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_acked);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcv_rtt_est);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcvq_space);
- CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_rx, 99);
+ CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_rx, 96);
}
void __init tcp_init(void)
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 04/15] tcp: AccECN core
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (2 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 03/15] tcp: reorganize tcp_sock_write_txrx group for variables later chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-23 16:13 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation chia-yu.chang
` (10 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Olivier Tilmans, Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
This change implements Accurate ECN without negotiation and
AccECN Option (that will be added by later changes). Based on
AccECN specifications:
https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
Accurate ECN allows feeding back the number of CE (congestion
experienced) marks accurately to the sender in contrast to
RFC3168 ECN that can only signal one marks-seen-yes/no per RTT.
Congestion control algorithms can take advantage of the accurate
ECN information to fine-tune their congestion response to avoid
drastic rate reduction when only mild congestion is encountered.
With Accurate ECN, tp->received_ce (r.cep in AccECN spec) keeps
track of how many segments have arrived with a CE mark. Accurate
ECN uses ACE field (ECE, CWR, AE) to communicate the value back
to the sender which updates tp->delivered_ce (s.cep) based on the
feedback. This signalling channel is lossy when ACE field overflow
occurs.
Conservative strategy is selected here to deal with the ACE
overflow, however, some strategies using the AccECN option later
in the overall patchset mitigate against false overflows detected.
The ACE field values on the wire are offset by
TCP_ACCECN_CEP_INIT_OFFSET. Delivered_ce/received_ce count the
real CE marks rather than forcing all downstream users to adapt
to the wire offset.
This patch uses the first 1-byte hole and the last 4-byte hole of
the tcp_sock_write_txrx for 'received_ce_pending' and 'received_ce'.
Also, the group size of tcp_sock_write_txrx is increased from
91 + 4 to 95 + 4 due to the new u32 received_ce member. Below are
the trimmed pahole outcomes before and after this patch.
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
__cacheline_group_begin__tcp_sock_write_txrx[0]; /* 2585 0 */
u8 nonagle:4; /* 2585: 0 1 */
u8 rate_app_limited:1; /* 2585: 4 1 */
/* XXX 3 bits hole, try to pack */
/* XXX 2 bytes hole, try to pack */
[...]
u32 delivered_ce; /* 2640 4 */
u32 app_limited; /* 2644 4 */
u32 rcv_wnd; /* 2648 4 */
struct tcp_options_received rx_opt; /* 2652 24 */
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2676 0 */
/* XXX 4 bytes hole, try to pack */
[...]
/* size: 3264, cachelines: 51, members: 163 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
__cacheline_group_begin__tcp_sock_write_txrx[0]; /* 2585 0 */
u8 nonagle:4; /* 2585: 0 1 */
u8 rate_app_limited:1; /* 2585: 4 1 */
/* XXX 3 bits hole, try to pack */
/* Force alignment to the next boundary: */
u8 :0;
u8 received_ce_pending:4;/* 2586: 0 1 */
u8 unused2:4; /* 2586: 4 1 */
/* XXX 1 byte hole, try to pack */
[...]
u32 delivered_ce; /* 2640 4 */
u32 received_ce; /* 2644 4 */
u32 app_limited; /* 2648 4 */
u32 rcv_wnd; /* 2652 4 */
struct tcp_options_received rx_opt; /* 2656 24 */
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2680 0 */
[...]
/* size: 3264, cachelines: 51, members: 166 */
}
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Co-developed-by: Olivier Tilmans <olivier.tilmans@nokia.com>
Signed-off-by: Olivier Tilmans <olivier.tilmans@nokia.com>
Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v9:
- Use tcp_data_ecn_check() to set TCP_ECN_SEE flag only for RFC3168 ECN
- Add comments about setting TCP_ECN_SEEN flag for RFC3168 and Accruate ECN
---
.../networking/net_cachelines/tcp_sock.rst | 2 +
include/linux/tcp.h | 3 +
include/net/tcp.h | 26 ++++
net/ipv4/tcp.c | 4 +-
net/ipv4/tcp_input.c | 132 ++++++++++++++++--
net/ipv4/tcp_output.c | 20 ++-
6 files changed, 175 insertions(+), 12 deletions(-)
diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
index 7bbda5944ee2..31313a9adccc 100644
--- a/Documentation/networking/net_cachelines/tcp_sock.rst
+++ b/Documentation/networking/net_cachelines/tcp_sock.rst
@@ -101,6 +101,8 @@ u32 prr_delivered
u32 prr_out read_mostly read_mostly tcp_rate_skb_sent,tcp_newly_delivered(tx);tcp_ack,tcp_rate_gen,tcp_clean_rtx_queue(rx)
u32 delivered read_mostly read_write tcp_rate_skb_sent, tcp_newly_delivered(tx);tcp_ack, tcp_rate_gen, tcp_clean_rtx_queue (rx)
u32 delivered_ce read_mostly read_write tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
+u32 received_ce read_mostly read_write
+u8:4 received_ce_pending read_mostly read_write
u32 lost read_mostly tcp_ack
u32 app_limited read_write read_mostly tcp_rate_check_app_limited,tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
u64 first_tx_mstamp read_write tcp_rate_skb_sent
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index bd692764d039..874e0e45dfad 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -287,6 +287,8 @@ struct tcp_sock {
*/
u8 nonagle : 4,/* Disable Nagle algorithm? */
rate_app_limited:1; /* rate_{delivered,interval_us} limited? */
+ u8 received_ce_pending:4, /* Not yet transmit cnt of received_ce */
+ unused2:4;
__be32 pred_flags;
u64 tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */
u64 tcp_mstamp; /* most recent packet received/sent */
@@ -299,6 +301,7 @@ struct tcp_sock {
u32 snd_up; /* Urgent pointer */
u32 delivered; /* Total data packets delivered incl. rexmits */
u32 delivered_ce; /* Like the above but only ECE marked packets */
+ u32 received_ce; /* Like the above but for rcvd CE marked pkts */
u32 app_limited; /* limited until "delivered" reaches this val */
u32 rcv_wnd; /* Current receiver window */
/*
diff --git a/include/net/tcp.h b/include/net/tcp.h
index ed01ae4be7a9..6cf5cea992e3 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -415,6 +415,11 @@ static inline void tcp_ecn_mode_set(struct tcp_sock *tp, u8 mode)
tp->ecn_flags |= mode;
}
+static inline u8 tcp_accecn_ace(const struct tcphdr *th)
+{
+ return (th->ae << 2) | (th->cwr << 1) | th->ece;
+}
+
enum tcp_tw_status {
TCP_TW_SUCCESS = 0,
TCP_TW_RST = 1,
@@ -964,6 +969,20 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
#define TCPHDR_ACE (TCPHDR_ECE | TCPHDR_CWR | TCPHDR_AE)
#define TCPHDR_SYN_ECN (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR)
+#define TCP_ACCECN_CEP_ACE_MASK 0x7
+#define TCP_ACCECN_ACE_MAX_DELTA 6
+
+/* To avoid/detect middlebox interference, not all counters start at 0.
+ * See draft-ietf-tcpm-accurate-ecn for the latest values.
+ */
+#define TCP_ACCECN_CEP_INIT_OFFSET 5
+
+static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
+{
+ tp->received_ce = 0;
+ tp->received_ce_pending = 0;
+}
+
/* State flags for sacked in struct tcp_skb_cb */
enum tcp_skb_cb_sacked_flags {
TCPCB_SACKED_ACKED = (1 << 0), /* SKB ACK'd by a SACK block */
@@ -1773,11 +1792,18 @@ static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt,
static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
{
+ u32 ace;
+
/* mptcp hooks are only on the slow path */
if (sk_is_mptcp((struct sock *)tp))
return;
+ ace = tcp_ecn_mode_accecn(tp) ?
+ ((tp->delivered_ce + TCP_ACCECN_CEP_INIT_OFFSET) &
+ TCP_ACCECN_CEP_ACE_MASK) : 0;
+
tp->pred_flags = htonl((tp->tcp_header_len << 26) |
+ (ace << 22) |
ntohl(TCP_FLAG_ACK) |
snd_wnd);
}
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 18b6cb7dc02e..8e0e8d784b1c 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3392,6 +3392,7 @@ int tcp_disconnect(struct sock *sk, int flags)
tp->window_clamp = 0;
tp->delivered = 0;
tp->delivered_ce = 0;
+ tcp_accecn_init_counters(tp);
if (icsk->icsk_ca_initialized && icsk->icsk_ca_ops->release)
icsk->icsk_ca_ops->release(sk);
memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv));
@@ -5118,6 +5119,7 @@ static void __init tcp_struct_check(void)
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, snd_up);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, delivered);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, delivered_ce);
+ CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, received_ce);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, app_limited);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, rcv_wnd);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, rx_opt);
@@ -5125,7 +5127,7 @@ static void __init tcp_struct_check(void)
/* 32bit arches with 8byte alignment on u64 fields might need padding
* before tcp_clock_cache.
*/
- CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 91 + 4);
+ CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 95 + 4);
/* RX read-write hotpath cache lines */
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_received);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 19a1542883df..0fa3803b353d 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -341,14 +341,17 @@ static bool tcp_in_quickack_mode(struct sock *sk)
static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
{
+ /* Do not set CWR if in AccECN mode! */
if (tcp_ecn_mode_rfc3168(tp))
tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}
static void tcp_ecn_accept_cwr(struct sock *sk, const struct sk_buff *skb)
{
- if (tcp_hdr(skb)->cwr) {
- tcp_sk(sk)->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ if (tcp_ecn_mode_rfc3168(tp) && tcp_hdr(skb)->cwr) {
+ tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
/* If the sender is telling us it has entered CWR, then its
* cwnd may be very low (even just 1 packet), so we should ACK
@@ -384,16 +387,25 @@ static void tcp_data_ecn_check(struct sock *sk, const struct sk_buff *skb)
if (tcp_ca_needs_ecn(sk))
tcp_ca_event(sk, CA_EVENT_ECN_IS_CE);
- if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
+ if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR) &&
+ tcp_ecn_mode_rfc3168(tp)) {
/* Better not delay acks, sender can have a very low cwnd */
tcp_enter_quickack_mode(sk, 2);
tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
}
+ /* As for RFC3168 ECN, the TCP_ECN_SEEN flag is set by
+ * tcp_data_ecn_check() when the ECN codepoint of
+ * received TCP data contains ECT(0), ECT(1), or CE.
+ */
+ if (!tcp_ecn_mode_rfc3168(tp))
+ break;
tp->ecn_flags |= TCP_ECN_SEEN;
break;
default:
if (tcp_ca_needs_ecn(sk))
tcp_ca_event(sk, CA_EVENT_ECN_NO_CE);
+ if (!tcp_ecn_mode_rfc3168(tp))
+ break;
tp->ecn_flags |= TCP_ECN_SEEN;
break;
}
@@ -428,10 +440,64 @@ static void tcp_count_delivered(struct tcp_sock *tp, u32 delivered,
bool ece_ack)
{
tp->delivered += delivered;
- if (ece_ack)
+ if (tcp_ecn_mode_rfc3168(tp) && ece_ack)
tcp_count_delivered_ce(tp, delivered);
}
+/* Returns the ECN CE delta */
+static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
+ u32 delivered_pkts, int flag)
+{
+ const struct tcphdr *th = tcp_hdr(skb);
+ struct tcp_sock *tp = tcp_sk(sk);
+ u32 delta, safe_delta;
+ u32 corrected_ace;
+
+ /* Reordered ACK or uncertain due to lack of data to send and ts */
+ if (!(flag & (FLAG_FORWARD_PROGRESS | FLAG_TS_PROGRESS)))
+ return 0;
+
+ if (!(flag & FLAG_SLOWPATH)) {
+ /* AccECN counter might overflow on large ACKs */
+ if (delivered_pkts <= TCP_ACCECN_CEP_ACE_MASK)
+ return 0;
+ }
+
+ /* ACE field is not available during handshake */
+ if (flag & FLAG_SYN_ACKED)
+ return 0;
+
+ if (tp->received_ce_pending >= TCP_ACCECN_ACE_MAX_DELTA)
+ inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_NOW;
+
+ corrected_ace = tcp_accecn_ace(th) - TCP_ACCECN_CEP_INIT_OFFSET;
+ delta = (corrected_ace - tp->delivered_ce) & TCP_ACCECN_CEP_ACE_MASK;
+ if (delivered_pkts <= TCP_ACCECN_CEP_ACE_MASK)
+ return delta;
+
+ safe_delta = delivered_pkts -
+ ((delivered_pkts - delta) & TCP_ACCECN_CEP_ACE_MASK);
+
+ return safe_delta;
+}
+
+static u32 tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
+ u32 delivered_pkts, int *flag)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+ u32 delta;
+
+ delta = __tcp_accecn_process(sk, skb, delivered_pkts, *flag);
+ if (delta > 0) {
+ tcp_count_delivered_ce(tp, delta);
+ *flag |= FLAG_ECE;
+ /* Recalculate header predictor */
+ if (tp->pred_flags)
+ tcp_fast_path_on(tp);
+ }
+ return delta;
+}
+
/* Buffer size and advertised window tuning.
*
* 1. Tuning sk->sk_sndbuf, when connection enters established state.
@@ -3787,7 +3853,8 @@ static void tcp_xmit_recovery(struct sock *sk, int rexmit)
}
/* Returns the number of packets newly acked or sacked by the current ACK */
-static u32 tcp_newly_delivered(struct sock *sk, u32 prior_delivered, int flag)
+static u32 tcp_newly_delivered(struct sock *sk, u32 prior_delivered,
+ u32 ecn_count, int flag)
{
const struct net *net = sock_net(sk);
struct tcp_sock *tp = tcp_sk(sk);
@@ -3795,8 +3862,12 @@ static u32 tcp_newly_delivered(struct sock *sk, u32 prior_delivered, int flag)
delivered = tp->delivered - prior_delivered;
NET_ADD_STATS(net, LINUX_MIB_TCPDELIVERED, delivered);
- if (flag & FLAG_ECE)
- NET_ADD_STATS(net, LINUX_MIB_TCPDELIVEREDCE, delivered);
+
+ if (flag & FLAG_ECE) {
+ if (tcp_ecn_mode_rfc3168(tp))
+ ecn_count = delivered;
+ NET_ADD_STATS(net, LINUX_MIB_TCPDELIVEREDCE, ecn_count);
+ }
return delivered;
}
@@ -3817,6 +3888,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
u32 delivered = tp->delivered;
u32 lost = tp->lost;
int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */
+ u32 ecn_count = 0; /* Did we receive ECE/an AccECN ACE update? */
u32 prior_fack;
sack_state.first_sackt = 0;
@@ -3924,6 +3996,11 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
tcp_rack_update_reo_wnd(sk, &rs);
+ if (tcp_ecn_mode_accecn(tp))
+ ecn_count = tcp_accecn_process(sk, skb,
+ tp->delivered - delivered,
+ &flag);
+
tcp_in_ack_event(sk, flag);
if (tp->tlp_high_seq)
@@ -3948,7 +4025,8 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
sk_dst_confirm(sk);
- delivered = tcp_newly_delivered(sk, delivered, flag);
+ delivered = tcp_newly_delivered(sk, delivered, ecn_count, flag);
+
lost = tp->lost - lost; /* freshly marked lost */
rs.is_ack_delayed = !!(flag & FLAG_ACK_MAYBE_DELAYED);
tcp_rate_gen(sk, delivered, lost, is_sack_reneg, sack_state.rate);
@@ -3957,12 +4035,16 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
return 1;
no_queue:
+ if (tcp_ecn_mode_accecn(tp))
+ ecn_count = tcp_accecn_process(sk, skb,
+ tp->delivered - delivered,
+ &flag);
tcp_in_ack_event(sk, flag);
/* If data was DSACKed, see if we can undo a cwnd reduction. */
if (flag & FLAG_DSACKING_ACK) {
tcp_fastretrans_alert(sk, prior_snd_una, num_dupack, &flag,
&rexmit);
- tcp_newly_delivered(sk, delivered, flag);
+ tcp_newly_delivered(sk, delivered, ecn_count, flag);
}
/* If this ack opens up a zero window, clear backoff. It was
* being used to time the probes, and is probably far higher than
@@ -3983,7 +4065,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
&sack_state);
tcp_fastretrans_alert(sk, prior_snd_una, num_dupack, &flag,
&rexmit);
- tcp_newly_delivered(sk, delivered, flag);
+ tcp_newly_delivered(sk, delivered, ecn_count, flag);
tcp_xmit_recovery(sk, rexmit);
}
@@ -5821,6 +5903,31 @@ static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *t
}
}
+/* Updates Accurate ECN received counters from the received IP ECN field */
+static void tcp_ecn_received_counters(struct sock *sk,
+ const struct sk_buff *skb)
+{
+ u8 ecnfield = TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK;
+ u8 is_ce = INET_ECN_is_ce(ecnfield);
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ if (!INET_ECN_is_not_ect(ecnfield)) {
+ u32 pcount = is_ce * max_t(u16, 1, skb_shinfo(skb)->gso_segs);
+
+ /* As for accurate ECN, the TCP_ECN_SEEN flag is set by
+ * tcp_ecn_received_counters() when the ECN codepoint of
+ * received TCP data or ACK contains ECT(0), ECT(1), or CE.
+ */
+ if (!tcp_ecn_mode_rfc3168(tp))
+ tp->ecn_flags |= TCP_ECN_SEEN;
+
+ /* ACE counter tracks *all* segments including pure ACKs */
+ tp->received_ce += pcount;
+ tp->received_ce_pending = min(tp->received_ce_pending + pcount,
+ 0xfU);
+ }
+}
+
/* Accept RST for rcv_nxt - 1 after a FIN.
* When tcp connections are abruptly terminated from Mac OSX (via ^C), a
* FIN is sent followed by a RST packet. The RST is sent with the same
@@ -6083,6 +6190,8 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
flag |= __tcp_replace_ts_recent(tp,
delta);
+ tcp_ecn_received_counters(sk, skb);
+
/* We know that such packets are checksummed
* on entry.
*/
@@ -6127,6 +6236,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
/* Bulk data transfer: receiver */
tcp_cleanup_skb(skb);
__skb_pull(skb, tcp_header_len);
+ tcp_ecn_received_counters(sk, skb);
eaten = tcp_queue_rcv(sk, skb, &fragstolen);
tcp_event_data_recv(sk, skb);
@@ -6167,6 +6277,8 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
return;
step5:
+ tcp_ecn_received_counters(sk, skb);
+
reason = tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT);
if ((int)reason < 0) {
reason = -reason;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 974e4062be88..4b32aa619594 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -374,6 +374,17 @@ tcp_ecn_make_synack(const struct request_sock *req, struct tcphdr *th)
th->ece = 1;
}
+static void tcp_accecn_set_ace(struct tcphdr *th, struct tcp_sock *tp)
+{
+ u32 wire_ace;
+
+ wire_ace = tp->received_ce + TCP_ACCECN_CEP_INIT_OFFSET;
+ th->ece = !!(wire_ace & 0x1);
+ th->cwr = !!(wire_ace & 0x2);
+ th->ae = !!(wire_ace & 0x4);
+ tp->received_ce_pending = 0;
+}
+
/* Set up ECN state for a packet on a ESTABLISHED socket that is about to
* be sent.
*/
@@ -382,7 +393,14 @@ static void tcp_ecn_send(struct sock *sk, struct sk_buff *skb,
{
struct tcp_sock *tp = tcp_sk(sk);
- if (tcp_ecn_mode_rfc3168(tp)) {
+ if (!tcp_ecn_mode_any(tp))
+ return;
+
+ if (tcp_ecn_mode_accecn(tp)) {
+ INET_ECN_xmit(sk);
+ tcp_accecn_set_ace(th, tp);
+ skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ACCECN;
+ } else {
/* Not-retransmitted data segment: set ECT and inject CWR. */
if (skb->len != tcp_header_len &&
!before(TCP_SKB_CB(skb)->seq, tp->snd_nxt)) {
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (3 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 04/15] tcp: AccECN core chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-25 7:57 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters chia-yu.chang
` (9 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Olivier Tilmans, Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
Accurate ECN negotiation parts based on the specification:
https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
Accurate ECN is negotiated using ECE, CWR and AE flags in the
TCP header. TCP falls back into using RFC3168 ECN if one of the
ends supports only RFC3168-style ECN.
The AccECN negotiation includes reflecting IP ECN field value
seen in SYN and SYNACK back using the same bits as negotiation
to allow responding to SYN CE marks and to detect ECN field
mangling. CE marks should not occur currently because SYN=1
segments are sent with Non-ECT in IP ECN field (but proposal
exists to remove this restriction).
Reflecting SYN IP ECN field in SYNACK is relatively simple.
Reflecting SYNACK IP ECN field in the final/third ACK of
the handshake is more challenging. Linux TCP code is not well
prepared for using the final/third ACK a signalling channel
which makes things somewhat complicated here.
tcp_ecn sysctl can be used to select the highest ECN variant
(Accurate ECN, ECN, No ECN) that is attemped to be negotiated and
requested for incoming connection and outgoing connection:
TCP_ECN_IN_NOECN_OUT_NOECN, TCP_ECN_IN_ECN_OUT_ECN,
TCP_ECN_IN_ECN_OUT_NOECN, TCP_ECN_IN_ACCECN_OUT_ACCECN,
TCP_ECN_IN_ACCECN_OUT_ECN, and TCP_ECN_IN_ACCECN_OUT_NOECN.
After this patch, the size of tcp_request_sock remains unchanged
and no new holes are added. Below are the pahole outcomes before
and after this patch:
[BEFORE THIS PATCH]
struct tcp_request_sock {
[...]
u32 rcv_nxt; /* 352 4 */
u8 syn_tos; /* 356 1 */
/* size: 360, cachelines: 6, members: 16 */
}
[AFTER THIS PATCH]
struct tcp_request_sock {
[...]
u32 rcv_nxt; /* 352 4 */
u8 syn_tos; /* 356 1 */
bool accecn_ok; /* 357 1 */
u8 syn_ect_snt:2; /* 358: 0 1 */
u8 syn_ect_rcv:2; /* 358: 2 1 */
u8 accecn_fail_mode:4; /* 358: 4 1 */
/* size: 360, cachelines: 6, members: 20 */
}
After this patch, the size of tcp_sock remains unchanged and no new
holes are added. Also, 4 bits of the existing 2-byte hole are exploited.
Below are the pahole outcomes before and after this patch:
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
u8 dup_ack_counter:2; /* 2825: 0 1 */
u8 tlp_retrans:1; /* 2825: 2 1 */
u8 unused:5; /* 2825: 3 1 */
u8 thin_lto:1; /* 2826: 0 1 */
u8 fastopen_connect:1; /* 2826: 1 1 */
u8 fastopen_no_cookie:1; /* 2826: 2 1 */
u8 fastopen_client_fail:2; /* 2826: 3 1 */
u8 frto:1; /* 2826: 5 1 */
/* XXX 2 bits hole, try to pack */
[...]
u8 keepalive_probes; /* 2829 1 */
/* XXX 2 bytes hole, try to pack */
[...]
/* size: 3264, cachelines: 51, members: 166 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
u8 dup_ack_counter:2; /* 2825: 0 1 */
u8 tlp_retrans:1; /* 2825: 2 1 */
u8 syn_ect_snt:2; /* 2825: 3 1 */
u8 syn_ect_rcv:2; /* 2825: 5 1 */
u8 wait_third_ack:1; /* 2825: 7 1 */
u8 thin_lto:1; /* 2826: 0 1 */
u8 fastopen_connect:1; /* 2826: 1 1 */
u8 fastopen_no_cookie:1; /* 2826: 2 1 */
u8 fastopen_client_fail:2; /* 2826: 3 1 */
u8 frto:1; /* 2826: 5 1 */
/* XXX 2 bits hole, try to pack */
[...]
u8 keepalive_probes; /* 2829 1 */
u8 accecn_fail_mode:4; /* 2830: 0 1 */
/* XXX 4 bits hole, try to pack */
/* XXX 1 byte hole, try to pack */
[...]
/* size: 3264, cachelines: 51, members: 169 */
}
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Co-developed-by: Olivier Tilmans <olivier.tilmans@nokia.com>
Signed-off-by: Olivier Tilmans <olivier.tilmans@nokia.com>
Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
.../networking/net_cachelines/tcp_sock.rst | 4 +
include/linux/tcp.h | 9 +-
include/net/tcp.h | 93 ++++++++-
net/ipv4/syncookies.c | 3 +
net/ipv4/sysctl_net_ipv4.c | 3 +-
net/ipv4/tcp.c | 2 +
net/ipv4/tcp_input.c | 178 ++++++++++++++++--
net/ipv4/tcp_ipv4.c | 5 +-
net/ipv4/tcp_minisocks.c | 51 ++++-
net/ipv4/tcp_output.c | 78 ++++++--
net/ipv6/syncookies.c | 1 +
net/ipv6/tcp_ipv6.c | 1 +
12 files changed, 384 insertions(+), 44 deletions(-)
diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
index 31313a9adccc..22ac668fe6c7 100644
--- a/Documentation/networking/net_cachelines/tcp_sock.rst
+++ b/Documentation/networking/net_cachelines/tcp_sock.rst
@@ -103,6 +103,10 @@ u32 delivered read_mostly read_w
u32 delivered_ce read_mostly read_write tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
u32 received_ce read_mostly read_write
u8:4 received_ce_pending read_mostly read_write
+u8:2 syn_ect_snt write_mostly read_write
+u8:2 syn_ect_rcv read_mostly read_write
+u8:1 wait_third_ack read_write
+u8:4 accecn_fail_mode
u32 lost read_mostly tcp_ack
u32 app_limited read_write read_mostly tcp_rate_check_app_limited,tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
u64 first_tx_mstamp read_write tcp_rate_skb_sent
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 874e0e45dfad..1d8301f2883c 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -168,6 +168,10 @@ struct tcp_request_sock {
* after data-in-SYN.
*/
u8 syn_tos;
+ bool accecn_ok;
+ u8 syn_ect_snt: 2,
+ syn_ect_rcv: 2,
+ accecn_fail_mode:4;
#ifdef CONFIG_TCP_AO
u8 ao_keyid;
u8 ao_rcv_next;
@@ -375,7 +379,9 @@ struct tcp_sock {
u8 compressed_ack;
u8 dup_ack_counter:2,
tlp_retrans:1, /* TLP is a retransmission */
- unused:5;
+ syn_ect_snt:2, /* AccECN ECT memory, only */
+ syn_ect_rcv:2, /* ... needed durign 3WHS + first seqno */
+ wait_third_ack:1; /* Wait 3rd ACK in simultaneous open */
u8 thin_lto : 1,/* Use linear timeouts for thin streams */
fastopen_connect:1, /* FASTOPEN_CONNECT sockopt */
fastopen_no_cookie:1, /* Allow send/recv SYN+data without a cookie */
@@ -391,6 +397,7 @@ struct tcp_sock {
syn_fastopen_child:1; /* created TFO passive child socket */
u8 keepalive_probes; /* num of allowed keep alive probes */
+ u8 accecn_fail_mode:4; /* AccECN failure handling */
u32 tcp_tx_delay; /* delay (in usec) added to TX packets */
/* RTT measurement */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 6cf5cea992e3..4d6325fa3f67 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -27,6 +27,7 @@
#include <linux/ktime.h>
#include <linux/indirect_call_wrapper.h>
#include <linux/bits.h>
+#include <linux/bitfield.h>
#include <net/inet_connection_sock.h>
#include <net/inet_timewait_sock.h>
@@ -234,6 +235,37 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
#define TCPOLEN_MSS_ALIGNED 4
#define TCPOLEN_EXP_SMC_BASE_ALIGNED 8
+/* tp->accecn_fail_mode */
+#define TCP_ACCECN_ACE_FAIL_SEND BIT(0)
+#define TCP_ACCECN_ACE_FAIL_RECV BIT(1)
+#define TCP_ACCECN_OPT_FAIL_SEND BIT(2)
+#define TCP_ACCECN_OPT_FAIL_RECV BIT(3)
+
+static inline bool tcp_accecn_ace_fail_send(const struct tcp_sock *tp)
+{
+ return tp->accecn_fail_mode & TCP_ACCECN_ACE_FAIL_SEND;
+}
+
+static inline bool tcp_accecn_ace_fail_recv(const struct tcp_sock *tp)
+{
+ return tp->accecn_fail_mode & TCP_ACCECN_ACE_FAIL_RECV;
+}
+
+static inline bool tcp_accecn_opt_fail_send(const struct tcp_sock *tp)
+{
+ return tp->accecn_fail_mode & TCP_ACCECN_OPT_FAIL_SEND;
+}
+
+static inline bool tcp_accecn_opt_fail_recv(const struct tcp_sock *tp)
+{
+ return tp->accecn_fail_mode & TCP_ACCECN_OPT_FAIL_RECV;
+}
+
+static inline void tcp_accecn_fail_mode_set(struct tcp_sock *tp, u8 mode)
+{
+ tp->accecn_fail_mode |= mode;
+}
+
/* Flags in tp->nonagle */
#define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */
#define TCP_NAGLE_CORK 2 /* Socket is corked */
@@ -420,6 +452,23 @@ static inline u8 tcp_accecn_ace(const struct tcphdr *th)
return (th->ae << 2) | (th->cwr << 1) | th->ece;
}
+/* Infer the ECT value our SYN arrived with from the echoed ACE field */
+static inline int tcp_accecn_extract_syn_ect(u8 ace)
+{
+ if (ace & 0x1)
+ return INET_ECN_ECT_1;
+ if (!(ace & 0x2))
+ return INET_ECN_ECT_0;
+ if (ace & 0x4)
+ return INET_ECN_CE;
+ return INET_ECN_NOT_ECT;
+}
+
+bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect);
+void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
+ u8 syn_ect_snt);
+void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb);
+
enum tcp_tw_status {
TCP_TW_SUCCESS = 0,
TCP_TW_RST = 1,
@@ -657,6 +706,15 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *
dst_feature(dst, RTAX_FEATURE_ECN);
}
+/* AccECN specification, 5.1: [...] a server can determine that it
+ * negotiated AccECN as [...] if the ACK contains an ACE field with
+ * the value 0b010 to 0b111 (decimal 2 to 7).
+ */
+static inline bool cookie_accecn_ok(const struct tcphdr *th)
+{
+ return tcp_accecn_ace(th) > 0x1;
+}
+
#if IS_ENABLED(CONFIG_BPF)
static inline bool cookie_bpf_ok(struct sk_buff *skb)
{
@@ -968,6 +1026,7 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
#define TCPHDR_ACE (TCPHDR_ECE | TCPHDR_CWR | TCPHDR_AE)
#define TCPHDR_SYN_ECN (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR)
+#define TCPHDR_SYNACK_ACCECN (TCPHDR_SYN | TCPHDR_ACK | TCPHDR_CWR)
#define TCP_ACCECN_CEP_ACE_MASK 0x7
#define TCP_ACCECN_ACE_MAX_DELTA 6
@@ -977,6 +1036,19 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
*/
#define TCP_ACCECN_CEP_INIT_OFFSET 5
+/* The highest ECN variant (Accurate ECN, ECN, or no ECN) that is
+ * attemped to be negotiated and requested for incoming connection
+ * and outgoing connection, respectively.
+ */
+enum tcp_ecn_mode {
+ TCP_ECN_IN_NOECN_OUT_NOECN = 0,
+ TCP_ECN_IN_ECN_OUT_ECN = 1,
+ TCP_ECN_IN_ECN_OUT_NOECN = 2,
+ TCP_ECN_IN_ACCECN_OUT_ACCECN = 3,
+ TCP_ECN_IN_ACCECN_OUT_ECN = 4,
+ TCP_ECN_IN_ACCECN_OUT_NOECN = 5,
+};
+
static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
{
tp->received_ce = 0;
@@ -1051,6 +1123,15 @@ struct tcp_skb_cb {
#define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0]))
+static inline u16 tcp_accecn_reflector_flags(u8 ect)
+{
+ u32 flags = ect + 2;
+
+ if (ect == 3)
+ flags++;
+ return FIELD_PREP(TCPHDR_ACE, flags);
+}
+
extern const struct inet_connection_sock_af_ops ipv4_specific;
#if IS_ENABLED(CONFIG_IPV6)
@@ -1173,7 +1254,10 @@ enum tcp_ca_ack_event_flags {
#define TCP_CONG_NON_RESTRICTED BIT(0)
/* Requires ECN/ECT set on all packets */
#define TCP_CONG_NEEDS_ECN BIT(1)
-#define TCP_CONG_MASK (TCP_CONG_NON_RESTRICTED | TCP_CONG_NEEDS_ECN)
+/* Require successfully negotiated AccECN capability */
+#define TCP_CONG_NEEDS_ACCECN BIT(2)
+#define TCP_CONG_MASK (TCP_CONG_NON_RESTRICTED | TCP_CONG_NEEDS_ECN | \
+ TCP_CONG_NEEDS_ACCECN)
union tcp_cc_info;
@@ -1305,6 +1389,13 @@ static inline bool tcp_ca_needs_ecn(const struct sock *sk)
return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ECN;
}
+static inline bool tcp_ca_needs_accecn(const struct sock *sk)
+{
+ const struct inet_connection_sock *icsk = inet_csk(sk);
+
+ return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ACCECN;
+}
+
static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
{
const struct inet_connection_sock *icsk = inet_csk(sk);
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index 5459a78b9809..3a44eb9c1d1a 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -403,6 +403,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
struct tcp_sock *tp = tcp_sk(sk);
struct inet_request_sock *ireq;
struct net *net = sock_net(sk);
+ struct tcp_request_sock *treq;
struct request_sock *req;
struct sock *ret = sk;
struct flowi4 fl4;
@@ -428,6 +429,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
}
ireq = inet_rsk(req);
+ treq = tcp_rsk(req);
sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
@@ -482,6 +484,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
if (!req->syncookie)
ireq->rcv_wscale = rcv_wscale;
ireq->ecn_ok &= cookie_ecn_ok(net, &rt->dst);
+ treq->accecn_ok = ireq->ecn_ok && cookie_accecn_ok(th);
ret = tcp_get_cookie_sock(sk, skb, req, &rt->dst);
/* ip_queue_xmit() depends on our flow being setup
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 3a43010d726f..75ec1a599b52 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -47,6 +47,7 @@ static unsigned int udp_child_hash_entries_max = UDP_HTABLE_SIZE_MAX;
static int tcp_plb_max_rounds = 31;
static int tcp_plb_max_cong_thresh = 256;
static unsigned int tcp_tw_reuse_delay_max = TCP_PAWS_MSL * MSEC_PER_SEC;
+static int tcp_ecn_mode_max = 5;
/* obsolete */
static int sysctl_tcp_low_latency __read_mostly;
@@ -728,7 +729,7 @@ static struct ctl_table ipv4_net_table[] = {
.mode = 0644,
.proc_handler = proc_dou8vec_minmax,
.extra1 = SYSCTL_ZERO,
- .extra2 = SYSCTL_TWO,
+ .extra2 = &tcp_ecn_mode_max,
},
{
.procname = "tcp_ecn_fallback",
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 8e0e8d784b1c..e6d7b5420c88 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3392,6 +3392,8 @@ int tcp_disconnect(struct sock *sk, int flags)
tp->window_clamp = 0;
tp->delivered = 0;
tp->delivered_ce = 0;
+ tp->wait_third_ack = 0;
+ tp->accecn_fail_mode = 0;
tcp_accecn_init_counters(tp);
if (icsk->icsk_ca_initialized && icsk->icsk_ca_ops->release)
icsk->icsk_ca_ops->release(sk);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 0fa3803b353d..c986452302cb 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -411,14 +411,114 @@ static void tcp_data_ecn_check(struct sock *sk, const struct sk_buff *skb)
}
}
-static void tcp_ecn_rcv_synack(struct tcp_sock *tp, const struct tcphdr *th)
+/* AccECN specificaiton, 3.1.2: If a TCP server that implements AccECN
+ * receives a SYN with the three TCP header flags (AE, CWR and ECE) set
+ * to any combination other than 000, 011 or 111, it MUST negotiate the
+ * use of AccECN as if they had been set to 111.
+ */
+static bool tcp_accecn_syn_requested(const struct tcphdr *th)
+{
+ u8 ace = tcp_accecn_ace(th);
+
+ return ace && ace != 0x3;
+}
+
+/* Check ECN field transition to detect invalid transitions */
+static bool tcp_ect_transition_valid(u8 snt, u8 rcv)
{
- if (tcp_ecn_mode_rfc3168(tp) && (!th->ece || th->cwr))
+ if (rcv == snt)
+ return true;
+
+ /* Non-ECT altered to something or something became non-ECT */
+ if (snt == INET_ECN_NOT_ECT || rcv == INET_ECN_NOT_ECT)
+ return false;
+ /* CE -> ECT(0/1)? */
+ if (snt == INET_ECN_CE)
+ return false;
+ return true;
+}
+
+bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect)
+{
+ u8 ect = tcp_accecn_extract_syn_ect(ace);
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ if (!sock_net(sk)->ipv4.sysctl_tcp_ecn_fallback)
+ return true;
+
+ if (!tcp_ect_transition_valid(sent_ect, ect)) {
+ tcp_accecn_fail_mode_set(tp, TCP_ACCECN_ACE_FAIL_RECV);
+ return false;
+ }
+
+ return true;
+}
+
+/* See Table 2 of the AccECN draft */
+
+static void tcp_ecn_rcv_synack(struct sock *sk, const struct tcphdr *th,
+ u8 ip_dsfield)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+ u8 ace = tcp_accecn_ace(th);
+
+ switch (ace) {
+ case 0x0:
+ case 0x7:
+ /* +========+========+============+=============+
+ * | A | B | SYN/ACK | Feedback |
+ * | | | B->A | Mode of A |
+ * | | | AE CWR ECE | |
+ * +========+========+============+=============+
+ * | AccECN | No ECN | 0 0 0 | Not ECN |
+ * | AccECN | Broken | 1 1 1 | Not ECN |
+ * +--------+--------+------------+-------------+
+ */
tcp_ecn_mode_set(tp, TCP_ECN_DISABLED);
+ break;
+ case 0x1:
+ case 0x5:
+ /* +========+========+============+=============+
+ * | A | B | SYN/ACK | Feedback |
+ * | | | B->A | Mode of A |
+ * | | | AE CWR ECE | |
+ * +========+========+============+=============+
+ * | AccECN | Nonce | 1 0 1 | (Reserved) |
+ * | AccECN | ECN | 0 0 1 | Classic ECN |
+ * | Nonce | AccECN | 0 0 1 | Classic ECN |
+ * | ECN | AccECN | 0 0 1 | Classic ECN |
+ * +--------+--------+------------+-------------+
+ */
+ if (tcp_ecn_mode_pending(tp))
+ /* Downgrade from AccECN, or requested initially */
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_RFC3168);
+ break;
+ default:
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
+ tp->syn_ect_rcv = ip_dsfield & INET_ECN_MASK;
+ if (INET_ECN_is_ce(ip_dsfield) &&
+ tcp_accecn_validate_syn_feedback(sk, ace,
+ tp->syn_ect_snt)) {
+ tp->received_ce++;
+ tp->received_ce_pending++;
+ }
+ break;
+ }
}
-static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
+static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th,
+ const struct sk_buff *skb)
{
+ if (tcp_ecn_mode_pending(tp)) {
+ if (!tcp_accecn_syn_requested(th)) {
+ /* Downgrade to classic ECN feedback */
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_RFC3168);
+ } else {
+ tp->syn_ect_rcv = TCP_SKB_CB(skb)->ip_dsfield &
+ INET_ECN_MASK;
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
+ }
+ }
if (tcp_ecn_mode_rfc3168(tp) && (!th->ece || !th->cwr))
tcp_ecn_mode_set(tp, TCP_ECN_DISABLED);
}
@@ -3711,8 +3811,18 @@ bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
return __tcp_oow_rate_limited(net, mib_idx, last_oow_ack_time);
}
+static void tcp_send_ack_reflect_ect(struct sock *sk, bool accecn_reflector)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+ u16 flags = 0;
+
+ if (accecn_reflector)
+ flags = tcp_accecn_reflector_flags(tp->syn_ect_rcv);
+ __tcp_send_ack(sk, tp->rcv_nxt, flags);
+}
+
/* RFC 5961 7 [ACK Throttling] */
-static void tcp_send_challenge_ack(struct sock *sk)
+static void tcp_send_challenge_ack(struct sock *sk, bool accecn_reflector)
{
struct tcp_sock *tp = tcp_sk(sk);
struct net *net = sock_net(sk);
@@ -3742,7 +3852,7 @@ static void tcp_send_challenge_ack(struct sock *sk)
WRITE_ONCE(net->ipv4.tcp_challenge_count, count - 1);
send_ack:
NET_INC_STATS(net, LINUX_MIB_TCPCHALLENGEACK);
- tcp_send_ack(sk);
+ tcp_send_ack_reflect_ect(sk, accecn_reflector);
}
}
@@ -3909,7 +4019,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
/* RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation] */
if (before(ack, prior_snd_una - max_window)) {
if (!(flag & FLAG_NO_CHALLENGE_ACK))
- tcp_send_challenge_ack(sk);
+ tcp_send_challenge_ack(sk, false);
return -SKB_DROP_REASON_TCP_TOO_OLD_ACK;
}
goto old_ack;
@@ -5904,8 +6014,7 @@ static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *t
}
/* Updates Accurate ECN received counters from the received IP ECN field */
-static void tcp_ecn_received_counters(struct sock *sk,
- const struct sk_buff *skb)
+void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb)
{
u8 ecnfield = TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK;
u8 is_ce = INET_ECN_is_ce(ecnfield);
@@ -5952,6 +6061,7 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
const struct tcphdr *th, int syn_inerr)
{
struct tcp_sock *tp = tcp_sk(sk);
+ bool accecn_reflector = false;
SKB_DR(reason);
/* RFC1323: H1. Apply PAWS check first. */
@@ -6044,7 +6154,7 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
if (tp->syn_fastopen && !tp->data_segs_in &&
sk->sk_state == TCP_ESTABLISHED)
tcp_fastopen_active_disable(sk);
- tcp_send_challenge_ack(sk);
+ tcp_send_challenge_ack(sk, false);
SKB_DR_SET(reason, TCP_RESET);
goto discard;
}
@@ -6055,16 +6165,23 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
* RFC 5961 4.2 : Send a challenge ack
*/
if (th->syn) {
+ if (tcp_ecn_mode_accecn(tp))
+ accecn_reflector = true;
if (sk->sk_state == TCP_SYN_RECV && sk->sk_socket && th->ack &&
TCP_SKB_CB(skb)->seq + 1 == TCP_SKB_CB(skb)->end_seq &&
TCP_SKB_CB(skb)->seq + 1 == tp->rcv_nxt &&
- TCP_SKB_CB(skb)->ack_seq == tp->snd_nxt)
+ TCP_SKB_CB(skb)->ack_seq == tp->snd_nxt) {
+ if (!tcp_ecn_disabled(tp)) {
+ tp->wait_third_ack = true;
+ tcp_send_ack_reflect_ect(sk, accecn_reflector);
+ }
goto pass;
+ }
syn_challenge:
if (syn_inerr)
TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
- tcp_send_challenge_ack(sk);
+ tcp_send_challenge_ack(sk, accecn_reflector);
SKB_DR_SET(reason, TCP_INVALID_SYN);
goto discard;
}
@@ -6277,6 +6394,12 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
return;
step5:
+ if (unlikely(tp->wait_third_ack)) {
+ tp->wait_third_ack = 0;
+ if (tcp_ecn_mode_accecn(tp))
+ tcp_accecn_third_ack(sk, skb, tp->syn_ect_snt);
+ tcp_fast_path_on(tp);
+ }
tcp_ecn_received_counters(sk, skb);
reason = tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT);
@@ -6529,7 +6652,8 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
* state to ESTABLISHED..."
*/
- tcp_ecn_rcv_synack(tp, th);
+ if (tcp_ecn_mode_any(tp))
+ tcp_ecn_rcv_synack(sk, th, TCP_SKB_CB(skb)->ip_dsfield);
tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
tcp_try_undo_spurious_syn(sk);
@@ -6601,7 +6725,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
TCP_DELACK_MAX, false);
goto consume;
}
- tcp_send_ack(sk);
+ tcp_send_ack_reflect_ect(sk, tcp_ecn_mode_accecn(tp));
return -1;
}
@@ -6660,7 +6784,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
tp->snd_wl1 = TCP_SKB_CB(skb)->seq;
tp->max_window = tp->snd_wnd;
- tcp_ecn_rcv_syn(tp, th);
+ tcp_ecn_rcv_syn(tp, th, skb);
tcp_mtup_init(sk);
tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
@@ -6842,7 +6966,7 @@ tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
}
/* accept old ack during closing */
if ((int)reason < 0) {
- tcp_send_challenge_ack(sk);
+ tcp_send_challenge_ack(sk, false);
reason = -reason;
goto discard;
}
@@ -6889,9 +7013,16 @@ tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
tp->lsndtime = tcp_jiffies32;
tcp_initialize_rcv_mss(sk);
- tcp_fast_path_on(tp);
+ if (likely(!tp->wait_third_ack)) {
+ if (tcp_ecn_mode_accecn(tp))
+ tcp_accecn_third_ack(sk, skb, tp->syn_ect_snt);
+ tcp_fast_path_on(tp);
+ }
if (sk->sk_shutdown & SEND_SHUTDOWN)
tcp_shutdown(sk, SEND_SHUTDOWN);
+
+ if (sk->sk_socket && tp->wait_third_ack)
+ goto consume;
break;
case TCP_FIN_WAIT1: {
@@ -7061,6 +7192,15 @@ static void tcp_ecn_create_request(struct request_sock *req,
bool ect, ecn_ok;
u32 ecn_ok_dst;
+ if (tcp_accecn_syn_requested(th) &&
+ (net->ipv4.sysctl_tcp_ecn >= 3 || tcp_ca_needs_accecn(listen_sk))) {
+ inet_rsk(req)->ecn_ok = 1;
+ tcp_rsk(req)->accecn_ok = 1;
+ tcp_rsk(req)->syn_ect_rcv = TCP_SKB_CB(skb)->ip_dsfield &
+ INET_ECN_MASK;
+ return;
+ }
+
if (!th_ecn)
return;
@@ -7068,7 +7208,8 @@ static void tcp_ecn_create_request(struct request_sock *req,
ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
ecn_ok = READ_ONCE(net->ipv4.sysctl_tcp_ecn) || ecn_ok_dst;
- if (((!ect || th->res1) && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
+ if (((!ect || th->res1 || th->ae) && ecn_ok) ||
+ tcp_ca_needs_ecn(listen_sk) ||
(ecn_ok_dst & DST_FEATURE_ECN_CA) ||
tcp_bpf_ca_needs_ecn((struct sock *)req))
inet_rsk(req)->ecn_ok = 1;
@@ -7086,6 +7227,9 @@ static void tcp_openreq_init(struct request_sock *req,
tcp_rsk(req)->snt_synack = 0;
tcp_rsk(req)->snt_tsval_first = 0;
tcp_rsk(req)->last_oow_ack_time = 0;
+ tcp_rsk(req)->accecn_ok = 0;
+ tcp_rsk(req)->syn_ect_rcv = 0;
+ tcp_rsk(req)->syn_ect_snt = 0;
req->mss = rx_opt->mss_clamp;
req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
ireq->tstamp_ok = rx_opt->tstamp_ok;
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 6a14f9e6fef6..c5b93802d7c0 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1189,7 +1189,7 @@ static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst,
enum tcp_synack_type synack_type,
struct sk_buff *syn_skb)
{
- const struct inet_request_sock *ireq = inet_rsk(req);
+ struct inet_request_sock *ireq = inet_rsk(req);
struct flowi4 fl4;
int err = -1;
struct sk_buff *skb;
@@ -1202,6 +1202,7 @@ static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst,
skb = tcp_make_synack(sk, dst, req, foc, synack_type, syn_skb);
if (skb) {
+ tcp_rsk(req)->syn_ect_snt = inet_sk(sk)->tos & INET_ECN_MASK;
__tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
tos = READ_ONCE(inet_sk(sk)->tos);
@@ -3448,7 +3449,7 @@ static void __net_init tcp_set_hashinfo(struct net *net)
static int __net_init tcp_sk_init(struct net *net)
{
- net->ipv4.sysctl_tcp_ecn = 2;
+ net->ipv4.sysctl_tcp_ecn = TCP_ECN_IN_ECN_OUT_NOECN;
net->ipv4.sysctl_tcp_ecn_fallback = 1;
net->ipv4.sysctl_tcp_base_mss = TCP_BASE_MSS;
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 43d7852ce07e..779a206a5ca6 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -461,12 +461,51 @@ void tcp_openreq_init_rwin(struct request_sock *req,
ireq->rcv_wscale = rcv_wscale;
}
-static void tcp_ecn_openreq_child(struct tcp_sock *tp,
- const struct request_sock *req)
+void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
+ u8 syn_ect_snt)
{
- tcp_ecn_mode_set(tp, inet_rsk(req)->ecn_ok ?
- TCP_ECN_MODE_RFC3168 :
- TCP_ECN_DISABLED);
+ u8 ace = tcp_accecn_ace(tcp_hdr(skb));
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ switch (ace) {
+ case 0x0:
+ tcp_accecn_fail_mode_set(tp, TCP_ACCECN_ACE_FAIL_RECV);
+ break;
+ case 0x7:
+ case 0x5:
+ case 0x1:
+ /* Unused but legal values */
+ break;
+ default:
+ /* Validation only applies to first non-data packet */
+ if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq &&
+ !TCP_SKB_CB(skb)->sacked &&
+ tcp_accecn_validate_syn_feedback(sk, ace, syn_ect_snt)) {
+ if ((tcp_accecn_extract_syn_ect(ace) == INET_ECN_CE) &&
+ !tp->delivered_ce)
+ tp->delivered_ce++;
+ }
+ break;
+ }
+}
+
+static void tcp_ecn_openreq_child(struct sock *sk,
+ const struct request_sock *req,
+ const struct sk_buff *skb)
+{
+ const struct tcp_request_sock *treq = tcp_rsk(req);
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ if (treq->accecn_ok) {
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
+ tp->syn_ect_snt = treq->syn_ect_snt;
+ tcp_accecn_third_ack(sk, skb, treq->syn_ect_snt);
+ tcp_ecn_received_counters(sk, skb);
+ } else {
+ tcp_ecn_mode_set(tp, inet_rsk(req)->ecn_ok ?
+ TCP_ECN_MODE_RFC3168 :
+ TCP_ECN_DISABLED);
+ }
}
void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst)
@@ -631,7 +670,7 @@ struct sock *tcp_create_openreq_child(const struct sock *sk,
if (skb->len >= TCP_MSS_DEFAULT + newtp->tcp_header_len)
newicsk->icsk_ack.last_seg_size = skb->len - newtp->tcp_header_len;
newtp->rx_opt.mss_clamp = req->mss;
- tcp_ecn_openreq_child(newtp, req);
+ tcp_ecn_openreq_child(newsk, req, skb);
newtp->fastopen_req = NULL;
RCU_INIT_POINTER(newtp->fastopen_rsk, NULL);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 4b32aa619594..79ad69dfd9d6 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -322,7 +322,7 @@ static u16 tcp_select_window(struct sock *sk)
/* Packet ECN state for a SYN-ACK */
static void tcp_ecn_send_synack(struct sock *sk, struct sk_buff *skb)
{
- const struct tcp_sock *tp = tcp_sk(sk);
+ struct tcp_sock *tp = tcp_sk(sk);
TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_CWR;
if (tcp_ecn_disabled(tp))
@@ -330,6 +330,13 @@ static void tcp_ecn_send_synack(struct sock *sk, struct sk_buff *skb)
else if (tcp_ca_needs_ecn(sk) ||
tcp_bpf_ca_needs_ecn(sk))
INET_ECN_xmit(sk);
+
+ if (tp->ecn_flags & TCP_ECN_MODE_ACCECN) {
+ TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_ACE;
+ TCP_SKB_CB(skb)->tcp_flags |=
+ tcp_accecn_reflector_flags(tp->syn_ect_rcv);
+ tp->syn_ect_snt = inet_sk(sk)->tos & INET_ECN_MASK;
+ }
}
/* Packet ECN state for a SYN. */
@@ -337,8 +344,20 @@ static void tcp_ecn_send_syn(struct sock *sk, struct sk_buff *skb)
{
struct tcp_sock *tp = tcp_sk(sk);
bool bpf_needs_ecn = tcp_bpf_ca_needs_ecn(sk);
- bool use_ecn = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_ecn) == 1 ||
- tcp_ca_needs_ecn(sk) || bpf_needs_ecn;
+ bool use_ecn, use_accecn;
+ u8 tcp_ecn = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_ecn);
+
+ /* ============== ==========================
+ * tcp_ecn values Outgoing connections
+ * ============== ==========================
+ * 0,2,5 Do not request ECN
+ * 1,4 Request ECN connection
+ * 3 Request AccECN connection
+ * ============== ==========================
+ */
+ use_accecn = tcp_ecn == 3 || tcp_ca_needs_accecn(sk);
+ use_ecn = tcp_ecn == 1 || tcp_ecn == 4 ||
+ tcp_ca_needs_ecn(sk) || bpf_needs_ecn || use_accecn;
if (!use_ecn) {
const struct dst_entry *dst = __sk_dst_get(sk);
@@ -354,35 +373,58 @@ static void tcp_ecn_send_syn(struct sock *sk, struct sk_buff *skb)
INET_ECN_xmit(sk);
TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
- tcp_ecn_mode_set(tp, TCP_ECN_MODE_RFC3168);
+ if (use_accecn) {
+ TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_AE;
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_PENDING);
+ tp->syn_ect_snt = inet_sk(sk)->tos & INET_ECN_MASK;
+ } else {
+ tcp_ecn_mode_set(tp, TCP_ECN_MODE_RFC3168);
+ }
}
}
static void tcp_ecn_clear_syn(struct sock *sk, struct sk_buff *skb)
{
- if (READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_ecn_fallback))
+ if (READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_ecn_fallback)) {
/* tp->ecn_flags are cleared at a later point in time when
* SYN ACK is ultimatively being received.
*/
- TCP_SKB_CB(skb)->tcp_flags &= ~(TCPHDR_ECE | TCPHDR_CWR);
+ TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_ACE;
+ }
+}
+
+static void tcp_accecn_echo_syn_ect(struct tcphdr *th, u8 ect)
+{
+ th->ae = !!(ect & INET_ECN_ECT_0);
+ th->cwr = ect != INET_ECN_ECT_0;
+ th->ece = ect == INET_ECN_ECT_1;
}
static void
tcp_ecn_make_synack(const struct request_sock *req, struct tcphdr *th)
{
- if (inet_rsk(req)->ecn_ok)
+ if (tcp_rsk(req)->accecn_ok)
+ tcp_accecn_echo_syn_ect(th, tcp_rsk(req)->syn_ect_rcv);
+ else if (inet_rsk(req)->ecn_ok)
th->ece = 1;
}
-static void tcp_accecn_set_ace(struct tcphdr *th, struct tcp_sock *tp)
+static void tcp_accecn_set_ace(struct tcp_sock *tp, struct sk_buff *skb,
+ struct tcphdr *th)
{
u32 wire_ace;
- wire_ace = tp->received_ce + TCP_ACCECN_CEP_INIT_OFFSET;
- th->ece = !!(wire_ace & 0x1);
- th->cwr = !!(wire_ace & 0x2);
- th->ae = !!(wire_ace & 0x4);
- tp->received_ce_pending = 0;
+ /* The final packet of the 3WHS or anything like it must reflect
+ * the SYN/ACK ECT instead of putting CEP into ACE field, such
+ * case show up in tcp_flags.
+ */
+ if (likely(!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACE))) {
+ wire_ace = tp->received_ce + TCP_ACCECN_CEP_INIT_OFFSET;
+ th->ece = !!(wire_ace & 0x1);
+ th->cwr = !!(wire_ace & 0x2);
+ th->ae = !!(wire_ace & 0x4);
+ tp->received_ce_pending = 0;
+ }
}
/* Set up ECN state for a packet on a ESTABLISHED socket that is about to
@@ -397,8 +439,9 @@ static void tcp_ecn_send(struct sock *sk, struct sk_buff *skb,
return;
if (tcp_ecn_mode_accecn(tp)) {
- INET_ECN_xmit(sk);
- tcp_accecn_set_ace(th, tp);
+ if (!tcp_accecn_ace_fail_recv(tp))
+ INET_ECN_xmit(sk);
+ tcp_accecn_set_ace(tp, skb, th);
skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ACCECN;
} else {
/* Not-retransmitted data segment: set ECT and inject CWR. */
@@ -3408,7 +3451,10 @@ int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
tcp_retrans_try_collapse(sk, skb, avail_wnd);
}
- /* RFC3168, section 6.1.1.1. ECN fallback */
+ /* RFC3168, section 6.1.1.1. ECN fallback
+ * As AccECN uses the same SYN flags (+ AE), this check covers both
+ * cases.
+ */
if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN_ECN) == TCPHDR_SYN_ECN)
tcp_ecn_clear_syn(sk, skb);
diff --git a/net/ipv6/syncookies.c b/net/ipv6/syncookies.c
index 9d83eadd308b..50046460ee0b 100644
--- a/net/ipv6/syncookies.c
+++ b/net/ipv6/syncookies.c
@@ -264,6 +264,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
if (!req->syncookie)
ireq->rcv_wscale = rcv_wscale;
ireq->ecn_ok &= cookie_ecn_ok(net, dst);
+ tcp_rsk(req)->accecn_ok = ireq->ecn_ok && cookie_accecn_ok(th);
ret = tcp_get_cookie_sock(sk, skb, req, dst);
if (!ret) {
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index e8e68a142649..eb7dc7fb08cc 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -544,6 +544,7 @@ static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,
skb = tcp_make_synack(sk, dst, req, foc, synack_type, syn_skb);
if (skb) {
+ tcp_rsk(req)->syn_ect_snt = np->tclass & INET_ECN_MASK;
__tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
&ireq->ir_v6_rmt_addr);
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (4 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-25 8:04 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 07/15] tcp: accecn: AccECN needs to know delivered bytes chia-yu.chang
` (8 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
These three byte counters track IP ECN field payload byte sums for
all arriving (acceptable) packets for ECT0, ECT1, and CE. The
AccECN option (added by a later patch in the series) echoes these
counters back to sender side; therefore, it is placed within the
group of tcp_sock_write_txrx.
Below are the pahole outcomes before and after this patch, in which
the group size of tcp_sock_write_txrx is increased from 95 + 4 to
107 + 4 and an extra 4-byte hole is created but will be exploited
in later patches:
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
u32 delivered_ce; /* 2640 4 */
u32 received_ce; /* 2644 4 */
u32 app_limited; /* 2648 4 */
u32 rcv_wnd; /* 2652 4 */
struct tcp_options_received rx_opt; /* 2656 24 */
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2680 0 */
[...]
/* size: 3264, cachelines: 51, members: 169 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
u32 delivered_ce; /* 2640 4 */
u32 received_ce; /* 2644 4 */
u32 received_ecn_bytes[3];/* 2648 12 */
u32 app_limited; /* 2660 4 */
u32 rcv_wnd; /* 2664 4 */
struct tcp_options_received rx_opt; /* 2668 24 */
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2692 0 */
/* XXX 4 bytes hole, try to pack */
[...]
/* size: 3264, cachelines: 51, members: 170 */
}
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Neal Cardwell <ncardwell@google.com>
Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v8:
- Add new helper function tcp_ecn_received_counters_payload()
---
.../networking/net_cachelines/tcp_sock.rst | 1 +
include/linux/tcp.h | 4 ++++
include/net/tcp.h | 20 +++++++++++++++++-
net/ipv4/tcp.c | 3 ++-
net/ipv4/tcp_input.c | 21 +++++++++++++++----
net/ipv4/tcp_minisocks.c | 2 +-
6 files changed, 44 insertions(+), 7 deletions(-)
diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
index 22ac668fe6c7..804480d39132 100644
--- a/Documentation/networking/net_cachelines/tcp_sock.rst
+++ b/Documentation/networking/net_cachelines/tcp_sock.rst
@@ -102,6 +102,7 @@ u32 prr_out read_mostly read_m
u32 delivered read_mostly read_write tcp_rate_skb_sent, tcp_newly_delivered(tx);tcp_ack, tcp_rate_gen, tcp_clean_rtx_queue (rx)
u32 delivered_ce read_mostly read_write tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
u32 received_ce read_mostly read_write
+u32[3] received_ecn_bytes read_mostly read_write
u8:4 received_ce_pending read_mostly read_write
u8:2 syn_ect_snt write_mostly read_write
u8:2 syn_ect_rcv read_mostly read_write
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 1d8301f2883c..0c2331e186e8 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -306,6 +306,10 @@ struct tcp_sock {
u32 delivered; /* Total data packets delivered incl. rexmits */
u32 delivered_ce; /* Like the above but only ECE marked packets */
u32 received_ce; /* Like the above but for rcvd CE marked pkts */
+ u32 received_ecn_bytes[3]; /* received byte counters for three ECN
+ * types: INET_ECN_ECT_1, INET_ECN_ECT_0,
+ * and INET_ECN_CE
+ */
u32 app_limited; /* limited until "delivered" reaches this val */
u32 rcv_wnd; /* Current receiver window */
/*
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 4d6325fa3f67..b861941a2213 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -467,7 +467,10 @@ static inline int tcp_accecn_extract_syn_ect(u8 ace)
bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect);
void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
u8 syn_ect_snt);
-void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb);
+void tcp_ecn_received_counters_payload(struct sock *sk,
+ const struct sk_buff *skb);
+void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
+ u32 payload_len);
enum tcp_tw_status {
TCP_TW_SUCCESS = 0,
@@ -1035,6 +1038,20 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
* See draft-ietf-tcpm-accurate-ecn for the latest values.
*/
#define TCP_ACCECN_CEP_INIT_OFFSET 5
+#define TCP_ACCECN_E1B_INIT_OFFSET 1
+#define TCP_ACCECN_E0B_INIT_OFFSET 1
+#define TCP_ACCECN_CEB_INIT_OFFSET 0
+
+static inline void __tcp_accecn_init_bytes_counters(int *counter_array)
+{
+ BUILD_BUG_ON(INET_ECN_ECT_1 != 0x1);
+ BUILD_BUG_ON(INET_ECN_ECT_0 != 0x2);
+ BUILD_BUG_ON(INET_ECN_CE != 0x3);
+
+ counter_array[INET_ECN_ECT_1 - 1] = 0;
+ counter_array[INET_ECN_ECT_0 - 1] = 0;
+ counter_array[INET_ECN_CE - 1] = 0;
+}
/* The highest ECN variant (Accurate ECN, ECN, or no ECN) that is
* attemped to be negotiated and requested for incoming connection
@@ -1053,6 +1070,7 @@ static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
{
tp->received_ce = 0;
tp->received_ce_pending = 0;
+ __tcp_accecn_init_bytes_counters(tp->received_ecn_bytes);
}
/* State flags for sacked in struct tcp_skb_cb */
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index e6d7b5420c88..0e779de3ce01 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -5122,6 +5122,7 @@ static void __init tcp_struct_check(void)
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, delivered);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, delivered_ce);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, received_ce);
+ CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, received_ecn_bytes);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, app_limited);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, rcv_wnd);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, rx_opt);
@@ -5129,7 +5130,7 @@ static void __init tcp_struct_check(void)
/* 32bit arches with 8byte alignment on u64 fields might need padding
* before tcp_clock_cache.
*/
- CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 95 + 4);
+ CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 107 + 4);
/* RX read-write hotpath cache lines */
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_received);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index c986452302cb..5c0159cc0083 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -6013,8 +6013,17 @@ static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *t
}
}
+void tcp_ecn_received_counters_payload(struct sock *sk,
+ const struct sk_buff *skb)
+{
+ const struct tcphdr *th = (const struct tcphdr *)skb->data;
+
+ tcp_ecn_received_counters(sk, skb, skb->len - th->doff * 4);
+}
+
/* Updates Accurate ECN received counters from the received IP ECN field */
-void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb)
+void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
+ u32 payload_len)
{
u8 ecnfield = TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK;
u8 is_ce = INET_ECN_is_ce(ecnfield);
@@ -6034,6 +6043,9 @@ void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb)
tp->received_ce += pcount;
tp->received_ce_pending = min(tp->received_ce_pending + pcount,
0xfU);
+
+ if (payload_len > 0)
+ tp->received_ecn_bytes[ecnfield - 1] += payload_len;
}
}
@@ -6307,7 +6319,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
flag |= __tcp_replace_ts_recent(tp,
delta);
- tcp_ecn_received_counters(sk, skb);
+ tcp_ecn_received_counters(sk, skb, 0);
/* We know that such packets are checksummed
* on entry.
@@ -6353,7 +6365,8 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
/* Bulk data transfer: receiver */
tcp_cleanup_skb(skb);
__skb_pull(skb, tcp_header_len);
- tcp_ecn_received_counters(sk, skb);
+ tcp_ecn_received_counters(sk, skb,
+ len - tcp_header_len);
eaten = tcp_queue_rcv(sk, skb, &fragstolen);
tcp_event_data_recv(sk, skb);
@@ -6400,7 +6413,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
tcp_accecn_third_ack(sk, skb, tp->syn_ect_snt);
tcp_fast_path_on(tp);
}
- tcp_ecn_received_counters(sk, skb);
+ tcp_ecn_received_counters_payload(sk, skb);
reason = tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT);
if ((int)reason < 0) {
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 779a206a5ca6..f1e698c323f3 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -500,7 +500,7 @@ static void tcp_ecn_openreq_child(struct sock *sk,
tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
tp->syn_ect_snt = treq->syn_ect_snt;
tcp_accecn_third_ack(sk, skb, treq->syn_ect_snt);
- tcp_ecn_received_counters(sk, skb);
+ tcp_ecn_received_counters_payload(sk, skb);
} else {
tcp_ecn_mode_set(tp, inet_rsk(req)->ecn_ok ?
TCP_ECN_MODE_RFC3168 :
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 07/15] tcp: accecn: AccECN needs to know delivered bytes
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (5 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 08/15] tcp: sack option handling improvements chia-yu.chang
` (7 subsequent siblings)
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
AccECN byte counter estimation requires delivered bytes
which can be calculated while processing SACK blocks and
cumulative ACK. The delivered bytes will be used to estimate
the byte counters between AccECN option (on ACKs w/o the
option).
Non-SACK calculation is quite annoying, inaccurate, and
likely bogus.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
net/ipv4/tcp_input.c | 14 ++++++++++++--
1 file changed, 12 insertions(+), 2 deletions(-)
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 5c0159cc0083..a327fc14b207 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -1196,6 +1196,7 @@ struct tcp_sacktag_state {
u64 last_sackt;
u32 reord;
u32 sack_delivered;
+ u32 delivered_bytes;
int flag;
unsigned int mss_now;
struct rate_sample *rate;
@@ -1557,7 +1558,7 @@ static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
static u8 tcp_sacktag_one(struct sock *sk,
struct tcp_sacktag_state *state, u8 sacked,
u32 start_seq, u32 end_seq,
- int dup_sack, int pcount,
+ int dup_sack, int pcount, u32 plen,
u64 xmit_time)
{
struct tcp_sock *tp = tcp_sk(sk);
@@ -1617,6 +1618,7 @@ static u8 tcp_sacktag_one(struct sock *sk,
tp->sacked_out += pcount;
/* Out-of-order packets delivered */
state->sack_delivered += pcount;
+ state->delivered_bytes += plen;
}
/* D-SACK. We can detect redundant retransmission in S|R and plain R
@@ -1653,7 +1655,7 @@ static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *prev,
* tcp_highest_sack_seq() when skb is highest_sack.
*/
tcp_sacktag_one(sk, state, TCP_SKB_CB(skb)->sacked,
- start_seq, end_seq, dup_sack, pcount,
+ start_seq, end_seq, dup_sack, pcount, skb->len,
tcp_skb_timestamp_us(skb));
tcp_rate_skb_delivered(sk, skb, state->rate);
@@ -1938,6 +1940,7 @@ static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
TCP_SKB_CB(skb)->end_seq,
dup_sack,
tcp_skb_pcount(skb),
+ skb->len,
tcp_skb_timestamp_us(skb));
tcp_rate_skb_delivered(sk, skb, state->rate);
if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
@@ -3446,6 +3449,8 @@ static int tcp_clean_rtx_queue(struct sock *sk, const struct sk_buff *ack_skb,
if (sacked & TCPCB_SACKED_ACKED) {
tp->sacked_out -= acked_pcount;
+ /* snd_una delta covers these skbs */
+ sack->delivered_bytes -= skb->len;
} else if (tcp_is_sack(tp)) {
tcp_count_delivered(tp, acked_pcount, ece_ack);
if (!tcp_skb_spurious_retrans(tp, skb))
@@ -3542,6 +3547,10 @@ static int tcp_clean_rtx_queue(struct sock *sk, const struct sk_buff *ack_skb,
if (before(reord, prior_fack))
tcp_check_sack_reordering(sk, reord, 0);
}
+
+ sack->delivered_bytes = (skb ?
+ TCP_SKB_CB(skb)->seq : tp->snd_una) -
+ prior_snd_una;
} else if (skb && rtt_update && sack_rtt_us >= 0 &&
sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp,
tcp_skb_timestamp_us(skb))) {
@@ -4004,6 +4013,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
sack_state.first_sackt = 0;
sack_state.rate = &rs;
sack_state.sack_delivered = 0;
+ sack_state.delivered_bytes = 0;
/* We very likely will need to access rtx queue. */
prefetch(sk->tcp_rtx_queue.rb_node);
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 08/15] tcp: sack option handling improvements
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (6 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 07/15] tcp: accecn: AccECN needs to know delivered bytes chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-25 8:08 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 09/15] tcp: accecn: AccECN option chia-yu.chang
` (6 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
1) Don't early return when sack doesn't fit. AccECN code will be
placed after this fragment so no early returns please.
2) Make sure opts->num_sack_blocks is not left undefined. E.g.,
tcp_current_mss() does not memset its opts struct to zero.
AccECN code checks if SACK option is present and may even
alter it to make room for AccECN option when many SACK blocks
are present. Thus, num_sack_blocks needs to be always valid.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v8:
- Set opts->num_sack_blocks=0 to avoid potential undefined value
---
net/ipv4/tcp_output.c | 25 ++++++++++++++-----------
1 file changed, 14 insertions(+), 11 deletions(-)
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 79ad69dfd9d6..37c981aa9bc6 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1092,17 +1092,20 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb
eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;
if (unlikely(eff_sacks)) {
const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
- if (unlikely(remaining < TCPOLEN_SACK_BASE_ALIGNED +
- TCPOLEN_SACK_PERBLOCK))
- return size;
-
- opts->num_sack_blocks =
- min_t(unsigned int, eff_sacks,
- (remaining - TCPOLEN_SACK_BASE_ALIGNED) /
- TCPOLEN_SACK_PERBLOCK);
-
- size += TCPOLEN_SACK_BASE_ALIGNED +
- opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
+ if (likely(remaining >= TCPOLEN_SACK_BASE_ALIGNED +
+ TCPOLEN_SACK_PERBLOCK)) {
+ opts->num_sack_blocks =
+ min_t(unsigned int, eff_sacks,
+ (remaining - TCPOLEN_SACK_BASE_ALIGNED) /
+ TCPOLEN_SACK_PERBLOCK);
+
+ size += TCPOLEN_SACK_BASE_ALIGNED +
+ opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
+ } else {
+ opts->num_sack_blocks = 0;
+ }
+ } else {
+ opts->num_sack_blocks = 0;
}
if (unlikely(BPF_SOCK_OPS_TEST_FLAG(tp,
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (7 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 08/15] tcp: sack option handling improvements chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-25 9:21 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 10/15] tcp: accecn: AccECN option send control chia-yu.chang
` (5 subsequent siblings)
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
The Accurate ECN allows echoing back the sum of bytes for
each IP ECN field value in the received packets using
AccECN option. This change implements AccECN option tx & rx
side processing without option send control related features
that are added by a later change.
Based on specification:
https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
(Some features of the spec will be added in the later changes
rather than in this one).
A full-length AccECN option is always attempted but if it does
not fit, the minimum length is selected based on the counters
that have changed since the last update. The AccECN option
(with 24-bit fields) often ends in odd sizes so the option
write code tries to take advantage of some nop used to pad
the other TCP options.
The delivered_ecn_bytes pairs with received_ecn_bytes similar
to how delivered_ce pairs with received_ce. In contrast to
ACE field, however, the option is not always available to update
delivered_ecn_bytes. For ACK w/o AccECN option, the delivered
bytes calculated based on the cumulative ACK+SACK information
are assigned to one of the counters using an estimation
heuristic to select the most likely ECN byte counter. Any
estimation error is corrected when the next AccECN option
arrives. It may occur that the heuristic gets too confused
when there are enough different byte counter deltas between
ACKs with the AccECN option in which case the heuristic just
gives up on updating the counters for a while.
tcp_ecn_option sysctl can be used to select option sending
mode for AccECN: TCP_ECN_OPTION_DISABLED, TCP_ECN_OPTION_MINIMUM,
and TCP_ECN_OPTION_FULL.
This patch increases the size of tcp_info struct, as there is
no existing holes for new u32 variables. Below are the pahole
outcomes before and after this patch:
[BEFORE THIS PATCH]
struct tcp_info {
[...]
__u32 tcpi_total_rto_time; /* 244 4 */
/* size: 248, cachelines: 4, members: 61 */
}
[AFTER THIS PATCH]
struct tcp_info {
[...]
__u32 tcpi_total_rto_time; /* 244 4 */
__u32 tcpi_received_ce; /* 248 4 */
__u32 tcpi_delivered_e1_bytes; /* 252 4 */
__u32 tcpi_delivered_e0_bytes; /* 256 4 */
__u32 tcpi_delivered_ce_bytes; /* 260 4 */
__u32 tcpi_received_e1_bytes; /* 264 4 */
__u32 tcpi_received_e0_bytes; /* 268 4 */
__u32 tcpi_received_ce_bytes; /* 272 4 */
/* size: 280, cachelines: 5, members: 68 */
}
This patch uses the existing 1-byte holes in the tcp_sock_write_txrx
group for new u8 members, but adds a 4-byte hole in tcp_sock_write_rx
group after the new u32 delivered_ecn_bytes[3] member. Therefore, the
group size of tcp_sock_write_rx is increased from 96 to 112. Below
are the pahole outcomes before and after this patch:
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
u8 received_ce_pending:4; /* 2586: 0 1 */
u8 unused2:4; /* 2586: 4 1 */
/* XXX 1 byte hole, try to pack */
[...]
u32 rcv_rtt_last_tsecr; /* 2732 4 */
[...]
__cacheline_group_end__tcp_sock_write_rx[0]; /* 2792 0 */
[...]
/* size: 3264, cachelines: 51, members: 170 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
u8 received_ce_pending:4;/* 2586: 0 1 */
u8 unused2:4; /* 2586: 4 1 */
u8 accecn_minlen:2; /* 2587: 0 1 */
u8 est_ecnfield:2; /* 2587: 2 1 */
u8 unused3:4; /* 2587: 4 1 */
[...]
u32 rcv_rtt_last_tsecr; /* 2732 4 */
u32 delivered_ecn_bytes[3];/* 2736 12 */
/* XXX 4 bytes hole, try to pack */
[...]
__cacheline_group_end__tcp_sock_write_rx[0]; /* 2808 0 */
[...]
/* size: 3264, cachelines: 51, members: 174 */
}
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Neal Cardwell <ncardwell@google.com>
Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v9:
- Restruct the code in the for loop of tcp_accecn_process_option()
- Remove ecn_bytes and add use_synack_ecn_bytes flag in tcp_out_options
struct to identify whether syn_ack_bytes or received_ecn_bytes is used
- Replace leftover_bytes and leftover_size with leftover_highbyte and
leftover_lowbyte and add comments in tcp_options_write()
v8:
- Reset leftover_size to 2 once leftover_bytes is used
---
.../networking/net_cachelines/tcp_sock.rst | 3 +
include/linux/tcp.h | 9 +-
include/net/netns/ipv4.h | 1 +
include/net/tcp.h | 20 +++
include/uapi/linux/tcp.h | 7 +
net/ipv4/sysctl_net_ipv4.c | 9 +
net/ipv4/tcp.c | 15 +-
net/ipv4/tcp_input.c | 166 ++++++++++++++++-
net/ipv4/tcp_ipv4.c | 1 +
net/ipv4/tcp_output.c | 170 +++++++++++++++++-
10 files changed, 388 insertions(+), 13 deletions(-)
diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
index 804480d39132..ed6af7d0110c 100644
--- a/Documentation/networking/net_cachelines/tcp_sock.rst
+++ b/Documentation/networking/net_cachelines/tcp_sock.rst
@@ -104,9 +104,12 @@ u32 delivered_ce read_mostly read_w
u32 received_ce read_mostly read_write
u32[3] received_ecn_bytes read_mostly read_write
u8:4 received_ce_pending read_mostly read_write
+u32[3] delivered_ecn_bytes read_write
u8:2 syn_ect_snt write_mostly read_write
u8:2 syn_ect_rcv read_mostly read_write
u8:1 wait_third_ack read_write
+u8:2 accecn_minlen write_mostly read_write
+u8:2 est_ecnfield read_write
u8:4 accecn_fail_mode
u32 lost read_mostly tcp_ack
u32 app_limited read_write read_mostly tcp_rate_check_app_limited,tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 0c2331e186e8..0008b8190ea0 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -122,8 +122,9 @@ struct tcp_options_received {
smc_ok : 1, /* SMC seen on SYN packet */
snd_wscale : 4, /* Window scaling received from sender */
rcv_wscale : 4; /* Window scaling to send to receiver */
- u8 saw_unknown:1, /* Received unknown option */
- unused:7;
+ u8 accecn:6, /* AccECN index in header, 0=no options */
+ saw_unknown:1, /* Received unknown option */
+ unused:1;
u8 num_sacks; /* Number of SACK blocks */
u16 user_mss; /* mss requested by user in ioctl */
u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
@@ -293,6 +294,9 @@ struct tcp_sock {
rate_app_limited:1; /* rate_{delivered,interval_us} limited? */
u8 received_ce_pending:4, /* Not yet transmit cnt of received_ce */
unused2:4;
+ u8 accecn_minlen:2,/* Minimum length of AccECN option sent */
+ est_ecnfield:2,/* ECN field for AccECN delivered estimates */
+ unused3:4;
__be32 pred_flags;
u64 tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */
u64 tcp_mstamp; /* most recent packet received/sent */
@@ -337,6 +341,7 @@ struct tcp_sock {
u32 rate_delivered; /* saved rate sample: packets delivered */
u32 rate_interval_us; /* saved rate sample: time elapsed */
u32 rcv_rtt_last_tsecr;
+ u32 delivered_ecn_bytes[3];
u64 first_tx_mstamp; /* start of window send phase */
u64 delivered_mstamp; /* time we reached "delivered" */
u64 bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index 6373e3f17da8..4569a9ef4fb8 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -148,6 +148,7 @@ struct netns_ipv4 {
struct local_ports ip_local_ports;
u8 sysctl_tcp_ecn;
+ u8 sysctl_tcp_ecn_option;
u8 sysctl_tcp_ecn_fallback;
u8 sysctl_ip_default_ttl;
diff --git a/include/net/tcp.h b/include/net/tcp.h
index b861941a2213..f7ba314eb7f9 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -204,6 +204,8 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
#define TCPOPT_AO 29 /* Authentication Option (RFC5925) */
#define TCPOPT_MPTCP 30 /* Multipath TCP (RFC6824) */
#define TCPOPT_FASTOPEN 34 /* Fast open (RFC7413) */
+#define TCPOPT_ACCECN0 172 /* 0xAC: Accurate ECN Order 0 */
+#define TCPOPT_ACCECN1 174 /* 0xAE: Accurate ECN Order 1 */
#define TCPOPT_EXP 254 /* Experimental */
/* Magic number to be after the option value for sharing TCP
* experimental options. See draft-ietf-tcpm-experimental-options-00.txt
@@ -221,6 +223,7 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
#define TCPOLEN_TIMESTAMP 10
#define TCPOLEN_MD5SIG 18
#define TCPOLEN_FASTOPEN_BASE 2
+#define TCPOLEN_ACCECN_BASE 2
#define TCPOLEN_EXP_FASTOPEN_BASE 4
#define TCPOLEN_EXP_SMC_BASE 6
@@ -234,6 +237,13 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
#define TCPOLEN_MD5SIG_ALIGNED 20
#define TCPOLEN_MSS_ALIGNED 4
#define TCPOLEN_EXP_SMC_BASE_ALIGNED 8
+#define TCPOLEN_ACCECN_PERFIELD 3
+
+/* Maximum number of byte counters in AccECN option + size */
+#define TCP_ACCECN_NUMFIELDS 3
+#define TCP_ACCECN_MAXSIZE (TCPOLEN_ACCECN_BASE + \
+ TCPOLEN_ACCECN_PERFIELD * \
+ TCP_ACCECN_NUMFIELDS)
/* tp->accecn_fail_mode */
#define TCP_ACCECN_ACE_FAIL_SEND BIT(0)
@@ -1066,11 +1076,21 @@ enum tcp_ecn_mode {
TCP_ECN_IN_ACCECN_OUT_NOECN = 5,
};
+/* AccECN option sending when AccECN has been successfully negotiated */
+enum tcp_ecn_option {
+ TCP_ECN_OPTION_DISABLED = 0,
+ TCP_ECN_OPTION_MINIMUM = 1,
+ TCP_ECN_OPTION_FULL = 2,
+};
+
static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
{
tp->received_ce = 0;
tp->received_ce_pending = 0;
__tcp_accecn_init_bytes_counters(tp->received_ecn_bytes);
+ __tcp_accecn_init_bytes_counters(tp->delivered_ecn_bytes);
+ tp->accecn_minlen = 0;
+ tp->est_ecnfield = 0;
}
/* State flags for sacked in struct tcp_skb_cb */
diff --git a/include/uapi/linux/tcp.h b/include/uapi/linux/tcp.h
index bdac8c42fa82..53e0e85b52be 100644
--- a/include/uapi/linux/tcp.h
+++ b/include/uapi/linux/tcp.h
@@ -316,6 +316,13 @@ struct tcp_info {
* in milliseconds, including any
* unfinished recovery.
*/
+ __u32 tcpi_received_ce; /* # of CE marks received */
+ __u32 tcpi_delivered_e1_bytes; /* Accurate ECN byte counters */
+ __u32 tcpi_delivered_e0_bytes;
+ __u32 tcpi_delivered_ce_bytes;
+ __u32 tcpi_received_e1_bytes;
+ __u32 tcpi_received_e0_bytes;
+ __u32 tcpi_received_ce_bytes;
};
/* netlink attributes types for SCM_TIMESTAMPING_OPT_STATS */
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 75ec1a599b52..1d7fd86ca7b9 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -731,6 +731,15 @@ static struct ctl_table ipv4_net_table[] = {
.extra1 = SYSCTL_ZERO,
.extra2 = &tcp_ecn_mode_max,
},
+ {
+ .procname = "tcp_ecn_option",
+ .data = &init_net.ipv4.sysctl_tcp_ecn_option,
+ .maxlen = sizeof(u8),
+ .mode = 0644,
+ .proc_handler = proc_dou8vec_minmax,
+ .extra1 = SYSCTL_ZERO,
+ .extra2 = SYSCTL_TWO,
+ },
{
.procname = "tcp_ecn_fallback",
.data = &init_net.ipv4.sysctl_tcp_ecn_fallback,
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 0e779de3ce01..1c1d4cbdda1c 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -270,6 +270,7 @@
#include <net/icmp.h>
#include <net/inet_common.h>
+#include <net/inet_ecn.h>
#include <net/tcp.h>
#include <net/mptcp.h>
#include <net/proto_memory.h>
@@ -4138,6 +4139,9 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
{
const struct tcp_sock *tp = tcp_sk(sk); /* iff sk_type == SOCK_STREAM */
const struct inet_connection_sock *icsk = inet_csk(sk);
+ const u8 ect1_idx = INET_ECN_ECT_1 - 1;
+ const u8 ect0_idx = INET_ECN_ECT_0 - 1;
+ const u8 ce_idx = INET_ECN_CE - 1;
unsigned long rate;
u32 now;
u64 rate64;
@@ -4264,6 +4268,14 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
if (tp->rto_stamp)
info->tcpi_total_rto_time += tcp_clock_ms() - tp->rto_stamp;
+ info->tcpi_received_ce = tp->received_ce;
+ info->tcpi_delivered_e1_bytes = tp->delivered_ecn_bytes[ect1_idx];
+ info->tcpi_delivered_e0_bytes = tp->delivered_ecn_bytes[ect0_idx];
+ info->tcpi_delivered_ce_bytes = tp->delivered_ecn_bytes[ce_idx];
+ info->tcpi_received_e1_bytes = tp->received_ecn_bytes[ect1_idx];
+ info->tcpi_received_e0_bytes = tp->received_ecn_bytes[ect0_idx];
+ info->tcpi_received_ce_bytes = tp->received_ecn_bytes[ce_idx];
+
unlock_sock_fast(sk, slow);
}
EXPORT_SYMBOL_GPL(tcp_get_info);
@@ -5142,12 +5154,13 @@ static void __init tcp_struct_check(void)
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rate_delivered);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rate_interval_us);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcv_rtt_last_tsecr);
+ CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, delivered_ecn_bytes);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, first_tx_mstamp);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, delivered_mstamp);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_acked);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcv_rtt_est);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcvq_space);
- CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_rx, 96);
+ CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_rx, 112);
}
void __init tcp_init(void)
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index a327fc14b207..66390966cc41 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -70,6 +70,7 @@
#include <linux/sysctl.h>
#include <linux/kernel.h>
#include <linux/prefetch.h>
+#include <linux/bitops.h>
#include <net/dst.h>
#include <net/tcp.h>
#include <net/proto_memory.h>
@@ -530,6 +531,139 @@ static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr
return false;
}
+/* Maps IP ECN field ECT/CE code point to AccECN option field number, given
+ * we are sending fields with Accurate ECN Order 1: ECT(1), CE, ECT(0).
+ */
+static u8 tcp_ecnfield_to_accecn_optfield(u8 ecnfield)
+{
+ switch (ecnfield & INET_ECN_MASK) {
+ case INET_ECN_NOT_ECT:
+ return 0; /* AccECN does not send counts of NOT_ECT */
+ case INET_ECN_ECT_1:
+ return 1;
+ case INET_ECN_CE:
+ return 2;
+ case INET_ECN_ECT_0:
+ return 3;
+ }
+ return 0;
+}
+
+/* Maps IP ECN field ECT/CE code point to AccECN option field value offset.
+ * Some fields do not start from zero, to detect zeroing by middleboxes.
+ */
+static u32 tcp_accecn_field_init_offset(u8 ecnfield)
+{
+ switch (ecnfield & INET_ECN_MASK) {
+ case INET_ECN_NOT_ECT:
+ return 0; /* AccECN does not send counts of NOT_ECT */
+ case INET_ECN_ECT_1:
+ return TCP_ACCECN_E1B_INIT_OFFSET;
+ case INET_ECN_CE:
+ return TCP_ACCECN_CEB_INIT_OFFSET;
+ case INET_ECN_ECT_0:
+ return TCP_ACCECN_E0B_INIT_OFFSET;
+ }
+ return 0;
+}
+
+/* Maps AccECN option field #nr to IP ECN field ECT/CE bits */
+static unsigned int tcp_accecn_optfield_to_ecnfield(unsigned int optfield,
+ bool order)
+{
+ u8 tmp;
+
+ optfield = order ? 2 - optfield : optfield;
+ tmp = optfield + 2;
+
+ return (tmp + (tmp >> 2)) & INET_ECN_MASK;
+}
+
+/* Handles AccECN option ECT and CE 24-bit byte counters update into
+ * the u32 value in tcp_sock. As we're processing TCP options, it is
+ * safe to access from - 1.
+ */
+static s32 tcp_update_ecn_bytes(u32 *cnt, const char *from, u32 init_offset)
+{
+ u32 truncated = (get_unaligned_be32(from - 1) - init_offset) &
+ 0xFFFFFFU;
+ u32 delta = (truncated - *cnt) & 0xFFFFFFU;
+
+ /* If delta has the highest bit set (24th bit) indicating
+ * negative, sign extend to correct an estimation using
+ * sign_extend32(delta, 24 - 1)
+ */
+ delta = sign_extend32(delta, 23);
+ *cnt += delta;
+ return (s32)delta;
+}
+
+/* Returns true if the byte counters can be used */
+static bool tcp_accecn_process_option(struct tcp_sock *tp,
+ const struct sk_buff *skb,
+ u32 delivered_bytes, int flag)
+{
+ u8 estimate_ecnfield = tp->est_ecnfield;
+ bool ambiguous_ecn_bytes_incr = false;
+ bool first_changed = false;
+ unsigned int optlen;
+ bool order1, res;
+ unsigned int i;
+ u8 *ptr;
+
+ if (!(flag & FLAG_SLOWPATH) || !tp->rx_opt.accecn) {
+ if (estimate_ecnfield) {
+ u8 ecnfield = estimate_ecnfield - 1;
+
+ tp->delivered_ecn_bytes[ecnfield] += delivered_bytes;
+ return true;
+ }
+ return false;
+ }
+
+ ptr = skb_transport_header(skb) + tp->rx_opt.accecn;
+ optlen = ptr[1] - 2;
+ WARN_ON_ONCE(ptr[0] != TCPOPT_ACCECN0 && ptr[0] != TCPOPT_ACCECN1);
+ order1 = (ptr[0] == TCPOPT_ACCECN1);
+ ptr += 2;
+
+ res = !!estimate_ecnfield;
+ for (i = 0; i < 3; i++) {
+ u32 init_offset;
+ u8 ecnfield;
+ s32 delta;
+ u32 *cnt;
+
+ if (optlen < TCPOLEN_ACCECN_PERFIELD)
+ break;
+
+ ecnfield = tcp_accecn_optfield_to_ecnfield(i, order1);
+ init_offset = tcp_accecn_field_init_offset(ecnfield);
+ cnt = &tp->delivered_ecn_bytes[ecnfield - 1];
+ delta = tcp_update_ecn_bytes(cnt, ptr, init_offset);
+ if (delta && delta < 0) {
+ res = false;
+ ambiguous_ecn_bytes_incr = true;
+ }
+ if (delta && ecnfield != estimate_ecnfield) {
+ if (!first_changed) {
+ tp->est_ecnfield = ecnfield;
+ first_changed = true;
+ } else {
+ res = false;
+ ambiguous_ecn_bytes_incr = true;
+ }
+ }
+
+ optlen -= TCPOLEN_ACCECN_PERFIELD;
+ ptr += TCPOLEN_ACCECN_PERFIELD;
+ }
+ if (ambiguous_ecn_bytes_incr)
+ tp->est_ecnfield = 0;
+
+ return res;
+}
+
static void tcp_count_delivered_ce(struct tcp_sock *tp, u32 ecn_count)
{
tp->delivered_ce += ecn_count;
@@ -546,7 +680,8 @@ static void tcp_count_delivered(struct tcp_sock *tp, u32 delivered,
/* Returns the ECN CE delta */
static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
- u32 delivered_pkts, int flag)
+ u32 delivered_pkts, u32 delivered_bytes,
+ int flag)
{
const struct tcphdr *th = tcp_hdr(skb);
struct tcp_sock *tp = tcp_sk(sk);
@@ -557,6 +692,8 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
if (!(flag & (FLAG_FORWARD_PROGRESS | FLAG_TS_PROGRESS)))
return 0;
+ tcp_accecn_process_option(tp, skb, delivered_bytes, flag);
+
if (!(flag & FLAG_SLOWPATH)) {
/* AccECN counter might overflow on large ACKs */
if (delivered_pkts <= TCP_ACCECN_CEP_ACE_MASK)
@@ -582,12 +719,14 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
}
static u32 tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
- u32 delivered_pkts, int *flag)
+ u32 delivered_pkts, u32 delivered_bytes,
+ int *flag)
{
struct tcp_sock *tp = tcp_sk(sk);
u32 delta;
- delta = __tcp_accecn_process(sk, skb, delivered_pkts, *flag);
+ delta = __tcp_accecn_process(sk, skb, delivered_pkts,
+ delivered_bytes, *flag);
if (delta > 0) {
tcp_count_delivered_ce(tp, delta);
*flag |= FLAG_ECE;
@@ -4119,6 +4258,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
if (tcp_ecn_mode_accecn(tp))
ecn_count = tcp_accecn_process(sk, skb,
tp->delivered - delivered,
+ sack_state.delivered_bytes,
&flag);
tcp_in_ack_event(sk, flag);
@@ -4158,6 +4298,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
if (tcp_ecn_mode_accecn(tp))
ecn_count = tcp_accecn_process(sk, skb,
tp->delivered - delivered,
+ sack_state.delivered_bytes,
&flag);
tcp_in_ack_event(sk, flag);
/* If data was DSACKed, see if we can undo a cwnd reduction. */
@@ -4285,6 +4426,7 @@ void tcp_parse_options(const struct net *net,
ptr = (const unsigned char *)(th + 1);
opt_rx->saw_tstamp = 0;
+ opt_rx->accecn = 0;
opt_rx->saw_unknown = 0;
while (length > 0) {
@@ -4376,6 +4518,12 @@ void tcp_parse_options(const struct net *net,
ptr, th->syn, foc, false);
break;
+ case TCPOPT_ACCECN0:
+ case TCPOPT_ACCECN1:
+ /* Save offset of AccECN option in TCP header */
+ opt_rx->accecn = (ptr - 2) - (__u8 *)th;
+ break;
+
case TCPOPT_EXP:
/* Fast Open option shares code 254 using a
* 16 bits magic number.
@@ -4436,11 +4584,14 @@ static bool tcp_fast_parse_options(const struct net *net,
*/
if (th->doff == (sizeof(*th) / 4)) {
tp->rx_opt.saw_tstamp = 0;
+ tp->rx_opt.accecn = 0;
return false;
} else if (tp->rx_opt.tstamp_ok &&
th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
- if (tcp_parse_aligned_timestamp(tp, th))
+ if (tcp_parse_aligned_timestamp(tp, th)) {
+ tp->rx_opt.accecn = 0;
return true;
+ }
}
tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
@@ -6054,8 +6205,12 @@ void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
tp->received_ce_pending = min(tp->received_ce_pending + pcount,
0xfU);
- if (payload_len > 0)
+ if (payload_len > 0) {
+ u8 minlen = tcp_ecnfield_to_accecn_optfield(ecnfield);
tp->received_ecn_bytes[ecnfield - 1] += payload_len;
+ tp->accecn_minlen = max_t(u8, tp->accecn_minlen,
+ minlen);
+ }
}
}
@@ -6275,6 +6430,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
*/
tp->rx_opt.saw_tstamp = 0;
+ tp->rx_opt.accecn = 0;
/* pred_flags is 0xS?10 << 16 + snd_wnd
* if header_prediction is to be made
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index c5b93802d7c0..387cf8994202 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -3450,6 +3450,7 @@ static void __net_init tcp_set_hashinfo(struct net *net)
static int __net_init tcp_sk_init(struct net *net)
{
net->ipv4.sysctl_tcp_ecn = TCP_ECN_IN_ECN_OUT_NOECN;
+ net->ipv4.sysctl_tcp_ecn_option = TCP_ECN_OPTION_FULL;
net->ipv4.sysctl_tcp_ecn_fallback = 1;
net->ipv4.sysctl_tcp_base_mss = TCP_BASE_MSS;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 37c981aa9bc6..ca36f5d775f7 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -492,6 +492,7 @@ static inline bool tcp_urg_mode(const struct tcp_sock *tp)
#define OPTION_SMC BIT(9)
#define OPTION_MPTCP BIT(10)
#define OPTION_AO BIT(11)
+#define OPTION_ACCECN BIT(12)
static void smc_options_write(__be32 *ptr, u16 *options)
{
@@ -513,6 +514,8 @@ struct tcp_out_options {
u16 mss; /* 0 to disable */
u8 ws; /* window scale, 0 to disable */
u8 num_sack_blocks; /* number of SACK blocks to include */
+ u8 num_accecn_fields:7, /* number of AccECN fields needed */
+ use_synack_ecn_bytes:1; /* Use synack_ecn_bytes or not */
u8 hash_size; /* bytes in hash_location */
u8 bpf_opt_len; /* length of BPF hdr option */
__u8 *hash_location; /* temporary pointer, overloaded */
@@ -521,6 +524,11 @@ struct tcp_out_options {
struct mptcp_out_options mptcp;
};
+/* Initial values for AccECN option, ordered is based on ECN field bits
+ * similar to received_ecn_bytes. Used for SYN/ACK AccECN option.
+ */
+static u32 synack_ecn_bytes[3] = { 0, 0, 0 };
+
static void mptcp_options_write(struct tcphdr *th, __be32 *ptr,
struct tcp_sock *tp,
struct tcp_out_options *opts)
@@ -728,6 +736,8 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
struct tcp_out_options *opts,
struct tcp_key *key)
{
+ u8 leftover_highbyte = TCPOPT_NOP; /* replace 1st NOP if avail */
+ u8 leftover_lowbyte = TCPOPT_NOP; /* replace 2nd NOP in succession */
__be32 *ptr = (__be32 *)(th + 1);
u16 options = opts->options; /* mungable copy */
@@ -763,15 +773,75 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
*ptr++ = htonl(opts->tsecr);
}
+ if (OPTION_ACCECN & options) {
+ const u8 ect0_idx = INET_ECN_ECT_0 - 1;
+ const u8 ect1_idx = INET_ECN_ECT_1 - 1;
+ const u8 ce_idx = INET_ECN_CE - 1;
+ u32 e0b;
+ u32 e1b;
+ u32 ceb;
+ u8 len;
+
+ if (opts->use_synack_ecn_bytes) {
+ e0b = synack_ecn_bytes[ect0_idx] + TCP_ACCECN_E0B_INIT_OFFSET;
+ e1b = synack_ecn_bytes[ect1_idx] + TCP_ACCECN_E1B_INIT_OFFSET;
+ ceb = synack_ecn_bytes[ce_idx] + TCP_ACCECN_CEB_INIT_OFFSET;
+ } else {
+ e0b = tp->received_ecn_bytes[ect0_idx] + TCP_ACCECN_E0B_INIT_OFFSET;
+ e1b = tp->received_ecn_bytes[ect1_idx] + TCP_ACCECN_E1B_INIT_OFFSET;
+ ceb = tp->received_ecn_bytes[ce_idx] + TCP_ACCECN_CEB_INIT_OFFSET;
+ }
+
+ len = TCPOLEN_ACCECN_BASE +
+ opts->num_accecn_fields * TCPOLEN_ACCECN_PERFIELD;
+
+ if (opts->num_accecn_fields == 2) {
+ *ptr++ = htonl((TCPOPT_ACCECN1 << 24) | (len << 16) |
+ ((e1b >> 8) & 0xffff));
+ *ptr++ = htonl(((e1b & 0xff) << 24) |
+ (ceb & 0xffffff));
+ } else if (opts->num_accecn_fields == 1) {
+ *ptr++ = htonl((TCPOPT_ACCECN1 << 24) | (len << 16) |
+ ((e1b >> 8) & 0xffff));
+ leftover_highbyte = e1b & 0xff;
+ leftover_lowbyte = TCPOPT_NOP;
+ } else if (opts->num_accecn_fields == 0) {
+ leftover_highbyte = TCPOPT_ACCECN1;
+ leftover_lowbyte = len;
+ } else if (opts->num_accecn_fields == 3) {
+ *ptr++ = htonl((TCPOPT_ACCECN1 << 24) | (len << 16) |
+ ((e1b >> 8) & 0xffff));
+ *ptr++ = htonl(((e1b & 0xff) << 24) |
+ (ceb & 0xffffff));
+ *ptr++ = htonl(((e0b & 0xffffff) << 8) |
+ TCPOPT_NOP);
+ }
+ if (tp)
+ tp->accecn_minlen = 0;
+ }
+
if (unlikely(OPTION_SACK_ADVERTISE & options)) {
- *ptr++ = htonl((TCPOPT_NOP << 24) |
- (TCPOPT_NOP << 16) |
+ *ptr++ = htonl((leftover_highbyte << 24) |
+ (leftover_lowbyte << 16) |
(TCPOPT_SACK_PERM << 8) |
TCPOLEN_SACK_PERM);
+ leftover_highbyte = TCPOPT_NOP;
+ leftover_lowbyte = TCPOPT_NOP;
}
if (unlikely(OPTION_WSCALE & options)) {
- *ptr++ = htonl((TCPOPT_NOP << 24) |
+ u8 highbyte = TCPOPT_NOP;
+
+ /* Do not split the leftover 2-byte to fit into a single
+ * NOP, i.e., replace this NOP only when 1 byte is leftover
+ * within leftover_highbyte.
+ */
+ if (unlikely(leftover_highbyte != TCPOPT_NOP &&
+ leftover_lowbyte == TCPOPT_NOP)) {
+ highbyte = leftover_highbyte;
+ leftover_highbyte = TCPOPT_NOP;
+ }
+ *ptr++ = htonl((highbyte << 24) |
(TCPOPT_WINDOW << 16) |
(TCPOLEN_WINDOW << 8) |
opts->ws);
@@ -782,11 +852,13 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
tp->duplicate_sack : tp->selective_acks;
int this_sack;
- *ptr++ = htonl((TCPOPT_NOP << 24) |
- (TCPOPT_NOP << 16) |
+ *ptr++ = htonl((leftover_highbyte << 24) |
+ (leftover_lowbyte << 16) |
(TCPOPT_SACK << 8) |
(TCPOLEN_SACK_BASE + (opts->num_sack_blocks *
TCPOLEN_SACK_PERBLOCK)));
+ leftover_highbyte = TCPOPT_NOP;
+ leftover_lowbyte = TCPOPT_NOP;
for (this_sack = 0; this_sack < opts->num_sack_blocks;
++this_sack) {
@@ -795,6 +867,14 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
}
tp->rx_opt.dsack = 0;
+ } else if (unlikely(leftover_highbyte != TCPOPT_NOP ||
+ leftover_lowbyte != TCPOPT_NOP)) {
+ *ptr++ = htonl((leftover_highbyte << 24) |
+ (leftover_lowbyte << 16) |
+ (TCPOPT_NOP << 8) |
+ TCPOPT_NOP);
+ leftover_highbyte = TCPOPT_NOP;
+ leftover_lowbyte = TCPOPT_NOP;
}
if (unlikely(OPTION_FAST_OPEN_COOKIE & options)) {
@@ -875,6 +955,55 @@ static void mptcp_set_option_cond(const struct request_sock *req,
}
}
+static u32 tcp_synack_options_combine_saving(struct tcp_out_options *opts)
+{
+ /* How much there's room for combining with the alignment padding? */
+ if ((opts->options & (OPTION_SACK_ADVERTISE | OPTION_TS)) ==
+ OPTION_SACK_ADVERTISE)
+ return 2;
+ else if (opts->options & OPTION_WSCALE)
+ return 1;
+ return 0;
+}
+
+/* Calculates how long AccECN option will fit to @remaining option space.
+ *
+ * AccECN option can sometimes replace NOPs used for alignment of other
+ * TCP options (up to @max_combine_saving available).
+ *
+ * Only solutions with at least @required AccECN fields are accepted.
+ *
+ * Returns: The size of the AccECN option excluding space repurposed from
+ * the alignment of the other options.
+ */
+static int tcp_options_fit_accecn(struct tcp_out_options *opts, int required,
+ int remaining, int max_combine_saving)
+{
+ int size = TCP_ACCECN_MAXSIZE;
+
+ opts->num_accecn_fields = TCP_ACCECN_NUMFIELDS;
+
+ while (opts->num_accecn_fields >= required) {
+ int leftover_size = size & 0x3;
+ /* Pad to dword if cannot combine */
+ if (leftover_size > max_combine_saving)
+ leftover_size = -((4 - leftover_size) & 0x3);
+
+ if (remaining >= size - leftover_size) {
+ size -= leftover_size;
+ break;
+ }
+
+ opts->num_accecn_fields--;
+ size -= TCPOLEN_ACCECN_PERFIELD;
+ }
+ if (opts->num_accecn_fields < required)
+ return 0;
+
+ opts->options |= OPTION_ACCECN;
+ return size;
+}
+
/* Compute TCP options for SYN packets. This is not the final
* network wire format yet.
*/
@@ -957,6 +1086,17 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
}
}
+ /* Simultaneous open SYN/ACK needs AccECN option but not SYN */
+ if (unlikely((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK) &&
+ tcp_ecn_mode_accecn(tp) &&
+ sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
+ remaining >= TCPOLEN_ACCECN_BASE)) {
+ u32 saving = tcp_synack_options_combine_saving(opts);
+
+ opts->use_synack_ecn_bytes = 1;
+ remaining -= tcp_options_fit_accecn(opts, 0, remaining, saving);
+ }
+
bpf_skops_hdr_opt_len(sk, skb, NULL, NULL, 0, opts, &remaining);
return MAX_TCP_OPTION_SPACE - remaining;
@@ -974,6 +1114,7 @@ static unsigned int tcp_synack_options(const struct sock *sk,
{
struct inet_request_sock *ireq = inet_rsk(req);
unsigned int remaining = MAX_TCP_OPTION_SPACE;
+ struct tcp_request_sock *treq = tcp_rsk(req);
if (tcp_key_is_md5(key)) {
opts->options |= OPTION_MD5;
@@ -1036,6 +1177,14 @@ static unsigned int tcp_synack_options(const struct sock *sk,
smc_set_option_cond(tcp_sk(sk), ireq, opts, &remaining);
+ if (treq->accecn_ok && sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
+ remaining >= TCPOLEN_ACCECN_BASE) {
+ u32 saving = tcp_synack_options_combine_saving(opts);
+
+ opts->use_synack_ecn_bytes = 1;
+ remaining -= tcp_options_fit_accecn(opts, 0, remaining, saving);
+ }
+
bpf_skops_hdr_opt_len((struct sock *)sk, skb, req, syn_skb,
synack_type, opts, &remaining);
@@ -1108,6 +1257,17 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb
opts->num_sack_blocks = 0;
}
+ if (tcp_ecn_mode_accecn(tp) &&
+ sock_net(sk)->ipv4.sysctl_tcp_ecn_option) {
+ int saving = opts->num_sack_blocks > 0 ? 2 : 0;
+ int remaining = MAX_TCP_OPTION_SPACE - size;
+
+ opts->use_synack_ecn_bytes = 0;
+ size += tcp_options_fit_accecn(opts, tp->accecn_minlen,
+ remaining,
+ saving);
+ }
+
if (unlikely(BPF_SOCK_OPS_TEST_FLAG(tp,
BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG))) {
unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 10/15] tcp: accecn: AccECN option send control
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (8 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 09/15] tcp: accecn: AccECN option chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 11/15] tcp: accecn: AccECN option failure handling chia-yu.chang
` (4 subsequent siblings)
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
Instead of sending the option in every ACK, limit sending to
those ACKs where the option is necessary:
- Handshake
- "Change-triggered ACK" + the ACK following it. The
2nd ACK is necessary to unambiguously indicate which
of the ECN byte counters in increasing. The first
ACK has two counters increasing due to the ecnfield
edge.
- ACKs with CE to allow CEP delta validations to take
advantage of the option.
- Force option to be sent every at least once per 2^22
bytes. The check is done using the bit edges of the
byte counters (avoids need for extra variables).
- AccECN option beacon to send a few times per RTT even if
nothing in the ECN state requires that. The default is 3
times per RTT, and its period can be set via
sysctl_tcp_ecn_option_beacon.
Below are the pahole outcomes before and after this patch,
in which the group size of tcp_sock_write_tx is increased
from 89 to 97 due to the new u64 accecn_opt_tstamp member:
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
u64 tcp_wstamp_ns; /* 2552 8 */
struct list_head tsorted_sent_queue; /* 2560 16 */
[...]
__cacheline_group_end__tcp_sock_write_tx[0]; /* 2585 0 */
__cacheline_group_begin__tcp_sock_write_txrx[0]; /* 2585 0 */
u8 nonagle:4; /* 2585: 0 1 */
u8 rate_app_limited:1; /* 2585: 4 1 */
/* XXX 3 bits hole, try to pack */
/* Force alignment to the next boundary: */
u8 :0;
u8 received_ce_pending:4;/* 2586: 0 1 */
u8 unused2:4; /* 2586: 4 1 */
u8 accecn_minlen:2; /* 2587: 0 1 */
u8 est_ecnfield:2; /* 2587: 2 1 */
u8 unused3:4; /* 2587: 4 1 */
[...]
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2692 0 */
[...]
/* size: 3264, cachelines: 51, members: 174 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
u64 tcp_wstamp_ns; /* 2552 8 */
u64 accecn_opt_tstamp; /* 2560 8 */
struct list_head tsorted_sent_queue; /* 2568 16 */
[...]
__cacheline_group_end__tcp_sock_write_tx[0]; /* 2593 0 */
__cacheline_group_begin__tcp_sock_write_txrx[0]; /* 2593 0 */
u8 nonagle:4; /* 2593: 0 1 */
u8 rate_app_limited:1; /* 2593: 4 1 */
/* XXX 3 bits hole, try to pack */
/* Force alignment to the next boundary: */
u8 :0;
u8 received_ce_pending:4;/* 2594: 0 1 */
u8 unused2:4; /* 2594: 4 1 */
u8 accecn_minlen:2; /* 2595: 0 1 */
u8 est_ecnfield:2; /* 2595: 2 1 */
u8 accecn_opt_demand:2; /* 2595: 4 1 */
u8 prev_ecnfield:2; /* 2595: 6 1 */
[...]
__cacheline_group_end__tcp_sock_write_txrx[0]; /* 2700 0 */
[...]
/* size: 3264, cachelines: 51, members: 176 */
}
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v8:
- Add new helper function tcp_accecn_opt_demand_min()
- Remove white space only change
---
.../networking/net_cachelines/tcp_sock.rst | 3 ++
include/linux/tcp.h | 4 +-
include/net/netns/ipv4.h | 1 +
include/net/tcp.h | 5 +++
net/ipv4/sysctl_net_ipv4.c | 9 +++++
net/ipv4/tcp.c | 5 ++-
net/ipv4/tcp_input.c | 40 ++++++++++++++++++-
net/ipv4/tcp_ipv4.c | 1 +
net/ipv4/tcp_minisocks.c | 2 +
net/ipv4/tcp_output.c | 28 ++++++++++++-
10 files changed, 93 insertions(+), 5 deletions(-)
diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
index ed6af7d0110c..88c668f9c68b 100644
--- a/Documentation/networking/net_cachelines/tcp_sock.rst
+++ b/Documentation/networking/net_cachelines/tcp_sock.rst
@@ -110,6 +110,9 @@ u8:2 syn_ect_rcv read_mostly read_w
u8:1 wait_third_ack read_write
u8:2 accecn_minlen write_mostly read_write
u8:2 est_ecnfield read_write
+u8:2 accecn_opt_demand read_mostly read_write
+u8:2 prev_ecnfield read_write
+u64 accecn_opt_tstamp read_write
u8:4 accecn_fail_mode
u32 lost read_mostly tcp_ack
u32 app_limited read_write read_mostly tcp_rate_check_app_limited,tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 0008b8190ea0..2c0a2db6e6dd 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -275,6 +275,7 @@ struct tcp_sock {
u32 mdev_us; /* medium deviation */
u32 rtt_seq; /* sequence number to update rttvar */
u64 tcp_wstamp_ns; /* departure time for next sent data packet */
+ u64 accecn_opt_tstamp; /* Last AccECN option sent timestamp */
struct list_head tsorted_sent_queue; /* time-sorted sent but un-SACKed skbs */
struct sk_buff *highest_sack; /* skb just after the highest
* skb with SACKed bit set
@@ -296,7 +297,8 @@ struct tcp_sock {
unused2:4;
u8 accecn_minlen:2,/* Minimum length of AccECN option sent */
est_ecnfield:2,/* ECN field for AccECN delivered estimates */
- unused3:4;
+ accecn_opt_demand:2,/* Demand AccECN option for n next ACKs */
+ prev_ecnfield:2; /* ECN bits from the previous segment */
__be32 pred_flags;
u64 tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */
u64 tcp_mstamp; /* most recent packet received/sent */
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index 4569a9ef4fb8..ff8b5b56ad00 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -149,6 +149,7 @@ struct netns_ipv4 {
u8 sysctl_tcp_ecn;
u8 sysctl_tcp_ecn_option;
+ u8 sysctl_tcp_ecn_option_beacon;
u8 sysctl_tcp_ecn_fallback;
u8 sysctl_ip_default_ttl;
diff --git a/include/net/tcp.h b/include/net/tcp.h
index f7ba314eb7f9..fb0d69ee3ce1 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -91,6 +91,9 @@ void tcp_time_wait(struct sock *sk, int state, int timeo);
/* Maximal number of window scale according to RFC1323 */
#define TCP_MAX_WSCALE 14U
+/* Default sending frequency of accurate ECN option per RTT */
+#define TCP_ECN_OPTION_BEACON 3
+
/* urg_data states */
#define TCP_URG_VALID 0x0100
#define TCP_URG_NOTYET 0x0200
@@ -477,6 +480,7 @@ static inline int tcp_accecn_extract_syn_ect(u8 ace)
bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect);
void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
u8 syn_ect_snt);
+void tcp_accecn_opt_demand_min(struct sock *sk, u8 opt_demand_min);
void tcp_ecn_received_counters_payload(struct sock *sk,
const struct sk_buff *skb);
void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
@@ -1090,6 +1094,7 @@ static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
__tcp_accecn_init_bytes_counters(tp->received_ecn_bytes);
__tcp_accecn_init_bytes_counters(tp->delivered_ecn_bytes);
tp->accecn_minlen = 0;
+ tp->accecn_opt_demand = 0;
tp->est_ecnfield = 0;
}
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 1d7fd86ca7b9..169a393374b3 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -740,6 +740,15 @@ static struct ctl_table ipv4_net_table[] = {
.extra1 = SYSCTL_ZERO,
.extra2 = SYSCTL_TWO,
},
+ {
+ .procname = "tcp_ecn_option_beacon",
+ .data = &init_net.ipv4.sysctl_tcp_ecn_option_beacon,
+ .maxlen = sizeof(u8),
+ .mode = 0644,
+ .proc_handler = proc_dou8vec_minmax,
+ .extra1 = SYSCTL_ZERO,
+ .extra2 = SYSCTL_THREE,
+ },
{
.procname = "tcp_ecn_fallback",
.data = &init_net.ipv4.sysctl_tcp_ecn_fallback,
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 1c1d4cbdda1c..f7a85192c86f 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3396,6 +3396,8 @@ int tcp_disconnect(struct sock *sk, int flags)
tp->wait_third_ack = 0;
tp->accecn_fail_mode = 0;
tcp_accecn_init_counters(tp);
+ tp->prev_ecnfield = 0;
+ tp->accecn_opt_tstamp = 0;
if (icsk->icsk_ca_initialized && icsk->icsk_ca_ops->release)
icsk->icsk_ca_ops->release(sk);
memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv));
@@ -5114,11 +5116,12 @@ static void __init tcp_struct_check(void)
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, lsndtime);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, mdev_us);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, tcp_wstamp_ns);
+ CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, accecn_opt_tstamp);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, rtt_seq);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, tsorted_sent_queue);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, highest_sack);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_tx, ecn_flags);
- CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_tx, 89);
+ CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_tx, 97);
/* TXRX read-write hotpath cache lines */
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, pred_flags);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 66390966cc41..3cc9c57d9983 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -497,6 +497,7 @@ static void tcp_ecn_rcv_synack(struct sock *sk, const struct tcphdr *th,
default:
tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
tp->syn_ect_rcv = ip_dsfield & INET_ECN_MASK;
+ tp->accecn_opt_demand = 2;
if (INET_ECN_is_ce(ip_dsfield) &&
tcp_accecn_validate_syn_feedback(sk, ace,
tp->syn_ect_snt)) {
@@ -517,6 +518,7 @@ static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th,
} else {
tp->syn_ect_rcv = TCP_SKB_CB(skb)->ip_dsfield &
INET_ECN_MASK;
+ tp->prev_ecnfield = tp->syn_ect_rcv;
tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
}
}
@@ -6182,6 +6184,15 @@ void tcp_ecn_received_counters_payload(struct sock *sk,
tcp_ecn_received_counters(sk, skb, skb->len - th->doff * 4);
}
+void tcp_accecn_opt_demand_min(struct sock *sk, u8 opt_demand_min)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+ u8 opt_demand;
+
+ opt_demand = max_t(u8, opt_demand_min, tp->accecn_opt_demand);
+ tp->accecn_opt_demand = opt_demand;
+}
+
/* Updates Accurate ECN received counters from the received IP ECN field */
void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
u32 payload_len)
@@ -6189,6 +6200,7 @@ void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
u8 ecnfield = TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK;
u8 is_ce = INET_ECN_is_ce(ecnfield);
struct tcp_sock *tp = tcp_sk(sk);
+ bool ecn_edge;
if (!INET_ECN_is_not_ect(ecnfield)) {
u32 pcount = is_ce * max_t(u16, 1, skb_shinfo(skb)->gso_segs);
@@ -6207,9 +6219,33 @@ void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
if (payload_len > 0) {
u8 minlen = tcp_ecnfield_to_accecn_optfield(ecnfield);
+ u32 oldbytes = tp->received_ecn_bytes[ecnfield - 1];
+
tp->received_ecn_bytes[ecnfield - 1] += payload_len;
tp->accecn_minlen = max_t(u8, tp->accecn_minlen,
minlen);
+
+ /* Demand AccECN option at least every 2^22 bytes to
+ * avoid overflowing the ECN byte counters.
+ */
+ if ((tp->received_ecn_bytes[ecnfield - 1] ^ oldbytes) &
+ ~((1 << 22) - 1)) {
+ tcp_accecn_opt_demand_min(sk, 1);
+ }
+ }
+ }
+
+ ecn_edge = tp->prev_ecnfield != ecnfield;
+ if (ecn_edge || is_ce) {
+ tp->prev_ecnfield = ecnfield;
+ /* Demand Accurate ECN change-triggered ACKs. Two ACK are
+ * demanded to indicate unambiguously the ecnfield value
+ * in the latter ACK.
+ */
+ if (tcp_ecn_mode_accecn(tp)) {
+ if (ecn_edge)
+ inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_NOW;
+ tp->accecn_opt_demand = 2;
}
}
}
@@ -6342,8 +6378,10 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
* RFC 5961 4.2 : Send a challenge ack
*/
if (th->syn) {
- if (tcp_ecn_mode_accecn(tp))
+ if (tcp_ecn_mode_accecn(tp)) {
accecn_reflector = true;
+ tcp_accecn_opt_demand_min(sk, 1);
+ }
if (sk->sk_state == TCP_SYN_RECV && sk->sk_socket && th->ack &&
TCP_SKB_CB(skb)->seq + 1 == TCP_SKB_CB(skb)->end_seq &&
TCP_SKB_CB(skb)->seq + 1 == tp->rcv_nxt &&
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 387cf8994202..7d4660378378 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -3451,6 +3451,7 @@ static int __net_init tcp_sk_init(struct net *net)
{
net->ipv4.sysctl_tcp_ecn = TCP_ECN_IN_ECN_OUT_NOECN;
net->ipv4.sysctl_tcp_ecn_option = TCP_ECN_OPTION_FULL;
+ net->ipv4.sysctl_tcp_ecn_option_beacon = TCP_ECN_OPTION_BEACON;
net->ipv4.sysctl_tcp_ecn_fallback = 1;
net->ipv4.sysctl_tcp_base_mss = TCP_BASE_MSS;
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index f1e698c323f3..5b0f703f23a5 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -500,6 +500,8 @@ static void tcp_ecn_openreq_child(struct sock *sk,
tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
tp->syn_ect_snt = treq->syn_ect_snt;
tcp_accecn_third_ack(sk, skb, treq->syn_ect_snt);
+ tp->prev_ecnfield = treq->syn_ect_rcv;
+ tp->accecn_opt_demand = 1;
tcp_ecn_received_counters_payload(sk, skb);
} else {
tcp_ecn_mode_set(tp, inet_rsk(req)->ecn_ok ?
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index ca36f5d775f7..a4c80be115e5 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -816,8 +816,12 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
*ptr++ = htonl(((e0b & 0xffffff) << 8) |
TCPOPT_NOP);
}
- if (tp)
+ if (tp) {
tp->accecn_minlen = 0;
+ tp->accecn_opt_tstamp = tp->tcp_mstamp;
+ if (tp->accecn_opt_demand)
+ tp->accecn_opt_demand--;
+ }
}
if (unlikely(OPTION_SACK_ADVERTISE & options)) {
@@ -1004,6 +1008,18 @@ static int tcp_options_fit_accecn(struct tcp_out_options *opts, int required,
return size;
}
+static bool tcp_accecn_option_beacon_check(const struct sock *sk)
+{
+ const struct tcp_sock *tp = tcp_sk(sk);
+
+ if (!sock_net(sk)->ipv4.sysctl_tcp_ecn_option_beacon)
+ return false;
+
+ return tcp_stamp_us_delta(tp->tcp_mstamp, tp->accecn_opt_tstamp) *
+ sock_net(sk)->ipv4.sysctl_tcp_ecn_option_beacon >=
+ (tp->srtt_us >> 3);
+}
+
/* Compute TCP options for SYN packets. This is not the final
* network wire format yet.
*/
@@ -1258,7 +1274,10 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb
}
if (tcp_ecn_mode_accecn(tp) &&
- sock_net(sk)->ipv4.sysctl_tcp_ecn_option) {
+ sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
+ (sock_net(sk)->ipv4.sysctl_tcp_ecn_option >= TCP_ECN_OPTION_FULL ||
+ tp->accecn_opt_demand ||
+ tcp_accecn_option_beacon_check(sk))) {
int saving = opts->num_sack_blocks > 0 ? 2 : 0;
int remaining = MAX_TCP_OPTION_SPACE - size;
@@ -2975,6 +2994,11 @@ static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
sent_pkts = 0;
tcp_mstamp_refresh(tp);
+
+ /* AccECN option beacon depends on mstamp, it may change mss */
+ if (tcp_ecn_mode_accecn(tp) && tcp_accecn_option_beacon_check(sk))
+ mss_now = tcp_current_mss(sk);
+
if (!push_one) {
/* Do MTU probing. */
result = tcp_mtu_probe(sk);
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 11/15] tcp: accecn: AccECN option failure handling
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (9 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 10/15] tcp: accecn: AccECN option send control chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 12/15] tcp: accecn: AccECN option ceb/cep heuristic chia-yu.chang
` (3 subsequent siblings)
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
AccECN option may fail in various way, handle these:
- Attempt to negotiate the use of AccECN on the 1st retransmitted SYN
- From the 2nd retransmitted SYN, stop AccECN negotiation
- Remove option from SYN/ACK rexmits to handle blackholes
- If no option arrives in SYN/ACK, assume Option is not usable
- If an option arrives later, re-enabled
- If option is zeroed, disable AccECN option processing
This patch use existing padding bits in tcp_request_sock and
holes in tcp_sock without increasing the size.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v9:
- Add comments about the 1st retx SYN still attempt AccECN negotiation
v8:
- Add new helper function tcp_accecn_saw_opt_fail_recv()
---
include/linux/tcp.h | 4 ++-
include/net/tcp.h | 8 ++++++
net/ipv4/tcp.c | 1 +
net/ipv4/tcp_input.c | 55 +++++++++++++++++++++++++++++++++++-----
net/ipv4/tcp_minisocks.c | 38 +++++++++++++++++++++++++++
net/ipv4/tcp_output.c | 11 ++++++--
6 files changed, 108 insertions(+), 9 deletions(-)
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 2c0a2db6e6dd..8609fb138108 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -173,6 +173,7 @@ struct tcp_request_sock {
u8 syn_ect_snt: 2,
syn_ect_rcv: 2,
accecn_fail_mode:4;
+ u8 saw_accecn_opt :2;
#ifdef CONFIG_TCP_AO
u8 ao_keyid;
u8 ao_rcv_next;
@@ -408,7 +409,8 @@ struct tcp_sock {
syn_fastopen_child:1; /* created TFO passive child socket */
u8 keepalive_probes; /* num of allowed keep alive probes */
- u8 accecn_fail_mode:4; /* AccECN failure handling */
+ u8 accecn_fail_mode:4, /* AccECN failure handling */
+ saw_accecn_opt:2; /* An AccECN option was seen */
u32 tcp_tx_delay; /* delay (in usec) added to TX packets */
/* RTT measurement */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index fb0d69ee3ce1..7ee85f6b733a 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -279,6 +279,12 @@ static inline void tcp_accecn_fail_mode_set(struct tcp_sock *tp, u8 mode)
tp->accecn_fail_mode |= mode;
}
+/* tp->saw_accecn_opt states */
+#define TCP_ACCECN_OPT_NOT_SEEN 0x0
+#define TCP_ACCECN_OPT_EMPTY_SEEN 0x1
+#define TCP_ACCECN_OPT_COUNTER_SEEN 0x2
+#define TCP_ACCECN_OPT_FAIL_SEEN 0x3
+
/* Flags in tp->nonagle */
#define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */
#define TCP_NAGLE_CORK 2 /* Socket is corked */
@@ -478,9 +484,11 @@ static inline int tcp_accecn_extract_syn_ect(u8 ace)
}
bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect);
+void tcp_accecn_saw_opt_fail_recv(struct tcp_sock *tp, u8 saw_opt);
void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
u8 syn_ect_snt);
void tcp_accecn_opt_demand_min(struct sock *sk, u8 opt_demand_min);
+u8 tcp_accecn_option_init(const struct sk_buff *skb, u8 opt_offset);
void tcp_ecn_received_counters_payload(struct sock *sk,
const struct sk_buff *skb);
void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index f7a85192c86f..a9e30c72d71b 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3395,6 +3395,7 @@ int tcp_disconnect(struct sock *sk, int flags)
tp->delivered_ce = 0;
tp->wait_third_ack = 0;
tp->accecn_fail_mode = 0;
+ tp->saw_accecn_opt = TCP_ACCECN_OPT_NOT_SEEN;
tcp_accecn_init_counters(tp);
tp->prev_ecnfield = 0;
tp->accecn_opt_tstamp = 0;
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 3cc9c57d9983..f415ed549339 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -455,10 +455,16 @@ bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect)
return true;
}
-/* See Table 2 of the AccECN draft */
+void tcp_accecn_saw_opt_fail_recv(struct tcp_sock *tp, u8 saw_opt)
+{
+ tp->saw_accecn_opt = saw_opt;
+ if (tp->saw_accecn_opt == TCP_ACCECN_OPT_FAIL_SEEN)
+ tcp_accecn_fail_mode_set(tp, TCP_ACCECN_OPT_FAIL_RECV);
+}
-static void tcp_ecn_rcv_synack(struct sock *sk, const struct tcphdr *th,
- u8 ip_dsfield)
+/* See Table 2 of the AccECN draft */
+static void tcp_ecn_rcv_synack(struct sock *sk, const struct sk_buff *skb,
+ const struct tcphdr *th, u8 ip_dsfield)
{
struct tcp_sock *tp = tcp_sk(sk);
u8 ace = tcp_accecn_ace(th);
@@ -497,7 +503,13 @@ static void tcp_ecn_rcv_synack(struct sock *sk, const struct tcphdr *th,
default:
tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
tp->syn_ect_rcv = ip_dsfield & INET_ECN_MASK;
- tp->accecn_opt_demand = 2;
+ if (tp->rx_opt.accecn &&
+ tp->saw_accecn_opt < TCP_ACCECN_OPT_COUNTER_SEEN) {
+ u8 saw_opt = tcp_accecn_option_init(skb, tp->rx_opt.accecn);
+
+ tcp_accecn_saw_opt_fail_recv(tp, saw_opt);
+ tp->accecn_opt_demand = 2;
+ }
if (INET_ECN_is_ce(ip_dsfield) &&
tcp_accecn_validate_syn_feedback(sk, ace,
tp->syn_ect_snt)) {
@@ -613,7 +625,22 @@ static bool tcp_accecn_process_option(struct tcp_sock *tp,
unsigned int i;
u8 *ptr;
+ if (tcp_accecn_opt_fail_recv(tp))
+ return false;
+
if (!(flag & FLAG_SLOWPATH) || !tp->rx_opt.accecn) {
+ if (!tp->saw_accecn_opt) {
+ /* Too late to enable after this point due to
+ * potential counter wraps
+ */
+ if (tp->bytes_sent >= (1 << 23) - 1) {
+ u8 saw_opt = TCP_ACCECN_OPT_FAIL_SEEN;
+
+ tcp_accecn_saw_opt_fail_recv(tp, saw_opt);
+ }
+ return false;
+ }
+
if (estimate_ecnfield) {
u8 ecnfield = estimate_ecnfield - 1;
@@ -629,6 +656,13 @@ static bool tcp_accecn_process_option(struct tcp_sock *tp,
order1 = (ptr[0] == TCPOPT_ACCECN1);
ptr += 2;
+ if (tp->saw_accecn_opt < TCP_ACCECN_OPT_COUNTER_SEEN) {
+ tp->saw_accecn_opt = tcp_accecn_option_init(skb,
+ tp->rx_opt.accecn);
+ if (tp->saw_accecn_opt == TCP_ACCECN_OPT_FAIL_SEEN)
+ tcp_accecn_fail_mode_set(tp, TCP_ACCECN_OPT_FAIL_RECV);
+ }
+
res = !!estimate_ecnfield;
for (i = 0; i < 3; i++) {
u32 init_offset;
@@ -6380,7 +6414,13 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
if (th->syn) {
if (tcp_ecn_mode_accecn(tp)) {
accecn_reflector = true;
- tcp_accecn_opt_demand_min(sk, 1);
+ if (tp->rx_opt.accecn &&
+ tp->saw_accecn_opt < TCP_ACCECN_OPT_COUNTER_SEEN) {
+ u8 saw_opt = tcp_accecn_option_init(skb, tp->rx_opt.accecn);
+
+ tcp_accecn_saw_opt_fail_recv(tp, saw_opt);
+ tcp_accecn_opt_demand_min(sk, 1);
+ }
}
if (sk->sk_state == TCP_SYN_RECV && sk->sk_socket && th->ack &&
TCP_SKB_CB(skb)->seq + 1 == TCP_SKB_CB(skb)->end_seq &&
@@ -6870,7 +6910,8 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
*/
if (tcp_ecn_mode_any(tp))
- tcp_ecn_rcv_synack(sk, th, TCP_SKB_CB(skb)->ip_dsfield);
+ tcp_ecn_rcv_synack(sk, skb, th,
+ TCP_SKB_CB(skb)->ip_dsfield);
tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
tcp_try_undo_spurious_syn(sk);
@@ -7445,6 +7486,8 @@ static void tcp_openreq_init(struct request_sock *req,
tcp_rsk(req)->snt_tsval_first = 0;
tcp_rsk(req)->last_oow_ack_time = 0;
tcp_rsk(req)->accecn_ok = 0;
+ tcp_rsk(req)->saw_accecn_opt = TCP_ACCECN_OPT_NOT_SEEN;
+ tcp_rsk(req)->accecn_fail_mode = 0;
tcp_rsk(req)->syn_ect_rcv = 0;
tcp_rsk(req)->syn_ect_snt = 0;
req->mss = rx_opt->mss_clamp;
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 5b0f703f23a5..ddf2837eb4d1 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -500,6 +500,7 @@ static void tcp_ecn_openreq_child(struct sock *sk,
tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
tp->syn_ect_snt = treq->syn_ect_snt;
tcp_accecn_third_ack(sk, skb, treq->syn_ect_snt);
+ tp->saw_accecn_opt = treq->saw_accecn_opt;
tp->prev_ecnfield = treq->syn_ect_rcv;
tp->accecn_opt_demand = 1;
tcp_ecn_received_counters_payload(sk, skb);
@@ -554,6 +555,30 @@ static void smc_check_reset_syn_req(const struct tcp_sock *oldtp,
#endif
}
+u8 tcp_accecn_option_init(const struct sk_buff *skb, u8 opt_offset)
+{
+ u8 *ptr = skb_transport_header(skb) + opt_offset;
+ unsigned int optlen = ptr[1] - 2;
+
+ WARN_ON_ONCE(ptr[0] != TCPOPT_ACCECN0 && ptr[0] != TCPOPT_ACCECN1);
+ ptr += 2;
+
+ /* Detect option zeroing: an AccECN connection "MAY check that the
+ * initial value of the EE0B field or the EE1B field is non-zero"
+ */
+ if (optlen < TCPOLEN_ACCECN_PERFIELD)
+ return TCP_ACCECN_OPT_EMPTY_SEEN;
+ if (get_unaligned_be24(ptr) == 0)
+ return TCP_ACCECN_OPT_FAIL_SEEN;
+ if (optlen < TCPOLEN_ACCECN_PERFIELD * 3)
+ return TCP_ACCECN_OPT_COUNTER_SEEN;
+ ptr += TCPOLEN_ACCECN_PERFIELD * 2;
+ if (get_unaligned_be24(ptr) == 0)
+ return TCP_ACCECN_OPT_FAIL_SEEN;
+
+ return TCP_ACCECN_OPT_COUNTER_SEEN;
+}
+
/* This is not only more efficient than what we used to do, it eliminates
* a lot of code duplication between IPv4/IPv6 SYN recv processing. -DaveM
*
@@ -715,6 +740,7 @@ struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
bool own_req;
tmp_opt.saw_tstamp = 0;
+ tmp_opt.accecn = 0;
if (th->doff > (sizeof(struct tcphdr)>>2)) {
tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0, NULL);
@@ -892,6 +918,18 @@ struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
if (!(flg & TCP_FLAG_ACK))
return NULL;
+ if (tcp_rsk(req)->accecn_ok && tmp_opt.accecn &&
+ tcp_rsk(req)->saw_accecn_opt < TCP_ACCECN_OPT_COUNTER_SEEN) {
+ u8 saw_opt = tcp_accecn_option_init(skb, tmp_opt.accecn);
+
+ tcp_rsk(req)->saw_accecn_opt = saw_opt;
+ if (tcp_rsk(req)->saw_accecn_opt == TCP_ACCECN_OPT_FAIL_SEEN) {
+ u8 fail_mode = TCP_ACCECN_OPT_FAIL_RECV;
+
+ tcp_rsk(req)->accecn_fail_mode |= fail_mode;
+ }
+ }
+
/* For Fast Open no more processing is needed (sk is the
* child socket).
*/
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index a4c80be115e5..4a87380037cb 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1102,9 +1102,14 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
}
}
- /* Simultaneous open SYN/ACK needs AccECN option but not SYN */
+ /* Simultaneous open SYN/ACK needs AccECN option but not SYN.
+ * It is attempted to negotiate the use of AccECN also on the first
+ * retransmitted SYN, as mentioned in "3.1.4.1. Retransmitted SYNs"
+ * of AccECN draft.
+ */
if (unlikely((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK) &&
tcp_ecn_mode_accecn(tp) &&
+ inet_csk(sk)->icsk_retransmits < 2 &&
sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
remaining >= TCPOLEN_ACCECN_BASE)) {
u32 saving = tcp_synack_options_combine_saving(opts);
@@ -1194,7 +1199,7 @@ static unsigned int tcp_synack_options(const struct sock *sk,
smc_set_option_cond(tcp_sk(sk), ireq, opts, &remaining);
if (treq->accecn_ok && sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
- remaining >= TCPOLEN_ACCECN_BASE) {
+ req->num_timeout < 1 && remaining >= TCPOLEN_ACCECN_BASE) {
u32 saving = tcp_synack_options_combine_saving(opts);
opts->use_synack_ecn_bytes = 1;
@@ -1275,6 +1280,8 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb
if (tcp_ecn_mode_accecn(tp) &&
sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
+ tp->saw_accecn_opt &&
+ !tcp_accecn_opt_fail_send(tp) &&
(sock_net(sk)->ipv4.sysctl_tcp_ecn_option >= TCP_ECN_OPTION_FULL ||
tp->accecn_opt_demand ||
tcp_accecn_option_beacon_check(sk))) {
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 12/15] tcp: accecn: AccECN option ceb/cep heuristic
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (10 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 11/15] tcp: accecn: AccECN option failure handling chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 13/15] tcp: accecn: AccECN ACE field multi-wrap heuristic chia-yu.chang
` (2 subsequent siblings)
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
The heuristic algorithm from draft-11 Appendix A.2.2 to
mitigate against false ACE field overflows.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
include/net/tcp.h | 1 +
net/ipv4/tcp_input.c | 18 ++++++++++++++++--
2 files changed, 17 insertions(+), 2 deletions(-)
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 7ee85f6b733a..a122784d844b 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -247,6 +247,7 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
#define TCP_ACCECN_MAXSIZE (TCPOLEN_ACCECN_BASE + \
TCPOLEN_ACCECN_PERFIELD * \
TCP_ACCECN_NUMFIELDS)
+#define TCP_ACCECN_SAFETY_SHIFT 1 /* SAFETY_FACTOR in accecn draft */
/* tp->accecn_fail_mode */
#define TCP_ACCECN_ACE_FAIL_SEND BIT(0)
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index f415ed549339..3f8cac22efda 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -719,16 +719,19 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
u32 delivered_pkts, u32 delivered_bytes,
int flag)
{
+ u32 old_ceb = tcp_sk(sk)->delivered_ecn_bytes[INET_ECN_CE - 1];
const struct tcphdr *th = tcp_hdr(skb);
struct tcp_sock *tp = tcp_sk(sk);
- u32 delta, safe_delta;
+ u32 delta, safe_delta, d_ceb;
+ bool opt_deltas_valid;
u32 corrected_ace;
/* Reordered ACK or uncertain due to lack of data to send and ts */
if (!(flag & (FLAG_FORWARD_PROGRESS | FLAG_TS_PROGRESS)))
return 0;
- tcp_accecn_process_option(tp, skb, delivered_bytes, flag);
+ opt_deltas_valid = tcp_accecn_process_option(tp, skb,
+ delivered_bytes, flag);
if (!(flag & FLAG_SLOWPATH)) {
/* AccECN counter might overflow on large ACKs */
@@ -751,6 +754,17 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
safe_delta = delivered_pkts -
((delivered_pkts - delta) & TCP_ACCECN_CEP_ACE_MASK);
+ if (opt_deltas_valid) {
+ d_ceb = tp->delivered_ecn_bytes[INET_ECN_CE - 1] - old_ceb;
+ if (!d_ceb)
+ return delta;
+ if (d_ceb > delta * tp->mss_cache)
+ return safe_delta;
+ if (d_ceb <
+ safe_delta * tp->mss_cache >> TCP_ACCECN_SAFETY_SHIFT)
+ return delta;
+ }
+
return safe_delta;
}
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 13/15] tcp: accecn: AccECN ACE field multi-wrap heuristic
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (11 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 12/15] tcp: accecn: AccECN option ceb/cep heuristic chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 14/15] tcp: accecn: try to fit AccECN option with SACK chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 15/15] tcp: try to avoid safer when ACKs are thinned chia-yu.chang
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
Armed with ceb delta from option, delivered bytes, and
delivered packets it is possible to estimate how many times
ACE field wrapped.
This calculation is necessary only if more than one wrap
is possible. Without SACK, delivered bytes and packets are
not always trustworthy in which case TCP falls back to the
simpler no-or-all wraps ceb algorithm.
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
net/ipv4/tcp_input.c | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 3f8cac22efda..97b5fe52d8fd 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -758,6 +758,24 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
d_ceb = tp->delivered_ecn_bytes[INET_ECN_CE - 1] - old_ceb;
if (!d_ceb)
return delta;
+
+ if ((delivered_pkts >= (TCP_ACCECN_CEP_ACE_MASK + 1) * 2) &&
+ (tcp_is_sack(tp) ||
+ ((1 << inet_csk(sk)->icsk_ca_state) &
+ (TCPF_CA_Open | TCPF_CA_CWR)))) {
+ u32 est_d_cep;
+
+ if (delivered_bytes <= d_ceb)
+ return safe_delta;
+
+ est_d_cep = DIV_ROUND_UP_ULL((u64)d_ceb *
+ delivered_pkts,
+ delivered_bytes);
+ return min(safe_delta,
+ delta +
+ (est_d_cep & ~TCP_ACCECN_CEP_ACE_MASK));
+ }
+
if (d_ceb > delta * tp->mss_cache)
return safe_delta;
if (d_ceb <
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 14/15] tcp: accecn: try to fit AccECN option with SACK
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (12 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 13/15] tcp: accecn: AccECN ACE field multi-wrap heuristic chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
2025-06-25 9:33 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 15/15] tcp: try to avoid safer when ACKs are thinned chia-yu.chang
14 siblings, 1 reply; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
As SACK blocks tend to eat all option space when there are
many holes, it is useful to compromise on sending many SACK
blocks in every ACK and attempt to fit the AccECN option
there by reducing the number of SACK blocks. However, it will
never go below two SACK blocks because of the AccECN option.
As the AccECN option is often not put to every ACK, the space
hijack is usually only temporary. Depending on the length of
AccECN option (can be either 11, 8, 5, or 2 bytes, cf. Table
5 in AccECN spec) and the NOPs used for alignment of other
TCP options, up to two SACK blocks will be reduced.
Co-developed-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
v8:
- Update tcp_options_fit_accecn() to avoid using recursion
---
net/ipv4/tcp_output.c | 22 ++++++++++++++++++++--
1 file changed, 20 insertions(+), 2 deletions(-)
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 4a87380037cb..001c883c2940 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -984,23 +984,41 @@ static int tcp_options_fit_accecn(struct tcp_out_options *opts, int required,
int remaining, int max_combine_saving)
{
int size = TCP_ACCECN_MAXSIZE;
+ int sack_blocks_reduce = 0;
+ int rem = remaining;
opts->num_accecn_fields = TCP_ACCECN_NUMFIELDS;
-
while (opts->num_accecn_fields >= required) {
int leftover_size = size & 0x3;
/* Pad to dword if cannot combine */
if (leftover_size > max_combine_saving)
leftover_size = -((4 - leftover_size) & 0x3);
- if (remaining >= size - leftover_size) {
+ if (rem >= size - leftover_size) {
size -= leftover_size;
break;
+ } else if (opts->num_accecn_fields == required &&
+ opts->num_sack_blocks > 2 &&
+ required > 0) {
+ /* Try to fit the option by removing one SACK block */
+ opts->num_sack_blocks--;
+ sack_blocks_reduce++;
+ rem = rem + TCPOLEN_SACK_PERBLOCK;
+
+ opts->num_accecn_fields = TCP_ACCECN_NUMFIELDS;
+ size = TCP_ACCECN_MAXSIZE;
+ continue;
}
opts->num_accecn_fields--;
size -= TCPOLEN_ACCECN_PERFIELD;
}
+ if (sack_blocks_reduce > 0) {
+ if (opts->num_accecn_fields >= required)
+ size -= sack_blocks_reduce * TCPOLEN_SACK_PERBLOCK;
+ else
+ opts->num_sack_blocks += sack_blocks_reduce;
+ }
if (opts->num_accecn_fields < required)
return 0;
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* [PATCH v9 net-next 15/15] tcp: try to avoid safer when ACKs are thinned
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
` (13 preceding siblings ...)
2025-06-21 19:37 ` [PATCH v9 net-next 14/15] tcp: accecn: try to fit AccECN option with SACK chia-yu.chang
@ 2025-06-21 19:37 ` chia-yu.chang
14 siblings, 0 replies; 29+ messages in thread
From: chia-yu.chang @ 2025-06-21 19:37 UTC (permalink / raw)
To: pabeni, edumazet, linux-doc, corbet, horms, dsahern, kuniyu, bpf,
netdev, dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri,
davem, andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
Cc: Chia-Yu Chang
From: Ilpo Järvinen <ij@kernel.org>
Add newly acked pkts EWMA. When ACK thinning occurs, select
between safer and unsafe cep delta in AccECN processing based
on it. If the packets ACKed per ACK tends to be large, don't
conservatively assume ACE field overflow.
This patch uses the existing 2-byte holes in the rx group for new
u16 variables withtout creating more holes. Below are the pahole
outcomes before and after this patch:
[BEFORE THIS PATCH]
struct tcp_sock {
[...]
u32 delivered_ecn_bytes[3]; /* 2744 12 */
/* XXX 4 bytes hole, try to pack */
[...]
__cacheline_group_end__tcp_sock_write_rx[0]; /* 2816 0 */
[...]
/* size: 3264, cachelines: 51, members: 177 */
}
[AFTER THIS PATCH]
struct tcp_sock {
[...]
u32 delivered_ecn_bytes[3]; /* 2744 12 */
u16 pkts_acked_ewma; /* 2756 2 */
/* XXX 2 bytes hole, try to pack */
[...]
__cacheline_group_end__tcp_sock_write_rx[0]; /* 2816 0 */
[...]
/* size: 3264, cachelines: 51, members: 178 */
}
Signed-off-by: Ilpo Järvinen <ij@kernel.org>
Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
---
.../networking/net_cachelines/tcp_sock.rst | 1 +
include/linux/tcp.h | 1 +
net/ipv4/tcp.c | 2 ++
net/ipv4/tcp_input.c | 20 ++++++++++++++++++-
4 files changed, 23 insertions(+), 1 deletion(-)
diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
index 88c668f9c68b..f431ff1eb932 100644
--- a/Documentation/networking/net_cachelines/tcp_sock.rst
+++ b/Documentation/networking/net_cachelines/tcp_sock.rst
@@ -105,6 +105,7 @@ u32 received_ce read_mostly read_w
u32[3] received_ecn_bytes read_mostly read_write
u8:4 received_ce_pending read_mostly read_write
u32[3] delivered_ecn_bytes read_write
+u16 pkts_acked_ewma read_write
u8:2 syn_ect_snt write_mostly read_write
u8:2 syn_ect_rcv read_mostly read_write
u8:1 wait_third_ack read_write
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 8609fb138108..c3b9ecc3f2e2 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -345,6 +345,7 @@ struct tcp_sock {
u32 rate_interval_us; /* saved rate sample: time elapsed */
u32 rcv_rtt_last_tsecr;
u32 delivered_ecn_bytes[3];
+ u16 pkts_acked_ewma;/* Pkts acked EWMA for AccECN cep heuristic */
u64 first_tx_mstamp; /* start of window send phase */
u64 delivered_mstamp; /* time we reached "delivered" */
u64 bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index a9e30c72d71b..40fdfba1c04a 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3399,6 +3399,7 @@ int tcp_disconnect(struct sock *sk, int flags)
tcp_accecn_init_counters(tp);
tp->prev_ecnfield = 0;
tp->accecn_opt_tstamp = 0;
+ tp->pkts_acked_ewma = 0;
if (icsk->icsk_ca_initialized && icsk->icsk_ca_ops->release)
icsk->icsk_ca_ops->release(sk);
memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv));
@@ -5159,6 +5160,7 @@ static void __init tcp_struct_check(void)
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rate_interval_us);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcv_rtt_last_tsecr);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, delivered_ecn_bytes);
+ CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, pkts_acked_ewma);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, first_tx_mstamp);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, delivered_mstamp);
CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_acked);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 97b5fe52d8fd..f15ebee4a641 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -714,6 +714,10 @@ static void tcp_count_delivered(struct tcp_sock *tp, u32 delivered,
tcp_count_delivered_ce(tp, delivered);
}
+#define PKTS_ACKED_WEIGHT 6
+#define PKTS_ACKED_PREC 6
+#define ACK_COMP_THRESH 4
+
/* Returns the ECN CE delta */
static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
u32 delivered_pkts, u32 delivered_bytes,
@@ -733,6 +737,19 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
opt_deltas_valid = tcp_accecn_process_option(tp, skb,
delivered_bytes, flag);
+ if (delivered_pkts) {
+ if (!tp->pkts_acked_ewma) {
+ tp->pkts_acked_ewma = delivered_pkts << PKTS_ACKED_PREC;
+ } else {
+ u32 ewma = tp->pkts_acked_ewma;
+
+ ewma = (((ewma << PKTS_ACKED_WEIGHT) - ewma) +
+ (delivered_pkts << PKTS_ACKED_PREC)) >>
+ PKTS_ACKED_WEIGHT;
+ tp->pkts_acked_ewma = min_t(u32, ewma, 0xFFFFU);
+ }
+ }
+
if (!(flag & FLAG_SLOWPATH)) {
/* AccECN counter might overflow on large ACKs */
if (delivered_pkts <= TCP_ACCECN_CEP_ACE_MASK)
@@ -781,7 +798,8 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
if (d_ceb <
safe_delta * tp->mss_cache >> TCP_ACCECN_SAFETY_SHIFT)
return delta;
- }
+ } else if (tp->pkts_acked_ewma > (ACK_COMP_THRESH << PKTS_ACKED_PREC))
+ return delta;
return safe_delta;
}
--
2.34.1
^ permalink raw reply related [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 02/15] tcp: fast path functions later
2025-06-21 19:37 ` [PATCH v9 net-next 02/15] tcp: fast path functions later chia-yu.chang
@ 2025-06-23 14:24 ` Eric Dumazet
0 siblings, 0 replies; 29+ messages in thread
From: Eric Dumazet @ 2025-06-23 14:24 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Ilpo Järvinen <ij@kernel.org>
>
> The following patch will use tcp_ecn_mode_accecn(),
> TCP_ACCECN_CEP_INIT_OFFSET, TCP_ACCECN_CEP_ACE_MASK in
> __tcp_fast_path_on() to make new flag for AccECN.
>
> No functional changes.
>
> Signed-off-by: Ilpo Järvinen <ij@kernel.org>
> Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 03/15] tcp: reorganize tcp_sock_write_txrx group for variables later
2025-06-21 19:37 ` [PATCH v9 net-next 03/15] tcp: reorganize tcp_sock_write_txrx group for variables later chia-yu.chang
@ 2025-06-23 14:37 ` Eric Dumazet
0 siblings, 0 replies; 29+ messages in thread
From: Eric Dumazet @ 2025-06-23 14:37 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
>
> Use the first 3-byte hole at the beginning of the tcp_sock_write_txrx
> group for 'noneagle'/'rate_app_limited' to fill in the existing hole
> in later patches. Therefore, the group size of tcp_sock_write_txrx is
> reduced from 92 + 4 to 91 + 4. In addition, the group size of
> tcp_sock_write_rx is changed to 96 to fit in the pahole outcome.
> Below are the trimmed pahole outcomes before and after this patch:
Reviewed-by: Eric Dumazet <edumazet@google.com>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 04/15] tcp: AccECN core
2025-06-21 19:37 ` [PATCH v9 net-next 04/15] tcp: AccECN core chia-yu.chang
@ 2025-06-23 16:13 ` Eric Dumazet
0 siblings, 0 replies; 29+ messages in thread
From: Eric Dumazet @ 2025-06-23 16:13 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel, Olivier Tilmans
On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Ilpo Järvinen <ij@kernel.org>
>
> This change implements Accurate ECN without negotiation and
> AccECN Option (that will be added by later changes). Based on
> AccECN specifications:
> https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
>
> Accurate ECN allows feeding back the number of CE (congestion
> experienced) marks accurately to the sender in contrast to
> RFC3168 ECN that can only signal one marks-seen-yes/no per RTT.
> Congestion control algorithms can take advantage of the accurate
> ECN information to fine-tune their congestion response to avoid
> drastic rate reduction when only mild congestion is encountered.
>
> With Accurate ECN, tp->received_ce (r.cep in AccECN spec) keeps
> track of how many segments have arrived with a CE mark. Accurate
> ECN uses ACE field (ECE, CWR, AE) to communicate the value back
> to the sender which updates tp->delivered_ce (s.cep) based on the
> feedback. This signalling channel is lossy when ACE field overflow
> occurs.
>
> Conservative strategy is selected here to deal with the ACE
> overflow, however, some strategies using the AccECN option later
> in the overall patchset mitigate against false overflows detected.
>
> The ACE field values on the wire are offset by
> TCP_ACCECN_CEP_INIT_OFFSET. Delivered_ce/received_ce count the
> real CE marks rather than forcing all downstream users to adapt
> to the wire offset.
>
> This patch uses the first 1-byte hole and the last 4-byte hole of
> the tcp_sock_write_txrx for 'received_ce_pending' and 'received_ce'.
> Also, the group size of tcp_sock_write_txrx is increased from
> 91 + 4 to 95 + 4 due to the new u32 received_ce member. Below are
> the trimmed pahole outcomes before and after this patch.
>
> Signed-off-by: Ilpo Järvinen <ij@kernel.org>
> Co-developed-by: Olivier Tilmans <olivier.tilmans@nokia.com>
> Signed-off-by: Olivier Tilmans <olivier.tilmans@nokia.com>
> Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
> Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
>
> ---
> v9:
> - Use tcp_data_ecn_check() to set TCP_ECN_SEE flag only for RFC3168 ECN
> - Add comments about setting TCP_ECN_SEEN flag for RFC3168 and Accruate ECN
Reviewed-by: Eric Dumazet <edumazet@google.com>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation
2025-06-21 19:37 ` [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation chia-yu.chang
@ 2025-06-25 7:57 ` Eric Dumazet
2025-06-26 8:06 ` Chia-Yu Chang (Nokia)
0 siblings, 1 reply; 29+ messages in thread
From: Eric Dumazet @ 2025-06-25 7:57 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
jhs, kuba, stephen, xiyou.wangcong, jiri, davem, andrew+netdev,
donald.hunter, ast, liuhangbin, shuah, linux-kselftest, ij,
ncardwell, koen.de_schepper, g.white, ingemar.s.johansson,
mirja.kuehlewind, cheshire, rs.ietf, Jason_Livingood, vidhi_goel,
Olivier Tilmans
On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Ilpo Järvinen <ij@kernel.org>
>
> Accurate ECN negotiation parts based on the specification:
> https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
>
> Accurate ECN is negotiated using ECE, CWR and AE flags in the
> TCP header. TCP falls back into using RFC3168 ECN if one of the
> ends supports only RFC3168-style ECN.
>
> The AccECN negotiation includes reflecting IP ECN field value
> seen in SYN and SYNACK back using the same bits as negotiation
> to allow responding to SYN CE marks and to detect ECN field
> mangling. CE marks should not occur currently because SYN=1
> segments are sent with Non-ECT in IP ECN field (but proposal
> exists to remove this restriction).
>
> Reflecting SYN IP ECN field in SYNACK is relatively simple.
> Reflecting SYNACK IP ECN field in the final/third ACK of
> the handshake is more challenging. Linux TCP code is not well
> prepared for using the final/third ACK a signalling channel
> which makes things somewhat complicated here.
>
> tcp_ecn sysctl can be used to select the highest ECN variant
> (Accurate ECN, ECN, No ECN) that is attemped to be negotiated and
> requested for incoming connection and outgoing connection:
> TCP_ECN_IN_NOECN_OUT_NOECN, TCP_ECN_IN_ECN_OUT_ECN,
> TCP_ECN_IN_ECN_OUT_NOECN, TCP_ECN_IN_ACCECN_OUT_ACCECN,
> TCP_ECN_IN_ACCECN_OUT_ECN, and TCP_ECN_IN_ACCECN_OUT_NOECN.
>
> After this patch, the size of tcp_request_sock remains unchanged
> and no new holes are added. Below are the pahole outcomes before
> and after this patch:
>
>
> }
>
> Signed-off-by: Ilpo Järvinen <ij@kernel.org>
> Co-developed-by: Olivier Tilmans <olivier.tilmans@nokia.com>
> Signed-off-by: Olivier Tilmans <olivier.tilmans@nokia.com>
> Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
> Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
> ---
> .../networking/net_cachelines/tcp_sock.rst | 4 +
> include/linux/tcp.h | 9 +-
> include/net/tcp.h | 93 ++++++++-
> net/ipv4/syncookies.c | 3 +
> net/ipv4/sysctl_net_ipv4.c | 3 +-
> net/ipv4/tcp.c | 2 +
> net/ipv4/tcp_input.c | 178 ++++++++++++++++--
> net/ipv4/tcp_ipv4.c | 5 +-
> net/ipv4/tcp_minisocks.c | 51 ++++-
> net/ipv4/tcp_output.c | 78 ++++++--
> net/ipv6/syncookies.c | 1 +
> net/ipv6/tcp_ipv6.c | 1 +
> 12 files changed, 384 insertions(+), 44 deletions(-)
>
> diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
> index 31313a9adccc..22ac668fe6c7 100644
> --- a/Documentation/networking/net_cachelines/tcp_sock.rst
> +++ b/Documentation/networking/net_cachelines/tcp_sock.rst
> @@ -103,6 +103,10 @@ u32 delivered read_mostly read_w
> u32 delivered_ce read_mostly read_write tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
> u32 received_ce read_mostly read_write
> u8:4 received_ce_pending read_mostly read_write
> +u8:2 syn_ect_snt write_mostly read_write
> +u8:2 syn_ect_rcv read_mostly read_write
> +u8:1 wait_third_ack read_write
> +u8:4 accecn_fail_mode
> u32 lost read_mostly tcp_ack
> u32 app_limited read_write read_mostly tcp_rate_check_app_limited,tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
> u64 first_tx_mstamp read_write tcp_rate_skb_sent
> diff --git a/include/linux/tcp.h b/include/linux/tcp.h
> index 874e0e45dfad..1d8301f2883c 100644
> --- a/include/linux/tcp.h
> +++ b/include/linux/tcp.h
> @@ -168,6 +168,10 @@ struct tcp_request_sock {
> * after data-in-SYN.
> */
> u8 syn_tos;
> + bool accecn_ok;
> + u8 syn_ect_snt: 2,
> + syn_ect_rcv: 2,
> + accecn_fail_mode:4;
> #ifdef CONFIG_TCP_AO
> u8 ao_keyid;
> u8 ao_rcv_next;
> @@ -375,7 +379,9 @@ struct tcp_sock {
> u8 compressed_ack;
> u8 dup_ack_counter:2,
> tlp_retrans:1, /* TLP is a retransmission */
> - unused:5;
> + syn_ect_snt:2, /* AccECN ECT memory, only */
> + syn_ect_rcv:2, /* ... needed durign 3WHS + first seqno */
> + wait_third_ack:1; /* Wait 3rd ACK in simultaneous open */
> u8 thin_lto : 1,/* Use linear timeouts for thin streams */
> fastopen_connect:1, /* FASTOPEN_CONNECT sockopt */
> fastopen_no_cookie:1, /* Allow send/recv SYN+data without a cookie */
> @@ -391,6 +397,7 @@ struct tcp_sock {
> syn_fastopen_child:1; /* created TFO passive child socket */
>
> u8 keepalive_probes; /* num of allowed keep alive probes */
> + u8 accecn_fail_mode:4; /* AccECN failure handling */
> u32 tcp_tx_delay; /* delay (in usec) added to TX packets */
>
> /* RTT measurement */
> diff --git a/include/net/tcp.h b/include/net/tcp.h
> index 6cf5cea992e3..4d6325fa3f67 100644
> --- a/include/net/tcp.h
> +++ b/include/net/tcp.h
> @@ -27,6 +27,7 @@
> #include <linux/ktime.h>
> #include <linux/indirect_call_wrapper.h>
> #include <linux/bits.h>
> +#include <linux/bitfield.h>
>
> #include <net/inet_connection_sock.h>
> #include <net/inet_timewait_sock.h>
> @@ -234,6 +235,37 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
> #define TCPOLEN_MSS_ALIGNED 4
> #define TCPOLEN_EXP_SMC_BASE_ALIGNED 8
>
> +/* tp->accecn_fail_mode */
> +#define TCP_ACCECN_ACE_FAIL_SEND BIT(0)
> +#define TCP_ACCECN_ACE_FAIL_RECV BIT(1)
> +#define TCP_ACCECN_OPT_FAIL_SEND BIT(2)
> +#define TCP_ACCECN_OPT_FAIL_RECV BIT(3)
> +
> +static inline bool tcp_accecn_ace_fail_send(const struct tcp_sock *tp)
> +{
> + return tp->accecn_fail_mode & TCP_ACCECN_ACE_FAIL_SEND;
> +}
> +
> +static inline bool tcp_accecn_ace_fail_recv(const struct tcp_sock *tp)
> +{
> + return tp->accecn_fail_mode & TCP_ACCECN_ACE_FAIL_RECV;
> +}
> +
> +static inline bool tcp_accecn_opt_fail_send(const struct tcp_sock *tp)
> +{
> + return tp->accecn_fail_mode & TCP_ACCECN_OPT_FAIL_SEND;
> +}
> +
> +static inline bool tcp_accecn_opt_fail_recv(const struct tcp_sock *tp)
> +{
> + return tp->accecn_fail_mode & TCP_ACCECN_OPT_FAIL_RECV;
> +}
> +
> +static inline void tcp_accecn_fail_mode_set(struct tcp_sock *tp, u8 mode)
> +{
> + tp->accecn_fail_mode |= mode;
> +}
> +
> /* Flags in tp->nonagle */
> #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */
> #define TCP_NAGLE_CORK 2 /* Socket is corked */
> @@ -420,6 +452,23 @@ static inline u8 tcp_accecn_ace(const struct tcphdr *th)
> return (th->ae << 2) | (th->cwr << 1) | th->ece;
> }
>
> +/* Infer the ECT value our SYN arrived with from the echoed ACE field */
> +static inline int tcp_accecn_extract_syn_ect(u8 ace)
> +{
> + if (ace & 0x1)
> + return INET_ECN_ECT_1;
> + if (!(ace & 0x2))
> + return INET_ECN_ECT_0;
> + if (ace & 0x4)
> + return INET_ECN_CE;
> + return INET_ECN_NOT_ECT;
> +}
> +
> +bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect);
> +void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
> + u8 syn_ect_snt);
> +void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb);
> +
> enum tcp_tw_status {
> TCP_TW_SUCCESS = 0,
> TCP_TW_RST = 1,
> @@ -657,6 +706,15 @@ static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *
> dst_feature(dst, RTAX_FEATURE_ECN);
> }
>
> +/* AccECN specification, 5.1: [...] a server can determine that it
> + * negotiated AccECN as [...] if the ACK contains an ACE field with
> + * the value 0b010 to 0b111 (decimal 2 to 7).
> + */
> +static inline bool cookie_accecn_ok(const struct tcphdr *th)
> +{
> + return tcp_accecn_ace(th) > 0x1;
> +}
> +
> #if IS_ENABLED(CONFIG_BPF)
> static inline bool cookie_bpf_ok(struct sk_buff *skb)
> {
> @@ -968,6 +1026,7 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
>
> #define TCPHDR_ACE (TCPHDR_ECE | TCPHDR_CWR | TCPHDR_AE)
> #define TCPHDR_SYN_ECN (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR)
> +#define TCPHDR_SYNACK_ACCECN (TCPHDR_SYN | TCPHDR_ACK | TCPHDR_CWR)
>
> #define TCP_ACCECN_CEP_ACE_MASK 0x7
> #define TCP_ACCECN_ACE_MAX_DELTA 6
> @@ -977,6 +1036,19 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
> */
> #define TCP_ACCECN_CEP_INIT_OFFSET 5
>
> +/* The highest ECN variant (Accurate ECN, ECN, or no ECN) that is
> + * attemped to be negotiated and requested for incoming connection
> + * and outgoing connection, respectively.
> + */
> +enum tcp_ecn_mode {
> + TCP_ECN_IN_NOECN_OUT_NOECN = 0,
> + TCP_ECN_IN_ECN_OUT_ECN = 1,
> + TCP_ECN_IN_ECN_OUT_NOECN = 2,
> + TCP_ECN_IN_ACCECN_OUT_ACCECN = 3,
> + TCP_ECN_IN_ACCECN_OUT_ECN = 4,
> + TCP_ECN_IN_ACCECN_OUT_NOECN = 5,
> +};
> +
> static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
> {
> tp->received_ce = 0;
> @@ -1051,6 +1123,15 @@ struct tcp_skb_cb {
>
> #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0]))
>
> +static inline u16 tcp_accecn_reflector_flags(u8 ect)
> +{
> + u32 flags = ect + 2;
> +
> + if (ect == 3)
> + flags++;
A comment might help, I have no idea of what is going on here.
> + return FIELD_PREP(TCPHDR_ACE, flags);
> +}
> +
> extern const struct inet_connection_sock_af_ops ipv4_specific;
>
> #if IS_ENABLED(CONFIG_IPV6)
> @@ -1173,7 +1254,10 @@ enum tcp_ca_ack_event_flags {
> #define TCP_CONG_NON_RESTRICTED BIT(0)
> /* Requires ECN/ECT set on all packets */
> #define TCP_CONG_NEEDS_ECN BIT(1)
> -#define TCP_CONG_MASK (TCP_CONG_NON_RESTRICTED | TCP_CONG_NEEDS_ECN)
> +/* Require successfully negotiated AccECN capability */
> +#define TCP_CONG_NEEDS_ACCECN BIT(2)
> +#define TCP_CONG_MASK (TCP_CONG_NON_RESTRICTED | TCP_CONG_NEEDS_ECN | \
> + TCP_CONG_NEEDS_ACCECN)
>
> union tcp_cc_info;
>
> @@ -1305,6 +1389,13 @@ static inline bool tcp_ca_needs_ecn(const struct sock *sk)
> return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ECN;
> }
>
> +static inline bool tcp_ca_needs_accecn(const struct sock *sk)
> +{
> + const struct inet_connection_sock *icsk = inet_csk(sk);
> +
> + return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ACCECN;
> +}
> +
> static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
> {
> const struct inet_connection_sock *icsk = inet_csk(sk);
> diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
> index 5459a78b9809..3a44eb9c1d1a 100644
> --- a/net/ipv4/syncookies.c
> +++ b/net/ipv4/syncookies.c
> @@ -403,6 +403,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
> struct tcp_sock *tp = tcp_sk(sk);
> struct inet_request_sock *ireq;
> struct net *net = sock_net(sk);
> + struct tcp_request_sock *treq;
> struct request_sock *req;
> struct sock *ret = sk;
> struct flowi4 fl4;
> @@ -428,6 +429,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
> }
>
> ireq = inet_rsk(req);
> + treq = tcp_rsk(req);
>
> sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
> sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
> @@ -482,6 +484,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
> if (!req->syncookie)
> ireq->rcv_wscale = rcv_wscale;
> ireq->ecn_ok &= cookie_ecn_ok(net, &rt->dst);
> + treq->accecn_ok = ireq->ecn_ok && cookie_accecn_ok(th);
>
> ret = tcp_get_cookie_sock(sk, skb, req, &rt->dst);
> /* ip_queue_xmit() depends on our flow being setup
> diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
> index 3a43010d726f..75ec1a599b52 100644
> --- a/net/ipv4/sysctl_net_ipv4.c
> +++ b/net/ipv4/sysctl_net_ipv4.c
> @@ -47,6 +47,7 @@ static unsigned int udp_child_hash_entries_max = UDP_HTABLE_SIZE_MAX;
> static int tcp_plb_max_rounds = 31;
> static int tcp_plb_max_cong_thresh = 256;
> static unsigned int tcp_tw_reuse_delay_max = TCP_PAWS_MSL * MSEC_PER_SEC;
> +static int tcp_ecn_mode_max = 5;
>
> /* obsolete */
> static int sysctl_tcp_low_latency __read_mostly;
> @@ -728,7 +729,7 @@ static struct ctl_table ipv4_net_table[] = {
> .mode = 0644,
> .proc_handler = proc_dou8vec_minmax,
> .extra1 = SYSCTL_ZERO,
> - .extra2 = SYSCTL_TWO,
> + .extra2 = &tcp_ecn_mode_max,
Please change Documentation/networking/ip-sysctl.rst tcp_ecn accordingly ?
> },
> {
> .procname = "tcp_ecn_fallback",
> diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
> index 8e0e8d784b1c..e6d7b5420c88 100644
> --- a/net/ipv4/tcp.c
> +++ b/net/ipv4/tcp.c
> @@ -3392,6 +3392,8 @@ int tcp_disconnect(struct sock *sk, int flags)
> tp->window_clamp = 0;
> tp->delivered = 0;
> tp->delivered_ce = 0;
> + tp->wait_third_ack = 0;
> + tp->accecn_fail_mode = 0;
> tcp_accecn_init_counters(tp);
> if (icsk->icsk_ca_initialized && icsk->icsk_ca_ops->release)
> icsk->icsk_ca_ops->release(sk);
> diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
> index 0fa3803b353d..c986452302cb 100644
> --- a/net/ipv4/tcp_input.c
> +++ b/net/ipv4/tcp_input.c
> @@ -411,14 +411,114 @@ static void tcp_data_ecn_check(struct sock *sk, const struct sk_buff *skb)
> }
> }
I do think this patch is too big and should be split.
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters
2025-06-21 19:37 ` [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters chia-yu.chang
@ 2025-06-25 8:04 ` Eric Dumazet
2025-06-26 8:45 ` Chia-Yu Chang (Nokia)
0 siblings, 1 reply; 29+ messages in thread
From: Eric Dumazet @ 2025-06-25 8:04 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Ilpo Järvinen <ij@kernel.org>
>
> These three byte counters track IP ECN field payload byte sums for
> all arriving (acceptable) packets for ECT0, ECT1, and CE. The
> AccECN option (added by a later patch in the series) echoes these
> counters back to sender side; therefore, it is placed within the
> group of tcp_sock_write_txrx.
>
> Below are the pahole outcomes before and after this patch, in which
> the group size of tcp_sock_write_txrx is increased from 95 + 4 to
> 107 + 4 and an extra 4-byte hole is created but will be exploited
> in later patches:
>
> [BEFORE THIS PATCH]
> struct tcp_sock {
> [...]
> u32 delivered_ce; /* 2640 4 */
> u32 received_ce; /* 2644 4 */
> u32 app_limited; /* 2648 4 */
> u32 rcv_wnd; /* 2652 4 */
> struct tcp_options_received rx_opt; /* 2656 24 */
> __cacheline_group_end__tcp_sock_write_txrx[0]; /* 2680 0 */
>
> [...]
> /* size: 3264, cachelines: 51, members: 169 */
> }
>
> [AFTER THIS PATCH]
> struct tcp_sock {
> [...]
> u32 delivered_ce; /* 2640 4 */
> u32 received_ce; /* 2644 4 */
> u32 received_ecn_bytes[3];/* 2648 12 */
> u32 app_limited; /* 2660 4 */
> u32 rcv_wnd; /* 2664 4 */
> struct tcp_options_received rx_opt; /* 2668 24 */
> __cacheline_group_end__tcp_sock_write_txrx[0]; /* 2692 0 */
> /* XXX 4 bytes hole, try to pack */
>
> [...]
> /* size: 3264, cachelines: 51, members: 170 */
> }
>
> Signed-off-by: Ilpo Järvinen <ij@kernel.org>
> Signed-off-by: Neal Cardwell <ncardwell@google.com>
> Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
> Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
>
> ---
> v8:
> - Add new helper function tcp_ecn_received_counters_payload()
> ---
> .../networking/net_cachelines/tcp_sock.rst | 1 +
> include/linux/tcp.h | 4 ++++
> include/net/tcp.h | 20 +++++++++++++++++-
> net/ipv4/tcp.c | 3 ++-
> net/ipv4/tcp_input.c | 21 +++++++++++++++----
> net/ipv4/tcp_minisocks.c | 2 +-
> 6 files changed, 44 insertions(+), 7 deletions(-)
>
> diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
> index 22ac668fe6c7..804480d39132 100644
> --- a/Documentation/networking/net_cachelines/tcp_sock.rst
> +++ b/Documentation/networking/net_cachelines/tcp_sock.rst
> @@ -102,6 +102,7 @@ u32 prr_out read_mostly read_m
> u32 delivered read_mostly read_write tcp_rate_skb_sent, tcp_newly_delivered(tx);tcp_ack, tcp_rate_gen, tcp_clean_rtx_queue (rx)
> u32 delivered_ce read_mostly read_write tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
> u32 received_ce read_mostly read_write
> +u32[3] received_ecn_bytes read_mostly read_write
> u8:4 received_ce_pending read_mostly read_write
> u8:2 syn_ect_snt write_mostly read_write
> u8:2 syn_ect_rcv read_mostly read_write
> diff --git a/include/linux/tcp.h b/include/linux/tcp.h
> index 1d8301f2883c..0c2331e186e8 100644
> --- a/include/linux/tcp.h
> +++ b/include/linux/tcp.h
> @@ -306,6 +306,10 @@ struct tcp_sock {
> u32 delivered; /* Total data packets delivered incl. rexmits */
> u32 delivered_ce; /* Like the above but only ECE marked packets */
> u32 received_ce; /* Like the above but for rcvd CE marked pkts */
> + u32 received_ecn_bytes[3]; /* received byte counters for three ECN
> + * types: INET_ECN_ECT_1, INET_ECN_ECT_0,
> + * and INET_ECN_CE
> + */
> u32 app_limited; /* limited until "delivered" reaches this val */
> u32 rcv_wnd; /* Current receiver window */
> /*
> diff --git a/include/net/tcp.h b/include/net/tcp.h
> index 4d6325fa3f67..b861941a2213 100644
> --- a/include/net/tcp.h
> +++ b/include/net/tcp.h
> @@ -467,7 +467,10 @@ static inline int tcp_accecn_extract_syn_ect(u8 ace)
> bool tcp_accecn_validate_syn_feedback(struct sock *sk, u8 ace, u8 sent_ect);
> void tcp_accecn_third_ack(struct sock *sk, const struct sk_buff *skb,
> u8 syn_ect_snt);
> -void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb);
> +void tcp_ecn_received_counters_payload(struct sock *sk,
> + const struct sk_buff *skb);
> +void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
> + u32 payload_len);
>
> enum tcp_tw_status {
> TCP_TW_SUCCESS = 0,
> @@ -1035,6 +1038,20 @@ static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)
> * See draft-ietf-tcpm-accurate-ecn for the latest values.
> */
> #define TCP_ACCECN_CEP_INIT_OFFSET 5
> +#define TCP_ACCECN_E1B_INIT_OFFSET 1
> +#define TCP_ACCECN_E0B_INIT_OFFSET 1
> +#define TCP_ACCECN_CEB_INIT_OFFSET 0
> +
> +static inline void __tcp_accecn_init_bytes_counters(int *counter_array)
> +{
> + BUILD_BUG_ON(INET_ECN_ECT_1 != 0x1);
> + BUILD_BUG_ON(INET_ECN_ECT_0 != 0x2);
> + BUILD_BUG_ON(INET_ECN_CE != 0x3);
> +
> + counter_array[INET_ECN_ECT_1 - 1] = 0;
> + counter_array[INET_ECN_ECT_0 - 1] = 0;
> + counter_array[INET_ECN_CE - 1] = 0;
> +}
>
> /* The highest ECN variant (Accurate ECN, ECN, or no ECN) that is
> * attemped to be negotiated and requested for incoming connection
> @@ -1053,6 +1070,7 @@ static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
> {
> tp->received_ce = 0;
> tp->received_ce_pending = 0;
> + __tcp_accecn_init_bytes_counters(tp->received_ecn_bytes);
> }
>
> /* State flags for sacked in struct tcp_skb_cb */
> diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
> index e6d7b5420c88..0e779de3ce01 100644
> --- a/net/ipv4/tcp.c
> +++ b/net/ipv4/tcp.c
> @@ -5122,6 +5122,7 @@ static void __init tcp_struct_check(void)
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, delivered);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, delivered_ce);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, received_ce);
> + CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, received_ecn_bytes);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, app_limited);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, rcv_wnd);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_txrx, rx_opt);
> @@ -5129,7 +5130,7 @@ static void __init tcp_struct_check(void)
> /* 32bit arches with 8byte alignment on u64 fields might need padding
> * before tcp_clock_cache.
> */
> - CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 95 + 4);
> + CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_txrx, 107 + 4);
>
> /* RX read-write hotpath cache lines */
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_received);
> diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
> index c986452302cb..5c0159cc0083 100644
> --- a/net/ipv4/tcp_input.c
> +++ b/net/ipv4/tcp_input.c
> @@ -6013,8 +6013,17 @@ static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *t
> }
> }
>
> +void tcp_ecn_received_counters_payload(struct sock *sk,
> + const struct sk_buff *skb)
> +{
> + const struct tcphdr *th = (const struct tcphdr *)skb->data;
> +
> + tcp_ecn_received_counters(sk, skb, skb->len - th->doff * 4);
> +}
> +
> /* Updates Accurate ECN received counters from the received IP ECN field */
> -void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb)
> +void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
> + u32 payload_len)
> {
> u8 ecnfield = TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK;
> u8 is_ce = INET_ECN_is_ce(ecnfield);
> @@ -6034,6 +6043,9 @@ void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb)
> tp->received_ce += pcount;
> tp->received_ce_pending = min(tp->received_ce_pending + pcount,
> 0xfU);
> +
> + if (payload_len > 0)
> + tp->received_ecn_bytes[ecnfield - 1] += payload_len;
> }
> }
>
> @@ -6307,7 +6319,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> flag |= __tcp_replace_ts_recent(tp,
> delta);
>
> - tcp_ecn_received_counters(sk, skb);
> + tcp_ecn_received_counters(sk, skb, 0);
>
> /* We know that such packets are checksummed
> * on entry.
> @@ -6353,7 +6365,8 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> /* Bulk data transfer: receiver */
> tcp_cleanup_skb(skb);
> __skb_pull(skb, tcp_header_len);
> - tcp_ecn_received_counters(sk, skb);
> + tcp_ecn_received_counters(sk, skb,
> + len - tcp_header_len);
> eaten = tcp_queue_rcv(sk, skb, &fragstolen);
>
> tcp_event_data_recv(sk, skb);
> @@ -6400,7 +6413,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> tcp_accecn_third_ack(sk, skb, tp->syn_ect_snt);
> tcp_fast_path_on(tp);
> }
> - tcp_ecn_received_counters(sk, skb);
> + tcp_ecn_received_counters_payload(sk, skb);
I missed this from a prior patch, but is it expected to account bytes
even if the packet is dropped ?
>
> reason = tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT);
> if ((int)reason < 0) {
> diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
> index 779a206a5ca6..f1e698c323f3 100644
> --- a/net/ipv4/tcp_minisocks.c
> +++ b/net/ipv4/tcp_minisocks.c
> @@ -500,7 +500,7 @@ static void tcp_ecn_openreq_child(struct sock *sk,
> tcp_ecn_mode_set(tp, TCP_ECN_MODE_ACCECN);
> tp->syn_ect_snt = treq->syn_ect_snt;
> tcp_accecn_third_ack(sk, skb, treq->syn_ect_snt);
> - tcp_ecn_received_counters(sk, skb);
> + tcp_ecn_received_counters_payload(sk, skb);
> } else {
> tcp_ecn_mode_set(tp, inet_rsk(req)->ecn_ok ?
> TCP_ECN_MODE_RFC3168 :
> --
> 2.34.1
>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 08/15] tcp: sack option handling improvements
2025-06-21 19:37 ` [PATCH v9 net-next 08/15] tcp: sack option handling improvements chia-yu.chang
@ 2025-06-25 8:08 ` Eric Dumazet
0 siblings, 0 replies; 29+ messages in thread
From: Eric Dumazet @ 2025-06-25 8:08 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
On Sat, Jun 21, 2025 at 12:38 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Ilpo Järvinen <ij@kernel.org>
>
> 1) Don't early return when sack doesn't fit. AccECN code will be
> placed after this fragment so no early returns please.
>
> 2) Make sure opts->num_sack_blocks is not left undefined. E.g.,
> tcp_current_mss() does not memset its opts struct to zero.
> AccECN code checks if SACK option is present and may even
> alter it to make room for AccECN option when many SACK blocks
> are present. Thus, num_sack_blocks needs to be always valid.
>
> Signed-off-by: Ilpo Järvinen <ij@kernel.org>
> Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
2025-06-21 19:37 ` [PATCH v9 net-next 09/15] tcp: accecn: AccECN option chia-yu.chang
@ 2025-06-25 9:21 ` Eric Dumazet
2025-06-26 14:47 ` Chia-Yu Chang (Nokia)
0 siblings, 1 reply; 29+ messages in thread
From: Eric Dumazet @ 2025-06-25 9:21 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
On Sat, Jun 21, 2025 at 12:38 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Ilpo Järvinen <ij@kernel.org>
>
> The Accurate ECN allows echoing back the sum of bytes for
> each IP ECN field value in the received packets using
> AccECN option. This change implements AccECN option tx & rx
> side processing without option send control related features
> that are added by a later change.
>
> Based on specification:
> https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
> (Some features of the spec will be added in the later changes
> rather than in this one).
>
> A full-length AccECN option is always attempted but if it does
> not fit, the minimum length is selected based on the counters
> that have changed since the last update. The AccECN option
> (with 24-bit fields) often ends in odd sizes so the option
> write code tries to take advantage of some nop used to pad
> the other TCP options.
>
> The delivered_ecn_bytes pairs with received_ecn_bytes similar
> to how delivered_ce pairs with received_ce. In contrast to
> ACE field, however, the option is not always available to update
> delivered_ecn_bytes. For ACK w/o AccECN option, the delivered
> bytes calculated based on the cumulative ACK+SACK information
> are assigned to one of the counters using an estimation
> heuristic to select the most likely ECN byte counter. Any
> estimation error is corrected when the next AccECN option
> arrives. It may occur that the heuristic gets too confused
> when there are enough different byte counter deltas between
> ACKs with the AccECN option in which case the heuristic just
> gives up on updating the counters for a while.
>
> tcp_ecn_option sysctl can be used to select option sending
> mode for AccECN: TCP_ECN_OPTION_DISABLED, TCP_ECN_OPTION_MINIMUM,
> and TCP_ECN_OPTION_FULL.
>
> This patch increases the size of tcp_info struct, as there is
> no existing holes for new u32 variables. Below are the pahole
> outcomes before and after this patch:
>
> [
> Signed-off-by: Ilpo Järvinen <ij@kernel.org>
> Signed-off-by: Neal Cardwell <ncardwell@google.com>
> Co-developed-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
> Signed-off-by: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
>
> ---
> v9:
> - Restruct the code in the for loop of tcp_accecn_process_option()
> - Remove ecn_bytes and add use_synack_ecn_bytes flag in tcp_out_options
> struct to identify whether syn_ack_bytes or received_ecn_bytes is used
> - Replace leftover_bytes and leftover_size with leftover_highbyte and
> leftover_lowbyte and add comments in tcp_options_write()
>
> v8:
> - Reset leftover_size to 2 once leftover_bytes is used
> ---
> .../networking/net_cachelines/tcp_sock.rst | 3 +
> include/linux/tcp.h | 9 +-
> include/net/netns/ipv4.h | 1 +
> include/net/tcp.h | 20 +++
> include/uapi/linux/tcp.h | 7 +
> net/ipv4/sysctl_net_ipv4.c | 9 +
> net/ipv4/tcp.c | 15 +-
> net/ipv4/tcp_input.c | 166 ++++++++++++++++-
> net/ipv4/tcp_ipv4.c | 1 +
> net/ipv4/tcp_output.c | 170 +++++++++++++++++-
> 10 files changed, 388 insertions(+), 13 deletions(-)
>
> diff --git a/Documentation/networking/net_cachelines/tcp_sock.rst b/Documentation/networking/net_cachelines/tcp_sock.rst
> index 804480d39132..ed6af7d0110c 100644
> --- a/Documentation/networking/net_cachelines/tcp_sock.rst
> +++ b/Documentation/networking/net_cachelines/tcp_sock.rst
> @@ -104,9 +104,12 @@ u32 delivered_ce read_mostly read_w
> u32 received_ce read_mostly read_write
> u32[3] received_ecn_bytes read_mostly read_write
> u8:4 received_ce_pending read_mostly read_write
> +u32[3] delivered_ecn_bytes read_write
> u8:2 syn_ect_snt write_mostly read_write
> u8:2 syn_ect_rcv read_mostly read_write
> u8:1 wait_third_ack read_write
> +u8:2 accecn_minlen write_mostly read_write
> +u8:2 est_ecnfield read_write
> u8:4 accecn_fail_mode
> u32 lost read_mostly tcp_ack
> u32 app_limited read_write read_mostly tcp_rate_check_app_limited,tcp_rate_skb_sent(tx);tcp_rate_gen(rx)
> diff --git a/include/linux/tcp.h b/include/linux/tcp.h
> index 0c2331e186e8..0008b8190ea0 100644
> --- a/include/linux/tcp.h
> +++ b/include/linux/tcp.h
> @@ -122,8 +122,9 @@ struct tcp_options_received {
> smc_ok : 1, /* SMC seen on SYN packet */
> snd_wscale : 4, /* Window scaling received from sender */
> rcv_wscale : 4; /* Window scaling to send to receiver */
> - u8 saw_unknown:1, /* Received unknown option */
> - unused:7;
> + u8 accecn:6, /* AccECN index in header, 0=no options */
> + saw_unknown:1, /* Received unknown option */
> + unused:1;
> u8 num_sacks; /* Number of SACK blocks */
> u16 user_mss; /* mss requested by user in ioctl */
> u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
> @@ -293,6 +294,9 @@ struct tcp_sock {
> rate_app_limited:1; /* rate_{delivered,interval_us} limited? */
> u8 received_ce_pending:4, /* Not yet transmit cnt of received_ce */
> unused2:4;
> + u8 accecn_minlen:2,/* Minimum length of AccECN option sent */
> + est_ecnfield:2,/* ECN field for AccECN delivered estimates */
> + unused3:4;
> __be32 pred_flags;
> u64 tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */
> u64 tcp_mstamp; /* most recent packet received/sent */
> @@ -337,6 +341,7 @@ struct tcp_sock {
> u32 rate_delivered; /* saved rate sample: packets delivered */
> u32 rate_interval_us; /* saved rate sample: time elapsed */
> u32 rcv_rtt_last_tsecr;
> + u32 delivered_ecn_bytes[3];
> u64 first_tx_mstamp; /* start of window send phase */
> u64 delivered_mstamp; /* time we reached "delivered" */
> u64 bytes_acked; /* RFC4898 tcpEStatsAppHCThruOctetsAcked
> diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
> index 6373e3f17da8..4569a9ef4fb8 100644
> --- a/include/net/netns/ipv4.h
> +++ b/include/net/netns/ipv4.h
> @@ -148,6 +148,7 @@ struct netns_ipv4 {
> struct local_ports ip_local_ports;
>
> u8 sysctl_tcp_ecn;
> + u8 sysctl_tcp_ecn_option;
> u8 sysctl_tcp_ecn_fallback;
>
> u8 sysctl_ip_default_ttl;
> diff --git a/include/net/tcp.h b/include/net/tcp.h
> index b861941a2213..f7ba314eb7f9 100644
> --- a/include/net/tcp.h
> +++ b/include/net/tcp.h
> @@ -204,6 +204,8 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
> #define TCPOPT_AO 29 /* Authentication Option (RFC5925) */
> #define TCPOPT_MPTCP 30 /* Multipath TCP (RFC6824) */
> #define TCPOPT_FASTOPEN 34 /* Fast open (RFC7413) */
> +#define TCPOPT_ACCECN0 172 /* 0xAC: Accurate ECN Order 0 */
> +#define TCPOPT_ACCECN1 174 /* 0xAE: Accurate ECN Order 1 */
> #define TCPOPT_EXP 254 /* Experimental */
> /* Magic number to be after the option value for sharing TCP
> * experimental options. See draft-ietf-tcpm-experimental-options-00.txt
> @@ -221,6 +223,7 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
> #define TCPOLEN_TIMESTAMP 10
> #define TCPOLEN_MD5SIG 18
> #define TCPOLEN_FASTOPEN_BASE 2
> +#define TCPOLEN_ACCECN_BASE 2
> #define TCPOLEN_EXP_FASTOPEN_BASE 4
> #define TCPOLEN_EXP_SMC_BASE 6
>
> @@ -234,6 +237,13 @@ static_assert((1 << ATO_BITS) > TCP_DELACK_MAX);
> #define TCPOLEN_MD5SIG_ALIGNED 20
> #define TCPOLEN_MSS_ALIGNED 4
> #define TCPOLEN_EXP_SMC_BASE_ALIGNED 8
> +#define TCPOLEN_ACCECN_PERFIELD 3
> +
> +/* Maximum number of byte counters in AccECN option + size */
> +#define TCP_ACCECN_NUMFIELDS 3
> +#define TCP_ACCECN_MAXSIZE (TCPOLEN_ACCECN_BASE + \
> + TCPOLEN_ACCECN_PERFIELD * \
> + TCP_ACCECN_NUMFIELDS)
>
> /* tp->accecn_fail_mode */
> #define TCP_ACCECN_ACE_FAIL_SEND BIT(0)
> @@ -1066,11 +1076,21 @@ enum tcp_ecn_mode {
> TCP_ECN_IN_ACCECN_OUT_NOECN = 5,
> };
>
> +/* AccECN option sending when AccECN has been successfully negotiated */
> +enum tcp_ecn_option {
> + TCP_ECN_OPTION_DISABLED = 0,
> + TCP_ECN_OPTION_MINIMUM = 1,
> + TCP_ECN_OPTION_FULL = 2,
> +};
> +
> static inline void tcp_accecn_init_counters(struct tcp_sock *tp)
> {
> tp->received_ce = 0;
> tp->received_ce_pending = 0;
> __tcp_accecn_init_bytes_counters(tp->received_ecn_bytes);
> + __tcp_accecn_init_bytes_counters(tp->delivered_ecn_bytes);
> + tp->accecn_minlen = 0;
> + tp->est_ecnfield = 0;
> }
>
> /* State flags for sacked in struct tcp_skb_cb */
> diff --git a/include/uapi/linux/tcp.h b/include/uapi/linux/tcp.h
> index bdac8c42fa82..53e0e85b52be 100644
> --- a/include/uapi/linux/tcp.h
> +++ b/include/uapi/linux/tcp.h
> @@ -316,6 +316,13 @@ struct tcp_info {
> * in milliseconds, including any
> * unfinished recovery.
> */
> + __u32 tcpi_received_ce; /* # of CE marks received */
> + __u32 tcpi_delivered_e1_bytes; /* Accurate ECN byte counters */
> + __u32 tcpi_delivered_e0_bytes;
> + __u32 tcpi_delivered_ce_bytes;
> + __u32 tcpi_received_e1_bytes;
> + __u32 tcpi_received_e0_bytes;
> + __u32 tcpi_received_ce_bytes;
We need to immediately fill the 32bit hole, otherwise we won't be able
to use it in the future.
> };
>
> /* netlink attributes types for SCM_TIMESTAMPING_OPT_STATS */
> diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
> index 75ec1a599b52..1d7fd86ca7b9 100644
> --- a/net/ipv4/sysctl_net_ipv4.c
> +++ b/net/ipv4/sysctl_net_ipv4.c
> @@ -731,6 +731,15 @@ static struct ctl_table ipv4_net_table[] = {
> .extra1 = SYSCTL_ZERO,
> .extra2 = &tcp_ecn_mode_max,
> },
> + {
> + .procname = "tcp_ecn_option",
> + .data = &init_net.ipv4.sysctl_tcp_ecn_option,
> + .maxlen = sizeof(u8),
> + .mode = 0644,
> + .proc_handler = proc_dou8vec_minmax,
> + .extra1 = SYSCTL_ZERO,
> + .extra2 = SYSCTL_TWO,
Please add documentation in Documentation/networking/ip-sysctl.rst
> + },
> {
> .procname = "tcp_ecn_fallback",
> .data = &init_net.ipv4.sysctl_tcp_ecn_fallback,
> diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
> index 0e779de3ce01..1c1d4cbdda1c 100644
> --- a/net/ipv4/tcp.c
> +++ b/net/ipv4/tcp.c
> @@ -270,6 +270,7 @@
>
> #include <net/icmp.h>
> #include <net/inet_common.h>
> +#include <net/inet_ecn.h>
> #include <net/tcp.h>
> #include <net/mptcp.h>
> #include <net/proto_memory.h>
> @@ -4138,6 +4139,9 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
> {
> const struct tcp_sock *tp = tcp_sk(sk); /* iff sk_type == SOCK_STREAM */
> const struct inet_connection_sock *icsk = inet_csk(sk);
> + const u8 ect1_idx = INET_ECN_ECT_1 - 1;
> + const u8 ect0_idx = INET_ECN_ECT_0 - 1;
> + const u8 ce_idx = INET_ECN_CE - 1;
> unsigned long rate;
> u32 now;
> u64 rate64;
> @@ -4264,6 +4268,14 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
> if (tp->rto_stamp)
> info->tcpi_total_rto_time += tcp_clock_ms() - tp->rto_stamp;
>
> + info->tcpi_received_ce = tp->received_ce;
> + info->tcpi_delivered_e1_bytes = tp->delivered_ecn_bytes[ect1_idx];
> + info->tcpi_delivered_e0_bytes = tp->delivered_ecn_bytes[ect0_idx];
> + info->tcpi_delivered_ce_bytes = tp->delivered_ecn_bytes[ce_idx];
> + info->tcpi_received_e1_bytes = tp->received_ecn_bytes[ect1_idx];
> + info->tcpi_received_e0_bytes = tp->received_ecn_bytes[ect0_idx];
> + info->tcpi_received_ce_bytes = tp->received_ecn_bytes[ce_idx];
> +
> unlock_sock_fast(sk, slow);
> }
> EXPORT_SYMBOL_GPL(tcp_get_info);
> @@ -5142,12 +5154,13 @@ static void __init tcp_struct_check(void)
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rate_delivered);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rate_interval_us);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcv_rtt_last_tsecr);
> + CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, delivered_ecn_bytes);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, first_tx_mstamp);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, delivered_mstamp);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, bytes_acked);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcv_rtt_est);
> CACHELINE_ASSERT_GROUP_MEMBER(struct tcp_sock, tcp_sock_write_rx, rcvq_space);
> - CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_rx, 96);
> + CACHELINE_ASSERT_GROUP_SIZE(struct tcp_sock, tcp_sock_write_rx, 112);
> }
>
> void __init tcp_init(void)
> diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
> index a327fc14b207..66390966cc41 100644
> --- a/net/ipv4/tcp_input.c
> +++ b/net/ipv4/tcp_input.c
> @@ -70,6 +70,7 @@
> #include <linux/sysctl.h>
> #include <linux/kernel.h>
> #include <linux/prefetch.h>
> +#include <linux/bitops.h>
> #include <net/dst.h>
> #include <net/tcp.h>
> #include <net/proto_memory.h>
> @@ -530,6 +531,139 @@ static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr
> return false;
> }
>
> +/* Maps IP ECN field ECT/CE code point to AccECN option field number, given
> + * we are sending fields with Accurate ECN Order 1: ECT(1), CE, ECT(0).
> + */
> +static u8 tcp_ecnfield_to_accecn_optfield(u8 ecnfield)
> +{
> + switch (ecnfield & INET_ECN_MASK) {
> + case INET_ECN_NOT_ECT:
> + return 0; /* AccECN does not send counts of NOT_ECT */
> + case INET_ECN_ECT_1:
> + return 1;
> + case INET_ECN_CE:
> + return 2;
> + case INET_ECN_ECT_0:
> + return 3;
> + }
> + return 0;
> +}
net/ipv4/tcp_input.c has already 7273 lines....
I would suggest adding all these tcp ecn helpers in a separate include file,
and move existing ones.
> +
> +/* Maps IP ECN field ECT/CE code point to AccECN option field value offset.
> + * Some fields do not start from zero, to detect zeroing by middleboxes.
> + */
> +static u32 tcp_accecn_field_init_offset(u8 ecnfield)
> +{
> + switch (ecnfield & INET_ECN_MASK) {
> + case INET_ECN_NOT_ECT:
> + return 0; /* AccECN does not send counts of NOT_ECT */
> + case INET_ECN_ECT_1:
> + return TCP_ACCECN_E1B_INIT_OFFSET;
> + case INET_ECN_CE:
> + return TCP_ACCECN_CEB_INIT_OFFSET;
> + case INET_ECN_ECT_0:
> + return TCP_ACCECN_E0B_INIT_OFFSET;
> + }
> + return 0;
> +}
> +
> +/* Maps AccECN option field #nr to IP ECN field ECT/CE bits */
> +static unsigned int tcp_accecn_optfield_to_ecnfield(unsigned int optfield,
> + bool order)
> +{
> + u8 tmp;
> +
> + optfield = order ? 2 - optfield : optfield;
> + tmp = optfield + 2;
> +
> + return (tmp + (tmp >> 2)) & INET_ECN_MASK;
> +}
> +
> +/* Handles AccECN option ECT and CE 24-bit byte counters update into
> + * the u32 value in tcp_sock. As we're processing TCP options, it is
> + * safe to access from - 1.
> + */
> +static s32 tcp_update_ecn_bytes(u32 *cnt, const char *from, u32 init_offset)
> +{
> + u32 truncated = (get_unaligned_be32(from - 1) - init_offset) &
> + 0xFFFFFFU;
> + u32 delta = (truncated - *cnt) & 0xFFFFFFU;
> +
> + /* If delta has the highest bit set (24th bit) indicating
> + * negative, sign extend to correct an estimation using
> + * sign_extend32(delta, 24 - 1)
> + */
> + delta = sign_extend32(delta, 23);
> + *cnt += delta;
> + return (s32)delta;
> +}
> +
> +/* Returns true if the byte counters can be used */
> +static bool tcp_accecn_process_option(struct tcp_sock *tp,
> + const struct sk_buff *skb,
> + u32 delivered_bytes, int flag)
> +{
> + u8 estimate_ecnfield = tp->est_ecnfield;
> + bool ambiguous_ecn_bytes_incr = false;
> + bool first_changed = false;
> + unsigned int optlen;
> + bool order1, res;
> + unsigned int i;
> + u8 *ptr;
> +
> + if (!(flag & FLAG_SLOWPATH) || !tp->rx_opt.accecn) {
> + if (estimate_ecnfield) {
> + u8 ecnfield = estimate_ecnfield - 1;
> +
> + tp->delivered_ecn_bytes[ecnfield] += delivered_bytes;
> + return true;
> + }
> + return false;
> + }
> +
> + ptr = skb_transport_header(skb) + tp->rx_opt.accecn;
> + optlen = ptr[1] - 2;
> + WARN_ON_ONCE(ptr[0] != TCPOPT_ACCECN0 && ptr[0] != TCPOPT_ACCECN1);
> + order1 = (ptr[0] == TCPOPT_ACCECN1);
> + ptr += 2;
> +
> + res = !!estimate_ecnfield;
> + for (i = 0; i < 3; i++) {
> + u32 init_offset;
> + u8 ecnfield;
> + s32 delta;
> + u32 *cnt;
> +
> + if (optlen < TCPOLEN_ACCECN_PERFIELD)
> + break;
> +
> + ecnfield = tcp_accecn_optfield_to_ecnfield(i, order1);
> + init_offset = tcp_accecn_field_init_offset(ecnfield);
> + cnt = &tp->delivered_ecn_bytes[ecnfield - 1];
> + delta = tcp_update_ecn_bytes(cnt, ptr, init_offset);
> + if (delta && delta < 0) {
> + res = false;
> + ambiguous_ecn_bytes_incr = true;
> + }
> + if (delta && ecnfield != estimate_ecnfield) {
> + if (!first_changed) {
> + tp->est_ecnfield = ecnfield;
> + first_changed = true;
> + } else {
> + res = false;
> + ambiguous_ecn_bytes_incr = true;
> + }
> + }
> +
> + optlen -= TCPOLEN_ACCECN_PERFIELD;
> + ptr += TCPOLEN_ACCECN_PERFIELD;
> + }
> + if (ambiguous_ecn_bytes_incr)
> + tp->est_ecnfield = 0;
> +
> + return res;
> +}
> +
> static void tcp_count_delivered_ce(struct tcp_sock *tp, u32 ecn_count)
> {
> tp->delivered_ce += ecn_count;
> @@ -546,7 +680,8 @@ static void tcp_count_delivered(struct tcp_sock *tp, u32 delivered,
>
> /* Returns the ECN CE delta */
> static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
> - u32 delivered_pkts, int flag)
> + u32 delivered_pkts, u32 delivered_bytes,
> + int flag)
> {
> const struct tcphdr *th = tcp_hdr(skb);
> struct tcp_sock *tp = tcp_sk(sk);
> @@ -557,6 +692,8 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
> if (!(flag & (FLAG_FORWARD_PROGRESS | FLAG_TS_PROGRESS)))
> return 0;
>
> + tcp_accecn_process_option(tp, skb, delivered_bytes, flag);
> +
> if (!(flag & FLAG_SLOWPATH)) {
> /* AccECN counter might overflow on large ACKs */
> if (delivered_pkts <= TCP_ACCECN_CEP_ACE_MASK)
> @@ -582,12 +719,14 @@ static u32 __tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
> }
>
> static u32 tcp_accecn_process(struct sock *sk, const struct sk_buff *skb,
> - u32 delivered_pkts, int *flag)
> + u32 delivered_pkts, u32 delivered_bytes,
> + int *flag)
> {
> struct tcp_sock *tp = tcp_sk(sk);
> u32 delta;
>
> - delta = __tcp_accecn_process(sk, skb, delivered_pkts, *flag);
> + delta = __tcp_accecn_process(sk, skb, delivered_pkts,
> + delivered_bytes, *flag);
> if (delta > 0) {
> tcp_count_delivered_ce(tp, delta);
> *flag |= FLAG_ECE;
> @@ -4119,6 +4258,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
> if (tcp_ecn_mode_accecn(tp))
> ecn_count = tcp_accecn_process(sk, skb,
> tp->delivered - delivered,
> + sack_state.delivered_bytes,
> &flag);
>
> tcp_in_ack_event(sk, flag);
> @@ -4158,6 +4298,7 @@ static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
> if (tcp_ecn_mode_accecn(tp))
> ecn_count = tcp_accecn_process(sk, skb,
> tp->delivered - delivered,
> + sack_state.delivered_bytes,
> &flag);
> tcp_in_ack_event(sk, flag);
> /* If data was DSACKed, see if we can undo a cwnd reduction. */
> @@ -4285,6 +4426,7 @@ void tcp_parse_options(const struct net *net,
>
> ptr = (const unsigned char *)(th + 1);
> opt_rx->saw_tstamp = 0;
> + opt_rx->accecn = 0;
> opt_rx->saw_unknown = 0;
>
> while (length > 0) {
> @@ -4376,6 +4518,12 @@ void tcp_parse_options(const struct net *net,
> ptr, th->syn, foc, false);
> break;
>
> + case TCPOPT_ACCECN0:
> + case TCPOPT_ACCECN1:
> + /* Save offset of AccECN option in TCP header */
> + opt_rx->accecn = (ptr - 2) - (__u8 *)th;
> + break;
> +
> case TCPOPT_EXP:
> /* Fast Open option shares code 254 using a
> * 16 bits magic number.
> @@ -4436,11 +4584,14 @@ static bool tcp_fast_parse_options(const struct net *net,
> */
> if (th->doff == (sizeof(*th) / 4)) {
> tp->rx_opt.saw_tstamp = 0;
> + tp->rx_opt.accecn = 0;
> return false;
> } else if (tp->rx_opt.tstamp_ok &&
> th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
> - if (tcp_parse_aligned_timestamp(tp, th))
> + if (tcp_parse_aligned_timestamp(tp, th)) {
> + tp->rx_opt.accecn = 0;
> return true;
> + }
> }
>
> tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
> @@ -6054,8 +6205,12 @@ void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
> tp->received_ce_pending = min(tp->received_ce_pending + pcount,
> 0xfU);
>
> - if (payload_len > 0)
> + if (payload_len > 0) {
> + u8 minlen = tcp_ecnfield_to_accecn_optfield(ecnfield);
> tp->received_ecn_bytes[ecnfield - 1] += payload_len;
> + tp->accecn_minlen = max_t(u8, tp->accecn_minlen,
> + minlen);
> + }
> }
> }
>
> @@ -6275,6 +6430,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> */
>
> tp->rx_opt.saw_tstamp = 0;
> + tp->rx_opt.accecn = 0;
>
> /* pred_flags is 0xS?10 << 16 + snd_wnd
> * if header_prediction is to be made
> diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
> index c5b93802d7c0..387cf8994202 100644
> --- a/net/ipv4/tcp_ipv4.c
> +++ b/net/ipv4/tcp_ipv4.c
> @@ -3450,6 +3450,7 @@ static void __net_init tcp_set_hashinfo(struct net *net)
> static int __net_init tcp_sk_init(struct net *net)
> {
> net->ipv4.sysctl_tcp_ecn = TCP_ECN_IN_ECN_OUT_NOECN;
> + net->ipv4.sysctl_tcp_ecn_option = TCP_ECN_OPTION_FULL;
> net->ipv4.sysctl_tcp_ecn_fallback = 1;
>
> net->ipv4.sysctl_tcp_base_mss = TCP_BASE_MSS;
> diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
> index 37c981aa9bc6..ca36f5d775f7 100644
> --- a/net/ipv4/tcp_output.c
> +++ b/net/ipv4/tcp_output.c
> @@ -492,6 +492,7 @@ static inline bool tcp_urg_mode(const struct tcp_sock *tp)
> #define OPTION_SMC BIT(9)
> #define OPTION_MPTCP BIT(10)
> #define OPTION_AO BIT(11)
> +#define OPTION_ACCECN BIT(12)
>
> static void smc_options_write(__be32 *ptr, u16 *options)
> {
> @@ -513,6 +514,8 @@ struct tcp_out_options {
> u16 mss; /* 0 to disable */
> u8 ws; /* window scale, 0 to disable */
> u8 num_sack_blocks; /* number of SACK blocks to include */
> + u8 num_accecn_fields:7, /* number of AccECN fields needed */
> + use_synack_ecn_bytes:1; /* Use synack_ecn_bytes or not */
> u8 hash_size; /* bytes in hash_location */
> u8 bpf_opt_len; /* length of BPF hdr option */
> __u8 *hash_location; /* temporary pointer, overloaded */
> @@ -521,6 +524,11 @@ struct tcp_out_options {
> struct mptcp_out_options mptcp;
> };
>
> +/* Initial values for AccECN option, ordered is based on ECN field bits
> + * similar to received_ecn_bytes. Used for SYN/ACK AccECN option.
> + */
> +static u32 synack_ecn_bytes[3] = { 0, 0, 0 };
Are you trying to use a global variable, shared by all cpus in the host ?
Please do not do that, we had CONFIG_SMP=y for a while.
> +
> static void mptcp_options_write(struct tcphdr *th, __be32 *ptr,
> struct tcp_sock *tp,
> struct tcp_out_options *opts)
> @@ -728,6 +736,8 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
> struct tcp_out_options *opts,
> struct tcp_key *key)
> {
> + u8 leftover_highbyte = TCPOPT_NOP; /* replace 1st NOP if avail */
> + u8 leftover_lowbyte = TCPOPT_NOP; /* replace 2nd NOP in succession */
> __be32 *ptr = (__be32 *)(th + 1);
> u16 options = opts->options; /* mungable copy */
>
> @@ -763,15 +773,75 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
> *ptr++ = htonl(opts->tsecr);
> }
>
> + if (OPTION_ACCECN & options) {
> + const u8 ect0_idx = INET_ECN_ECT_0 - 1;
> + const u8 ect1_idx = INET_ECN_ECT_1 - 1;
> + const u8 ce_idx = INET_ECN_CE - 1;
> + u32 e0b;
> + u32 e1b;
> + u32 ceb;
> + u8 len;
> +
> + if (opts->use_synack_ecn_bytes) {
> + e0b = synack_ecn_bytes[ect0_idx] + TCP_ACCECN_E0B_INIT_OFFSET;
> + e1b = synack_ecn_bytes[ect1_idx] + TCP_ACCECN_E1B_INIT_OFFSET;
> + ceb = synack_ecn_bytes[ce_idx] + TCP_ACCECN_CEB_INIT_OFFSET;
> + } else {
> + e0b = tp->received_ecn_bytes[ect0_idx] + TCP_ACCECN_E0B_INIT_OFFSET;
> + e1b = tp->received_ecn_bytes[ect1_idx] + TCP_ACCECN_E1B_INIT_OFFSET;
> + ceb = tp->received_ecn_bytes[ce_idx] + TCP_ACCECN_CEB_INIT_OFFSET;
> + }
> +
> + len = TCPOLEN_ACCECN_BASE +
> + opts->num_accecn_fields * TCPOLEN_ACCECN_PERFIELD;
> +
> + if (opts->num_accecn_fields == 2) {
> + *ptr++ = htonl((TCPOPT_ACCECN1 << 24) | (len << 16) |
> + ((e1b >> 8) & 0xffff));
> + *ptr++ = htonl(((e1b & 0xff) << 24) |
> + (ceb & 0xffffff));
> + } else if (opts->num_accecn_fields == 1) {
> + *ptr++ = htonl((TCPOPT_ACCECN1 << 24) | (len << 16) |
> + ((e1b >> 8) & 0xffff));
> + leftover_highbyte = e1b & 0xff;
> + leftover_lowbyte = TCPOPT_NOP;
> + } else if (opts->num_accecn_fields == 0) {
> + leftover_highbyte = TCPOPT_ACCECN1;
> + leftover_lowbyte = len;
> + } else if (opts->num_accecn_fields == 3) {
> + *ptr++ = htonl((TCPOPT_ACCECN1 << 24) | (len << 16) |
> + ((e1b >> 8) & 0xffff));
> + *ptr++ = htonl(((e1b & 0xff) << 24) |
> + (ceb & 0xffffff));
> + *ptr++ = htonl(((e0b & 0xffffff) << 8) |
> + TCPOPT_NOP);
> + }
> + if (tp)
> + tp->accecn_minlen = 0;
> + }
> +
> if (unlikely(OPTION_SACK_ADVERTISE & options)) {
> - *ptr++ = htonl((TCPOPT_NOP << 24) |
> - (TCPOPT_NOP << 16) |
> + *ptr++ = htonl((leftover_highbyte << 24) |
> + (leftover_lowbyte << 16) |
> (TCPOPT_SACK_PERM << 8) |
> TCPOLEN_SACK_PERM);
> + leftover_highbyte = TCPOPT_NOP;
> + leftover_lowbyte = TCPOPT_NOP;
> }
>
> if (unlikely(OPTION_WSCALE & options)) {
> - *ptr++ = htonl((TCPOPT_NOP << 24) |
> + u8 highbyte = TCPOPT_NOP;
> +
> + /* Do not split the leftover 2-byte to fit into a single
> + * NOP, i.e., replace this NOP only when 1 byte is leftover
> + * within leftover_highbyte.
> + */
> + if (unlikely(leftover_highbyte != TCPOPT_NOP &&
> + leftover_lowbyte == TCPOPT_NOP)) {
> + highbyte = leftover_highbyte;
> + leftover_highbyte = TCPOPT_NOP;
> + }
> + *ptr++ = htonl((highbyte << 24) |
> (TCPOPT_WINDOW << 16) |
> (TCPOLEN_WINDOW << 8) |
> opts->ws);
> @@ -782,11 +852,13 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
> tp->duplicate_sack : tp->selective_acks;
> int this_sack;
>
> - *ptr++ = htonl((TCPOPT_NOP << 24) |
> - (TCPOPT_NOP << 16) |
> + *ptr++ = htonl((leftover_highbyte << 24) |
> + (leftover_lowbyte << 16) |
> (TCPOPT_SACK << 8) |
> (TCPOLEN_SACK_BASE + (opts->num_sack_blocks *
> TCPOLEN_SACK_PERBLOCK)));
> + leftover_highbyte = TCPOPT_NOP;
> + leftover_lowbyte = TCPOPT_NOP;
>
> for (this_sack = 0; this_sack < opts->num_sack_blocks;
> ++this_sack) {
> @@ -795,6 +867,14 @@ static void tcp_options_write(struct tcphdr *th, struct tcp_sock *tp,
> }
>
> tp->rx_opt.dsack = 0;
> + } else if (unlikely(leftover_highbyte != TCPOPT_NOP ||
> + leftover_lowbyte != TCPOPT_NOP)) {
> + *ptr++ = htonl((leftover_highbyte << 24) |
> + (leftover_lowbyte << 16) |
> + (TCPOPT_NOP << 8) |
> + TCPOPT_NOP);
> + leftover_highbyte = TCPOPT_NOP;
> + leftover_lowbyte = TCPOPT_NOP;
> }
>
> if (unlikely(OPTION_FAST_OPEN_COOKIE & options)) {
> @@ -875,6 +955,55 @@ static void mptcp_set_option_cond(const struct request_sock *req,
> }
> }
>
> +static u32 tcp_synack_options_combine_saving(struct tcp_out_options *opts)
> +{
> + /* How much there's room for combining with the alignment padding? */
> + if ((opts->options & (OPTION_SACK_ADVERTISE | OPTION_TS)) ==
> + OPTION_SACK_ADVERTISE)
> + return 2;
> + else if (opts->options & OPTION_WSCALE)
> + return 1;
> + return 0;
> +}
> +
> +/* Calculates how long AccECN option will fit to @remaining option space.
> + *
> + * AccECN option can sometimes replace NOPs used for alignment of other
> + * TCP options (up to @max_combine_saving available).
> + *
> + * Only solutions with at least @required AccECN fields are accepted.
> + *
> + * Returns: The size of the AccECN option excluding space repurposed from
> + * the alignment of the other options.
> + */
> +static int tcp_options_fit_accecn(struct tcp_out_options *opts, int required,
> + int remaining, int max_combine_saving)
> +{
> + int size = TCP_ACCECN_MAXSIZE;
> +
> + opts->num_accecn_fields = TCP_ACCECN_NUMFIELDS;
> +
> + while (opts->num_accecn_fields >= required) {
> + int leftover_size = size & 0x3;
> + /* Pad to dword if cannot combine */
> + if (leftover_size > max_combine_saving)
> + leftover_size = -((4 - leftover_size) & 0x3);
> +
> + if (remaining >= size - leftover_size) {
> + size -= leftover_size;
> + break;
> + }
> +
> + opts->num_accecn_fields--;
> + size -= TCPOLEN_ACCECN_PERFIELD;
> + }
> + if (opts->num_accecn_fields < required)
> + return 0;
> +
> + opts->options |= OPTION_ACCECN;
> + return size;
> +}
> +
> /* Compute TCP options for SYN packets. This is not the final
> * network wire format yet.
> */
> @@ -957,6 +1086,17 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
> }
> }
>
> + /* Simultaneous open SYN/ACK needs AccECN option but not SYN */
> + if (unlikely((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK) &&
> + tcp_ecn_mode_accecn(tp) &&
> + sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
Please add READ_ONCE() over every reads of sysctl (for all your patches)
> + remaining >= TCPOLEN_ACCECN_BASE)) {
> + u32 saving = tcp_synack_options_combine_saving(opts);
> +
> + opts->use_synack_ecn_bytes = 1;
> + remaining -= tcp_options_fit_accecn(opts, 0, remaining, saving);
> + }
> +
> bpf_skops_hdr_opt_len(sk, skb, NULL, NULL, 0, opts, &remaining);
>
> return MAX_TCP_OPTION_SPACE - remaining;
> @@ -974,6 +1114,7 @@ static unsigned int tcp_synack_options(const struct sock *sk,
> {
> struct inet_request_sock *ireq = inet_rsk(req);
> unsigned int remaining = MAX_TCP_OPTION_SPACE;
> + struct tcp_request_sock *treq = tcp_rsk(req);
>
> if (tcp_key_is_md5(key)) {
> opts->options |= OPTION_MD5;
> @@ -1036,6 +1177,14 @@ static unsigned int tcp_synack_options(const struct sock *sk,
>
> smc_set_option_cond(tcp_sk(sk), ireq, opts, &remaining);
>
> + if (treq->accecn_ok && sock_net(sk)->ipv4.sysctl_tcp_ecn_option &&
> + remaining >= TCPOLEN_ACCECN_BASE) {
> + u32 saving = tcp_synack_options_combine_saving(opts);
> +
> + opts->use_synack_ecn_bytes = 1;
> + remaining -= tcp_options_fit_accecn(opts, 0, remaining, saving);
> + }
> +
> bpf_skops_hdr_opt_len((struct sock *)sk, skb, req, syn_skb,
> synack_type, opts, &remaining);
>
> @@ -1108,6 +1257,17 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb
> opts->num_sack_blocks = 0;
> }
>
> + if (tcp_ecn_mode_accecn(tp) &&
> + sock_net(sk)->ipv4.sysctl_tcp_ecn_option) {
> + int saving = opts->num_sack_blocks > 0 ? 2 : 0;
> + int remaining = MAX_TCP_OPTION_SPACE - size;
> +
> + opts->use_synack_ecn_bytes = 0;
> + size += tcp_options_fit_accecn(opts, tp->accecn_minlen,
> + remaining,
> + saving);
> + }
> +
> if (unlikely(BPF_SOCK_OPS_TEST_FLAG(tp,
> BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG))) {
> unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
> --
> 2.34.1
>
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 14/15] tcp: accecn: try to fit AccECN option with SACK
2025-06-21 19:37 ` [PATCH v9 net-next 14/15] tcp: accecn: try to fit AccECN option with SACK chia-yu.chang
@ 2025-06-25 9:33 ` Eric Dumazet
0 siblings, 0 replies; 29+ messages in thread
From: Eric Dumazet @ 2025-06-25 9:33 UTC (permalink / raw)
To: chia-yu.chang
Cc: pabeni, linux-doc, corbet, horms, dsahern, kuniyu, bpf, netdev,
dave.taht, jhs, kuba, stephen, xiyou.wangcong, jiri, davem,
andrew+netdev, donald.hunter, ast, liuhangbin, shuah,
linux-kselftest, ij, ncardwell, koen.de_schepper, g.white,
ingemar.s.johansson, mirja.kuehlewind, cheshire, rs.ietf,
Jason_Livingood, vidhi_goel
On Sat, Jun 21, 2025 at 12:38 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
>
> From: Chia-Yu Chang <chia-yu.chang@nokia-bell-labs.com>
>
> As SACK blocks tend to eat all option space when there are
> many holes, it is useful to compromise on sending many SACK
> blocks in every ACK and attempt to fit the AccECN option
> there by reducing the number of SACK blocks. However, it will
> never go below two SACK blocks because of the AccECN option.
>
> As the AccECN option is often not put to every ACK, the space
> hijack is usually only temporary. Depending on the length of
> AccECN option (can be either 11, 8, 5, or 2 bytes, cf. Table
> 5 in AccECN spec) and the NOPs used for alignment of other
> TCP options, up to two SACK blocks will be reduced.
I think it would be nice to study how AccECN and SACK compression play
together ?
^ permalink raw reply [flat|nested] 29+ messages in thread
* RE: [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation
2025-06-25 7:57 ` Eric Dumazet
@ 2025-06-26 8:06 ` Chia-Yu Chang (Nokia)
0 siblings, 0 replies; 29+ messages in thread
From: Chia-Yu Chang (Nokia) @ 2025-06-26 8:06 UTC (permalink / raw)
To: Eric Dumazet
Cc: pabeni@redhat.com, linux-doc@vger.kernel.org, corbet@lwn.net,
horms@kernel.org, dsahern@kernel.org, kuniyu@amazon.com,
bpf@vger.kernel.org, netdev@vger.kernel.org, jhs@mojatatu.com,
kuba@kernel.org, stephen@networkplumber.org,
xiyou.wangcong@gmail.com, jiri@resnulli.us, davem@davemloft.net,
andrew+netdev@lunn.ch, donald.hunter@gmail.com, ast@fiberby.net,
liuhangbin@gmail.com, shuah@kernel.org,
linux-kselftest@vger.kernel.org, ij@kernel.org,
ncardwell@google.com, Koen De Schepper (Nokia),
g.white@cablelabs.com, ingemar.s.johansson@ericsson.com,
mirja.kuehlewind@ericsson.com, cheshire@apple.com, rs.ietf@gmx.at,
Jason_Livingood@comcast.com, vidhi_goel@apple.com,
Olivier Tilmans (Nokia)
> -----Original Message-----
> From: Eric Dumazet <edumazet@google.com>
> Sent: Wednesday, June 25, 2025 9:58 AM
> To: Chia-Yu Chang (Nokia) <chia-yu.chang@nokia-bell-labs.com>
> Cc: pabeni@redhat.com; linux-doc@vger.kernel.org; corbet@lwn.net; horms@kernel.org; dsahern@kernel.org; kuniyu@amazon.com; bpf@vger.kernel.org; netdev@vger.kernel.org; jhs@mojatatu.com; kuba@kernel.org; stephen@networkplumber.org; xiyou.wangcong@gmail.com; jiri@resnulli.us; davem@davemloft.net; andrew+netdev@lunn.ch; donald.hunter@gmail.com; ast@fiberby.net; liuhangbin@gmail.com; shuah@kernel.org; linux-kselftest@vger.kernel.org; ij@kernel.org; ncardwell@google.com; Koen De Schepper (Nokia) <koen.de_schepper@nokia-bell-labs.com>; g.white@cablelabs.com; ingemar.s.johansson@ericsson.com; mirja.kuehlewind@ericsson.com; cheshire@apple.com; rs.ietf@gmx.at; Jason_Livingood@comcast.com; vidhi_goel@apple.com; Olivier Tilmans (Nokia) <olivier.tilmans@nokia.com>
> Subject: Re: [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation
>
>
> CAUTION: This is an external email. Please be very careful when clicking links or opening attachments. See the URL nok.it/ext for additional information.
>
>
>
> On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
> >
> > From: Ilpo Järvinen <ij@kernel.org>
> >
> > Accurate ECN negotiation parts based on the specification:
> > https://tools.ietf.org/id/draft-ietf-tcpm-accurate-ecn-28.txt
> >
[...]
> >
> > diff --git a/include/net/tcp.h b/include/net/tcp.h index
> > 6cf5cea992e3..4d6325fa3f67 100644
> > --- a/include/net/tcp.h
> > +++ b/include/net/tcp.h
[...]
> > @@ -1051,6 +1123,15 @@ struct tcp_skb_cb {
> >
> > #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0]))
> >
> > +static inline u16 tcp_accecn_reflector_flags(u8 ect)
> > +{
> > + u32 flags = ect + 2;
> > +
> > + if (ect == 3)
> > + flags++;
>
> A comment might help, I have no idea of what is going on here.
Hi Eric,
Sure, comments will be added in the next version.
>
> > + return FIELD_PREP(TCPHDR_ACE, flags);
> > +}
> > +
> > extern const struct inet_connection_sock_af_ops ipv4_specific;
> >
> > #if IS_ENABLED(CONFIG_IPV6)
[...]
> > diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
> > index 3a43010d726f..75ec1a599b52 100644
> > --- a/net/ipv4/sysctl_net_ipv4.c
> > +++ b/net/ipv4/sysctl_net_ipv4.c
> > @@ -47,6 +47,7 @@ static unsigned int udp_child_hash_entries_max = UDP_HTABLE_SIZE_MAX;
> > static int tcp_plb_max_rounds = 31;
> > static int tcp_plb_max_cong_thresh = 256;
> > static unsigned int tcp_tw_reuse_delay_max = TCP_PAWS_MSL * MSEC_PER_SEC;
> > +static int tcp_ecn_mode_max = 5;
> >
> > /* obsolete */
> > static int sysctl_tcp_low_latency __read_mostly;
> > @@ -728,7 +729,7 @@ static struct ctl_table ipv4_net_table[] = {
> > .mode = 0644,
> > .proc_handler = proc_dou8vec_minmax,
> > .extra1 = SYSCTL_ZERO,
> > - .extra2 = SYSCTL_TWO,
> > + .extra2 = &tcp_ecn_mode_max,
>
> Please change Documentation/networking/ip-sysctl.rst tcp_ecn accordingly ?
>
OK, I will break the patch of Documentation/networking/ip-sysctl.rst in this patch.
> > },
> > {
> > .procname = "tcp_ecn_fallback",
> > diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
> > index 8e0e8d784b1c..e6d7b5420c88 100644
> > --- a/net/ipv4/tcp.c
> > +++ b/net/ipv4/tcp.c
> > @@ -3392,6 +3392,8 @@ int tcp_disconnect(struct sock *sk, int flags)
> > tp->window_clamp = 0;
> > tp->delivered = 0;
> > tp->delivered_ce = 0;
> > + tp->wait_third_ack = 0;
> > + tp->accecn_fail_mode = 0;
> > tcp_accecn_init_counters(tp);
> > if (icsk->icsk_ca_initialized && icsk->icsk_ca_ops->release)
> > icsk->icsk_ca_ops->release(sk);
> > diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
> > index 0fa3803b353d..c986452302cb 100644
> > --- a/net/ipv4/tcp_input.c
> > +++ b/net/ipv4/tcp_input.c
> > @@ -411,14 +411,114 @@ static void tcp_data_ecn_check(struct sock *sk, const struct sk_buff *skb)
> > }
> > }
>
> I do think this patch is too big and should be split.
I will remove the following two parts from this patch into other patches:
(1) ECN negotiation in simultaneous connect, and
(2) CA module flag (TCP_CONG_NEEDS_ACCECN) defines that the CA expects to negotiate AccECN functionality.
Best regards,
Chia-Yu
^ permalink raw reply [flat|nested] 29+ messages in thread
* RE: [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters
2025-06-25 8:04 ` Eric Dumazet
@ 2025-06-26 8:45 ` Chia-Yu Chang (Nokia)
0 siblings, 0 replies; 29+ messages in thread
From: Chia-Yu Chang (Nokia) @ 2025-06-26 8:45 UTC (permalink / raw)
To: Eric Dumazet
Cc: pabeni@redhat.com, linux-doc@vger.kernel.org, corbet@lwn.net,
horms@kernel.org, dsahern@kernel.org, kuniyu@amazon.com,
bpf@vger.kernel.org, netdev@vger.kernel.org, dave.taht@gmail.com,
jhs@mojatatu.com, kuba@kernel.org, stephen@networkplumber.org,
xiyou.wangcong@gmail.com, jiri@resnulli.us, davem@davemloft.net,
andrew+netdev@lunn.ch, donald.hunter@gmail.com, ast@fiberby.net,
liuhangbin@gmail.com, shuah@kernel.org,
linux-kselftest@vger.kernel.org, ij@kernel.org,
ncardwell@google.com, Koen De Schepper (Nokia),
g.white@cablelabs.com, ingemar.s.johansson@ericsson.com,
mirja.kuehlewind@ericsson.com, cheshire@apple.com, rs.ietf@gmx.at,
Jason_Livingood@comcast.com, vidhi_goel@apple.com
> -----Original Message-----
> From: Eric Dumazet <edumazet@google.com>
> Sent: Wednesday, June 25, 2025 10:05 AM
> To: Chia-Yu Chang (Nokia) <chia-yu.chang@nokia-bell-labs.com>
> Cc: pabeni@redhat.com; linux-doc@vger.kernel.org; corbet@lwn.net; horms@kernel.org; dsahern@kernel.org; kuniyu@amazon.com; bpf@vger.kernel.org; netdev@vger.kernel.org; dave.taht@gmail.com; jhs@mojatatu.com; kuba@kernel.org; stephen@networkplumber.org; xiyou.wangcong@gmail.com; jiri@resnulli.us; davem@davemloft.net; andrew+netdev@lunn.ch; donald.hunter@gmail.com; ast@fiberby.net; liuhangbin@gmail.com; shuah@kernel.org; linux-kselftest@vger.kernel.org; ij@kernel.org; ncardwell@google.com; Koen De Schepper (Nokia) <koen.de_schepper@nokia-bell-labs.com>; g.white@cablelabs.com; ingemar.s.johansson@ericsson.com; mirja.kuehlewind@ericsson.com; cheshire@apple.com; rs.ietf@gmx.at; Jason_Livingood@comcast.com; vidhi_goel@apple.com
> Subject: Re: [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters
>
>
> CAUTION: This is an external email. Please be very careful when clicking links or opening attachments. See the URL nok.it/ext for additional information.
>
>
>
> On Sat, Jun 21, 2025 at 12:37 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
> >
> > From: Ilpo Järvinen <ij@kernel.org>
> >
[...]
> > --- a/net/ipv4/tcp_input.c
> > +++ b/net/ipv4/tcp_input.c
> > @@ -6013,8 +6013,17 @@ static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *t
> > }
> > }
> >
> > +void tcp_ecn_received_counters_payload(struct sock *sk,
> > + const struct sk_buff *skb) {
> > + const struct tcphdr *th = (const struct tcphdr *)skb->data;
> > +
> > + tcp_ecn_received_counters(sk, skb, skb->len - th->doff * 4); }
> > +
> > /* Updates Accurate ECN received counters from the received IP ECN
> > field */ -void tcp_ecn_received_counters(struct sock *sk, const struct
> > sk_buff *skb)
> > +void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb,
> > + u32 payload_len)
> > {
> > u8 ecnfield = TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK;
> > u8 is_ce = INET_ECN_is_ce(ecnfield); @@ -6034,6 +6043,9 @@
> > void tcp_ecn_received_counters(struct sock *sk, const struct sk_buff *skb)
> > tp->received_ce += pcount;
> > tp->received_ce_pending = min(tp->received_ce_pending + pcount,
> > 0xfU);
> > +
> > + if (payload_len > 0)
> > + tp->received_ecn_bytes[ecnfield - 1] +=
> > + payload_len;
> > }
> > }
> >
> > @@ -6307,7 +6319,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> > flag |= __tcp_replace_ts_recent(tp,
> >
> > delta);
> >
> > - tcp_ecn_received_counters(sk, skb);
> > + tcp_ecn_received_counters(sk, skb, 0);
> >
> > /* We know that such packets are checksummed
> > * on entry.
> > @@ -6353,7 +6365,8 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> > /* Bulk data transfer: receiver */
> > tcp_cleanup_skb(skb);
> > __skb_pull(skb, tcp_header_len);
> > - tcp_ecn_received_counters(sk, skb);
> > + tcp_ecn_received_counters(sk, skb,
> > + len -
> > + tcp_header_len);
> > eaten = tcp_queue_rcv(sk, skb, &fragstolen);
> >
> > tcp_event_data_recv(sk, skb); @@ -6400,7
> > +6413,7 @@ void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
> > tcp_accecn_third_ack(sk, skb, tp->syn_ect_snt);
> > tcp_fast_path_on(tp);
> > }
> > - tcp_ecn_received_counters(sk, skb);
> > + tcp_ecn_received_counters_payload(sk, skb);
>
> I missed this from a prior patch, but is it expected to account bytes even if the packet is dropped ?
>
Hi Eric,
What I know is that packets will be acoounted after validation.
So, if one packet is discarded due to tcp_validate_incoming(), it will NOT be counted in the AccECN counters.
Best regards,
Chia-Yu
^ permalink raw reply [flat|nested] 29+ messages in thread
* RE: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
2025-06-25 9:21 ` Eric Dumazet
@ 2025-06-26 14:47 ` Chia-Yu Chang (Nokia)
2025-06-30 18:05 ` Chia-Yu Chang (Nokia)
0 siblings, 1 reply; 29+ messages in thread
From: Chia-Yu Chang (Nokia) @ 2025-06-26 14:47 UTC (permalink / raw)
To: Eric Dumazet
Cc: pabeni@redhat.com, linux-doc@vger.kernel.org, corbet@lwn.net,
horms@kernel.org, dsahern@kernel.org, kuniyu@amazon.com,
bpf@vger.kernel.org, netdev@vger.kernel.org, dave.taht@gmail.com,
jhs@mojatatu.com, kuba@kernel.org, stephen@networkplumber.org,
xiyou.wangcong@gmail.com, jiri@resnulli.us, davem@davemloft.net,
andrew+netdev@lunn.ch, donald.hunter@gmail.com, ast@fiberby.net,
liuhangbin@gmail.com, shuah@kernel.org,
linux-kselftest@vger.kernel.org, ij@kernel.org,
ncardwell@google.com, Koen De Schepper (Nokia),
g.white@cablelabs.com, ingemar.s.johansson@ericsson.com,
mirja.kuehlewind@ericsson.com, cheshire@apple.com, rs.ietf@gmx.at,
Jason_Livingood@comcast.com, vidhi_goel@apple.com
> -----Original Message-----
> From: Eric Dumazet <edumazet@google.com>
> Sent: Wednesday, June 25, 2025 11:21 AM
> To: Chia-Yu Chang (Nokia) <chia-yu.chang@nokia-bell-labs.com>
> Cc: pabeni@redhat.com; linux-doc@vger.kernel.org; corbet@lwn.net; horms@kernel.org; dsahern@kernel.org; kuniyu@amazon.com; bpf@vger.kernel.org; netdev@vger.kernel.org; dave.taht@gmail.com; jhs@mojatatu.com; kuba@kernel.org; stephen@networkplumber.org; xiyou.wangcong@gmail.com; jiri@resnulli.us; davem@davemloft.net; andrew+netdev@lunn.ch; donald.hunter@gmail.com; ast@fiberby.net; liuhangbin@gmail.com; shuah@kernel.org; linux-kselftest@vger.kernel.org; ij@kernel.org; ncardwell@google.com; Koen De Schepper (Nokia) <koen.de_schepper@nokia-bell-labs.com>; g.white@cablelabs.com; ingemar.s.johansson@ericsson.com; mirja.kuehlewind@ericsson.com; cheshire@apple.com; rs.ietf@gmx.at; Jason_Livingood@comcast.com; vidhi_goel@apple.com
> Subject: Re: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
>
>
> CAUTION: This is an external email. Please be very careful when clicking links or opening attachments. See the URL nok.it/ext for additional information.
>
>
>
> On Sat, Jun 21, 2025 at 12:38 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
> >
> > From: Ilpo Järvinen <ij@kernel.org>
> >
[...]
> > --- a/include/uapi/linux/tcp.h
> > +++ b/include/uapi/linux/tcp.h
> > @@ -316,6 +316,13 @@ struct tcp_info {
> > * in milliseconds, including any
> > * unfinished recovery.
> > */
> > + __u32 tcpi_received_ce; /* # of CE marks received */
> > + __u32 tcpi_delivered_e1_bytes; /* Accurate ECN byte counters */
> > + __u32 tcpi_delivered_e0_bytes;
> > + __u32 tcpi_delivered_ce_bytes;
> > + __u32 tcpi_received_e1_bytes;
> > + __u32 tcpi_received_e0_bytes;
> > + __u32 tcpi_received_ce_bytes;
>
> We need to immediately fill the 32bit hole, otherwise we won't be able to use it in the future.
Hi Eric,
I did not see any holes created after adding these __u32 values, and you can see the pahole result of tcp_info below:
And the pahole result is the same either I compile with ARM32 or 64-bit architecture.
Or you mean we need an extra "__u32 unused;" at the end?
struct tcp_info {
__u8 tcpi_state; /* 0 1 */
__u8 tcpi_ca_state; /* 1 1 */
__u8 tcpi_retransmits; /* 2 1 */
__u8 tcpi_probes; /* 3 1 */
__u8 tcpi_backoff; /* 4 1 */
__u8 tcpi_options; /* 5 1 */
__u8 tcpi_snd_wscale:4; /* 6: 0 1 */
__u8 tcpi_rcv_wscale:4; /* 6: 4 1 */
__u8 tcpi_delivery_rate_app_limited:1; /* 7: 0 1 */
__u8 tcpi_fastopen_client_fail:2; /* 7: 1 1 */
/* XXX 5 bits hole, try to pack */
__u32 tcpi_rto; /* 8 4 */
__u32 tcpi_ato; /* 12 4 */
__u32 tcpi_snd_mss; /* 16 4 */
__u32 tcpi_rcv_mss; /* 20 4 */
__u32 tcpi_unacked; /* 24 4 */
__u32 tcpi_sacked; /* 28 4 */
__u32 tcpi_lost; /* 32 4 */
__u32 tcpi_retrans; /* 36 4 */
__u32 tcpi_fackets; /* 40 4 */
__u32 tcpi_last_data_sent; /* 44 4 */
__u32 tcpi_last_ack_sent; /* 48 4 */
__u32 tcpi_last_data_recv; /* 52 4 */
__u32 tcpi_last_ack_recv; /* 56 4 */
__u32 tcpi_pmtu; /* 60 4 */
/* --- cacheline 1 boundary (64 bytes) --- */
__u32 tcpi_rcv_ssthresh; /* 64 4 */
__u32 tcpi_rtt; /* 68 4 */
__u32 tcpi_rttvar; /* 72 4 */
__u32 tcpi_snd_ssthresh; /* 76 4 */
__u32 tcpi_snd_cwnd; /* 80 4 */
__u32 tcpi_advmss; /* 84 4 */
__u32 tcpi_reordering; /* 88 4 */
__u32 tcpi_rcv_rtt; /* 92 4 */
__u32 tcpi_rcv_space; /* 96 4 */
__u32 tcpi_total_retrans; /* 100 4 */
__u64 tcpi_pacing_rate; /* 104 8 */
__u64 tcpi_max_pacing_rate; /* 112 8 */
__u64 tcpi_bytes_acked; /* 120 8 */
/* --- cacheline 2 boundary (128 bytes) --- */
__u64 tcpi_bytes_received; /* 128 8 */
__u32 tcpi_segs_out; /* 136 4 */
__u32 tcpi_segs_in; /* 140 4 */
__u32 tcpi_notsent_bytes; /* 144 4 */
__u32 tcpi_min_rtt; /* 148 4 */
__u32 tcpi_data_segs_in; /* 152 4 */
__u32 tcpi_data_segs_out; /* 156 4 */
__u64 tcpi_delivery_rate; /* 160 8 */
__u64 tcpi_busy_time; /* 168 8 */
__u64 tcpi_rwnd_limited; /* 176 8 */
__u64 tcpi_sndbuf_limited; /* 184 8 */
/* --- cacheline 3 boundary (192 bytes) --- */
__u32 tcpi_delivered; /* 192 4 */
__u32 tcpi_delivered_ce; /* 196 4 */
__u64 tcpi_bytes_sent; /* 200 8 */
__u64 tcpi_bytes_retrans; /* 208 8 */
__u32 tcpi_dsack_dups; /* 216 4 */
__u32 tcpi_reord_seen; /* 220 4 */
__u32 tcpi_rcv_ooopack; /* 224 4 */
__u32 tcpi_snd_wnd; /* 228 4 */
__u32 tcpi_rcv_wnd; /* 232 4 */
__u32 tcpi_rehash; /* 236 4 */
__u16 tcpi_total_rto; /* 240 2 */
__u16 tcpi_total_rto_recoveries; /* 242 2 */
__u32 tcpi_total_rto_time; /* 244 4 */
__u32 tcpi_received_ce; /* 248 4 */
__u32 tcpi_delivered_e1_bytes; /* 252 4 */
/* --- cacheline 4 boundary (256 bytes) --- */
__u32 tcpi_delivered_e0_bytes; /* 256 4 */
__u32 tcpi_delivered_ce_bytes; /* 260 4 */
__u32 tcpi_received_e1_bytes; /* 264 4 */
__u32 tcpi_received_e0_bytes; /* 268 4 */
__u32 tcpi_received_ce_bytes; /* 272 4 */
/* size: 280, cachelines: 5, members: 68 */
/* sum members: 274 */
/* sum bitfield members: 11 bits, bit holes: 1, sum bit holes: 5 bits */
/* padding: 4 */
/* last cacheline: 24 bytes */
};
[...]
> > diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c index
> > a327fc14b207..66390966cc41 100644
> > --- a/net/ipv4/tcp_input.c
> > +++ b/net/ipv4/tcp_input.c
> > @@ -70,6 +70,7 @@
> > #include <linux/sysctl.h>
> > #include <linux/kernel.h>
> > #include <linux/prefetch.h>
> > +#include <linux/bitops.h>
> > #include <net/dst.h>
> > #include <net/tcp.h>
> > #include <net/proto_memory.h>
> > @@ -530,6 +531,139 @@ static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr
> > return false;
> > }
> >
> > +/* Maps IP ECN field ECT/CE code point to AccECN option field number,
> > +given
> > + * we are sending fields with Accurate ECN Order 1: ECT(1), CE, ECT(0).
> > + */
> > +static u8 tcp_ecnfield_to_accecn_optfield(u8 ecnfield) {
> > + switch (ecnfield & INET_ECN_MASK) {
> > + case INET_ECN_NOT_ECT:
> > + return 0; /* AccECN does not send counts of NOT_ECT */
> > + case INET_ECN_ECT_1:
> > + return 1;
> > + case INET_ECN_CE:
> > + return 2;
> > + case INET_ECN_ECT_0:
> > + return 3;
> > + }
> > + return 0;
> > +}
>
>
> net/ipv4/tcp_input.c has already 7273 lines....
>
> I would suggest adding all these tcp ecn helpers in a separate include file, and move existing ones.
>
Sure, I will create another header file including tcp ecn & accecn helpers.
Chia-Yu
^ permalink raw reply [flat|nested] 29+ messages in thread
* RE: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
2025-06-26 14:47 ` Chia-Yu Chang (Nokia)
@ 2025-06-30 18:05 ` Chia-Yu Chang (Nokia)
2025-06-30 18:07 ` Eric Dumazet
0 siblings, 1 reply; 29+ messages in thread
From: Chia-Yu Chang (Nokia) @ 2025-06-30 18:05 UTC (permalink / raw)
To: Eric Dumazet
Cc: pabeni@redhat.com, linux-doc@vger.kernel.org, corbet@lwn.net,
horms@kernel.org, dsahern@kernel.org, kuniyu@amazon.com,
bpf@vger.kernel.org, netdev@vger.kernel.org, dave.taht@gmail.com,
jhs@mojatatu.com, kuba@kernel.org, stephen@networkplumber.org,
xiyou.wangcong@gmail.com, jiri@resnulli.us, davem@davemloft.net,
andrew+netdev@lunn.ch, donald.hunter@gmail.com, ast@fiberby.net,
liuhangbin@gmail.com, shuah@kernel.org,
linux-kselftest@vger.kernel.org, ij@kernel.org,
ncardwell@google.com, Koen De Schepper (Nokia),
g.white@cablelabs.com, ingemar.s.johansson@ericsson.com,
mirja.kuehlewind@ericsson.com, cheshire@apple.com, rs.ietf@gmx.at,
Jason_Livingood@comcast.com, vidhi_goel@apple.com
> -----Original Message-----
> From: Chia-Yu Chang (Nokia)
> Sent: Thursday, June 26, 2025 4:47 PM
> To: Eric Dumazet <edumazet@google.com>
> Cc: pabeni@redhat.com; linux-doc@vger.kernel.org; corbet@lwn.net; horms@kernel.org; dsahern@kernel.org; kuniyu@amazon.com; bpf@vger.kernel.org; netdev@vger.kernel.org; dave.taht@gmail.com; jhs@mojatatu.com; kuba@kernel.org; stephen@networkplumber.org; xiyou.wangcong@gmail.com; jiri@resnulli.us; davem@davemloft.net; andrew+netdev@lunn.ch; donald.hunter@gmail.com; ast@fiberby.net; liuhangbin@gmail.com; shuah@kernel.org; linux-kselftest@vger.kernel.org; ij@kernel.org; ncardwell@google.com; Koen De Schepper (Nokia) <koen.de_schepper@nokia-bell-labs.com>; g.white@cablelabs.com; ingemar.s.johansson@ericsson.com; mirja.kuehlewind@ericsson.com; cheshire@apple.com; rs.ietf@gmx.at; Jason_Livingood@comcast.com; vidhi_goel@apple.com
> Subject: RE: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
>
> > -----Original Message-----
> > From: Eric Dumazet <edumazet@google.com>
> > Sent: Wednesday, June 25, 2025 11:21 AM
> > To: Chia-Yu Chang (Nokia) <chia-yu.chang@nokia-bell-labs.com>
> > Cc: pabeni@redhat.com; linux-doc@vger.kernel.org; corbet@lwn.net;
> > horms@kernel.org; dsahern@kernel.org; kuniyu@amazon.com;
> > bpf@vger.kernel.org; netdev@vger.kernel.org; dave.taht@gmail.com;
> > jhs@mojatatu.com; kuba@kernel.org; stephen@networkplumber.org;
> > xiyou.wangcong@gmail.com; jiri@resnulli.us; davem@davemloft.net;
> > andrew+netdev@lunn.ch; donald.hunter@gmail.com; ast@fiberby.net;
> > liuhangbin@gmail.com; shuah@kernel.org;
> > linux-kselftest@vger.kernel.org; ij@kernel.org; ncardwell@google.com;
> > Koen De Schepper (Nokia) <koen.de_schepper@nokia-bell-labs.com>;
> > g.white@cablelabs.com; ingemar.s.johansson@ericsson.com;
> > mirja.kuehlewind@ericsson.com; cheshire@apple.com; rs.ietf@gmx.at;
> > Jason_Livingood@comcast.com; vidhi_goel@apple.com
> > Subject: Re: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
> >
> >
> > CAUTION: This is an external email. Please be very careful when clicking links or opening attachments. See the URL nok.it/ext for additional information.
> >
> >
> >
> > On Sat, Jun 21, 2025 at 12:38 PM <chia-yu.chang@nokia-bell-labs.com> wrote:
> > >
> > > From: Ilpo Järvinen <ij@kernel.org>
> > >
> [...]
> > > --- a/include/uapi/linux/tcp.h
> > > +++ b/include/uapi/linux/tcp.h
> > > @@ -316,6 +316,13 @@ struct tcp_info {
> > > * in milliseconds, including any
> > > * unfinished recovery.
> > > */
> > > + __u32 tcpi_received_ce; /* # of CE marks received */
> > > + __u32 tcpi_delivered_e1_bytes; /* Accurate ECN byte counters */
> > > + __u32 tcpi_delivered_e0_bytes;
> > > + __u32 tcpi_delivered_ce_bytes;
> > > + __u32 tcpi_received_e1_bytes;
> > > + __u32 tcpi_received_e0_bytes;
> > > + __u32 tcpi_received_ce_bytes;
> >
> > We need to immediately fill the 32bit hole, otherwise we won't be able to use it in the future.
>
> Hi Eric,
>
> I did not see any holes created after adding these __u32 values, and you can see the pahole result of tcp_info below:
>
> And the pahole result is the same either I compile with ARM32 or 64-bit architecture.
>
> Or you mean we need an extra "__u32 unused;" at the end?
>
> struct tcp_info {
> __u8 tcpi_state; /* 0 1 */
> __u8 tcpi_ca_state; /* 1 1 */
> __u8 tcpi_retransmits; /* 2 1 */
> __u8 tcpi_probes; /* 3 1 */
> __u8 tcpi_backoff; /* 4 1 */
> __u8 tcpi_options; /* 5 1 */
> __u8 tcpi_snd_wscale:4; /* 6: 0 1 */
> __u8 tcpi_rcv_wscale:4; /* 6: 4 1 */
> __u8 tcpi_delivery_rate_app_limited:1; /* 7: 0 1 */
> __u8 tcpi_fastopen_client_fail:2; /* 7: 1 1 */
>
> /* XXX 5 bits hole, try to pack */
>
> __u32 tcpi_rto; /* 8 4 */
> __u32 tcpi_ato; /* 12 4 */
> __u32 tcpi_snd_mss; /* 16 4 */
> __u32 tcpi_rcv_mss; /* 20 4 */
> __u32 tcpi_unacked; /* 24 4 */
> __u32 tcpi_sacked; /* 28 4 */
> __u32 tcpi_lost; /* 32 4 */
> __u32 tcpi_retrans; /* 36 4 */
> __u32 tcpi_fackets; /* 40 4 */
> __u32 tcpi_last_data_sent; /* 44 4 */
> __u32 tcpi_last_ack_sent; /* 48 4 */
> __u32 tcpi_last_data_recv; /* 52 4 */
> __u32 tcpi_last_ack_recv; /* 56 4 */
> __u32 tcpi_pmtu; /* 60 4 */
> /* --- cacheline 1 boundary (64 bytes) --- */
> __u32 tcpi_rcv_ssthresh; /* 64 4 */
> __u32 tcpi_rtt; /* 68 4 */
> __u32 tcpi_rttvar; /* 72 4 */
> __u32 tcpi_snd_ssthresh; /* 76 4 */
> __u32 tcpi_snd_cwnd; /* 80 4 */
> __u32 tcpi_advmss; /* 84 4 */
> __u32 tcpi_reordering; /* 88 4 */
> __u32 tcpi_rcv_rtt; /* 92 4 */
> __u32 tcpi_rcv_space; /* 96 4 */
> __u32 tcpi_total_retrans; /* 100 4 */
> __u64 tcpi_pacing_rate; /* 104 8 */
> __u64 tcpi_max_pacing_rate; /* 112 8 */
> __u64 tcpi_bytes_acked; /* 120 8 */
> /* --- cacheline 2 boundary (128 bytes) --- */
> __u64 tcpi_bytes_received; /* 128 8 */
> __u32 tcpi_segs_out; /* 136 4 */
> __u32 tcpi_segs_in; /* 140 4 */
> __u32 tcpi_notsent_bytes; /* 144 4 */
> __u32 tcpi_min_rtt; /* 148 4 */
> __u32 tcpi_data_segs_in; /* 152 4 */
> __u32 tcpi_data_segs_out; /* 156 4 */
> __u64 tcpi_delivery_rate; /* 160 8 */
> __u64 tcpi_busy_time; /* 168 8 */
> __u64 tcpi_rwnd_limited; /* 176 8 */
> __u64 tcpi_sndbuf_limited; /* 184 8 */
> /* --- cacheline 3 boundary (192 bytes) --- */
> __u32 tcpi_delivered; /* 192 4 */
> __u32 tcpi_delivered_ce; /* 196 4 */
> __u64 tcpi_bytes_sent; /* 200 8 */
> __u64 tcpi_bytes_retrans; /* 208 8 */
> __u32 tcpi_dsack_dups; /* 216 4 */
> __u32 tcpi_reord_seen; /* 220 4 */
> __u32 tcpi_rcv_ooopack; /* 224 4 */
> __u32 tcpi_snd_wnd; /* 228 4 */
> __u32 tcpi_rcv_wnd; /* 232 4 */
> __u32 tcpi_rehash; /* 236 4 */
> __u16 tcpi_total_rto; /* 240 2 */
> __u16 tcpi_total_rto_recoveries; /* 242 2 */
> __u32 tcpi_total_rto_time; /* 244 4 */
> __u32 tcpi_received_ce; /* 248 4 */
> __u32 tcpi_delivered_e1_bytes; /* 252 4 */
> /* --- cacheline 4 boundary (256 bytes) --- */
> __u32 tcpi_delivered_e0_bytes; /* 256 4 */
> __u32 tcpi_delivered_ce_bytes; /* 260 4 */
> __u32 tcpi_received_e1_bytes; /* 264 4 */
> __u32 tcpi_received_e0_bytes; /* 268 4 */
> __u32 tcpi_received_ce_bytes; /* 272 4 */
>
>
> /* size: 280, cachelines: 5, members: 68 */
> /* sum members: 274 */
> /* sum bitfield members: 11 bits, bit holes: 1, sum bit holes: 5 bits */
> /* padding: 4 */
> /* last cacheline: 24 bytes */
> };
> [...]
> > > diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c index
> > > a327fc14b207..66390966cc41 100644
> > > --- a/net/ipv4/tcp_input.c
> > > +++ b/net/ipv4/tcp_input.c
> > > @@ -70,6 +70,7 @@
> > > #include <linux/sysctl.h>
> > > #include <linux/kernel.h>
> > > #include <linux/prefetch.h>
> > > +#include <linux/bitops.h>
> > > #include <net/dst.h>
> > > #include <net/tcp.h>
> > > #include <net/proto_memory.h>
> > > @@ -530,6 +531,139 @@ static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr
> > > return false;
> > > }
> > >
> > > +/* Maps IP ECN field ECT/CE code point to AccECN option field
> > > +number, given
> > > + * we are sending fields with Accurate ECN Order 1: ECT(1), CE, ECT(0).
> > > + */
> > > +static u8 tcp_ecnfield_to_accecn_optfield(u8 ecnfield) {
> > > + switch (ecnfield & INET_ECN_MASK) {
> > > + case INET_ECN_NOT_ECT:
> > > + return 0; /* AccECN does not send counts of NOT_ECT */
> > > + case INET_ECN_ECT_1:
> > > + return 1;
> > > + case INET_ECN_CE:
> > > + return 2;
> > > + case INET_ECN_ECT_0:
> > > + return 3;
> > > + }
> > > + return 0;
> > > +}
> >
> >
> > net/ipv4/tcp_input.c has already 7273 lines....
> >
> > I would suggest adding all these tcp ecn helpers in a separate include file, and move existing ones.
> >
>
> Sure, I will create another header file including tcp ecn & accecn helpers.
>
> Chia-Yu
On top of my previous reply, I will like to specify that the following ECN functions will also be included in new /include/net/tcp_ecn.h
void tcp_ecn_queue_cwr(), void tcp_ecn_accept_cwr(), and void tcp_ecn_withdraw_cwr()
This is because these functions are also been modified due to the introduction of Accurate ECN.
Does it make sense to you? Or only AccECN function shall be included in the new header?
^ permalink raw reply [flat|nested] 29+ messages in thread
* Re: [PATCH v9 net-next 09/15] tcp: accecn: AccECN option
2025-06-30 18:05 ` Chia-Yu Chang (Nokia)
@ 2025-06-30 18:07 ` Eric Dumazet
0 siblings, 0 replies; 29+ messages in thread
From: Eric Dumazet @ 2025-06-30 18:07 UTC (permalink / raw)
To: Chia-Yu Chang (Nokia)
Cc: pabeni@redhat.com, linux-doc@vger.kernel.org, corbet@lwn.net,
horms@kernel.org, dsahern@kernel.org, kuniyu@amazon.com,
bpf@vger.kernel.org, netdev@vger.kernel.org, dave.taht@gmail.com,
jhs@mojatatu.com, kuba@kernel.org, stephen@networkplumber.org,
xiyou.wangcong@gmail.com, jiri@resnulli.us, davem@davemloft.net,
andrew+netdev@lunn.ch, donald.hunter@gmail.com, ast@fiberby.net,
liuhangbin@gmail.com, shuah@kernel.org,
linux-kselftest@vger.kernel.org, ij@kernel.org,
ncardwell@google.com, Koen De Schepper (Nokia),
g.white@cablelabs.com, ingemar.s.johansson@ericsson.com,
mirja.kuehlewind@ericsson.com, cheshire@apple.com, rs.ietf@gmx.at,
Jason_Livingood@comcast.com, vidhi_goel@apple.com
On Mon, Jun 30, 2025 at 11:05 AM Chia-Yu Chang (Nokia)
<chia-yu.chang@nokia-bell-labs.com> wrote:
>
> On top of my previous reply, I will like to specify that the following ECN functions will also be included in new /include/net/tcp_ecn.h
>
> void tcp_ecn_queue_cwr(), void tcp_ecn_accept_cwr(), and void tcp_ecn_withdraw_cwr()
Sure !
>
> This is because these functions are also been modified due to the introduction of Accurate ECN.
>
> Does it make sense to you? Or only AccECN function shall be included in the new header?
^ permalink raw reply [flat|nested] 29+ messages in thread
end of thread, other threads:[~2025-06-30 18:08 UTC | newest]
Thread overview: 29+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-06-21 19:37 [PATCH v9 net-next 00/15] AccECN protocol patch series chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 01/15] tcp: reorganize SYN ECN code chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 02/15] tcp: fast path functions later chia-yu.chang
2025-06-23 14:24 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 03/15] tcp: reorganize tcp_sock_write_txrx group for variables later chia-yu.chang
2025-06-23 14:37 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 04/15] tcp: AccECN core chia-yu.chang
2025-06-23 16:13 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 05/15] tcp: accecn: AccECN negotiation chia-yu.chang
2025-06-25 7:57 ` Eric Dumazet
2025-06-26 8:06 ` Chia-Yu Chang (Nokia)
2025-06-21 19:37 ` [PATCH v9 net-next 06/15] tcp: accecn: add AccECN rx byte counters chia-yu.chang
2025-06-25 8:04 ` Eric Dumazet
2025-06-26 8:45 ` Chia-Yu Chang (Nokia)
2025-06-21 19:37 ` [PATCH v9 net-next 07/15] tcp: accecn: AccECN needs to know delivered bytes chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 08/15] tcp: sack option handling improvements chia-yu.chang
2025-06-25 8:08 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 09/15] tcp: accecn: AccECN option chia-yu.chang
2025-06-25 9:21 ` Eric Dumazet
2025-06-26 14:47 ` Chia-Yu Chang (Nokia)
2025-06-30 18:05 ` Chia-Yu Chang (Nokia)
2025-06-30 18:07 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 10/15] tcp: accecn: AccECN option send control chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 11/15] tcp: accecn: AccECN option failure handling chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 12/15] tcp: accecn: AccECN option ceb/cep heuristic chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 13/15] tcp: accecn: AccECN ACE field multi-wrap heuristic chia-yu.chang
2025-06-21 19:37 ` [PATCH v9 net-next 14/15] tcp: accecn: try to fit AccECN option with SACK chia-yu.chang
2025-06-25 9:33 ` Eric Dumazet
2025-06-21 19:37 ` [PATCH v9 net-next 15/15] tcp: try to avoid safer when ACKs are thinned chia-yu.chang
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).