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 void memory_device_plug_region(MachineState *ms, MemoryRegion *mr, 247 uint64_t addr) 248 { 249 /* we expect a previous call to memory_device_get_free_addr() */ 250 g_assert(ms->device_memory); 251 252 memory_region_add_subregion(&ms->device_memory->mr, 253 addr - ms->device_memory->base, mr); 254 } 255 256 void memory_device_unplug_region(MachineState *ms, MemoryRegion *mr) 257 { 258 /* we expect a previous call to memory_device_get_free_addr() */ 259 g_assert(ms->device_memory); 260 261 memory_region_del_subregion(&ms->device_memory->mr, mr); 262 } 263 264 static const TypeInfo memory_device_info = { 265 .name = TYPE_MEMORY_DEVICE, 266 .parent = TYPE_INTERFACE, 267 .class_size = sizeof(MemoryDeviceClass), 268 }; 269 270 static void memory_device_register_types(void) 271 { 272 type_register_static(&memory_device_info); 273 } 274 275 type_init(memory_device_register_types) 276