hw/mem/memory-device.c

   1 /*
   2  * Memory Device Interface
   3  *
   4  * Copyright ProfitBricks GmbH 2012
   5  * Copyright (C) 2014 Red Hat Inc
   6  * Copyright (c) 2018 Red Hat Inc
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   9  * See the COPYING file in the top-level directory.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "hw/mem/memory-device.h"
  14 #include "hw/qdev.h"
  15 #include "qapi/error.h"
  16 #include "hw/boards.h"
  17 #include "qemu/range.h"
  18 #include "hw/virtio/vhost.h"
  19 #include "sysemu/kvm.h"
  20
  21 static gint memory_device_addr_sort(gconstpointer a, gconstpointer b)
  22 {
  23     const MemoryDeviceState *md_a = MEMORY_DEVICE(a);
  24     const MemoryDeviceState *md_b = MEMORY_DEVICE(b);
  25     const MemoryDeviceClass *mdc_a = MEMORY_DEVICE_GET_CLASS(a);
  26     const MemoryDeviceClass *mdc_b = MEMORY_DEVICE_GET_CLASS(b);
  27     const uint64_t addr_a = mdc_a->get_addr(md_a);
  28     const uint64_t addr_b = mdc_b->get_addr(md_b);
  29
  30     if (addr_a > addr_b) {
  31         return 1;
  32     } else if (addr_a < addr_b) {
  33         return -1;
  34     }
  35     return 0;
  36 }
  37
  38 static int memory_device_build_list(Object *obj, void *opaque)
  39 {
  40     GSList **list = opaque;
  41
  42     if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {
  43         DeviceState *dev = DEVICE(obj);
  44         if (dev->realized) { /* only realized memory devices matter */
  45             *list = g_slist_insert_sorted(*list, dev, memory_device_addr_sort);
  46         }
  47     }
  48
  49     object_child_foreach(obj, memory_device_build_list, opaque);
  50     return 0;
  51 }
  52
  53 static int memory_device_used_region_size(Object *obj, void *opaque)
  54 {
  55     uint64_t *size = opaque;
  56
  57     if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {
  58         const DeviceState *dev = DEVICE(obj);
  59         const MemoryDeviceState *md = MEMORY_DEVICE(obj);
  60         const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj);
  61
  62         if (dev->realized) {
  63             *size += mdc->get_region_size(md);
  64         }
  65     }
  66
  67     object_child_foreach(obj, memory_device_used_region_size, opaque);
  68     return 0;
  69 }
  70
  71 static void memory_device_check_addable(MachineState *ms, uint64_t size,
  72                                         Error **errp)
  73 {
  74     uint64_t used_region_size = 0;
  75
  76     /* we will need a new memory slot for kvm and vhost */
  77     if (kvm_enabled() && !kvm_has_free_slot(ms)) {
  78         error_setg(errp, "hypervisor has no free memory slots left");
  79         return;
  80     }
  81     if (!vhost_has_free_slot()) {
  82         error_setg(errp, "a used vhost backend has no free memory slots left");
  83         return;
  84     }
  85
  86     /* will we exceed the total amount of memory specified */
  87     memory_device_used_region_size(OBJECT(ms), &used_region_size);
  88     if (used_region_size + size > ms->maxram_size - ms->ram_size) {
  89         error_setg(errp, "not enough space, currently 0x%" PRIx64
  90                    " in use of total hot pluggable 0x" RAM_ADDR_FMT,
  91                    used_region_size, ms->maxram_size - ms->ram_size);
  92         return;
  93     }
  94
  95 }
  96
  97 uint64_t memory_device_get_free_addr(MachineState *ms, const uint64_t *hint,
  98                                      uint64_t align, uint64_t size,
  99                                      Error **errp)
 100 {
 101     uint64_t address_space_start, address_space_end;
 102     GSList *list = NULL, *item;
 103     uint64_t new_addr = 0;
 104
 105     if (!ms->device_memory) {
 106         error_setg(errp, "memory devices (e.g. for memory hotplug) are not "
 107                          "supported by the machine");
 108         return 0;
 109     }
 110
 111     if (!memory_region_size(&ms->device_memory->mr)) {
 112         error_setg(errp, "memory devices (e.g. for memory hotplug) are not "
 113                          "enabled, please specify the maxmem option");
 114         return 0;
 115     }
 116     address_space_start = ms->device_memory->base;
 117     address_space_end = address_space_start +
 118                         memory_region_size(&ms->device_memory->mr);
 119     g_assert(QEMU_ALIGN_UP(address_space_start, align) == address_space_start);
 120     g_assert(address_space_end >= address_space_start);
 121
 122     memory_device_check_addable(ms, size, errp);
 123     if (*errp) {
 124         return 0;
 125     }
 126
 127     if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) {
 128         error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes",
 129                    align);
 130         return 0;
 131     }
 132
 133     if (QEMU_ALIGN_UP(size, align) != size) {
 134         error_setg(errp, "backend memory size must be multiple of 0x%"
 135                    PRIx64, align);
 136         return 0;
 137     }
 138
 139     if (hint) {
 140         new_addr = *hint;
 141         if (new_addr < address_space_start) {
 142             error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
 143                        "] at 0x%" PRIx64, new_addr, size, address_space_start);
 144             return 0;
 145         } else if ((new_addr + size) > address_space_end) {
 146             error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
 147                        "] beyond 0x%" PRIx64, new_addr, size,
 148                        address_space_end);
 149             return 0;
 150         }
 151     } else {
 152         new_addr = address_space_start;
 153     }
 154
 155     /* find address range that will fit new memory device */
 156     object_child_foreach(OBJECT(ms), memory_device_build_list, &list);
 157     for (item = list; item; item = g_slist_next(item)) {
 158         const MemoryDeviceState *md = item->data;
 159         const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(OBJECT(md));
 160         uint64_t md_size, md_addr;
 161
 162         md_addr = mdc->get_addr(md);
 163         md_size = mdc->get_region_size(md);
 164         if (*errp) {
 165             goto out;
 166         }
 167
 168         if (ranges_overlap(md_addr, md_size, new_addr, size)) {
 169             if (hint) {
 170                 const DeviceState *d = DEVICE(md);
 171                 error_setg(errp, "address range conflicts with '%s'", d->id);
 172                 goto out;
 173             }
 174             new_addr = QEMU_ALIGN_UP(md_addr + md_size, align);
 175         }
 176     }
 177
 178     if (new_addr + size > address_space_end) {
 179         error_setg(errp, "could not find position in guest address space for "
 180                    "memory device - memory fragmented due to alignments");
 181         goto out;
 182     }
 183 out:
 184     g_slist_free(list);
 185     return new_addr;
 186 }
 187
 188 MemoryDeviceInfoList *qmp_memory_device_list(void)
 189 {
 190     GSList *devices = NULL, *item;
 191     MemoryDeviceInfoList *list = NULL, *prev = NULL;
 192
 193     object_child_foreach(qdev_get_machine(), memory_device_build_list,
 194                          &devices);
 195
 196     for (item = devices; item; item = g_slist_next(item)) {
 197         const MemoryDeviceState *md = MEMORY_DEVICE(item->data);
 198         const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data);
 199         MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);
 200         MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);
 201
 202         mdc->fill_device_info(md, info);
 203
 204         elem->value = info;
 205         elem->next = NULL;
 206         if (prev) {
 207             prev->next = elem;
 208         } else {
 209             list = elem;
 210         }
 211         prev = elem;
 212     }
 213
 214     g_slist_free(devices);
 215
 216     return list;
 217 }
 218
 219 static int memory_device_plugged_size(Object *obj, void *opaque)
 220 {
 221     uint64_t *size = opaque;
 222
 223     if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {
 224         const DeviceState *dev = DEVICE(obj);
 225         const MemoryDeviceState *md = MEMORY_DEVICE(obj);
 226         const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj);
 227
 228         if (dev->realized) {
 229             *size += mdc->get_plugged_size(md);
 230         }
 231     }
 232
 233     object_child_foreach(obj, memory_device_plugged_size, opaque);
 234     return 0;
 235 }
 236
 237 uint64_t get_plugged_memory_size(void)
 238 {
 239     uint64_t size = 0;
 240
 241     memory_device_plugged_size(qdev_get_machine(), &size);
 242
 243     return size;
 244 }
 245
 246 static const TypeInfo memory_device_info = {
 247     .name          = TYPE_MEMORY_DEVICE,
 248     .parent        = TYPE_INTERFACE,
 249     .class_size = sizeof(MemoryDeviceClass),
 250 };
 251
 252 static void memory_device_register_types(void)
 253 {
 254     type_register_static(&memory_device_info);
 255 }
 256
 257 type_init(memory_device_register_types)