Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c402293b authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'vsock-virtio' 

Stefan Hajnoczi says:

====================
Add virtio transport for AF_VSOCK

v2:
 * Rebased onto Linux v4.4-rc2
 * vhost: Refuse to assign reserved CIDs
 * vhost: Refuse guest CID if already in use
 * vhost: Only accept correctly addressed packets (no spoofing!)
 * vhost: Support flexible rx/tx descriptor layout
 * vhost: Add missing total_tx_buf decrement
 * virtio_transport: Fix total_tx_buf accounting
 * virtio_transport: Add virtio_transport global mutex to prevent races
 * common: Notify other side of SOCK_STREAM disconnect (fixes shutdown
   semantics)
 * common: Avoid recursive mutex_lock(tx_lock) for write_space (fixes deadlock)
 * common: Define VIRTIO_VSOCK_TYPE_STREAM/DGRAM hardware interface constants
 * common: Define VIRTIO_VSOCK_SHUTDOWN_RCV/SEND hardware interface constants
 * common: Fix peer_buf_alloc inheritance on child socket

This patch series adds a virtio transport for AF_VSOCK (net/vmw_vsock/).
AF_VSOCK is designed for communication between virtual machines and
hypervisors.  It is currently only implemented for VMware's VMCI transport.

This series implements the proposed virtio-vsock device specification from
here:
http://comments.gmane.org/gmane.comp.emulators.virtio.devel/855

Most of the work was done by Asias He and Gerd Hoffmann a while back.  I have
picked up the series again.

The QEMU userspace changes are here:
https://github.com/stefanha/qemu/commits/vsock



Why virtio-vsock?
-----------------
Guest<->host communication is currently done over the virtio-serial device.
This makes it hard to port sockets API-based applications and is limited to
static ports.

virtio-vsock uses the sockets API so that applications can rely on familiar
SOCK_STREAM and SOCK_DGRAM semantics.  Applications on the host can easily
connect to guest agents because the sockets API allows multiple connections to
a listen socket (unlike virtio-serial).  This simplifies the guest<->host
communication and eliminates the need for extra processes on the host to
arbitrate virtio-serial ports.

Overview
--------
This series adds 3 pieces:

1. virtio_transport_common.ko - core virtio vsock code that uses vsock.ko

2. virtio_transport.ko - guest driver

3. drivers/vhost/vsock.ko - host driver

Howto
-----
The following kernel options are needed:
  CONFIG_VSOCKETS=y
  CONFIG_VIRTIO_VSOCKETS=y
  CONFIG_VIRTIO_VSOCKETS_COMMON=y
  CONFIG_VHOST_VSOCK=m

Launch QEMU as follows:
  # qemu ... -device vhost-vsock-pci,id=vhost-vsock-pci0,guest-cid=3

Guest and host can communicate via AF_VSOCK sockets.  The host's CID (address)
is 2 and the guest is automatically assigned a CID (use VMADDR_CID_ANY (-1) to
bind to it).

Status
------
There are a few design changes I'd like to make to the virtio-vsock device:

1. The 3-way handshake isn't necessary over a reliable transport (virtqueue).
   Spoofing packets is also impossible so the security aspects of the 3-way
   handshake (including syn cookie) add nothing.  The next version will have a
   single operation to establish a connection.

2. Credit-based flow control doesn't work for SOCK_DGRAM since multiple clients
   can transmit to the same listen socket.  There is no way for the clients to
   coordinate buffer space with each other fairly.  The next version will drop
   credit-based flow control for SOCK_DGRAM and only rely on best-effort
   delivery.  SOCK_STREAM still has guaranteed delivery.

3. In the next version only the host will be able to establish connections
   (i.e. to connect to a guest agent).  This is for security reasons since
   there is currently no ability to provide host services only to certain
   guests.  This also matches how AF_VSOCK works on modern VMware hypervisors.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents c89359a4 8a2a2029

drivers/vhost/Kconfig

