[deliverable/linux.git] / drivers / vhost / test.c

/* Copyright (C) 2009 Red Hat, Inc.
 * Author: Michael S. Tsirkin <mst@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.
 *
 * test virtio server in host kernel.
 */

#include <linux/compat.h>
#include <linux/eventfd.h>
#include <linux/vhost.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include <linux/file.h>
#include <linux/slab.h>

#include "test.h"
#include "vhost.h"

/* Max number of bytes transferred before requeueing the job.
 * Using this limit prevents one virtqueue from starving others. */
#define VHOST_TEST_WEIGHT 0x80000

enum {
	VHOST_TEST_VQ = 0,
	VHOST_TEST_VQ_MAX = 1,
};

struct vhost_test {
	struct vhost_dev dev;
	struct vhost_virtqueue vqs[VHOST_TEST_VQ_MAX];
};

/* Expects to be always run from workqueue - which acts as
 * read-size critical section for our kind of RCU. */
static void handle_vq(struct vhost_test *n)
{
	struct vhost_virtqueue *vq = &n->vqs[VHOST_TEST_VQ];
	unsigned out, in;
	int head;
	size_t len, total_len = 0;
	void *private;

	mutex_lock(&vq->mutex);
	private = vq->private_data;
	if (!private) {
		mutex_unlock(&vq->mutex);
		return;
	}

	vhost_disable_notify(&n->dev, vq);

	for (;;) {
		head = vhost_get_vq_desc(vq, vq->iov,
					 ARRAY_SIZE(vq->iov),
					 &out, &in,
					 NULL, NULL);
		/* On error, stop handling until the next kick. */
		if (unlikely(head < 0))
			break;
		/* Nothing new?  Wait for eventfd to tell us they refilled. */
		if (head == vq->num) {
			if (unlikely(vhost_enable_notify(&n->dev, vq))) {
				vhost_disable_notify(&n->dev, vq);
				continue;
			}
			break;
		}
		if (in) {
			vq_err(vq, "Unexpected descriptor format for TX: "
			       "out %d, int %d\n", out, in);
			break;
		}
		len = iov_length(vq->iov, out);
		/* Sanity check */
		if (!len) {
			vq_err(vq, "Unexpected 0 len for TX\n");
			break;
		}
		vhost_add_used_and_signal(&n->dev, vq, head, 0);
		total_len += len;
		if (unlikely(total_len >= VHOST_TEST_WEIGHT)) {
			vhost_poll_queue(&vq->poll);
			break;
		}
	}

	mutex_unlock(&vq->mutex);
}

static void handle_vq_kick(struct vhost_work *work)
{
	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
						  poll.work);
	struct vhost_test *n = container_of(vq->dev, struct vhost_test, dev);

	handle_vq(n);
}

static int vhost_test_open(struct inode *inode, struct file *f)
{
	struct vhost_test *n = kmalloc(sizeof *n, GFP_KERNEL);
	struct vhost_dev *dev;
	struct vhost_virtqueue **vqs;

	if (!n)
		return -ENOMEM;
	vqs = kmalloc(VHOST_TEST_VQ_MAX * sizeof(*vqs), GFP_KERNEL);
	if (!vqs) {
		kfree(n);
		return -ENOMEM;
	}

	dev = &n->dev;
	vqs[VHOST_TEST_VQ] = &n->vqs[VHOST_TEST_VQ];
	n->vqs[VHOST_TEST_VQ].handle_kick = handle_vq_kick;
	vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX);

	f->private_data = n;

	return 0;
}

static void *vhost_test_stop_vq(struct vhost_test *n,
				struct vhost_virtqueue *vq)
{
	void *private;

	mutex_lock(&vq->mutex);
	private = vq->private_data;
	vq->private_data = NULL;
	mutex_unlock(&vq->mutex);
	return private;
}

static void vhost_test_stop(struct vhost_test *n, void **privatep)
{
	*privatep = vhost_test_stop_vq(n, n->vqs + VHOST_TEST_VQ);
}

static void vhost_test_flush_vq(struct vhost_test *n, int index)
{
	vhost_poll_flush(&n->vqs[index].poll);
}

static void vhost_test_flush(struct vhost_test *n)
{
	vhost_test_flush_vq(n, VHOST_TEST_VQ);
}

static int vhost_test_release(struct inode *inode, struct file *f)
{
	struct vhost_test *n = f->private_data;
	void  *private;

	vhost_test_stop(n, &private);
	vhost_test_flush(n);
	vhost_dev_cleanup(&n->dev, false);
	/* We do an extra flush before freeing memory,
	 * since jobs can re-queue themselves. */
	vhost_test_flush(n);
	kfree(n);
	return 0;
}

