Linux virtualization list
 help / color / mirror / Atom feed
* [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails
@ 2026-11-18  1:34 Bobby Eshleman
  2026-11-18  1:38 ` netdev-bot+sinfo
                   ` (2 more replies)
  0 siblings, 3 replies; 4+ messages in thread
From: Bobby Eshleman @ 2026-11-18  1:34 UTC (permalink / raw)
  To: Stefano Garzarella, David S. Miller, Eric Dumazet, Jakub Kicinski,
	Paolo Abeni, Simon Horman, George Zhang, Andy King,
	Dmitry Torokhov
  Cc: virtualization, netdev, linux-kernel, Kyle Zeng, Michal Luczaj,
	Bobby Eshleman

vsock_connect() sleeps with the socket unlocked. Meanwhile the transport
can complete the handshake, setting sock->state to SS_CONNECTED, and then
reset the connection, e.g. in vhost_vsock_reset_orphans(),
virtio_vsock_reset_sock() or vmci_transport_handle_detach(). When
connect() gets the lock back, it finds sk_err set and moves the socket
back to SS_UNCONNECTED. Userspace can then connect() the socket again,
and a connect() to a CID on another transport makes
vsock_assign_transport() release the transport the socket was connected
on.

Only move the socket back to SS_UNCONNECTED if it is still
SS_CONNECTING. A socket that got connected stays SS_CONNECTED, and
another connect() fails with -EISCONN.

Likewise, only move sk_state to TCP_CLOSE if it is still TCP_SYN_SENT.
Otherwise a second thread blocked in connect() on the same socket can
time out after the first one failed and called listen(), and overwrite
TCP_LISTEN.

Fixes: d021c344051a ("VSOCK: Introduce VM Sockets")
Reported-by: Kyle Zeng <kylebot@openai.com>
Link: https://lore.kernel.org/netdev/20260909-vsock-connect-reset-closing-v1-1-50298b9ccfbf@rbox.co/
Suggested-by: Michal Luczaj <mhal@rbox.co>
Signed-off-by: Bobby Eshleman <bobbyeshleman@meta.com>
---
Changes in v2:
- Only reset sk_state if it is still TCP_SYN_SENT, so a concurrent
  connect() caller that times out late doesn't overwrite TCP_LISTEN
  (Sashiko).
- Drop Michal's Reviewed-by since the code changed.
- Link to v1: https://lore.kernel.org/r/20261116-vsock-connect-close-v1-1-43fb125973dd@meta.com
---
 net/vmw_vsock/af_vsock.c | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
index 1d7d53542724..ce958b48295b 100644
--- a/net/vmw_vsock/af_vsock.c
+++ b/net/vmw_vsock/af_vsock.c
@@ -1704,6 +1704,19 @@ static void vsock_connect_timeout(struct work_struct *work)
 	sock_put(sk);
 }
 