+4 −0
Original line number Diff line number Diff line
@@ -47,3 +47,7 @@ config VHOST_CROSS_ENDIAN_LEGACY 
	  adds some overhead, it is disabled by default.



	  If unsure, say "N".



if STAGING

source "drivers/vhost/Kconfig.vsock"

endif

drivers/vhost/Kconfig.vsock

0 → 100644
+7 −0
Original line number Diff line number Diff line 
config VHOST_VSOCK

	tristate "vhost virtio-vsock driver"

	depends on VSOCKETS && EVENTFD

	select VIRTIO_VSOCKETS_COMMON

	default n

	---help---

	Say M here to enable the vhost-vsock for virtio-vsock guests

drivers/vhost/Makefile

+4 −0
Original line number Diff line number Diff line
@@ -4,5 +4,9 @@ vhost_net-y := net.o 
obj-$(CONFIG_VHOST_SCSI) += vhost_scsi.o

vhost_scsi-y := scsi.o



obj-$(CONFIG_VHOST_VSOCK) += vhost_vsock.o

vhost_vsock-y := vsock.o



obj-$(CONFIG_VHOST_RING) += vringh.o



obj-$(CONFIG_VHOST)	+= vhost.o

drivers/vhost/vsock.c

0 → 100644
+631 −0
Original line number Diff line number Diff line 
/*

 * vhost transport for vsock

 *

 * Copyright (C) 2013-2015 Red Hat, Inc.

 * Author: Asias He <asias@redhat.com>

 *         Stefan Hajnoczi <stefanha@redhat.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2.

 */

#include <linux/miscdevice.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <net/sock.h>

#include <linux/virtio_vsock.h>

#include <linux/vhost.h>



#include <net/af_vsock.h>

#include "vhost.h"

#include "vsock.h"



#define VHOST_VSOCK_DEFAULT_HOST_CID	2



static int vhost_transport_socket_init(struct vsock_sock *vsk,

				       struct vsock_sock *psk);



enum {

	VHOST_VSOCK_FEATURES = VHOST_FEATURES,

};



/* Used to track all the vhost_vsock instances on the system. */

static LIST_HEAD(vhost_vsock_list);

static DEFINE_MUTEX(vhost_vsock_mutex);



struct vhost_vsock_virtqueue {

	struct vhost_virtqueue vq;

};



struct vhost_vsock {

	/* Vhost device */

	struct vhost_dev dev;

	/* Vhost vsock virtqueue*/

	struct vhost_vsock_virtqueue vqs[VSOCK_VQ_MAX];

	/* Link to global vhost_vsock_list*/

	struct list_head list;

	/* Head for pkt from host to guest */

	struct list_head send_pkt_list;

	/* Work item to send pkt */

	struct vhost_work send_pkt_work;

	/* Wait queue for send pkt */

	wait_queue_head_t queue_wait;

	/* Used for global tx buf limitation */

	u32 total_tx_buf;

	/* Guest contex id this vhost_vsock instance handles */

	u32 guest_cid;

};



static u32 vhost_transport_get_local_cid(void)

{

	u32 cid = VHOST_VSOCK_DEFAULT_HOST_CID;

	return cid;

}



static struct vhost_vsock *vhost_vsock_get(u32 guest_cid)

{

	struct vhost_vsock *vsock;



	mutex_lock(&vhost_vsock_mutex);

	list_for_each_entry(vsock, &vhost_vsock_list, list) {

		if (vsock->guest_cid == guest_cid) {

			mutex_unlock(&vhost_vsock_mutex);

			return vsock;

		}

	}

	mutex_unlock(&vhost_vsock_mutex);



	return NULL;

}



static void

vhost_transport_do_send_pkt(struct vhost_vsock *vsock,

			    struct vhost_virtqueue *vq)

{

	bool added = false;



	mutex_lock(&vq->mutex);

	vhost_disable_notify(&vsock->dev, vq);

