]>
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 | ||
bb0831bd DH |
96 | uint64_t memory_device_get_free_addr(MachineState *ms, const uint64_t *hint, |
97 | uint64_t align, uint64_t size, | |
98 | Error **errp) | |
99 | { | |
100 | uint64_t address_space_start, address_space_end; | |
101 | GSList *list = NULL, *item; | |
102 | uint64_t new_addr = 0; | |
103 | ||
104 | if (!ms->device_memory) { | |
105 | error_setg(errp, "memory devices (e.g. for memory hotplug) are not " | |
106 | "supported by the machine"); | |
107 | return 0; | |
108 | } | |
109 | ||
110 | if (!memory_region_size(&ms->device_memory->mr)) { | |
111 | error_setg(errp, "memory devices (e.g. for memory hotplug) are not " | |
112 | "enabled, please specify the maxmem option"); | |
113 | return 0; | |
114 | } | |
115 | address_space_start = ms->device_memory->base; | |
116 | address_space_end = address_space_start + | |
117 | memory_region_size(&ms->device_memory->mr); | |
bb0831bd DH |
118 | g_assert(address_space_end >= address_space_start); |
119 | ||
4d8938a0 DH |
120 | /* address_space_start indicates the maximum alignment we expect */ |
121 | if (QEMU_ALIGN_UP(address_space_start, align) != address_space_start) { | |
7c63ba20 | 122 | error_setg(errp, "the alignment (0x%" PRIx64 ") is not supported", |
4d8938a0 DH |
123 | align); |
124 | return 0; | |
125 | } | |
126 | ||
1b6d6af2 DH |
127 | memory_device_check_addable(ms, size, errp); |
128 | if (*errp) { | |
129 | return 0; | |
130 | } | |
131 | ||
bb0831bd DH |
132 | if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) { |
133 | error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes", | |
134 | align); | |
135 | return 0; | |
136 | } | |
137 | ||
138 | if (QEMU_ALIGN_UP(size, align) != size) { | |
139 | error_setg(errp, "backend memory size must be multiple of 0x%" | |
140 | PRIx64, align); | |
141 | return 0; | |
142 | } | |
143 | ||
144 | if (hint) { | |
145 | new_addr = *hint; | |
146 | if (new_addr < address_space_start) { | |
26b1d1fd | 147 | error_setg(errp, "can't add memory device [0x%" PRIx64 ":0x%" PRIx64 |
ac1b3375 DH |
148 | "] before 0x%" PRIx64, new_addr, size, |
149 | address_space_start); | |
bb0831bd DH |
150 | return 0; |
151 | } else if ((new_addr + size) > address_space_end) { | |
26b1d1fd | 152 | error_setg(errp, "can't add memory device [0x%" PRIx64 ":0x%" PRIx64 |
bb0831bd DH |
153 | "] beyond 0x%" PRIx64, new_addr, size, |
154 | address_space_end); | |
155 | return 0; | |
156 | } | |
157 | } else { | |
158 | new_addr = address_space_start; | |
159 | } | |
160 | ||
161 | /* find address range that will fit new memory device */ | |
162 | object_child_foreach(OBJECT(ms), memory_device_build_list, &list); | |
163 | for (item = list; item; item = g_slist_next(item)) { | |
164 | const MemoryDeviceState *md = item->data; | |
165 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(OBJECT(md)); | |
166 | uint64_t md_size, md_addr; | |
167 | ||
168 | md_addr = mdc->get_addr(md); | |
946d6154 | 169 | md_size = memory_device_get_region_size(md, &error_abort); |
bb0831bd DH |
170 | |
171 | if (ranges_overlap(md_addr, md_size, new_addr, size)) { | |
172 | if (hint) { | |
173 | const DeviceState *d = DEVICE(md); | |
f99d84b1 DH |
174 | error_setg(errp, "address range conflicts with memory device" |
175 | " id='%s'", d->id ? d->id : "(unnamed)"); | |
bb0831bd DH |
176 | goto out; |
177 | } | |
178 | new_addr = QEMU_ALIGN_UP(md_addr + md_size, align); | |
179 | } | |
180 | } | |
181 | ||
182 | if (new_addr + size > address_space_end) { | |
183 | error_setg(errp, "could not find position in guest address space for " | |
184 | "memory device - memory fragmented due to alignments"); | |
185 | goto out; | |
186 | } | |
187 | out: | |
188 | g_slist_free(list); | |
189 | return new_addr; | |
190 | } | |
191 | ||
2cc0e2e8 DH |
192 | MemoryDeviceInfoList *qmp_memory_device_list(void) |
193 | { | |
194 | GSList *devices = NULL, *item; | |
195 | MemoryDeviceInfoList *list = NULL, *prev = NULL; | |
196 | ||
197 | object_child_foreach(qdev_get_machine(), memory_device_build_list, | |
198 | &devices); | |
199 | ||
200 | for (item = devices; item; item = g_slist_next(item)) { | |
201 | const MemoryDeviceState *md = MEMORY_DEVICE(item->data); | |
202 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data); | |
203 | MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1); | |
204 | MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1); | |
205 | ||
206 | mdc->fill_device_info(md, info); | |
207 | ||
208 | elem->value = info; | |
209 | elem->next = NULL; | |
210 | if (prev) { | |
211 | prev->next = elem; | |
212 | } else { | |
213 | list = elem; | |
214 | } | |
215 | prev = elem; | |
216 | } | |
217 | ||
218 | g_slist_free(devices); | |
219 | ||
220 | return list; | |
221 | } | |
222 | ||
223 | static int memory_device_plugged_size(Object *obj, void *opaque) | |
224 | { | |
225 | uint64_t *size = opaque; | |
226 | ||
227 | if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { | |
228 | const DeviceState *dev = DEVICE(obj); | |
229 | const MemoryDeviceState *md = MEMORY_DEVICE(obj); | |
230 | const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj); | |
231 | ||
232 | if (dev->realized) { | |
e40c5b6b | 233 | *size += mdc->get_plugged_size(md, &error_abort); |
2cc0e2e8 DH |
234 | } |
235 | } | |
236 | ||
237 | object_child_foreach(obj, memory_device_plugged_size, opaque); | |
238 | return 0; | |
239 | } | |
240 | ||
241 | uint64_t get_plugged_memory_size(void) | |
242 | { | |
243 | uint64_t size = 0; | |
244 | ||
245 | memory_device_plugged_size(qdev_get_machine(), &size); | |
246 | ||
247 | return size; | |
248 | } | |
249 | ||
18d11dc9 DH |
250 | void memory_device_plug_region(MachineState *ms, MemoryRegion *mr, |
251 | uint64_t addr) | |
252 | { | |
253 | /* we expect a previous call to memory_device_get_free_addr() */ | |
254 | g_assert(ms->device_memory); | |
255 | ||
256 | memory_region_add_subregion(&ms->device_memory->mr, | |
257 | addr - ms->device_memory->base, mr); | |
258 | } | |
259 | ||
260 | void memory_device_unplug_region(MachineState *ms, MemoryRegion *mr) | |
261 | { | |
262 | /* we expect a previous call to memory_device_get_free_addr() */ | |
263 | g_assert(ms->device_memory); | |
264 | ||
265 | memory_region_del_subregion(&ms->device_memory->mr, mr); | |
266 | } | |
267 | ||
946d6154 DH |
268 | uint64_t memory_device_get_region_size(const MemoryDeviceState *md, |
269 | Error **errp) | |
270 | { | |
271 | MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); | |
272 | ||
273 | return mdc->get_region_size(md, errp); | |
274 | } | |
275 | ||
2cc0e2e8 DH |
276 | static const TypeInfo memory_device_info = { |
277 | .name = TYPE_MEMORY_DEVICE, | |
278 | .parent = TYPE_INTERFACE, | |
279 | .class_size = sizeof(MemoryDeviceClass), | |
280 | }; | |
281 | ||
282 | static void memory_device_register_types(void) | |
283 | { | |
284 | type_register_static(&memory_device_info); | |
285 | } | |
286 | ||
287 | type_init(memory_device_register_types) |