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