static long vhost_test_run(struct vhost_test *n, int test)
{
	void *priv, *oldpriv;
	struct vhost_virtqueue *vq;
	int r, index;

	if (test < 0 || test > 1)
		return -EINVAL;

	mutex_lock(&n->dev.mutex);
	r = vhost_dev_check_owner(&n->dev);
	if (r)
		goto err;

	for (index = 0; index < n->dev.nvqs; ++index) {
		/* Verify that ring has been setup correctly. */
		if (!vhost_vq_access_ok(&n->vqs[index])) {
			r = -EFAULT;
			goto err;
		}
	}

	for (index = 0; index < n->dev.nvqs; ++index) {
		vq = n->vqs + index;
		mutex_lock(&vq->mutex);
		priv = test ? n : NULL;

		/* start polling new socket */
		oldpriv = vq->private_data;
		vq->private_data = priv;

		r = vhost_vq_init_access(&n->vqs[index]);

		mutex_unlock(&vq->mutex);

		if (r)
			goto err;

		if (oldpriv) {
			vhost_test_flush_vq(n, index);
		}
	}

	mutex_unlock(&n->dev.mutex);
	return 0;

err:
	mutex_unlock(&n->dev.mutex);
	return r;
}

static long vhost_test_reset_owner(struct vhost_test *n)
{
	void *priv = NULL;
	long err;
	struct vhost_umem *umem;

	mutex_lock(&n->dev.mutex);
	err = vhost_dev_check_owner(&n->dev);
	if (err)
		goto done;
	umem = vhost_dev_reset_owner_prepare();
	if (!umem) {
		err = -ENOMEM;
		goto done;
	}
	vhost_test_stop(n, &priv);
	vhost_test_flush(n);
	vhost_dev_reset_owner(&n->dev, umem);
done:
	mutex_unlock(&n->dev.mutex);
	return err;
}

static int vhost_test_set_features(struct vhost_test *n, u64 features)
{
	struct vhost_virtqueue *vq;

	mutex_lock(&n->dev.mutex);
	if ((features & (1 << VHOST_F_LOG_ALL)) &&
	    !vhost_log_access_ok(&n->dev)) {
		mutex_unlock(&n->dev.mutex);
		return -EFAULT;
	}
	vq = &n->vqs[VHOST_TEST_VQ];
	mutex_lock(&vq->mutex);
	vq->acked_features = features;
	mutex_unlock(&vq->mutex);
	mutex_unlock(&n->dev.mutex);
	return 0;
}

static long vhost_test_ioctl(struct file *f, unsigned int ioctl,
			     unsigned long arg)
{
	struct vhost_test *n = f->private_data;
	void __user *argp = (void __user *)arg;
	u64 __user *featurep = argp;
	int test;
	u64 features;
	int r;
	switch (ioctl) {
	case VHOST_TEST_RUN:
		if (copy_from_user(&test, argp, sizeof test))
			return -EFAULT;
		return vhost_test_run(n, test);
	case VHOST_GET_FEATURES:
		features = VHOST_FEATURES;
		if (copy_to_user(featurep, &features, sizeof features))
			return -EFAULT;
		return 0;
	case VHOST_SET_FEATURES:
		printk(KERN_ERR "1\n");
		if (copy_from_user(&features, featurep, sizeof features))
			return -EFAULT;
		printk(KERN_ERR "2\n");
		if (features & ~VHOST_FEATURES)
			return -EOPNOTSUPP;
		printk(KERN_ERR "3\n");
		return vhost_test_set_features(n, features);
	case VHOST_RESET_OWNER:
		return vhost_test_reset_owner(n);
	default:
		mutex_lock(&n->dev.mutex);
		r = vhost_dev_ioctl(&n->dev, ioctl, argp);
                if (r == -ENOIOCTLCMD)
                        r = vhost_vring_ioctl(&n->dev, ioctl, argp);
		vhost_test_flush(n);
		mutex_unlock(&n->dev.mutex);
		return r;
	}
}

#ifdef CONFIG_COMPAT
static long vhost_test_compat_ioctl(struct file *f, unsigned int ioctl,
				   unsigned long arg)
{
	return vhost_test_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
}
#endif

static const struct file_operations vhost_test_fops = {
	.owner          = THIS_MODULE,
	.release        = vhost_test_release,
	.unlocked_ioctl = vhost_test_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl   = vhost_test_compat_ioctl,
#endif
	.open           = vhost_test_open,
	.llseek		= noop_llseek,
};

