]>
Commit | Line | Data |
---|---|---|
2cc0e2e8 DH |
1 | /* |
2 | * Memory Device Interface | |
3 | * | |
4 | * Copyright ProfitBricks GmbH 2012 | |
5 | * Copyright (C) 2014 Red Hat Inc | |
6 | * Copyright (c) 2018 Red Hat Inc | |
7 | * | |
8 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
9 | * See the COPYING file in the top-level directory. | |
10 | */ | |
11 | ||
12 | #include "qemu/osdep.h" | |
13 | #include "hw/mem/memory-device.h" | |
14 | #include "hw/qdev.h" | |
15 | #include "qapi/error.h" | |
16 | #include "hw/boards.h" | |
17 | #include "qemu/range.h" | |
1b6d6af2 DH |
18 | #include "hw/virtio/vhost.h" |
19 | #include "sysemu/kvm.h" | |
2cc0e2e8 DH |
20 | |
21 | static gint memory_device_addr_sort(gconstpointer a, gconstpointer b) | |
22 | { | |
23 | const MemoryDeviceState *md_a = MEMORY_DEVICE(a); | |
24 | const MemoryDeviceState *md_b = MEMORY_DEVICE(b); | |
25 | const MemoryDeviceClass *mdc_a = MEMORY_DEVICE_GET_CLASS(a); | |
26 | const MemoryDeviceClass *mdc_b = MEMORY_DEVICE_GET_CLASS(b); | |
27 | const uint64_t addr_a = mdc_a->get_addr(md_a); | |
28 | const uint64_t addr_b = mdc_b->get_addr(md_b); | |
29 | ||
30 | if (addr_a > addr_b) { | |
31 | return 1; | |
32 | } else if (addr_a < addr_b) { | |
33 | return -1; | |
34 | } | |
35 | return 0; | |
36 | } | |
37 | ||
38 | static int memory_device_build_list(Object *obj, void *opaque) | |
39 | { | |
40 | GSList **list = opaque; | |
41 | ||
42 | if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { | |
43 | DeviceState *dev = DEVICE(obj); | |
44 | if (dev->realized) { /* only realized memory devices matter */ | |
45 | *list = g_slist_insert_sorted(*list, dev, memory_device_addr_sort); | |
46 | } | |
47 | } | |
48 | ||
49 | object_child_foreach(obj, memory_device_build_list, opaque); | |
50 | return 0; | |
51 | } | |
52 | ||
1b6d6af2 DH |
53 | static int memory_device_used_region_size(Object *obj, void *opaque) |
54 | { | |
55 | uint64_t *size = opaque; | |
56 | ||
57 | if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { | |
58 | const DeviceState *dev = DEVICE(obj); | |
59 | const MemoryDeviceState *md = MEMORY_DEVICE(obj); | |
1b6d6af2 DH |
60 | |
61 | if (dev->realized) { | |
946d6154 | 62 | *size += memory_device_get_region_size(md, &error_abort); |
1b6d6af2 DH |
63 | } |
64 | } | |
65 | ||
66 | object_child_foreach(obj, memory_device_used_region_size, opaque); | |
67 | return 0; | |
68 | } | |
69 | ||
70 | static void memory_device_check_addable(MachineState *ms, uint64_t size, | |
71 | Error **errp) | |
72 | { | |
73 | uint64_t used_region_size = 0; | |
74 | ||
75 | /* we will need a new memory slot for kvm and vhost */ | |
76 | if (kvm_enabled() && !kvm_has_free_slot(ms)) { | |
77 | error_setg(errp, "hypervisor has no free memory slots left"); | |
78 | return; | |
79 | } | |
80 | if (!vhost_has_free_slot()) { | |
81 | error_setg(errp, "a used vhost backend has no free memory slots left"); | |
82 | return; | |
83 | } | |
84 | ||
85 | /* will we exceed the total amount of memory specified */ | |
86 | memory_device_used_region_size(OBJECT(ms), &used_region_size); | |
87 | if (used_region_size + size > ms->maxram_size - ms->ram_size) { | |
88 | error_setg(errp, "not enough space, currently 0x%" PRIx64 | |
26b1d1fd | 89 | " in use of total space for memory devices 0x" RAM_ADDR_FMT, |
1b6d6af2 DH |
90 | used_region_size, ms->maxram_size - ms->ram_size); |
91 | return; | |
92 | } | |
93 | ||
94 | } | |
95 | ||
6ef2c0f2 DH |
96 | static uint64_t memory_device_get_free_addr(MachineState *ms, |
97 | const uint64_t *hint, | |
98 | uint64_t align, uint64_t size, | |
99 | Error **errp) | |
bb0831bd DH |
100 | { |
101 | uint64_t address_space_start, address_space_end; | |
102 | GSList *list = NULL, *item; | |
103 | uint64_t new_addr = 0; | |
104 | ||
105 | if (!ms->device_memory) { | |
106 | error_setg(errp, "memory devices (e.g. for memory hotplug) are not " | |
107 | "supported by the machine"); | |
108 | return 0; | |
109 | } | |
110 | ||
111 | if (!memory_region_size(&ms->device_memory->mr)) { | |
112 | error_setg(errp, "memory devices (e.g. for memory hotplug) are not " | |
113 | "enabled, please specify the maxmem option"); | |
114 | return 0; | |
115 | } | |
116 | address_space_start = ms->device_memory->base; | |
117 | address_space_end = address_space_start + | |
118 | memory_region_size(&ms->device_memory->mr); | |
bb0831bd DH |
119 | g_assert(address_space_end >= address_space_start); |
120 | ||
4d8938a0 DH |
121 | /* address_space_start indicates the maximum alignment we expect */ |
122 | if (QEMU_ALIGN_UP(address_space_start, align) != address_space_start) { | |
7c63ba20 | 123 | error_setg(errp, "the alignment (0x%" PRIx64 ") is not supported", |
4d8938a0 DH |
124 | align); |
125 | return 0; | |
126 | } | |
127 | ||
1b6d6af2 DH |
128 | memory_device_check_addable(ms, size, errp); |
129 | if (*errp) { | |
130 | return 0; | |
131 | } | |
132 | ||
bb0831bd DH |
133 | if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) { |
134 | error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes", | |
135 | align); | |
136 | return 0; | |
137 | } | |
138 | ||
139 | if (QEMU_ALIGN_UP(size, align) != size) { | |
140 | error_setg(errp, "backend memory size must be multiple of 0x%" | |
141 | PRIx64, align); | |
142 | return 0; | |
143 | } | |
144 | ||
145 | if (hint) { | |
146 | new_addr = *hint; | |
147 | if (new_addr < address_space_start) { | |
26b1d1fd | 148 | error_setg(errp, "can't add memory device [0x%" PRIx64 ":0x%" PRIx64 |
ac1b3375 DH |
149 | "] before 0x%" PRIx64, new_addr, size, |
150 | address_space_start); | |
bb0831bd DH |
151 | return 0; |
152 | } else if ((new_addr + size) > address_space_end) { | |
26b1d1fd | 153 | error_setg(errp, "can't add memory device [0x%" PRIx64 ":0x%" PRIx64 |
bb0831bd DH |
154 | "] beyond 0x%" PRIx64, new_addr, size, |
155 | address_space_end); | |
156 | return 0; | |
157 | } | |
158 | } else { | |
159 | new_addr = address_space_start; | |
160 | } | |
161 | ||
162 | /* find address range that will fit new memory device */ | |
163 | object_child_foreach(OBJECT(ms), memory_device_build_list, &list); | |
164 | for (item = list; item; item = g_slist_next(item)) { | |
165 | const MemoryDeviceState *md = item->data; | |
166 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(OBJECT(md)); | |
167 | uint64_t md_size, md_addr; | |
168 | ||
169 | md_addr = mdc->get_addr(md); | |
946d6154 | 170 | md_size = memory_device_get_region_size(md, &error_abort); |
bb0831bd DH |
171 | |
172 | if (ranges_overlap(md_addr, md_size, new_addr, size)) { | |
173 | if (hint) { | |
174 | const DeviceState *d = DEVICE(md); | |
f99d84b1 DH |
175 | error_setg(errp, "address range conflicts with memory device" |
176 | " id='%s'", d->id ? d->id : "(unnamed)"); | |
bb0831bd DH |
177 | goto out; |
178 | } | |
179 | new_addr = QEMU_ALIGN_UP(md_addr + md_size, align); | |
180 | } | |
181 | } | |
182 | ||
183 | if (new_addr + size > address_space_end) { | |
184 | error_setg(errp, "could not find position in guest address space for " | |
185 | "memory device - memory fragmented due to alignments"); | |
186 | goto out; | |
187 | } | |
188 | out: | |
189 | g_slist_free(list); | |
190 | return new_addr; | |
191 | } | |
192 | ||
2cc0e2e8 DH |
193 | MemoryDeviceInfoList *qmp_memory_device_list(void) |
194 | { | |
195 | GSList *devices = NULL, *item; | |
196 | MemoryDeviceInfoList *list = NULL, *prev = NULL; | |
197 | ||
198 | object_child_foreach(qdev_get_machine(), memory_device_build_list, | |
199 | &devices); | |
200 | ||
201 | for (item = devices; item; item = g_slist_next(item)) { | |
202 | const MemoryDeviceState *md = MEMORY_DEVICE(item->data); | |
203 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data); | |
204 | MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1); | |
205 | MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1); | |
206 | ||
207 | mdc->fill_device_info(md, info); | |
208 | ||
209 | elem->value = info; | |
210 | elem->next = NULL; | |
211 | if (prev) { | |
212 | prev->next = elem; | |
213 | } else { | |
214 | list = elem; | |
215 | } | |
216 | prev = elem; | |
217 | } | |
218 | ||
219 | g_slist_free(devices); | |
220 | ||
221 | return list; | |
222 | } | |
223 | ||
224 | static int memory_device_plugged_size(Object *obj, void *opaque) | |
225 | { | |
226 | uint64_t *size = opaque; | |
227 | ||
228 | if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { | |
229 | const DeviceState *dev = DEVICE(obj); | |
230 | const MemoryDeviceState *md = MEMORY_DEVICE(obj); | |
231 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj); | |
232 | ||
233 | if (dev->realized) { | |
e40c5b6b | 234 | *size += mdc->get_plugged_size(md, &error_abort); |
2cc0e2e8 DH |
235 | } |
236 | } | |
237 | ||
238 | object_child_foreach(obj, memory_device_plugged_size, opaque); | |
239 | return 0; | |
240 | } | |
241 | ||
242 | uint64_t get_plugged_memory_size(void) | |
243 | { | |
244 | uint64_t size = 0; | |
245 | ||
246 | memory_device_plugged_size(qdev_get_machine(), &size); | |
247 | ||
248 | return size; | |
249 | } | |
250 | ||
6ef2c0f2 DH |
251 | void memory_device_pre_plug(MemoryDeviceState *md, MachineState *ms, |
252 | const uint64_t *legacy_align, Error **errp) | |
253 | { | |
254 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); | |
255 | Error *local_err = NULL; | |
256 | uint64_t addr, align; | |
257 | MemoryRegion *mr; | |
258 | ||
259 | mr = mdc->get_memory_region(md, &local_err); | |
260 | if (local_err) { | |
261 | goto out; | |
262 | } | |
263 | ||
264 | align = legacy_align ? *legacy_align : memory_region_get_alignment(mr); | |
265 | addr = mdc->get_addr(md); | |
266 | addr = memory_device_get_free_addr(ms, !addr ? NULL : &addr, align, | |
267 | memory_region_size(mr), &local_err); | |
268 | if (local_err) { | |
269 | goto out; | |
270 | } | |
271 | mdc->set_addr(md, addr, &local_err); | |
272 | out: | |
273 | error_propagate(errp, local_err); | |
274 | } | |
275 | ||
55d67a04 | 276 | void memory_device_plug(MemoryDeviceState *md, MachineState *ms) |
18d11dc9 | 277 | { |
55d67a04 DH |
278 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); |
279 | const uint64_t addr = mdc->get_addr(md); | |
280 | MemoryRegion *mr; | |
281 | ||
282 | /* | |
283 | * We expect that a previous call to memory_device_pre_plug() succeeded, so | |
284 | * it can't fail at this point. | |
285 | */ | |
286 | mr = mdc->get_memory_region(md, &error_abort); | |
18d11dc9 DH |
287 | g_assert(ms->device_memory); |
288 | ||
289 | memory_region_add_subregion(&ms->device_memory->mr, | |
290 | addr - ms->device_memory->base, mr); | |
291 | } | |
292 | ||
8288590d | 293 | void memory_device_unplug(MemoryDeviceState *md, MachineState *ms) |
18d11dc9 | 294 | { |
8288590d DH |
295 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); |
296 | MemoryRegion *mr; | |
297 | ||
298 | /* | |
299 | * We expect that a previous call to memory_device_pre_plug() succeeded, so | |
300 | * it can't fail at this point. | |
301 | */ | |
302 | mr = mdc->get_memory_region(md, &error_abort); | |
18d11dc9 DH |
303 | g_assert(ms->device_memory); |
304 | ||
305 | memory_region_del_subregion(&ms->device_memory->mr, mr); | |
306 | } | |
307 | ||
946d6154 DH |
308 | uint64_t memory_device_get_region_size(const MemoryDeviceState *md, |
309 | Error **errp) | |
310 | { | |
af390027 DH |
311 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); |
312 | MemoryRegion *mr; | |
946d6154 | 313 | |
af390027 DH |
314 | /* dropping const here is fine as we don't touch the memory region */ |
315 | mr = mdc->get_memory_region((MemoryDeviceState *)md, errp); | |
316 | if (!mr) { | |
317 | return 0; | |
318 | } | |
319 | ||
320 | return memory_region_size(mr); | |
946d6154 DH |
321 | } |
322 | ||
2cc0e2e8 DH |
323 | static const TypeInfo memory_device_info = { |
324 | .name = TYPE_MEMORY_DEVICE, | |
325 | .parent = TYPE_INTERFACE, | |
326 | .class_size = sizeof(MemoryDeviceClass), | |
327 | }; | |
328 | ||
329 | static void memory_device_register_types(void) | |
330 | { | |
331 | type_register_static(&memory_device_info); | |
332 | } | |
333 | ||
334 | type_init(memory_device_register_types) |