backends/hostmem-memfd.c

   1 /*
   2  * QEMU host memfd memory backend
   3  *
   4  * Copyright (C) 2018 Red Hat Inc
   5  *
   6  * Authors:
   7  *   Marc-André Lureau <marcandre.lureau@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
  13 #include "qemu/osdep.h"
  14 #include "sysemu/hostmem.h"
  15 #include "sysemu/sysemu.h"
  16 #include "qom/object_interfaces.h"
  17 #include "qemu/memfd.h"
  18 #include "qemu/module.h"
  19 #include "qapi/error.h"
  20
  21 #define TYPE_MEMORY_BACKEND_MEMFD "memory-backend-memfd"
  22
  23 #define MEMORY_BACKEND_MEMFD(obj)                                        \
  24     OBJECT_CHECK(HostMemoryBackendMemfd, (obj), TYPE_MEMORY_BACKEND_MEMFD)
  25
  26 typedef struct HostMemoryBackendMemfd HostMemoryBackendMemfd;
  27
  28 struct HostMemoryBackendMemfd {
  29     HostMemoryBackend parent_obj;
  30
  31     bool hugetlb;
  32     uint64_t hugetlbsize;
  33     bool seal;
  34 };
  35
  36 static void
  37 memfd_backend_memory_alloc(HostMemoryBackend *backend, Error **errp)
  38 {
  39     HostMemoryBackendMemfd *m = MEMORY_BACKEND_MEMFD(backend);
  40     char *name;
  41     int fd;
  42
  43     if (!backend->size) {
  44         error_setg(errp, "can't create backend with size 0");
  45         return;
  46     }
  47
  48     backend->force_prealloc = mem_prealloc;
  49     fd = qemu_memfd_create(TYPE_MEMORY_BACKEND_MEMFD, backend->size,
  50                            m->hugetlb, m->hugetlbsize, m->seal ?
  51                            F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL : 0,
  52                            errp);
  53     if (fd == -1) {
  54         return;
  55     }
  56
  57     name = host_memory_backend_get_name(backend);
  58     memory_region_init_ram_from_fd(&backend->mr, OBJECT(backend),
  59                                    name, backend->size,
  60                                    backend->share, fd, errp);
  61     g_free(name);
  62 }
  63
  64 static bool
  65 memfd_backend_get_hugetlb(Object *o, Error **errp)
  66 {
  67     return MEMORY_BACKEND_MEMFD(o)->hugetlb;
  68 }
  69
  70 static void
  71 memfd_backend_set_hugetlb(Object *o, bool value, Error **errp)
  72 {
  73     MEMORY_BACKEND_MEMFD(o)->hugetlb = value;
  74 }
  75
  76 static void
  77 memfd_backend_set_hugetlbsize(Object *obj, Visitor *v, const char *name,
  78                               void *opaque, Error **errp)
  79 {
  80     HostMemoryBackendMemfd *m = MEMORY_BACKEND_MEMFD(obj);
  81     Error *local_err = NULL;
  82     uint64_t value;
  83
  84     if (host_memory_backend_mr_inited(MEMORY_BACKEND(obj))) {
  85         error_setg(&local_err, "cannot change property value");
  86         goto out;
  87     }
  88
  89     visit_type_size(v, name, &value, &local_err);
  90     if (local_err) {
  91         goto out;
  92     }
  93     if (!value) {
  94         error_setg(&local_err, "Property '%s.%s' doesn't take value '%"
  95                    PRIu64 "'", object_get_typename(obj), name, value);
  96         goto out;
  97     }
  98     m->hugetlbsize = value;
  99 out:
 100     error_propagate(errp, local_err);
 101 }
 102
 103 static void
 104 memfd_backend_get_hugetlbsize(Object *obj, Visitor *v, const char *name,
 105                               void *opaque, Error **errp)
 106 {
 107     HostMemoryBackendMemfd *m = MEMORY_BACKEND_MEMFD(obj);
 108     uint64_t value = m->hugetlbsize;
 109
 110     visit_type_size(v, name, &value, errp);
 111 }
 112
 113 static bool
 114 memfd_backend_get_seal(Object *o, Error **errp)
 115 {
 116     return MEMORY_BACKEND_MEMFD(o)->seal;
 117 }
 118
 119 static void
 120 memfd_backend_set_seal(Object *o, bool value, Error **errp)
 121 {
 122     MEMORY_BACKEND_MEMFD(o)->seal = value;
 123 }
 124
 125 static void
 126 memfd_backend_instance_init(Object *obj)
 127 {
 128     HostMemoryBackendMemfd *m = MEMORY_BACKEND_MEMFD(obj);
 129
 130     /* default to sealed file */
 131     m->seal = true;
 132     MEMORY_BACKEND(m)->share = true;
 133 }
 134
 135 static void
 136 memfd_backend_class_init(ObjectClass *oc, void *data)
 137 {
 138     HostMemoryBackendClass *bc = MEMORY_BACKEND_CLASS(oc);
 139
 140     bc->alloc = memfd_backend_memory_alloc;
 141
 142     if (qemu_memfd_check(MFD_HUGETLB)) {
 143         object_class_property_add_bool(oc, "hugetlb",
 144                                        memfd_backend_get_hugetlb,
 145                                        memfd_backend_set_hugetlb,
 146                                        &error_abort);
 147         object_class_property_set_description(oc, "hugetlb",
 148                                               "Use huge pages",
 149                                               &error_abort);
 150         object_class_property_add(oc, "hugetlbsize", "int",
 151                                   memfd_backend_get_hugetlbsize,
 152                                   memfd_backend_set_hugetlbsize,
 153                                   NULL, NULL, &error_abort);
 154         object_class_property_set_description(oc, "hugetlbsize",
 155                                               "Huge pages size (ex: 2M, 1G)",
 156                                               &error_abort);
 157     }
 158     object_class_property_add_bool(oc, "seal",
 159                                    memfd_backend_get_seal,
 160                                    memfd_backend_set_seal,
 161                                    &error_abort);
 162     object_class_property_set_description(oc, "seal",
 163                                           "Seal growing & shrinking",
 164                                           &error_abort);
 165 }
 166
 167 static const TypeInfo memfd_backend_info = {
 168     .name = TYPE_MEMORY_BACKEND_MEMFD,
 169     .parent = TYPE_MEMORY_BACKEND,
 170     .instance_init = memfd_backend_instance_init,
 171     .class_init = memfd_backend_class_init,
 172     .instance_size = sizeof(HostMemoryBackendMemfd),
 173 };
 174
 175 static void register_types(void)
 176 {
 177     if (qemu_memfd_check(MFD_ALLOW_SEALING)) {
 178         type_register_static(&memfd_backend_info);
 179     }
 180 }
 181
 182 type_init(register_types);