1 /* Copyright (C) 2009 Red Hat, Inc.
2 * Author: Michael S. Tsirkin <mst@redhat.com>
4 * This work is licensed under the terms of the GNU GPL, version 2.
6 * test virtio server in host kernel.
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>
16 #include <linux/rcupdate.h>
17 #include <linux/file.h>
18 #include <linux/slab.h>
23 /* Max number of bytes transferred before requeueing the job.
24 * Using this limit prevents one virtqueue from starving others. */
25 #define VHOST_TEST_WEIGHT 0x80000
29 VHOST_TEST_VQ_MAX
= 1,
34 struct vhost_virtqueue vqs
[VHOST_TEST_VQ_MAX
];
37 /* Expects to be always run from workqueue - which acts as
38 * read-size critical section for our kind of RCU. */
39 static void handle_vq(struct vhost_test
*n
)
41 struct vhost_virtqueue
*vq
= &n
->vqs
[VHOST_TEST_VQ
];
44 size_t len
, total_len
= 0;
47 mutex_lock(&vq
->mutex
);
48 private = vq
->private_data
;
50 mutex_unlock(&vq
->mutex
);
54 vhost_disable_notify(&n
->dev
, vq
);
57 head
= vhost_get_vq_desc(&n
->dev
, vq
, vq
->iov
,
61 /* On error, stop handling until the next kick. */
62 if (unlikely(head
< 0))
64 /* Nothing new? Wait for eventfd to tell us they refilled. */
65 if (head
== vq
->num
) {
66 if (unlikely(vhost_enable_notify(&n
->dev
, vq
))) {
67 vhost_disable_notify(&n
->dev
, vq
);
73 vq_err(vq
, "Unexpected descriptor format for TX: "
74 "out %d, int %d\n", out
, in
);
77 len
= iov_length(vq
->iov
, out
);
80 vq_err(vq
, "Unexpected 0 len for TX\n");
83 vhost_add_used_and_signal(&n
->dev
, vq
, head
, 0);
85 if (unlikely(total_len
>= VHOST_TEST_WEIGHT
)) {
86 vhost_poll_queue(&vq
->poll
);
91 mutex_unlock(&vq
->mutex
);
94 static void handle_vq_kick(struct vhost_work
*work
)
96 struct vhost_virtqueue
*vq
= container_of(work
, struct vhost_virtqueue
,
98 struct vhost_test
*n
= container_of(vq
->dev
, struct vhost_test
, dev
);
103 static int vhost_test_open(struct inode
*inode
, struct file
*f
)
105 struct vhost_test
*n
= kmalloc(sizeof *n
, GFP_KERNEL
);
106 struct vhost_dev
*dev
;
107 struct vhost_virtqueue
**vqs
;
112 vqs
= kmalloc(VHOST_TEST_VQ_MAX
* sizeof(*vqs
), GFP_KERNEL
);
119 vqs
[VHOST_TEST_VQ
] = &n
->vqs
[VHOST_TEST_VQ
];
120 n
->vqs
[VHOST_TEST_VQ
].handle_kick
= handle_vq_kick
;
121 r
= vhost_dev_init(dev
, vqs
, VHOST_TEST_VQ_MAX
);
133 static void *vhost_test_stop_vq(struct vhost_test
*n
,
134 struct vhost_virtqueue
*vq
)
138 mutex_lock(&vq
->mutex
);
139 private = vq
->private_data
;
140 vq
->private_data
= NULL
;
141 mutex_unlock(&vq
->mutex
);
145 static void vhost_test_stop(struct vhost_test
*n
, void **privatep
)
147 *privatep
= vhost_test_stop_vq(n
, n
->vqs
+ VHOST_TEST_VQ
);
150 static void vhost_test_flush_vq(struct vhost_test
*n
, int index
)
152 vhost_poll_flush(&n
->vqs
[index
].poll
);
155 static void vhost_test_flush(struct vhost_test
*n
)
157 vhost_test_flush_vq(n
, VHOST_TEST_VQ
);
160 static int vhost_test_release(struct inode
*inode
, struct file
*f
)
162 struct vhost_test
*n
= f
->private_data
;
165 vhost_test_stop(n
, &private);
167 vhost_dev_cleanup(&n
->dev
, false);
168 /* We do an extra flush before freeing memory,
169 * since jobs can re-queue themselves. */
175 static long vhost_test_run(struct vhost_test
*n
, int test
)
177 void *priv
, *oldpriv
;
178 struct vhost_virtqueue
*vq
;
181 if (test
< 0 || test
> 1)
184 mutex_lock(&n
->dev
.mutex
);
185 r
= vhost_dev_check_owner(&n
->dev
);
189 for (index
= 0; index
< n
->dev
.nvqs
; ++index
) {
190 /* Verify that ring has been setup correctly. */
191 if (!vhost_vq_access_ok(&n
->vqs
[index
])) {
197 for (index
= 0; index
< n
->dev
.nvqs
; ++index
) {
199 mutex_lock(&vq
->mutex
);
200 priv
= test
? n
: NULL
;
202 /* start polling new socket */
203 oldpriv
= rcu_dereference_protected(vq
->private_data
,
204 lockdep_is_held(&vq
->mutex
));
205 rcu_assign_pointer(vq
->private_data
, priv
);
207 r
= vhost_init_used(&n
->vqs
[index
]);
209 mutex_unlock(&vq
->mutex
);
215 vhost_test_flush_vq(n
, index
);
219 mutex_unlock(&n
->dev
.mutex
);
223 mutex_unlock(&n
->dev
.mutex
);
227 static long vhost_test_reset_owner(struct vhost_test
*n
)
231 struct vhost_memory
*memory
;
233 mutex_lock(&n
->dev
.mutex
);
234 err
= vhost_dev_check_owner(&n
->dev
);
237 memory
= vhost_dev_reset_owner_prepare();
242 vhost_test_stop(n
, &priv
);
244 vhost_dev_reset_owner(&n
->dev
, memory
);
246 mutex_unlock(&n
->dev
.mutex
);
250 static int vhost_test_set_features(struct vhost_test
*n
, u64 features
)
252 mutex_lock(&n
->dev
.mutex
);
253 if ((features
& (1 << VHOST_F_LOG_ALL
)) &&
254 !vhost_log_access_ok(&n
->dev
)) {
255 mutex_unlock(&n
->dev
.mutex
);
258 n
->dev
.acked_features
= features
;
261 mutex_unlock(&n
->dev
.mutex
);
265 static long vhost_test_ioctl(struct file
*f
, unsigned int ioctl
,
268 struct vhost_test
*n
= f
->private_data
;
269 void __user
*argp
= (void __user
*)arg
;
270 u64 __user
*featurep
= argp
;
276 if (copy_from_user(&test
, argp
, sizeof test
))
278 return vhost_test_run(n
, test
);
279 case VHOST_GET_FEATURES
:
280 features
= VHOST_FEATURES
;
281 if (copy_to_user(featurep
, &features
, sizeof features
))
284 case VHOST_SET_FEATURES
:
285 if (copy_from_user(&features
, featurep
, sizeof features
))
287 if (features
& ~VHOST_FEATURES
)
289 return vhost_test_set_features(n
, features
);
290 case VHOST_RESET_OWNER
:
291 return vhost_test_reset_owner(n
);
293 mutex_lock(&n
->dev
.mutex
);
294 r
= vhost_dev_ioctl(&n
->dev
, ioctl
, argp
);
295 if (r
== -ENOIOCTLCMD
)
296 r
= vhost_vring_ioctl(&n
->dev
, ioctl
, argp
);
298 mutex_unlock(&n
->dev
.mutex
);
304 static long vhost_test_compat_ioctl(struct file
*f
, unsigned int ioctl
,
307 return vhost_test_ioctl(f
, ioctl
, (unsigned long)compat_ptr(arg
));
311 static const struct file_operations vhost_test_fops
= {
312 .owner
= THIS_MODULE
,
313 .release
= vhost_test_release
,
314 .unlocked_ioctl
= vhost_test_ioctl
,
316 .compat_ioctl
= vhost_test_compat_ioctl
,
318 .open
= vhost_test_open
,
319 .llseek
= noop_llseek
,
322 static struct miscdevice vhost_test_misc
= {
328 static int vhost_test_init(void)
330 return misc_register(&vhost_test_misc
);
332 module_init(vhost_test_init
);
334 static void vhost_test_exit(void)
336 misc_deregister(&vhost_test_misc
);
338 module_exit(vhost_test_exit
);
340 MODULE_VERSION("0.0.1");
341 MODULE_LICENSE("GPL v2");
342 MODULE_AUTHOR("Michael S. Tsirkin");
343 MODULE_DESCRIPTION("Host kernel side for virtio simulator");