Skip to contentSkip to conversation

vsock: use sock_error() to consume sk_err after a failed connect

PATCH Superseded [email protected] 3 participants 4 messages Jul 30 – Aug 4

Subsystems (4)

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/1 vsock: use sock_error() to consume sk_err after a failed connect

From: Nguyen Dinh Phi <[email protected]>

Syzbot report an issue which can be reproduced with these steps:

r0 = socket(AF_VSOCK, SOCK_STREAM, 0)
bind(r0, {VMADDR_CID_ANY, PORT})
connect(r0, {VMADDR_CID_LOCAL, PORT}) -> -1, EPROTO (self-connect)
listen(r0, backlog) -> 0
r1 = socket(AF_VSOCK, SOCK_STREAM, 0)
connect(r1, {VMADDR_CID_LOCAL, PORT}) -> 0
accept(r0) -> -1, EPROTO (stale sk_err)

Basically, it creates a socket (r0) and triggers a self-connect after binding it. This self-connect fails with EPROTO because it loops back to r0 while the socket is still in the TCP_SYN_SENT state, causing it to be incorrectly dispatched to the connecting-client path. The unexpected packet type encountered there sets sk_err to EPROTO.

After that, it invokes a listen() call on the same socket. This listen() call succeeds because the kernel's listening path never inspects or clears sk_err. Then, a new socket (r1) is created as a normal client and connects to r0. However, vsock_accept() rejects this incoming connection because the listener's sk_err still holds the EPROTO error from the earlier failed self-connect.

This rejection causes the child socket created for r1's connection to never be freed on virtio or hyperv transports; only the VMCI transport implements pending_work to revisit and clean up a rejected socket

Fix the issue by using sock_error() to read the sk_err to prevent the rejection branch from occurring in this scenario.

sock_error() atomically reads and clears sk_err, ensuring the error is consumed when vsock_connect() returns and cannot affect subsequent operations on the same socket. This matches the established pattern used by other protocol connect() implementations in the network stack like __inet_stream_connect(), tipc_wait_for_connect()...

---
V2: Add reproducer steps to commit message.
V3: Fix truncated title and add annotations to reproducer steps.

 net/vmw_vsock/af_vsock.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)
net/vmw_vsock/af_vsock.c +2 -5
index 622dbd046799..43eddc33ed12 100644
@@ -1847,14 +1847,11 @@ static int vsock_connect(struct socket *sock, struct sockaddr_unsized *addr,
 		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 	}
 
