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 "qemu/config-file.h" 17 #include "qom/object_interfaces.h" 18 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 27 static void 28 host_memory_backend_get_size(Object *obj, Visitor *v, void *opaque, 29 const char *name, Error **errp) 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 38 host_memory_backend_set_size(Object *obj, Visitor *v, void *opaque, 39 const char *name, Error **errp) 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 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 115 static int 116 host_memory_backend_get_policy(Object *obj, Error **errp G_GNUC_UNUSED) 117 { 118 HostMemoryBackend *backend = MEMORY_BACKEND(obj); 119 return backend->policy; 120 } 121 122 static void 123 host_memory_backend_set_policy(Object *obj, int policy, Error **errp) 124 { 125 HostMemoryBackend *backend = MEMORY_BACKEND(obj); 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 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 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 222 static void host_memory_backend_init(Object *obj) 223 { 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); 230 backend->prealloc = mem_prealloc; 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); 238 object_property_add_bool(obj, "prealloc", 239 host_memory_backend_get_prealloc, 240 host_memory_backend_set_prealloc, NULL); 241 object_property_add(obj, "size", "int", 242 host_memory_backend_get_size, 243 host_memory_backend_set_size, NULL, NULL, NULL); 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); 247 object_property_add_enum(obj, "policy", "HostMemPolicy", 248 HostMemPolicy_lookup, 249 host_memory_backend_get_policy, 250 host_memory_backend_set_policy, NULL); 251 } 252 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 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); 264 Error *local_err = NULL; 265 void *ptr; 266 uint64_t sz; 267 268 if (bc->alloc) { 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 } 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. */ 291 unsigned flags = MPOL_MF_STRICT | MPOL_MF_MOVE; 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 */ 325 if (backend->prealloc) { 326 os_mem_prealloc(memory_region_get_fd(&backend->mr), ptr, sz); 327 } 328 } 329 } 330 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 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; 350 ucc->can_be_deleted = host_memory_backend_can_be_deleted; 351 } 352 353 static const TypeInfo host_memory_backend_info = { 354 .name = TYPE_MEMORY_BACKEND, 355 .parent = TYPE_OBJECT, 356 .abstract = true, 357 .class_size = sizeof(HostMemoryBackendClass), 358 .class_init = host_memory_backend_class_init, 359 .instance_size = sizeof(HostMemoryBackend), 360 .instance_init = host_memory_backend_init, 361 .interfaces = (InterfaceInfo[]) { 362 { TYPE_USER_CREATABLE }, 363 { } 364 } 365 }; 366 367 static void register_types(void) 368 { 369 type_register_static(&host_memory_backend_info); 370 } 371 372 type_init(register_types); 373