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