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/file.h>
17 #include <linux/slab.h>
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
28 VHOST_TEST_VQ_MAX
= 1,
33 struct vhost_virtqueue vqs
[VHOST_TEST_VQ_MAX
];
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
)
40 struct vhost_virtqueue
*vq
= &n
->vqs
[VHOST_TEST_VQ
];
43 size_t len
, total_len
= 0;
46 mutex_lock(&vq
->mutex
);
47 private = vq
->private_data
;
49 mutex_unlock(&vq
->mutex
);
53 vhost_disable_notify(&n
->dev
, vq
);
56 head
= vhost_get_vq_desc(&n
->dev
, vq
, vq
->iov
,
60 /* On error, stop handling until the next kick. */
61 if (unlikely(head
< 0))
63 /* Nothing new? Wait for eventfd to tell us they refilled. */
64 if (head
== vq
->num
) {
65 if (unlikely(vhost_enable_notify(&n
->dev
, vq
))) {
66 vhost_disable_notify(&n
->dev
, vq
);
72 vq_err(vq
, "Unexpected descriptor format for TX: "
73 "out %d, int %d\n", out
, in
);
76 len
= iov_length(vq
->iov
, out
);
79 vq_err(vq
, "Unexpected 0 len for TX\n");
82 vhost_add_used_and_signal(&n
->dev
, vq
, head
, 0);
84 if (unlikely(total_len
>= VHOST_TEST_WEIGHT
)) {
85 vhost_poll_queue(&vq
->poll
);
90 mutex_unlock(&vq
->mutex
);
93 static void handle_vq_kick(struct vhost_work
*work
)
95 struct vhost_virtqueue
*vq
= container_of(work
, struct vhost_virtqueue
,
97 struct vhost_test
*n
= container_of(vq
->dev
, struct vhost_test
, dev
);
102 static int vhost_test_open(struct inode
*inode
, struct file
*f
)
104 struct vhost_test
*n
= kmalloc(sizeof *n
, GFP_KERNEL
);
105 struct vhost_dev
*dev
;
106 struct vhost_virtqueue
**vqs
;
111 vqs
= kmalloc(VHOST_TEST_VQ_MAX
* sizeof(*vqs
), GFP_KERNEL
);
118 vqs
[VHOST_TEST_VQ
] = &n
->vqs
[VHOST_TEST_VQ
];
119 n
->vqs
[VHOST_TEST_VQ
].handle_kick
= handle_vq_kick
;
120 r
= vhost_dev_init(dev
, vqs
, VHOST_TEST_VQ_MAX
);
132 static void *vhost_test_stop_vq(struct vhost_test
*n
,
133 struct vhost_virtqueue
*vq
)
137 mutex_lock(&vq
->mutex
);
138 private = vq
->private_data
;
139 vq
->private_data
= NULL
;
140 mutex_unlock(&vq
->mutex
);
144 static void vhost_test_stop(struct vhost_test
*n
, void **privatep
)
146 *privatep
= vhost_test_stop_vq(n
, n
->vqs
+ VHOST_TEST_VQ
);
149 static void vhost_test_flush_vq(struct vhost_test
*n
, int index
)
151 vhost_poll_flush(&n
->vqs
[index
].poll
);
154 static void vhost_test_flush(struct vhost_test
*n
)
156 vhost_test_flush_vq(n
, VHOST_TEST_VQ
);
159 static int vhost_test_release(struct inode
*inode
, struct file
*f
)
161 struct vhost_test
*n
= f
->private_data
;
164 vhost_test_stop(n
, &private);
166 vhost_dev_cleanup(&n
->dev
, false);
167 /* We do an extra flush before freeing memory,
168 * since jobs can re-queue themselves. */
174 static long vhost_test_run(struct vhost_test
*n
, int test
)
176 void *priv
, *oldpriv
;
177 struct vhost_virtqueue
*vq
;
180 if (test
< 0 || test
> 1)
183 mutex_lock(&n
->dev
.mutex
);
184 r
= vhost_dev_check_owner(&n
->dev
);
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
])) {
196 for (index
= 0; index
< n
->dev
.nvqs
; ++index
) {
198 mutex_lock(&vq
->mutex
);
199 priv
= test
? n
: NULL
;
201 /* start polling new socket */
202 oldpriv
= vq
->private_data
;
203 vq
->private_data
= priv
;
205 r
= vhost_init_used(&n
->vqs
[index
]);
207 mutex_unlock(&vq
->mutex
);
213 vhost_test_flush_vq(n
, index
);
217 mutex_unlock(&n
->dev
.mutex
);
221 mutex_unlock(&n
->dev
.mutex
);
225 static long vhost_test_reset_owner(struct vhost_test
*n
)
229 struct vhost_memory
*memory
;
231 mutex_lock(&n
->dev
.mutex
);
232 err
= vhost_dev_check_owner(&n
->dev
);
235 memory
= vhost_dev_reset_owner_prepare();
240 vhost_test_stop(n
, &priv
);
242 vhost_dev_reset_owner(&n
->dev
, memory
);
244 mutex_unlock(&n
->dev
.mutex
);
248 static int vhost_test_set_features(struct vhost_test
*n
, u64 features
)
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
);
256 n
->dev
.acked_features
= features
;
259 mutex_unlock(&n
->dev
.mutex
);
263 static long vhost_test_ioctl(struct file
*f
, unsigned int ioctl
,
266 struct vhost_test
*n
= f
->private_data
;
267 void __user
*argp
= (void __user
*)arg
;
268 u64 __user
*featurep
= argp
;
274 if (copy_from_user(&test
, argp
, sizeof test
))
276 return vhost_test_run(n
, test
);
277 case VHOST_GET_FEATURES
:
278 features
= VHOST_FEATURES
;
279 if (copy_to_user(featurep
, &features
, sizeof features
))
282 case VHOST_SET_FEATURES
:
283 if (copy_from_user(&features
, featurep
, sizeof features
))
285 if (features
& ~VHOST_FEATURES
)
287 return vhost_test_set_features(n
, features
);
288 case VHOST_RESET_OWNER
:
289 return vhost_test_reset_owner(n
);
291 mutex_lock(&n
->dev
.mutex
);
292 r
= vhost_dev_ioctl(&n
->dev
, ioctl
, argp
);
293 if (r
== -ENOIOCTLCMD
)
294 r
= vhost_vring_ioctl(&n
->dev
, ioctl
, argp
);
296 mutex_unlock(&n
->dev
.mutex
);
302 static long vhost_test_compat_ioctl(struct file
*f
, unsigned int ioctl
,
305 return vhost_test_ioctl(f
, ioctl
, (unsigned long)compat_ptr(arg
));
309 static const struct file_operations vhost_test_fops
= {
310 .owner
= THIS_MODULE
,
311 .release
= vhost_test_release
,
312 .unlocked_ioctl
= vhost_test_ioctl
,
314 .compat_ioctl
= vhost_test_compat_ioctl
,
316 .open
= vhost_test_open
,
317 .llseek
= noop_llseek
,
320 static struct miscdevice vhost_test_misc
= {
326 static int vhost_test_init(void)
328 return misc_register(&vhost_test_misc
);
330 module_init(vhost_test_init
);
332 static void vhost_test_exit(void)
334 misc_deregister(&vhost_test_misc
);
336 module_exit(vhost_test_exit
);
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");