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