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