	for (;;) {

		struct virtio_vsock_pkt *pkt;

		struct iov_iter iov_iter;

		unsigned out, in;

		struct sock *sk;

		size_t nbytes;

		size_t len;

		int head;



		if (list_empty(&vsock->send_pkt_list)) {

			vhost_enable_notify(&vsock->dev, vq);

			break;

		}



		head = vhost_get_vq_desc(vq, vq->iov, ARRAY_SIZE(vq->iov),

					 &out, &in, NULL, NULL);

		pr_debug("%s: head = %d\n", __func__, head);

		if (head < 0)

			break;



		if (head == vq->num) {

			if (unlikely(vhost_enable_notify(&vsock->dev, vq))) {

				vhost_disable_notify(&vsock->dev, vq);

				continue;

			}

			break;

		}



		pkt = list_first_entry(&vsock->send_pkt_list,

				       struct virtio_vsock_pkt, list);

		list_del_init(&pkt->list);



		if (out) {

			virtio_transport_free_pkt(pkt);

			vq_err(vq, "Expected 0 output buffers, got %u\n", out);

			break;

		}



		len = iov_length(&vq->iov[out], in);

		iov_iter_init(&iov_iter, READ, &vq->iov[out], in, len);



		nbytes = copy_to_iter(&pkt->hdr, sizeof(pkt->hdr), &iov_iter);

		if (nbytes != sizeof(pkt->hdr)) {

			virtio_transport_free_pkt(pkt);

			vq_err(vq, "Faulted on copying pkt hdr\n");

			break;

		}



		nbytes = copy_to_iter(pkt->buf, pkt->len, &iov_iter);

		if (nbytes != pkt->len) {

			virtio_transport_free_pkt(pkt);

			vq_err(vq, "Faulted on copying pkt buf\n");

			break;

		}



		vhost_add_used(vq, head, pkt->len); /* TODO should this be sizeof(pkt->hdr) + pkt->len? */

		added = true;



		virtio_transport_dec_tx_pkt(pkt);

		vsock->total_tx_buf -= pkt->len;



		sk = sk_vsock(pkt->trans->vsk);

		/* Release refcnt taken in vhost_transport_send_pkt */

		sock_put(sk);



		virtio_transport_free_pkt(pkt);

	}

	if (added)

		vhost_signal(&vsock->dev, vq);

	mutex_unlock(&vq->mutex);



	if (added)

		wake_up(&vsock->queue_wait);

}



static void vhost_transport_send_pkt_work(struct vhost_work *work)

{

	struct vhost_virtqueue *vq;

	struct vhost_vsock *vsock;



	vsock = container_of(work, struct vhost_vsock, send_pkt_work);

	vq = &vsock->vqs[VSOCK_VQ_RX].vq;



	vhost_transport_do_send_pkt(vsock, vq);

}



static int

vhost_transport_send_pkt(struct vsock_sock *vsk,

			 struct virtio_vsock_pkt_info *info)

{

	u32 src_cid, src_port, dst_cid, dst_port;

	struct virtio_transport *trans;

	struct virtio_vsock_pkt *pkt;

	struct vhost_virtqueue *vq;

	struct vhost_vsock *vsock;

	u32 pkt_len = info->pkt_len;

	DEFINE_WAIT(wait);



	src_cid = vhost_transport_get_local_cid();

	src_port = vsk->local_addr.svm_port;

	if (!info->remote_cid) {

		dst_cid	= vsk->remote_addr.svm_cid;

		dst_port = vsk->remote_addr.svm_port;

	} else {

		dst_cid = info->remote_cid;

		dst_port = info->remote_port;

	}



	/* Find the vhost_vsock according to guest context id  */

	vsock = vhost_vsock_get(dst_cid);

	if (!vsock)

		return -ENODEV;



	trans = vsk->trans;

	vq = &vsock->vqs[VSOCK_VQ_RX].vq;



	/* we can send less than pkt_len bytes */

	if (pkt_len > VIRTIO_VSOCK_DEFAULT_RX_BUF_SIZE)

		pkt_len = VIRTIO_VSOCK_DEFAULT_RX_BUF_SIZE;



	/* virtio_transport_get_credit might return less than pkt_len credit */