-	if (sk->sk_err) {
-		err = -sk->sk_err;
+	err = sock_error(sk);
+	if (err) {
 		sk->sk_state = TCP_CLOSE;
 		sock->state = SS_UNCONNECTED;
-	} else {
-		err = 0;
 	}
-
 out_wait:
 	finish_wait(sk_sleep(sk), &wait);
 out:
Signature · 1 line
2.43.0
maintainer
#1 lore raw
Quoted 38 lines · On 7/30/26 10:18 AM, [email protected] wrote:

From: Nguyen Dinh Phi <[email protected]>

Syzbot report an issue which can be reproduced with these steps:

   r0 = socket(AF_VSOCK, SOCK_STREAM, 0)
   bind(r0, {VMADDR_CID_ANY, PORT})
   connect(r0, {VMADDR_CID_LOCAL, PORT})   -> -1, EPROTO  (self-connect)
   listen(r0, backlog)                     -> 0
   r1 = socket(AF_VSOCK, SOCK_STREAM, 0)
   connect(r1, {VMADDR_CID_LOCAL, PORT})   -> 0
   accept(r0)                              -> -1, EPROTO  (stale sk_err)

Basically, it creates a socket (r0) and triggers a self-connect after binding it. This self-connect fails with EPROTO because it loops back to r0 while the socket is still in the TCP_SYN_SENT state, causing it to be incorrectly dispatched to the connecting-client path. The unexpected packet type encountered there sets sk_err to EPROTO.

After that, it invokes a listen() call on the same socket. This listen() call succeeds because the kernel's listening path never inspects or clears sk_err. Then, a new socket (r1) is created as a normal client and connects to r0. However, vsock_accept() rejects this incoming connection because the listener's sk_err still holds the EPROTO error from the earlier failed self-connect.

This rejection causes the child socket created for r1's connection to never be freed on virtio or hyperv transports; only the VMCI transport implements pending_work to revisit and clean up a rejected socket

Fix the issue by using sock_error() to read the sk_err to prevent the rejection branch from occurring in this scenario.

sock_error() atomically reads and clears sk_err, ensuring the error is consumed when vsock_connect() returns and cannot affect subsequent operations on the same socket. This matches the established pattern used by other protocol connect() implementations in the network stack like __inet_stream_connect(), tipc_wait_for_connect()...

Quoted 5 lines

Sashiko nipa points out that the race still exits:

https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260730081843.287563-1-phind.uet%40gmail.com

/P

#2 lore raw
Quoted 41 lines · Paolo Abeni
Quoted 38 lines · On 7/30/26 10:18 AM, [email protected] wrote:

From: Nguyen Dinh Phi <[email protected]>

Syzbot report an issue which can be reproduced with these steps:

   r0 = socket(AF_VSOCK, SOCK_STREAM, 0)
   bind(r0, {VMADDR_CID_ANY, PORT})
   connect(r0, {VMADDR_CID_LOCAL, PORT})   -> -1, EPROTO  (self-connect)
   listen(r0, backlog)                     -> 0
   r1 = socket(AF_VSOCK, SOCK_STREAM, 0)
   connect(r1, {VMADDR_CID_LOCAL, PORT})   -> 0
   accept(r0)                              -> -1, EPROTO  (stale sk_err)

Basically, it creates a socket (r0) and triggers a self-connect after binding it. This self-connect fails with EPROTO because it loops back to r0 while the socket is still in the TCP_SYN_SENT state, causing it to be incorrectly dispatched to the connecting-client path. The unexpected packet type encountered there sets sk_err to EPROTO.

After that, it invokes a listen() call on the same socket. This listen() call succeeds because the kernel's listening path never inspects or clears sk_err. Then, a new socket (r1) is created as a normal client and connects to r0. However, vsock_accept() rejects this incoming connection because the listener's sk_err still holds the EPROTO error from the earlier failed self-connect.

This rejection causes the child socket created for r1's connection to never be freed on virtio or hyperv transports; only the VMCI transport implements pending_work to revisit and clean up a rejected socket

Fix the issue by using sock_error() to read the sk_err to prevent the rejection branch from occurring in this scenario.

sock_error() atomically reads and clears sk_err, ensuring the error is consumed when vsock_connect() returns and cannot affect subsequent operations on the same socket. This matches the established pattern used by other protocol connect() implementations in the network stack like __inet_stream_connect(), tipc_wait_for_connect()...

Quoted 8 lines
Quoted 5 lines

Sashiko nipa points out that the race still exits:

https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260730081843.287563-1-phind.uet%40gmail.com

Yeah, it seems the same conclusion we reached with Michal on v1 and Phi agreed on: https://lore.kernel.org/netdev/[email protected]/

Not sure why sk_err check was not removed in vsock_accept.

Phi can you check?

Thanks,
Stefano

#3 lore raw
Quoted 51 lines · Stefano Garzarella
Quoted 41 lines · Paolo Abeni
Quoted 38 lines · On 7/30/26 10:18 AM, [email protected] wrote:

From: Nguyen Dinh Phi <[email protected]>

Syzbot report an issue which can be reproduced with these steps:

   r0 = socket(AF_VSOCK, SOCK_STREAM, 0)
   bind(r0, {VMADDR_CID_ANY, PORT})
   connect(r0, {VMADDR_CID_LOCAL, PORT})   -> -1, EPROTO  (self-connect) listen(r0, backlog)                     -> 0
   r1 = socket(AF_VSOCK, SOCK_STREAM, 0)
   connect(r1, {VMADDR_CID_LOCAL, PORT})   -> 0
   accept(r0)                              -> -1, EPROTO  (stale sk_err)

Basically, it creates a socket (r0) and triggers a self-connect after binding it. This self-connect fails with EPROTO because it loops back to r0 while the socket is still in the TCP_SYN_SENT state, causing it to be incorrectly dispatched to the connecting-client path. The unexpected packet type encountered there sets sk_err to EPROTO.

After that, it invokes a listen() call on the same socket. This listen() call succeeds because the kernel's listening path never inspects or clears sk_err. Then, a new socket (r1) is created as a normal client and connects to r0. However, vsock_accept() rejects this incoming connection because the listener's sk_err still holds the EPROTO error from the earlier failed self-connect.

This rejection causes the child socket created for r1's connection to never be freed on virtio or hyperv transports; only the VMCI transport implements pending_work to revisit and clean up a rejected socket

Fix the issue by using sock_error() to read the sk_err to prevent the rejection branch from occurring  in this scenario.

sock_error() atomically reads and clears sk_err, ensuring the error is consumed when vsock_connect() returns and cannot affect subsequent operations on the same socket. This matches the established pattern used by other protocol connect() implementations in the network stack like __inet_stream_connect(), tipc_wait_for_connect()...

Quoted 8 lines
Quoted 5 lines

Sashiko nipa points out that the race still exits:

https://netdev-ai.bots.linux.dev/sashiko/#/ patchset/20260730081843.287563-1-phind.uet%40gmail.com

Quoted 9 lines

Yeah, it seems the same conclusion we reached with Michal on v1 and Phi agreed on: https://lore.kernel.org/netdev/148e56ec-dc26-4be2-a7af- [email protected]/

Not sure why sk_err check was not removed in vsock_accept.

Phi can you check?

Thanks,
Stefano

Sorry, I made a mistake when sending email.
I've just sent a new version.

Thanks,
Phi.