[PATCH net-next v6 6/8] vsock/virtio: support guest device network namespace
From: Bobby Eshleman
Date: Fri Nov 13 2026 - 22:21:52 EST
virtio-vsock did not have namespace support (the device was always
accessible to any global namespace).
Make the virtio-vsock device assignable to a namespace by setting
.netns_assign_allow, and allow stream and seqpacket sockets from any
netns that can reach the device rather than only from global-mode ones.
The device starts out assigned to init_net, and because virtio-vsock and
init_net are both hardcoded to global mode, nothing changes until the
assign command is issued.
An assign can land while virtio_transport_rx_work() is draining a
batch, so the assigned namespace is re-read per packet rather than once
per batch. Matching the rest of the batch against the namespace the
device has left would reset connections that belong to the new one.
When the device is assigned, VSOCK_CMD_DEV_NETNS_SET closes every
connected socket that can no longer reach it. A socket that completes
its handshake at the same time must not slip into the connected table
behind that sweep, so the listen and connecting receive paths now call
vsock_maybe_set_connected(), which checks reachability and inserts the
socket under the lock the sweep walks the table with. If the check
fails, the handshake is aborted and the host is sent a RST.
A socket closed by an assign can still try to send, e.g. a credit
update from setsockopt(SO_RCVLOWAT) or a shutdown. To stop that,
virtio_transport_send_pkt_info() now returns -ENETUNREACH without
sending when the socket's netns cannot reach the device. RSTs sent by
virtio_transport_reset_no_sock(), such as the one above, do not go
through it and still reach the host.
Signed-off-by: Bobby Eshleman <bobbyeshleman@xxxxxxxx>
---
Changes in v6:
- Move the reachability check from virtio_transport_send_pkt() to
virtio_transport_send_pkt_info(), so RSTs sent by
virtio_transport_reset_no_sock() still reach the host after an assign
(Paolo, Sashiko)
- Revert the v5 change that sent the recv_listen()/recv_connecting()
RSTs to the netns the packet arrived on; sock_net(sk) works again now
that those RSTs skip the check
- Export vsock_g2h_reachable_sk() for virtio_transport_send_pkt_info()
- Rewrite the commit message: drop what the previous patch already does
and describe the virtio_transport_send_pkt_info() check (Paolo)
Changes in v5:
- Send the RSTs in virtio_transport_recv_listen() and
virtio_transport_recv_connecting() to the netns the packet arrived on,
not the socket's: after an assign the socket's netns may no longer
reach the device, so the RST would be dropped by the reachability
check this patch adds to virtio_transport_send_pkt() (Stefano, Sashiko)
Changes in v4:
- Drop packets in virtio_transport_send_pkt() from a netns that cannot
reach the device, e.g. shutdown() or credit updates on a swept socket
(Sashiko)
Changes in v3:
- Re-read the assigned netns per packet in virtio_transport_rx_work()
rather than once per batch, so a mid-batch assign cannot reset the new
namespace's connections (Sashiko)
- Drop the NULL netns reset in virtio_transport_rx_work(), the assigned
netns is now pinned
- Drop the .reset op and the virtio_transport_reset{,_no_sock}() exports,
the sweep no longer sends a RST (Sashiko)
Changes in v2:
- Export virtio_transport_reset(), wire it to the new .reset op (Stefano)
- netns_assign_allow is now a bool (Stefano)
- Pass NULL, not &init_net, in virtio_transport_rx_work(), and
comment why (Stefano)
- Drop the if (net) guard around put_net() (Stefano)
- Drop the comments at the vsock_maybe_set_connected() call sites,
the commit msg seems sufficient
---
include/net/af_vsock.h | 1 +
net/vmw_vsock/af_vsock.c | 6 +++++-
net/vmw_vsock/virtio_transport.c | 23 +++++++++++++++-----
net/vmw_vsock/virtio_transport_common.c | 37 ++++++++++++++++++++++++++-------
4 files changed, 53 insertions(+), 14 deletions(-)
diff --git a/include/net/af_vsock.h b/include/net/af_vsock.h
index a35ab9e41bbb..fa025dd754a1 100644
--- a/include/net/af_vsock.h
+++ b/include/net/af_vsock.h
@@ -249,6 +249,7 @@ void vsock_linger(struct sock *sk);
struct net *vsock_g2h_net_get(netns_tracker *tracker);
bool vsock_g2h_net_eq(const struct net *net);
bool vsock_g2h_net_reachable(struct net *net);
+bool vsock_g2h_reachable_sk(struct vsock_sock *vsk);
bool vsock_maybe_set_connected(struct vsock_sock *vsk);
/**** TAP ****/
diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
index d4d88c8cf142..3bc9eee8ad9d 100644
--- a/net/vmw_vsock/af_vsock.c
+++ b/net/vmw_vsock/af_vsock.c
@@ -921,13 +921,17 @@ bool vsock_g2h_net_reachable(struct net *net)
}
EXPORT_SYMBOL_GPL(vsock_g2h_net_reachable);
-static bool vsock_g2h_reachable_sk(struct vsock_sock *vsk)
+/* True if @vsk can reach the g2h device, or its transport ignores namespace
+ * assignment.
+ */
+bool vsock_g2h_reachable_sk(struct vsock_sock *vsk)
{
if (!vsock_net_assignable(vsk->transport))
return true;
return vsock_g2h_net_reachable(sock_net(sk_vsock(vsk)));
}
+EXPORT_SYMBOL_GPL(vsock_g2h_reachable_sk);
/* Move @vsk to TCP_ESTABLISHED and into the connected table, unless the device
* has moved to a namespace @vsk cannot reach. Returns false without doing
diff --git a/net/vmw_vsock/virtio_transport.c b/net/vmw_vsock/virtio_transport.c
index eced6929405d..4123924536dd 100644
--- a/net/vmw_vsock/virtio_transport.c
+++ b/net/vmw_vsock/virtio_transport.c
@@ -542,7 +542,7 @@ static bool virtio_transport_msgzerocopy_allow(void)
bool virtio_transport_stream_allow(struct vsock_sock *vsk, u32 cid, u32 port)
{
- return vsock_net_mode_global(vsk);
+ return vsock_g2h_net_reachable(sock_net(sk_vsock(vsk)));
}
static bool virtio_transport_seqpacket_allow(struct vsock_sock *vsk,
@@ -587,6 +587,7 @@ static struct virtio_transport virtio_transport = {
.seqpacket_has_data = virtio_transport_seqpacket_has_data,
.msgzerocopy_allow = virtio_transport_msgzerocopy_allow,
+ .netns_assign_allow = true,
.notify_poll_in = virtio_transport_notify_poll_in,
.notify_poll_out = virtio_transport_notify_poll_out,
@@ -616,7 +617,7 @@ virtio_transport_seqpacket_allow(struct vsock_sock *vsk, u32 remote_cid)
struct virtio_vsock *vsock;
bool seqpacket_allow;
- if (!vsock_net_mode_global(vsk))
+ if (!vsock_g2h_net_reachable(sock_net(sk_vsock(vsk))))
return false;
seqpacket_allow = false;
@@ -633,7 +634,12 @@ static void virtio_transport_rx_work(struct work_struct *work)
{
struct virtio_vsock *vsock =
container_of(work, struct virtio_vsock, rx_work);
+ struct virtio_transport *t = &virtio_transport;
+ netns_tracker ns_tracker;
struct virtqueue *vq;
+ struct net *net;
+
+ net = vsock_g2h_net_get(&ns_tracker);
mutex_lock(&vsock->rx_lock);
@@ -682,10 +688,15 @@ static void virtio_transport_rx_work(struct work_struct *work)
virtio_transport_deliver_tap_pkt(skb);
- /* Force virtio-transport into global mode since it
- * does not yet support local-mode namespacing.
+ /* Only grab a reference if the net changes underneath
+ * us.
*/
- virtio_transport_recv_pkt(&virtio_transport, skb, NULL);
+ if (unlikely(!vsock_g2h_net_eq(net))) {
+ put_net_track(net, &ns_tracker);
+ net = vsock_g2h_net_get(&ns_tracker);
+ }
+
+ virtio_transport_recv_pkt(t, skb, net);
}
} while (!virtqueue_enable_cb(vq));
@@ -694,6 +705,8 @@ static void virtio_transport_rx_work(struct work_struct *work)
virtio_vsock_rx_fill(vsock);
out_nofill:
mutex_unlock(&vsock->rx_lock);
+
+ put_net_track(net, &ns_tracker);
}
static int virtio_vsock_vqs_init(struct virtio_vsock *vsock)
diff --git a/net/vmw_vsock/virtio_transport_common.c b/net/vmw_vsock/virtio_transport_common.c
index 1e762a480df4..c1cbe834e4f5 100644
--- a/net/vmw_vsock/virtio_transport_common.c
+++ b/net/vmw_vsock/virtio_transport_common.c
@@ -295,6 +295,9 @@ static struct sk_buff *virtio_transport_alloc_skb(struct virtio_vsock_pkt_info *
* since a socket assigned to a transport is required.
*
* Do not use on listener sockets!
+ *
+ * This checks that the socket can reach the g2h device, so device-only replies
+ * such as virtio_transport_reset_no_sock() must keep not using this path.
*/
static int virtio_transport_send_pkt_info(struct vsock_sock *vsk,
struct virtio_vsock_pkt_info *info)
@@ -317,6 +320,9 @@ static int virtio_transport_send_pkt_info(struct vsock_sock *vsk,
if (unlikely(!t_ops))
return -EFAULT;
+ if (!vsock_g2h_reachable_sk(vsk))
+ return -ENETUNREACH;
+
src_cid = t_ops->transport.get_local_cid();
src_port = vsk->local_addr.svm_port;
if (!info->remote_cid) {
@@ -1468,8 +1474,8 @@ void virtio_transport_release(struct vsock_sock *vsk)
EXPORT_SYMBOL_GPL(virtio_transport_release);
static int
-virtio_transport_recv_connecting(struct sock *sk,
- struct sk_buff *skb)
+virtio_transport_recv_connecting(struct sock *sk, struct sk_buff *skb,
+ struct virtio_transport *t)
{
struct virtio_vsock_hdr *hdr = virtio_vsock_hdr(skb);
struct vsock_sock *vsk = vsock_sk(sk);
@@ -1478,9 +1484,18 @@ virtio_transport_recv_connecting(struct sock *sk,
switch (le16_to_cpu(hdr->op)) {
case VIRTIO_VSOCK_OP_RESPONSE:
- sk->sk_state = TCP_ESTABLISHED;
+ if (!vsock_maybe_set_connected(vsk)) {
+ /* The net arg is required but unused: only g2h can fail
+ * vsock_maybe_set_connected(), and g2h
+ * virtio_transport_reset_no_sock() ignores the net arg.
+ */
+ virtio_transport_reset_no_sock(t, skb, sock_net(sk));
+ skerr = ECONNRESET;
+ err = -ENETUNREACH;
+ goto close;
+ }
+
sk->sk_socket->state = SS_CONNECTED;
- vsock_insert_connected(vsk);
sk->sk_state_change(sk);
break;
case VIRTIO_VSOCK_OP_INVALID:
@@ -1498,6 +1513,7 @@ virtio_transport_recv_connecting(struct sock *sk,
destroy:
virtio_transport_reset(vsk, skb);
+close:
sk->sk_state = TCP_CLOSE;
sk->sk_err = skerr;
sk_error_report(sk);
@@ -1736,8 +1752,6 @@ virtio_transport_recv_listen(struct sock *sk, struct sk_buff *skb,
lock_sock_nested(child, SINGLE_DEPTH_NESTING);
- child->sk_state = TCP_ESTABLISHED;
-
vchild = vsock_sk(child);
vsock_addr_init(&vchild->local_addr, le64_to_cpu(hdr->dst_cid),
le32_to_cpu(hdr->dst_port));
@@ -1758,7 +1772,14 @@ virtio_transport_recv_listen(struct sock *sk, struct sk_buff *skb,
if (virtio_transport_space_update(child, skb))
child->sk_write_space(child);
- vsock_insert_connected(vchild);
+ if (!vsock_maybe_set_connected(vchild)) {
+ release_sock(child);
+ /* Only reached for g2h, whose send_pkt() ignores the netns. */
+ virtio_transport_reset_no_sock(t, skb, sock_net(sk));
+ sock_put(child);
+ return -ENETUNREACH;
+ }
+
vsock_enqueue_accept(sk, child);
virtio_transport_send_response(vchild, skb);
@@ -1859,7 +1880,7 @@ void virtio_transport_recv_pkt(struct virtio_transport *t,
kfree_skb(skb);
break;
case TCP_SYN_SENT:
- virtio_transport_recv_connecting(sk, skb);
+ virtio_transport_recv_connecting(sk, skb, t);
kfree_skb(skb);
break;
case TCP_ESTABLISHED:
--
2.53.1-Meta