	pkt_len = virtio_transport_get_credit(trans, pkt_len);



	/* Do not send zero length OP_RW pkt*/

	if (pkt_len == 0 && info->op == VIRTIO_VSOCK_OP_RW)

		return pkt_len;



	/* Respect global tx buf limitation */

	mutex_lock(&vq->mutex);

	while (pkt_len + vsock->total_tx_buf > VIRTIO_VSOCK_MAX_TX_BUF_SIZE) {

		prepare_to_wait_exclusive(&vsock->queue_wait, &wait,

					  TASK_UNINTERRUPTIBLE);

		mutex_unlock(&vq->mutex);

		schedule();

		mutex_lock(&vq->mutex);

		finish_wait(&vsock->queue_wait, &wait);

	}

	vsock->total_tx_buf += pkt_len;

	mutex_unlock(&vq->mutex);



	pkt = virtio_transport_alloc_pkt(vsk, info, pkt_len,

					 src_cid, src_port,

					 dst_cid, dst_port);

	if (!pkt) {

		mutex_lock(&vq->mutex);

		vsock->total_tx_buf -= pkt_len;

		mutex_unlock(&vq->mutex);

		virtio_transport_put_credit(trans, pkt_len);

		return -ENOMEM;

	}



	pr_debug("%s:info->pkt_len= %d\n", __func__, pkt_len);

	/* Released in vhost_transport_do_send_pkt */

	sock_hold(&trans->vsk->sk);

	virtio_transport_inc_tx_pkt(pkt);



	/* Queue it up in vhost work */

	mutex_lock(&vq->mutex);

	list_add_tail(&pkt->list, &vsock->send_pkt_list);

	vhost_work_queue(&vsock->dev, &vsock->send_pkt_work);

	mutex_unlock(&vq->mutex);



	return pkt_len;

}



static struct virtio_transport_pkt_ops vhost_ops = {

	.send_pkt = vhost_transport_send_pkt,

};



static struct virtio_vsock_pkt *

vhost_vsock_alloc_pkt(struct vhost_virtqueue *vq,

		      unsigned int out, unsigned int in)

{

	struct virtio_vsock_pkt *pkt;

	struct iov_iter iov_iter;

	size_t nbytes;

	size_t len;



	if (in != 0) {

		vq_err(vq, "Expected 0 input buffers, got %u\n", in);

		return NULL;

	}



	pkt = kzalloc(sizeof(*pkt), GFP_KERNEL);

	if (!pkt)

		return NULL;



	len = iov_length(vq->iov, out);

	iov_iter_init(&iov_iter, WRITE, vq->iov, out, len);



	nbytes = copy_from_iter(&pkt->hdr, sizeof(pkt->hdr), &iov_iter);

	if (nbytes != sizeof(pkt->hdr)) {

		vq_err(vq, "Expected %zu bytes for pkt->hdr, got %zu bytes\n",

		       sizeof(pkt->hdr), nbytes);

		kfree(pkt);

		return NULL;

	}



	if (le16_to_cpu(pkt->hdr.type) == VIRTIO_VSOCK_TYPE_DGRAM)

		pkt->len = le32_to_cpu(pkt->hdr.len) & 0XFFFF;

	else if (le16_to_cpu(pkt->hdr.type) == VIRTIO_VSOCK_TYPE_STREAM)

		pkt->len = le32_to_cpu(pkt->hdr.len);



	/* No payload */

	if (!pkt->len)

		return pkt;



	/* The pkt is too big */

	if (pkt->len > VIRTIO_VSOCK_MAX_PKT_BUF_SIZE) {

		kfree(pkt);

		return NULL;

	}



	pkt->buf = kmalloc(pkt->len, GFP_KERNEL);

	if (!pkt->buf) {

		kfree(pkt);

		return NULL;

	}



	nbytes = copy_from_iter(pkt->buf, pkt->len, &iov_iter);

	if (nbytes != pkt->len) {

		vq_err(vq, "Expected %u byte payload, got %zu bytes\n",

		       pkt->len, nbytes);

		virtio_transport_free_pkt(pkt);

		return NULL;

	}



	return pkt;

}



