1 // SPDX-License-Identifier: GPL-2.0-only
3 * vhost transport for vsock
5 * Copyright (C) 2013-2015 Red Hat, Inc.
6 * Author: Asias He <asias@redhat.com>
7 * Stefan Hajnoczi <stefanha@redhat.com>
9 #include <linux/miscdevice.h>
10 #include <linux/atomic.h>
11 #include <linux/module.h>
12 #include <linux/mutex.h>
13 #include <linux/vmalloc.h>
15 #include <linux/virtio_vsock.h>
16 #include <linux/vhost.h>
17 #include <linux/hashtable.h>
19 #include <net/af_vsock.h>
22 #define VHOST_VSOCK_DEFAULT_HOST_CID 2
23 /* Max number of bytes transferred before requeueing the job.
24 * Using this limit prevents one virtqueue from starving others. */
25 #define VHOST_VSOCK_WEIGHT 0x80000
26 /* Max number of packets transferred before requeueing the job.
27 * Using this limit prevents one virtqueue from starving others with
30 #define VHOST_VSOCK_PKT_WEIGHT 256
33 VHOST_VSOCK_FEATURES
= VHOST_FEATURES
|
34 (1ULL << VIRTIO_F_ACCESS_PLATFORM
) |
35 (1ULL << VIRTIO_VSOCK_F_SEQPACKET
)
39 VHOST_VSOCK_BACKEND_FEATURES
= (1ULL << VHOST_BACKEND_F_IOTLB_MSG_V2
)
42 /* Used to track all the vhost_vsock instances on the system. */
43 static DEFINE_MUTEX(vhost_vsock_mutex
);
44 static DEFINE_READ_MOSTLY_HASHTABLE(vhost_vsock_hash
, 8);
48 struct vhost_virtqueue vqs
[2];
50 /* Link to global vhost_vsock_hash, writes use vhost_vsock_mutex */
51 struct hlist_node hash
;
53 struct vhost_work send_pkt_work
;
54 struct sk_buff_head send_pkt_queue
; /* host->guest pending packets */
56 atomic_t queued_replies
;
62 static u32
vhost_transport_get_local_cid(void)
64 return VHOST_VSOCK_DEFAULT_HOST_CID
;
67 /* Callers that dereference the return value must hold vhost_vsock_mutex or the
70 static struct vhost_vsock
*vhost_vsock_get(u32 guest_cid
)
72 struct vhost_vsock
*vsock
;
74 hash_for_each_possible_rcu(vhost_vsock_hash
, vsock
, hash
, guest_cid
) {
75 u32 other_cid
= vsock
->guest_cid
;
77 /* Skip instances that have no CID yet */
81 if (other_cid
== guest_cid
)
90 vhost_transport_do_send_pkt(struct vhost_vsock
*vsock
,
91 struct vhost_virtqueue
*vq
)
93 struct vhost_virtqueue
*tx_vq
= &vsock
->vqs
[VSOCK_VQ_TX
];
94 int pkts
= 0, total_len
= 0;
96 bool restart_tx
= false;
98 mutex_lock(&vq
->mutex
);
100 if (!vhost_vq_get_backend(vq
))
103 if (!vq_meta_prefetch(vq
))
106 /* Avoid further vmexits, we're already processing the virtqueue */
107 vhost_disable_notify(&vsock
->dev
, vq
);
110 struct virtio_vsock_hdr
*hdr
;
111 size_t iov_len
, payload_len
;
112 struct iov_iter iov_iter
;
113 u32 flags_to_restore
= 0;
120 skb
= virtio_vsock_skb_dequeue(&vsock
->send_pkt_queue
);
123 vhost_enable_notify(&vsock
->dev
, vq
);
127 head
= vhost_get_vq_desc(vq
, vq
->iov
, ARRAY_SIZE(vq
->iov
),
128 &out
, &in
, NULL
, NULL
);
130 virtio_vsock_skb_queue_head(&vsock
->send_pkt_queue
, skb
);
134 if (head
== vq
->num
) {
135 virtio_vsock_skb_queue_head(&vsock
->send_pkt_queue
, skb
);
136 /* We cannot finish yet if more buffers snuck in while
137 * re-enabling notify.
139 if (unlikely(vhost_enable_notify(&vsock
->dev
, vq
))) {
140 vhost_disable_notify(&vsock
->dev
, vq
);
148 vq_err(vq
, "Expected 0 output buffers, got %u\n", out
);
152 iov_len
= iov_length(&vq
->iov
[out
], in
);
153 if (iov_len
< sizeof(*hdr
)) {
155 vq_err(vq
, "Buffer len [%zu] too small\n", iov_len
);
159 iov_iter_init(&iov_iter
, ITER_DEST
, &vq
->iov
[out
], in
, iov_len
);
160 offset
= VIRTIO_VSOCK_SKB_CB(skb
)->offset
;
161 payload_len
= skb
->len
- offset
;
162 hdr
= virtio_vsock_hdr(skb
);
164 /* If the packet is greater than the space available in the
165 * buffer, we split it using multiple buffers.
167 if (payload_len
> iov_len
- sizeof(*hdr
)) {
168 payload_len
= iov_len
- sizeof(*hdr
);
170 /* As we are copying pieces of large packet's buffer to
171 * small rx buffers, headers of packets in rx queue are
172 * created dynamically and are initialized with header
173 * of current packet(except length). But in case of
174 * SOCK_SEQPACKET, we also must clear message delimeter
175 * bit (VIRTIO_VSOCK_SEQ_EOM) and MSG_EOR bit
176 * (VIRTIO_VSOCK_SEQ_EOR) if set. Otherwise,
177 * there will be sequence of packets with these
178 * bits set. After initialized header will be copied to
179 * rx buffer, these required bits will be restored.
181 if (le32_to_cpu(hdr
->flags
) & VIRTIO_VSOCK_SEQ_EOM
) {
182 hdr
->flags
&= ~cpu_to_le32(VIRTIO_VSOCK_SEQ_EOM
);
183 flags_to_restore
|= VIRTIO_VSOCK_SEQ_EOM
;
185 if (le32_to_cpu(hdr
->flags
) & VIRTIO_VSOCK_SEQ_EOR
) {
186 hdr
->flags
&= ~cpu_to_le32(VIRTIO_VSOCK_SEQ_EOR
);
187 flags_to_restore
|= VIRTIO_VSOCK_SEQ_EOR
;
192 /* Set the correct length in the header */
193 hdr
->len
= cpu_to_le32(payload_len
);
195 nbytes
= copy_to_iter(hdr
, sizeof(*hdr
), &iov_iter
);
196 if (nbytes
!= sizeof(*hdr
)) {
198 vq_err(vq
, "Faulted on copying pkt hdr\n");
202 if (skb_copy_datagram_iter(skb
,
207 vq_err(vq
, "Faulted on copying pkt buf\n");
211 /* Deliver to monitoring devices all packets that we
214 virtio_transport_deliver_tap_pkt(skb
);
216 vhost_add_used(vq
, head
, sizeof(*hdr
) + payload_len
);
219 VIRTIO_VSOCK_SKB_CB(skb
)->offset
+= payload_len
;
220 total_len
+= payload_len
;
222 /* If we didn't send all the payload we can requeue the packet
223 * to send it with the next available buffer.
225 if (VIRTIO_VSOCK_SKB_CB(skb
)->offset
< skb
->len
) {
226 hdr
->flags
|= cpu_to_le32(flags_to_restore
);
228 /* We are queueing the same skb to handle
229 * the remaining bytes, and we want to deliver it
230 * to monitoring devices in the next iteration.
232 virtio_vsock_skb_clear_tap_delivered(skb
);
233 virtio_vsock_skb_queue_head(&vsock
->send_pkt_queue
, skb
);
235 if (virtio_vsock_skb_reply(skb
)) {
238 val
= atomic_dec_return(&vsock
->queued_replies
);
240 /* Do we have resources to resume tx
243 if (val
+ 1 == tx_vq
->num
)
249 } while(likely(!vhost_exceeds_weight(vq
, ++pkts
, total_len
)));
251 vhost_signal(&vsock
->dev
, vq
);
254 mutex_unlock(&vq
->mutex
);
257 vhost_poll_queue(&tx_vq
->poll
);
260 static void vhost_transport_send_pkt_work(struct vhost_work
*work
)
262 struct vhost_virtqueue
*vq
;
263 struct vhost_vsock
*vsock
;
265 vsock
= container_of(work
, struct vhost_vsock
, send_pkt_work
);
266 vq
= &vsock
->vqs
[VSOCK_VQ_RX
];
268 vhost_transport_do_send_pkt(vsock
, vq
);
272 vhost_transport_send_pkt(struct sk_buff
*skb
)
274 struct virtio_vsock_hdr
*hdr
= virtio_vsock_hdr(skb
);
275 struct vhost_vsock
*vsock
;
280 /* Find the vhost_vsock according to guest context id */
281 vsock
= vhost_vsock_get(le64_to_cpu(hdr
->dst_cid
));
288 if (virtio_vsock_skb_reply(skb
))
289 atomic_inc(&vsock
->queued_replies
);
291 virtio_vsock_skb_queue_tail(&vsock
->send_pkt_queue
, skb
);
292 vhost_vq_work_queue(&vsock
->vqs
[VSOCK_VQ_RX
], &vsock
->send_pkt_work
);
299 vhost_transport_cancel_pkt(struct vsock_sock
*vsk
)
301 struct vhost_vsock
*vsock
;
307 /* Find the vhost_vsock according to guest context id */
308 vsock
= vhost_vsock_get(vsk
->remote_addr
.svm_cid
);
312 cnt
= virtio_transport_purge_skbs(vsk
, &vsock
->send_pkt_queue
);
315 struct vhost_virtqueue
*tx_vq
= &vsock
->vqs
[VSOCK_VQ_TX
];
318 new_cnt
= atomic_sub_return(cnt
, &vsock
->queued_replies
);
319 if (new_cnt
+ cnt
>= tx_vq
->num
&& new_cnt
< tx_vq
->num
)
320 vhost_poll_queue(&tx_vq
->poll
);
329 static struct sk_buff
*
330 vhost_vsock_alloc_skb(struct vhost_virtqueue
*vq
,
331 unsigned int out
, unsigned int in
)
333 struct virtio_vsock_hdr
*hdr
;
334 struct iov_iter iov_iter
;
341 vq_err(vq
, "Expected 0 input buffers, got %u\n", in
);
345 len
= iov_length(vq
->iov
, out
);
347 /* len contains both payload and hdr */
348 skb
= virtio_vsock_alloc_skb(len
, GFP_KERNEL
);
352 iov_iter_init(&iov_iter
, ITER_SOURCE
, vq
->iov
, out
, len
);
354 hdr
= virtio_vsock_hdr(skb
);
355 nbytes
= copy_from_iter(hdr
, sizeof(*hdr
), &iov_iter
);
356 if (nbytes
!= sizeof(*hdr
)) {
357 vq_err(vq
, "Expected %zu bytes for pkt->hdr, got %zu bytes\n",
358 sizeof(*hdr
), nbytes
);
363 payload_len
= le32_to_cpu(hdr
->len
);
369 /* The pkt is too big or the length in the header is invalid */
370 if (payload_len
> VIRTIO_VSOCK_MAX_PKT_BUF_SIZE
||
371 payload_len
+ sizeof(*hdr
) > len
) {
376 virtio_vsock_skb_rx_put(skb
);
378 nbytes
= copy_from_iter(skb
->data
, payload_len
, &iov_iter
);
379 if (nbytes
!= payload_len
) {
380 vq_err(vq
, "Expected %zu byte payload, got %zu bytes\n",
381 payload_len
, nbytes
);
389 /* Is there space left for replies to rx packets? */
390 static bool vhost_vsock_more_replies(struct vhost_vsock
*vsock
)
392 struct vhost_virtqueue
*vq
= &vsock
->vqs
[VSOCK_VQ_TX
];
395 smp_rmb(); /* paired with atomic_inc() and atomic_dec_return() */
396 val
= atomic_read(&vsock
->queued_replies
);
398 return val
< vq
->num
;
401 static bool vhost_transport_msgzerocopy_allow(void)
406 static bool vhost_transport_seqpacket_allow(u32 remote_cid
);
408 static struct virtio_transport vhost_transport
= {
410 .module
= THIS_MODULE
,
412 .get_local_cid
= vhost_transport_get_local_cid
,
414 .init
= virtio_transport_do_socket_init
,
415 .destruct
= virtio_transport_destruct
,
416 .release
= virtio_transport_release
,
417 .connect
= virtio_transport_connect
,
418 .shutdown
= virtio_transport_shutdown
,
419 .cancel_pkt
= vhost_transport_cancel_pkt
,
421 .dgram_enqueue
= virtio_transport_dgram_enqueue
,
422 .dgram_dequeue
= virtio_transport_dgram_dequeue
,
423 .dgram_bind
= virtio_transport_dgram_bind
,
424 .dgram_allow
= virtio_transport_dgram_allow
,
426 .stream_enqueue
= virtio_transport_stream_enqueue
,
427 .stream_dequeue
= virtio_transport_stream_dequeue
,
428 .stream_has_data
= virtio_transport_stream_has_data
,
429 .stream_has_space
= virtio_transport_stream_has_space
,
430 .stream_rcvhiwat
= virtio_transport_stream_rcvhiwat
,
431 .stream_is_active
= virtio_transport_stream_is_active
,
432 .stream_allow
= virtio_transport_stream_allow
,
434 .seqpacket_dequeue
= virtio_transport_seqpacket_dequeue
,
435 .seqpacket_enqueue
= virtio_transport_seqpacket_enqueue
,
436 .seqpacket_allow
= vhost_transport_seqpacket_allow
,
437 .seqpacket_has_data
= virtio_transport_seqpacket_has_data
,
439 .msgzerocopy_allow
= vhost_transport_msgzerocopy_allow
,
441 .notify_poll_in
= virtio_transport_notify_poll_in
,
442 .notify_poll_out
= virtio_transport_notify_poll_out
,
443 .notify_recv_init
= virtio_transport_notify_recv_init
,
444 .notify_recv_pre_block
= virtio_transport_notify_recv_pre_block
,
445 .notify_recv_pre_dequeue
= virtio_transport_notify_recv_pre_dequeue
,
446 .notify_recv_post_dequeue
= virtio_transport_notify_recv_post_dequeue
,
447 .notify_send_init
= virtio_transport_notify_send_init
,
448 .notify_send_pre_block
= virtio_transport_notify_send_pre_block
,
449 .notify_send_pre_enqueue
= virtio_transport_notify_send_pre_enqueue
,
450 .notify_send_post_enqueue
= virtio_transport_notify_send_post_enqueue
,
451 .notify_buffer_size
= virtio_transport_notify_buffer_size
,
452 .notify_set_rcvlowat
= virtio_transport_notify_set_rcvlowat
,
454 .read_skb
= virtio_transport_read_skb
,
457 .send_pkt
= vhost_transport_send_pkt
,
460 static bool vhost_transport_seqpacket_allow(u32 remote_cid
)
462 struct vhost_vsock
*vsock
;
463 bool seqpacket_allow
= false;
466 vsock
= vhost_vsock_get(remote_cid
);
469 seqpacket_allow
= vsock
->seqpacket_allow
;
473 return seqpacket_allow
;
476 static void vhost_vsock_handle_tx_kick(struct vhost_work
*work
)
478 struct vhost_virtqueue
*vq
= container_of(work
, struct vhost_virtqueue
,
480 struct vhost_vsock
*vsock
= container_of(vq
->dev
, struct vhost_vsock
,
482 int head
, pkts
= 0, total_len
= 0;
483 unsigned int out
, in
;
487 mutex_lock(&vq
->mutex
);
489 if (!vhost_vq_get_backend(vq
))
492 if (!vq_meta_prefetch(vq
))
495 vhost_disable_notify(&vsock
->dev
, vq
);
497 struct virtio_vsock_hdr
*hdr
;
499 if (!vhost_vsock_more_replies(vsock
)) {
500 /* Stop tx until the device processes already
501 * pending replies. Leave tx virtqueue
502 * callbacks disabled.
504 goto no_more_replies
;
507 head
= vhost_get_vq_desc(vq
, vq
->iov
, ARRAY_SIZE(vq
->iov
),
508 &out
, &in
, NULL
, NULL
);
512 if (head
== vq
->num
) {
513 if (unlikely(vhost_enable_notify(&vsock
->dev
, vq
))) {
514 vhost_disable_notify(&vsock
->dev
, vq
);
520 skb
= vhost_vsock_alloc_skb(vq
, out
, in
);
522 vq_err(vq
, "Faulted on pkt\n");
526 total_len
+= sizeof(*hdr
) + skb
->len
;
528 /* Deliver to monitoring devices all received packets */
529 virtio_transport_deliver_tap_pkt(skb
);
531 hdr
= virtio_vsock_hdr(skb
);
533 /* Only accept correctly addressed packets */
534 if (le64_to_cpu(hdr
->src_cid
) == vsock
->guest_cid
&&
535 le64_to_cpu(hdr
->dst_cid
) ==
536 vhost_transport_get_local_cid())
537 virtio_transport_recv_pkt(&vhost_transport
, skb
);
541 vhost_add_used(vq
, head
, 0);
543 } while(likely(!vhost_exceeds_weight(vq
, ++pkts
, total_len
)));
547 vhost_signal(&vsock
->dev
, vq
);
550 mutex_unlock(&vq
->mutex
);
553 static void vhost_vsock_handle_rx_kick(struct vhost_work
*work
)
555 struct vhost_virtqueue
*vq
= container_of(work
, struct vhost_virtqueue
,
557 struct vhost_vsock
*vsock
= container_of(vq
->dev
, struct vhost_vsock
,
560 vhost_transport_do_send_pkt(vsock
, vq
);
563 static int vhost_vsock_start(struct vhost_vsock
*vsock
)
565 struct vhost_virtqueue
*vq
;
569 mutex_lock(&vsock
->dev
.mutex
);
571 ret
= vhost_dev_check_owner(&vsock
->dev
);
575 for (i
= 0; i
< ARRAY_SIZE(vsock
->vqs
); i
++) {
578 mutex_lock(&vq
->mutex
);
580 if (!vhost_vq_access_ok(vq
)) {
585 if (!vhost_vq_get_backend(vq
)) {
586 vhost_vq_set_backend(vq
, vsock
);
587 ret
= vhost_vq_init_access(vq
);
592 mutex_unlock(&vq
->mutex
);
595 /* Some packets may have been queued before the device was started,
596 * let's kick the send worker to send them.
598 vhost_vq_work_queue(&vsock
->vqs
[VSOCK_VQ_RX
], &vsock
->send_pkt_work
);
600 mutex_unlock(&vsock
->dev
.mutex
);
604 vhost_vq_set_backend(vq
, NULL
);
605 mutex_unlock(&vq
->mutex
);
607 for (i
= 0; i
< ARRAY_SIZE(vsock
->vqs
); i
++) {
610 mutex_lock(&vq
->mutex
);
611 vhost_vq_set_backend(vq
, NULL
);
612 mutex_unlock(&vq
->mutex
);
615 mutex_unlock(&vsock
->dev
.mutex
);
619 static int vhost_vsock_stop(struct vhost_vsock
*vsock
, bool check_owner
)
624 mutex_lock(&vsock
->dev
.mutex
);
627 ret
= vhost_dev_check_owner(&vsock
->dev
);
632 for (i
= 0; i
< ARRAY_SIZE(vsock
->vqs
); i
++) {
633 struct vhost_virtqueue
*vq
= &vsock
->vqs
[i
];
635 mutex_lock(&vq
->mutex
);
636 vhost_vq_set_backend(vq
, NULL
);
637 mutex_unlock(&vq
->mutex
);
641 mutex_unlock(&vsock
->dev
.mutex
);
645 static void vhost_vsock_free(struct vhost_vsock
*vsock
)
650 static int vhost_vsock_dev_open(struct inode
*inode
, struct file
*file
)
652 struct vhost_virtqueue
**vqs
;
653 struct vhost_vsock
*vsock
;
656 /* This struct is large and allocation could fail, fall back to vmalloc
657 * if there is no other way.
659 vsock
= kvmalloc(sizeof(*vsock
), GFP_KERNEL
| __GFP_RETRY_MAYFAIL
);
663 vqs
= kmalloc_array(ARRAY_SIZE(vsock
->vqs
), sizeof(*vqs
), GFP_KERNEL
);
669 vsock
->guest_cid
= 0; /* no CID assigned yet */
670 vsock
->seqpacket_allow
= false;
672 atomic_set(&vsock
->queued_replies
, 0);
674 vqs
[VSOCK_VQ_TX
] = &vsock
->vqs
[VSOCK_VQ_TX
];
675 vqs
[VSOCK_VQ_RX
] = &vsock
->vqs
[VSOCK_VQ_RX
];
676 vsock
->vqs
[VSOCK_VQ_TX
].handle_kick
= vhost_vsock_handle_tx_kick
;
677 vsock
->vqs
[VSOCK_VQ_RX
].handle_kick
= vhost_vsock_handle_rx_kick
;
679 vhost_dev_init(&vsock
->dev
, vqs
, ARRAY_SIZE(vsock
->vqs
),
680 UIO_MAXIOV
, VHOST_VSOCK_PKT_WEIGHT
,
681 VHOST_VSOCK_WEIGHT
, true, NULL
);
683 file
->private_data
= vsock
;
684 skb_queue_head_init(&vsock
->send_pkt_queue
);
685 vhost_work_init(&vsock
->send_pkt_work
, vhost_transport_send_pkt_work
);
689 vhost_vsock_free(vsock
);
693 static void vhost_vsock_flush(struct vhost_vsock
*vsock
)
695 vhost_dev_flush(&vsock
->dev
);
698 static void vhost_vsock_reset_orphans(struct sock
*sk
)
700 struct vsock_sock
*vsk
= vsock_sk(sk
);
702 /* vmci_transport.c doesn't take sk_lock here either. At least we're
703 * under vsock_table_lock so the sock cannot disappear while we're
707 /* If the peer is still valid, no need to reset connection */
708 if (vhost_vsock_get(vsk
->remote_addr
.svm_cid
))
711 /* If the close timeout is pending, let it expire. This avoids races
712 * with the timeout callback.
714 if (vsk
->close_work_scheduled
)
717 sock_set_flag(sk
, SOCK_DONE
);
718 vsk
->peer_shutdown
= SHUTDOWN_MASK
;
719 sk
->sk_state
= SS_UNCONNECTED
;
720 sk
->sk_err
= ECONNRESET
;
724 static int vhost_vsock_dev_release(struct inode
*inode
, struct file
*file
)
726 struct vhost_vsock
*vsock
= file
->private_data
;
728 mutex_lock(&vhost_vsock_mutex
);
729 if (vsock
->guest_cid
)
730 hash_del_rcu(&vsock
->hash
);
731 mutex_unlock(&vhost_vsock_mutex
);
733 /* Wait for other CPUs to finish using vsock */
736 /* Iterating over all connections for all CIDs to find orphans is
737 * inefficient. Room for improvement here. */
738 vsock_for_each_connected_socket(&vhost_transport
.transport
,
739 vhost_vsock_reset_orphans
);
741 /* Don't check the owner, because we are in the release path, so we
742 * need to stop the vsock device in any case.
743 * vhost_vsock_stop() can not fail in this case, so we don't need to
744 * check the return code.
746 vhost_vsock_stop(vsock
, false);
747 vhost_vsock_flush(vsock
);
748 vhost_dev_stop(&vsock
->dev
);
750 virtio_vsock_skb_queue_purge(&vsock
->send_pkt_queue
);
752 vhost_dev_cleanup(&vsock
->dev
);
753 kfree(vsock
->dev
.vqs
);
754 vhost_vsock_free(vsock
);
758 static int vhost_vsock_set_cid(struct vhost_vsock
*vsock
, u64 guest_cid
)
760 struct vhost_vsock
*other
;
762 /* Refuse reserved CIDs */
763 if (guest_cid
<= VMADDR_CID_HOST
||
764 guest_cid
== U32_MAX
)
767 /* 64-bit CIDs are not yet supported */
768 if (guest_cid
> U32_MAX
)
771 /* Refuse if CID is assigned to the guest->host transport (i.e. nested
772 * VM), to make the loopback work.
774 if (vsock_find_cid(guest_cid
))
777 /* Refuse if CID is already in use */
778 mutex_lock(&vhost_vsock_mutex
);
779 other
= vhost_vsock_get(guest_cid
);
780 if (other
&& other
!= vsock
) {
781 mutex_unlock(&vhost_vsock_mutex
);
785 if (vsock
->guest_cid
)
786 hash_del_rcu(&vsock
->hash
);
788 vsock
->guest_cid
= guest_cid
;
789 hash_add_rcu(vhost_vsock_hash
, &vsock
->hash
, vsock
->guest_cid
);
790 mutex_unlock(&vhost_vsock_mutex
);
795 static int vhost_vsock_set_features(struct vhost_vsock
*vsock
, u64 features
)
797 struct vhost_virtqueue
*vq
;
800 if (features
& ~VHOST_VSOCK_FEATURES
)
803 mutex_lock(&vsock
->dev
.mutex
);
804 if ((features
& (1 << VHOST_F_LOG_ALL
)) &&
805 !vhost_log_access_ok(&vsock
->dev
)) {
809 if ((features
& (1ULL << VIRTIO_F_ACCESS_PLATFORM
))) {
810 if (vhost_init_device_iotlb(&vsock
->dev
))
814 vsock
->seqpacket_allow
= features
& (1ULL << VIRTIO_VSOCK_F_SEQPACKET
);
816 for (i
= 0; i
< ARRAY_SIZE(vsock
->vqs
); i
++) {
818 mutex_lock(&vq
->mutex
);
819 vq
->acked_features
= features
;
820 mutex_unlock(&vq
->mutex
);
822 mutex_unlock(&vsock
->dev
.mutex
);
826 mutex_unlock(&vsock
->dev
.mutex
);
830 static long vhost_vsock_dev_ioctl(struct file
*f
, unsigned int ioctl
,
833 struct vhost_vsock
*vsock
= f
->private_data
;
834 void __user
*argp
= (void __user
*)arg
;
841 case VHOST_VSOCK_SET_GUEST_CID
:
842 if (copy_from_user(&guest_cid
, argp
, sizeof(guest_cid
)))
844 return vhost_vsock_set_cid(vsock
, guest_cid
);
845 case VHOST_VSOCK_SET_RUNNING
:
846 if (copy_from_user(&start
, argp
, sizeof(start
)))
849 return vhost_vsock_start(vsock
);
851 return vhost_vsock_stop(vsock
, true);
852 case VHOST_GET_FEATURES
:
853 features
= VHOST_VSOCK_FEATURES
;
854 if (copy_to_user(argp
, &features
, sizeof(features
)))
857 case VHOST_SET_FEATURES
:
858 if (copy_from_user(&features
, argp
, sizeof(features
)))
860 return vhost_vsock_set_features(vsock
, features
);
861 case VHOST_GET_BACKEND_FEATURES
:
862 features
= VHOST_VSOCK_BACKEND_FEATURES
;
863 if (copy_to_user(argp
, &features
, sizeof(features
)))
866 case VHOST_SET_BACKEND_FEATURES
:
867 if (copy_from_user(&features
, argp
, sizeof(features
)))
869 if (features
& ~VHOST_VSOCK_BACKEND_FEATURES
)
871 vhost_set_backend_features(&vsock
->dev
, features
);
874 mutex_lock(&vsock
->dev
.mutex
);
875 r
= vhost_dev_ioctl(&vsock
->dev
, ioctl
, argp
);
876 if (r
== -ENOIOCTLCMD
)
877 r
= vhost_vring_ioctl(&vsock
->dev
, ioctl
, argp
);
879 vhost_vsock_flush(vsock
);
880 mutex_unlock(&vsock
->dev
.mutex
);
885 static ssize_t
vhost_vsock_chr_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
887 struct file
*file
= iocb
->ki_filp
;
888 struct vhost_vsock
*vsock
= file
->private_data
;
889 struct vhost_dev
*dev
= &vsock
->dev
;
890 int noblock
= file
->f_flags
& O_NONBLOCK
;
892 return vhost_chr_read_iter(dev
, to
, noblock
);
895 static ssize_t
vhost_vsock_chr_write_iter(struct kiocb
*iocb
,
896 struct iov_iter
*from
)
898 struct file
*file
= iocb
->ki_filp
;
899 struct vhost_vsock
*vsock
= file
->private_data
;
900 struct vhost_dev
*dev
= &vsock
->dev
;
902 return vhost_chr_write_iter(dev
, from
);
905 static __poll_t
vhost_vsock_chr_poll(struct file
*file
, poll_table
*wait
)
907 struct vhost_vsock
*vsock
= file
->private_data
;
908 struct vhost_dev
*dev
= &vsock
->dev
;
910 return vhost_chr_poll(file
, dev
, wait
);
913 static const struct file_operations vhost_vsock_fops
= {
914 .owner
= THIS_MODULE
,
915 .open
= vhost_vsock_dev_open
,
916 .release
= vhost_vsock_dev_release
,
917 .llseek
= noop_llseek
,
918 .unlocked_ioctl
= vhost_vsock_dev_ioctl
,
919 .compat_ioctl
= compat_ptr_ioctl
,
920 .read_iter
= vhost_vsock_chr_read_iter
,
921 .write_iter
= vhost_vsock_chr_write_iter
,
922 .poll
= vhost_vsock_chr_poll
,
925 static struct miscdevice vhost_vsock_misc
= {
926 .minor
= VHOST_VSOCK_MINOR
,
927 .name
= "vhost-vsock",
928 .fops
= &vhost_vsock_fops
,
931 static int __init
vhost_vsock_init(void)
935 ret
= vsock_core_register(&vhost_transport
.transport
,
936 VSOCK_TRANSPORT_F_H2G
);
940 ret
= misc_register(&vhost_vsock_misc
);
942 vsock_core_unregister(&vhost_transport
.transport
);
949 static void __exit
vhost_vsock_exit(void)
951 misc_deregister(&vhost_vsock_misc
);
952 vsock_core_unregister(&vhost_transport
.transport
);
955 module_init(vhost_vsock_init
);
956 module_exit(vhost_vsock_exit
);
957 MODULE_LICENSE("GPL v2");
958 MODULE_AUTHOR("Asias He");
959 MODULE_DESCRIPTION("vhost transport for vsock ");
960 MODULE_ALIAS_MISCDEV(VHOST_VSOCK_MINOR
);
961 MODULE_ALIAS("devname:vhost-vsock");