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 and initialize it to init_net. 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 a device is assigned to a namespace, every already established vsock socket that is no longer able to reach the device is forcibly closed. For that reason, adding new sockets to the connected table must be performed atomically with regards to namespace assignment. This ensures that when the socket is added to the connected table that it actually passes the new reachability conditions set by ns assignment. If it wins the race to the table and does NOT pass the reachability tests, then it will be reset. This is the purpose of the new helper 'vsock_maybe_set_connected()'. Signed-off-by: Bobby Eshleman --- 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 --- net/vmw_vsock/virtio_transport.c | 32 +++++++++++++++++++++----- net/vmw_vsock/virtio_transport_common.c | 40 ++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 20 deletions(-) diff --git a/net/vmw_vsock/virtio_transport.c b/net/vmw_vsock/virtio_transport.c index eced6929405d..06df82b130cf 100644 --- a/net/vmw_vsock/virtio_transport.c +++ b/net/vmw_vsock/virtio_transport.c @@ -256,6 +256,15 @@ virtio_transport_send_pkt(struct sk_buff *skb, struct net *net) goto out_rcu; } + /* A socket reset by an assign can still send credit updates from + * recvmsg() and setsockopt(SO_RCVLOWAT). + */ + if (!vsock_g2h_net_reachable(net)) { + kfree_skb(skb); + len = -ENETUNREACH; + goto out_rcu; + } + /* If send_pkt_queue is empty, we can safely bypass this queue * because packet order is maintained and (try) to put the packet * on the virtqueue using virtio_transport_send_skb_fast_path. @@ -542,7 +551,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 +596,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 +626,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 +643,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 +697,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 +714,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..7efcbdc7e04f 100644 --- a/net/vmw_vsock/virtio_transport_common.c +++ b/net/vmw_vsock/virtio_transport_common.c @@ -1468,8 +1468,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 net *net) { struct virtio_vsock_hdr *hdr = virtio_vsock_hdr(skb); struct vsock_sock *vsk = vsock_sk(sk); @@ -1478,9 +1478,14 @@ 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)) { + virtio_transport_reset_no_sock(t, skb, net); + 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 +1503,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); @@ -1702,7 +1708,7 @@ static bool virtio_transport_space_update(struct sock *sk, /* Handle server socket */ static int virtio_transport_recv_listen(struct sock *sk, struct sk_buff *skb, - struct virtio_transport *t) + struct virtio_transport *t, struct net *net) { struct virtio_vsock_hdr *hdr = virtio_vsock_hdr(skb); struct vsock_sock *vsk = vsock_sk(sk); @@ -1711,12 +1717,12 @@ virtio_transport_recv_listen(struct sock *sk, struct sk_buff *skb, int ret; if (le16_to_cpu(hdr->op) != VIRTIO_VSOCK_OP_REQUEST) { - virtio_transport_reset_no_sock(t, skb, sock_net(sk)); + virtio_transport_reset_no_sock(t, skb, net); return -EINVAL; } if (sk_acceptq_is_full(sk)) { - virtio_transport_reset_no_sock(t, skb, sock_net(sk)); + virtio_transport_reset_no_sock(t, skb, net); return -ENOMEM; } @@ -1724,20 +1730,18 @@ virtio_transport_recv_listen(struct sock *sk, struct sk_buff *skb, * Subsequent enqueues would lead to a memory leak. */ if (sk->sk_shutdown == SHUTDOWN_MASK) { - virtio_transport_reset_no_sock(t, skb, sock_net(sk)); + virtio_transport_reset_no_sock(t, skb, net); return -ESHUTDOWN; } child = vsock_create_connected(sk); if (!child) { - virtio_transport_reset_no_sock(t, skb, sock_net(sk)); + virtio_transport_reset_no_sock(t, skb, net); return -ENOMEM; } 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)); @@ -1750,7 +1754,7 @@ virtio_transport_recv_listen(struct sock *sk, struct sk_buff *skb, */ if (ret || vchild->transport != &t->transport) { release_sock(child); - virtio_transport_reset_no_sock(t, skb, sock_net(sk)); + virtio_transport_reset_no_sock(t, skb, net); sock_put(child); return ret; } @@ -1758,7 +1762,13 @@ 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); + virtio_transport_reset_no_sock(t, skb, net); + sock_put(child); + return -ENETUNREACH; + } + vsock_enqueue_accept(sk, child); virtio_transport_send_response(vchild, skb); @@ -1855,11 +1865,11 @@ void virtio_transport_recv_pkt(struct virtio_transport *t, switch (sk->sk_state) { case TCP_LISTEN: - virtio_transport_recv_listen(sk, skb, t); + virtio_transport_recv_listen(sk, skb, t, net); kfree_skb(skb); break; case TCP_SYN_SENT: - virtio_transport_recv_connecting(sk, skb); + virtio_transport_recv_connecting(sk, skb, t, net); kfree_skb(skb); break; case TCP_ESTABLISHED: -- 2.53.0-Meta