static struct miscdevice vhost_test_misc = {
	MISC_DYNAMIC_MINOR,
	"vhost-test",
	&vhost_test_fops,
};
module_misc_device(vhost_test_misc);

MODULE_VERSION("0.0.1");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Michael S. Tsirkin");
MODULE_DESCRIPTION("Host kernel side for virtio simulator");
Commit	Line	Data
71ccc212 MT	1	/* Copyright (C) 2009 Red Hat, Inc.
	2	* Author: Michael S. Tsirkin <mst@redhat.com>
	3	*
	4	* This work is licensed under the terms of the GNU GPL, version 2.
	5	*
	6	* test virtio server in host kernel.
	7	*/
	8
	9	#include <linux/compat.h>
	10	#include <linux/eventfd.h>
	11	#include <linux/vhost.h>
	12	#include <linux/miscdevice.h>
	13	#include <linux/module.h>
	14	#include <linux/mutex.h>
	15	#include <linux/workqueue.h>
71ccc212 MT	16	#include <linux/file.h>
	17	#include <linux/slab.h>
	18
	19	#include "test.h"
6ac1afbf	20	#include "vhost.h"
71ccc212 MT	21
	22	/* Max number of bytes transferred before requeueing the job.
	23	* Using this limit prevents one virtqueue from starving others. */
	24	#define VHOST_TEST_WEIGHT 0x80000
	25
	26	enum {
	27	VHOST_TEST_VQ = 0,
	28	VHOST_TEST_VQ_MAX = 1,
	29	};
	30
	31	struct vhost_test {
	32	struct vhost_dev dev;
	33	struct vhost_virtqueue vqs[VHOST_TEST_VQ_MAX];
	34	};
	35
	36	/* Expects to be always run from workqueue - which acts as
	37	* read-size critical section for our kind of RCU. */
	38	static void handle_vq(struct vhost_test *n)
	39	{
09a34c84	40	struct vhost_virtqueue *vq = &n->vqs[VHOST_TEST_VQ];
71ccc212 MT	41	unsigned out, in;
	42	int head;
	43	size_t len, total_len = 0;
	44	void *private;
	45
09a34c84 MT	46	mutex_lock(&vq->mutex);
	47	private = vq->private_data;
	48	if (!private) {
	49	mutex_unlock(&vq->mutex);
71ccc212	50	return;
09a34c84	51	}
71ccc212	52
8ea8cf89	53	vhost_disable_notify(&n->dev, vq);
71ccc212 MT	54
71ccc212 MT	55	for (;;) {
47283bef	56	head = vhost_get_vq_desc(vq, vq->iov,
71ccc212 MT	57	ARRAY_SIZE(vq->iov),
	58	&out, &in,
	59	NULL, NULL);
	60	/* On error, stop handling until the next kick. */
	61	if (unlikely(head < 0))
	62	break;
	63	/* Nothing new? Wait for eventfd to tell us they refilled. */
	64	if (head == vq->num) {
8ea8cf89 MT	65	if (unlikely(vhost_enable_notify(&n->dev, vq))) {
8ea8cf89 MT	66	vhost_disable_notify(&n->dev, vq);
71ccc212 MT	67	continue;
	68	}
	69	break;
	70	}
	71	if (in) {
	72	vq_err(vq, "Unexpected descriptor format for TX: "
	73	"out %d, int %d\n", out, in);
	74	break;
	75	}
	76	len = iov_length(vq->iov, out);
	77	/* Sanity check */
	78	if (!len) {
	79	vq_err(vq, "Unexpected 0 len for TX\n");
	80	break;
	81	}
	82	vhost_add_used_and_signal(&n->dev, vq, head, 0);
	83	total_len += len;
	84	if (unlikely(total_len >= VHOST_TEST_WEIGHT)) {
	85	vhost_poll_queue(&vq->poll);
	86	break;
	87	}
	88	}
	89
	90	mutex_unlock(&vq->mutex);
	91	}
	92
	93	static void handle_vq_kick(struct vhost_work *work)
	94	{
	95	struct vhost_virtqueue *vq = container_of(work, struct vhost_virtqueue,
	96	poll.work);
	97	struct vhost_test *n = container_of(vq->dev, struct vhost_test, dev);
	98
	99	handle_vq(n);
	100	}
	101
	102	static int vhost_test_open(struct inode inode, struct file f)
	103	{
	104	struct vhost_test n = kmalloc(sizeof n, GFP_KERNEL);
	105	struct vhost_dev *dev;
09a34c84	106	struct vhost_virtqueue **vqs;
71ccc212 MT	107
	108	if (!n)
	109	return -ENOMEM;
09a34c84 MT	110	vqs = kmalloc(VHOST_TEST_VQ_MAX * sizeof(*vqs), GFP_KERNEL);
	111	if (!vqs) {
	112	kfree(n);
	113	return -ENOMEM;
	114	}
71ccc212 MT	115
71ccc212 MT	116	dev = &n->dev;
09a34c84	117	vqs[VHOST_TEST_VQ] = &n->vqs[VHOST_TEST_VQ];
71ccc212	118	n->vqs[VHOST_TEST_VQ].handle_kick = handle_vq_kick;
59566b6e	119	vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX);
71ccc212 MT	120
	121	f->private_data = n;
	122
	123	return 0;
	124	}
	125
	126	static void vhost_test_stop_vq(struct vhost_test n,
	127	struct vhost_virtqueue *vq)
	128	{
	129	void *private;
	130
	131	mutex_lock(&vq->mutex);
09a34c84 MT	132	private = vq->private_data;
09a34c84 MT	133	vq->private_data = NULL;
71ccc212 MT	134	mutex_unlock(&vq->mutex);
	135	return private;
	136	}
	137
	138	static void vhost_test_stop(struct vhost_test n, void *privatep)
	139	{
	140	*privatep = vhost_test_stop_vq(n, n->vqs + VHOST_TEST_VQ);
	141	}
	142
	143	static void vhost_test_flush_vq(struct vhost_test *n, int index)
	144	{
09a34c84	145	vhost_poll_flush(&n->vqs[index].poll);
71ccc212 MT	146	}
	147
	148	static void vhost_test_flush(struct vhost_test *n)
	149	{
	150	vhost_test_flush_vq(n, VHOST_TEST_VQ);
	151	}
	152
	153	static int vhost_test_release(struct inode inode, struct file f)
	154	{
	155	struct vhost_test *n = f->private_data;
	156	void *private;
	157
	158	vhost_test_stop(n, &private);
	159	vhost_test_flush(n);
5e7045b0	160	vhost_dev_cleanup(&n->dev, false);
71ccc212 MT	161	/* We do an extra flush before freeing memory,
	162	* since jobs can re-queue themselves. */
	163	vhost_test_flush(n);
	164	kfree(n);
	165	return 0;
	166	}
	167
	168	static long vhost_test_run(struct vhost_test *n, int test)
	169	{
	170	void priv, oldpriv;
	171	struct vhost_virtqueue *vq;
	172	int r, index;
	173
	174	if (test < 0 \|\| test > 1)
	175	return -EINVAL;
	176
	177	mutex_lock(&n->dev.mutex);
	178	r = vhost_dev_check_owner(&n->dev);
	179	if (r)
	180	goto err;
	181
	182	for (index = 0; index < n->dev.nvqs; ++index) {
	183	/* Verify that ring has been setup correctly. */
	184	if (!vhost_vq_access_ok(&n->vqs[index])) {
	185	r = -EFAULT;
	186	goto err;
	187	}
	188	}
	189
	190	for (index = 0; index < n->dev.nvqs; ++index) {
	191	vq = n->vqs + index;
	192	mutex_lock(&vq->mutex);
	193	priv = test ? n : NULL;
	194
	195	/* start polling new socket */
22fa90c7 AH	196	oldpriv = vq->private_data;
22fa90c7 AH	197	vq->private_data = priv;
71ccc212	198
80f7d030	199	r = vhost_vq_init_access(&n->vqs[index]);
f59281da	200
71ccc212 MT	201	mutex_unlock(&vq->mutex);
71ccc212 MT	202
f59281da JW	203	if (r)
	204	goto err;
	205
71ccc212 MT	206	if (oldpriv) {
	207	vhost_test_flush_vq(n, index);
	208	}
	209	}
	210
	211	mutex_unlock(&n->dev.mutex);
	212	return 0;
	213
	214	err:
	215	mutex_unlock(&n->dev.mutex);
	216	return r;
	217	}
	218
	219	static long vhost_test_reset_owner(struct vhost_test *n)
	220	{
	221	void *priv = NULL;
	222	long err;
446374d7	223	struct vhost_umem *umem;
150b9e51	224
71ccc212 MT	225	mutex_lock(&n->dev.mutex);
	226	err = vhost_dev_check_owner(&n->dev);
	227	if (err)
	228	goto done;
446374d7 MT	229	umem = vhost_dev_reset_owner_prepare();
446374d7 MT	230	if (!umem) {
150b9e51 MT	231	err = -ENOMEM;
	232	goto done;
	233	}
71ccc212 MT	234	vhost_test_stop(n, &priv);
71ccc212 MT	235	vhost_test_flush(n);
446374d7	236	vhost_dev_reset_owner(&n->dev, umem);
71ccc212 MT	237	done:
	238	mutex_unlock(&n->dev.mutex);
	239	return err;
	240	}
	241
	242	static int vhost_test_set_features(struct vhost_test *n, u64 features)
	243	{
ea16c514 MT	244	struct vhost_virtqueue *vq;
ea16c514 MT	245
71ccc212 MT	246	mutex_lock(&n->dev.mutex);
	247	if ((features & (1 << VHOST_F_LOG_ALL)) &&
	248	!vhost_log_access_ok(&n->dev)) {
	249	mutex_unlock(&n->dev.mutex);
	250	return -EFAULT;
	251	}
ea16c514 MT	252	vq = &n->vqs[VHOST_TEST_VQ];
	253	mutex_lock(&vq->mutex);
	254	vq->acked_features = features;
	255	mutex_unlock(&vq->mutex);
71ccc212 MT	256	mutex_unlock(&n->dev.mutex);
	257	return 0;
	258	}
	259
	260	static long vhost_test_ioctl(struct file *f, unsigned int ioctl,
	261	unsigned long arg)
	262	{
	263	struct vhost_test *n = f->private_data;
	264	void __user argp = (void __user )arg;
	265	u64 __user *featurep = argp;
	266	int test;
	267	u64 features;
	268	int r;
	269	switch (ioctl) {
	270	case VHOST_TEST_RUN:
	271	if (copy_from_user(&test, argp, sizeof test))
	272	return -EFAULT;
	273	return vhost_test_run(n, test);
	274	case VHOST_GET_FEATURES:
09a34c84	275	features = VHOST_FEATURES;
71ccc212 MT	276	if (copy_to_user(featurep, &features, sizeof features))
	277	return -EFAULT;
	278	return 0;
	279	case VHOST_SET_FEATURES:
4e9fa50c	280	printk(KERN_ERR "1\n");
71ccc212 MT	281	if (copy_from_user(&features, featurep, sizeof features))
71ccc212 MT	282	return -EFAULT;
4e9fa50c	283	printk(KERN_ERR "2\n");
09a34c84	284	if (features & ~VHOST_FEATURES)
71ccc212	285	return -EOPNOTSUPP;
4e9fa50c	286	printk(KERN_ERR "3\n");
71ccc212 MT	287	return vhost_test_set_features(n, features);
	288	case VHOST_RESET_OWNER:
	289	return vhost_test_reset_owner(n);
	290	default:
	291	mutex_lock(&n->dev.mutex);
73640c99 MT	292	r = vhost_dev_ioctl(&n->dev, ioctl, argp);
	293	if (r == -ENOIOCTLCMD)
	294	r = vhost_vring_ioctl(&n->dev, ioctl, argp);
71ccc212 MT	295	vhost_test_flush(n);
	296	mutex_unlock(&n->dev.mutex);
	297	return r;
	298	}
	299	}
	300
	301	#ifdef CONFIG_COMPAT
	302	static long vhost_test_compat_ioctl(struct file *f, unsigned int ioctl,
	303	unsigned long arg)
	304	{
	305	return vhost_test_ioctl(f, ioctl, (unsigned long)compat_ptr(arg));
	306	}
	307	#endif
	308
	309	static const struct file_operations vhost_test_fops = {
	310	.owner = THIS_MODULE,
	311	.release = vhost_test_release,
	312	.unlocked_ioctl = vhost_test_ioctl,
	313	#ifdef CONFIG_COMPAT
	314	.compat_ioctl = vhost_test_compat_ioctl,
	315	#endif
	316	.open = vhost_test_open,
	317	.llseek = noop_llseek,
	318	};
	319
	320	static struct miscdevice vhost_test_misc = {
	321	MISC_DYNAMIC_MINOR,
	322	"vhost-test",
	323	&vhost_test_fops,
	324	};
ca75d601	325	module_misc_device(vhost_test_misc);
71ccc212 MT	326
	327	MODULE_VERSION("0.0.1");
	328	MODULE_LICENSE("GPL v2");
	329	MODULE_AUTHOR("Michael S. Tsirkin");
	330	MODULE_DESCRIPTION("Host kernel side for virtio simulator");