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