mptcp: various bugfixes and improvements
Subsystems (3)
cover mptcp: various bugfixes and improvements
This series contains the following mptcp bug fixes:
1. Fix crash on tcp fallback when userspace doesn't provide a 'struct sockaddr' to accept().
2. Close mptcp socket only when all subflows have closed, not just the first.
3. avoid stream data corruption when we'd receive identical mapping at the exact same time on multiple subflows.
4. Fix "fn parameter not described" kerneldoc warnings.
Florian Westphal (3):
mptcp: fix tcp fallback crash
mptcp: subflow: check parent mptcp socket on subflow state change
mptcp: re-check dsn before reading from subflow
Matthieu Baerts (1):
mptcp: fix "fn parameter not described" warnings
net/mptcp/protocol.c | 109 +++++++++++++++++++++++++++++++++++++++++++++++++-- net/mptcp/protocol.h | 2 + net/mptcp/subflow.c | 3 +- net/mptcp/token.c | 9 +++-- 4 files changed, 113 insertions(+), 10 deletions(-)
PATCH 1/4 mptcp: fix tcp fallback crash
Christoph Paasch reports following crash:
general protection fault [..] CPU: 0 PID: 2874 Comm: syz-executor072 Not tainted 5.6.0-rc5 #62 RIP: 0010:__pv_queued_spin_lock_slowpath kernel/locking/qspinlock.c:471 [..] queued_spin_lock_slowpath arch/x86/include/asm/qspinlock.h:50 [inline] do_raw_spin_lock include/linux/spinlock.h:181 [inline] spin_lock_bh include/linux/spinlock.h:343 [inline] __mptcp_flush_join_list+0x44/0xb0 net/mptcp/protocol.c:278 mptcp_shutdown+0xb3/0x230 net/mptcp/protocol.c:1882
[..]
Problem is that mptcp_shutdown() socket isn't an mptcp socket, its a plain tcp_sk. Thus, trying to access mptcp_sk specific members accesses garbage.
Root cause is that accept() returns a fallback (tcp) socket, not an mptcp one. There is code in getpeername to detect this and override the sockets stream_ops. But this will only run when accept() caller provided a sockaddr struct. "accept(fd, NULL, 0)" will therefore result in mptcp stream ops, but with sock->sk pointing at a tcp_sk.
Update the existing fallback handling to detect this as well.
Moreover, mptcp_shutdown did not have fallback handling, and mptcp_poll did it too late so add that there as well.
--- net/mptcp/protocol.c | 50 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 46 insertions(+), 4 deletions(-)
net/mptcp/protocol.c +46 -4
@@ -57,10 +57,43 @@ static bool __mptcp_needs_tcp_fallback(const struct mptcp_sock *msk)return msk->first && !sk_is_mptcp (msk->first); } +static struct socket *mptcp_is_tcpsk (struct sock *sk) +{ +struct socket *sock = sk->sk_socket; + +if (sock->sk != sk) +return NULL ; + +if (unlikely (sk->sk_prot == &tcp_prot)) { +/* we are being invoked after mptcp_accept() has +* accepted a non-mp-capable flow: sk is a tcp_sk, +* not an mptcp one. +* +* Hand the socket over to tcp so all further socket ops +* bypass mptcp. +*/ + sock->ops = &inet_stream_ops; +return sock; +#if IS_ENABLED (CONFIG_MPTCP_IPV6 ) + } else if (unlikely(sk->sk_prot == &tcpv6_prot)) { + sock->ops = &inet6_stream_ops; +return sock; +#endif + } + +return NULL ; +} +static struct socket *__mptcp_tcp_fallback (struct mptcp_sock *msk) { +struct socket *sock; +sock_owned_by_me ((const struct sock *)msk); + sock =mptcp_is_tcpsk ((struct sock *)msk); +if (unlikely (sock)) +return sock; +if (likely (!__mptcp_needs_tcp_fallback (msk)))return NULL ;
@@ -84,6 +117,10 @@ static struct socket *__mptcp_socket_create(struct mptcp_sock *msk, int state)struct socket *ssock;int err; + ssock =__mptcp_tcp_fallback (msk); +if (unlikely (ssock)) +return ssock; + ssock =__mptcp_nmpc_socket (msk);if (ssock) goto set_state;
@@ -1752,7 +1789,9 @@ static __poll_t mptcp_poll(struct file *file, struct socket *sock, msk =mptcp_sk (sk);lock_sock (sk); - ssock =__mptcp_nmpc_socket (msk); + ssock =__mptcp_tcp_fallback (msk); +if (!ssock) + ssock =__mptcp_nmpc_socket (msk);if (ssock) { mask = ssock->ops->poll (file, ssock, wait);release_sock (sk);
@@ -1762,9 +1801,6 @@ static __poll_t mptcp_poll(struct file *file, struct socket *sock,release_sock (sk);sock_poll_wait (file, sock, wait);lock_sock (sk); - ssock =__mptcp_tcp_fallback (msk); -if (unlikely (ssock)) -return ssock->ops->poll (file, ssock,NULL );if (test_bit (MPTCP_DATA_READY , &msk->flags)) mask =EPOLLIN |EPOLLRDNORM ;
@@ -1783,11 +1819,17 @@ static int mptcp_shutdown(struct socket *sock, int how) {struct mptcp_sock *msk =mptcp_sk (sock->sk);struct mptcp_subflow_context *subflow; +struct socket *ssock;int ret =0 ;pr_debug ("sk=%p, how=%d" , msk, how);lock_sock (sock->sk); + ssock =__mptcp_tcp_fallback (msk); +if (ssock) { +release_sock (sock->sk); +return inet_shutdown (ssock, how); + }if (how ==SHUT_WR || how ==SHUT_RDWR )inet_sk_state_store (sock->sk,TCP_FIN_WAIT1 );
Signature · 1 line
2.24.1
PATCH 2/4 mptcp: subflow: check parent mptcp socket on subflow state change
In reply to Florian WestphalThis is needed at least until proper MPTCP-Level fin/reset signalling gets added:
We wake parent when a subflow changes, but we should do this only when all subflows have closed, not just one.
Schedule the mptcp worker and tell it to check eof state on all subflows.
Only flag mptcp socket as closed and wake userspace processes blocking in poll if all subflows have closed.
--- net/mptcp/protocol.c | 33 +++++++++++++++++++++++++++++++++ net/mptcp/protocol.h | 2 ++ net/mptcp/subflow.c | 3 +-- 3 files changed, 36 insertions(+), 2 deletions(-)
net/mptcp/protocol.c +33 -0
@@ -327,6 +327,15 @@ void mptcp_data_acked(struct sock *sk)sock_hold (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); +} +static void mptcp_stop_timer (struct sock *sk) {struct inet_connection_sock *icsk =inet_csk (sk);
@@ -1031,6 +1040,27 @@ static unsigned int mptcp_sync_mss(struct sock *sk, u32 pmtu)return 0 ; } +static void mptcp_check_for_eof (struct mptcp_sock *msk) +{ +struct mptcp_subflow_context *subflow; +struct sock *sk = (struct sock *)msk; +int receivers =0 ; + +mptcp_for_each_subflow (msk, subflow) + receivers += !subflow->rx_eof; + +if (!receivers && !(sk->sk_shutdown &RCV_SHUTDOWN )) { +/* hopefully temporary hack: propagate shutdown status +* to msk, when all subflows agree on it +*/ + sk->sk_shutdown |=RCV_SHUTDOWN ; + +smp_mb__before_atomic ();/* SHUTDOWN must be visible first */ +set_bit (MPTCP_DATA_READY , &msk->flags); + sk->sk_data_ready (sk); + } +} +static void mptcp_worker (struct work_struct *work) { struct mptcp_sock *msk = container_of(work, struct mptcp_sock, work);
@@ -1047,6 +1077,9 @@ static void mptcp_worker(struct work_struct *work)__mptcp_flush_join_list (msk);__mptcp_move_skbs (msk); +if (test_and_clear_bit (MPTCP_WORK_EOF , &msk->flags)) +mptcp_check_for_eof (msk); +if (!test_and_clear_bit (MPTCP_WORK_RTX , &msk->flags)) goto unlock;
net/mptcp/protocol.h +2 -0
@@ -89,6 +89,7 @@#define MPTCP_DATA_READY 0#define MPTCP_SEND_SPACE 1#define MPTCP_WORK_RTX 2 +#define MPTCP_WORK_EOF 3static inline __be32 mptcp_option (u8 subopt,u8 len,u8 nib,u8 field) {
@@ -339,6 +340,7 @@ void mptcp_finish_connect(struct sock *sk);void mptcp_data_ready (struct sock *sk,struct sock *ssk);bool mptcp_finish_join (struct sock *sk);void mptcp_data_acked (struct sock *sk); +void mptcp_subflow_eof (struct sock *sk);int mptcp_token_new_request (struct request_sock *req);void mptcp_token_destroy_request (u32 token);
net/mptcp/subflow.c +1 -2
@@ -994,8 +994,7 @@ static void subflow_state_change(struct sock *sk)if (!(parent->sk_shutdown &RCV_SHUTDOWN ) && !subflow->rx_eof &&subflow_is_done (sk)) { subflow->rx_eof =1 ; - parent->sk_shutdown |=RCV_SHUTDOWN ; -__subflow_state_change (parent); +mptcp_subflow_eof (parent); } }
Signature · 1 line
2.24.1
PATCH 3/4 mptcp: re-check dsn before reading from subflow
In reply to Florian Westphalmptcp_subflow_data_available() is commonly called via ssk->sk_data_ready(), in this case the mptcp socket lock cannot be acquired.
Therefore, while we can safely discard subflow data that was already received up to msk->ack_seq, we cannot be sure that 'subflow->data_avail' will still be valid at the time userspace wants to read the data -- a previous read on a different subflow might have carried this data already.
In that (unlikely) event, msk->ack_seq will have been updated and will be ahead of the subflow dsn.
We can check for this condition and skip/resync to the expected sequence number.
--- net/mptcp/protocol.c | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
net/mptcp/protocol.c +26 -0
@@ -158,6 +158,27 @@ static void __mptcp_move_skb(struct mptcp_sock *msk, struct sock *ssk,MPTCP_SKB_CB (skb)->offset = offset; } +/* both sockets must be locked */ +static bool mptcp_subflow_dsn_valid (const struct mptcp_sock *msk, +struct sock *ssk) +{ +struct mptcp_subflow_context *subflow =mptcp_subflow_ctx (ssk); +u64 dsn =mptcp_subflow_get_mapped_dsn (subflow); + +/* revalidate data sequence number. +* +* mptcp_subflow_data_available() is usually called +* without msk lock. Its unlikely (but possible) +* that msk->ack_seq has been advanced since the last +* call found in-sequence data. +*/ +if (likely (dsn == msk->ack_seq)) +return true; + + subflow->data_avail =0 ; +return mptcp_subflow_data_available (ssk); +} +static bool __mptcp_move_skbs_from_subflow (struct mptcp_sock *msk,struct sock *ssk,unsigned int *bytes)
@@ -169,6 +190,11 @@ static bool __mptcp_move_skbs_from_subflow(struct mptcp_sock *msk,struct tcp_sock *tp;bool done = false; +if (!mptcp_subflow_dsn_valid (msk, ssk)) { + *bytes =0 ; +return false; + } +if (!(sk->sk_userlocks &SOCK_RCVBUF_LOCK )) {int rcvbuf =max (ssk->sk_rcvbuf, sk->sk_rcvbuf);
Signature · 1 line
2.24.1
PATCH 4/4 mptcp: fix "fn parameter not described" warnings
In reply to Florian WestphalFrom: Matthieu Baerts <[email protected]>
Obtained with:
$ make W=1 net/mptcp/token.o net/mptcp/token.c:53: warning: Function parameter or member 'req' not described in 'mptcp_token_new_request' net/mptcp/token.c:98: warning: Function parameter or member 'sk' not described in 'mptcp_token_new_connect' net/mptcp/token.c:133: warning: Function parameter or member 'conn' not described in 'mptcp_token_new_accept' net/mptcp/token.c:178: warning: Function parameter or member 'token' not described in 'mptcp_token_destroy_request' net/mptcp/token.c:191: warning: Function parameter or member 'token' not described in 'mptcp_token_destroy'
--- net/mptcp/token.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
net/mptcp/token.c +5 -4
@@ -40,7 +40,7 @@ static int token_used __read_mostly;/** * mptcp_token_new_request - create new key/idsn/token for subflow_request -* @req - the request socket +* @req: the request socket * * This function is called when a new mptcp connection is coming in. *
@@ -80,7 +80,7 @@ int mptcp_token_new_request(struct request_sock *req)/** * mptcp_token_new_connect - create new key/idsn/token for subflow -* @sk - the socket that will initiate a connection +* @sk: the socket that will initiate a connection * * This function is called when a new outgoing mptcp connection is * initiated.
@@ -125,6 +125,7 @@ int mptcp_token_new_connect(struct sock *sk)/** * mptcp_token_new_accept - insert token for later processing * @token: the token to insert to the tree +* @conn: the just cloned socket linked to the new connection * * Called when a SYN packet creates a new logical connection, i.e. * is not a join request.
@@ -169,7 +170,7 @@ struct mptcp_sock *mptcp_token_get_sock(u32 token)/** * mptcp_token_destroy_request - remove mptcp connection/token -* @token - token of mptcp connection to remove +* @token: token of mptcp connection to remove * * Remove not-yet-fully-established incoming connection identified * by @token.
@@ -183,7 +184,7 @@ void mptcp_token_destroy_request(u32 token)/** * mptcp_token_destroy - remove mptcp connection/token -* @token - token of mptcp connection to remove +* @token: token of mptcp connection to remove * * Remove the connection identified by @token. */
Signature · 1 line
2.24.1
David Miller
maintainerFrom: Florian Westphal <[email protected]>
Date: Thu, 2 Apr 2020 13:44:50 +0200
Quoted 8 lines
This series contains the following mptcp bug fixes:
1. Fix crash on tcp fallback when userspace doesn't provide a 'struct sockaddr' to
accept().
2. Close mptcp socket only when all subflows have closed, not just the first.
3. avoid stream data corruption when we'd receive identical mapping at the exact same time on multiple subflows.
4. Fix "fn parameter not described" kerneldoc warnings.
Series applied, thanks Florian.