mptcp: support for queuing data at mptcp-level
Subsystems (3)
Paolo Abeni
cover mptcp: support for queuing data at mptcp-level
This is necessary to cope correctly with large sendbuffer (larger then snd wnd) while respecting the MPTCP level snd window.
A major rework of both xmit and shudown path is required to support this feature (patches 6 and 7). To try to keep the related patches as small as possible, a bunch of new helpers is created by patches 1-5.
Note that patch 3 can stand for it's own merit and possibly be upstreamed soon.
Finally patch 8 uses the MPTCP equivalent of tcp_push_pending_frames(), to spool queued data ad MPTCP level, as soon as the windows allow that.
This iteration includes all the fixes mentioned in the ML on top of the RFC, plus some mores - all noted in the individual patches changelog. It also includes the sndwnd patch from Florian, rebased.
Still not bugs free - I see some not-so-frequent timeouts in mptcp_connect.sh tests and tput in simult_xmit tests are less stable, but should be notably better than previous iteration. I suggest considering for merge on the export branch.
Not strictily related to this series: we currently send DATA_FIN ack only once
- the behaviour is not change here. If that is dropped, we will never retransmit, and the peer will be stuck.
Florian Westphal (1):
mptcp: keep track of advertised windows right edge
Paolo Abeni (8):
tcp: factor out __tcp_close() helper
mptcp: introduce mptcp_schedule_work
mptcp: reduce the arguments of mptcp_sendmsg_frag
mptcp: add accounting for pending data
mptcp: introduce MPTCP snd_nxt
mptcp: refactor shutdown and close
mptcp: move page frag allocation in mptcp_sendmsg()
mptcp: try to push pending data on snd una updates
include/net/tcp.h | 1 + net/ipv4/tcp.c | 9 +- net/mptcp/options.c | 24 +- net/mptcp/pm.c | 4 +- net/mptcp/protocol.c | 783 +++++++++++++++++++++++++------------------ net/mptcp/protocol.h | 67 +++- net/mptcp/subflow.c | 21 +- 7 files changed, 560 insertions(+), 349 deletions(-)
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 1/9 tcp: factor out __tcp_close() helper
unlocked version of protocol level close, will be used by MPTCP to allow decouple orphaning and subflow level close.
--- include/net/tcp.h | 1 + net/ipv4/tcp.c | 9 +++++++-- 2 files changed, 8 insertions(+), 2 deletions(-)
include/net/tcp.h +1 -0
@@ -392,6 +392,7 @@ void tcp_update_metrics(struct sock *sk);void tcp_init_metrics (struct sock *sk);void tcp_metrics_init (void );bool tcp_peer_is_proven (struct request_sock *req,struct dst_entry *dst); +void __tcp_close (struct sock *sk,long timeout);void tcp_close (struct sock *sk,long timeout);void tcp_init_sock (struct sock *sk);void tcp_init_transfer (struct sock *sk,int bpf_op,struct sk_buff *skb);
net/ipv4/tcp.c +7 -2
@@ -2404,13 +2404,12 @@ bool tcp_check_oom(struct sock *sk, int shift)return too_many_orphans || out_of_socket_memory; } -void tcp_close (struct sock *sk,long timeout) +void __tcp_close (struct sock *sk,long timeout) {struct sk_buff *skb;int data_was_unread =0 ;int state; -lock_sock (sk); sk->sk_shutdown =SHUTDOWN_MASK ;if (sk->sk_state ==TCP_LISTEN ) {
@@ -2574,6 +2573,12 @@ void tcp_close(struct sock *sk, long timeout) out:bh_unlock_sock (sk);local_bh_enable (); +} + +void tcp_close (struct sock *sk,long timeout) +{ +lock_sock (sk); +__tcp_close (sk, timeout);release_sock (sk);sock_put (sk); }
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 2/9 mptcp: introduce mptcp_schedule_work
In reply to Paolo Abeniremove some of code duplications an allow preventing rescheduling on close.
--- net/mptcp/pm.c | 4 +--- net/mptcp/protocol.c | 33 +++++++++++++++++++-------------- net/mptcp/protocol.h | 1 + 3 files changed, 21 insertions(+), 17 deletions(-)
net/mptcp/pm.c +1 -3
@@ -89,9 +89,7 @@ static bool mptcp_pm_schedule_work(struct mptcp_sock *msk,return false; msk->pm.status |=BIT (new_status); -if (schedule_work (&msk->work)) -sock_hold ((struct sock *)msk); -return true; +return mptcp_schedule_work ((struct sock *)msk); }void mptcp_pm_fully_established (struct mptcp_sock *msk)
net/mptcp/protocol.c +19 -14
@@ -601,9 +601,8 @@ static bool move_skbs_to_msk(struct mptcp_sock *msk, struct sock *ssk)* this is not a good place to change state. Let the workqueue * do it. */ -if (mptcp_pending_data_fin (sk,NULL ) && -schedule_work (&msk->work)) -sock_hold (sk); +if (mptcp_pending_data_fin (sk,NULL )) +mptcp_schedule_work (sk); }spin_unlock_bh (&sk->sk_lock.slock);
@@ -680,23 +679,29 @@ static void mptcp_reset_timer(struct sock *sk)sk_reset_timer (sk, &icsk->icsk_retransmit_timer, jiffies + tout); } +bool mptcp_schedule_work (struct sock *sk) +{ +if (inet_sk_state_load (sk) !=TCP_CLOSE && +schedule_work (&mptcp_sk (sk)->work)) { +sock_hold (sk); +return true; + } +return false; +} +void mptcp_data_acked (struct sock *sk) {mptcp_reset_timer (sk);if ((!test_bit (MPTCP_SEND_SPACE , &mptcp_sk (sk)->flags) || - (inet_sk_state_load (sk) !=TCP_ESTABLISHED )) && -schedule_work (&mptcp_sk (sk)->work)) -sock_hold (sk); + (inet_sk_state_load (sk) !=TCP_ESTABLISHED ))) +mptcp_schedule_work (sk); }void mptcp_subflow_eof (struct sock *sk) { -struct mptcp_sock *msk =mptcp_sk (sk); - -if (!test_and_set_bit (MPTCP_WORK_EOF , &msk->flags) && -schedule_work (&msk->work)) -sock_hold (sk); +if (!test_and_set_bit (MPTCP_WORK_EOF , &mptcp_sk (sk)->flags)) +mptcp_schedule_work (sk); }static void mptcp_check_for_eof (struct mptcp_sock *msk)
@@ -1610,8 +1615,7 @@ static void mptcp_retransmit_handler(struct sock *sk)mptcp_stop_timer (sk); }else {set_bit (MPTCP_WORK_RTX , &msk->flags); -if (schedule_work (&msk->work)) -sock_hold (sk); +mptcp_schedule_work (sk); } }
@@ -2312,7 +2316,8 @@ static void mptcp_release_cb(struct sock *sk)struct sock *ssk; ssk =mptcp_subflow_recv_lookup (msk); -if (!ssk || !schedule_work (&msk->work)) +if (!ssk || sk->sk_state ==TCP_CLOSE || + !schedule_work (&msk->work))__sock_put (sk); }
net/mptcp/protocol.h +1 -0
@@ -405,6 +405,7 @@ static inline bool mptcp_is_fully_established(struct sock *sk)void mptcp_rcv_space_init (struct mptcp_sock *msk,const struct sock *ssk);void mptcp_data_ready (struct sock *sk,struct sock *ssk);bool mptcp_finish_join (struct sock *sk); +bool mptcp_schedule_work (struct sock *sk);void mptcp_data_acked (struct sock *sk);void mptcp_subflow_eof (struct sock *sk);bool mptcp_update_rcv_data_fin (struct mptcp_sock *msk,u64 data_fin_seq);
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 3/9 mptcp: reduce the arguments of mptcp_sendmsg_frag
In reply to Paolo AbeniThe current argument list is pretty long and quite unreadable, move many of them into a specific struct. Later patches will add more stuff to such struct.
Additionally drop the 'timeo' argument, now unused.
---
v8 -> v9:
- cleanup mptcp_sendmsg_info init in mptcp_worker
--- net/mptcp/protocol.c | 53 ++++++++++++++++++++++++-------------------- 1 file changed, 29 insertions(+), 24 deletions(-)
net/mptcp/protocol.c +29 -24
@@ -892,12 +892,16 @@ mptcp_carve_data_frag(const struct mptcp_sock *msk, struct page_frag *pfrag,return dfrag; } +struct mptcp_sendmsg_info { +int mss_now; +int size_goal; +}; +static int mptcp_sendmsg_frag (struct sock *sk,struct sock *ssk,struct msghdr *msg,struct mptcp_data_frag *dfrag, -long *timeo,int *pmss_now, -int *ps_goal) +struct mptcp_sendmsg_info *info) { -int mss_now, avail_size, size_goal, offset, ret, frag_truesize =0 ; +int avail_size, offset, ret, frag_truesize =0 ;bool dfrag_collapsed, can_collapse = false;struct mptcp_sock *msk =mptcp_sk (sk);struct mptcp_ext *mpext =NULL ;
@@ -923,10 +927,8 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk, }/* compute copy limit */ - mss_now =tcp_send_mss (ssk, &size_goal, msg->msg_flags); - *pmss_now = mss_now; - *ps_goal = size_goal; - avail_size = size_goal; + info->mss_now =tcp_send_mss (ssk, &info->size_goal, msg->msg_flags); + avail_size = info->size_goal; skb =tcp_write_queue_tail (ssk);if (skb) { mpext =skb_ext_find (skb,SKB_EXT_MPTCP );
@@ -937,12 +939,12 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk,* queue management operation, to avoid breaking the ext <-> * SSN association set here */ - can_collapse = (size_goal - skb->len >0 ) && + can_collapse = (info->size_goal - skb->len >0 ) &&mptcp_skb_can_collapse_to (*write_seq, skb, mpext);if (!can_collapse)TCP_SKB_CB (skb)->eor =1 ;else - avail_size = size_goal - skb->len; + avail_size = info->size_goal - skb->len; }if (!retransmission) {
@@ -1174,11 +1176,15 @@ static void ssk_check_wmem(struct mptcp_sock *msk)static int mptcp_sendmsg (struct sock *sk,struct msghdr *msg,size_t len) { -int mss_now =0 , size_goal =0 , ret =0 ;struct mptcp_sock *msk =mptcp_sk (sk); +struct mptcp_sendmsg_info info = { + .mss_now =0 , + .size_goal =0 , + };struct page_frag *pfrag;size_t copied =0 ;struct sock *ssk; +int ret =0 ;u32 sndbuf;bool tx_ok;long timeo;
@@ -1247,8 +1253,7 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)lock_sock (ssk); tx_ok =msg_data_left (msg);while (tx_ok) { - ret =mptcp_sendmsg_frag (sk, ssk, msg,NULL , &timeo, &mss_now, - &size_goal); + ret =mptcp_sendmsg_frag (sk, ssk, msg,NULL , &info);if (ret <0 ) {if (ret == -EAGAIN && timeo >0 ) {mptcp_set_timeout (sk, ssk);
@@ -1271,8 +1276,8 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)if (!sk_stream_memory_free (ssk) || !mptcp_page_frag_refill (ssk, pfrag) || !mptcp_ext_cache_refill (msk)) { -tcp_push (ssk, msg->msg_flags, mss_now, -tcp_sk (ssk)->nonagle, size_goal); +tcp_push (ssk, msg->msg_flags, info.mss_now, +tcp_sk (ssk)->nonagle, info.size_goal);mptcp_set_timeout (sk, ssk);release_sock (ssk); goto restart;
@@ -1292,8 +1297,8 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)* limits before we send more data. */ if (unlikely (!sk_stream_memory_free (sk))) { -tcp_push (ssk, msg->msg_flags, mss_now, -tcp_sk (ssk)->nonagle, size_goal); +tcp_push (ssk, msg->msg_flags, info.mss_now, +tcp_sk (ssk)->nonagle, info.size_goal);mptcp_clean_una (sk);if (!sk_stream_memory_free (sk)) {/* can't send more for now, need to wait for
@@ -1310,8 +1315,8 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)mptcp_set_timeout (sk, ssk);if (copied) { -tcp_push (ssk, msg->msg_flags, mss_now,tcp_sk (ssk)->nonagle, - size_goal); +tcp_push (ssk, msg->msg_flags, info.mss_now, +tcp_sk (ssk)->nonagle, info.size_goal);/* start the timer, if it's not pending */ if (!mptcp_timer_pending (sk))
@@ -1736,14 +1741,15 @@ static void mptcp_worker(struct work_struct *work) { struct mptcp_sock *msk = container_of(work, struct mptcp_sock, work);struct sock *ssk, *sk = &msk->sk.icsk_inet.sk; -int orig_len, orig_offset, mss_now =0 , size_goal =0 ; +struct mptcp_sendmsg_info info = {};struct mptcp_data_frag *dfrag; +int orig_len, orig_offset;u64 orig_write_seq;size_t copied =0 ;struct msghdr msg = { .msg_flags =MSG_DONTWAIT , }; -long timeo =0 ; +int ret;lock_sock (sk);mptcp_clean_una_wakeup (sk);
@@ -1779,8 +1785,7 @@ static void mptcp_worker(struct work_struct *work) orig_offset = dfrag->offset; orig_write_seq = dfrag->data_seq;while (dfrag->data_len >0 ) { -int ret =mptcp_sendmsg_frag (sk, ssk, &msg, dfrag, &timeo, - &mss_now, &size_goal); + ret =mptcp_sendmsg_frag (sk, ssk, &msg, dfrag, &info);if (ret <0 )break ;
@@ -1793,8 +1798,8 @@ static void mptcp_worker(struct work_struct *work)break ; }if (copied) -tcp_push (ssk, msg.msg_flags, mss_now,tcp_sk (ssk)->nonagle, - size_goal); +tcp_push (ssk,0 , info.mss_now,tcp_sk (ssk)->nonagle, + info.size_goal); dfrag->data_seq = orig_write_seq; dfrag->offset = orig_offset;
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 4/9 mptcp: add accounting for pending data
In reply to Paolo AbeniPreparation patch to track the data pending in the msk write queue. No functional change introduced here
--- net/mptcp/protocol.c | 1 + net/mptcp/protocol.h | 38 +++++++++++++++++++++++++++++++++++--- 2 files changed, 36 insertions(+), 3 deletions(-)
net/mptcp/protocol.c +1 -0
@@ -1829,6 +1829,7 @@ static int __mptcp_init_sock(struct sock *sk)__set_bit (MPTCP_SEND_SPACE , &msk->flags);INIT_WORK (&msk->work, mptcp_worker); msk->out_of_order_queue =RB_ROOT ; + msk->first_pending =NULL ; msk->first =NULL ;inet_csk (sk)->icsk_sync_mss = mptcp_sync_mss;
net/mptcp/protocol.h +35 -3
@@ -186,9 +186,10 @@ struct mptcp_pm_data {struct mptcp_data_frag {struct list_head list;u64 data_seq; -int data_len; -int offset; -int overhead; +u16 data_len; +u16 offset; +u16 overhead; +u16 already_sent;struct page *page; };
@@ -217,6 +218,7 @@ struct mptcp_sock {struct rb_root out_of_order_queue;struct list_head conn_list;struct list_head rtx_queue; +struct mptcp_data_frag *first_pending;struct list_head join_list;struct skb_ext *cached_ext;/* for the next sendmsg */ struct socket *subflow;/* outgoing connect/listener/!mp_capable */
@@ -238,6 +240,36 @@ static inline struct mptcp_sock *mptcp_sk(const struct sock *sk)return (struct mptcp_sock *)sk; } +static inline struct mptcp_data_frag *mptcp_send_head (const struct sock *sk) +{ +const struct mptcp_sock *msk =mptcp_sk (sk); + +return READ_ONCE (msk->first_pending); +} + +static inline struct mptcp_data_frag *mptcp_send_next (struct sock *sk) +{ +struct mptcp_sock *msk =mptcp_sk (sk); +struct mptcp_data_frag *cur; + + cur = msk->first_pending; +return list_is_last (&cur->list, &msk->rtx_queue) ?NULL : +list_next_entry (cur, list); +} + +static inline struct mptcp_data_frag *mptcp_pending_tail (const struct sock *sk) +{ +struct mptcp_sock *msk =mptcp_sk (sk); + +if (!msk->first_pending) +return NULL ; + +if (WARN_ON_ONCE (list_empty (&msk->rtx_queue))) +return NULL ; + + return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list); +} +static inline struct mptcp_data_frag *mptcp_rtx_tail (const struct sock *sk) {struct mptcp_sock *msk =mptcp_sk (sk);
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 5/9 mptcp: introduce MPTCP snd_nxt
In reply to Paolo AbeniTrack the next MPTCP sequence numer used on xmit,
currently always equal to write_next.
Signed-of-by: Paolo Abeni <pabeni(a)redhat.com>
--- net/mptcp/options.c | 4 ++-- net/mptcp/protocol.c | 7 +++++-- net/mptcp/protocol.h | 17 +++++++++-------- 3 files changed, 16 insertions(+), 12 deletions(-)
net/mptcp/options.c +2 -2
@@ -794,7 +794,7 @@ static void update_una(struct mptcp_sock *msk, struct mptcp_options_received *mp_opt) {u64 new_snd_una, snd_una, old_snd_una =atomic64_read (&msk->snd_una); -u64 write_seq =READ_ONCE (msk->write_seq); +u64 snd_nxt =READ_ONCE (msk->snd_nxt);/* avoid ack expansion on update conflict, to reduce the risk of * wrongly expanding to a future ack sequence number, which is way
@@ -803,7 +803,7 @@ static void update_una(struct mptcp_sock *msk, new_snd_una =expand_ack (old_snd_una, mp_opt->data_ack, mp_opt->ack64);/* ACK for data not even sent yet? Ignore. */ -if (after64 (new_snd_una, write_seq)) +if (after64 (new_snd_una, snd_nxt)) new_snd_una = old_snd_una;while (after64 (new_snd_una, old_snd_una)) {
net/mptcp/protocol.c +5 -2
@@ -812,7 +812,7 @@ static void mptcp_clean_una(struct sock *sk)* plain TCP */ if (__mptcp_check_fallback (msk)) -atomic64_set (&msk->snd_una, msk->write_seq); +atomic64_set (&msk->snd_una, msk->snd_nxt); snd_una =atomic64_read (&msk->snd_una);list_for_each_entry_safe (dfrag, dtmp, &msk->rtx_queue, list) {
@@ -1325,6 +1325,7 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)release_sock (ssk); out: + msk->snd_nxt = msk->write_seq;ssk_check_wmem (msk);release_sock (sk);return copied ? : ret;
@@ -1616,7 +1617,7 @@ static void mptcp_retransmit_handler(struct sock *sk) {struct mptcp_sock *msk =mptcp_sk (sk); -if (atomic64_read (&msk->snd_una) ==READ_ONCE (msk->write_seq)) { +if (atomic64_read (&msk->snd_una) ==READ_ONCE (msk->snd_nxt)) {mptcp_stop_timer (sk); }else {set_bit (MPTCP_WORK_RTX , &msk->flags);
@@ -2073,6 +2074,7 @@ struct sock *mptcp_sk_clone(const struct sock *sk,WRITE_ONCE (msk->fully_established, false); msk->write_seq = subflow_req->idsn +1 ; + msk->snd_nxt = msk->write_seq;atomic64_set (&msk->snd_una, msk->write_seq);if (mp_opt->mp_capable) { msk->can_ack = true;
@@ -2384,6 +2386,7 @@ void mptcp_finish_connect(struct sock *ssk)WRITE_ONCE (msk->remote_key, subflow->remote_key);WRITE_ONCE (msk->local_key, subflow->local_key);WRITE_ONCE (msk->write_seq, subflow->idsn +1 ); +WRITE_ONCE (msk->snd_nxt, msk->write_seq);WRITE_ONCE (msk->ack_seq, ack_seq);WRITE_ONCE (msk->can_ack,1 );atomic64_set (&msk->snd_una, msk->write_seq);
net/mptcp/protocol.h +9 -8
@@ -91,6 +91,13 @@#define MPTCP_WORK_EOF 3#define MPTCP_FALLBACK_DONE 4 +static inline bool before64 (__u64 seq1,__u64 seq2) +{ +return (__s64)(seq1 - seq2) <0 ; +} + +#define after64 (seq2, seq1) before64(seq1, seq2) +struct mptcp_options_received {u64 sndr_key;u64 rcvr_key;
@@ -200,6 +207,7 @@ struct mptcp_sock {u64 local_key;u64 remote_key;u64 write_seq; +u64 snd_nxt;u64 ack_seq;u64 rcv_data_fin_seq;struct sock *last_snd;
@@ -274,7 +282,7 @@ static inline struct mptcp_data_frag *mptcp_rtx_tail(const struct sock *sk) {struct mptcp_sock *msk =mptcp_sk (sk); -if (list_empty (&msk->rtx_queue)) +if (!before64 (msk->snd_nxt,atomic64_read (&msk->snd_una)))return NULL ; return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list);
@@ -524,13 +532,6 @@ static inline struct mptcp_ext *mptcp_get_ext(struct sk_buff *skb)return (struct mptcp_ext *)skb_ext_find (skb,SKB_EXT_MPTCP ); } -static inline bool before64 (__u64 seq1,__u64 seq2) -{ -return (__s64)(seq1 - seq2) <0 ; -} - -#define after64 (seq2, seq1) before64(seq1, seq2) -void mptcp_diag_subflow_init (struct tcp_ulp_ops *ops);static inline bool __mptcp_check_fallback (const struct mptcp_sock *msk)
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 6/9 mptcp: refactor shutdown and close
In reply to Paolo AbeniWe must not close the subflows before all the MPTCP level data, comprising the DATA_FIN has been acked at the MPTCP level, otherwise we could be unable to retransmit as needed.
__mptcp_wr_shutdown() shutdown is responsible to check for the correct status and close all subflows. Is called by the output path after spooling any data and at shutdown/close time.
In a similar way, __mptcp_destroy_sock() is responsible to clean-up the MPTCP level status, and is called when the msk transition to TCP_CLOSE.
The protocol level close() does not force anymore the TCP_CLOSE status, but orphan the msk socket and all the subflows. Orphaned msk sockets are forciby closed after a timeout or when all MPTCP-level data is acked.
There is a caveat about keeping the orphaned subflows around:
the TCP stack can asynchronusly call tcp_cleanup_ulp() on them via tcp_close(). To prevent accessing freed memory on later MPTCP level operations, the msk acquires a reference to each subflow socket and prevent subflow_ulp_release() from releasing the subflow context before __mptcp_destroy_sock().
The additional subflow references are released by __mptcp_done() and the async ULP release is detected checking ULP ops. If such field has been already cleared by the ULP release path, the dangling context is freed directly by __mptcp_done().
---
RFC -> v1:
- drop TCP_TIME_WAIT status, we can't use it or will foul sk_fullsock()
- refactor wr_shutdown, now split in 2 parts. DATA_FIN is sent by __mptcp_check_send_data_fin() when snd_nxt + 1 == write_seq
- drop mptcp_wr_eof(), simply check for TCP_CLOSE state - Mat
- do send data fin ack in TCP_FIN_WAIT2 state (return; -> break; in switch statement)
--- net/mptcp/options.c | 2 +- net/mptcp/protocol.c | 264 ++++++++++++++++++++++++++++++------------- net/mptcp/protocol.h | 10 +- net/mptcp/subflow.c | 21 +++- 4 files changed, 212 insertions(+), 85 deletions(-)
net/mptcp/options.c +1 -1
@@ -491,7 +491,7 @@ static bool mptcp_established_options_dss(struct sock *sk, struct sk_buff *skb,bool ret = false; mpext = skb ?mptcp_get_ext (skb) :NULL ; - snd_data_fin_enable =READ_ONCE (msk->snd_data_fin_enable); + snd_data_fin_enable =mptcp_data_fin_enabled (msk);if (!skb || (mpext && mpext->use_map) || snd_data_fin_enable) {unsigned int map_size;
net/mptcp/protocol.c +186 -78
446 lines not on this page · raw message
net/mptcp/protocol.h +9 -1
@@ -90,6 +90,7 @@#define MPTCP_WORK_RTX 2#define MPTCP_WORK_EOF 3#define MPTCP_FALLBACK_DONE 4 +#define MPTCP_WORKER_RUNNING 5static inline bool before64 (__u64 seq1,__u64 seq2) {
@@ -351,7 +352,8 @@ struct mptcp_subflow_context { backup : 1, rx_eof : 1, use_64bit_ack : 1, /* Set when we received a 64-bit DSN */ - can_ack : 1; /* only after processing the remote a key */ + can_ack : 1, /* only after processing the remote a key */ + disposable : 1; /* ctx can be free at ulp release time */enum mptcp_data_avail data_avail;u32 remote_nonce;u64 thmac;
@@ -448,6 +450,12 @@ bool mptcp_finish_join(struct sock *sk);bool mptcp_schedule_work (struct sock *sk);void mptcp_data_acked (struct sock *sk);void mptcp_subflow_eof (struct sock *sk); +static inline bool mptcp_data_fin_enabled (const struct mptcp_sock *msk) +{ +return READ_ONCE (msk->snd_data_fin_enable) && +READ_ONCE (msk->write_seq) ==READ_ONCE (msk->snd_nxt); +} +bool mptcp_update_rcv_data_fin (struct mptcp_sock *msk,u64 data_fin_seq);void mptcp_destroy_common (struct mptcp_sock *msk);
net/mptcp/subflow.c +16 -5
@@ -1104,6 +1104,7 @@ int __mptcp_subflow_connect(struct sock *sk, const struct mptcp_addr_info *loc,if (err && err != -EINPROGRESS ) goto failed; +sock_hold (ssk);spin_lock_bh (&msk->join_list_lock);list_add_tail (&subflow->node, &msk->join_list);spin_unlock_bh (&msk->join_list_lock);
@@ -1111,6 +1112,7 @@ int __mptcp_subflow_connect(struct sock *sk, const struct mptcp_addr_info *loc,return err; failed: + subflow->disposable =1 ;sock_release (sf);return err; }
@@ -1303,17 +1305,26 @@ static int subflow_ulp_init(struct sock *sk)return err; } -static void subflow_ulp_release (struct sock *sk) +static void subflow_ulp_release (struct sock *ssk) { -struct mptcp_subflow_context *ctx =mptcp_subflow_ctx (sk); +struct mptcp_subflow_context *ctx =mptcp_subflow_ctx (ssk); +bool release = true; +struct sock *sk;if (!ctx)return ; -if (ctx->conn) -sock_put (ctx->conn); + sk = ctx->conn; +if (sk) { +/* if the msk has been orphaned, keep the ctx +* alive, will be freed by mptcp_done() +*/ + release = ctx->disposable; +sock_put (sk); + } -kfree_rcu (ctx, rcu); +if (release) +kfree_rcu (ctx, rcu); } static void subflow_ulp_clone(const struct request_sock *req,
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 7/9 mptcp: move page frag allocation in mptcp_sendmsg()
In reply to Paolo Abenimptcp_sendmsg() is refactored so that first it copies the data provided from user space into the send queue, and then tries to spool the send queue via sendmsg_frag.
There a subtle change in the mptcp level collapsing on consecutive data fragment: we now allow that only on unsent data.
The latter don't need to deal with msghdr data anymore and can be simplified in a relevant way.
snd_nxt and write_seq are now tracked independently.
Overall this allows some relevant cleanup and will allow sending pending mptcp data on msk una update in later patch.
---
rfc -> v1:
- fix infinite loop on edge condition ret < 0 -> ret <= 0
- update with wr_shutdown changes
--- net/mptcp/protocol.c | 400 ++++++++++++++++++++----------------------- 1 file changed, 182 insertions(+), 218 deletions(-)
net/mptcp/protocol.c +182 -218
@@ -43,6 +43,7 @@ struct mptcp_skb_cb {static struct percpu_counter mptcp_sockets_allocated;static void __mptcp_destroy_sock (struct sock *sk,int timeout); +static void __mptcp_check_send_data_fin (struct sock *sk);/* If msk has an initial subflow socket, and the MP_CAPABLE handshake has not * completed yet or has failed, return the subflow socket.
@@ -784,6 +785,7 @@ static bool mptcp_frag_can_collapse_to(const struct mptcp_sock *msk, const struct mptcp_data_frag *df) {return df && pfrag->page == df->page && + pfrag->size - pfrag->offset >0 && df->data_seq + df->data_len == msk->write_seq; }
@@ -834,6 +836,8 @@ static void mptcp_clean_una(struct sock *sk)if (after64 (dfrag->data_seq + dfrag->data_len, snd_una))break ; +if (WARN_ON_ONCE (dfrag == msk->first_pending)) +break ;dfrag_clear (sk, dfrag); cleaned = true; }
@@ -842,12 +846,13 @@ static void mptcp_clean_una(struct sock *sk)if (dfrag &&after64 (snd_una, dfrag->data_seq)) {u64 delta = snd_una - dfrag->data_seq; -if (WARN_ON_ONCE (delta > dfrag->data_len)) +if (WARN_ON_ONCE (delta > dfrag->already_sent)) goto out; dfrag->data_seq += delta; dfrag->offset += delta; dfrag->data_len -= delta; + dfrag->already_sent -= delta;dfrag_uncharge (sk, delta); cleaned = true;
@@ -881,12 +886,23 @@ static void mptcp_clean_una_wakeup(struct sock *sk)*/ static bool mptcp_page_frag_refill (struct sock *sk,struct page_frag *pfrag) { +struct mptcp_subflow_context *subflow; +struct mptcp_sock *msk =mptcp_sk (sk); +bool first = true; +if (likely (skb_page_frag_refill (32U +sizeof (struct mptcp_data_frag ), pfrag, sk->sk_allocation)))return true; - sk->sk_prot->enter_memory_pressure (sk);sk_stream_moderate_sndbuf (sk); +mptcp_for_each_subflow (msk, subflow) { +struct sock *ssk =mptcp_subflow_tcp_sock (subflow); + +if (first) +tcp_enter_memory_pressure (ssk); +sk_stream_moderate_sndbuf (ssk); + first = false; + }return false; }
@@ -902,6 +918,7 @@ mptcp_carve_data_frag(const struct mptcp_sock *msk, struct page_frag *pfrag, dfrag->data_seq = msk->write_seq; dfrag->overhead = offset - orig_offset +sizeof (struct mptcp_data_frag ); dfrag->offset = offset +sizeof (struct mptcp_data_frag ); + dfrag->already_sent =0 ; dfrag->page = pfrag->page;return dfrag;
@@ -910,124 +927,59 @@ mptcp_carve_data_frag(const struct mptcp_sock *msk, struct page_frag *pfrag,struct mptcp_sendmsg_info {int mss_now;int size_goal; +u16 limit; +u16 sent; +unsigned int flags; };static int mptcp_sendmsg_frag (struct sock *sk,struct sock *ssk, -struct msghdr *msg,struct mptcp_data_frag *dfrag, +struct mptcp_data_frag *dfrag,struct mptcp_sendmsg_info *info) { -int avail_size, offset, ret, frag_truesize =0 ; -bool dfrag_collapsed, can_collapse = false; +u64 data_seq = dfrag->data_seq + info->sent;struct mptcp_sock *msk =mptcp_sk (sk);struct mptcp_ext *mpext =NULL ; -bool retransmission = !!dfrag;struct sk_buff *skb, *tail; -struct page_frag *pfrag; -struct page *page; -u64 *write_seq; +bool can_collapse = false; +int avail_size, ret;size_t psize; -/* use the mptcp page cache so that we can easily move the data -* from one substream to another, but do per subflow memory accounting -* Note: pfrag is used only !retransmission, but the compiler if -* fooled into a warning if we don't init here -*/ - pfrag =sk_page_frag (sk); -if (!retransmission) { - write_seq = &msk->write_seq; - page = pfrag->page; - }else { - write_seq = &dfrag->data_seq; - page = dfrag->page; - } +pr_debug ("msk=%p ssk=%p sending dfrag at seq=%lld len=%d already sent=%d" , + msk, ssk, dfrag->data_seq, dfrag->data_len, info->sent); -/* compute copy limit */ - info->mss_now =tcp_send_mss (ssk, &info->size_goal, msg->msg_flags); +/* compute send limit */ + info->mss_now =tcp_send_mss (ssk, &info->size_goal, info->flags); avail_size = info->size_goal; skb =tcp_write_queue_tail (ssk);if (skb) { - mpext =skb_ext_find (skb,SKB_EXT_MPTCP ); -/* Limit the write to the size available in the * current skb, if any, so that we create at most a new skb. * Explicitly tells TCP internals to avoid collapsing on later * queue management operation, to avoid breaking the ext <-> * SSN association set here */ + mpext =skb_ext_find (skb,SKB_EXT_MPTCP ); can_collapse = (info->size_goal - skb->len >0 ) && -mptcp_skb_can_collapse_to (*write_seq, skb, mpext); +mptcp_skb_can_collapse_to (data_seq, skb, mpext);if (!can_collapse)TCP_SKB_CB (skb)->eor =1 ;else avail_size = info->size_goal - skb->len; } -if (!retransmission) { -/* reuse tail pfrag, if possible, or carve a new one from the -* page allocator -*/ - dfrag =mptcp_rtx_tail (sk); - offset = pfrag->offset; - dfrag_collapsed =mptcp_frag_can_collapse_to (msk, pfrag, dfrag); -if (!dfrag_collapsed) { - dfrag =mptcp_carve_data_frag (msk, pfrag, offset); - offset = dfrag->offset; - frag_truesize = dfrag->overhead; - } - psize =min_t (size_t, pfrag->size - offset, avail_size); - -/* Copy to page */ -pr_debug ("left=%zu" ,msg_data_left (msg)); - psize =copy_page_from_iter (pfrag->page, offset, -min_t (size_t,msg_data_left (msg), - psize), - &msg->msg_iter); -pr_debug ("left=%zu" ,msg_data_left (msg)); -if (!psize) -return -EINVAL ; +if (WARN_ON_ONCE (info->sent > info->limit || + info->limit > dfrag->data_len)) +return 0 ; -if (!sk_wmem_schedule (sk, psize + dfrag->overhead)) { -iov_iter_revert (&msg->msg_iter, psize); -return -ENOMEM ; - } - }else { - offset = dfrag->offset; - psize =min_t (size_t, dfrag->data_len, avail_size); - } + psize =min_t (size_t, info->limit - info->sent, avail_size);/* tell the TCP stack to delay the push so that we can safely * access the skb after the sendpages call */ - ret =do_tcp_sendpages (ssk, page, offset, psize, - msg->msg_flags |MSG_SENDPAGE_NOTLAST |MSG_DONTWAIT ); -if (ret <=0 ) { -if (!retransmission) -iov_iter_revert (&msg->msg_iter, psize); + ret =do_tcp_sendpages (ssk, dfrag->page, dfrag->offset + info->sent, + psize, info->flags |MSG_SENDPAGE_NOTLAST |MSG_DONTWAIT ); +if (ret <=0 )return ret; - } - - frag_truesize += ret; -if (!retransmission) { -if (unlikely (ret < psize)) -iov_iter_revert (&msg->msg_iter, psize - ret); - -/* send successful, keep track of sent data for mptcp-level -* retransmission -*/ - dfrag->data_len += ret; -if (!dfrag_collapsed) { -get_page (dfrag->page); -list_add_tail (&dfrag->list, &msk->rtx_queue); -sk_wmem_queued_add (sk, frag_truesize); - }else { -sk_wmem_queued_add (sk, ret); - } - -/* charge data on mptcp rtx queue to the master socket -* Note: we charge such data both to sk and ssk -*/ - sk->sk_forward_alloc -= frag_truesize; - }/* if the tail skb extension is still the cached one, collapsing * really happened. Note: we can't check for 'same skb' as the sk_buff
@@ -1046,7 +998,7 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk, msk->cached_ext =NULL ;memset (mpext,0 ,sizeof (*mpext)); - mpext->data_seq = *write_seq; + mpext->data_seq = data_seq; mpext->subflow_seq =mptcp_subflow_ctx (ssk)->rel_write_seq; mpext->data_len = ret; mpext->use_map =1 ;
@@ -1057,11 +1009,7 @@ static int mptcp_sendmsg_frag(struct sock *sk, struct sock *ssk, mpext->dsn64); out: -if (!retransmission) - pfrag->offset += frag_truesize; -WRITE_ONCE (*write_seq, *write_seq + ret);mptcp_subflow_ctx (ssk)->rel_write_seq += ret; -return ret; }
@@ -1189,19 +1137,85 @@ static void ssk_check_wmem(struct mptcp_sock *msk)mptcp_nospace (msk); } -static int mptcp_sendmsg (struct sock *sk,struct msghdr *msg,size_t len) +static void mptcp_push_release (struct sock *sk,struct sock *ssk, +struct mptcp_sendmsg_info *info) +{ +mptcp_set_timeout (sk, ssk); +tcp_push (ssk,0 , info->mss_now,tcp_sk (ssk)->nonagle, info->size_goal); +release_sock (ssk); +} + +static void mptcp_push_pending (struct sock *sk,unsigned int flags) { +struct sock *prev_ssk =NULL , *ssk =NULL ;struct mptcp_sock *msk =mptcp_sk (sk);struct mptcp_sendmsg_info info = { - .mss_now =0 , - .size_goal =0 , + .flags = flags, }; +struct mptcp_data_frag *dfrag; +int len, copied =0 ; +u32 sndbuf; + +while ((dfrag =mptcp_send_head (sk))) { + info.sent = dfrag->already_sent; + info.limit = dfrag->data_len; + len = dfrag->data_len - dfrag->already_sent; +while (len >0 ) { +int ret =0 ; + + prev_ssk = ssk; +__mptcp_flush_join_list (msk); + ssk =mptcp_subflow_get_send (msk, &sndbuf); + +/* do auto tuning */ +if (!(sk->sk_userlocks &SOCK_SNDBUF_LOCK ) && + sndbuf >READ_ONCE (sk->sk_sndbuf)) +WRITE_ONCE (sk->sk_sndbuf, sndbuf); + +/* try to keep the subflow socket lock across +* consecutive xmit on the same socket +*/ +if (ssk != prev_ssk && prev_ssk) +mptcp_push_release (sk, prev_ssk, &info); +if (!ssk) + goto out; + +if (ssk != prev_ssk || !prev_ssk) +lock_sock (ssk); + + ret =mptcp_sendmsg_frag (sk, ssk, dfrag, &info); +if (ret <=0 ) { +mptcp_push_release (sk, ssk, &info); + goto out; + } + + info.sent += ret; + dfrag->already_sent += ret; + msk->snd_nxt += ret; + copied += ret; + len -= ret; + } +WRITE_ONCE (msk->first_pending,mptcp_send_next (sk)); + } + +/* at this point we held the socket lock for the last subflow we used */ +if (ssk) +mptcp_push_release (sk, ssk, &info); + +out: +/* start the timer, if it's not pending */ +if (!mptcp_timer_pending (sk)) +mptcp_reset_timer (sk); +if (copied) +__mptcp_check_send_data_fin (sk); +} + +static int mptcp_sendmsg (struct sock *sk,struct msghdr *msg,size_t len) +{ +struct mptcp_sock *msk =mptcp_sk (sk);struct page_frag *pfrag;size_t copied =0 ; -struct sock *ssk;int ret =0 ; -u32 sndbuf; -bool tx_ok;long timeo;if (msg->msg_flags & ~(MSG_MORE |MSG_DONTWAIT |MSG_NOSIGNAL ))
@@ -1218,129 +1232,88 @@ static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) } pfrag =sk_page_frag (sk); -restart:mptcp_clean_una (sk); -if (sk->sk_err || (sk->sk_shutdown &SEND_SHUTDOWN )) { - ret = -EPIPE ; - goto out; - } - -__mptcp_flush_join_list (msk); - ssk =mptcp_subflow_get_send (msk, &sndbuf); -while (!sk_stream_memory_free (sk) || - !ssk || - !mptcp_page_frag_refill (ssk, pfrag)) { -if (ssk) { -/* make sure retransmit timer is -* running before we wait for memory. -* -* The retransmit timer might be needed -* to make the peer send an up-to-date -* MPTCP Ack. -*/ -mptcp_set_timeout (sk, ssk); -if (!mptcp_timer_pending (sk)) -mptcp_reset_timer (sk); - } +while (msg_data_left (msg)) { +struct mptcp_data_frag *dfrag; +int frag_truesize =0 ; +bool dfrag_collapsed; +size_t psize, offset; -mptcp_nospace (msk); - ret =sk_stream_wait_memory (sk, &timeo); -if (ret) - goto out; - -mptcp_clean_una (sk); - - ssk =mptcp_subflow_get_send (msk, &sndbuf); -if (list_empty (&msk->conn_list)) { - ret = -ENOTCONN ; +if (sk->sk_err || (sk->sk_shutdown &SEND_SHUTDOWN )) { + ret = -EPIPE ; goto out; } - } -/* do auto tuning */ -if (!(sk->sk_userlocks &SOCK_SNDBUF_LOCK ) && - sndbuf >READ_ONCE (sk->sk_sndbuf)) -WRITE_ONCE (sk->sk_sndbuf, sndbuf); - -pr_debug ("conn_list->subflow=%p" , ssk); +/* reuse tail pfrag, if possible, or carve a new one from the +* page allocator +*/ + dfrag =mptcp_pending_tail (sk); + dfrag_collapsed =mptcp_frag_can_collapse_to (msk, pfrag, dfrag); +if (!dfrag_collapsed) { +if (!sk_stream_memory_free (sk) || + !mptcp_page_frag_refill (sk, pfrag)) + goto wait_for_memory; -lock_sock (ssk); - tx_ok =msg_data_left (msg); -while (tx_ok) { - ret =mptcp_sendmsg_frag (sk, ssk, msg,NULL , &info); -if (ret <0 ) { -if (ret == -EAGAIN && timeo >0 ) { -mptcp_set_timeout (sk, ssk); -release_sock (ssk); - goto restart; - } -break ; + dfrag =mptcp_carve_data_frag (msk, pfrag, pfrag->offset); + frag_truesize = dfrag->overhead; } -/* burst can be negative, we will try move to the next subflow -* at selection time, if possible. +/* we do not bound vs wspace, to allow a single packet. +* memory accounting will prevent execessive memory usage +* anyway */ - msk->snd_burst -= ret; - copied += ret; - - tx_ok =msg_data_left (msg); -if (!tx_ok) -break ; - -if (!sk_stream_memory_free (ssk) || - !mptcp_page_frag_refill (ssk, pfrag) || - !mptcp_ext_cache_refill (msk)) { -tcp_push (ssk, msg->msg_flags, info.mss_now, -tcp_sk (ssk)->nonagle, info.size_goal); -mptcp_set_timeout (sk, ssk); -release_sock (ssk); - goto restart; + offset = dfrag->offset + dfrag->data_len; + psize = pfrag->size - offset; + psize =min_t (size_t, psize,msg_data_left (msg)); +if (!sk_wmem_schedule (sk, psize + frag_truesize)) + goto wait_for_memory; + +if (copy_page_from_iter (dfrag->page, offset, psize, + &msg->msg_iter) != psize) { + ret = -EFAULT ; + goto out; } -/* memory is charged to mptcp level socket as well, i.e. -* if msg is very large, mptcp socket may run out of buffer -* space. mptcp_clean_una() will release data that has -* been acked at mptcp level in the mean time, so there is -* a good chance we can continue sending data right away. -* -* Normally, when the tcp subflow can accept more data, then -* so can the MPTCP socket. However, we need to cope with -* peers that might lag behind in their MPTCP-level -* acknowledgements, i.e. data might have been acked at -* tcp level only. So, we must also check the MPTCP socket -* limits before we send more data. +/* data successfully copied into the write queue */ + copied += psize; + dfrag->data_len += psize; + frag_truesize += psize; + pfrag->offset += frag_truesize; +WRITE_ONCE (msk->write_seq, msk->write_seq + psize); + +/* charge data on mptcp pending queue to the msk socket +* Note: we charge such data both to sk and ssk */ -if (unlikely (!sk_stream_memory_free (sk))) { -tcp_push (ssk, msg->msg_flags, info.mss_now, -tcp_sk (ssk)->nonagle, info.size_goal); -mptcp_clean_una (sk); -if (!sk_stream_memory_free (sk)) { -/* can't send more for now, need to wait for -* MPTCP-level ACKs from peer. -* -* Wakeup will happen via mptcp_clean_una(). -*/ -mptcp_set_timeout (sk, ssk); -release_sock (ssk); - goto restart; - } +sk_wmem_queued_add (sk, frag_truesize); + sk->sk_forward_alloc -= frag_truesize; +if (!dfrag_collapsed) { +get_page (dfrag->page); +list_add_tail (&dfrag->list, &msk->rtx_queue); +if (!msk->first_pending) +WRITE_ONCE (msk->first_pending, dfrag); } - } +pr_debug ("msk=%p dfrag at seq=%lld len=%d sent=%d new=%d" , msk, + dfrag->data_seq, dfrag->data_len, dfrag->already_sent, + !dfrag_collapsed); -mptcp_set_timeout (sk, ssk); -if (copied) { -tcp_push (ssk, msg->msg_flags, info.mss_now, -tcp_sk (ssk)->nonagle, info.size_goal); +if (!mptcp_ext_cache_refill (msk)) + goto wait_for_memory; +continue ; + +wait_for_memory: +mptcp_nospace (msk); + ret =sk_stream_wait_memory (sk, &timeo); +if (ret) + goto out; -/* start the timer, if it's not pending */ -if (!mptcp_timer_pending (sk)) -mptcp_reset_timer (sk); +mptcp_clean_una (sk); } -release_sock (ssk); +if (copied) +mptcp_push_pending (sk, msg->msg_flags); + out: - msk->snd_nxt = msk->write_seq;ssk_check_wmem (msk);release_sock (sk);return copied ? : ret;
@@ -1793,12 +1766,7 @@ static void mptcp_worker(struct work_struct *work)struct sock *ssk, *sk = &msk->sk.icsk_inet.sk;struct mptcp_sendmsg_info info = {};struct mptcp_data_frag *dfrag; -int orig_len, orig_offset; -u64 orig_write_seq;size_t copied =0 ; -struct msghdr msg = { - .msg_flags =MSG_DONTWAIT , - };int state, ret;lock_sock (sk);
@@ -1847,18 +1815,17 @@ static void mptcp_worker(struct work_struct *work)lock_sock (ssk); - orig_len = dfrag->data_len; - orig_offset = dfrag->offset; - orig_write_seq = dfrag->data_seq; -while (dfrag->data_len >0 ) { - ret =mptcp_sendmsg_frag (sk, ssk, &msg, dfrag, &info); +/* limit retransmission to the bytes already sent on some subflows */ + info.sent =0 ; + info.limit = dfrag->already_sent; +while (info.sent < dfrag->already_sent) { + ret =mptcp_sendmsg_frag (sk, ssk, dfrag, &info);if (ret <0 )break ;MPTCP_INC_STATS (sock_net (sk),MPTCP_MIB_RETRANSSEGS ); copied += ret; - dfrag->data_len -= ret; - dfrag->offset += ret; + info.sent += ret;if (!mptcp_ext_cache_refill (msk))break ;
@@ -1867,10 +1834,6 @@ static void mptcp_worker(struct work_struct *work)tcp_push (ssk,0 , info.mss_now,tcp_sk (ssk)->nonagle, info.size_goal); - dfrag->data_seq = orig_write_seq; - dfrag->offset = orig_offset; - dfrag->data_len = orig_len; -mptcp_set_timeout (sk, ssk);release_sock (ssk);
@@ -1945,6 +1908,7 @@ static void __mptcp_clear_xmit(struct sock *sk)sk_stop_timer (sk, &msk->sk.icsk_retransmit_timer); +WRITE_ONCE (msk->first_pending,NULL );list_for_each_entry_safe (dfrag, dtmp, &msk->rtx_queue, list)dfrag_clear (sk, dfrag); }
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 8/9 mptcp: try to push pending data on snd una updates
In reply to Paolo AbeniAfter the previous patch we may end-up with unsent data in the write buffer. If such buffer is full, the writer will block for unlimited time.
We need to trigger the MPTCP xmit path even for the subflow rx path, on MPTCP snd_una updates.
Keep things simple and just schedule the work queue if needed.
--- net/mptcp/protocol.c | 3 +++ 1 file changed, 3 insertions(+)
net/mptcp/protocol.c +3 -0
@@ -710,6 +710,7 @@ void mptcp_data_acked(struct sock *sk)mptcp_reset_timer (sk);if ((!test_bit (MPTCP_SEND_SPACE , &mptcp_sk (sk)->flags) || +mptcp_send_head (sk) || (inet_sk_state_load (sk) !=TCP_ESTABLISHED )))mptcp_schedule_work (sk); }
@@ -1779,6 +1780,8 @@ static void mptcp_worker(struct work_struct *work)mptcp_check_data_fin_ack (sk);__mptcp_flush_join_list (msk);__mptcp_move_skbs (msk); +if (mptcp_send_head (sk)) +mptcp_push_pending (sk,0 );if (msk->pm.status)pm_work (msk);
Signature · 1 line
2.26.2
Paolo Abeni
PATCH 9/9 mptcp: keep track of advertised windows right edge
In reply to Paolo AbeniFrom: Florian Westphal <fw(a)strlen.de>
Before sending 'x' new bytes also check that the new snd_una would be within the permitted receive window.
For every ACK that also contains a DSS ack, check wheter its tcp-level receive window would advance the current mptcp window right edge and update it if so.
--- net/mptcp/options.c | 18 +++++++++++--- net/mptcp/protocol.c | 58 +++++++++++++++++++++++++++++++++++++++++--- net/mptcp/protocol.h | 1 + 3 files changed, 71 insertions(+), 6 deletions(-)
net/mptcp/options.c +15 -3
@@ -790,10 +790,12 @@ static u64 expand_ack(u64 old_ack, u64 cur_ack, bool use_64bit)return cur_ack; } -static void update_una (struct mptcp_sock *msk, -struct mptcp_options_received *mp_opt) +static void ack_update_msk (struct mptcp_sock *msk, +const struct sock *ssk, +struct mptcp_options_received *mp_opt) {u64 new_snd_una, snd_una, old_snd_una =atomic64_read (&msk->snd_una); +u64 new_wnd_end, wnd_end, old_wnd_end =atomic64_read (&msk->wnd_end);u64 snd_nxt =READ_ONCE (msk->snd_nxt);/* avoid ack expansion on update conflict, to reduce the risk of
@@ -806,6 +808,16 @@ static void update_una(struct mptcp_sock *msk,if (after64 (new_snd_una, snd_nxt)) new_snd_una = old_snd_una; + new_wnd_end = new_snd_una +tcp_sk (ssk)->snd_wnd; + +while (after64 (new_wnd_end, old_wnd_end)) { + wnd_end = old_wnd_end; + old_wnd_end =atomic64_cmpxchg (&msk->wnd_end, wnd_end, + new_wnd_end); +if (old_wnd_end == wnd_end) +break ; + } +while (after64 (new_snd_una, old_snd_una)) { snd_una = old_snd_una; old_snd_una = atomic64_cmpxchg(&msk->snd_una, snd_una,
@@ -910,7 +922,7 @@ void mptcp_incoming_options(struct sock *sk, struct sk_buff *skb)* monodirectional flows will stuck */ if (mp_opt.use_ack) -update_una (msk, &mp_opt); +ack_update_msk (msk, sk, &mp_opt);/* Zero-data-length packets are dropped by the caller and not * propagated to the MPTCP layer, so the skb extension does not
net/mptcp/protocol.c +55 -3
114 lines not on this page · raw message
net/mptcp/protocol.h +1 -0
@@ -214,6 +214,7 @@ struct mptcp_sock {struct sock *last_snd;int snd_burst;atomic64_t snd_una; +atomic64_t wnd_end;unsigned long timer_ival;u32 token;unsigned long flags;
Signature · 1 line
2.26.2
Mat Martineau
[MPTCP] Re: [PATCH v1 6/9] mptcp: refactor shutdown and close
In reply to Paolo AbeniQuoted 88 lines · Paolo Abeni
We must not close the subflows before all the MPTCP level data, comprising the
DATA_FINhas been acked at the MPTCP level, otherwise we could be unable to retransmit as needed.
__mptcp_wr_shutdown()shutdown is responsible to check for the correct status and close all subflows. Is called by the output path after spooling any data and at shutdown/close time.In a similar way,
__mptcp_destroy_sock()is responsible to clean-up the MPTCP level status, and is called when the msk transition toTCP_CLOSE.The protocol level
close()does not force anymore theTCP_CLOSEstatus, but orphan the msk socket and all the subflows. Orphaned msk sockets are forciby closed after a timeout or when all MPTCP-level data is acked.There is a caveat about keeping the orphaned subflows around:
the TCP stack can asynchronusly calltcp_cleanup_ulp()on them viatcp_close(). To prevent accessing freed memory on later MPTCP level operations, the msk acquires a reference to each subflow socket and preventsubflow_ulp_release()from releasing the subflow context before__mptcp_destroy_sock().The additional subflow references are released by
__mptcp_done()and the async ULP release is detected checking ULP ops. If such field has been already cleared by the ULP release path, the dangling context is freed directly by__mptcp_done().Signed-off-by Paolo Abeni <pabeni(a)redhat.com>---
RFC -> v1:
- dropTCP_TIME_WAITstatus, we can't use it or will foulsk_fullsock()
- refactorwr_shutdown, now split in 2 parts.DATA_FINis sent by__mptcp_check_send_data_fin()whensnd_nxt+ 1 ==write_seq
- dropmptcp_wr_eof(), simply check forTCP_CLOSEstate - Mat
- do send data fin ack inTCP_FIN_WAIT2state (return; -> break; in switch statement)
---net/mptcp/options.c | 2 +- net/mptcp/protocol.c | 264 ++++++++++++++++++++++++++++++------------- net/mptcp/protocol.h | 10 +- net/mptcp/subflow.c | 21 +++- 4 files changed, 212 insertions(+), 85 deletions(-)net/mptcp/options.c +1
-1@@ -491,7 +491,7 @@ static bool mptcp_established_options_dss(struct sock *sk, struct sk_buff *skb,bool ret = false; mpext = skb ?mptcp_get_ext (skb) :NULL ; - snd_data_fin_enable =READ_ONCE (msk->snd_data_fin_enable); + snd_data_fin_enable =mptcp_data_fin_enabled (msk);if (!skb || (mpext && mpext->use_map) || snd_data_fin_enable) {unsigned int map_size;net/mptcp/protocol.c +4
-0@@ -21,6 +21,7 @@#include <net/transp_v6.h> #endif #include <net/mptcp.h> +#include <net/xfrm.h> #include "protocol.h" #include "mib.h" @@ -41,6 +42,8 @@ struct mptcp_skb_cb {static struct percpu_counter mptcp_sockets_allocated; +static void __mptcp_destroy_sock (struct sock *sk,int timeout); +/* If msk has an initial subflow socket, and the MP_CAPABLE handshake has not * completed yet or has failed, return the subflow socket. * Otherwise return NULL. @@ -102,6 +105,7 @@ static int __mptcp_socket_create(struct mptcp_sock *msk) msk->subflow = ssock; subflow =mptcp_subflow_ctx (ssock->sk);list_add (&subflow->node, &msk->conn_list); +sock_hold (ssock->sk); subflow->request_mptcp =1 ;/* accept() will wait on first subflow sk_wq, and we always wakes up
net/mptcp/protocol.c static void mptcp_stop_timer(struct sock *sk) · line 320
Quoted 4 lines
net/mptcp/protocol.c +1
-0@@ -313,6 +317,7 @@ static void mptcp_stop_timer(struct sock *sk)mptcp_sk (sk)->timer_ival =0 ; } +/* return true when transitioning to CLOSE state */
Outdated comment? Function returns void.
Quoted 61 lines
net/mptcp/protocol.c +14
-4static void mptcp_check_data_fin_ack (struct sock *sk) {struct mptcp_sock *msk =mptcp_sk (sk);@@ -331,15 +336,20 @@ static void mptcp_check_data_fin_ack(struct sock *sk)switch (sk->sk_state) {case TCP_FIN_WAIT1 :inet_sk_state_store (sk,TCP_FIN_WAIT2 ); - sk->sk_state_change (sk);break ;case TCP_CLOSING :case TCP_LAST_ACK :inet_sk_state_store (sk,TCP_CLOSE ); - sk->sk_state_change (sk);break ; } +/* if the socket is detached from user-space there is no point +* in keeping it around after spooling all the data +*/ +if (sock_flag (sk,SOCK_DEAD )) +return ; + + sk->sk_state_change (sk);if (sk->sk_shutdown ==SHUTDOWN_MASK || sk->sk_state ==TCP_CLOSE )sk_wake_async (sk,SOCK_WAKE_WAITD ,POLL_HUP );@@ -418,7 +428,6 @@ static void mptcp_check_data_fin(struct sock *sk)break ;case TCP_FIN_WAIT2 :inet_sk_state_store (sk,TCP_CLOSE ); -// @@ Close subflows now? break ;default :/* Other states not expected */ @@ -435,8 +444,10 @@ static void mptcp_check_data_fin(struct sock *sk)release_sock (ssk); } - sk->sk_state_change (sk); +if (sock_flag (sk,SOCK_DEAD )) +return ; + sk->sk_state_change (sk);if (sk->sk_shutdown ==SHUTDOWN_MASK || sk->sk_state ==TCP_CLOSE )sk_wake_async (sk,SOCK_WAKE_WAITD ,POLL_HUP );@@ -672,6 +683,10 @@ static void mptcp_reset_timer(struct sock *sk)struct inet_connection_sock *icsk =inet_csk (sk);unsigned long tout; +/* prevent rescheduling on close */ +if (unlikely (inet_sk_state_load (sk) ==TCP_CLOSE )) +return ; +/* should never be called with mptcp level timer cleared */ tout =READ_ONCE (mptcp_sk (sk)->timer_ival);if (WARN_ON_ONCE (!tout))@@ -1697,13 +1712,28 @@ void __mptcp_close_ssk(struct sock *sk, struct sock *ssk,list_del (&subflow->node);
net/mptcp/protocol.c void __mptcp_close_ssk(struct sock *sk, struct sock *ssk, · line 1721
Quoted 10 lines
net/mptcp/protocol.c +7
-3-if (sock && sock != sk->sk_socket) { -/* outgoing subflow */ -sock_release (sock); +/* outgoing subflow */ +if (sock && sock != sk->sk_socket) +iput (SOCK_INODE (sock)); + +lock_sock (ssk); + +/* if ssk hit tcp_done(), tcp_cleanup_ulp() cleared the related oops
Pointing out the oops/ops typo because "oops" has such major consequences in the kernel!
net/mptcp/protocol.c void __mptcp_close_ssk(struct sock *sk, struct sock *ssk, · line 1726
Quoted 5 lines
net/mptcp/protocol.c +5
-0+* the ssk has been already destroyed, we just need to release the +* reference owned by msk; +*/ +if (!inet_csk (ssk)->icsk_ulp_ops) { +kfree_rcu (subflow, rcu);
icsk_ulp_ops might have been cleared for fallback sockets, is that an expected case here too?
Quoted 4 lines
net/mptcp/protocol.c +1
-2}else { -/* incoming subflow */ -tcp_close (ssk, timeout); +/* otherwise ask tcp do dispose of ssk and subflow ctx */
net/mptcp/protocol.c void __mptcp_close_ssk(struct sock *sk, struct sock *ssk, · line 1738
Quoted 10 lines
net/mptcp/protocol.c +7
-0+ subflow->disposable =1 ; +__tcp_close (ssk, timeout); + +/* close acquired an extra ref */ +__sock_put (ssk); } +release_sock (ssk); +sock_put (ssk); }
--
Mat Martineau
Intel
Mat Martineau
Quoted 11 lines · Paolo Abeni
This is necessary to cope correctly with large sendbuffer (larger then snd wnd) while respecting the MPTCP level snd window.
A major rework of both xmit and shudown path is required to support this feature (patches 6 and 7). To try to keep the related patches as small as possible, a bunch of new helpers is created by patches 1-5.
Note that patch 3 can stand for it's own merit and possibly be upstreamed soon.Finally patch 8 uses the MPTCP equivalent of
tcp_push_pending_frames(), to spool queued data ad MPTCP level, as soon as the windows allow that.
Quoted 8 lines
This iteration includes all the fixes mentioned in the ML on top of the RFC, plus some mores - all noted in the individual patches changelog. It also includes the sndwnd patch from Florian, rebased.
Still not bugs free - I see some not-so-frequent timeouts in
mptcp_connect.shtests and tput insimult_xmittests are less stable, but should be notably better than previous iteration. I suggest considering for merge on the export branch.
I had a couple of questions on patch 6, and also reviewed the rest. I'm ok with merging on the export branch if that works ok with other patches that will get sent to net-next before it closes for the 5.10 merge window.
Mat
Quoted 18 lines
Not strictily related to this series: we currently send
DATA_FINack only once
- the behaviour is not change here. If that is dropped, we will never retransmit, and the peer will be stuck.Florian Westphal (1):
mptcp: keep track of advertised windows right edgePaolo Abeni (8):
tcp: factor out__tcp_close()helper
mptcp: introducemptcp_schedule_work
mptcp: reduce the arguments ofmptcp_sendmsg_frag
mptcp: add accounting for pending data
mptcp: introduce MPTCPsnd_nxt
mptcp: refactor shutdown and close
mptcp: move page frag allocation inmptcp_sendmsg()
mptcp: try to push pending data on snd una updates
Quoted 15 lines
include/net/tcp.h | 1 + net/ipv4/tcp.c | 9 +- net/mptcp/options.c | 24 +- net/mptcp/pm.c | 4 +- net/mptcp/protocol.c | 783 +++++++++++++++++++++++++------------------ net/mptcp/protocol.h | 67 +++- net/mptcp/subflow.c | 21 +- 7 files changed, 560 insertions(+), 349 deletions(-)Signature · 4 lines
2.26.2 _______________________________________________ mptcp mailing list -- mptcp(a)lists.01.org To unsubscribe send an email to mptcp-leave(a)lists.01.org
--
Mat Martineau
Intel
Paolo Abeni
[MPTCP] Re: [PATCH v1 6/9] mptcp: refactor shutdown and close
In reply to Mat MartineauQuoted 8 lines · Mat Martineau
net/mptcp/protocol.c +1
-0+* the ssk has been already destroyed, we just need to release the net/mptcp/protocol.c void __mptcp_close_ssk(struct sock *sk, struct sock *ssk, · line 1726
Quoted 4 lines
net/mptcp/protocol.c +4
-0+* reference owned by msk; +*/ +if (!inet_csk (ssk)->icsk_ulp_ops) { +kfree_rcu (subflow, rcu);
icsk_ulp_opsmight have been cleared for fallback sockets, is that an expected case here too?
modulo bugs, we clear ULP only when accepting new connection, and in that case we end-up with a real, plain TCP socket, so we should not enter this code-path. So the above should be safe.
I'll include your other feedback in the next iteration - to be posted after some more testing - thanks!
/P