hw/mem/pc-dimm.c

   1 /*
   2  * Dimm device for Memory Hotplug
   3  *
   4  * Copyright ProfitBricks GmbH 2012
   5  * Copyright (C) 2014 Red Hat Inc
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>
  19  */
  20
  21 #include "hw/mem/pc-dimm.h"
  22 #include "qemu/config-file.h"
  23 #include "qapi/visitor.h"
  24 #include "qemu/range.h"
  25 #include "sysemu/numa.h"
  26 #include "sysemu/kvm.h"
  27 #include "trace.h"
  28
  29 typedef struct pc_dimms_capacity {
  30      uint64_t size;
  31      Error    **errp;
  32 } pc_dimms_capacity;
  33
  34 void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
  35                          MemoryRegion *mr, uint64_t align, bool gap,
  36                          Error **errp)
  37 {
  38     int slot;
  39     MachineState *machine = MACHINE(qdev_get_machine());
  40     PCDIMMDevice *dimm = PC_DIMM(dev);
  41     Error *local_err = NULL;
  42     uint64_t existing_dimms_capacity = 0;
  43     uint64_t addr;
  44
  45     addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err);
  46     if (local_err) {
  47         goto out;
  48     }
  49
  50     addr = pc_dimm_get_free_addr(hpms->base,
  51                                  memory_region_size(&hpms->mr),
  52                                  !addr ? NULL : &addr, align, gap,
  53                                  memory_region_size(mr), &local_err);
  54     if (local_err) {
  55         goto out;
  56     }
  57
  58     existing_dimms_capacity = pc_existing_dimms_capacity(&local_err);
  59     if (local_err) {
  60         goto out;
  61     }
  62
  63     if (existing_dimms_capacity + memory_region_size(mr) >
  64         machine->maxram_size - machine->ram_size) {
  65         error_setg(&local_err, "not enough space, currently 0x%" PRIx64
  66                    " in use of total hot pluggable 0x" RAM_ADDR_FMT,
  67                    existing_dimms_capacity,
  68                    machine->maxram_size - machine->ram_size);
  69         goto out;
  70     }
  71
  72     object_property_set_int(OBJECT(dev), addr, PC_DIMM_ADDR_PROP, &local_err);
  73     if (local_err) {
  74         goto out;
  75     }
  76     trace_mhp_pc_dimm_assigned_address(addr);
  77
  78     slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP, &local_err);
  79     if (local_err) {
  80         goto out;
  81     }
  82
  83     slot = pc_dimm_get_free_slot(slot == PC_DIMM_UNASSIGNED_SLOT ? NULL : &slot,
  84                                  machine->ram_slots, &local_err);
  85     if (local_err) {
  86         goto out;
  87     }
  88     object_property_set_int(OBJECT(dev), slot, PC_DIMM_SLOT_PROP, &local_err);
  89     if (local_err) {
  90         goto out;
  91     }
  92     trace_mhp_pc_dimm_assigned_slot(slot);
  93
  94     if (kvm_enabled() && !kvm_has_free_slot(machine)) {
  95         error_setg(&local_err, "hypervisor has no free memory slots left");
  96         goto out;
  97     }
  98
  99     memory_region_add_subregion(&hpms->mr, addr - hpms->base, mr);
 100     vmstate_register_ram(mr, dev);
 101     numa_set_mem_node_id(addr, memory_region_size(mr), dimm->node);
 102
 103 out:
 104     error_propagate(errp, local_err);
 105 }
 106
 107 void pc_dimm_memory_unplug(DeviceState *dev, MemoryHotplugState *hpms,
 108                            MemoryRegion *mr)
 109 {
 110     PCDIMMDevice *dimm = PC_DIMM(dev);
 111
 112     numa_unset_mem_node_id(dimm->addr, memory_region_size(mr), dimm->node);
 113     memory_region_del_subregion(&hpms->mr, mr);
 114     vmstate_unregister_ram(mr, dev);
 115 }
 116
 117 static int pc_existing_dimms_capacity_internal(Object *obj, void *opaque)
 118 {
 119     pc_dimms_capacity *cap = opaque;
 120     uint64_t *size = &cap->size;
 121
 122     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 123         DeviceState *dev = DEVICE(obj);
 124
 125         if (dev->realized) {
 126             (*size) += object_property_get_int(obj, PC_DIMM_SIZE_PROP,
 127                 cap->errp);
 128         }
 129
 130         if (cap->errp && *cap->errp) {
 131             return 1;
 132         }
 133     }
 134     object_child_foreach(obj, pc_existing_dimms_capacity_internal, opaque);
 135     return 0;
 136 }
 137
 138 uint64_t pc_existing_dimms_capacity(Error **errp)
 139 {
 140     pc_dimms_capacity cap;
 141
 142     cap.size = 0;
 143     cap.errp = errp;
 144
 145     pc_existing_dimms_capacity_internal(qdev_get_machine(), &cap);
 146     return cap.size;
 147 }
 148
 149 int qmp_pc_dimm_device_list(Object *obj, void *opaque)
 150 {
 151     MemoryDeviceInfoList ***prev = opaque;
 152
 153     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 154         DeviceState *dev = DEVICE(obj);
 155
 156         if (dev->realized) {
 157             MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);
 158             MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);
 159             PCDIMMDeviceInfo *di = g_new0(PCDIMMDeviceInfo, 1);
 160             DeviceClass *dc = DEVICE_GET_CLASS(obj);
 161             PCDIMMDevice *dimm = PC_DIMM(obj);
 162
 163             if (dev->id) {
 164                 di->has_id = true;
 165                 di->id = g_strdup(dev->id);
 166             }
 167             di->hotplugged = dev->hotplugged;
 168             di->hotpluggable = dc->hotpluggable;
 169             di->addr = dimm->addr;
 170             di->slot = dimm->slot;
 171             di->node = dimm->node;
 172             di->size = object_property_get_int(OBJECT(dimm), PC_DIMM_SIZE_PROP,
 173                                                NULL);
 174             di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem));
 175
 176             info->dimm = di;
 177             elem->value = info;
 178             elem->next = NULL;
 179             **prev = elem;
 180             *prev = &elem->next;
 181         }
 182     }
 183
 184     object_child_foreach(obj, qmp_pc_dimm_device_list, opaque);
 185     return 0;
 186 }
 187
 188 ram_addr_t get_current_ram_size(void)
 189 {
 190     MemoryDeviceInfoList *info_list = NULL;
 191     MemoryDeviceInfoList **prev = &info_list;
 192     MemoryDeviceInfoList *info;
 193     ram_addr_t size = ram_size;
 194
 195     qmp_pc_dimm_device_list(qdev_get_machine(), &prev);
 196     for (info = info_list; info; info = info->next) {
 197         MemoryDeviceInfo *value = info->value;
 198
 199         if (value) {
 200             switch (value->kind) {
 201             case MEMORY_DEVICE_INFO_KIND_DIMM:
 202                 size += value->dimm->size;
 203                 break;
 204             default:
 205                 break;
 206             }
 207         }
 208     }
 209     qapi_free_MemoryDeviceInfoList(info_list);
 210
 211     return size;
 212 }
 213
 214 static int pc_dimm_slot2bitmap(Object *obj, void *opaque)
 215 {
 216     unsigned long *bitmap = opaque;
 217
 218     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 219         DeviceState *dev = DEVICE(obj);
 220         if (dev->realized) { /* count only realized DIMMs */
 221             PCDIMMDevice *d = PC_DIMM(obj);
 222             set_bit(d->slot, bitmap);
 223         }
 224     }
 225
 226     object_child_foreach(obj, pc_dimm_slot2bitmap, opaque);
 227     return 0;
 228 }
 229
 230 int pc_dimm_get_free_slot(const int *hint, int max_slots, Error **errp)
 231 {
 232     unsigned long *bitmap = bitmap_new(max_slots);
 233     int slot = 0;
 234
 235     object_child_foreach(qdev_get_machine(), pc_dimm_slot2bitmap, bitmap);
 236
 237     /* check if requested slot is not occupied */
 238     if (hint) {
 239         if (*hint >= max_slots) {
 240             error_setg(errp, "invalid slot# %d, should be less than %d",
 241                        *hint, max_slots);
 242         } else if (!test_bit(*hint, bitmap)) {
 243             slot = *hint;
 244         } else {
 245             error_setg(errp, "slot %d is busy", *hint);
 246         }
 247         goto out;
 248     }
 249
 250     /* search for free slot */
 251     slot = find_first_zero_bit(bitmap, max_slots);
 252     if (slot == max_slots) {
 253         error_setg(errp, "no free slots available");
 254     }
 255 out:
 256     g_free(bitmap);
 257     return slot;
 258 }
 259
 260 static gint pc_dimm_addr_sort(gconstpointer a, gconstpointer b)
 261 {
 262     PCDIMMDevice *x = PC_DIMM(a);
 263     PCDIMMDevice *y = PC_DIMM(b);
 264     Int128 diff = int128_sub(int128_make64(x->addr), int128_make64(y->addr));
 265
 266     if (int128_lt(diff, int128_zero())) {
 267         return -1;
 268     } else if (int128_gt(diff, int128_zero())) {
 269         return 1;
 270     }
 271     return 0;
 272 }
 273
 274 static int pc_dimm_built_list(Object *obj, void *opaque)
 275 {
 276     GSList **list = opaque;
 277
 278     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 279         DeviceState *dev = DEVICE(obj);
 280         if (dev->realized) { /* only realized DIMMs matter */
 281             *list = g_slist_insert_sorted(*list, dev, pc_dimm_addr_sort);
 282         }
 283     }
 284
 285     object_child_foreach(obj, pc_dimm_built_list, opaque);
 286     return 0;
 287 }
 288
 289 uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
 290                                uint64_t address_space_size,
 291                                uint64_t *hint, uint64_t align, bool gap,
 292                                uint64_t size, Error **errp)
 293 {
 294     GSList *list = NULL, *item;
 295     uint64_t new_addr, ret = 0;
 296     uint64_t address_space_end = address_space_start + address_space_size;
 297
 298     g_assert(QEMU_ALIGN_UP(address_space_start, align) == address_space_start);
 299
 300     if (!address_space_size) {
 301         error_setg(errp, "memory hotplug is not enabled, "
 302                          "please add maxmem option");
 303         goto out;
 304     }
 305
 306     if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) {
 307         error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes",
 308                    align);
 309         goto out;
 310     }
 311
 312     if (QEMU_ALIGN_UP(size, align) != size) {
 313         error_setg(errp, "backend memory size must be multiple of 0x%"
 314                    PRIx64, align);
 315         goto out;
 316     }
 317
 318     assert(address_space_end > address_space_start);
 319     object_child_foreach(qdev_get_machine(), pc_dimm_built_list, &list);
 320
 321     if (hint) {
 322         new_addr = *hint;
 323     } else {
 324         new_addr = address_space_start;
 325     }
 326
 327     /* find address range that will fit new DIMM */
 328     for (item = list; item; item = g_slist_next(item)) {
 329         PCDIMMDevice *dimm = item->data;
 330         uint64_t dimm_size = object_property_get_int(OBJECT(dimm),
 331                                                      PC_DIMM_SIZE_PROP,
 332                                                      errp);
 333         if (errp && *errp) {
 334             goto out;
 335         }
 336
 337         if (ranges_overlap(dimm->addr, dimm_size, new_addr,
 338                            size + (gap ? 1 : 0))) {
 339             if (hint) {
 340                 DeviceState *d = DEVICE(dimm);
 341                 error_setg(errp, "address range conflicts with '%s'", d->id);
 342                 goto out;
 343             }
 344             new_addr = QEMU_ALIGN_UP(dimm->addr + dimm_size + (gap ? 1 : 0),
 345                                      align);
 346         }
 347     }
 348     ret = new_addr;
 349
 350     if (new_addr < address_space_start) {
 351         error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
 352                    "] at 0x%" PRIx64, new_addr, size, address_space_start);
 353     } else if ((new_addr + size) > address_space_end) {
 354         error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
 355                    "] beyond 0x%" PRIx64, new_addr, size, address_space_end);
 356     }
 357
 358 out:
 359     g_slist_free(list);
 360     return ret;
 361 }
 362
 363 static Property pc_dimm_properties[] = {
 364     DEFINE_PROP_UINT64(PC_DIMM_ADDR_PROP, PCDIMMDevice, addr, 0),
 365     DEFINE_PROP_UINT32(PC_DIMM_NODE_PROP, PCDIMMDevice, node, 0),
 366     DEFINE_PROP_INT32(PC_DIMM_SLOT_PROP, PCDIMMDevice, slot,
 367                       PC_DIMM_UNASSIGNED_SLOT),
 368     DEFINE_PROP_END_OF_LIST(),
 369 };
 370
 371 static void pc_dimm_get_size(Object *obj, Visitor *v, void *opaque,
 372                           const char *name, Error **errp)
 373 {
 374     int64_t value;
 375     MemoryRegion *mr;
 376     PCDIMMDevice *dimm = PC_DIMM(obj);
 377
 378     mr = host_memory_backend_get_memory(dimm->hostmem, errp);
 379     value = memory_region_size(mr);
 380
 381     visit_type_int(v, &value, name, errp);
 382 }
 383
 384 static void pc_dimm_check_memdev_is_busy(Object *obj, const char *name,
 385                                       Object *val, Error **errp)
 386 {
 387     MemoryRegion *mr;
 388
 389     mr = host_memory_backend_get_memory(MEMORY_BACKEND(val), errp);
 390     if (memory_region_is_mapped(mr)) {
 391         char *path = object_get_canonical_path_component(val);
 392         error_setg(errp, "can't use already busy memdev: %s", path);
 393         g_free(path);
 394     } else {
 395         qdev_prop_allow_set_link_before_realize(obj, name, val, errp);
 396     }
 397 }
 398
 399 static void pc_dimm_init(Object *obj)
 400 {
 401     PCDIMMDevice *dimm = PC_DIMM(obj);
 402
 403     object_property_add(obj, PC_DIMM_SIZE_PROP, "int", pc_dimm_get_size,
 404                         NULL, NULL, NULL, &error_abort);
 405     object_property_add_link(obj, PC_DIMM_MEMDEV_PROP, TYPE_MEMORY_BACKEND,
 406                              (Object **)&dimm->hostmem,
 407                              pc_dimm_check_memdev_is_busy,
 408                              OBJ_PROP_LINK_UNREF_ON_RELEASE,
 409                              &error_abort);
 410 }
 411
 412 static void pc_dimm_realize(DeviceState *dev, Error **errp)
 413 {
 414     PCDIMMDevice *dimm = PC_DIMM(dev);
 415
 416     if (!dimm->hostmem) {
 417         error_setg(errp, "'" PC_DIMM_MEMDEV_PROP "' property is not set");
 418         return;
 419     }
 420     if (((nb_numa_nodes > 0) && (dimm->node >= nb_numa_nodes)) ||
 421         (!nb_numa_nodes && dimm->node)) {
 422         error_setg(errp, "'DIMM property " PC_DIMM_NODE_PROP " has value %"
 423                    PRIu32 "' which exceeds the number of numa nodes: %d",
 424                    dimm->node, nb_numa_nodes ? nb_numa_nodes : 1);
 425         return;
 426     }
 427 }
 428
 429 static MemoryRegion *pc_dimm_get_memory_region(PCDIMMDevice *dimm)
 430 {
 431     return host_memory_backend_get_memory(dimm->hostmem, &error_abort);
 432 }
 433
 434 static void pc_dimm_class_init(ObjectClass *oc, void *data)
 435 {
 436     DeviceClass *dc = DEVICE_CLASS(oc);
 437     PCDIMMDeviceClass *ddc = PC_DIMM_CLASS(oc);
 438
 439     dc->realize = pc_dimm_realize;
 440     dc->props = pc_dimm_properties;
 441     dc->desc = "DIMM memory module";
 442
 443     ddc->get_memory_region = pc_dimm_get_memory_region;
 444 }
 445
 446 static TypeInfo pc_dimm_info = {
 447     .name          = TYPE_PC_DIMM,
 448     .parent        = TYPE_DEVICE,
 449     .instance_size = sizeof(PCDIMMDevice),
 450     .instance_init = pc_dimm_init,
 451     .class_init    = pc_dimm_class_init,
 452     .class_size    = sizeof(PCDIMMDeviceClass),
 453 };
 454
 455 static void pc_dimm_register_types(void)
 456 {
 457     type_register_static(&pc_dimm_info);
 458 }
 459
 460 type_init(pc_dimm_register_types)