[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(&n->dev, 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;
	int r;

	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;
	r = vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX);
	if (r < 0) {
		kfree(vqs);
		kfree(n);
		return r;
	}

	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_init_used(&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_memory *memory;

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

static int vhost_test_set_features(struct vhost_test *n, u64 features)
{
	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;
	}
	n->dev.acked_features = features;
	smp_wmb();
	vhost_test_flush(n);
	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:
		if (copy_from_user(&features, featurep, sizeof features))
			return -EFAULT;
		if (features & ~VHOST_FEATURES)
			return -EOPNOTSUPP;
		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,
};

static int vhost_test_init(void)
{
	return misc_register(&vhost_test_misc);
}
module_init(vhost_test_init);

static void vhost_test_exit(void)
{
	misc_deregister(&vhost_test_misc);
}
module_exit(vhost_test_exit);

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
	55	for (;;) {
	56	head = vhost_get_vq_desc(&n->dev, vq, vq->iov,
	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	int r;
	108
	109	if (!n)
	110	return -ENOMEM;
09a34c84 MT	111	vqs = kmalloc(VHOST_TEST_VQ_MAX * sizeof(*vqs), GFP_KERNEL);
	112	if (!vqs) {
	113	kfree(n);
	114	return -ENOMEM;
	115	}
71ccc212 MT	116
71ccc212 MT	117	dev = &n->dev;
09a34c84	118	vqs[VHOST_TEST_VQ] = &n->vqs[VHOST_TEST_VQ];
71ccc212	119	n->vqs[VHOST_TEST_VQ].handle_kick = handle_vq_kick;
09a34c84	120	r = vhost_dev_init(dev, vqs, VHOST_TEST_VQ_MAX);
71ccc212	121	if (r < 0) {
09a34c84	122	kfree(vqs);
71ccc212 MT	123	kfree(n);
	124	return r;
	125	}
	126
	127	f->private_data = n;
	128
	129	return 0;
	130	}
	131
	132	static void vhost_test_stop_vq(struct vhost_test n,
	133	struct vhost_virtqueue *vq)
	134	{
	135	void *private;
	136
	137	mutex_lock(&vq->mutex);
09a34c84 MT	138	private = vq->private_data;
09a34c84 MT	139	vq->private_data = NULL;
71ccc212 MT	140	mutex_unlock(&vq->mutex);
	141	return private;
	142	}
	143
	144	static void vhost_test_stop(struct vhost_test n, void *privatep)
	145	{
	146	*privatep = vhost_test_stop_vq(n, n->vqs + VHOST_TEST_VQ);
	147	}
	148
	149	static void vhost_test_flush_vq(struct vhost_test *n, int index)
	150	{
09a34c84	151	vhost_poll_flush(&n->vqs[index].poll);
71ccc212 MT	152	}
	153
	154	static void vhost_test_flush(struct vhost_test *n)
	155	{
	156	vhost_test_flush_vq(n, VHOST_TEST_VQ);
	157	}
	158
	159	static int vhost_test_release(struct inode inode, struct file f)
	160	{
	161	struct vhost_test *n = f->private_data;
	162	void *private;
	163
	164	vhost_test_stop(n, &private);
	165	vhost_test_flush(n);
5e7045b0	166	vhost_dev_cleanup(&n->dev, false);
71ccc212 MT	167	/* We do an extra flush before freeing memory,
	168	* since jobs can re-queue themselves. */
	169	vhost_test_flush(n);
	170	kfree(n);
	171	return 0;
	172	}
	173
	174	static long vhost_test_run(struct vhost_test *n, int test)
	175	{
	176	void priv, oldpriv;
	177	struct vhost_virtqueue *vq;
	178	int r, index;
	179
	180	if (test < 0 \|\| test > 1)
	181	return -EINVAL;
	182
	183	mutex_lock(&n->dev.mutex);
	184	r = vhost_dev_check_owner(&n->dev);
	185	if (r)
	186	goto err;
	187
	188	for (index = 0; index < n->dev.nvqs; ++index) {
	189	/* Verify that ring has been setup correctly. */
	190	if (!vhost_vq_access_ok(&n->vqs[index])) {
	191	r = -EFAULT;
	192	goto err;
	193	}
	194	}
	195
	196	for (index = 0; index < n->dev.nvqs; ++index) {
	197	vq = n->vqs + index;
	198	mutex_lock(&vq->mutex);
	199	priv = test ? n : NULL;
	200
	201	/* start polling new socket */
22fa90c7 AH	202	oldpriv = vq->private_data;
22fa90c7 AH	203	vq->private_data = priv;
71ccc212	204
f59281da JW	205	r = vhost_init_used(&n->vqs[index]);
f59281da JW	206
71ccc212 MT	207	mutex_unlock(&vq->mutex);
71ccc212 MT	208
f59281da JW	209	if (r)
	210	goto err;
	211
71ccc212 MT	212	if (oldpriv) {
	213	vhost_test_flush_vq(n, index);
	214	}
	215	}
	216
	217	mutex_unlock(&n->dev.mutex);
	218	return 0;
	219
	220	err:
	221	mutex_unlock(&n->dev.mutex);
	222	return r;
	223	}
	224
	225	static long vhost_test_reset_owner(struct vhost_test *n)
	226	{
	227	void *priv = NULL;
	228	long err;
150b9e51 MT	229	struct vhost_memory *memory;
150b9e51 MT	230
71ccc212 MT	231	mutex_lock(&n->dev.mutex);
	232	err = vhost_dev_check_owner(&n->dev);
	233	if (err)
	234	goto done;
150b9e51 MT	235	memory = vhost_dev_reset_owner_prepare();
	236	if (!memory) {
	237	err = -ENOMEM;
	238	goto done;
	239	}
71ccc212 MT	240	vhost_test_stop(n, &priv);
71ccc212 MT	241	vhost_test_flush(n);
150b9e51	242	vhost_dev_reset_owner(&n->dev, memory);
71ccc212 MT	243	done:
	244	mutex_unlock(&n->dev.mutex);
	245	return err;
	246	}
	247
	248	static int vhost_test_set_features(struct vhost_test *n, u64 features)
	249	{
	250	mutex_lock(&n->dev.mutex);
	251	if ((features & (1 << VHOST_F_LOG_ALL)) &&
	252	!vhost_log_access_ok(&n->dev)) {
	253	mutex_unlock(&n->dev.mutex);
	254	return -EFAULT;
	255	}
	256	n->dev.acked_features = features;
	257	smp_wmb();
	258	vhost_test_flush(n);
	259	mutex_unlock(&n->dev.mutex);
	260	return 0;
	261	}
	262
	263	static long vhost_test_ioctl(struct file *f, unsigned int ioctl,
	264	unsigned long arg)
	265	{
	266	struct vhost_test *n = f->private_data;
	267	void __user argp = (void __user )arg;
	268	u64 __user *featurep = argp;
	269	int test;
	270	u64 features;
	271	int r;
	272	switch (ioctl) {
	273	case VHOST_TEST_RUN:
	274	if (copy_from_user(&test, argp, sizeof test))
	275	return -EFAULT;
	276	return vhost_test_run(n, test);
	277	case VHOST_GET_FEATURES:
09a34c84	278	features = VHOST_FEATURES;
71ccc212 MT	279	if (copy_to_user(featurep, &features, sizeof features))
	280	return -EFAULT;
	281	return 0;
	282	case VHOST_SET_FEATURES:
	283	if (copy_from_user(&features, featurep, sizeof features))
	284	return -EFAULT;
09a34c84	285	if (features & ~VHOST_FEATURES)
71ccc212 MT	286	return -EOPNOTSUPP;
	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	};
	325
	326	static int vhost_test_init(void)
	327	{
	328	return misc_register(&vhost_test_misc);
	329	}
	330	module_init(vhost_test_init);
	331
	332	static void vhost_test_exit(void)
	333	{
	334	misc_deregister(&vhost_test_misc);
	335	}
	336	module_exit(vhost_test_exit);
	337
	338	MODULE_VERSION("0.0.1");
	339	MODULE_LICENSE("GPL v2");
	340	MODULE_AUTHOR("Michael S. Tsirkin");
	341	MODULE_DESCRIPTION("Host kernel side for virtio simulator");