static void vhost_vsock_handle_ctl_kick(struct vhost_work *work)

{

	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,

						  poll.work);

	struct vhost_vsock *vsock = container_of(vq->dev, struct vhost_vsock,

						 dev);



	pr_debug("%s vq=%p, vsock=%p\n", __func__, vq, vsock);

}



static void vhost_vsock_handle_tx_kick(struct vhost_work *work)

{

	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,

						  poll.work);

	struct vhost_vsock *vsock = container_of(vq->dev, struct vhost_vsock,

						 dev);

	struct virtio_vsock_pkt *pkt;

	int head;

	unsigned int out, in;

	bool added = false;

	u32 len;



	mutex_lock(&vq->mutex);

	vhost_disable_notify(&vsock->dev, vq);

	for (;;) {

		head = vhost_get_vq_desc(vq, vq->iov, ARRAY_SIZE(vq->iov),

					 &out, &in, NULL, NULL);

		if (head < 0)

			break;



		if (head == vq->num) {

			if (unlikely(vhost_enable_notify(&vsock->dev, vq))) {

				vhost_disable_notify(&vsock->dev, vq);

				continue;

			}

			break;

		}



		pkt = vhost_vsock_alloc_pkt(vq, out, in);

		if (!pkt) {

			vq_err(vq, "Faulted on pkt\n");

			continue;

		}



		len = pkt->len;



		/* Only accept correctly addressed packets */

		if (le32_to_cpu(pkt->hdr.src_cid) == vsock->guest_cid &&

		    le32_to_cpu(pkt->hdr.dst_cid) == vhost_transport_get_local_cid())

			virtio_transport_recv_pkt(pkt);

		else

			virtio_transport_free_pkt(pkt);



		vhost_add_used(vq, head, len);

		added = true;

	}

	if (added)

		vhost_signal(&vsock->dev, vq);

	mutex_unlock(&vq->mutex);

}



static void vhost_vsock_handle_rx_kick(struct vhost_work *work)

{

	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,

						poll.work);

	struct vhost_vsock *vsock = container_of(vq->dev, struct vhost_vsock,

						 dev);



	vhost_transport_do_send_pkt(vsock, vq);

}



static int vhost_vsock_dev_open(struct inode *inode, struct file *file)

{

	struct vhost_virtqueue **vqs;

	struct vhost_vsock *vsock;

	int ret;



	vsock = kzalloc(sizeof(*vsock), GFP_KERNEL);

	if (!vsock)

		return -ENOMEM;



	pr_debug("%s:vsock=%p\n", __func__, vsock);



	vqs = kmalloc(VSOCK_VQ_MAX * sizeof(*vqs), GFP_KERNEL);

	if (!vqs) {

		ret = -ENOMEM;

		goto out;

	}



	vqs[VSOCK_VQ_CTRL] = &vsock->vqs[VSOCK_VQ_CTRL].vq;

	vqs[VSOCK_VQ_TX] = &vsock->vqs[VSOCK_VQ_TX].vq;

	vqs[VSOCK_VQ_RX] = &vsock->vqs[VSOCK_VQ_RX].vq;

	vsock->vqs[VSOCK_VQ_CTRL].vq.handle_kick = vhost_vsock_handle_ctl_kick;

	vsock->vqs[VSOCK_VQ_TX].vq.handle_kick = vhost_vsock_handle_tx_kick;

	vsock->vqs[VSOCK_VQ_RX].vq.handle_kick = vhost_vsock_handle_rx_kick;



	vhost_dev_init(&vsock->dev, vqs, VSOCK_VQ_MAX);



	file->private_data = vsock;

	init_waitqueue_head(&vsock->queue_wait);

	INIT_LIST_HEAD(&vsock->send_pkt_list);

	vhost_work_init(&vsock->send_pkt_work, vhost_transport_send_pkt_work);



	mutex_lock(&vhost_vsock_mutex);

	list_add_tail(&vsock->list, &vhost_vsock_list);

	mutex_unlock(&vhost_vsock_mutex);

	return 0;



out:

	kfree(vsock);

	return ret;

}



