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