]>
Commit | Line | Data |
---|---|---|
1f070489 IM |
1 | /* |
2 | * QEMU Host Memory Backend | |
3 | * | |
4 | * Copyright (C) 2013-2014 Red Hat Inc | |
5 | * | |
6 | * Authors: | |
7 | * Igor Mammedov <imammedo@redhat.com> | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
10 | * See the COPYING file in the top-level directory. | |
11 | */ | |
9c058332 | 12 | #include "qemu/osdep.h" |
1f070489 | 13 | #include "sysemu/hostmem.h" |
6b269967 | 14 | #include "hw/boards.h" |
da34e65c | 15 | #include "qapi/error.h" |
1f070489 | 16 | #include "qapi/visitor.h" |
4cf1b76b HT |
17 | #include "qapi-types.h" |
18 | #include "qapi-visit.h" | |
1f070489 IM |
19 | #include "qemu/config-file.h" |
20 | #include "qom/object_interfaces.h" | |
21 | ||
4cf1b76b HT |
22 | #ifdef CONFIG_NUMA |
23 | #include <numaif.h> | |
24 | QEMU_BUILD_BUG_ON(HOST_MEM_POLICY_DEFAULT != MPOL_DEFAULT); | |
25 | QEMU_BUILD_BUG_ON(HOST_MEM_POLICY_PREFERRED != MPOL_PREFERRED); | |
26 | QEMU_BUILD_BUG_ON(HOST_MEM_POLICY_BIND != MPOL_BIND); | |
27 | QEMU_BUILD_BUG_ON(HOST_MEM_POLICY_INTERLEAVE != MPOL_INTERLEAVE); | |
28 | #endif | |
29 | ||
1f070489 | 30 | static void |
d7bce999 EB |
31 | host_memory_backend_get_size(Object *obj, Visitor *v, const char *name, |
32 | void *opaque, Error **errp) | |
1f070489 IM |
33 | { |
34 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
35 | uint64_t value = backend->size; | |
36 | ||
51e72bc1 | 37 | visit_type_size(v, name, &value, errp); |
1f070489 IM |
38 | } |
39 | ||
40 | static void | |
d7bce999 EB |
41 | host_memory_backend_set_size(Object *obj, Visitor *v, const char *name, |
42 | void *opaque, Error **errp) | |
1f070489 IM |
43 | { |
44 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
45 | Error *local_err = NULL; | |
46 | uint64_t value; | |
47 | ||
48 | if (memory_region_size(&backend->mr)) { | |
49 | error_setg(&local_err, "cannot change property value"); | |
50 | goto out; | |
51 | } | |
52 | ||
51e72bc1 | 53 | visit_type_size(v, name, &value, &local_err); |
1f070489 IM |
54 | if (local_err) { |
55 | goto out; | |
56 | } | |
57 | if (!value) { | |
58 | error_setg(&local_err, "Property '%s.%s' doesn't take value '%" | |
59 | PRIu64 "'", object_get_typename(obj), name, value); | |
60 | goto out; | |
61 | } | |
62 | backend->size = value; | |
63 | out: | |
64 | error_propagate(errp, local_err); | |
65 | } | |
66 | ||
1454d33f XG |
67 | static uint16List **host_memory_append_node(uint16List **node, |
68 | unsigned long value) | |
69 | { | |
70 | *node = g_malloc0(sizeof(**node)); | |
71 | (*node)->value = value; | |
72 | return &(*node)->next; | |
73 | } | |
74 | ||
4cf1b76b | 75 | static void |
d7bce999 EB |
76 | host_memory_backend_get_host_nodes(Object *obj, Visitor *v, const char *name, |
77 | void *opaque, Error **errp) | |
4cf1b76b HT |
78 | { |
79 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
80 | uint16List *host_nodes = NULL; | |
81 | uint16List **node = &host_nodes; | |
82 | unsigned long value; | |
83 | ||
84 | value = find_first_bit(backend->host_nodes, MAX_NODES); | |
1454d33f XG |
85 | |
86 | node = host_memory_append_node(node, value); | |
87 | ||
4cf1b76b | 88 | if (value == MAX_NODES) { |
1454d33f | 89 | goto out; |
4cf1b76b HT |
90 | } |
91 | ||
4cf1b76b HT |
92 | do { |
93 | value = find_next_bit(backend->host_nodes, MAX_NODES, value + 1); | |
94 | if (value == MAX_NODES) { | |
95 | break; | |
96 | } | |
97 | ||
1454d33f | 98 | node = host_memory_append_node(node, value); |
4cf1b76b HT |
99 | } while (true); |
100 | ||
1454d33f | 101 | out: |
51e72bc1 | 102 | visit_type_uint16List(v, name, &host_nodes, errp); |
4cf1b76b HT |
103 | } |
104 | ||
105 | static void | |
d7bce999 EB |
106 | host_memory_backend_set_host_nodes(Object *obj, Visitor *v, const char *name, |
107 | void *opaque, Error **errp) | |
4cf1b76b HT |
108 | { |
109 | #ifdef CONFIG_NUMA | |
110 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
111 | uint16List *l = NULL; | |
112 | ||
51e72bc1 | 113 | visit_type_uint16List(v, name, &l, errp); |
4cf1b76b HT |
114 | |
115 | while (l) { | |
116 | bitmap_set(backend->host_nodes, l->value, 1); | |
117 | l = l->next; | |
118 | } | |
119 | #else | |
120 | error_setg(errp, "NUMA node binding are not supported by this QEMU"); | |
121 | #endif | |
122 | } | |
123 | ||
a3590dac DB |
124 | static int |
125 | host_memory_backend_get_policy(Object *obj, Error **errp G_GNUC_UNUSED) | |
4cf1b76b HT |
126 | { |
127 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
a3590dac | 128 | return backend->policy; |
4cf1b76b HT |
129 | } |
130 | ||
131 | static void | |
a3590dac | 132 | host_memory_backend_set_policy(Object *obj, int policy, Error **errp) |
4cf1b76b HT |
133 | { |
134 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
4cf1b76b HT |
135 | backend->policy = policy; |
136 | ||
137 | #ifndef CONFIG_NUMA | |
138 | if (policy != HOST_MEM_POLICY_DEFAULT) { | |
139 | error_setg(errp, "NUMA policies are not supported by this QEMU"); | |
140 | } | |
141 | #endif | |
142 | } | |
143 | ||
605d0a94 PB |
144 | static bool host_memory_backend_get_merge(Object *obj, Error **errp) |
145 | { | |
146 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
147 | ||
148 | return backend->merge; | |
149 | } | |
150 | ||
151 | static void host_memory_backend_set_merge(Object *obj, bool value, Error **errp) | |
152 | { | |
153 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
154 | ||
155 | if (!memory_region_size(&backend->mr)) { | |
156 | backend->merge = value; | |
157 | return; | |
158 | } | |
159 | ||
160 | if (value != backend->merge) { | |
161 | void *ptr = memory_region_get_ram_ptr(&backend->mr); | |
162 | uint64_t sz = memory_region_size(&backend->mr); | |
163 | ||
164 | qemu_madvise(ptr, sz, | |
165 | value ? QEMU_MADV_MERGEABLE : QEMU_MADV_UNMERGEABLE); | |
166 | backend->merge = value; | |
167 | } | |
168 | } | |
169 | ||
170 | static bool host_memory_backend_get_dump(Object *obj, Error **errp) | |
171 | { | |
172 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
173 | ||
174 | return backend->dump; | |
175 | } | |
176 | ||
177 | static void host_memory_backend_set_dump(Object *obj, bool value, Error **errp) | |
178 | { | |
179 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
180 | ||
181 | if (!memory_region_size(&backend->mr)) { | |
182 | backend->dump = value; | |
183 | return; | |
184 | } | |
185 | ||
186 | if (value != backend->dump) { | |
187 | void *ptr = memory_region_get_ram_ptr(&backend->mr); | |
188 | uint64_t sz = memory_region_size(&backend->mr); | |
189 | ||
190 | qemu_madvise(ptr, sz, | |
191 | value ? QEMU_MADV_DODUMP : QEMU_MADV_DONTDUMP); | |
192 | backend->dump = value; | |
193 | } | |
194 | } | |
195 | ||
a35ba7be PB |
196 | static bool host_memory_backend_get_prealloc(Object *obj, Error **errp) |
197 | { | |
198 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
199 | ||
200 | return backend->prealloc || backend->force_prealloc; | |
201 | } | |
202 | ||
203 | static void host_memory_backend_set_prealloc(Object *obj, bool value, | |
204 | Error **errp) | |
205 | { | |
206 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); | |
207 | ||
208 | if (backend->force_prealloc) { | |
209 | if (value) { | |
210 | error_setg(errp, | |
211 | "remove -mem-prealloc to use the prealloc property"); | |
212 | return; | |
213 | } | |
214 | } | |
215 | ||
216 | if (!memory_region_size(&backend->mr)) { | |
217 | backend->prealloc = value; | |
218 | return; | |
219 | } | |
220 | ||
221 | if (value && !backend->prealloc) { | |
222 | int fd = memory_region_get_fd(&backend->mr); | |
223 | void *ptr = memory_region_get_ram_ptr(&backend->mr); | |
224 | uint64_t sz = memory_region_size(&backend->mr); | |
225 | ||
226 | os_mem_prealloc(fd, ptr, sz); | |
227 | backend->prealloc = true; | |
228 | } | |
229 | } | |
230 | ||
58f4662c | 231 | static void host_memory_backend_init(Object *obj) |
1f070489 | 232 | { |
605d0a94 | 233 | HostMemoryBackend *backend = MEMORY_BACKEND(obj); |
6b269967 | 234 | MachineState *machine = MACHINE(qdev_get_machine()); |
605d0a94 | 235 | |
6b269967 EH |
236 | backend->merge = machine_mem_merge(machine); |
237 | backend->dump = machine_dump_guest_core(machine); | |
a35ba7be | 238 | backend->prealloc = mem_prealloc; |
605d0a94 PB |
239 | |
240 | object_property_add_bool(obj, "merge", | |
241 | host_memory_backend_get_merge, | |
242 | host_memory_backend_set_merge, NULL); | |
243 | object_property_add_bool(obj, "dump", | |
244 | host_memory_backend_get_dump, | |
245 | host_memory_backend_set_dump, NULL); | |
a35ba7be PB |
246 | object_property_add_bool(obj, "prealloc", |
247 | host_memory_backend_get_prealloc, | |
248 | host_memory_backend_set_prealloc, NULL); | |
1f070489 | 249 | object_property_add(obj, "size", "int", |
58f4662c HT |
250 | host_memory_backend_get_size, |
251 | host_memory_backend_set_size, NULL, NULL, NULL); | |
4cf1b76b HT |
252 | object_property_add(obj, "host-nodes", "int", |
253 | host_memory_backend_get_host_nodes, | |
254 | host_memory_backend_set_host_nodes, NULL, NULL, NULL); | |
a3590dac DB |
255 | object_property_add_enum(obj, "policy", "HostMemPolicy", |
256 | HostMemPolicy_lookup, | |
257 | host_memory_backend_get_policy, | |
258 | host_memory_backend_set_policy, NULL); | |
1f070489 IM |
259 | } |
260 | ||
1f070489 IM |
261 | MemoryRegion * |
262 | host_memory_backend_get_memory(HostMemoryBackend *backend, Error **errp) | |
263 | { | |
264 | return memory_region_size(&backend->mr) ? &backend->mr : NULL; | |
265 | } | |
266 | ||
bd9262d9 HT |
267 | static void |
268 | host_memory_backend_memory_complete(UserCreatable *uc, Error **errp) | |
269 | { | |
270 | HostMemoryBackend *backend = MEMORY_BACKEND(uc); | |
271 | HostMemoryBackendClass *bc = MEMORY_BACKEND_GET_CLASS(uc); | |
605d0a94 PB |
272 | Error *local_err = NULL; |
273 | void *ptr; | |
274 | uint64_t sz; | |
bd9262d9 HT |
275 | |
276 | if (bc->alloc) { | |
605d0a94 PB |
277 | bc->alloc(backend, &local_err); |
278 | if (local_err) { | |
279 | error_propagate(errp, local_err); | |
280 | return; | |
281 | } | |
282 | ||
283 | ptr = memory_region_get_ram_ptr(&backend->mr); | |
284 | sz = memory_region_size(&backend->mr); | |
285 | ||
286 | if (backend->merge) { | |
287 | qemu_madvise(ptr, sz, QEMU_MADV_MERGEABLE); | |
288 | } | |
289 | if (!backend->dump) { | |
290 | qemu_madvise(ptr, sz, QEMU_MADV_DONTDUMP); | |
291 | } | |
4cf1b76b HT |
292 | #ifdef CONFIG_NUMA |
293 | unsigned long lastbit = find_last_bit(backend->host_nodes, MAX_NODES); | |
294 | /* lastbit == MAX_NODES means maxnode = 0 */ | |
295 | unsigned long maxnode = (lastbit + 1) % (MAX_NODES + 1); | |
296 | /* ensure policy won't be ignored in case memory is preallocated | |
297 | * before mbind(). note: MPOL_MF_STRICT is ignored on hugepages so | |
298 | * this doesn't catch hugepage case. */ | |
288d3322 | 299 | unsigned flags = MPOL_MF_STRICT | MPOL_MF_MOVE; |
4cf1b76b HT |
300 | |
301 | /* check for invalid host-nodes and policies and give more verbose | |
302 | * error messages than mbind(). */ | |
303 | if (maxnode && backend->policy == MPOL_DEFAULT) { | |
304 | error_setg(errp, "host-nodes must be empty for policy default," | |
305 | " or you should explicitly specify a policy other" | |
306 | " than default"); | |
307 | return; | |
308 | } else if (maxnode == 0 && backend->policy != MPOL_DEFAULT) { | |
309 | error_setg(errp, "host-nodes must be set for policy %s", | |
310 | HostMemPolicy_lookup[backend->policy]); | |
311 | return; | |
312 | } | |
313 | ||
314 | /* We can have up to MAX_NODES nodes, but we need to pass maxnode+1 | |
315 | * as argument to mbind() due to an old Linux bug (feature?) which | |
316 | * cuts off the last specified node. This means backend->host_nodes | |
317 | * must have MAX_NODES+1 bits available. | |
318 | */ | |
319 | assert(sizeof(backend->host_nodes) >= | |
320 | BITS_TO_LONGS(MAX_NODES + 1) * sizeof(unsigned long)); | |
321 | assert(maxnode <= MAX_NODES); | |
322 | if (mbind(ptr, sz, backend->policy, | |
323 | maxnode ? backend->host_nodes : NULL, maxnode + 1, flags)) { | |
a3567ba1 PF |
324 | if (backend->policy != MPOL_DEFAULT || errno != ENOSYS) { |
325 | error_setg_errno(errp, errno, | |
326 | "cannot bind memory to host NUMA nodes"); | |
327 | return; | |
328 | } | |
4cf1b76b HT |
329 | } |
330 | #endif | |
331 | /* Preallocate memory after the NUMA policy has been instantiated. | |
332 | * This is necessary to guarantee memory is allocated with | |
333 | * specified NUMA policy in place. | |
334 | */ | |
a35ba7be PB |
335 | if (backend->prealloc) { |
336 | os_mem_prealloc(memory_region_get_fd(&backend->mr), ptr, sz); | |
337 | } | |
bd9262d9 HT |
338 | } |
339 | } | |
340 | ||
36bce5ca LM |
341 | static bool |
342 | host_memory_backend_can_be_deleted(UserCreatable *uc, Error **errp) | |
343 | { | |
344 | MemoryRegion *mr; | |
345 | ||
346 | mr = host_memory_backend_get_memory(MEMORY_BACKEND(uc), errp); | |
347 | if (memory_region_is_mapped(mr)) { | |
348 | return false; | |
349 | } else { | |
350 | return true; | |
351 | } | |
352 | } | |
353 | ||
bd9262d9 HT |
354 | static void |
355 | host_memory_backend_class_init(ObjectClass *oc, void *data) | |
356 | { | |
357 | UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc); | |
358 | ||
359 | ucc->complete = host_memory_backend_memory_complete; | |
36bce5ca | 360 | ucc->can_be_deleted = host_memory_backend_can_be_deleted; |
bd9262d9 HT |
361 | } |
362 | ||
58f4662c | 363 | static const TypeInfo host_memory_backend_info = { |
1f070489 IM |
364 | .name = TYPE_MEMORY_BACKEND, |
365 | .parent = TYPE_OBJECT, | |
366 | .abstract = true, | |
367 | .class_size = sizeof(HostMemoryBackendClass), | |
bd9262d9 | 368 | .class_init = host_memory_backend_class_init, |
1f070489 | 369 | .instance_size = sizeof(HostMemoryBackend), |
58f4662c | 370 | .instance_init = host_memory_backend_init, |
1f070489 IM |
371 | .interfaces = (InterfaceInfo[]) { |
372 | { TYPE_USER_CREATABLE }, | |
373 | { } | |
374 | } | |
375 | }; | |
376 | ||
377 | static void register_types(void) | |
378 | { | |
58f4662c | 379 | type_register_static(&host_memory_backend_info); |
1f070489 IM |
380 | } |
381 | ||
382 | type_init(register_types); |