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 "qemu/error-report.h" 14 #include "hw/mem/memory-device.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 #include "trace.h" 21 22 static gint memory_device_addr_sort(gconstpointer a, gconstpointer b) 23 { 24 const MemoryDeviceState *md_a = MEMORY_DEVICE(a); 25 const MemoryDeviceState *md_b = MEMORY_DEVICE(b); 26 const MemoryDeviceClass *mdc_a = MEMORY_DEVICE_GET_CLASS(a); 27 const MemoryDeviceClass *mdc_b = MEMORY_DEVICE_GET_CLASS(b); 28 const uint64_t addr_a = mdc_a->get_addr(md_a); 29 const uint64_t addr_b = mdc_b->get_addr(md_b); 30 31 if (addr_a > addr_b) { 32 return 1; 33 } else if (addr_a < addr_b) { 34 return -1; 35 } 36 return 0; 37 } 38 39 static int memory_device_build_list(Object *obj, void *opaque) 40 { 41 GSList **list = opaque; 42 43 if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { 44 DeviceState *dev = DEVICE(obj); 45 if (dev->realized) { /* only realized memory devices matter */ 46 *list = g_slist_insert_sorted(*list, dev, memory_device_addr_sort); 47 } 48 } 49 50 object_child_foreach(obj, memory_device_build_list, opaque); 51 return 0; 52 } 53 54 static int memory_device_used_region_size(Object *obj, void *opaque) 55 { 56 uint64_t *size = opaque; 57 58 if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { 59 const DeviceState *dev = DEVICE(obj); 60 const MemoryDeviceState *md = MEMORY_DEVICE(obj); 61 62 if (dev->realized) { 63 *size += memory_device_get_region_size(md, &error_abort); 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 < used_region_size || 89 used_region_size + size > ms->maxram_size - ms->ram_size) { 90 error_setg(errp, "not enough space, currently 0x%" PRIx64 91 " in use of total space for memory devices 0x" RAM_ADDR_FMT, 92 used_region_size, ms->maxram_size - ms->ram_size); 93 return; 94 } 95 96 } 97 98 static uint64_t memory_device_get_free_addr(MachineState *ms, 99 const uint64_t *hint, 100 uint64_t align, uint64_t size, 101 Error **errp) 102 { 103 Error *err = NULL; 104 GSList *list = NULL, *item; 105 Range as, new = range_empty; 106 107 if (!ms->device_memory) { 108 error_setg(errp, "memory devices (e.g. for memory hotplug) are not " 109 "supported by the machine"); 110 return 0; 111 } 112 113 if (!memory_region_size(&ms->device_memory->mr)) { 114 error_setg(errp, "memory devices (e.g. for memory hotplug) are not " 115 "enabled, please specify the maxmem option"); 116 return 0; 117 } 118 range_init_nofail(&as, ms->device_memory->base, 119 memory_region_size(&ms->device_memory->mr)); 120 121 /* start of address space indicates the maximum alignment we expect */ 122 if (!QEMU_IS_ALIGNED(range_lob(&as), align)) { 123 warn_report("the alignment (0x%" PRIx64 ") exceeds the expected" 124 " maximum alignment, memory will get fragmented and not" 125 " all 'maxmem' might be usable for memory devices.", 126 align); 127 } 128 129 memory_device_check_addable(ms, size, &err); 130 if (err) { 131 error_propagate(errp, err); 132 return 0; 133 } 134 135 if (hint && !QEMU_IS_ALIGNED(*hint, align)) { 136 error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes", 137 align); 138 return 0; 139 } 140 141 if (!QEMU_IS_ALIGNED(size, align)) { 142 error_setg(errp, "backend memory size must be multiple of 0x%" 143 PRIx64, align); 144 return 0; 145 } 146 147 if (hint) { 148 if (range_init(&new, *hint, size) || !range_contains_range(&as, &new)) { 149 error_setg(errp, "can't add memory device [0x%" PRIx64 ":0x%" PRIx64 150 "], usable range for memory devices [0x%" PRIx64 ":0x%" 151 PRIx64 "]", *hint, size, range_lob(&as), 152 range_size(&as)); 153 return 0; 154 } 155 } else { 156 if (range_init(&new, QEMU_ALIGN_UP(range_lob(&as), align), size)) { 157 error_setg(errp, "can't add memory device, device too big"); 158 return 0; 159 } 160 } 161 162 /* find address range that will fit new memory device */ 163 object_child_foreach(OBJECT(ms), memory_device_build_list, &list); 164 for (item = list; item; item = g_slist_next(item)) { 165 const MemoryDeviceState *md = item->data; 166 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(OBJECT(md)); 167 uint64_t next_addr; 168 Range tmp; 169 170 range_init_nofail(&tmp, mdc->get_addr(md), 171 memory_device_get_region_size(md, &error_abort)); 172 173 if (range_overlaps_range(&tmp, &new)) { 174 if (hint) { 175 const DeviceState *d = DEVICE(md); 176 error_setg(errp, "address range conflicts with memory device" 177 " id='%s'", d->id ? d->id : "(unnamed)"); 178 goto out; 179 } 180 181 next_addr = QEMU_ALIGN_UP(range_upb(&tmp) + 1, align); 182 if (!next_addr || range_init(&new, next_addr, range_size(&new))) { 183 range_make_empty(&new); 184 break; 185 } 186 } else if (range_lob(&tmp) > range_upb(&new)) { 187 break; 188 } 189 } 190 191 if (!range_contains_range(&as, &new)) { 192 error_setg(errp, "could not find position in guest address space for " 193 "memory device - memory fragmented due to alignments"); 194 } 195 out: 196 g_slist_free(list); 197 return range_lob(&new); 198 } 199 200 MemoryDeviceInfoList *qmp_memory_device_list(void) 201 { 202 GSList *devices = NULL, *item; 203 MemoryDeviceInfoList *list = NULL, **tail = &list; 204 205 object_child_foreach(qdev_get_machine(), memory_device_build_list, 206 &devices); 207 208 for (item = devices; item; item = g_slist_next(item)) { 209 const MemoryDeviceState *md = MEMORY_DEVICE(item->data); 210 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data); 211 MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1); 212 213 mdc->fill_device_info(md, info); 214 215 QAPI_LIST_APPEND(tail, info); 216 } 217 218 g_slist_free(devices); 219 220 return list; 221 } 222 223 static int memory_device_plugged_size(Object *obj, void *opaque) 224 { 225 uint64_t *size = opaque; 226 227 if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) { 228 const DeviceState *dev = DEVICE(obj); 229 const MemoryDeviceState *md = MEMORY_DEVICE(obj); 230 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj); 231 232 if (dev->realized) { 233 *size += mdc->get_plugged_size(md, &error_abort); 234 } 235 } 236 237 object_child_foreach(obj, memory_device_plugged_size, opaque); 238 return 0; 239 } 240 241 uint64_t get_plugged_memory_size(void) 242 { 243 uint64_t size = 0; 244 245 memory_device_plugged_size(qdev_get_machine(), &size); 246 247 return size; 248 } 249 250 void memory_device_pre_plug(MemoryDeviceState *md, MachineState *ms, 251 const uint64_t *legacy_align, Error **errp) 252 { 253 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); 254 Error *local_err = NULL; 255 uint64_t addr, align = 0; 256 MemoryRegion *mr; 257 258 mr = mdc->get_memory_region(md, &local_err); 259 if (local_err) { 260 goto out; 261 } 262 263 if (legacy_align) { 264 align = *legacy_align; 265 } else { 266 if (mdc->get_min_alignment) { 267 align = mdc->get_min_alignment(md); 268 } 269 align = MAX(align, memory_region_get_alignment(mr)); 270 } 271 addr = mdc->get_addr(md); 272 addr = memory_device_get_free_addr(ms, !addr ? NULL : &addr, align, 273 memory_region_size(mr), &local_err); 274 if (local_err) { 275 goto out; 276 } 277 mdc->set_addr(md, addr, &local_err); 278 if (!local_err) { 279 trace_memory_device_pre_plug(DEVICE(md)->id ? DEVICE(md)->id : "", 280 addr); 281 } 282 out: 283 error_propagate(errp, local_err); 284 } 285 286 void memory_device_plug(MemoryDeviceState *md, MachineState *ms) 287 { 288 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); 289 const uint64_t addr = mdc->get_addr(md); 290 MemoryRegion *mr; 291 292 /* 293 * We expect that a previous call to memory_device_pre_plug() succeeded, so 294 * it can't fail at this point. 295 */ 296 mr = mdc->get_memory_region(md, &error_abort); 297 g_assert(ms->device_memory); 298 299 memory_region_add_subregion(&ms->device_memory->mr, 300 addr - ms->device_memory->base, mr); 301 trace_memory_device_plug(DEVICE(md)->id ? DEVICE(md)->id : "", addr); 302 } 303 304 void memory_device_unplug(MemoryDeviceState *md, MachineState *ms) 305 { 306 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); 307 MemoryRegion *mr; 308 309 /* 310 * We expect that a previous call to memory_device_pre_plug() succeeded, so 311 * it can't fail at this point. 312 */ 313 mr = mdc->get_memory_region(md, &error_abort); 314 g_assert(ms->device_memory); 315 316 memory_region_del_subregion(&ms->device_memory->mr, mr); 317 trace_memory_device_unplug(DEVICE(md)->id ? DEVICE(md)->id : "", 318 mdc->get_addr(md)); 319 } 320 321 uint64_t memory_device_get_region_size(const MemoryDeviceState *md, 322 Error **errp) 323 { 324 const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(md); 325 MemoryRegion *mr; 326 327 /* dropping const here is fine as we don't touch the memory region */ 328 mr = mdc->get_memory_region((MemoryDeviceState *)md, errp); 329 if (!mr) { 330 return 0; 331 } 332 333 return memory_region_size(mr); 334 } 335 336 static const TypeInfo memory_device_info = { 337 .name = TYPE_MEMORY_DEVICE, 338 .parent = TYPE_INTERFACE, 339 .class_size = sizeof(MemoryDeviceClass), 340 }; 341 342 static void memory_device_register_types(void) 343 { 344 type_register_static(&memory_device_info); 345 } 346 347 type_init(memory_device_register_types) 348