backends/hostmem.c

   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 static void host_memory_backend_finalize(Object *obj)
 261 {
 262     HostMemoryBackend *backend = MEMORY_BACKEND(obj);
 263
 264     if (memory_region_size(&backend->mr)) {
 265         memory_region_destroy(&backend->mr);
 266     }
 267 }
 268
 269 MemoryRegion *
 270 host_memory_backend_get_memory(HostMemoryBackend *backend, Error **errp)
 271 {
 272     return memory_region_size(&backend->mr) ? &backend->mr : NULL;
 273 }
 274
 275 static void
 276 host_memory_backend_memory_complete(UserCreatable *uc, Error **errp)
 277 {
 278     HostMemoryBackend *backend = MEMORY_BACKEND(uc);
 279     HostMemoryBackendClass *bc = MEMORY_BACKEND_GET_CLASS(uc);
 280     Error *local_err = NULL;
 281     void *ptr;
 282     uint64_t sz;
 283
 284     if (bc->alloc) {
 285         bc->alloc(backend, &local_err);
 286         if (local_err) {
 287             error_propagate(errp, local_err);
 288             return;
 289         }
 290
 291         ptr = memory_region_get_ram_ptr(&backend->mr);
 292         sz = memory_region_size(&backend->mr);
 293
 294         if (backend->merge) {
 295             qemu_madvise(ptr, sz, QEMU_MADV_MERGEABLE);
 296         }
 297         if (!backend->dump) {
 298             qemu_madvise(ptr, sz, QEMU_MADV_DONTDUMP);
 299         }
 300 #ifdef CONFIG_NUMA
 301         unsigned long lastbit = find_last_bit(backend->host_nodes, MAX_NODES);
 302         /* lastbit == MAX_NODES means maxnode = 0 */
 303         unsigned long maxnode = (lastbit + 1) % (MAX_NODES + 1);
 304         /* ensure policy won't be ignored in case memory is preallocated
 305          * before mbind(). note: MPOL_MF_STRICT is ignored on hugepages so
 306          * this doesn't catch hugepage case. */
 307         unsigned flags = MPOL_MF_STRICT;
 308
 309         /* check for invalid host-nodes and policies and give more verbose
 310          * error messages than mbind(). */
 311         if (maxnode && backend->policy == MPOL_DEFAULT) {
 312             error_setg(errp, "host-nodes must be empty for policy default,"
 313                        " or you should explicitly specify a policy other"
 314                        " than default");
 315             return;
 316         } else if (maxnode == 0 && backend->policy != MPOL_DEFAULT) {
 317             error_setg(errp, "host-nodes must be set for policy %s",
 318                        HostMemPolicy_lookup[backend->policy]);
 319             return;
 320         }
 321
 322         /* We can have up to MAX_NODES nodes, but we need to pass maxnode+1
 323          * as argument to mbind() due to an old Linux bug (feature?) which
 324          * cuts off the last specified node. This means backend->host_nodes
 325          * must have MAX_NODES+1 bits available.
 326          */
 327         assert(sizeof(backend->host_nodes) >=
 328                BITS_TO_LONGS(MAX_NODES + 1) * sizeof(unsigned long));
 329         assert(maxnode <= MAX_NODES);
 330         if (mbind(ptr, sz, backend->policy,
 331                   maxnode ? backend->host_nodes : NULL, maxnode + 1, flags)) {
 332             error_setg_errno(errp, errno,
 333                              "cannot bind memory to host NUMA nodes");
 334             return;
 335         }
 336 #endif
 337         /* Preallocate memory after the NUMA policy has been instantiated.
 338          * This is necessary to guarantee memory is allocated with
 339          * specified NUMA policy in place.
 340          */
 341         if (backend->prealloc) {
 342             os_mem_prealloc(memory_region_get_fd(&backend->mr), ptr, sz);
 343         }
 344     }
 345 }
 346
 347 static void
 348 host_memory_backend_class_init(ObjectClass *oc, void *data)
 349 {
 350     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 351
 352     ucc->complete = host_memory_backend_memory_complete;
 353 }
 354
 355 static const TypeInfo host_memory_backend_info = {
 356     .name = TYPE_MEMORY_BACKEND,
 357     .parent = TYPE_OBJECT,
 358     .abstract = true,
 359     .class_size = sizeof(HostMemoryBackendClass),
 360     .class_init = host_memory_backend_class_init,
 361     .instance_size = sizeof(HostMemoryBackend),
 362     .instance_init = host_memory_backend_init,
 363     .instance_finalize = host_memory_backend_finalize,
 364     .interfaces = (InterfaceInfo[]) {
 365         { TYPE_USER_CREATABLE },
 366         { }
 367     }
 368 };
 369
 370 static void register_types(void)
 371 {
 372     type_register_static(&host_memory_backend_info);
 373 }
 374
 375 type_init(register_types);