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