+/* Avoid breaking the socket when another thread has changed its state while
+ * we were asleep.
+ */
+static void vsock_connect_close(struct socket *sock)
+{
+	struct sock *sk = sock->sk;
+
+	if (sk->sk_state == TCP_SYN_SENT)
+		sk->sk_state = TCP_CLOSE;
+	if (sock->state == SS_CONNECTING)
+		sock->state = SS_UNCONNECTED;
+}
+
 static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
 			 int addr_len, int flags)
 {
@@ -1862,8 +1875,7 @@ static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
 			 * sk_state == TCP_SYN_SENT, which hereby we break.
 			 * In such case VIRTIO_VSOCK_OP_RST will follow.
 			 */
-			sk->sk_state = TCP_CLOSE;
-			sock->state = SS_UNCONNECTED;
+			vsock_connect_close(sock);
 
 			/* Try to cancel VIRTIO_VSOCK_OP_REQUEST skb sent out by
 			 * transport->connect().
@@ -1877,10 +1889,8 @@ static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
 	}
 
 	err = sock_error(sk);
-	if (err) {
-		sk->sk_state = TCP_CLOSE;
-		sock->state = SS_UNCONNECTED;
-	}
+	if (err)
+		vsock_connect_close(sock);
 
 out_wait:
 	finish_wait(sk_sleep(sk), &wait);

---
base-commit: 533ec433efdc11196f438da90d683053a57257ff
change-id: 20261116-vsock-connect-close-1beb7cb51e7a

Best regards,
-- 
Bobby Eshleman <bobbyeshleman@meta.com>


^ permalink raw reply related	[flat|nested] 4+ messages in thread

* Re: [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails
  2026-11-18  1:34 [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails Bobby Eshleman
@ 2026-11-18  1:38 ` netdev-bot+sinfo
  2026-11-19  1:34 ` sashiko-bot
  2026-11-19  2:27 ` netdev-bot+sashiko
  2 siblings, 0 replies; 4+ messages in thread
From: netdev-bot+sinfo @ 2026-11-18  1:38 UTC (permalink / raw)
  To: Bobby Eshleman
  Cc: Stefano Garzarella, David S. Miller, Eric Dumazet, Jakub Kicinski,
	Paolo Abeni, Simon Horman, George Zhang, Andy King,
	Dmitry Torokhov, virtualization, netdev, linux-kernel, Kyle Zeng,
	Michal Luczaj

Hi!

This is an automated message. This series looks like a fix, but its
commit messages seem to be missing some information:

 - How the issue was discovered, e.g. hit in production, hit during
   development, syzbot report, manual code inspection, LLM or static
   analysis tool scan.

 - Whether the issue was actually triggered, or is only theoretical
   (e.g. found by LLM and not proven at runtime). If it was triggered
   please include the symptoms, like the stack trace or kernel messages.

Please do not repost the series just to address the above. Instead,
reply to this email with the missing information, so that reviewers
can take it into account.

*IMPORTANT*: If you do repost (for other reasons) - please include
the relevant info in the cover letter or commit messages.
-- 
The evaluation is done by an LLM so it may be wrong, if you think
that is the case please reply and explain.

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails
  2026-11-18  1:34 [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails Bobby Eshleman
  2026-11-18  1:38 ` netdev-bot+sinfo
@ 2026-11-19  1:34 ` sashiko-bot
  2026-11-19  2:27 ` netdev-bot+sashiko
  2 siblings, 0 replies; 4+ messages in thread
From: sashiko-bot @ 2026-11-19  1:34 UTC (permalink / raw)
  To: Bobby Eshleman; +Cc: virtualization, Michael S. Tsirkin, Eugenio Perez

Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [Medium] vsock: incomplete handling of post-handshake reset in
  vsock_connect()
- [Medium] vsock: concurrent vsock_connect() waiter stays in loop and
  clobbers retry
--

commit 82a88284866b93cccb5d48f9bd76a86ebb091f06
Author: Bobby Eshleman <bobbyeshleman@meta.com>

vsock: only undo SS_CONNECTING when connect() fails

This commit adds vsock_connect_close() so vsock_connect() only resets
sk->sk_state to TCP_CLOSE when it is still TCP_SYN_SENT and sock->state to
SS_UNCONNECTED when it is still SS_CONNECTING.

Link: https://lore.kernel.org/netdev/20260909-vsock-connect-reset-closing-v1-1-50298b9ccfbf@rbox.co/

> diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
> index 1d7d53542724f..ce958b48295b9 100644
> --- a/net/vmw_vsock/af_vsock.c
> +++ b/net/vmw_vsock/af_vsock.c
> @@ -1704,6 +1704,19 @@ static void vsock_connect_timeout(struct work_struct *work)
>  	sock_put(sk);
>  }
>  
> +/* Avoid breaking the socket when another thread has changed its state while
> + * we were asleep.
> + */
> +static void vsock_connect_close(struct socket *sock)
> +{
> +	struct sock *sk = sock->sk;
> +
> +	if (sk->sk_state == TCP_SYN_SENT)
> +		sk->sk_state = TCP_CLOSE;
> +	if (sock->state == SS_CONNECTING)
> +		sock->state = SS_UNCONNECTED;
> +}

[Severity: Medium]
Can a second thread blocked in vsock_connect() stay in the wait loop after
the first attempt fails, and later clobber a retry connect() on the same
socket?

CPU0                              CPU1
vsock_connect()
  sk->sk_state = TCP_SYN_SENT
  sock->state = SS_CONNECTING
  release_sock(sk)
                                  vsock_connect()
                                    /* sees SS_CONNECTING */
                                    release_sock(sk)
  /* timeout or peer RST */
  lock_sock(sk)
  sock_error(sk) /* clears sk_err */
  vsock_connect_close(sock)
    sk->sk_state = TCP_CLOSE
    sock->state = SS_UNCONNECTED
  release_sock(sk)
                                  lock_sock(sk)
                                  /* sk_state == TCP_CLOSE && sk_err == 0,
                                   * so while loop continues
                                   */
                                  release_sock(sk)
  vsock_connect() /* retry */
    sk->sk_state = TCP_SYN_SENT
    sock->state = SS_CONNECTING
    release_sock(sk)
                                  /* timeout or signal */
                                  lock_sock(sk)
                                  vsock_connect_close(sock)
                                    /* resets retry's TCP_SYN_SENT and
                                     * SS_CONNECTING
                                     */
                                  vsock_transport_cancel_pkt(vsk)

Because the wait loop only exits on TCP_ESTABLISHED, TCP_CLOSING or
sk->sk_err != 0, CPU1 does not see that the socket left TCP_SYN_SENT once
CPU0 clears sk->sk_err (or times out with sk->sk_err == 0).  When CPU1 later
times out or gets a signal, vsock_connect_close() sees TCP_SYN_SENT and
SS_CONNECTING from the new connect() attempt, resets them to TCP_CLOSE and
SS_UNCONNECTED while CPU0 sleeps, and cancels the new attempt's packets.
Even if userspace called listen() instead of retrying connect(), CPU1 still
calls vsock_transport_cancel_pkt() on timeout.

Also, if another thread consumes sk->sk_err via getsockopt(SO_ERROR) or
recvmsg(MSG_ERRQUEUE) before vsock_connect() calls sock_error(sk), err is 0,
so vsock_connect() skips vsock_connect_close() and returns 0 while leaving
sock->state as SS_CONNECTING with sk->sk_state == TCP_CLOSE.

> @@ -1862,8 +1875,7 @@ static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
>  			 * sk_state == TCP_SYN_SENT, which hereby we break.
>  			 * In such case VIRTIO_VSOCK_OP_RST will follow.
>  			 */
> -			sk->sk_state = TCP_CLOSE;
> -			sock->state = SS_UNCONNECTED;
> +			vsock_connect_close(sock);
>  
>  			/* Try to cancel VIRTIO_VSOCK_OP_REQUEST skb sent out by
>  			 * transport->connect().
> @@ -1877,10 +1889,8 @@ static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
>  	}
>  
>  	err = sock_error(sk);
> -	if (err) {
> -		sk->sk_state = TCP_CLOSE;
> -		sock->state = SS_UNCONNECTED;
> -	}
> +	if (err)
> +		vsock_connect_close(sock);
>  
>  out_wait:
>  	finish_wait(sk_sleep(sk), &wait);

[Severity: Medium]
When the transport completes the handshake (setting sock->state to
SS_CONNECTED and sk->sk_state to TCP_ESTABLISHED) and then resets the
socket to TCP_CLOSE while vsock_connect() is sleeping, does vsock_connect()
still mishandle the post-handshake reset in the wait loop and error path?

First, in vmci_transport_handle_detach(), a detach after the socket has
already reached TCP_ESTABLISHED sets sk->sk_state = TCP_CLOSE without
setting sk->sk_err:

net/vmw_vsock/vmci_transport.c:vmci_transport_handle_detach() {
    ...
			if (sk->sk_state == TCP_SYN_SENT) {
				sk->sk_state = TCP_CLOSE;
				sk->sk_err = ECONNRESET;
				sk_error_report(sk);
				return;
			}
			sk->sk_state = TCP_CLOSE;
    ...
}

When vsock_connect() wakes up, sk->sk_state is neither TCP_ESTABLISHED nor
TCP_CLOSING and sk->sk_err is 0, so it re-enters schedule_timeout() and
blocks until connect_timeout expires.

Second, if a timeout or signal coincides with a post-handshake reset to
TCP_CLOSE, vsock_connect() enters the signal/timeout branch and calls
vsock_transport_cancel_pkt(vsk) on a socket whose sock->state is already
SS_CONNECTED.  If another thread called sendmsg() once sock->state became
SS_CONNECTED, virtio_transport_cancel_pkt() purges queued
VIRTIO_VSOCK_OP_RW packets without decrementing vvs->bytes_unsent, leaving
unsent-byte accounting for SIOCOUTQ and vsock_linger() out of sync.

Third, when virtio_vsock_reset_sock() or vhost_vsock_reset_orphans() sets
sk->sk_err = ECONNRESET after the handshake completed, vsock_connect()
exits the loop, consumes sk->sk_err via sock_error(sk), and returns
-ECONNRESET from connect() while leaving sock->state as SS_CONNECTED.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117-vsock-connect-close-v2-1-db5388323770@meta.com?part=1

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails
  2026-11-18  1:34 [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails Bobby Eshleman
  2026-11-18  1:38 ` netdev-bot+sinfo
  2026-11-19  1:34 ` sashiko-bot
@ 2026-11-19  2:27 ` netdev-bot+sashiko
  2 siblings, 0 replies; 4+ messages in thread
From: netdev-bot+sashiko @ 2026-11-19  2:27 UTC (permalink / raw)
  To: bobbyeshleman
  Cc: sgarzare, davem, edumazet, kuba, pabeni, horms, georgezhang,
	acking, dtor, virtualization, netdev, linux-kernel, kylebot, mhal

Thank you for your contribution! Sashiko AI review found 3 potential
issue(s) to consider.

Critical: 0 · High: 0 · Medium: 1 · Low: 2

If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).

- [Medium] A connect() waiter that times out late can still abort a newer
  connect attempt on the same socket.
- [Low] The commit message names the wrong trigger paths.
- [Low] If another thread calls shutdown() while a blocking connect() is
  sleeping, a failed connect now leaves the socket in SS_DISCONNECTING…

--

vsock: only undo SS_CONNECTING when connect() fails

This patch adds a vsock_connect_close() helper. On a failed connect(), it
moves sk_state to TCP_CLOSE only if it is still TCP_SYN_SENT, and moves
sock->state to SS_UNCONNECTED only if it is still SS_CONNECTING. The goal
is to stop a socket that got connected and was then reset from going back
to SS_UNCONNECTED, and to stop a late waiter from overwriting TCP_LISTEN.

Link: https://lore.kernel.org/netdev/20260909-vsock-connect-reset-closing-v1-1-50298b9ccfbf@rbox.co/

> vsock_connect() sleeps with the socket unlocked. Meanwhile the transport
> can complete the handshake, setting sock->state to SS_CONNECTED, and then
> reset the connection, e.g. in vhost_vsock_reset_orphans(),
> virtio_vsock_reset_sock() or vmci_transport_handle_detach(). When
> connect() gets the lock back, it finds sk_err set and moves the socket
> back to SS_UNCONNECTED.

[Severity: Low]
Does this description hold for all three examples?

virtio_vsock_reset_sock() fits it: it sets sk_state = TCP_CLOSE and
sk_err = ECONNRESET.

vhost_vsock_reset_orphans() in drivers/vhost/vsock.c writes a socket_state
constant into sk_state:

    sk->sk_state = SS_UNCONNECTED;
    sk->sk_err = ECONNRESET;

SS_UNCONNECTED has the same value (1) as TCP_ESTABLISHED. This function
also only runs on sockets in vsock_connected_table, which are already
established. So a vsock_connect() that gets the lock back takes the early
exit:

    if (sk->sk_state == TCP_ESTABLISHED ||
        sk->sk_state == TCP_CLOSING) {
        err = 0;
        goto out_wait;
    }

It returns 0 and never reaches the code this patch changes.

vmci_transport_handle_detach() sets sk_err only in the TCP_SYN_SENT branch.
For an established socket it only does this, and sk_err stays 0:

    sk->sk_state = TCP_CLOSE;

connect() then goes back to sleep and reaches the reset through the
timeout/signal branch, not through the sock_error() branch.

The code change covers both reset sites, so only the description is
affected. Could the commit message say which transports actually reach
this, and by which path?

> diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
> index 1d7d53542724f..ce958b48295b9 100644
> --- a/net/vmw_vsock/af_vsock.c
> +++ b/net/vmw_vsock/af_vsock.c
> @@ -1704,6 +1704,19 @@ static void vsock_connect_timeout(struct work_struct *work)
>  	sock_put(sk);
>  }
>  
> +/* Avoid breaking the socket when another thread has changed its state while
> + * we were asleep.
> + */
> +static void vsock_connect_close(struct socket *sock)
> +{
> +	struct sock *sk = sock->sk;
> +
> +	if (sk->sk_state == TCP_SYN_SENT)
> +		sk->sk_state = TCP_CLOSE;
> +	if (sock->state == SS_CONNECTING)
> +		sock->state = SS_UNCONNECTED;

[Severity: Low]
What happens if another thread calls shutdown() while a blocking connect()
is asleep?

vsock_shutdown() moves any socket that is not SS_UNCONNECTED to
SS_DISCONNECTING, including one that is still SS_CONNECTING:

    } else {
        sock->state = SS_DISCONNECTING;
        err = 0;
    }

Later the sleeping connect() times out, gets a signal, or sees sk_err.
vsock_connect_close() then moves sk_state from TCP_SYN_SENT to TCP_CLOSE,
but sock->state stays SS_DISCONNECTING. After that, every connect() takes
this path:

    case SS_DISCONNECTING:
        err = -EINVAL;
        goto out;

listen() also fails its sock->state != SS_UNCONNECTED check. So a socket
that never connected can no longer be reused. Before this patch it went
back to SS_UNCONNECTED.

The non-blocking path in vsock_connect_timeout() still resets sock->state
without checking it:

    if (sk->sk_state == TCP_SYN_SENT &&
        (sk->sk_shutdown != SHUTDOWN_MASK)) {
        sk->sk_state = TCP_CLOSE;
        sk->sk_socket->state = SS_UNCONNECTED;

So the same shutdown-during-connect race now ends differently depending on
O_NONBLOCK.

SS_DISCONNECTING does need to stay when the connection was established
before shutdown() and the reset. Otherwise SS_CONNECTED ->
SS_DISCONNECTING -> reset brings the original problem back. Could the
helper tell the never-established case apart, for example by looking at
sk_state, instead of either always keeping or always clearing
SS_DISCONNECTING?

> +}
> +

[ ... ]

> @@ -1862,8 +1875,7 @@ static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
>  			 * sk_state == TCP_SYN_SENT, which hereby we break.
>  			 * In such case VIRTIO_VSOCK_OP_RST will follow.
>  			 */
> -			sk->sk_state = TCP_CLOSE;
> -			sock->state = SS_UNCONNECTED;
> +			vsock_connect_close(sock);
>  
>  			/* Try to cancel VIRTIO_VSOCK_OP_REQUEST skb sent out by
>  			 * transport->connect().

[Severity: Medium]
Can a connect() waiter that times out late still abort a newer connect
attempt on the same socket?

vsock_connect_close() only checks whether the socket looks like it is
connecting right now. It cannot tell whether TCP_SYN_SENT / SS_CONNECTING
belongs to this waiter's attempt or to a later connect() call.

Here is a possible sequence in vsock_connect():

Thread A
  blocking connect(), sets TCP_SYN_SENT / SS_CONNECTING, sleeps

Thread B
  connect() on the same socket, takes the SS_CONNECTING case (-EALREADY),
  sleeps with a full connect_timeout

The peer rejects the handshake:

  virtio_transport_recv_connecting()
      sk->sk_state = TCP_CLOSE;
      sk->sk_err = skerr;
      sk_error_report(sk);

Thread A
  wakes first, sock_error() clears sk_err to 0,
  vsock_connect_close() sets SS_UNCONNECTED

Thread B
  wakes, sees TCP_CLOSE with sk_err == 0, sleeps for the rest of its
  timeout

Thread C
  connect() takes the default branch, sets TCP_SYN_SENT, sends a REQUEST,
  sets SS_CONNECTING

Thread B
  timeout expires:
      vsock_connect_close(sock);        <- sees C's state, resets it
      vsock_transport_cancel_pkt(vsk);  <- cancels C's REQUEST

C is not woken and gets no error. It sleeps until its own timeout and
returns -ETIMEDOUT. A peer RESPONSE that arrives while the socket is in
TCP_CLOSE gets an RST.

This looks like the same stale-waiter problem that v2 fixes for
TCP_LISTEN. The new helper's comment says "Avoid breaking the socket when
another thread has changed its state while we were asleep". Should this
case be covered as well?

[ ... ]

-- 
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261117-vsock-connect-close-v2-1-db5388323770%40meta.com

^ permalink raw reply	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2026-11-19  2:27 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18  1:34 [PATCH net v2] vsock: only undo SS_CONNECTING when connect() fails Bobby Eshleman
2026-11-18  1:38 ` netdev-bot+sinfo
2026-11-19  1:34 ` sashiko-bot
2026-11-19  2:27 ` netdev-bot+sashiko

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox