2 * Memory Device Interface
4 * Copyright ProfitBricks GmbH 2012
5 * Copyright (C) 2014 Red Hat Inc
6 * Copyright (c) 2018 Red Hat Inc
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.
12 #include "qemu/osdep.h"
13 #include "hw/mem/memory-device.h"
15 #include "qapi/error.h"
16 #include "hw/boards.h"
17 #include "qemu/range.h"
18 #include "hw/virtio/vhost.h"
19 #include "sysemu/kvm.h"
22 static gint
memory_device_addr_sort(gconstpointer a
, gconstpointer b
)
24 const MemoryDeviceState
*md_a
= MEMORY_DEVICE(a
);
25 const MemoryDeviceState
*md_b
= MEMORY_DEVICE(b
);
26 const MemoryDeviceClass
*mdc_a
= MEMORY_DEVICE_GET_CLASS(a
);
27 const MemoryDeviceClass
*mdc_b
= MEMORY_DEVICE_GET_CLASS(b
);
28 const uint64_t addr_a
= mdc_a
->get_addr(md_a
);
29 const uint64_t addr_b
= mdc_b
->get_addr(md_b
);
31 if (addr_a
> addr_b
) {
33 } else if (addr_a
< addr_b
) {
39 static int memory_device_build_list(Object
*obj
, void *opaque
)
41 GSList
**list
= opaque
;
43 if (object_dynamic_cast(obj
, TYPE_MEMORY_DEVICE
)) {
44 DeviceState
*dev
= DEVICE(obj
);
45 if (dev
->realized
) { /* only realized memory devices matter */
46 *list
= g_slist_insert_sorted(*list
, dev
, memory_device_addr_sort
);
50 object_child_foreach(obj
, memory_device_build_list
, opaque
);
54 static int memory_device_used_region_size(Object
*obj
, void *opaque
)
56 uint64_t *size
= opaque
;
58 if (object_dynamic_cast(obj
, TYPE_MEMORY_DEVICE
)) {
59 const DeviceState
*dev
= DEVICE(obj
);
60 const MemoryDeviceState
*md
= MEMORY_DEVICE(obj
);
63 *size
+= memory_device_get_region_size(md
, &error_abort
);
67 object_child_foreach(obj
, memory_device_used_region_size
, opaque
);
71 static void memory_device_check_addable(MachineState
*ms
, uint64_t size
,
74 uint64_t used_region_size
= 0;
76 /* we will need a new memory slot for kvm and vhost */
77 if (kvm_enabled() && !kvm_has_free_slot(ms
)) {
78 error_setg(errp
, "hypervisor has no free memory slots left");
81 if (!vhost_has_free_slot()) {
82 error_setg(errp
, "a used vhost backend has no free memory slots left");
86 /* will we exceed the total amount of memory specified */
87 memory_device_used_region_size(OBJECT(ms
), &used_region_size
);
88 if (used_region_size
+ size
< used_region_size
||
89 used_region_size
+ size
> ms
->maxram_size
- ms
->ram_size
) {
90 error_setg(errp
, "not enough space, currently 0x%" PRIx64
91 " in use of total space for memory devices 0x" RAM_ADDR_FMT
,
92 used_region_size
, ms
->maxram_size
- ms
->ram_size
);
98 static uint64_t memory_device_get_free_addr(MachineState
*ms
,
100 uint64_t align
, uint64_t size
,
103 GSList
*list
= NULL
, *item
;
104 Range as
, new = range_empty
;
106 if (!ms
->device_memory
) {
107 error_setg(errp
, "memory devices (e.g. for memory hotplug) are not "
108 "supported by the machine");
112 if (!memory_region_size(&ms
->device_memory
->mr
)) {
113 error_setg(errp
, "memory devices (e.g. for memory hotplug) are not "
114 "enabled, please specify the maxmem option");
117 range_init_nofail(&as
, ms
->device_memory
->base
,
118 memory_region_size(&ms
->device_memory
->mr
));
120 /* start of address space indicates the maximum alignment we expect */
121 if (!QEMU_IS_ALIGNED(range_lob(&as
), align
)) {
122 error_setg(errp
, "the alignment (0x%" PRIx64
") is not supported",
127 memory_device_check_addable(ms
, size
, errp
);
132 if (hint
&& !QEMU_IS_ALIGNED(*hint
, align
)) {
133 error_setg(errp
, "address must be aligned to 0x%" PRIx64
" bytes",
138 if (!QEMU_IS_ALIGNED(size
, align
)) {
139 error_setg(errp
, "backend memory size must be multiple of 0x%"
145 if (range_init(&new, *hint
, size
) || !range_contains_range(&as
, &new)) {
146 error_setg(errp
, "can't add memory device [0x%" PRIx64
":0x%" PRIx64
147 "], usable range for memory devices [0x%" PRIx64
":0x%"
148 PRIx64
"]", *hint
, size
, range_lob(&as
),
153 if (range_init(&new, range_lob(&as
), size
)) {
154 error_setg(errp
, "can't add memory device, device too big");
159 /* find address range that will fit new memory device */
160 object_child_foreach(OBJECT(ms
), memory_device_build_list
, &list
);
161 for (item
= list
; item
; item
= g_slist_next(item
)) {
162 const MemoryDeviceState
*md
= item
->data
;
163 const MemoryDeviceClass
*mdc
= MEMORY_DEVICE_GET_CLASS(OBJECT(md
));
167 range_init_nofail(&tmp
, mdc
->get_addr(md
),
168 memory_device_get_region_size(md
, &error_abort
));
170 if (range_overlaps_range(&tmp
, &new)) {
172 const DeviceState
*d
= DEVICE(md
);
173 error_setg(errp
, "address range conflicts with memory device"
174 " id='%s'", d
->id
? d
->id
: "(unnamed)");
178 next_addr
= QEMU_ALIGN_UP(range_upb(&tmp
) + 1, align
);
179 if (!next_addr
|| range_init(&new, next_addr
, range_size(&new))) {
180 range_make_empty(&new);
186 if (!range_contains_range(&as
, &new)) {
187 error_setg(errp
, "could not find position in guest address space for "
188 "memory device - memory fragmented due to alignments");
193 return range_lob(&new);
196 MemoryDeviceInfoList
*qmp_memory_device_list(void)
198 GSList
*devices
= NULL
, *item
;
199 MemoryDeviceInfoList
*list
= NULL
, *prev
= NULL
;
201 object_child_foreach(qdev_get_machine(), memory_device_build_list
,
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);
210 mdc
->fill_device_info(md
, info
);
222 g_slist_free(devices
);
227 static int memory_device_plugged_size(Object
*obj
, void *opaque
)
229 uint64_t *size
= opaque
;
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
);
237 *size
+= mdc
->get_plugged_size(md
, &error_abort
);
241 object_child_foreach(obj
, memory_device_plugged_size
, opaque
);
245 uint64_t get_plugged_memory_size(void)
249 memory_device_plugged_size(qdev_get_machine(), &size
);
254 void memory_device_pre_plug(MemoryDeviceState
*md
, MachineState
*ms
,
255 const uint64_t *legacy_align
, Error
**errp
)
257 const MemoryDeviceClass
*mdc
= MEMORY_DEVICE_GET_CLASS(md
);
258 Error
*local_err
= NULL
;
259 uint64_t addr
, align
;
262 mr
= mdc
->get_memory_region(md
, &local_err
);
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
);
274 mdc
->set_addr(md
, addr
, &local_err
);
276 trace_memory_device_pre_plug(DEVICE(md
)->id
? DEVICE(md
)->id
: "",
280 error_propagate(errp
, local_err
);
283 void memory_device_plug(MemoryDeviceState
*md
, MachineState
*ms
)
285 const MemoryDeviceClass
*mdc
= MEMORY_DEVICE_GET_CLASS(md
);
286 const uint64_t addr
= mdc
->get_addr(md
);
290 * We expect that a previous call to memory_device_pre_plug() succeeded, so
291 * it can't fail at this point.
293 mr
= mdc
->get_memory_region(md
, &error_abort
);
294 g_assert(ms
->device_memory
);
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
);
301 void memory_device_unplug(MemoryDeviceState
*md
, MachineState
*ms
)
303 const MemoryDeviceClass
*mdc
= MEMORY_DEVICE_GET_CLASS(md
);
307 * We expect that a previous call to memory_device_pre_plug() succeeded, so
308 * it can't fail at this point.
310 mr
= mdc
->get_memory_region(md
, &error_abort
);
311 g_assert(ms
->device_memory
);
313 memory_region_del_subregion(&ms
->device_memory
->mr
, mr
);
314 trace_memory_device_unplug(DEVICE(md
)->id
? DEVICE(md
)->id
: "",
318 uint64_t memory_device_get_region_size(const MemoryDeviceState
*md
,
321 const MemoryDeviceClass
*mdc
= MEMORY_DEVICE_GET_CLASS(md
);
324 /* dropping const here is fine as we don't touch the memory region */
325 mr
= mdc
->get_memory_region((MemoryDeviceState
*)md
, errp
);
330 return memory_region_size(mr
);
333 static const TypeInfo memory_device_info
= {
334 .name
= TYPE_MEMORY_DEVICE
,
335 .parent
= TYPE_INTERFACE
,
336 .class_size
= sizeof(MemoryDeviceClass
),
339 static void memory_device_register_types(void)
341 type_register_static(&memory_device_info
);
344 type_init(memory_device_register_types
)