blob: 94dbd25caa303c44c4c972230fcb2752da619fc0 [file] [log] [blame]
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001/* Copyright (C) 2009 Red Hat, Inc.
2 * Copyright (C) 2006 Rusty Russell IBM Corporation
3 *
4 * Author: Michael S. Tsirkin <mst@redhat.com>
5 *
6 * Inspiration, some code, and most witty comments come from
Rob Landley61516582011-05-06 09:27:36 -07007 * Documentation/virtual/lguest/lguest.c, by Rusty Russell
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00008 *
9 * This work is licensed under the terms of the GNU GPL, version 2.
10 *
11 * Generic code for virtio server in host kernel.
12 */
13
14#include <linux/eventfd.h>
15#include <linux/vhost.h>
16#include <linux/virtio_net.h>
17#include <linux/mm.h>
Michael S. Tsirkin64e1c802010-10-06 15:34:45 +020018#include <linux/mmu_context.h>
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000019#include <linux/miscdevice.h>
20#include <linux/mutex.h>
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000021#include <linux/rcupdate.h>
22#include <linux/poll.h>
23#include <linux/file.h>
24#include <linux/highmem.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
Tejun Heoc23f34452010-06-02 20:40:00 +020026#include <linux/kthread.h>
Michael S. Tsirkin9e3d1952010-07-27 22:56:50 +030027#include <linux/cgroup.h>
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000028
29#include <linux/net.h>
30#include <linux/if_packet.h>
31#include <linux/if_arp.h>
32
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000033#include "vhost.h"
34
35enum {
36 VHOST_MEMORY_MAX_NREGIONS = 64,
37 VHOST_MEMORY_F_LOG = 0x1,
38};
39
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +000040static unsigned vhost_zcopy_mask __read_mostly;
41
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +030042#define vhost_used_event(vq) ((u16 __user *)&vq->avail->ring[vq->num])
43#define vhost_avail_event(vq) ((u16 __user *)&vq->used->ring[vq->num])
44
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000045static void vhost_poll_func(struct file *file, wait_queue_head_t *wqh,
46 poll_table *pt)
47{
48 struct vhost_poll *poll;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000049
Krishna Kumard47effe2011-03-01 17:06:37 +053050 poll = container_of(pt, struct vhost_poll, table);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000051 poll->wqh = wqh;
52 add_wait_queue(wqh, &poll->wait);
53}
54
55static int vhost_poll_wakeup(wait_queue_t *wait, unsigned mode, int sync,
56 void *key)
57{
Tejun Heoc23f34452010-06-02 20:40:00 +020058 struct vhost_poll *poll = container_of(wait, struct vhost_poll, wait);
59
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000060 if (!((unsigned long)key & poll->mask))
61 return 0;
62
Tejun Heoc23f34452010-06-02 20:40:00 +020063 vhost_poll_queue(poll);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000064 return 0;
65}
66
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +030067static void vhost_work_init(struct vhost_work *work, vhost_work_fn_t fn)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000068{
Tejun Heoc23f34452010-06-02 20:40:00 +020069 INIT_LIST_HEAD(&work->node);
70 work->fn = fn;
71 init_waitqueue_head(&work->done);
72 work->flushing = 0;
73 work->queue_seq = work->done_seq = 0;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000074}
75
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +030076/* Init poll structure */
77void vhost_poll_init(struct vhost_poll *poll, vhost_work_fn_t fn,
78 unsigned long mask, struct vhost_dev *dev)
79{
80 init_waitqueue_func_entry(&poll->wait, vhost_poll_wakeup);
81 init_poll_funcptr(&poll->table, vhost_poll_func);
82 poll->mask = mask;
83 poll->dev = dev;
84
85 vhost_work_init(&poll->work, fn);
86}
87
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000088/* Start polling a file. We add ourselves to file's wait queue. The caller must
89 * keep a reference to a file until after vhost_poll_stop is called. */
90void vhost_poll_start(struct vhost_poll *poll, struct file *file)
91{
92 unsigned long mask;
Krishna Kumard47effe2011-03-01 17:06:37 +053093
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +000094 mask = file->f_op->poll(file, &poll->table);
95 if (mask)
96 vhost_poll_wakeup(&poll->wait, 0, 0, (void *)mask);
97}
98
99/* Stop polling a file. After this function returns, it becomes safe to drop the
100 * file reference. You must also flush afterwards. */
101void vhost_poll_stop(struct vhost_poll *poll)
102{
103 remove_wait_queue(poll->wqh, &poll->wait);
104}
105
Michael S. Tsirkin0174b0c2011-01-10 10:03:20 +0200106static bool vhost_work_seq_done(struct vhost_dev *dev, struct vhost_work *work,
107 unsigned seq)
108{
109 int left;
Krishna Kumard47effe2011-03-01 17:06:37 +0530110
Michael S. Tsirkin0174b0c2011-01-10 10:03:20 +0200111 spin_lock_irq(&dev->work_lock);
112 left = seq - work->done_seq;
113 spin_unlock_irq(&dev->work_lock);
114 return left <= 0;
115}
116
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300117static void vhost_work_flush(struct vhost_dev *dev, struct vhost_work *work)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000118{
Tejun Heoc23f34452010-06-02 20:40:00 +0200119 unsigned seq;
Tejun Heoc23f34452010-06-02 20:40:00 +0200120 int flushing;
121
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300122 spin_lock_irq(&dev->work_lock);
Tejun Heoc23f34452010-06-02 20:40:00 +0200123 seq = work->queue_seq;
124 work->flushing++;
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300125 spin_unlock_irq(&dev->work_lock);
Michael S. Tsirkin0174b0c2011-01-10 10:03:20 +0200126 wait_event(work->done, vhost_work_seq_done(dev, work, seq));
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300127 spin_lock_irq(&dev->work_lock);
Tejun Heoc23f34452010-06-02 20:40:00 +0200128 flushing = --work->flushing;
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300129 spin_unlock_irq(&dev->work_lock);
Tejun Heoc23f34452010-06-02 20:40:00 +0200130 BUG_ON(flushing < 0);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000131}
132
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300133/* Flush any work that has been scheduled. When calling this, don't hold any
134 * locks that are also used by the callback. */
135void vhost_poll_flush(struct vhost_poll *poll)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000136{
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300137 vhost_work_flush(poll->dev, &poll->work);
138}
139
140static inline void vhost_work_queue(struct vhost_dev *dev,
141 struct vhost_work *work)
142{
Tejun Heoc23f34452010-06-02 20:40:00 +0200143 unsigned long flags;
144
145 spin_lock_irqsave(&dev->work_lock, flags);
146 if (list_empty(&work->node)) {
147 list_add_tail(&work->node, &dev->work_list);
148 work->queue_seq++;
149 wake_up_process(dev->worker);
150 }
151 spin_unlock_irqrestore(&dev->work_lock, flags);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000152}
153
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300154void vhost_poll_queue(struct vhost_poll *poll)
155{
156 vhost_work_queue(poll->dev, &poll->work);
157}
158
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000159static void vhost_vq_reset(struct vhost_dev *dev,
160 struct vhost_virtqueue *vq)
161{
162 vq->num = 1;
163 vq->desc = NULL;
164 vq->avail = NULL;
165 vq->used = NULL;
166 vq->last_avail_idx = 0;
167 vq->avail_idx = 0;
168 vq->last_used_idx = 0;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300169 vq->signalled_used = 0;
170 vq->signalled_used_valid = false;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000171 vq->used_flags = 0;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000172 vq->log_used = false;
173 vq->log_addr = -1ull;
David Stevens8dd014a2010-07-27 18:52:21 +0300174 vq->vhost_hlen = 0;
175 vq->sock_hlen = 0;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000176 vq->private_data = NULL;
177 vq->log_base = NULL;
178 vq->error_ctx = NULL;
179 vq->error = NULL;
180 vq->kick = NULL;
181 vq->call_ctx = NULL;
182 vq->call = NULL;
Michael S. Tsirkin73a99f02010-02-23 11:23:45 +0200183 vq->log_ctx = NULL;
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000184 vq->upend_idx = 0;
185 vq->done_idx = 0;
186 vq->ubufs = NULL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000187}
188
Tejun Heoc23f34452010-06-02 20:40:00 +0200189static int vhost_worker(void *data)
190{
191 struct vhost_dev *dev = data;
192 struct vhost_work *work = NULL;
193 unsigned uninitialized_var(seq);
194
Michael S. Tsirkin64e1c802010-10-06 15:34:45 +0200195 use_mm(dev->mm);
196
Tejun Heoc23f34452010-06-02 20:40:00 +0200197 for (;;) {
198 /* mb paired w/ kthread_stop */
199 set_current_state(TASK_INTERRUPTIBLE);
200
201 spin_lock_irq(&dev->work_lock);
202 if (work) {
203 work->done_seq = seq;
204 if (work->flushing)
205 wake_up_all(&work->done);
206 }
207
208 if (kthread_should_stop()) {
209 spin_unlock_irq(&dev->work_lock);
210 __set_current_state(TASK_RUNNING);
Michael S. Tsirkin64e1c802010-10-06 15:34:45 +0200211 break;
Tejun Heoc23f34452010-06-02 20:40:00 +0200212 }
213 if (!list_empty(&dev->work_list)) {
214 work = list_first_entry(&dev->work_list,
215 struct vhost_work, node);
216 list_del_init(&work->node);
217 seq = work->queue_seq;
218 } else
219 work = NULL;
220 spin_unlock_irq(&dev->work_lock);
221
222 if (work) {
223 __set_current_state(TASK_RUNNING);
224 work->fn(work);
Nadav Har'Eld550dda2012-02-27 15:07:29 +0200225 if (need_resched())
226 schedule();
Tejun Heoc23f34452010-06-02 20:40:00 +0200227 } else
228 schedule();
229
230 }
Michael S. Tsirkin64e1c802010-10-06 15:34:45 +0200231 unuse_mm(dev->mm);
232 return 0;
Tejun Heoc23f34452010-06-02 20:40:00 +0200233}
234
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000235static void vhost_vq_free_iovecs(struct vhost_virtqueue *vq)
236{
237 kfree(vq->indirect);
238 vq->indirect = NULL;
239 kfree(vq->log);
240 vq->log = NULL;
241 kfree(vq->heads);
242 vq->heads = NULL;
243 kfree(vq->ubuf_info);
244 vq->ubuf_info = NULL;
245}
246
247void vhost_enable_zcopy(int vq)
248{
249 vhost_zcopy_mask |= 0x1 << vq;
250}
251
Jason Wange0e9b402010-09-14 23:53:05 +0800252/* Helper to allocate iovec buffers for all vqs. */
253static long vhost_dev_alloc_iovecs(struct vhost_dev *dev)
254{
255 int i;
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000256 bool zcopy;
Krishna Kumard47effe2011-03-01 17:06:37 +0530257
Jason Wange0e9b402010-09-14 23:53:05 +0800258 for (i = 0; i < dev->nvqs; ++i) {
259 dev->vqs[i].indirect = kmalloc(sizeof *dev->vqs[i].indirect *
260 UIO_MAXIOV, GFP_KERNEL);
261 dev->vqs[i].log = kmalloc(sizeof *dev->vqs[i].log * UIO_MAXIOV,
262 GFP_KERNEL);
263 dev->vqs[i].heads = kmalloc(sizeof *dev->vqs[i].heads *
264 UIO_MAXIOV, GFP_KERNEL);
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000265 zcopy = vhost_zcopy_mask & (0x1 << i);
266 if (zcopy)
267 dev->vqs[i].ubuf_info =
268 kmalloc(sizeof *dev->vqs[i].ubuf_info *
269 UIO_MAXIOV, GFP_KERNEL);
Jason Wange0e9b402010-09-14 23:53:05 +0800270 if (!dev->vqs[i].indirect || !dev->vqs[i].log ||
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000271 !dev->vqs[i].heads ||
272 (zcopy && !dev->vqs[i].ubuf_info))
Jason Wange0e9b402010-09-14 23:53:05 +0800273 goto err_nomem;
274 }
275 return 0;
Krishna Kumard47effe2011-03-01 17:06:37 +0530276
Jason Wange0e9b402010-09-14 23:53:05 +0800277err_nomem:
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000278 for (; i >= 0; --i)
279 vhost_vq_free_iovecs(&dev->vqs[i]);
Jason Wange0e9b402010-09-14 23:53:05 +0800280 return -ENOMEM;
281}
282
283static void vhost_dev_free_iovecs(struct vhost_dev *dev)
284{
285 int i;
Krishna Kumard47effe2011-03-01 17:06:37 +0530286
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000287 for (i = 0; i < dev->nvqs; ++i)
288 vhost_vq_free_iovecs(&dev->vqs[i]);
Jason Wange0e9b402010-09-14 23:53:05 +0800289}
290
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000291long vhost_dev_init(struct vhost_dev *dev,
292 struct vhost_virtqueue *vqs, int nvqs)
293{
294 int i;
Tejun Heoc23f34452010-06-02 20:40:00 +0200295
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000296 dev->vqs = vqs;
297 dev->nvqs = nvqs;
298 mutex_init(&dev->mutex);
299 dev->log_ctx = NULL;
300 dev->log_file = NULL;
301 dev->memory = NULL;
302 dev->mm = NULL;
Tejun Heoc23f34452010-06-02 20:40:00 +0200303 spin_lock_init(&dev->work_lock);
304 INIT_LIST_HEAD(&dev->work_list);
305 dev->worker = NULL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000306
307 for (i = 0; i < dev->nvqs; ++i) {
Jason Wange0e9b402010-09-14 23:53:05 +0800308 dev->vqs[i].log = NULL;
309 dev->vqs[i].indirect = NULL;
310 dev->vqs[i].heads = NULL;
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000311 dev->vqs[i].ubuf_info = NULL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000312 dev->vqs[i].dev = dev;
313 mutex_init(&dev->vqs[i].mutex);
314 vhost_vq_reset(dev, dev->vqs + i);
315 if (dev->vqs[i].handle_kick)
316 vhost_poll_init(&dev->vqs[i].poll,
Tejun Heoc23f34452010-06-02 20:40:00 +0200317 dev->vqs[i].handle_kick, POLLIN, dev);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000318 }
Tejun Heoc23f34452010-06-02 20:40:00 +0200319
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000320 return 0;
321}
322
323/* Caller should have device mutex */
324long vhost_dev_check_owner(struct vhost_dev *dev)
325{
326 /* Are you the owner? If not, I don't think you mean to do that */
327 return dev->mm == current->mm ? 0 : -EPERM;
328}
329
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300330struct vhost_attach_cgroups_struct {
Krishna Kumard47effe2011-03-01 17:06:37 +0530331 struct vhost_work work;
332 struct task_struct *owner;
333 int ret;
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300334};
335
336static void vhost_attach_cgroups_work(struct vhost_work *work)
337{
Krishna Kumard47effe2011-03-01 17:06:37 +0530338 struct vhost_attach_cgroups_struct *s;
339
340 s = container_of(work, struct vhost_attach_cgroups_struct, work);
341 s->ret = cgroup_attach_task_all(s->owner, current);
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300342}
343
344static int vhost_attach_cgroups(struct vhost_dev *dev)
345{
Krishna Kumard47effe2011-03-01 17:06:37 +0530346 struct vhost_attach_cgroups_struct attach;
347
348 attach.owner = current;
349 vhost_work_init(&attach.work, vhost_attach_cgroups_work);
350 vhost_work_queue(dev, &attach.work);
351 vhost_work_flush(dev, &attach.work);
352 return attach.ret;
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300353}
354
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000355/* Caller should have device mutex */
356static long vhost_dev_set_owner(struct vhost_dev *dev)
357{
Tejun Heoc23f34452010-06-02 20:40:00 +0200358 struct task_struct *worker;
359 int err;
Krishna Kumard47effe2011-03-01 17:06:37 +0530360
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000361 /* Is there an owner already? */
Tejun Heoc23f34452010-06-02 20:40:00 +0200362 if (dev->mm) {
363 err = -EBUSY;
364 goto err_mm;
365 }
Krishna Kumard47effe2011-03-01 17:06:37 +0530366
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000367 /* No owner, become one */
368 dev->mm = get_task_mm(current);
Tejun Heoc23f34452010-06-02 20:40:00 +0200369 worker = kthread_create(vhost_worker, dev, "vhost-%d", current->pid);
370 if (IS_ERR(worker)) {
371 err = PTR_ERR(worker);
372 goto err_worker;
373 }
374
375 dev->worker = worker;
Michael S. Tsirkin87d6a412010-09-02 14:05:30 +0300376 wake_up_process(worker); /* avoid contributing to loadavg */
377
378 err = vhost_attach_cgroups(dev);
Michael S. Tsirkin9e3d1952010-07-27 22:56:50 +0300379 if (err)
380 goto err_cgroup;
Tejun Heoc23f34452010-06-02 20:40:00 +0200381
Jason Wange0e9b402010-09-14 23:53:05 +0800382 err = vhost_dev_alloc_iovecs(dev);
383 if (err)
384 goto err_cgroup;
385
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000386 return 0;
Michael S. Tsirkin9e3d1952010-07-27 22:56:50 +0300387err_cgroup:
388 kthread_stop(worker);
Michael S. Tsirkin615cc222010-09-02 14:16:36 +0300389 dev->worker = NULL;
Tejun Heoc23f34452010-06-02 20:40:00 +0200390err_worker:
391 if (dev->mm)
392 mmput(dev->mm);
393 dev->mm = NULL;
394err_mm:
395 return err;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000396}
397
398/* Caller should have device mutex */
399long vhost_dev_reset_owner(struct vhost_dev *dev)
400{
401 struct vhost_memory *memory;
402
403 /* Restore memory to default empty mapping. */
404 memory = kmalloc(offsetof(struct vhost_memory, regions), GFP_KERNEL);
405 if (!memory)
406 return -ENOMEM;
407
Michael S. Tsirkinea5d4042011-11-27 19:05:58 +0200408 vhost_dev_cleanup(dev, true);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000409
410 memory->nregions = 0;
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100411 RCU_INIT_POINTER(dev->memory, memory);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000412 return 0;
413}
414
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000415/* In case of DMA done not in order in lower device driver for some reason.
416 * upend_idx is used to track end of used idx, done_idx is used to track head
417 * of used idx. Once lower device DMA done contiguously, we will signal KVM
418 * guest used idx.
419 */
420int vhost_zerocopy_signal_used(struct vhost_virtqueue *vq)
421{
422 int i;
423 int j = 0;
424
425 for (i = vq->done_idx; i != vq->upend_idx; i = (i + 1) % UIO_MAXIOV) {
426 if ((vq->heads[i].len == VHOST_DMA_DONE_LEN)) {
427 vq->heads[i].len = VHOST_DMA_CLEAR_LEN;
428 vhost_add_used_and_signal(vq->dev, vq,
429 vq->heads[i].id, 0);
430 ++j;
431 } else
432 break;
433 }
434 if (j)
435 vq->done_idx = i;
436 return j;
437}
438
Michael S. Tsirkinea5d4042011-11-27 19:05:58 +0200439/* Caller should have device mutex if and only if locked is set */
440void vhost_dev_cleanup(struct vhost_dev *dev, bool locked)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000441{
442 int i;
Krishna Kumard47effe2011-03-01 17:06:37 +0530443
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000444 for (i = 0; i < dev->nvqs; ++i) {
445 if (dev->vqs[i].kick && dev->vqs[i].handle_kick) {
446 vhost_poll_stop(&dev->vqs[i].poll);
447 vhost_poll_flush(&dev->vqs[i].poll);
448 }
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +0000449 /* Wait for all lower device DMAs done. */
450 if (dev->vqs[i].ubufs)
451 vhost_ubuf_put_and_wait(dev->vqs[i].ubufs);
452
453 /* Signal guest as appropriate. */
454 vhost_zerocopy_signal_used(&dev->vqs[i]);
455
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000456 if (dev->vqs[i].error_ctx)
457 eventfd_ctx_put(dev->vqs[i].error_ctx);
458 if (dev->vqs[i].error)
459 fput(dev->vqs[i].error);
460 if (dev->vqs[i].kick)
461 fput(dev->vqs[i].kick);
462 if (dev->vqs[i].call_ctx)
463 eventfd_ctx_put(dev->vqs[i].call_ctx);
464 if (dev->vqs[i].call)
465 fput(dev->vqs[i].call);
466 vhost_vq_reset(dev, dev->vqs + i);
467 }
Jason Wange0e9b402010-09-14 23:53:05 +0800468 vhost_dev_free_iovecs(dev);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000469 if (dev->log_ctx)
470 eventfd_ctx_put(dev->log_ctx);
471 dev->log_ctx = NULL;
472 if (dev->log_file)
473 fput(dev->log_file);
474 dev->log_file = NULL;
475 /* No one will access memory at this point */
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100476 kfree(rcu_dereference_protected(dev->memory,
Michael S. Tsirkinea5d4042011-11-27 19:05:58 +0200477 locked ==
478 lockdep_is_held(&dev->mutex)));
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100479 RCU_INIT_POINTER(dev->memory, NULL);
Tejun Heoc23f34452010-06-02 20:40:00 +0200480 WARN_ON(!list_empty(&dev->work_list));
Eric Dumazet78b620c2010-08-31 02:05:57 +0000481 if (dev->worker) {
482 kthread_stop(dev->worker);
483 dev->worker = NULL;
484 }
Michael S. Tsirkin533a19b2010-10-06 15:34:38 +0200485 if (dev->mm)
486 mmput(dev->mm);
487 dev->mm = NULL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000488}
489
490static int log_access_ok(void __user *log_base, u64 addr, unsigned long sz)
491{
492 u64 a = addr / VHOST_PAGE_SIZE / 8;
Krishna Kumard47effe2011-03-01 17:06:37 +0530493
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000494 /* Make sure 64 bit math will not overflow. */
495 if (a > ULONG_MAX - (unsigned long)log_base ||
496 a + (unsigned long)log_base > ULONG_MAX)
Dan Carpenter6d97e552010-10-11 19:24:19 +0200497 return 0;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000498
499 return access_ok(VERIFY_WRITE, log_base + a,
500 (sz + VHOST_PAGE_SIZE * 8 - 1) / VHOST_PAGE_SIZE / 8);
501}
502
503/* Caller should have vq mutex and device mutex. */
504static int vq_memory_access_ok(void __user *log_base, struct vhost_memory *mem,
505 int log_all)
506{
507 int i;
Jeff Dike179b2842010-04-07 09:59:10 -0400508
Michael S. Tsirkinf8322fb2010-05-27 12:28:03 +0300509 if (!mem)
510 return 0;
Jeff Dike179b2842010-04-07 09:59:10 -0400511
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000512 for (i = 0; i < mem->nregions; ++i) {
513 struct vhost_memory_region *m = mem->regions + i;
514 unsigned long a = m->userspace_addr;
515 if (m->memory_size > ULONG_MAX)
516 return 0;
517 else if (!access_ok(VERIFY_WRITE, (void __user *)a,
518 m->memory_size))
519 return 0;
520 else if (log_all && !log_access_ok(log_base,
521 m->guest_phys_addr,
522 m->memory_size))
523 return 0;
524 }
525 return 1;
526}
527
528/* Can we switch to this memory table? */
529/* Caller should have device mutex but not vq mutex */
530static int memory_access_ok(struct vhost_dev *d, struct vhost_memory *mem,
531 int log_all)
532{
533 int i;
Krishna Kumard47effe2011-03-01 17:06:37 +0530534
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000535 for (i = 0; i < d->nvqs; ++i) {
536 int ok;
537 mutex_lock(&d->vqs[i].mutex);
538 /* If ring is inactive, will check when it's enabled. */
539 if (d->vqs[i].private_data)
540 ok = vq_memory_access_ok(d->vqs[i].log_base, mem,
541 log_all);
542 else
543 ok = 1;
544 mutex_unlock(&d->vqs[i].mutex);
545 if (!ok)
546 return 0;
547 }
548 return 1;
549}
550
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300551static int vq_access_ok(struct vhost_dev *d, unsigned int num,
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000552 struct vring_desc __user *desc,
553 struct vring_avail __user *avail,
554 struct vring_used __user *used)
555{
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300556 size_t s = vhost_has_feature(d, VIRTIO_RING_F_EVENT_IDX) ? 2 : 0;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000557 return access_ok(VERIFY_READ, desc, num * sizeof *desc) &&
558 access_ok(VERIFY_READ, avail,
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300559 sizeof *avail + num * sizeof *avail->ring + s) &&
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000560 access_ok(VERIFY_WRITE, used,
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300561 sizeof *used + num * sizeof *used->ring + s);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000562}
563
564/* Can we log writes? */
565/* Caller should have device mutex but not vq mutex */
566int vhost_log_access_ok(struct vhost_dev *dev)
567{
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100568 struct vhost_memory *mp;
569
570 mp = rcu_dereference_protected(dev->memory,
571 lockdep_is_held(&dev->mutex));
572 return memory_access_ok(dev, mp, 1);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000573}
574
575/* Verify access for write logging. */
576/* Caller should have vq mutex and device mutex */
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300577static int vq_log_access_ok(struct vhost_dev *d, struct vhost_virtqueue *vq,
578 void __user *log_base)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000579{
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100580 struct vhost_memory *mp;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300581 size_t s = vhost_has_feature(d, VIRTIO_RING_F_EVENT_IDX) ? 2 : 0;
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100582
583 mp = rcu_dereference_protected(vq->dev->memory,
584 lockdep_is_held(&vq->mutex));
585 return vq_memory_access_ok(log_base, mp,
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000586 vhost_has_feature(vq->dev, VHOST_F_LOG_ALL)) &&
587 (!vq->log_used || log_access_ok(log_base, vq->log_addr,
588 sizeof *vq->used +
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300589 vq->num * sizeof *vq->used->ring + s));
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000590}
591
592/* Can we start vq? */
593/* Caller should have vq mutex and device mutex */
594int vhost_vq_access_ok(struct vhost_virtqueue *vq)
595{
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300596 return vq_access_ok(vq->dev, vq->num, vq->desc, vq->avail, vq->used) &&
597 vq_log_access_ok(vq->dev, vq, vq->log_base);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000598}
599
600static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m)
601{
602 struct vhost_memory mem, *newmem, *oldmem;
603 unsigned long size = offsetof(struct vhost_memory, regions);
Krishna Kumard47effe2011-03-01 17:06:37 +0530604
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900605 if (copy_from_user(&mem, m, size))
606 return -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000607 if (mem.padding)
608 return -EOPNOTSUPP;
609 if (mem.nregions > VHOST_MEMORY_MAX_NREGIONS)
610 return -E2BIG;
611 newmem = kmalloc(size + mem.nregions * sizeof *m->regions, GFP_KERNEL);
612 if (!newmem)
613 return -ENOMEM;
614
615 memcpy(newmem, &mem, size);
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900616 if (copy_from_user(newmem->regions, m->regions,
617 mem.nregions * sizeof *m->regions)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000618 kfree(newmem);
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900619 return -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000620 }
621
Krishna Kumard47effe2011-03-01 17:06:37 +0530622 if (!memory_access_ok(d, newmem,
623 vhost_has_feature(d, VHOST_F_LOG_ALL))) {
Takuya Yoshikawaa02c3782010-05-27 19:03:56 +0900624 kfree(newmem);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000625 return -EFAULT;
Takuya Yoshikawaa02c3782010-05-27 19:03:56 +0900626 }
Arnd Bergmann28457ee2010-03-09 19:24:45 +0100627 oldmem = rcu_dereference_protected(d->memory,
628 lockdep_is_held(&d->mutex));
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000629 rcu_assign_pointer(d->memory, newmem);
630 synchronize_rcu();
631 kfree(oldmem);
632 return 0;
633}
634
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000635static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
636{
637 struct file *eventfp, *filep = NULL,
638 *pollstart = NULL, *pollstop = NULL;
639 struct eventfd_ctx *ctx = NULL;
640 u32 __user *idxp = argp;
641 struct vhost_virtqueue *vq;
642 struct vhost_vring_state s;
643 struct vhost_vring_file f;
644 struct vhost_vring_addr a;
645 u32 idx;
646 long r;
647
648 r = get_user(idx, idxp);
649 if (r < 0)
650 return r;
Krishna Kumar0f3d9a12010-05-25 11:10:36 +0530651 if (idx >= d->nvqs)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000652 return -ENOBUFS;
653
654 vq = d->vqs + idx;
655
656 mutex_lock(&vq->mutex);
657
658 switch (ioctl) {
659 case VHOST_SET_VRING_NUM:
660 /* Resizing ring with an active backend?
661 * You don't want to do that. */
662 if (vq->private_data) {
663 r = -EBUSY;
664 break;
665 }
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900666 if (copy_from_user(&s, argp, sizeof s)) {
667 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000668 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900669 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000670 if (!s.num || s.num > 0xffff || (s.num & (s.num - 1))) {
671 r = -EINVAL;
672 break;
673 }
674 vq->num = s.num;
675 break;
676 case VHOST_SET_VRING_BASE:
677 /* Moving base with an active backend?
678 * You don't want to do that. */
679 if (vq->private_data) {
680 r = -EBUSY;
681 break;
682 }
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900683 if (copy_from_user(&s, argp, sizeof s)) {
684 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000685 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900686 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000687 if (s.num > 0xffff) {
688 r = -EINVAL;
689 break;
690 }
691 vq->last_avail_idx = s.num;
692 /* Forget the cached index value. */
693 vq->avail_idx = vq->last_avail_idx;
694 break;
695 case VHOST_GET_VRING_BASE:
696 s.index = idx;
697 s.num = vq->last_avail_idx;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900698 if (copy_to_user(argp, &s, sizeof s))
699 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000700 break;
701 case VHOST_SET_VRING_ADDR:
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900702 if (copy_from_user(&a, argp, sizeof a)) {
703 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000704 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900705 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000706 if (a.flags & ~(0x1 << VHOST_VRING_F_LOG)) {
707 r = -EOPNOTSUPP;
708 break;
709 }
710 /* For 32bit, verify that the top 32bits of the user
711 data are set to zero. */
712 if ((u64)(unsigned long)a.desc_user_addr != a.desc_user_addr ||
713 (u64)(unsigned long)a.used_user_addr != a.used_user_addr ||
714 (u64)(unsigned long)a.avail_user_addr != a.avail_user_addr) {
715 r = -EFAULT;
716 break;
717 }
718 if ((a.avail_user_addr & (sizeof *vq->avail->ring - 1)) ||
719 (a.used_user_addr & (sizeof *vq->used->ring - 1)) ||
720 (a.log_guest_addr & (sizeof *vq->used->ring - 1))) {
721 r = -EINVAL;
722 break;
723 }
724
725 /* We only verify access here if backend is configured.
726 * If it is not, we don't as size might not have been setup.
727 * We will verify when backend is configured. */
728 if (vq->private_data) {
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300729 if (!vq_access_ok(d, vq->num,
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000730 (void __user *)(unsigned long)a.desc_user_addr,
731 (void __user *)(unsigned long)a.avail_user_addr,
732 (void __user *)(unsigned long)a.used_user_addr)) {
733 r = -EINVAL;
734 break;
735 }
736
737 /* Also validate log access for used ring if enabled. */
738 if ((a.flags & (0x1 << VHOST_VRING_F_LOG)) &&
739 !log_access_ok(vq->log_base, a.log_guest_addr,
740 sizeof *vq->used +
741 vq->num * sizeof *vq->used->ring)) {
742 r = -EINVAL;
743 break;
744 }
745 }
746
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000747 vq->log_used = !!(a.flags & (0x1 << VHOST_VRING_F_LOG));
748 vq->desc = (void __user *)(unsigned long)a.desc_user_addr;
749 vq->avail = (void __user *)(unsigned long)a.avail_user_addr;
750 vq->log_addr = a.log_guest_addr;
751 vq->used = (void __user *)(unsigned long)a.used_user_addr;
752 break;
753 case VHOST_SET_VRING_KICK:
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900754 if (copy_from_user(&f, argp, sizeof f)) {
755 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000756 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900757 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000758 eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
Michael S. Tsirkin535297a2010-03-17 16:06:11 +0200759 if (IS_ERR(eventfp)) {
760 r = PTR_ERR(eventfp);
761 break;
762 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000763 if (eventfp != vq->kick) {
764 pollstop = filep = vq->kick;
765 pollstart = vq->kick = eventfp;
766 } else
767 filep = eventfp;
768 break;
769 case VHOST_SET_VRING_CALL:
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900770 if (copy_from_user(&f, argp, sizeof f)) {
771 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000772 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900773 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000774 eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
Michael S. Tsirkin535297a2010-03-17 16:06:11 +0200775 if (IS_ERR(eventfp)) {
776 r = PTR_ERR(eventfp);
777 break;
778 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000779 if (eventfp != vq->call) {
780 filep = vq->call;
781 ctx = vq->call_ctx;
782 vq->call = eventfp;
783 vq->call_ctx = eventfp ?
784 eventfd_ctx_fileget(eventfp) : NULL;
785 } else
786 filep = eventfp;
787 break;
788 case VHOST_SET_VRING_ERR:
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900789 if (copy_from_user(&f, argp, sizeof f)) {
790 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000791 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900792 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000793 eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
Michael S. Tsirkin535297a2010-03-17 16:06:11 +0200794 if (IS_ERR(eventfp)) {
795 r = PTR_ERR(eventfp);
796 break;
797 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000798 if (eventfp != vq->error) {
799 filep = vq->error;
800 vq->error = eventfp;
801 ctx = vq->error_ctx;
802 vq->error_ctx = eventfp ?
803 eventfd_ctx_fileget(eventfp) : NULL;
804 } else
805 filep = eventfp;
806 break;
807 default:
808 r = -ENOIOCTLCMD;
809 }
810
811 if (pollstop && vq->handle_kick)
812 vhost_poll_stop(&vq->poll);
813
814 if (ctx)
815 eventfd_ctx_put(ctx);
816 if (filep)
817 fput(filep);
818
819 if (pollstart && vq->handle_kick)
820 vhost_poll_start(&vq->poll, vq->kick);
821
822 mutex_unlock(&vq->mutex);
823
824 if (pollstop && vq->handle_kick)
825 vhost_poll_flush(&vq->poll);
826 return r;
827}
828
829/* Caller must have device mutex */
830long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, unsigned long arg)
831{
832 void __user *argp = (void __user *)arg;
833 struct file *eventfp, *filep = NULL;
834 struct eventfd_ctx *ctx = NULL;
835 u64 p;
836 long r;
837 int i, fd;
838
839 /* If you are not the owner, you can become one */
840 if (ioctl == VHOST_SET_OWNER) {
841 r = vhost_dev_set_owner(d);
842 goto done;
843 }
844
845 /* You must be the owner to do anything else */
846 r = vhost_dev_check_owner(d);
847 if (r)
848 goto done;
849
850 switch (ioctl) {
851 case VHOST_SET_MEM_TABLE:
852 r = vhost_set_memory(d, argp);
853 break;
854 case VHOST_SET_LOG_BASE:
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900855 if (copy_from_user(&p, argp, sizeof p)) {
856 r = -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000857 break;
Takuya Yoshikawa7ad9c9d2010-05-27 18:58:03 +0900858 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000859 if ((u64)(unsigned long)p != p) {
860 r = -EFAULT;
861 break;
862 }
863 for (i = 0; i < d->nvqs; ++i) {
864 struct vhost_virtqueue *vq;
865 void __user *base = (void __user *)(unsigned long)p;
866 vq = d->vqs + i;
867 mutex_lock(&vq->mutex);
868 /* If ring is inactive, will check when it's enabled. */
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +0300869 if (vq->private_data && !vq_log_access_ok(d, vq, base))
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000870 r = -EFAULT;
871 else
872 vq->log_base = base;
873 mutex_unlock(&vq->mutex);
874 }
875 break;
876 case VHOST_SET_LOG_FD:
877 r = get_user(fd, (int __user *)argp);
878 if (r < 0)
879 break;
880 eventfp = fd == -1 ? NULL : eventfd_fget(fd);
881 if (IS_ERR(eventfp)) {
882 r = PTR_ERR(eventfp);
883 break;
884 }
885 if (eventfp != d->log_file) {
886 filep = d->log_file;
887 ctx = d->log_ctx;
888 d->log_ctx = eventfp ?
889 eventfd_ctx_fileget(eventfp) : NULL;
890 } else
891 filep = eventfp;
892 for (i = 0; i < d->nvqs; ++i) {
893 mutex_lock(&d->vqs[i].mutex);
894 d->vqs[i].log_ctx = d->log_ctx;
895 mutex_unlock(&d->vqs[i].mutex);
896 }
897 if (ctx)
898 eventfd_ctx_put(ctx);
899 if (filep)
900 fput(filep);
901 break;
902 default:
903 r = vhost_set_vring(d, ioctl, argp);
904 break;
905 }
906done:
907 return r;
908}
909
910static const struct vhost_memory_region *find_region(struct vhost_memory *mem,
911 __u64 addr, __u32 len)
912{
913 struct vhost_memory_region *reg;
914 int i;
Krishna Kumard47effe2011-03-01 17:06:37 +0530915
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000916 /* linear search is not brilliant, but we really have on the order of 6
917 * regions in practice */
918 for (i = 0; i < mem->nregions; ++i) {
919 reg = mem->regions + i;
920 if (reg->guest_phys_addr <= addr &&
921 reg->guest_phys_addr + reg->memory_size - 1 >= addr)
922 return reg;
923 }
924 return NULL;
925}
926
927/* TODO: This is really inefficient. We need something like get_user()
928 * (instruction directly accesses the data, with an exception table entry
929 * returning -EFAULT). See Documentation/x86/exception-tables.txt.
930 */
931static int set_bit_to_user(int nr, void __user *addr)
932{
933 unsigned long log = (unsigned long)addr;
934 struct page *page;
935 void *base;
936 int bit = nr + (log % PAGE_SIZE) * 8;
937 int r;
Krishna Kumard47effe2011-03-01 17:06:37 +0530938
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000939 r = get_user_pages_fast(log, 1, 1, &page);
Michael S. Tsirkind6db3f52010-02-23 11:25:23 +0200940 if (r < 0)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000941 return r;
Michael S. Tsirkind6db3f52010-02-23 11:25:23 +0200942 BUG_ON(r != 1);
Cong Wangc6daa7f2011-11-25 23:14:26 +0800943 base = kmap_atomic(page);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000944 set_bit(bit, base);
Cong Wangc6daa7f2011-11-25 23:14:26 +0800945 kunmap_atomic(base);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000946 set_page_dirty_lock(page);
947 put_page(page);
948 return 0;
949}
950
951static int log_write(void __user *log_base,
952 u64 write_address, u64 write_length)
953{
Michael S. Tsirkin28831ee2010-11-29 10:22:10 +0200954 u64 write_page = write_address / VHOST_PAGE_SIZE;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000955 int r;
Krishna Kumard47effe2011-03-01 17:06:37 +0530956
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000957 if (!write_length)
958 return 0;
Michael S. Tsirkin3bf9be42010-11-29 10:19:07 +0200959 write_length += write_address % VHOST_PAGE_SIZE;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000960 for (;;) {
961 u64 base = (u64)(unsigned long)log_base;
Michael S. Tsirkin28831ee2010-11-29 10:22:10 +0200962 u64 log = base + write_page / 8;
963 int bit = write_page % 8;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000964 if ((u64)(unsigned long)log != log)
965 return -EFAULT;
966 r = set_bit_to_user(bit, (void __user *)(unsigned long)log);
967 if (r < 0)
968 return r;
969 if (write_length <= VHOST_PAGE_SIZE)
970 break;
971 write_length -= VHOST_PAGE_SIZE;
Michael S. Tsirkin28831ee2010-11-29 10:22:10 +0200972 write_page += 1;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000973 }
974 return r;
975}
976
977int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log,
978 unsigned int log_num, u64 len)
979{
980 int i, r;
981
982 /* Make sure data written is seen before log. */
Michael S. Tsirkin56593382010-02-01 07:21:02 +0000983 smp_wmb();
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000984 for (i = 0; i < log_num; ++i) {
985 u64 l = min(log[i].len, len);
986 r = log_write(vq->log_base, log[i].addr, l);
987 if (r < 0)
988 return r;
989 len -= l;
Michael S. Tsirkin5786aee2010-09-22 12:31:53 +0200990 if (!len) {
991 if (vq->log_ctx)
992 eventfd_signal(vq->log_ctx, 1);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000993 return 0;
Michael S. Tsirkin5786aee2010-09-22 12:31:53 +0200994 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000995 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +0000996 /* Length written exceeds what we have stored. This is a bug. */
997 BUG();
998 return 0;
999}
1000
Jason Wang2723fea2011-06-21 18:04:38 +08001001static int vhost_update_used_flags(struct vhost_virtqueue *vq)
1002{
1003 void __user *used;
Michael S. Tsirkinb8342262011-07-19 17:15:43 +03001004 if (__put_user(vq->used_flags, &vq->used->flags) < 0)
Jason Wang2723fea2011-06-21 18:04:38 +08001005 return -EFAULT;
1006 if (unlikely(vq->log_used)) {
1007 /* Make sure the flag is seen before log. */
1008 smp_wmb();
1009 /* Log used flag write. */
1010 used = &vq->used->flags;
1011 log_write(vq->log_base, vq->log_addr +
1012 (used - (void __user *)vq->used),
1013 sizeof vq->used->flags);
1014 if (vq->log_ctx)
1015 eventfd_signal(vq->log_ctx, 1);
1016 }
1017 return 0;
1018}
1019
1020static int vhost_update_avail_event(struct vhost_virtqueue *vq, u16 avail_event)
1021{
Michael S. Tsirkinb8342262011-07-19 17:15:43 +03001022 if (__put_user(vq->avail_idx, vhost_avail_event(vq)))
Jason Wang2723fea2011-06-21 18:04:38 +08001023 return -EFAULT;
1024 if (unlikely(vq->log_used)) {
1025 void __user *used;
1026 /* Make sure the event is seen before log. */
1027 smp_wmb();
1028 /* Log avail event write */
1029 used = vhost_avail_event(vq);
1030 log_write(vq->log_base, vq->log_addr +
1031 (used - (void __user *)vq->used),
1032 sizeof *vhost_avail_event(vq));
1033 if (vq->log_ctx)
1034 eventfd_signal(vq->log_ctx, 1);
1035 }
1036 return 0;
1037}
1038
1039int vhost_init_used(struct vhost_virtqueue *vq)
1040{
1041 int r;
1042 if (!vq->private_data)
1043 return 0;
1044
1045 r = vhost_update_used_flags(vq);
1046 if (r)
1047 return r;
1048 vq->signalled_used_valid = false;
1049 return get_user(vq->last_used_idx, &vq->used->idx);
1050}
1051
Christoph Hellwiga8d37822010-04-13 14:11:25 -04001052static int translate_desc(struct vhost_dev *dev, u64 addr, u32 len,
1053 struct iovec iov[], int iov_size)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001054{
1055 const struct vhost_memory_region *reg;
1056 struct vhost_memory *mem;
1057 struct iovec *_iov;
1058 u64 s = 0;
1059 int ret = 0;
1060
1061 rcu_read_lock();
1062
1063 mem = rcu_dereference(dev->memory);
1064 while ((u64)len > s) {
1065 u64 size;
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001066 if (unlikely(ret >= iov_size)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001067 ret = -ENOBUFS;
1068 break;
1069 }
1070 reg = find_region(mem, addr, len);
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001071 if (unlikely(!reg)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001072 ret = -EFAULT;
1073 break;
1074 }
1075 _iov = iov + ret;
1076 size = reg->memory_size - addr + reg->guest_phys_addr;
1077 _iov->iov_len = min((u64)len, size);
Christoph Hellwiga8d37822010-04-13 14:11:25 -04001078 _iov->iov_base = (void __user *)(unsigned long)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001079 (reg->userspace_addr + addr - reg->guest_phys_addr);
1080 s += size;
1081 addr += size;
1082 ++ret;
1083 }
1084
1085 rcu_read_unlock();
1086 return ret;
1087}
1088
1089/* Each buffer in the virtqueues is actually a chain of descriptors. This
1090 * function returns the next descriptor in the chain,
1091 * or -1U if we're at the end. */
1092static unsigned next_desc(struct vring_desc *desc)
1093{
1094 unsigned int next;
1095
1096 /* If this descriptor says it doesn't chain, we're done. */
1097 if (!(desc->flags & VRING_DESC_F_NEXT))
1098 return -1U;
1099
1100 /* Check they're not leading us off end of descriptors. */
1101 next = desc->next;
1102 /* Make sure compiler knows to grab that: we don't want it changing! */
1103 /* We will use the result as an index in an array, so most
1104 * architectures only need a compiler barrier here. */
1105 read_barrier_depends();
1106
1107 return next;
1108}
1109
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001110static int get_indirect(struct vhost_dev *dev, struct vhost_virtqueue *vq,
1111 struct iovec iov[], unsigned int iov_size,
1112 unsigned int *out_num, unsigned int *in_num,
1113 struct vhost_log *log, unsigned int *log_num,
1114 struct vring_desc *indirect)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001115{
1116 struct vring_desc desc;
1117 unsigned int i = 0, count, found = 0;
1118 int ret;
1119
1120 /* Sanity check */
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001121 if (unlikely(indirect->len % sizeof desc)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001122 vq_err(vq, "Invalid length in indirect descriptor: "
1123 "len 0x%llx not multiple of 0x%zx\n",
1124 (unsigned long long)indirect->len,
1125 sizeof desc);
1126 return -EINVAL;
1127 }
1128
1129 ret = translate_desc(dev, indirect->addr, indirect->len, vq->indirect,
Jason Wange0e9b402010-09-14 23:53:05 +08001130 UIO_MAXIOV);
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001131 if (unlikely(ret < 0)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001132 vq_err(vq, "Translation failure %d in indirect.\n", ret);
1133 return ret;
1134 }
1135
1136 /* We will use the result as an address to read from, so most
1137 * architectures only need a compiler barrier here. */
1138 read_barrier_depends();
1139
1140 count = indirect->len / sizeof desc;
1141 /* Buffers are chained via a 16 bit next field, so
1142 * we can have at most 2^16 of these. */
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001143 if (unlikely(count > USHRT_MAX + 1)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001144 vq_err(vq, "Indirect buffer length too big: %d\n",
1145 indirect->len);
1146 return -E2BIG;
1147 }
1148
1149 do {
1150 unsigned iov_count = *in_num + *out_num;
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001151 if (unlikely(++found > count)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001152 vq_err(vq, "Loop detected: last one at %u "
1153 "indirect size %u\n",
1154 i, count);
1155 return -EINVAL;
1156 }
Krishna Kumard47effe2011-03-01 17:06:37 +05301157 if (unlikely(memcpy_fromiovec((unsigned char *)&desc,
1158 vq->indirect, sizeof desc))) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001159 vq_err(vq, "Failed indirect descriptor: idx %d, %zx\n",
1160 i, (size_t)indirect->addr + i * sizeof desc);
1161 return -EINVAL;
1162 }
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001163 if (unlikely(desc.flags & VRING_DESC_F_INDIRECT)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001164 vq_err(vq, "Nested indirect descriptor: idx %d, %zx\n",
1165 i, (size_t)indirect->addr + i * sizeof desc);
1166 return -EINVAL;
1167 }
1168
1169 ret = translate_desc(dev, desc.addr, desc.len, iov + iov_count,
1170 iov_size - iov_count);
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001171 if (unlikely(ret < 0)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001172 vq_err(vq, "Translation failure %d indirect idx %d\n",
1173 ret, i);
1174 return ret;
1175 }
1176 /* If this is an input descriptor, increment that count. */
1177 if (desc.flags & VRING_DESC_F_WRITE) {
1178 *in_num += ret;
1179 if (unlikely(log)) {
1180 log[*log_num].addr = desc.addr;
1181 log[*log_num].len = desc.len;
1182 ++*log_num;
1183 }
1184 } else {
1185 /* If it's an output descriptor, they're all supposed
1186 * to come before any input descriptors. */
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001187 if (unlikely(*in_num)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001188 vq_err(vq, "Indirect descriptor "
1189 "has out after in: idx %d\n", i);
1190 return -EINVAL;
1191 }
1192 *out_num += ret;
1193 }
1194 } while ((i = next_desc(&desc)) != -1);
1195 return 0;
1196}
1197
1198/* This looks in the virtqueue and for the first available buffer, and converts
1199 * it to an iovec for convenient access. Since descriptors consist of some
1200 * number of output then some number of input descriptors, it's actually two
1201 * iovecs, but we pack them into one and note how many of each there were.
1202 *
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001203 * This function returns the descriptor number found, or vq->num (which is
1204 * never a valid descriptor number) if none was found. A negative code is
1205 * returned on error. */
1206int vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
1207 struct iovec iov[], unsigned int iov_size,
1208 unsigned int *out_num, unsigned int *in_num,
1209 struct vhost_log *log, unsigned int *log_num)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001210{
1211 struct vring_desc desc;
1212 unsigned int i, head, found = 0;
1213 u16 last_avail_idx;
1214 int ret;
1215
1216 /* Check it isn't doing very strange things with descriptor numbers. */
1217 last_avail_idx = vq->last_avail_idx;
Michael S. Tsirkin8b7347a2010-09-19 15:56:30 +02001218 if (unlikely(__get_user(vq->avail_idx, &vq->avail->idx))) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001219 vq_err(vq, "Failed to access avail idx at %p\n",
1220 &vq->avail->idx);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001221 return -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001222 }
1223
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001224 if (unlikely((u16)(vq->avail_idx - last_avail_idx) > vq->num)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001225 vq_err(vq, "Guest moved used index from %u to %u",
1226 last_avail_idx, vq->avail_idx);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001227 return -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001228 }
1229
1230 /* If there's nothing new since last we looked, return invalid. */
1231 if (vq->avail_idx == last_avail_idx)
1232 return vq->num;
1233
1234 /* Only get avail ring entries after they have been exposed by guest. */
Michael S. Tsirkin56593382010-02-01 07:21:02 +00001235 smp_rmb();
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001236
1237 /* Grab the next descriptor number they're advertising, and increment
1238 * the index we've seen. */
Michael S. Tsirkin8b7347a2010-09-19 15:56:30 +02001239 if (unlikely(__get_user(head,
1240 &vq->avail->ring[last_avail_idx % vq->num]))) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001241 vq_err(vq, "Failed to read head: idx %d address %p\n",
1242 last_avail_idx,
1243 &vq->avail->ring[last_avail_idx % vq->num]);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001244 return -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001245 }
1246
1247 /* If their number is silly, that's an error. */
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001248 if (unlikely(head >= vq->num)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001249 vq_err(vq, "Guest says index %u > %u is available",
1250 head, vq->num);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001251 return -EINVAL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001252 }
1253
1254 /* When we start there are none of either input nor output. */
1255 *out_num = *in_num = 0;
1256 if (unlikely(log))
1257 *log_num = 0;
1258
1259 i = head;
1260 do {
1261 unsigned iov_count = *in_num + *out_num;
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001262 if (unlikely(i >= vq->num)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001263 vq_err(vq, "Desc index is %u > %u, head = %u",
1264 i, vq->num, head);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001265 return -EINVAL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001266 }
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001267 if (unlikely(++found > vq->num)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001268 vq_err(vq, "Loop detected: last one at %u "
1269 "vq size %u head %u\n",
1270 i, vq->num, head);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001271 return -EINVAL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001272 }
Michael S. Tsirkinfcc042a2011-03-06 13:33:49 +02001273 ret = __copy_from_user(&desc, vq->desc + i, sizeof desc);
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001274 if (unlikely(ret)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001275 vq_err(vq, "Failed to get descriptor: idx %d addr %p\n",
1276 i, vq->desc + i);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001277 return -EFAULT;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001278 }
1279 if (desc.flags & VRING_DESC_F_INDIRECT) {
1280 ret = get_indirect(dev, vq, iov, iov_size,
1281 out_num, in_num,
1282 log, log_num, &desc);
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001283 if (unlikely(ret < 0)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001284 vq_err(vq, "Failure detected "
1285 "in indirect descriptor at idx %d\n", i);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001286 return ret;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001287 }
1288 continue;
1289 }
1290
1291 ret = translate_desc(dev, desc.addr, desc.len, iov + iov_count,
1292 iov_size - iov_count);
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001293 if (unlikely(ret < 0)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001294 vq_err(vq, "Translation failure %d descriptor idx %d\n",
1295 ret, i);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001296 return ret;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001297 }
1298 if (desc.flags & VRING_DESC_F_WRITE) {
1299 /* If this is an input descriptor,
1300 * increment that count. */
1301 *in_num += ret;
1302 if (unlikely(log)) {
1303 log[*log_num].addr = desc.addr;
1304 log[*log_num].len = desc.len;
1305 ++*log_num;
1306 }
1307 } else {
1308 /* If it's an output descriptor, they're all supposed
1309 * to come before any input descriptors. */
Michael S. Tsirkin7b3384f2010-07-01 18:40:12 +03001310 if (unlikely(*in_num)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001311 vq_err(vq, "Descriptor has out after in: "
1312 "idx %d\n", i);
Michael S. Tsirkind5675bd2010-06-24 16:59:59 +03001313 return -EINVAL;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001314 }
1315 *out_num += ret;
1316 }
1317 } while ((i = next_desc(&desc)) != -1);
1318
1319 /* On success, increment avail index. */
1320 vq->last_avail_idx++;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001321
1322 /* Assume notifications from guest are disabled at this point,
1323 * if they aren't we would need to update avail_event index. */
1324 BUG_ON(!(vq->used_flags & VRING_USED_F_NO_NOTIFY));
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001325 return head;
1326}
1327
1328/* Reverse the effect of vhost_get_vq_desc. Useful for error handling. */
David Stevens8dd014a2010-07-27 18:52:21 +03001329void vhost_discard_vq_desc(struct vhost_virtqueue *vq, int n)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001330{
David Stevens8dd014a2010-07-27 18:52:21 +03001331 vq->last_avail_idx -= n;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001332}
1333
1334/* After we've used one of their buffers, we tell them about it. We'll then
1335 * want to notify the guest, using eventfd. */
1336int vhost_add_used(struct vhost_virtqueue *vq, unsigned int head, int len)
1337{
Christoph Hellwiga8d37822010-04-13 14:11:25 -04001338 struct vring_used_elem __user *used;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001339
1340 /* The virtqueue contains a ring of used buffers. Get a pointer to the
1341 * next entry in that used ring. */
1342 used = &vq->used->ring[vq->last_used_idx % vq->num];
Michael S. Tsirkin8b7347a2010-09-19 15:56:30 +02001343 if (__put_user(head, &used->id)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001344 vq_err(vq, "Failed to write used id");
1345 return -EFAULT;
1346 }
Michael S. Tsirkin8b7347a2010-09-19 15:56:30 +02001347 if (__put_user(len, &used->len)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001348 vq_err(vq, "Failed to write used len");
1349 return -EFAULT;
1350 }
1351 /* Make sure buffer is written before we update index. */
Michael S. Tsirkin56593382010-02-01 07:21:02 +00001352 smp_wmb();
Michael S. Tsirkin8b7347a2010-09-19 15:56:30 +02001353 if (__put_user(vq->last_used_idx + 1, &vq->used->idx)) {
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001354 vq_err(vq, "Failed to increment used idx");
1355 return -EFAULT;
1356 }
1357 if (unlikely(vq->log_used)) {
1358 /* Make sure data is seen before log. */
Michael S. Tsirkin56593382010-02-01 07:21:02 +00001359 smp_wmb();
Michael S. Tsirkin86e94242010-02-17 19:11:33 +02001360 /* Log used ring entry write. */
1361 log_write(vq->log_base,
Christoph Hellwiga8d37822010-04-13 14:11:25 -04001362 vq->log_addr +
1363 ((void __user *)used - (void __user *)vq->used),
Michael S. Tsirkin86e94242010-02-17 19:11:33 +02001364 sizeof *used);
1365 /* Log used index update. */
1366 log_write(vq->log_base,
1367 vq->log_addr + offsetof(struct vring_used, idx),
1368 sizeof vq->used->idx);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001369 if (vq->log_ctx)
1370 eventfd_signal(vq->log_ctx, 1);
1371 }
1372 vq->last_used_idx++;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001373 /* If the driver never bothers to signal in a very long while,
1374 * used index might wrap around. If that happens, invalidate
1375 * signalled_used index we stored. TODO: make sure driver
1376 * signals at least once in 2^16 and remove this. */
1377 if (unlikely(vq->last_used_idx == vq->signalled_used))
1378 vq->signalled_used_valid = false;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001379 return 0;
1380}
1381
David Stevens8dd014a2010-07-27 18:52:21 +03001382static int __vhost_add_used_n(struct vhost_virtqueue *vq,
1383 struct vring_used_elem *heads,
1384 unsigned count)
1385{
1386 struct vring_used_elem __user *used;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001387 u16 old, new;
David Stevens8dd014a2010-07-27 18:52:21 +03001388 int start;
1389
1390 start = vq->last_used_idx % vq->num;
1391 used = vq->used->ring + start;
Michael S. Tsirkindfe5ac52010-09-21 14:18:01 +02001392 if (__copy_to_user(used, heads, count * sizeof *used)) {
David Stevens8dd014a2010-07-27 18:52:21 +03001393 vq_err(vq, "Failed to write used");
1394 return -EFAULT;
1395 }
1396 if (unlikely(vq->log_used)) {
1397 /* Make sure data is seen before log. */
1398 smp_wmb();
1399 /* Log used ring entry write. */
1400 log_write(vq->log_base,
1401 vq->log_addr +
1402 ((void __user *)used - (void __user *)vq->used),
1403 count * sizeof *used);
1404 }
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001405 old = vq->last_used_idx;
1406 new = (vq->last_used_idx += count);
1407 /* If the driver never bothers to signal in a very long while,
1408 * used index might wrap around. If that happens, invalidate
1409 * signalled_used index we stored. TODO: make sure driver
1410 * signals at least once in 2^16 and remove this. */
1411 if (unlikely((u16)(new - vq->signalled_used) < (u16)(new - old)))
1412 vq->signalled_used_valid = false;
David Stevens8dd014a2010-07-27 18:52:21 +03001413 return 0;
1414}
1415
1416/* After we've used one of their buffers, we tell them about it. We'll then
1417 * want to notify the guest, using eventfd. */
1418int vhost_add_used_n(struct vhost_virtqueue *vq, struct vring_used_elem *heads,
1419 unsigned count)
1420{
1421 int start, n, r;
1422
1423 start = vq->last_used_idx % vq->num;
1424 n = vq->num - start;
1425 if (n < count) {
1426 r = __vhost_add_used_n(vq, heads, n);
1427 if (r < 0)
1428 return r;
1429 heads += n;
1430 count -= n;
1431 }
1432 r = __vhost_add_used_n(vq, heads, count);
1433
1434 /* Make sure buffer is written before we update index. */
1435 smp_wmb();
1436 if (put_user(vq->last_used_idx, &vq->used->idx)) {
1437 vq_err(vq, "Failed to increment used idx");
1438 return -EFAULT;
1439 }
1440 if (unlikely(vq->log_used)) {
1441 /* Log used index update. */
1442 log_write(vq->log_base,
1443 vq->log_addr + offsetof(struct vring_used, idx),
1444 sizeof vq->used->idx);
1445 if (vq->log_ctx)
1446 eventfd_signal(vq->log_ctx, 1);
1447 }
1448 return r;
1449}
1450
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001451static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001452{
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001453 __u16 old, new, event;
1454 bool v;
Michael S. Tsirkin0d499352010-05-11 19:44:17 +03001455 /* Flush out used index updates. This is paired
1456 * with the barrier that the Guest executes when enabling
1457 * interrupts. */
1458 smp_mb();
1459
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001460 if (vhost_has_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
1461 unlikely(vq->avail_idx == vq->last_avail_idx))
1462 return true;
1463
1464 if (!vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
1465 __u16 flags;
1466 if (__get_user(flags, &vq->avail->flags)) {
1467 vq_err(vq, "Failed to get flags");
1468 return true;
1469 }
1470 return !(flags & VRING_AVAIL_F_NO_INTERRUPT);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001471 }
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001472 old = vq->signalled_used;
1473 v = vq->signalled_used_valid;
1474 new = vq->signalled_used = vq->last_used_idx;
1475 vq->signalled_used_valid = true;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001476
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001477 if (unlikely(!v))
1478 return true;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001479
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001480 if (get_user(event, vhost_used_event(vq))) {
1481 vq_err(vq, "Failed to get used event idx");
1482 return true;
1483 }
1484 return vring_need_event(event, new, old);
1485}
1486
1487/* This actually signals the guest, using eventfd. */
1488void vhost_signal(struct vhost_dev *dev, struct vhost_virtqueue *vq)
1489{
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001490 /* Signal the Guest tell them we used something up. */
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001491 if (vq->call_ctx && vhost_notify(dev, vq))
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001492 eventfd_signal(vq->call_ctx, 1);
1493}
1494
1495/* And here's the combo meal deal. Supersize me! */
1496void vhost_add_used_and_signal(struct vhost_dev *dev,
1497 struct vhost_virtqueue *vq,
1498 unsigned int head, int len)
1499{
1500 vhost_add_used(vq, head, len);
1501 vhost_signal(dev, vq);
1502}
1503
David Stevens8dd014a2010-07-27 18:52:21 +03001504/* multi-buffer version of vhost_add_used_and_signal */
1505void vhost_add_used_and_signal_n(struct vhost_dev *dev,
1506 struct vhost_virtqueue *vq,
1507 struct vring_used_elem *heads, unsigned count)
1508{
1509 vhost_add_used_n(vq, heads, count);
1510 vhost_signal(dev, vq);
1511}
1512
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001513/* OK, now we need to know about added descriptors. */
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001514bool vhost_enable_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001515{
1516 u16 avail_idx;
1517 int r;
Krishna Kumard47effe2011-03-01 17:06:37 +05301518
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001519 if (!(vq->used_flags & VRING_USED_F_NO_NOTIFY))
1520 return false;
1521 vq->used_flags &= ~VRING_USED_F_NO_NOTIFY;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001522 if (!vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
Jason Wang2723fea2011-06-21 18:04:38 +08001523 r = vhost_update_used_flags(vq);
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001524 if (r) {
1525 vq_err(vq, "Failed to enable notification at %p: %d\n",
1526 &vq->used->flags, r);
1527 return false;
1528 }
1529 } else {
Jason Wang2723fea2011-06-21 18:04:38 +08001530 r = vhost_update_avail_event(vq, vq->avail_idx);
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001531 if (r) {
1532 vq_err(vq, "Failed to update avail event index at %p: %d\n",
1533 vhost_avail_event(vq), r);
1534 return false;
1535 }
1536 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001537 /* They could have slipped one in as we were doing that: make
1538 * sure it's written, then check again. */
Michael S. Tsirkin56593382010-02-01 07:21:02 +00001539 smp_mb();
Michael S. Tsirkin8b7347a2010-09-19 15:56:30 +02001540 r = __get_user(avail_idx, &vq->avail->idx);
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001541 if (r) {
1542 vq_err(vq, "Failed to check avail idx at %p: %d\n",
1543 &vq->avail->idx, r);
1544 return false;
1545 }
1546
David Stevens8dd014a2010-07-27 18:52:21 +03001547 return avail_idx != vq->avail_idx;
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001548}
1549
1550/* We don't need to be notified again. */
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001551void vhost_disable_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001552{
1553 int r;
Krishna Kumard47effe2011-03-01 17:06:37 +05301554
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001555 if (vq->used_flags & VRING_USED_F_NO_NOTIFY)
1556 return;
1557 vq->used_flags |= VRING_USED_F_NO_NOTIFY;
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001558 if (!vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
Jason Wang2723fea2011-06-21 18:04:38 +08001559 r = vhost_update_used_flags(vq);
Michael S. Tsirkin8ea8cf82011-05-20 02:10:54 +03001560 if (r)
1561 vq_err(vq, "Failed to enable notification at %p: %d\n",
1562 &vq->used->flags, r);
1563 }
Michael S. Tsirkin3a4d5c94e2010-01-14 06:17:27 +00001564}
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +00001565
1566static void vhost_zerocopy_done_signal(struct kref *kref)
1567{
1568 struct vhost_ubuf_ref *ubufs = container_of(kref, struct vhost_ubuf_ref,
1569 kref);
1570 wake_up(&ubufs->wait);
1571}
1572
1573struct vhost_ubuf_ref *vhost_ubuf_alloc(struct vhost_virtqueue *vq,
1574 bool zcopy)
1575{
1576 struct vhost_ubuf_ref *ubufs;
1577 /* No zero copy backend? Nothing to count. */
1578 if (!zcopy)
1579 return NULL;
1580 ubufs = kmalloc(sizeof *ubufs, GFP_KERNEL);
1581 if (!ubufs)
1582 return ERR_PTR(-ENOMEM);
1583 kref_init(&ubufs->kref);
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +00001584 init_waitqueue_head(&ubufs->wait);
1585 ubufs->vq = vq;
1586 return ubufs;
1587}
1588
1589void vhost_ubuf_put(struct vhost_ubuf_ref *ubufs)
1590{
1591 kref_put(&ubufs->kref, vhost_zerocopy_done_signal);
1592}
1593
1594void vhost_ubuf_put_and_wait(struct vhost_ubuf_ref *ubufs)
1595{
1596 kref_put(&ubufs->kref, vhost_zerocopy_done_signal);
1597 wait_event(ubufs->wait, !atomic_read(&ubufs->kref.refcount));
1598 kfree(ubufs);
1599}
1600
Michael S. Tsirkinca8f4fb2012-04-09 00:24:02 +00001601void vhost_zerocopy_callback(struct ubuf_info *ubuf)
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +00001602{
Michael S. Tsirkinca8f4fb2012-04-09 00:24:02 +00001603 struct vhost_ubuf_ref *ubufs = ubuf->ctx;
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +00001604 struct vhost_virtqueue *vq = ubufs->vq;
1605
Jason Wangc70aa542012-05-02 11:42:54 +08001606 vhost_poll_queue(&vq->poll);
Michael S. Tsirkinbab632d2011-07-18 03:48:46 +00001607 /* set len = 1 to mark this desc buffers done DMA */
1608 vq->heads[ubuf->desc].len = VHOST_DMA_DONE_LEN;
1609 kref_put(&ubufs->kref, vhost_zerocopy_done_signal);
1610}