hw/arm/bcm2836: Only provide "enabled-cpus" property to multicore SoCs
[qemu.git] / hw / vfio / spapr.c
1 /*
2 * DMA memory preregistration
3 *
4 * Authors:
5 * Alexey Kardashevskiy <aik@ozlabs.ru>
6 *
7 * This work is licensed under the terms of the GNU GPL, version 2. See
8 * the COPYING file in the top-level directory.
9 */
10
11 #include "qemu/osdep.h"
12 #include "cpu.h"
13 #include <sys/ioctl.h>
14 #include <linux/vfio.h>
15
16 #include "hw/vfio/vfio-common.h"
17 #include "hw/hw.h"
18 #include "exec/ram_addr.h"
19 #include "qemu/error-report.h"
20 #include "qapi/error.h"
21 #include "trace.h"
22
23 static bool vfio_prereg_listener_skipped_section(MemoryRegionSection *section)
24 {
25 if (memory_region_is_iommu(section->mr)) {
26 hw_error("Cannot possibly preregister IOMMU memory");
27 }
28
29 return !memory_region_is_ram(section->mr) ||
30 memory_region_is_ram_device(section->mr);
31 }
32
33 static void *vfio_prereg_gpa_to_vaddr(MemoryRegionSection *section, hwaddr gpa)
34 {
35 return memory_region_get_ram_ptr(section->mr) +
36 section->offset_within_region +
37 (gpa - section->offset_within_address_space);
38 }
39
40 static void vfio_prereg_listener_region_add(MemoryListener *listener,
41 MemoryRegionSection *section)
42 {
43 VFIOContainer *container = container_of(listener, VFIOContainer,
44 prereg_listener);
45 const hwaddr gpa = section->offset_within_address_space;
46 hwaddr end;
47 int ret;
48 hwaddr page_mask = qemu_real_host_page_mask;
49 struct vfio_iommu_spapr_register_memory reg = {
50 .argsz = sizeof(reg),
51 .flags = 0,
52 };
53
54 if (vfio_prereg_listener_skipped_section(section)) {
55 trace_vfio_prereg_listener_region_add_skip(
56 section->offset_within_address_space,
57 section->offset_within_address_space +
58 int128_get64(int128_sub(section->size, int128_one())));
59 return;
60 }
61
62 if (unlikely((section->offset_within_address_space & ~page_mask) ||
63 (section->offset_within_region & ~page_mask) ||
64 (int128_get64(section->size) & ~page_mask))) {
65 error_report("%s received unaligned region", __func__);
66 return;
67 }
68
69 end = section->offset_within_address_space + int128_get64(section->size);
70 if (gpa >= end) {
71 return;
72 }
73
74 memory_region_ref(section->mr);
75
76 reg.vaddr = (uintptr_t) vfio_prereg_gpa_to_vaddr(section, gpa);
77 reg.size = end - gpa;
78
79 ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_REGISTER_MEMORY, &reg);
80 trace_vfio_prereg_register(reg.vaddr, reg.size, ret ? -errno : 0);
81 if (ret) {
82 /*
83 * On the initfn path, store the first error in the container so we
84 * can gracefully fail. Runtime, there's not much we can do other
85 * than throw a hardware error.
86 */
87 if (!container->initialized) {
88 if (!container->error) {
89 error_setg_errno(&container->error, -ret,
90 "Memory registering failed");
91 }
92 } else {
93 hw_error("vfio: Memory registering failed, unable to continue");
94 }
95 }
96 }
97
98 static void vfio_prereg_listener_region_del(MemoryListener *listener,
99 MemoryRegionSection *section)
100 {
101 VFIOContainer *container = container_of(listener, VFIOContainer,
102 prereg_listener);
103 const hwaddr gpa = section->offset_within_address_space;
104 hwaddr end;
105 int ret;
106 hwaddr page_mask = qemu_real_host_page_mask;
107 struct vfio_iommu_spapr_register_memory reg = {
108 .argsz = sizeof(reg),
109 .flags = 0,
110 };
111
112 if (vfio_prereg_listener_skipped_section(section)) {
113 trace_vfio_prereg_listener_region_del_skip(
114 section->offset_within_address_space,
115 section->offset_within_address_space +
116 int128_get64(int128_sub(section->size, int128_one())));
117 return;
118 }
119
120 if (unlikely((section->offset_within_address_space & ~page_mask) ||
121 (section->offset_within_region & ~page_mask) ||
122 (int128_get64(section->size) & ~page_mask))) {
123 error_report("%s received unaligned region", __func__);
124 return;
125 }
126
127 end = section->offset_within_address_space + int128_get64(section->size);
128 if (gpa >= end) {
129 return;
130 }
131
132 reg.vaddr = (uintptr_t) vfio_prereg_gpa_to_vaddr(section, gpa);
133 reg.size = end - gpa;
134
135 ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY, &reg);
136 trace_vfio_prereg_unregister(reg.vaddr, reg.size, ret ? -errno : 0);
137 }
138
139 const MemoryListener vfio_prereg_listener = {
140 .region_add = vfio_prereg_listener_region_add,
141 .region_del = vfio_prereg_listener_region_del,
142 };
143
144 int vfio_spapr_create_window(VFIOContainer *container,
145 MemoryRegionSection *section,
146 hwaddr *pgsize)
147 {
148 int ret = 0;
149 IOMMUMemoryRegion *iommu_mr = IOMMU_MEMORY_REGION(section->mr);
150 uint64_t pagesize = memory_region_iommu_get_min_page_size(iommu_mr), pgmask;
151 unsigned entries, bits_total, bits_per_level, max_levels;
152 struct vfio_iommu_spapr_tce_create create = { .argsz = sizeof(create) };
153 long rampagesize = qemu_minrampagesize();
154
155 /*
156 * The host might not support the guest supported IOMMU page size,
157 * so we will use smaller physical IOMMU pages to back them.
158 */
159 if (pagesize > rampagesize) {
160 pagesize = rampagesize;
161 }
162 pgmask = container->pgsizes & (pagesize | (pagesize - 1));
163 pagesize = pgmask ? (1ULL << (63 - clz64(pgmask))) : 0;
164 if (!pagesize) {
165 error_report("Host doesn't support page size 0x%"PRIx64
166 ", the supported mask is 0x%lx",
167 memory_region_iommu_get_min_page_size(iommu_mr),
168 container->pgsizes);
169 return -EINVAL;
170 }
171
172 /*
173 * FIXME: For VFIO iommu types which have KVM acceleration to
174 * avoid bouncing all map/unmaps through qemu this way, this
175 * would be the right place to wire that up (tell the KVM
176 * device emulation the VFIO iommu handles to use).
177 */
178 create.window_size = int128_get64(section->size);
179 create.page_shift = ctz64(pagesize);
180 /*
181 * SPAPR host supports multilevel TCE tables. We try to guess optimal
182 * levels number and if this fails (for example due to the host memory
183 * fragmentation), we increase levels. The DMA address structure is:
184 * rrrrrrrr rxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx iiiiiiii
185 * where:
186 * r = reserved (bits >= 55 are reserved in the existing hardware)
187 * i = IOMMU page offset (64K in this example)
188 * x = bits to index a TCE which can be split to equal chunks to index
189 * within the level.
190 * The aim is to split "x" to smaller possible number of levels.
191 */
192 entries = create.window_size >> create.page_shift;
193 /* bits_total is number of "x" needed */
194 bits_total = ctz64(entries * sizeof(uint64_t));
195 /*
196 * bits_per_level is a safe guess of how much we can allocate per level:
197 * 8 is the current minimum for CONFIG_FORCE_MAX_ZONEORDER and MAX_ORDER
198 * is usually bigger than that.
199 * Below we look at qemu_real_host_page_size as TCEs are allocated from
200 * system pages.
201 */
202 bits_per_level = ctz64(qemu_real_host_page_size) + 8;
203 create.levels = bits_total / bits_per_level;
204 if (bits_total % bits_per_level) {
205 ++create.levels;
206 }
207 max_levels = (64 - create.page_shift) / ctz64(qemu_real_host_page_size);
208 for ( ; create.levels <= max_levels; ++create.levels) {
209 ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_TCE_CREATE, &create);
210 if (!ret) {
211 break;
212 }
213 }
214 if (ret) {
215 error_report("Failed to create a window, ret = %d (%m)", ret);
216 return -errno;
217 }
218
219 if (create.start_addr != section->offset_within_address_space) {
220 vfio_spapr_remove_window(container, create.start_addr);
221
222 error_report("Host doesn't support DMA window at %"HWADDR_PRIx", must be %"PRIx64,
223 section->offset_within_address_space,
224 (uint64_t)create.start_addr);
225 return -EINVAL;
226 }
227 trace_vfio_spapr_create_window(create.page_shift,
228 create.levels,
229 create.window_size,
230 create.start_addr);
231 *pgsize = pagesize;
232
233 return 0;
234 }
235
236 int vfio_spapr_remove_window(VFIOContainer *container,
237 hwaddr offset_within_address_space)
238 {
239 struct vfio_iommu_spapr_tce_remove remove = {
240 .argsz = sizeof(remove),
241 .start_addr = offset_within_address_space,
242 };
243 int ret;
244
245 ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_TCE_REMOVE, &remove);
246 if (ret) {
247 error_report("Failed to remove window at %"PRIx64,
248 (uint64_t)remove.start_addr);
249 return -errno;
250 }
251
252 trace_vfio_spapr_remove_window(offset_within_address_space);
253
254 return 0;
255 }