static void vhost_vsock_flush(struct vhost_vsock *vsock)

{

	int i;



	for (i = 0; i < VSOCK_VQ_MAX; i++)

		vhost_poll_flush(&vsock->vqs[i].vq.poll);

	vhost_work_flush(&vsock->dev, &vsock->send_pkt_work);

}



static int vhost_vsock_dev_release(struct inode *inode, struct file *file)

{

	struct vhost_vsock *vsock = file->private_data;



	mutex_lock(&vhost_vsock_mutex);

	list_del(&vsock->list);

	mutex_unlock(&vhost_vsock_mutex);



	vhost_dev_stop(&vsock->dev);

	vhost_vsock_flush(vsock);

	vhost_dev_cleanup(&vsock->dev, false);

	kfree(vsock->dev.vqs);

	kfree(vsock);

	return 0;

}



static int vhost_vsock_set_cid(struct vhost_vsock *vsock, u32 guest_cid)

{

	struct vhost_vsock *other;



	/* Refuse reserved CIDs */

	if (guest_cid <= VMADDR_CID_HOST) {

		return -EINVAL;

	}



	/* Refuse if CID is already in use */

	other = vhost_vsock_get(guest_cid);

	if (other && other != vsock) {

		return -EADDRINUSE;

	}



	mutex_lock(&vhost_vsock_mutex);

	vsock->guest_cid = guest_cid;

	pr_debug("%s:guest_cid=%d\n", __func__, guest_cid);

	mutex_unlock(&vhost_vsock_mutex);



	return 0;

}



static int vhost_vsock_set_features(struct vhost_vsock *vsock, u64 features)

{

	struct vhost_virtqueue *vq;

	int i;



	if (features & ~VHOST_VSOCK_FEATURES)

		return -EOPNOTSUPP;



	mutex_lock(&vsock->dev.mutex);

	if ((features & (1 << VHOST_F_LOG_ALL)) &&

	    !vhost_log_access_ok(&vsock->dev)) {

		mutex_unlock(&vsock->dev.mutex);

		return -EFAULT;

	}



	for (i = 0; i < VSOCK_VQ_MAX; i++) {

		vq = &vsock->vqs[i].vq;

		mutex_lock(&vq->mutex);

		vq->acked_features = features;

		mutex_unlock(&vq->mutex);

	}

	mutex_unlock(&vsock->dev.mutex);

	return 0;

}



static long vhost_vsock_dev_ioctl(struct file *f, unsigned int ioctl,

				  unsigned long arg)

{

	struct vhost_vsock *vsock = f->private_data;

	void __user *argp = (void __user *)arg;

	u64 __user *featurep = argp;

	u32 __user *cidp = argp;

	u32 guest_cid;

	u64 features;

	int r;



	switch (ioctl) {

	case VHOST_VSOCK_SET_GUEST_CID:

		if (get_user(guest_cid, cidp))

			return -EFAULT;

		return vhost_vsock_set_cid(vsock, guest_cid);

	case VHOST_GET_FEATURES:

		features = VHOST_VSOCK_FEATURES;

		if (copy_to_user(featurep, &features, sizeof(features)))

			return -EFAULT;

		return 0;

	case VHOST_SET_FEATURES:

		if (copy_from_user(&features, featurep, sizeof(features)))

			return -EFAULT;

		return vhost_vsock_set_features(vsock, features);

	default:

		mutex_lock(&vsock->dev.mutex);

		r = vhost_dev_ioctl(&vsock->dev, ioctl, argp);

		if (r == -ENOIOCTLCMD)

			r = vhost_vring_ioctl(&vsock->dev, ioctl, argp);

		else

			vhost_vsock_flush(vsock);

		mutex_unlock(&vsock->dev.mutex);

		return r;

	}

}



