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
  27 typedef struct pc_dimms_capacity {
  28      uint64_t size;
  29      Error    **errp;
  30 } pc_dimms_capacity;
  31
  32 static int pc_existing_dimms_capacity_internal(Object *obj, void *opaque)
  33 {
  34     pc_dimms_capacity *cap = opaque;
  35     uint64_t *size = &cap->size;
  36
  37     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
  38         DeviceState *dev = DEVICE(obj);
  39
  40         if (dev->realized) {
  41             (*size) += object_property_get_int(obj, PC_DIMM_SIZE_PROP,
  42                 cap->errp);
  43         }
  44
  45         if (cap->errp && *cap->errp) {
  46             return 1;
  47         }
  48     }
  49     object_child_foreach(obj, pc_existing_dimms_capacity_internal, opaque);
  50     return 0;
  51 }
  52
  53 uint64_t pc_existing_dimms_capacity(Error **errp)
  54 {
  55     pc_dimms_capacity cap;
  56
  57     cap.size = 0;
  58     cap.errp = errp;
  59
  60     pc_existing_dimms_capacity_internal(qdev_get_machine(), &cap);
  61     return cap.size;
  62 }
  63
  64 int qmp_pc_dimm_device_list(Object *obj, void *opaque)
  65 {
  66     MemoryDeviceInfoList ***prev = opaque;
  67
  68     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
  69         DeviceState *dev = DEVICE(obj);
  70
  71         if (dev->realized) {
  72             MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);
  73             MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);
  74             PCDIMMDeviceInfo *di = g_new0(PCDIMMDeviceInfo, 1);
  75             DeviceClass *dc = DEVICE_GET_CLASS(obj);
  76             PCDIMMDevice *dimm = PC_DIMM(obj);
  77
  78             if (dev->id) {
  79                 di->has_id = true;
  80                 di->id = g_strdup(dev->id);
  81             }
  82             di->hotplugged = dev->hotplugged;
  83             di->hotpluggable = dc->hotpluggable;
  84             di->addr = dimm->addr;
  85             di->slot = dimm->slot;
  86             di->node = dimm->node;
  87             di->size = object_property_get_int(OBJECT(dimm), PC_DIMM_SIZE_PROP,
  88                                                NULL);
  89             di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem));
  90
  91             info->dimm = di;
  92             elem->value = info;
  93             elem->next = NULL;
  94             **prev = elem;
  95             *prev = &elem->next;
  96         }
  97     }
  98
  99     object_child_foreach(obj, qmp_pc_dimm_device_list, opaque);
 100     return 0;
 101 }
 102
 103 ram_addr_t get_current_ram_size(void)
 104 {
 105     MemoryDeviceInfoList *info_list = NULL;
 106     MemoryDeviceInfoList **prev = &info_list;
 107     MemoryDeviceInfoList *info;
 108     ram_addr_t size = ram_size;
 109
 110     qmp_pc_dimm_device_list(qdev_get_machine(), &prev);
 111     for (info = info_list; info; info = info->next) {
 112         MemoryDeviceInfo *value = info->value;
 113
 114         if (value) {
 115             switch (value->kind) {
 116             case MEMORY_DEVICE_INFO_KIND_DIMM:
 117                 size += value->dimm->size;
 118                 break;
 119             default:
 120                 break;
 121             }
 122         }
 123     }
 124     qapi_free_MemoryDeviceInfoList(info_list);
 125
 126     return size;
 127 }
 128
 129 static int pc_dimm_slot2bitmap(Object *obj, void *opaque)
 130 {
 131     unsigned long *bitmap = opaque;
 132
 133     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 134         DeviceState *dev = DEVICE(obj);
 135         if (dev->realized) { /* count only realized DIMMs */
 136             PCDIMMDevice *d = PC_DIMM(obj);
 137             set_bit(d->slot, bitmap);
 138         }
 139     }
 140
 141     object_child_foreach(obj, pc_dimm_slot2bitmap, opaque);
 142     return 0;
 143 }
 144
 145 int pc_dimm_get_free_slot(const int *hint, int max_slots, Error **errp)
 146 {
 147     unsigned long *bitmap = bitmap_new(max_slots);
 148     int slot = 0;
 149
 150     object_child_foreach(qdev_get_machine(), pc_dimm_slot2bitmap, bitmap);
 151
 152     /* check if requested slot is not occupied */
 153     if (hint) {
 154         if (*hint >= max_slots) {
 155             error_setg(errp, "invalid slot# %d, should be less than %d",
 156                        *hint, max_slots);
 157         } else if (!test_bit(*hint, bitmap)) {
 158             slot = *hint;
 159         } else {
 160             error_setg(errp, "slot %d is busy", *hint);
 161         }
 162         goto out;
 163     }
 164
 165     /* search for free slot */
 166     slot = find_first_zero_bit(bitmap, max_slots);
 167     if (slot == max_slots) {
 168         error_setg(errp, "no free slots available");
 169     }
 170 out:
 171     g_free(bitmap);
 172     return slot;
 173 }
 174
 175 static gint pc_dimm_addr_sort(gconstpointer a, gconstpointer b)
 176 {
 177     PCDIMMDevice *x = PC_DIMM(a);
 178     PCDIMMDevice *y = PC_DIMM(b);
 179     Int128 diff = int128_sub(int128_make64(x->addr), int128_make64(y->addr));
 180
 181     if (int128_lt(diff, int128_zero())) {
 182         return -1;
 183     } else if (int128_gt(diff, int128_zero())) {
 184         return 1;
 185     }
 186     return 0;
 187 }
 188
 189 static int pc_dimm_built_list(Object *obj, void *opaque)
 190 {
 191     GSList **list = opaque;
 192
 193     if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
 194         DeviceState *dev = DEVICE(obj);
 195         if (dev->realized) { /* only realized DIMMs matter */
 196             *list = g_slist_insert_sorted(*list, dev, pc_dimm_addr_sort);
 197         }
 198     }
 199
 200     object_child_foreach(obj, pc_dimm_built_list, opaque);
 201     return 0;
 202 }
 203
 204 uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
 205                                uint64_t address_space_size,
 206                                uint64_t *hint, uint64_t align, uint64_t size,
 207                                Error **errp)
 208 {
 209     GSList *list = NULL, *item;
 210     uint64_t new_addr, ret = 0;
 211     uint64_t address_space_end = address_space_start + address_space_size;
 212
 213     g_assert(QEMU_ALIGN_UP(address_space_start, align) == address_space_start);
 214     g_assert(QEMU_ALIGN_UP(address_space_size, align) == address_space_size);
 215
 216     if (!address_space_size) {
 217         error_setg(errp, "memory hotplug is not enabled, "
 218                          "please add maxmem option");
 219         goto out;
 220     }
 221
 222     if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) {
 223         error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes",
 224                    align);
 225         goto out;
 226     }
 227
 228     if (QEMU_ALIGN_UP(size, align) != size) {
 229         error_setg(errp, "backend memory size must be multiple of 0x%"
 230                    PRIx64, align);
 231         goto out;
 232     }
 233
 234     assert(address_space_end > address_space_start);
 235     object_child_foreach(qdev_get_machine(), pc_dimm_built_list, &list);
 236
 237     if (hint) {
 238         new_addr = *hint;
 239     } else {
 240         new_addr = address_space_start;
 241     }
 242
 243     /* find address range that will fit new DIMM */
 244     for (item = list; item; item = g_slist_next(item)) {
 245         PCDIMMDevice *dimm = item->data;
 246         uint64_t dimm_size = object_property_get_int(OBJECT(dimm),
 247                                                      PC_DIMM_SIZE_PROP,
 248                                                      errp);
 249         if (errp && *errp) {
 250             goto out;
 251         }
 252
 253         if (ranges_overlap(dimm->addr, dimm_size, new_addr, size)) {
 254             if (hint) {
 255                 DeviceState *d = DEVICE(dimm);
 256                 error_setg(errp, "address range conflicts with '%s'", d->id);
 257                 goto out;
 258             }
 259             new_addr = QEMU_ALIGN_UP(dimm->addr + dimm_size, align);
 260         }
 261     }
 262     ret = new_addr;
 263
 264     if (new_addr < address_space_start) {
 265         error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
 266                    "] at 0x%" PRIx64, new_addr, size, address_space_start);
 267     } else if ((new_addr + size) > address_space_end) {
 268         error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
 269                    "] beyond 0x%" PRIx64, new_addr, size, address_space_end);
 270     }
 271
 272 out:
 273     g_slist_free(list);
 274     return ret;
 275 }
 276
 277 static Property pc_dimm_properties[] = {
 278     DEFINE_PROP_UINT64(PC_DIMM_ADDR_PROP, PCDIMMDevice, addr, 0),
 279     DEFINE_PROP_UINT32(PC_DIMM_NODE_PROP, PCDIMMDevice, node, 0),
 280     DEFINE_PROP_INT32(PC_DIMM_SLOT_PROP, PCDIMMDevice, slot,
 281                       PC_DIMM_UNASSIGNED_SLOT),
 282     DEFINE_PROP_END_OF_LIST(),
 283 };
 284
 285 static void pc_dimm_get_size(Object *obj, Visitor *v, void *opaque,
 286                           const char *name, Error **errp)
 287 {
 288     int64_t value;
 289     MemoryRegion *mr;
 290     PCDIMMDevice *dimm = PC_DIMM(obj);
 291
 292     mr = host_memory_backend_get_memory(dimm->hostmem, errp);
 293     value = memory_region_size(mr);
 294
 295     visit_type_int(v, &value, name, errp);
 296 }
 297
 298 static void pc_dimm_check_memdev_is_busy(Object *obj, const char *name,
 299                                       Object *val, Error **errp)
 300 {
 301     MemoryRegion *mr;
 302
 303     mr = host_memory_backend_get_memory(MEMORY_BACKEND(val), errp);
 304     if (memory_region_is_mapped(mr)) {
 305         char *path = object_get_canonical_path_component(val);
 306         error_setg(errp, "can't use already busy memdev: %s", path);
 307         g_free(path);
 308     } else {
 309         qdev_prop_allow_set_link_before_realize(obj, name, val, errp);
 310     }
 311 }
 312
 313 static void pc_dimm_init(Object *obj)
 314 {
 315     PCDIMMDevice *dimm = PC_DIMM(obj);
 316
 317     object_property_add(obj, PC_DIMM_SIZE_PROP, "int", pc_dimm_get_size,
 318                         NULL, NULL, NULL, &error_abort);
 319     object_property_add_link(obj, PC_DIMM_MEMDEV_PROP, TYPE_MEMORY_BACKEND,
 320                              (Object **)&dimm->hostmem,
 321                              pc_dimm_check_memdev_is_busy,
 322                              OBJ_PROP_LINK_UNREF_ON_RELEASE,
 323                              &error_abort);
 324 }
 325
 326 static void pc_dimm_realize(DeviceState *dev, Error **errp)
 327 {
 328     PCDIMMDevice *dimm = PC_DIMM(dev);
 329
 330     if (!dimm->hostmem) {
 331         error_setg(errp, "'" PC_DIMM_MEMDEV_PROP "' property is not set");
 332         return;
 333     }
 334     if ((nb_numa_nodes > 0) && (dimm->node >= nb_numa_nodes)) {
 335         error_setg(errp, "'DIMM property " PC_DIMM_NODE_PROP " has value %"
 336                    PRIu32 "' which exceeds the number of numa nodes: %d",
 337                    dimm->node, nb_numa_nodes);
 338         return;
 339     }
 340 }
 341
 342 static MemoryRegion *pc_dimm_get_memory_region(PCDIMMDevice *dimm)
 343 {
 344     return host_memory_backend_get_memory(dimm->hostmem, &error_abort);
 345 }
 346
 347 static void pc_dimm_class_init(ObjectClass *oc, void *data)
 348 {
 349     DeviceClass *dc = DEVICE_CLASS(oc);
 350     PCDIMMDeviceClass *ddc = PC_DIMM_CLASS(oc);
 351
 352     dc->realize = pc_dimm_realize;
 353     dc->props = pc_dimm_properties;
 354     dc->desc = "DIMM memory module";
 355
 356     ddc->get_memory_region = pc_dimm_get_memory_region;
 357 }
 358
 359 static TypeInfo pc_dimm_info = {
 360     .name          = TYPE_PC_DIMM,
 361     .parent        = TYPE_DEVICE,
 362     .instance_size = sizeof(PCDIMMDevice),
 363     .instance_init = pc_dimm_init,
 364     .class_init    = pc_dimm_class_init,
 365     .class_size    = sizeof(PCDIMMDeviceClass),
 366 };
 367
 368 static void pc_dimm_register_types(void)
 369 {
 370     type_register_static(&pc_dimm_info);
 371 }
 372
 373 type_init(pc_dimm_register_types)