1
2
3
4
5
6
7
8
9
10
11
12#include "qemu/osdep.h"
13#include "hw/mem/memory-device.h"
14#include "qapi/error.h"
15#include "hw/boards.h"
16#include "qemu/range.h"
17#include "hw/virtio/vhost.h"
18#include "sysemu/kvm.h"
19#include "trace.h"
20
21static 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
38static 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) {
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
53static 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);
60
61 if (dev->realized) {
62 *size += memory_device_get_region_size(md, &error_abort);
63 }
64 }
65
66 object_child_foreach(obj, memory_device_used_region_size, opaque);
67 return 0;
68}
69
70static void memory_device_check_addable(MachineState *ms, uint64_t size,
71 Error **errp)
72{
73 uint64_t used_region_size = 0;
74
75
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
86 memory_device_used_region_size(OBJECT(ms), &used_region_size);
87 if (used_region_size + size < used_region_size ||
88 used_region_size + size > ms->maxram_size - ms->ram_size) {
89 error_setg(errp, "not enough space, currently 0x%" PRIx64
90 " in use of total space for memory devices 0x" RAM_ADDR_FMT,
91 used_region_size, ms->maxram_size - ms->ram_size);
92 return;
93 }
94
95}
96
97static uint64_t memory_device_get_free_addr(MachineState *ms,
98 const uint64_t *hint,
99 uint64_t align, uint64_t size,
100 Error **errp)
101{
102 GSList *list = NULL, *item;
103 Range as, new = range_empty;
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 range_init_nofail(&as, ms->device_memory->base,
117 memory_region_size(&ms->device_memory->mr));
118
119
120 if (!QEMU_IS_ALIGNED(range_lob(&as), align)) {
121 error_setg(errp, "the alignment (0x%" PRIx64 ") is not supported",
122 align);
123 return 0;
124 }
125
126 memory_device_check_addable(ms, size, errp);
127 if (*errp) {
128 return 0;
129 }
130
131 if (hint && !QEMU_IS_ALIGNED(*hint, align)) {
132 error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes",
133 align);
134 return 0;
135 }
136
137 if (!QEMU_IS_ALIGNED(size, align)) {
138 error_setg(errp, "backend memory size must be multiple of 0x%"
139 PRIx64, align);
140 return 0;
141 }
142
143 if (hint) {
144 if (range_init(&new, *hint, size) || !range_contains_range(&as, &new)) {
145 error_setg(errp, "can't add memory device [0x%" PRIx64 ":0x%" PRIx64
146 "], usable range for memory devices [0x%" PRIx64 ":0x%"
147 PRIx64 "]", *hint, size, range_lob(&as),
148 range_size(&as));
149 return 0;
150 }
151 } else {
152 if (range_init(&new, range_lob(&as), size)) {
153 error_setg(errp, "can't add memory device, device too big");
154 return 0;
155 }
156 }
157
158
159 object_child_foreach(OBJECT(ms), memory_device_build_list, &list);
160 for (item = list; item; item = g_slist_next(item)) {
161 const MemoryDeviceState *md = item->data;
162 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(OBJECT(md));
163 uint64_t next_addr;
164 Range tmp;
165
166 range_init_nofail(&tmp, mdc->get_addr(md),
167 memory_device_get_region_size(md, &error_abort));
168
169 if (range_overlaps_range(&tmp, &new)) {
170 if (hint) {
171 const DeviceState *d = DEVICE(md);
172 error_setg(errp, "address range conflicts with memory device"
173 " id='%s'", d->id ? d->id : "(unnamed)");
174 goto out;
175 }
176
177 next_addr = QEMU_ALIGN_UP(range_upb(&tmp) + 1, align);
178 if (!next_addr || range_init(&new, next_addr, range_size(&new))) {
179 range_make_empty(&new);
180 break;
181 }
182 } else if (range_lob(&tmp) > range_upb(&new)) {
183 break;
184 }
185 }
186
187 if (!range_contains_range(&as, &new)) {
188 error_setg(errp, "could not find position in guest address space for "
189 "memory device - memory fragmented due to alignments");
190 }
191out:
192 g_slist_free(list);
193 return range_lob(&new);
194}
195
196MemoryDeviceInfoList *qmp_memory_device_list(void)
197{
198 GSList *devices = NULL, *item;
199 MemoryDeviceInfoList *list = NULL, *prev = NULL;
200
201 object_child_foreach(qdev_get_machine(), memory_device_build_list,
202 &devices);
203
204 for (item = devices; item; item = g_slist_next(item)) {
205 const MemoryDeviceState *md = MEMORY_DEVICE(item->data);
206 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data);
207 MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);
208 MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);
209
210 mdc->fill_device_info(md, info);
211
212 elem->value = info;
213 elem->next = NULL;
214 if (prev) {
215 prev->next = elem;
216 } else {
217 list = elem;
218 }
219 prev = elem;
220 }
221
222 g_slist_free(devices);
223
224 return list;
225}
226
227static int memory_device_plugged_size(Object *obj, void *opaque)
228{
229 uint64_t *size = opaque;
230
231 if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {
232 const DeviceState *dev = DEVICE(obj);
233 const MemoryDeviceState *md = MEMORY_DEVICE(obj);
234 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj);
235
236 if (dev->realized) {
237 *size += mdc->get_plugged_size(md, &error_abort);
238 }
239 }
240
241 object_child_foreach(obj, memory_device_plugged_size, opaque);
242 return 0;
243}
244
245uint64_t get_plugged_memory_size(void)
246{
247 uint64_t size = 0;
248
249 memory_device_plugged_size(qdev_get_machine(), &size);
250
251 return size;
252}
253
254void memory_device_pre_plug(MemoryDeviceState *md, MachineState *ms,
255 const uint64_t *legacy_align, Error **errp)
256{
257 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md);
258 Error *local_err = NULL;
259 uint64_t addr, align;
260 MemoryRegion *mr;
261
262 mr = mdc->get_memory_region(md, &local_err);
263 if (local_err) {
264 goto out;
265 }
266
267 align = legacy_align ? *legacy_align : memory_region_get_alignment(mr);
268 addr = mdc->get_addr(md);
269 addr = memory_device_get_free_addr(ms, !addr ? NULL : &addr, align,
270 memory_region_size(mr), &local_err);
271 if (local_err) {
272 goto out;
273 }
274 mdc->set_addr(md, addr, &local_err);
275 if (!local_err) {
276 trace_memory_device_pre_plug(DEVICE(md)->id ? DEVICE(md)->id : "",
277 addr);
278 }
279out:
280 error_propagate(errp, local_err);
281}
282
283void memory_device_plug(MemoryDeviceState *md, MachineState *ms)
284{
285 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md);
286 const uint64_t addr = mdc->get_addr(md);
287 MemoryRegion *mr;
288
289
290
291
292
293 mr = mdc->get_memory_region(md, &error_abort);
294 g_assert(ms->device_memory);
295
296 memory_region_add_subregion(&ms->device_memory->mr,
297 addr - ms->device_memory->base, mr);
298 trace_memory_device_plug(DEVICE(md)->id ? DEVICE(md)->id : "", addr);
299}
300
301void memory_device_unplug(MemoryDeviceState *md, MachineState *ms)
302{
303 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md);
304 MemoryRegion *mr;
305
306
307
308
309
310 mr = mdc->get_memory_region(md, &error_abort);
311 g_assert(ms->device_memory);
312
313 memory_region_del_subregion(&ms->device_memory->mr, mr);
314 trace_memory_device_unplug(DEVICE(md)->id ? DEVICE(md)->id : "",
315 mdc->get_addr(md));
316}
317
318uint64_t memory_device_get_region_size(const MemoryDeviceState *md,
319 Error **errp)
320{
321 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md);
322 MemoryRegion *mr;
323
324
325 mr = mdc->get_memory_region((MemoryDeviceState *)md, errp);
326 if (!mr) {
327 return 0;
328 }
329
330 return memory_region_size(mr);
331}
332
333static const TypeInfo memory_device_info = {
334 .name = TYPE_MEMORY_DEVICE,
335 .parent = TYPE_INTERFACE,
336 .class_size = sizeof(MemoryDeviceClass),
337};
338
339static void memory_device_register_types(void)
340{
341 type_register_static(&memory_device_info);
342}
343
344type_init(memory_device_register_types)
345