* 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