Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / virt / kvm / coalesced_mmio.c
1 /*
2  * KVM coalesced MMIO
3  *
4  * Copyright (c) 2008 Bull S.A.S.
5  *
6  *  Author: Laurent Vivier <Laurent.Vivier@bull.net>
7  *
8  */
9
10 #include "iodev.h"
11
12 #include <linux/kvm_host.h>
13 #include <linux/kvm.h>
14
15 #include "coalesced_mmio.h"
16
17 static inline struct kvm_coalesced_mmio_dev *to_mmio(struct kvm_io_device *dev)
18 {
19         return container_of(dev, struct kvm_coalesced_mmio_dev, dev);
20 }
21
22 static int coalesced_mmio_in_range(struct kvm_coalesced_mmio_dev *dev,
23                                    gpa_t addr, int len)
24 {
25         struct kvm_coalesced_mmio_zone *zone;
26         struct kvm_coalesced_mmio_ring *ring;
27         unsigned avail;
28         int i;
29
30         /* Are we able to batch it ? */
31
32         /* last is the first free entry
33          * check if we don't meet the first used entry
34          * there is always one unused entry in the buffer
35          */
36         ring = dev->kvm->coalesced_mmio_ring;
37         avail = (ring->first - ring->last - 1) % KVM_COALESCED_MMIO_MAX;
38         if (avail < KVM_MAX_VCPUS) {
39                 /* full */
40                 return 0;
41         }
42
43         /* is it in a batchable area ? */
44
45         for (i = 0; i < dev->nb_zones; i++) {
46                 zone = &dev->zone[i];
47
48                 /* (addr,len) is fully included in
49                  * (zone->addr, zone->size)
50                  */
51
52                 if (zone->addr <= addr &&
53                     addr + len <= zone->addr + zone->size)
54                         return 1;
55         }
56         return 0;
57 }
58
59 static int coalesced_mmio_write(struct kvm_io_device *this,
60                                 gpa_t addr, int len, const void *val)
61 {
62         struct kvm_coalesced_mmio_dev *dev = to_mmio(this);
63         struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring;
64         if (!coalesced_mmio_in_range(dev, addr, len))
65                 return -EOPNOTSUPP;
66
67         spin_lock(&dev->lock);
68
69         /* copy data in first free entry of the ring */
70
71         ring->coalesced_mmio[ring->last].phys_addr = addr;
72         ring->coalesced_mmio[ring->last].len = len;
73         memcpy(ring->coalesced_mmio[ring->last].data, val, len);
74         smp_wmb();
75         ring->last = (ring->last + 1) % KVM_COALESCED_MMIO_MAX;
76         spin_unlock(&dev->lock);
77         return 0;
78 }
79
80 static void coalesced_mmio_destructor(struct kvm_io_device *this)
81 {
82         struct kvm_coalesced_mmio_dev *dev = to_mmio(this);
83
84         kfree(dev);
85 }
86
87 static const struct kvm_io_device_ops coalesced_mmio_ops = {
88         .write      = coalesced_mmio_write,
89         .destructor = coalesced_mmio_destructor,
90 };
91
92 int kvm_coalesced_mmio_init(struct kvm *kvm)
93 {
94         struct kvm_coalesced_mmio_dev *dev;
95         struct page *page;
96         int ret;
97
98         ret = -ENOMEM;
99         page = alloc_page(GFP_KERNEL | __GFP_ZERO);
100         if (!page)
101                 goto out_err;
102         kvm->coalesced_mmio_ring = page_address(page);
103
104         ret = -ENOMEM;
105         dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev), GFP_KERNEL);
106         if (!dev)
107                 goto out_free_page;
108         spin_lock_init(&dev->lock);
109         kvm_iodevice_init(&dev->dev, &coalesced_mmio_ops);
110         dev->kvm = kvm;
111         kvm->coalesced_mmio_dev = dev;
112
113         mutex_lock(&kvm->slots_lock);
114         ret = kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS, &dev->dev);
115         mutex_unlock(&kvm->slots_lock);
116         if (ret < 0)
117                 goto out_free_dev;
118
119         return ret;
120
121 out_free_dev:
122         kfree(dev);
123 out_free_page:
124         __free_page(page);
125 out_err:
126         return ret;
127 }
128
129 void kvm_coalesced_mmio_free(struct kvm *kvm)
130 {
131         if (kvm->coalesced_mmio_ring)
132                 free_page((unsigned long)kvm->coalesced_mmio_ring);
133 }
134
135 int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm,
136                                          struct kvm_coalesced_mmio_zone *zone)
137 {
138         struct kvm_coalesced_mmio_dev *dev = kvm->coalesced_mmio_dev;
139
140         if (dev == NULL)
141                 return -EINVAL;
142
143         mutex_lock(&kvm->slots_lock);
144         if (dev->nb_zones >= KVM_COALESCED_MMIO_ZONE_MAX) {
145                 mutex_unlock(&kvm->slots_lock);
146                 return -ENOBUFS;
147         }
148
149         dev->zone[dev->nb_zones] = *zone;
150         dev->nb_zones++;
151
152         mutex_unlock(&kvm->slots_lock);
153         return 0;
154 }
155
156 int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm,
157                                            struct kvm_coalesced_mmio_zone *zone)
158 {
159         int i;
160         struct kvm_coalesced_mmio_dev *dev = kvm->coalesced_mmio_dev;
161         struct kvm_coalesced_mmio_zone *z;
162
163         if (dev == NULL)
164                 return -EINVAL;
165
166         mutex_lock(&kvm->slots_lock);
167
168         i = dev->nb_zones;
169         while (i) {
170                 z = &dev->zone[i - 1];
171
172                 /* unregister all zones
173                  * included in (zone->addr, zone->size)
174                  */
175
176                 if (zone->addr <= z->addr &&
177                     z->addr + z->size <= zone->addr + zone->size) {
178                         dev->nb_zones--;
179                         *z = dev->zone[dev->nb_zones];
180                 }
181                 i--;
182         }
183
184         mutex_unlock(&kvm->slots_lock);
185
186         return 0;
187 }