mptcp: address stall under memory pressure
Subsystems (2)
Paolo Abeni
maintainerv2 cover mptcp: address stall under memory pressure
This *should* address opus-5 feedback, as observed upstream.
New iteration takes care of gemini review on v1.
Paolo Abeni (7):
mptcp: move the retrans loop to a separate helper
mptcp: move the stale logic out of retrans scheduler
mptcp: let the retrans scheduler do its job
mptcp: explicitly drop over memory limits
mptcp: enforce hard limit on backlog flushing
mptcp: avoid code duplication in __mptcp_move_skb()
mptcp: implemented OoO queue pruning
net/mptcp/mib.c | 3 + net/mptcp/mib.h | 3 + net/mptcp/options.c | 32 ++++- net/mptcp/pm.c | 42 ++++--- net/mptcp/protocol.c | 290 ++++++++++++++++++++++++++++++------------- net/mptcp/protocol.h | 11 +- 6 files changed, 273 insertions(+), 108 deletions(-)
Signature · 1 line
2.55.0
Paolo Abeni
maintainerPATCH v2 1/7 mptcp: move the retrans loop to a separate helper
This is a cleanup in order to make the next patch simpler. No functional change intended.
--- net/mptcp/protocol.c | 74 +++++++++++++++++++++++++------------------- 1 file changed, 43 insertions(+), 31 deletions(-)
net/mptcp/protocol.c +43 -31
@@ -2791,41 +2791,14 @@ static void mptcp_check_fastclose(struct mptcp_sock *msk)sk_error_report (sk); } -static void __mptcp_retrans (struct sock *sk) +/* Retransmit the specified data fragment on all the selected subflows. */ +static int __mptcp_push_retrans (struct sock *sk,struct mptcp_data_frag *dfrag) {struct mptcp_sendmsg_info info = { .data_lock_held = true, };struct mptcp_sock *msk =mptcp_sk (sk);struct mptcp_subflow_context *subflow; -struct mptcp_data_frag *dfrag;struct sock *ssk; -int ret, err; -u16 len =0 ; - -mptcp_clean_una_wakeup (sk); - -/* first check ssk: need to kick "stale" logic */ - err =mptcp_sched_get_retrans (msk); - dfrag =mptcp_rtx_head (sk); -if (!dfrag) { -if (mptcp_data_fin_enabled (msk)) { -struct inet_connection_sock *icsk =inet_csk (sk); - -WRITE_ONCE (icsk->icsk_retransmits, - icsk->icsk_retransmits +1 ); -mptcp_set_datafin_timeout (sk); -mptcp_send_ack (msk); - - goto reset_timer; - } - -if (!mptcp_send_head (sk)) - goto clear_scheduled; - - goto reset_timer; - } - -if (err) - goto reset_timer; +int ret, len =0 ;mptcp_for_each_subflow (msk, subflow) {if (READ_ONCE (subflow->scheduled)) {
@@ -2853,7 +2826,7 @@ static void __mptcp_retrans(struct sock *sk) !msk->allow_subflows) {spin_unlock_bh (&msk->fallback_lock);release_sock (ssk); - goto clear_scheduled; +return -1 ; }while (info.sent < info.limit) {
@@ -2876,6 +2849,45 @@ static void __mptcp_retrans(struct sock *sk)release_sock (ssk); } } +return len; +} + +static void __mptcp_retrans (struct sock *sk) +{ +struct mptcp_sock *msk =mptcp_sk (sk); +struct mptcp_subflow_context *subflow; +struct mptcp_data_frag *dfrag; +int err, len; + +mptcp_clean_una_wakeup (sk); + +/* first check ssk: need to kick "stale" logic */ + err =mptcp_sched_get_retrans (msk); + dfrag =mptcp_rtx_head (sk); +if (!dfrag) { +if (mptcp_data_fin_enabled (msk)) { +struct inet_connection_sock *icsk =inet_csk (sk); + +WRITE_ONCE (icsk->icsk_retransmits, + icsk->icsk_retransmits +1 ); +mptcp_set_datafin_timeout (sk); +mptcp_send_ack (msk); + + goto reset_timer; + } + +if (!mptcp_send_head (sk)) + goto clear_scheduled; + + goto reset_timer; + } + +if (err) + goto reset_timer; + + len =__mptcp_push_retrans (sk, dfrag); +if (len <0 ) + goto clear_scheduled; msk->bytes_retrans += len; dfrag->already_sent =max (dfrag->already_sent, len);
Signature · 1 line
2.55.0
Paolo Abeni
maintainerPATCH v2 2/7 mptcp: move the stale logic out of retrans scheduler
In reply to Paolo AbeniThis allow separating the stale logic invocation and the retrans scheduler, and will simplify the next patch.
It's also a cleaner design as the retrans scheduler has currently too many side effects. As a possible downside, the retrans work will now traverse the subflows list additional times; that does not matter much, as this is slowpath.
While at it, pick more accurate names for the involved helpers and explicitly note that the per subflow stale data is under msk socket lock protection.
The scheduler and the stale logic may observe different subflow statues, as no subflow lock is acquired. This is intentional and not harmful, worst case leading to slower retransmissions.
---
v1 -> v2:
- fix stale lockless access
Note: BPF scheduler should be rebase to use the renamed helper
--- net/mptcp/pm.c | 42 +++++++++++++++++++++++++++--------------- net/mptcp/protocol.c | 4 ++-- net/mptcp/protocol.h | 11 +++++++---- 3 files changed, 36 insertions(+), 21 deletions(-)
net/mptcp/pm.c +27 -15
@@ -1061,7 +1061,7 @@ bool mptcp_pm_is_backup(struct mptcp_sock *msk, struct sock_common *skc)return msk->pm.ops->get_priority (msk, &skc_local); } -static void mptcp_pm_subflows_chk_stale (const struct mptcp_sock *msk,struct sock *ssk) +static void mptcp_pm_subflow_chk_stale (const struct mptcp_sock *msk,struct sock *ssk) {struct mptcp_subflow_context *iter, *subflow =mptcp_subflow_ctx (ssk);struct sock *sk = (struct sock *)msk;
@@ -1098,22 +1098,34 @@ static void mptcp_pm_subflows_chk_stale(const struct mptcp_sock *msk, struct soc } } -void mptcp_pm_subflow_chk_stale (const struct mptcp_sock *msk,struct sock *ssk) +void mptcp_pm_chk_stale (const struct mptcp_sock *msk) { -struct mptcp_subflow_context *subflow =mptcp_subflow_ctx (ssk); -u32 rcv_tstamp =READ_ONCE (tcp_sk (ssk)->rcv_tstamp); - -/* keep track of rtx periods with no progress */ -if (!subflow->stale_count) { - subflow->stale_rcv_tstamp = rcv_tstamp; - subflow->stale_count++; - }else if (subflow->stale_rcv_tstamp == rcv_tstamp) { -if (subflow->stale_count <U8_MAX ) +struct mptcp_subflow_context *subflow; + +mptcp_for_each_subflow (msk, subflow) { +struct sock *ssk =mptcp_subflow_tcp_sock (subflow); +u32 rcv_tstamp; + +if (!__mptcp_subflow_active (subflow)) +continue ; + +/* No data outstanding at TCP level? not stale */ +if (tcp_rtx_and_write_queues_empty (ssk)) +continue ; + +/* keep track of rtx periods with no progress */ + rcv_tstamp =READ_ONCE (tcp_sk (ssk)->rcv_tstamp); +if (!subflow->stale_count) { + subflow->stale_rcv_tstamp = rcv_tstamp; subflow->stale_count++; -mptcp_pm_subflows_chk_stale (msk, ssk); - }else { - subflow->stale_count =0 ; -mptcp_subflow_set_active (subflow); + }else if (subflow->stale_rcv_tstamp == rcv_tstamp) { +if (subflow->stale_count <U8_MAX ) + subflow->stale_count++; +mptcp_pm_subflow_chk_stale (msk, ssk); + }else { + subflow->stale_count =0 ; +mptcp_subflow_set_active (subflow); + } } }
net/mptcp/protocol.c +2 -2
@@ -2469,7 +2469,6 @@ struct sock *mptcp_subflow_get_retrans(struct mptcp_sock *msk)/* still data outstanding at TCP level? skip this */ if (!tcp_rtx_and_write_queues_empty (ssk)) { -mptcp_pm_subflow_chk_stale (msk, ssk); min_stale_count =min_t (int, min_stale_count, subflow->stale_count);continue ; }
@@ -2859,9 +2858,10 @@ static void __mptcp_retrans(struct sock *sk)struct mptcp_data_frag *dfrag;int err, len; +mptcp_pm_chk_stale (msk); +mptcp_clean_una_wakeup (sk); -/* first check ssk: need to kick "stale" logic */ err =mptcp_sched_get_retrans (msk); dfrag =mptcp_rtx_head (sk);if (!dfrag) {
net/mptcp/protocol.h +7 -4
@@ -581,12 +581,11 @@ struct mptcp_subflow_context { remote_key_valid : 1, /* received the peer key from */ disposable : 1, /* ctx can be free at ulp release time */ closing : 1, /* must not pass rx data to msk anymore */ - stale : 1, /* unable to snd/rcv data, do not use for xmit */ valid_csum_seen : 1, /* at least one csum validated */ is_mptfo : 1, /* subflow is doing TFO */ close_event_done : 1, /* has done the post-closed part */ mpc_drop : 1, /* the MPC option has been dropped in a rtx */ - __unused : 8; + __unused : 9;bool data_avail;bool scheduled;bool pm_listener;/* a listener managed by the kernel PM? */
@@ -605,7 +604,11 @@ struct mptcp_subflow_context { u8 reset_seen:1; u8 reset_transient:1; u8 reset_reason:4; -u8 stale_count; +u8 stale_count;/* Protected by the msk socket lock */ +u8 stale;/* Protected by the msk socket lock, +* if set the subflow is unable to snd/rcv +* data, the schedule should skip it +*/ u32 subflow_id;
@@ -1104,7 +1107,7 @@ int mptcp_pm_parse_entry(struct nlattr *attr, struct genl_info *info,bool mptcp_pm_addr_families_match (const struct sock *sk,const struct mptcp_addr_info *loc,const struct mptcp_addr_info *rem); -void mptcp_pm_subflow_chk_stale (const struct mptcp_sock *msk,struct sock *ssk); +void mptcp_pm_chk_stale (const struct mptcp_sock *msk);void mptcp_pm_new_connection (struct mptcp_sock *msk,const struct sock *ssk,int server_side);void mptcp_pm_fully_established (struct mptcp_sock *msk,const struct sock *ssk);bool mptcp_pm_allow_new_subflow (struct mptcp_sock *msk);
Signature · 1 line
2.55.0
Paolo Abeni
maintainerRe: [PATCH v2 mptcp-next 2/7] mptcp: move the stale logic out of retrans scheduler
Quoted 16 lines · Paolo Abeni
This allow separating the stale logic invocation and the retrans scheduler, and will simplify the next patch.
It's also a cleaner design as the retrans scheduler has currently too many side effects. As a possible downside, the retrans work will now traverse the subflows list additional times; that does not matter much, as this is slowpath.
While at it, pick more accurate names for the involved helpers and explicitly note that the per subflow stale data is under msk socket lock protection.
The scheduler and the stale logic may observe different subflow statues, as no subflow lock is acquired. This is intentional and not harmful, worst case leading to slower retransmissions.
Quoted 6 lines
Signed-off-by Paolo Abeni <[email protected]>---
v1 -> v2:
- fix stale lockless accessNote: BPF scheduler should be rebase to use the renamed helper
Additional note: I think the rename is a good thing, because the function additionally changed the argument list.
@Mat: please LMK if you are ok with squash-to patches for later self-tests/bpf things to be adjusted.
/P
Matthieu Baerts
maintainerRe: [PATCH v2 mptcp-next 2/7] mptcp: move the stale logic out of retrans scheduler
Quoted 17 lines · Paolo Abeni
Quoted 16 lines · Paolo Abeni
This allow separating the stale logic invocation and the retrans scheduler, and will simplify the next patch.
It's also a cleaner design as the retrans scheduler has currently too many side effects. As a possible downside, the retrans work will now traverse the subflows list additional times; that does not matter much, as this is slowpath.
While at it, pick more accurate names for the involved helpers and explicitly note that the per subflow stale data is under msk socket lock protection.
The scheduler and the stale logic may observe different subflow statues, as no subflow lock is acquired. This is intentional and not harmful, worst case leading to slower retransmissions.
Quoted 8 lines
Quoted 6 lines
Signed-off-by Paolo Abeni <[email protected]>---
v1 -> v2:
- fix stale lockless accessNote: BPF scheduler should be rebase to use the renamed helper
Additional note: I think the rename is a good thing, because the function additionally changed the argument list.
Fine by me: these helpers are only in our export branch anyway.
Quoted 2 lines
@Mat: please LMK if you are ok with squash-to patches for later self-tests/bpf things to be adjusted.
Yes, of course.
Because they are now our of the scheduler API, I guess they can be removed. So Geliang's series can be used on top of yours:
https://lore.kernel.org/[email protected]
Cheers,
Matt
Signature · 1 line
Sponsored by the NGI0 Core fund.
Paolo Abeni
maintainerPATCH v2 3/7 mptcp: let the retrans scheduler do its job
In reply to Paolo AbeniCurrently the MPTCP core enforces that when MPTCP-level retrans timer fires, at most a single dfrag is retransmitted. If some corner-cases it may be necessary retransmit multiple dfrags, and the MPTCP socket will need to wait multiple retrans timeout to accomplish that.
Remove the mentioned constraint, allowing to transmit multiple dfrags per retrans period, as long as the scheduler keeps selecting subflows for retransmissions and pending data is available in the rtx queue. The default scheduler will transmit a dfrag per available subflow.
---
v2:
- do not restart from first frag at each loop iteration
v<n> -> v<n+1>:
- many cleanups, since the stale logic is invoked only once outside the main loop
--- net/mptcp/protocol.c | 106 ++++++++++++++++++++++++++++++------------- 1 file changed, 75 insertions(+), 31 deletions(-)
net/mptcp/protocol.c +75 -31
@@ -1142,13 +1142,6 @@ static void __mptcp_clean_una_wakeup(struct sock *sk)mptcp_write_space (sk); } -static void mptcp_clean_una_wakeup (struct sock *sk) -{ -mptcp_data_lock (sk); -__mptcp_clean_una_wakeup (sk); -mptcp_data_unlock (sk); -} -static void mptcp_enter_memory_pressure (struct sock *sk) {struct mptcp_subflow_context *subflow;
@@ -2790,8 +2783,12 @@ static void mptcp_check_fastclose(struct mptcp_sock *msk)sk_error_report (sk); } -/* Retransmit the specified data fragment on all the selected subflows. */ -static int __mptcp_push_retrans (struct sock *sk,struct mptcp_data_frag *dfrag) +/* +* Retransmit the specified data fragment on all the selected subflows, +* starting from the specified sequence +*/ +static int __mptcp_push_retrans (struct sock *sk,struct mptcp_data_frag *dfrag, +u64 sent_seq) {struct mptcp_sendmsg_info info = { .data_lock_held = true, };struct mptcp_sock *msk =mptcp_sk (sk);
@@ -2801,6 +2798,7 @@ static int __mptcp_push_retrans(struct sock *sk, struct mptcp_data_frag *dfrag)mptcp_for_each_subflow (msk, subflow) {if (READ_ONCE (subflow->scheduled)) { +u16 offset = sent_seq - dfrag->data_seq;u16 copied =0 ;mptcp_subflow_set_scheduled (subflow, false);
@@ -2810,7 +2808,7 @@ static int __mptcp_push_retrans(struct sock *sk, struct mptcp_data_frag *dfrag)lock_sock (ssk);/* limit retransmission to the bytes already sent on some subflows */ - info.sent =0 ; + info.sent = offset; info.limit =READ_ONCE (msk->csum_enabled) ? dfrag->data_len : dfrag->already_sent;
@@ -2856,15 +2854,78 @@ static void __mptcp_retrans(struct sock *sk)struct mptcp_sock *msk =mptcp_sk (sk);struct mptcp_subflow_context *subflow;struct mptcp_data_frag *dfrag; +u64 retrans_seq, sent_seq; +bool need_retrans;int err, len;mptcp_pm_chk_stale (msk); -mptcp_clean_una_wakeup (sk); - - err =mptcp_sched_get_retrans (msk); +/* Get an updated and consistent rtx queue status. */ +mptcp_data_lock (sk); +__mptcp_clean_una_wakeup (sk); + retrans_seq = msk->snd_una; dfrag =mptcp_rtx_head (sk); -if (!dfrag) { + need_retrans = !!dfrag; +mptcp_data_unlock (sk); + +for (;;) { +bool already_acked; + + err =mptcp_sched_get_retrans (msk); +if (err) +break ; + +/* `already_sent` can be 0 for `dfrag` belonging to the RTX +* queue due to __mptcp_retransmit_pending_data(). +*/ +if (!dfrag || !dfrag->already_sent) +break ; + +/* Can fail only in case of fallback. */ + len =__mptcp_push_retrans (sk, dfrag, retrans_seq); +if (len <0 ) + goto clear_scheduled; + + retrans_seq += len; + msk->bytes_retrans += len; + dfrag->already_sent =max_t (u16, dfrag->already_sent, + retrans_seq - dfrag->data_seq); + +/* With csum enabled, retransmission can send new data. */ + sent_seq = dfrag->already_sent + dfrag->data_seq; +if (after64 (sent_seq, msk->snd_nxt)) +WRITE_ONCE (msk->snd_nxt, sent_seq); + +/* Attempt the next fragment only if the current one is +* completely retransmitted. +*/ +if (before64 (retrans_seq, dfrag->data_seq + dfrag->data_len)) +break ; + + dfrag =list_is_last (&dfrag->list, &msk->rtx_queue) ? +NULL :list_next_entry (dfrag, list); +if (!dfrag) +break ; + +/* Incoming acks can move snd_una after the current dfrag +* across loop iterations, if so start again from RTX head. +*/ +mptcp_data_lock (sk); + already_acked = !before64 (msk->snd_una, dfrag->data_seq + + dfrag->already_sent); +if (already_acked) { +__mptcp_clean_una_wakeup (sk); + retrans_seq = msk->snd_una; + dfrag =mptcp_rtx_head (sk); + need_retrans = !!dfrag; + }else if (after64 (msk->snd_una, retrans_seq)) { + retrans_seq = msk->snd_una; + } +mptcp_data_unlock (sk); + } + +/* Attempt data-fin retransmission only when the RTX queue is empty. */ +if (!need_retrans) {if (mptcp_data_fin_enabled (msk)) {struct inet_connection_sock *icsk =inet_csk (sk);
@@ -2872,30 +2933,13 @@ static void __mptcp_retrans(struct sock *sk) icsk->icsk_retransmits + 1);mptcp_set_datafin_timeout (sk);mptcp_send_ack (msk); - goto reset_timer; }if (!mptcp_send_head (sk)) goto clear_scheduled; - - goto reset_timer; } -if (err) - goto reset_timer; - - len =__mptcp_push_retrans (sk, dfrag); -if (len <0 ) - goto clear_scheduled; - - msk->bytes_retrans += len; - dfrag->already_sent =max (dfrag->already_sent, len); - -/* With csum enabled retransmission can send new data. */ -if (after64 (dfrag->already_sent + dfrag->data_seq, msk->snd_nxt)) -WRITE_ONCE (msk->snd_nxt, dfrag->already_sent + dfrag->data_seq); - reset_timer:mptcp_check_and_set_pending (sk);
Signature · 1 line
2.55.0
Paolo Abeni
maintainerPATCH v2 4/7 mptcp: explicitly drop over memory limits
In reply to Paolo AbeniCurrently the enforcement of the rcvbuf constraint is implemented when moving the skbs into the msk receive or OoO queue, keeping the incoming skbs in the subflow queue when over limit.
Under significant memory pressure the above can cause permanent data transfer stalls, as the skb needed to make forward progress can be stuck in a subflow queue.
Over memory limits, drop the incoming skb, relaying on MPTCP-level retransmissions.
Note that fallback socket must perform the limit before the skb reaches the subflow-level queue, as dropping an in-sequence already acked skb would break the stream.
This is not a complete fix for the stall issue, as the drop strategy needs refinements that will come in the next patches.
---
v<n> -. v<n+1>:
- refine mptcp_over_limit() to check separately backlog and rcvbuf
- do not drop rst (with data)
--- net/mptcp/mib.c | 2 ++ net/mptcp/mib.h | 2 ++ net/mptcp/options.c | 32 +++++++++++++++++++++++++++++--- net/mptcp/protocol.c | 31 +++++++++++++++++++++++-------- 4 files changed, 56 insertions(+), 11 deletions(-)
net/mptcp/mib.c +2 -0
@@ -85,6 +85,8 @@ static const struct snmp_mib mptcp_snmp_list[] = {SNMP_MIB_ITEM ("SimultConnectFallback" ,MPTCP_MIB_SIMULTCONNFALLBACK ),SNMP_MIB_ITEM ("FallbackFailed" ,MPTCP_MIB_FALLBACKFAILED ),SNMP_MIB_ITEM ("WinProbe" ,MPTCP_MIB_WINPROBE ), +SNMP_MIB_ITEM ("BacklogDrop" ,MPTCP_MIB_BACKLOGDROP ), + SNMP_MIB_ITEM("RcvPruned", MPTCP_MIB_RCVPRUNED), };/* mptcp_mib_alloc - allocate percpu mib counters
net/mptcp/mib.h +2 -0
@@ -88,6 +88,8 @@ enum linux_mptcp_mib_field {MPTCP_MIB_SIMULTCONNFALLBACK ,/* Simultaneous connect */ MPTCP_MIB_FALLBACKFAILED ,/* Can't fallback due to msk status */ MPTCP_MIB_WINPROBE ,/* MPTCP-level zero window probe */ +MPTCP_MIB_BACKLOGDROP ,/* Backlog over memory limit */ +MPTCP_MIB_RCVPRUNED ,/* Dropped due to memory constraints */ __MPTCP_MIB_MAX };
net/mptcp/options.c +29 -3
@@ -1190,8 +1190,34 @@ static bool add_addr_hmac_valid(struct mptcp_sock *msk,return hmac == mp_opt->ahmac; } -/* Return false in case of error (or subflow has been reset), -* else return true. +static bool mptcp_over_limit (struct sock *sk,struct sock *ssk, +const struct sk_buff *skb) +{ +struct mptcp_sock *msk =mptcp_sk (sk); +u32 rcvbuf =READ_ONCE (sk->sk_rcvbuf); + +if (likely ((u32 )sk_rmem_alloc_get (sk) <= rcvbuf && +READ_ONCE (msk->backlog_len) <= rcvbuf)) +return false; + +/* Avoid silently dropping pure acks, fin, rst or already-acked segments. */ +if (TCP_SKB_CB (skb)->seq ==TCP_SKB_CB (skb)->end_seq || +TCP_SKB_CB (skb)->tcp_flags & (TCPHDR_FIN |TCPHDR_RST ) || + !after (TCP_SKB_CB (skb)->end_seq,tcp_sk (ssk)->rcv_nxt)) +return false; + +/* Dropped due to memory constraints, schedule an ack. */ +inet_csk (ssk)->icsk_ack.pending |=ICSK_ACK_NOMEM |ICSK_ACK_NOW ; +inet_csk_schedule_ack (ssk); + +/* Plain TCP (fallback) and skb is dropped before the TCP recv queue. */ +NET_INC_STATS (sock_net (sk),LINUX_MIB_TCPRCVQDROP ); + +return true; +} + +/* Return false when the caller must drop the packet, i.e. in case of error, +* subflow has been reset, or over memory limits. */ bool mptcp_incoming_options (struct sock *sk,struct sk_buff *skb) {
@@ -1217,7 +1243,7 @@ bool mptcp_incoming_options(struct sock *sk, struct sk_buff *skb)__mptcp_data_acked (subflow->conn);mptcp_data_unlock (subflow->conn); -return true; +return !mptcp_over_limit (subflow->conn, sk, skb); }mptcp_get_options (skb, &mp_opt);
net/mptcp/protocol.c +23 -8
@@ -387,6 +387,16 @@ static bool __mptcp_move_skb(struct sock *sk, struct sk_buff *skb)mptcp_borrow_fwdmem (sk, skb); +/* Can't drop packets for fallback socket this late, or the stream +* will break. +*/ +if (unlikely (sk_rmem_alloc_get (sk) >READ_ONCE (sk->sk_rcvbuf)) && + !__mptcp_check_fallback (msk)) { +MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_RCVPRUNED ); +mptcp_drop (sk, skb); +return false; + } +if (MPTCP_SKB_CB (skb)->map_seq == msk->ack_seq) {/* in sequence */ msk->bytes_received += copy_len;
@@ -681,6 +691,7 @@ static void __mptcp_add_backlog(struct sock *sk,struct sk_buff *tail =NULL ;struct sock *ssk = skb->sk;bool fragstolen; +u64 limit;int delta;if (unlikely (sk->sk_state ==TCP_CLOSE )) {
@@ -688,6 +699,16 @@ static void __mptcp_add_backlog(struct sock *sk,return ; } +/* Similar additional allowance as plain TCP. */ + limit =READ_ONCE (sk->sk_rcvbuf); + limit += (limit >>1 ) +64 *1024 ; + limit =min_t (u64, limit,UINT_MAX ); +if (msk->backlog_len > limit && !__mptcp_check_fallback (msk)) { +__MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_BACKLOGDROP ); +kfree_skb_reason (skb,SKB_DROP_REASON_SOCKET_BACKLOG ); +return ; + } +/* Try to coalesce with the last skb in our backlog */ if (!list_empty (&msk->backlog_list)) tail = list_last_entry(&msk->backlog_list, struct sk_buff, list);
@@ -759,7 +780,7 @@ static bool __mptcp_move_skbs_from_subflow(struct mptcp_sock *msk,mptcp_init_skb (ssk, skb, offset, len); -if (own_msk &&sk_rmem_alloc_get (sk) < sk->sk_rcvbuf) { +if (own_msk) {mptcp_subflow_lend_fwdmem (subflow, skb); ret |=__mptcp_move_skb (sk, skb); }else {
@@ -2210,10 +2231,6 @@ static bool __mptcp_move_skbs(struct sock *sk, struct list_head *skbs, u32 *delt *delta =0 ;while (1 ) { -/* If the msk recvbuf is full stop, don't drop */ -if (sk_rmem_alloc_get (sk) > sk->sk_rcvbuf) -break ; -prefetch (skb->next);list_del (&skb->list); *delta += skb->truesize;
@@ -2241,9 +2258,7 @@ static bool mptcp_can_spool_backlog(struct sock *sk, struct list_head *skbs)DEBUG_NET_WARN_ON_ONCE (msk->backlog_unaccounted && sk->sk_socket &&mem_cgroup_from_sk (sk)); -/* Don't spool the backlog if the rcvbuf is full. */ -if (list_empty (&msk->backlog_list) || -sk_rmem_alloc_get (sk) > sk->sk_rcvbuf) +if (list_empty (&msk->backlog_list))return false;INIT_LIST_HEAD (skbs);
Signature · 1 line
2.55.0
Paolo Abeni
maintainerPATCH v2 5/7 mptcp: enforce hard limit on backlog flushing
In reply to Paolo AbeniCurrently a wild producer could keep the backlog flushing operation spinning for an unbound time.
Since the previous patch the amount of data present in the backlog is hard-limited. Move the backlog len update at the end of the flush loop to prevent it spinning forever.
Also, no need to splice back the remaining skbs list into the backlog, as such list is always empty after each backlog processing loop.
--- net/mptcp/protocol.c | 21 ++++++--------------- 1 file changed, 6 insertions(+), 15 deletions(-)
net/mptcp/protocol.c +6 -15
@@ -2229,7 +2229,6 @@ static bool __mptcp_move_skbs(struct sock *sk, struct list_head *skbs, u32 *deltstruct mptcp_sock *msk =mptcp_sk (sk);bool moved = false; - *delta =0 ;while (1 ) {prefetch (skb->next);list_del (&skb->list);
@@ -2266,20 +2265,12 @@ static bool mptcp_can_spool_backlog(struct sock *sk, struct list_head *skbs)return true; } -static void mptcp_backlog_spooled (struct sock *sk,u32 moved, -struct list_head *skbs) -{ -struct mptcp_sock *msk =mptcp_sk (sk); - -WRITE_ONCE (msk->backlog_len, msk->backlog_len - moved); -list_splice (skbs, &msk->backlog_list); -} -static bool mptcp_move_skbs (struct sock *sk) { +struct mptcp_sock *msk =mptcp_sk (sk);struct list_head skbs;bool enqueued = false; -u32 moved; +u32 moved =0 ;mptcp_data_lock (sk);while (mptcp_can_spool_backlog (sk, &skbs)) {
@@ -2287,8 +2278,8 @@ static bool mptcp_move_skbs(struct sock *sk) enqueued |=__mptcp_move_skbs (sk, &skbs, &moved);mptcp_data_lock (sk); -mptcp_backlog_spooled (sk, moved, &skbs); } +WRITE_ONCE (msk->backlog_len, msk->backlog_len - moved);mptcp_data_unlock (sk);if (enqueued &&mptcp_epollin_ready (sk))
@@ -3747,12 +3738,12 @@ static void mptcp_release_cb(struct sock *sk) __must_hold(&sk->sk_lock.slock) {struct mptcp_sock *msk =mptcp_sk (sk); +u32 moved =0 ;for (;;) {unsigned long flags = (msk->cb_flags &MPTCP_FLAGS_PROCESS_CTX_NEED );struct list_head join_list, skbs;bool spool_bl; -u32 moved; spool_bl =mptcp_can_spool_backlog (sk, &skbs);if (!flags && !spool_bl)
@@ -3785,9 +3776,9 @@ static void mptcp_release_cb(struct sock *sk)cond_resched ();spin_lock_bh (&sk->sk_lock.slock); -if (spool_bl) -mptcp_backlog_spooled (sk, moved, &skbs); } +if (moved) +WRITE_ONCE (msk->backlog_len, msk->backlog_len - moved);if (__test_and_clear_bit (MPTCP_CLEAN_UNA , &msk->cb_flags))__mptcp_clean_una_wakeup (sk);
Signature · 1 line
2.55.0
Paolo Abeni
maintainerPATCH v2 6/7 mptcp: avoid code duplication in __mptcp_move_skb()
In reply to Paolo AbeniAlike TCP, MPTCP handles in-sequence packets and partially overlapping ones in a very similar way: we can use the same path to handle both, avoiding some code duplication.
This will also make the next patch simpler.
--- net/mptcp/protocol.c | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-)
net/mptcp/protocol.c +13 -18
@@ -399,6 +399,7 @@ static bool __mptcp_move_skb(struct sock *sk, struct sk_buff *skb)if (MPTCP_SKB_CB (skb)->map_seq == msk->ack_seq) {/* in sequence */ +insert: msk->bytes_received += copy_len;WRITE_ONCE (msk->ack_seq, msk->ack_seq + copy_len); tail =skb_peek_tail (&sk->sk_receive_queue);
@@ -413,26 +414,20 @@ static bool __mptcp_move_skb(struct sock *sk, struct sk_buff *skb)return false; } -/* Completely old data? */ -if (!after64 (MPTCP_SKB_CB (skb)->end_seq, msk->ack_seq)) { -MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_DUPDATA ); -mptcp_drop (sk, skb); -return false; +/* Partial packet */ +if (after64 (MPTCP_SKB_CB (skb)->end_seq, msk->ack_seq)) { + copy_len =MPTCP_SKB_CB (skb)->end_seq - msk->ack_seq; +MPTCP_SKB_CB (skb)->offset += msk->ack_seq - +MPTCP_SKB_CB (skb)->map_seq; +MPTCP_SKB_CB (skb)->map_seq += msk->ack_seq - +MPTCP_SKB_CB (skb)->map_seq; + goto insert; } -/* Partial packet: map_seq < ack_seq < end_seq. -* Skip the already-acked bytes and enqueue the new data. -*/ - copy_len =MPTCP_SKB_CB (skb)->end_seq - msk->ack_seq; -MPTCP_SKB_CB (skb)->offset += msk->ack_seq -MPTCP_SKB_CB (skb)->map_seq; -MPTCP_SKB_CB (skb)->map_seq += msk->ack_seq - -MPTCP_SKB_CB (skb)->map_seq; - msk->bytes_received += copy_len; -WRITE_ONCE (msk->ack_seq, msk->ack_seq + copy_len); - -skb_set_owner_r (skb, sk); -__skb_queue_tail (&sk->sk_receive_queue, skb); -return true; +/* Completely old data */ +MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_DUPDATA ); +mptcp_drop (sk, skb); +return false; }static void mptcp_stop_rtx_timer (struct sock *sk)
Signature · 1 line
2.55.0
Paolo Abeni
maintainerPATCH v2 7/7 mptcp: implemented OoO queue pruning
In reply to Paolo AbeniWhen moving incoming skbs in the msk receive queue and the latter is above limits, prune it as needed quite alike what TCP is doing at the subflow level. The main difference relies in the stop condition:
since MPTCP does not perform collapsing, it's better off dropping the bare minimum to fit the (newer) incoming packet.
---
v<n> -> v<n+1>:
- prune only for new data
- reorganize the code to follow more closely TCP
--- net/mptcp/mib.c | 1 + net/mptcp/mib.h | 1 + net/mptcp/protocol.c | 81 ++++++++++++++++++++++++++++++++++++++------ 3 files changed, 73 insertions(+), 10 deletions(-)
net/mptcp/mib.c +1 -0
@@ -87,6 +87,7 @@ static const struct snmp_mib mptcp_snmp_list[] = {SNMP_MIB_ITEM ("WinProbe" ,MPTCP_MIB_WINPROBE ),SNMP_MIB_ITEM ("BacklogDrop" ,MPTCP_MIB_BACKLOGDROP ),SNMP_MIB_ITEM ("RcvPruned" ,MPTCP_MIB_RCVPRUNED ), + SNMP_MIB_ITEM("OFOPruned", MPTCP_MIB_OFOPRUNED), };/* mptcp_mib_alloc - allocate percpu mib counters
net/mptcp/mib.h +1 -0
@@ -90,6 +90,7 @@ enum linux_mptcp_mib_field {MPTCP_MIB_WINPROBE ,/* MPTCP-level zero window probe */ MPTCP_MIB_BACKLOGDROP ,/* Backlog over memory limit */ MPTCP_MIB_RCVPRUNED ,/* Dropped due to memory constraints */ +MPTCP_MIB_OFOPRUNED ,/* MPTCP-level OoO queue pruned */ __MPTCP_MIB_MAX };
net/mptcp/protocol.c +71 -10
102 lines not on this page · raw message
Signature · 1 line
2.55.0
Paolo Abeni
maintainerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
Quoted 89 lines · Paolo Abeni
When moving incoming skbs in the msk receive queue and the latter is above limits, prune it as needed quite alike what TCP is doing at the subflow level. The main difference relies in the stop condition:
since MPTCP does not perform collapsing, it's better off dropping the bare minimum to fit the (newer) incoming packet.Signed-off-by Paolo Abeni <[email protected]>Tested-by Gang Yan <[email protected]>Reviewed-by Matthieu Baerts (NGI0) <[email protected]>---
v<n> -> v<n+1>:
- prune only for new data
- reorganize the code to follow more closely TCP--- net/mptcp/mib.c | 1 + net/mptcp/mib.h | 1 + net/mptcp/protocol.c | 81 ++++++++++++++++++++++++++++++++++++++------ 3 files changed, 73 insertions(+), 10 deletions(-)net/mptcp/mib.c +1
-0@@ -87,6 +87,7 @@ static const struct snmp_mib mptcp_snmp_list[] = {SNMP_MIB_ITEM ("WinProbe" ,MPTCP_MIB_WINPROBE ),SNMP_MIB_ITEM ("BacklogDrop" ,MPTCP_MIB_BACKLOGDROP ),SNMP_MIB_ITEM ("RcvPruned" ,MPTCP_MIB_RCVPRUNED ), + SNMP_MIB_ITEM("OFOPruned", MPTCP_MIB_OFOPRUNED), };/* mptcp_mib_alloc - allocate percpu mib counters net/mptcp/mib.h +1
-0@@ -90,6 +90,7 @@ enum linux_mptcp_mib_field {MPTCP_MIB_WINPROBE ,/* MPTCP-level zero window probe */ MPTCP_MIB_BACKLOGDROP ,/* Backlog over memory limit */ MPTCP_MIB_RCVPRUNED ,/* Dropped due to memory constraints */ +MPTCP_MIB_OFOPRUNED ,/* MPTCP-level OoO queue pruned */ __MPTCP_MIB_MAX };net/mptcp/protocol.c +38
-0@@ -242,6 +242,65 @@ static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval)return false; } +/* "Inspired" from the TCP version; main difference: stop as soon as the MPTCP +* socket is under memory limit. +*/ +static void mptcp_prune_ofo_queue (struct sock *sk, +const struct sk_buff *in_skb) +{ +struct mptcp_sock *msk =mptcp_sk (sk); +struct rb_node *node, *prev; +bool pruned = false; +u64 mem; + +if (RB_EMPTY_ROOT (&msk->out_of_order_queue)) +return ; + + node = &msk->ooo_last_skb->rbnode; + +do { +struct sk_buff *skb =rb_to_skb (node); + +/* Stop pruning if the incoming skb would land in OoO tail. */ +if (after64 (MPTCP_SKB_CB (in_skb)->map_seq, +MPTCP_SKB_CB (skb)->map_seq)) +break ; + + pruned = true; + prev =rb_prev (node); +rb_erase (node, &msk->out_of_order_queue); +mptcp_drop (sk, skb); + msk->ooo_last_skb =rb_to_skb (prev); + + mem = (unsigned int )sk_rmem_alloc_get (sk); +if (mem <= sk->sk_rcvbuf) +break ; + + node = prev; + }while (node); + +if (pruned)
net/mptcp/protocol.c static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval) · line 292
Quoted 10 lines
net/mptcp/protocol.c +10
-0+MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_OFOPRUNED ); +} + +/* The stack can't drop packets for fallback socket at the msk level, or the +* stream will break. +*/ +static bool mptcp_can_ingest (const struct sock *sk) +{ +return unlikely (sk_rmem_alloc_get (sk) <=READ_ONCE (sk->sk_rcvbuf)) || +__mptcp_check_fallback (mptcp_sk (sk));
The above should obviously be: 'likely(...)'
@Matttbe: please LMK if you prefer a repost or you could adjust that while applying to the export branch.
/P
Matthieu Baerts
maintainerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
Quoted 102 lines · Paolo Abeni
Quoted 89 lines · Paolo Abeni
When moving incoming skbs in the msk receive queue and the latter is above limits, prune it as needed quite alike what TCP is doing at the subflow level. The main difference relies in the stop condition:
since MPTCP does not perform collapsing, it's better off dropping the bare minimum to fit the (newer) incoming packet.Signed-off-by Paolo Abeni <[email protected]>Tested-by Gang Yan <[email protected]>Reviewed-by Matthieu Baerts (NGI0) <[email protected]>---
v<n> -> v<n+1>:
- prune only for new data
- reorganize the code to follow more closely TCP--- net/mptcp/mib.c | 1 + net/mptcp/mib.h | 1 + net/mptcp/protocol.c | 81 ++++++++++++++++++++++++++++++++++++++------ 3 files changed, 73 insertions(+), 10 deletions(-)net/mptcp/mib.c +1
-0@@ -87,6 +87,7 @@ static const struct snmp_mib mptcp_snmp_list[] = {SNMP_MIB_ITEM ("WinProbe" ,MPTCP_MIB_WINPROBE ),SNMP_MIB_ITEM ("BacklogDrop" ,MPTCP_MIB_BACKLOGDROP ),SNMP_MIB_ITEM ("RcvPruned" ,MPTCP_MIB_RCVPRUNED ), + SNMP_MIB_ITEM("OFOPruned", MPTCP_MIB_OFOPRUNED), };/* mptcp_mib_alloc - allocate percpu mib counters net/mptcp/mib.h +1
-0@@ -90,6 +90,7 @@ enum linux_mptcp_mib_field {MPTCP_MIB_WINPROBE ,/* MPTCP-level zero window probe */ MPTCP_MIB_BACKLOGDROP ,/* Backlog over memory limit */ MPTCP_MIB_RCVPRUNED ,/* Dropped due to memory constraints */ +MPTCP_MIB_OFOPRUNED ,/* MPTCP-level OoO queue pruned */ __MPTCP_MIB_MAX };net/mptcp/protocol.c +38
-0@@ -242,6 +242,65 @@ static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval)return false; } +/* "Inspired" from the TCP version; main difference: stop as soon as the MPTCP +* socket is under memory limit. +*/ +static void mptcp_prune_ofo_queue (struct sock *sk, +const struct sk_buff *in_skb) +{ +struct mptcp_sock *msk =mptcp_sk (sk); +struct rb_node *node, *prev; +bool pruned = false; +u64 mem; + +if (RB_EMPTY_ROOT (&msk->out_of_order_queue)) +return ; + + node = &msk->ooo_last_skb->rbnode; + +do { +struct sk_buff *skb =rb_to_skb (node); + +/* Stop pruning if the incoming skb would land in OoO tail. */ +if (after64 (MPTCP_SKB_CB (in_skb)->map_seq, +MPTCP_SKB_CB (skb)->map_seq)) +break ; + + pruned = true; + prev =rb_prev (node); +rb_erase (node, &msk->out_of_order_queue); +mptcp_drop (sk, skb); + msk->ooo_last_skb =rb_to_skb (prev); + + mem = (unsigned int )sk_rmem_alloc_get (sk); +if (mem <= sk->sk_rcvbuf) +break ; + + node = prev; + }while (node); + +if (pruned)net/mptcp/protocol.c static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval) · line 292
Quoted 10 lines
net/mptcp/protocol.c +10
-0+MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_OFOPRUNED ); +} + +/* The stack can't drop packets for fallback socket at the msk level, or the +* stream will break. +*/ +static bool mptcp_can_ingest (const struct sock *sk) +{ +return unlikely (sk_rmem_alloc_get (sk) <=READ_ONCE (sk->sk_rcvbuf)) || +__mptcp_check_fallback (mptcp_sk (sk));The above should obviously be: 'likely(...)'
Quoted 2 lines
@Matttbe: please LMK if you prefer a repost or you could adjust that while applying to the export branch.
No problem, I can adjust them when applying them (if there are no other big modifications required, but I guess no).
Cheers,
Matt
Signature · 1 line
Sponsored by the NGI0 Core fund.
Geliang Tang
reviewerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
Hi Matt,
Quoted 117 lines · Matthieu Baerts
Quoted 116 lines · Paolo Abeni
Quoted 112 lines · Paolo Abeni
When moving incoming skbs in the msk receive queue and the latter is above limits, prune it as needed quite alike what TCP is doing at the subflow level. The main difference relies in the stop condition:
since MPTCP does not perform collapsing, it's better off dropping the
bare minimum to fit the (newer) incoming packet.Signed-off-by Paolo Abeni <[email protected]>Tested-by Gang Yan <[email protected]>Reviewed-by Matthieu Baerts (NGI0) <[email protected]>---
v<n> -> v<n+1>:
- prune only for new data
- reorganize the code to follow more closely TCP
---
net/mptcp/mib.c | 1 + net/mptcp/mib.h | 1 +net/mptcp/protocol.c| 81
++++++++++++++++++++++++++++++++++++++------3 files changed, 73 insertions(+), 10 deletions(-)net/mptcp/mib.c +1
-0@@ -87,6 +87,7 @@ static const struct snmp_mib mptcp_snmp_list[] = { SNMP_MIB_ITEM("WinProbe", MPTCP_MIB_WINPROBE), SNMP_MIB_ITEM("BacklogDrop", MPTCP_MIB_BACKLOGDROP), SNMP_MIB_ITEM("RcvPruned", MPTCP_MIB_RCVPRUNED), +SNMP_MIB_ITEM ("OFOPruned" ,MPTCP_MIB_OFOPRUNED ), };
/*mptcp_mib_alloc- allocate percpu mib countersnet/mptcp/mib.h +0
-0@@ -90,6 +90,7 @@ enum linux_mptcp_mib_field {
MPTCP_MIB_WINPROBE, /* MPTCP-level zero
window probe */
MPTCP_MIB_BACKLOGDROP, /* Backlog over memory
limit */
MPTCP_MIB_RCVPRUNED, /* Dropped due to memory
constraints */net/mptcp/mib.h +1
-0+ MPTCP_MIB_OFOPRUNED, /* MPTCP-level OoO queuepruned */
__MPTCP_MIB_MAX
};net/mptcp/protocol.c +0
-0@@ -242,6 +242,65 @@ static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval) return false; }
+/* "Inspired" from the TCP version; main difference: stop as soon as the MPTCP
+ * socket is under memory limit.
+ */net/mptcp/protocol.c +17
-0+static void mptcp_prune_ofo_queue (struct sock *sk, + const struct sk_buff *in_skb) +{ +struct mptcp_sock *msk =mptcp_sk (sk); +struct rb_node *node, *prev; +bool pruned = false; +u64 mem; + +if (RB_EMPTY_ROOT (&msk->out_of_order_queue)) +return ; + + node = &msk->ooo_last_skb->rbnode; + + do { + struct sk_buff *skb = rb_to_skb(node); + + /* Stop pruning if the incoming skb would landin OoO tail. */
net/mptcp/protocol.c +19
-0+if (after64 (MPTCP_SKB_CB (in_skb)->map_seq, + MPTCP_SKB_CB(skb)->map_seq)) +break ; + + pruned = true; + prev =rb_prev (node); +rb_erase (node, &msk->out_of_order_queue); +mptcp_drop (sk, skb); + msk->ooo_last_skb =rb_to_skb (prev); + + mem = (unsigned int )sk_rmem_alloc_get (sk); +if (mem <= sk->sk_rcvbuf) +break ; + + node = prev; + }while (node); + +if (pruned) + MPTCP_INC_STATS(sock_net(sk),
MPTCP_MIB_OFOPRUNED);net/mptcp/protocol.c +3
-0+} + +/* The stack can't drop packets for fallback socket at the msk level, or the
+ * stream will break.
+ */net/mptcp/protocol.c +3
-0+static bool mptcp_can_ingest(const struct sock *sk) +{ + return unlikely(sk_rmem_alloc_get(sk) <= READ_ONCE(sk-Quoted 1 line
sk_rcvbuf)) ||net/mptcp/protocol.c static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval) · line 292
Quoted 1 line
net/mptcp/protocol.c +1
-0+__mptcp_check_fallback (mptcp_sk (sk));The above should obviously be: 'likely(...)'
Quoted 6 lines
Quoted 3 lines
@Matttbe: please LMK if you prefer a repost or you could adjust that
while applying to the export branch.No problem, I can adjust them when applying them (if there are no other
big modifications required, but I guess no).
It seems you forgot to update this on the export branch.
Thanks,
-Geliang
Quoted 3 lines
Cheers,
Matt
Matthieu Baerts
maintainerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
Hi Geliang, Paolo,
Quoted 10 lines · Geliang Tang
Quoted 9 lines · Matthieu Baerts
Quoted 8 lines · Paolo Abeni
Quoted 7 lines · Paolo Abeni
When moving incoming skbs in the msk receive queue and the latter is above limits, prune it as needed quite alike what TCP is doing at the subflow level. The main difference relies in the stop condition:
since MPTCP does not perform collapsing, it's better off dropping the
bare minimum to fit the (newer) incoming packet.
(...)
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
net/mptcp/protocol.c static bool mptcp_rcvbuf_grow(struct sock *sk, u32 newval) · line 292
Quoted 9 lines
+/* The stack can't drop packets for fallback socket at the msk level, or the
+ * stream will break.
+ */net/mptcp/protocol.c +3
-0+static bool mptcp_can_ingest(const struct sock *sk) +{ + return unlikely(sk_rmem_alloc_get(sk) <= READ_ONCE(sk-Quoted 1 line
sk_rcvbuf)) ||net/mptcp/protocol.c +1
-0+__mptcp_check_fallback (mptcp_sk (sk));The above should obviously be: 'likely(...)'
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
@Matttbe: please LMK if you prefer a repost or you could adjust that
while applying to the export branch.No problem, I can adjust them when applying them (if there are no other
big modifications required, but I guess no).It seems you forgot to update this on the export branch.
Arf, indeed I did, my bad... good catch!
I just fixed it in our tree (and the alignment of the next line), but I will wait for Paolo's feedback to know if he judges that a new version is needed for upstream, or if that can be done in follow-up patches.
Maybe only the comments on the last patch actually requires modifications? (but maybe can be done in a follow-up patch?)
Cheers,
Matt
Signature · 1 line
Sponsored by the NGI0 Core fund.
Paolo Abeni
maintainerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
Quoted 5 lines · Matthieu Baerts
Quoted 1 line · Geliang Tang
It seems you forgot to update this on the export branch.
Arf, indeed I did, my bad... good catch!
Quoted 8 lines
I just fixed it in our tree (and the alignment of the next line), but I will wait for Paolo's feedback to know if he judges that a new version is needed for upstream, or if that can be done in follow-up patches.
Maybe only the comments on the last patch actually requires modifications? (but maybe can be done in a follow-up patch?)
I commented on the netdev thread. I would like to opt for the follow-up strategy. I confirm opus-5 is too good for me. I'll try to cook and send the series ASAP, but I suggest not rushing them to netdev, can go via the net tree after the PR.
/P
Paolo Abeni
maintainerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
In reply to Matthieu BaertsQuoted 8 lines · Matthieu Baerts
Quoted 1 line · Geliang Tang
It seems you forgot to update this on the export branch.
Arf, indeed I did, my bad... good catch!
I just fixed it in our tree (and the alignment of the next line), but I will wait for Paolo's feedback to know if he judges that a new version is needed for upstream, or if that can be done in follow-up patches.
Could you please revert the export branch to match upstream, so I can send follow-up patches?
Thanks!
Paolo
Matthieu Baerts
maintainerRe: [PATCH v2 mptcp-next 7/7] mptcp: implemented OoO queue pruning
Hi Paolo,
Quoted 11 lines · Paolo Abeni
Quoted 8 lines · Matthieu Baerts
Quoted 1 line · Geliang Tang
It seems you forgot to update this on the export branch.
Arf, indeed I did, my bad... good catch!
I just fixed it in our tree (and the alignment of the next line), but I will wait for Paolo's feedback to know if he judges that a new version is needed for upstream, or if that can be done in follow-up patches.
Could you please revert the export branch to match upstream, so I can send follow-up patches?
Sorry, I wasn't available this morning, and the auto-sync job failed because it got confused by the "Can't drop packets for fallback socket this late, or the stream" chunk introduced in patch 4/7, but dropped in 7/7 :)
Just fixed.
Cheers,
Matt
Signature · 1 line
Sponsored by the NGI0 Core fund.
Hi Paolo,
Quoted 1 line · Paolo Abeni
This *should* address opus-5 feedback, as observed upstream.
Thank you for the new version, and your patience with AI reviews! Hopefully opus-5 will not be even more picky!
This new version looks good to me:
New patches for t/upstream:
- b03efee5f28b: mptcp: move the retrans loop to a separate helper
- 23b698046768: mptcp: move the stale logic out of retrans scheduler
- 1a2614f8a410: mptcp: let the retrans scheduler do its job
- 568cc4fa11f2: mptcp: explicitly drop over memory limits
- c29573ac23e6: mptcp: enforce hard limit on backlog flushing
- e76d982954d3: mptcp: avoid code duplication in __mptcp_move_skb()
- b746103fb892: mptcp: implemented OoO queue pruning
- Results: 775addc43266..7bf94a8339a9 (export)
(+ Geliang's fixes for the BPF selftests)
Tests are now in progress:
Cheers,
Matt
Signature · 1 line
Sponsored by the NGI0 Core fund.