static const struct file_operations vhost_vsock_fops = {

	.owner          = THIS_MODULE,

	.open           = vhost_vsock_dev_open,

	.release        = vhost_vsock_dev_release,

	.llseek		= noop_llseek,

	.unlocked_ioctl = vhost_vsock_dev_ioctl,

};



static struct miscdevice vhost_vsock_misc = {

	.minor = MISC_DYNAMIC_MINOR,

	.name = "vhost-vsock",

	.fops = &vhost_vsock_fops,

};



static int

vhost_transport_socket_init(struct vsock_sock *vsk, struct vsock_sock *psk)

{

	struct virtio_transport *trans;

	int ret;



	ret = virtio_transport_do_socket_init(vsk, psk);

	if (ret)

		return ret;



	trans = vsk->trans;

	trans->ops = &vhost_ops;



	return ret;

}



static struct vsock_transport vhost_transport = {

	.get_local_cid            = vhost_transport_get_local_cid,



	.init                     = vhost_transport_socket_init,

	.destruct                 = virtio_transport_destruct,

	.release                  = virtio_transport_release,

	.connect                  = virtio_transport_connect,

	.shutdown                 = virtio_transport_shutdown,



	.dgram_enqueue            = virtio_transport_dgram_enqueue,

	.dgram_dequeue            = virtio_transport_dgram_dequeue,

	.dgram_bind               = virtio_transport_dgram_bind,

	.dgram_allow              = virtio_transport_dgram_allow,



	.stream_enqueue           = virtio_transport_stream_enqueue,

	.stream_dequeue           = virtio_transport_stream_dequeue,

	.stream_has_data          = virtio_transport_stream_has_data,

	.stream_has_space         = virtio_transport_stream_has_space,

	.stream_rcvhiwat          = virtio_transport_stream_rcvhiwat,

	.stream_is_active         = virtio_transport_stream_is_active,

	.stream_allow             = virtio_transport_stream_allow,



	.notify_poll_in           = virtio_transport_notify_poll_in,

	.notify_poll_out          = virtio_transport_notify_poll_out,

	.notify_recv_init         = virtio_transport_notify_recv_init,

	.notify_recv_pre_block    = virtio_transport_notify_recv_pre_block,

	.notify_recv_pre_dequeue  = virtio_transport_notify_recv_pre_dequeue,

	.notify_recv_post_dequeue = virtio_transport_notify_recv_post_dequeue,

	.notify_send_init         = virtio_transport_notify_send_init,

	.notify_send_pre_block    = virtio_transport_notify_send_pre_block,

	.notify_send_pre_enqueue  = virtio_transport_notify_send_pre_enqueue,

	.notify_send_post_enqueue = virtio_transport_notify_send_post_enqueue,



	.set_buffer_size          = virtio_transport_set_buffer_size,

	.set_min_buffer_size      = virtio_transport_set_min_buffer_size,

	.set_max_buffer_size      = virtio_transport_set_max_buffer_size,

	.get_buffer_size          = virtio_transport_get_buffer_size,

	.get_min_buffer_size      = virtio_transport_get_min_buffer_size,

	.get_max_buffer_size      = virtio_transport_get_max_buffer_size,

};



static int __init vhost_vsock_init(void)

{

	int ret;



	ret = vsock_core_init(&vhost_transport);

	if (ret < 0)

		return ret;

	return misc_register(&vhost_vsock_misc);

};



static void __exit vhost_vsock_exit(void)

{

	misc_deregister(&vhost_vsock_misc);

	vsock_core_exit();

};



module_init(vhost_vsock_init);

module_exit(vhost_vsock_exit);

MODULE_LICENSE("GPL v2");

MODULE_AUTHOR("Asias He");

MODULE_DESCRIPTION("vhost transport for vsock ");

drivers/vhost/vsock.h

0 → 100644
+4 −0
Original line number Diff line number Diff line 
#ifndef VHOST_VSOCK_H

#define VHOST_VSOCK_H

#define VHOST_VSOCK_SET_GUEST_CID _IOW(VHOST_VIRTIO, 0x60, __u32)

#endif