[mirror_qemu.git] / hw / mem / pc-dimm.c

/*
 * Dimm device for Memory Hotplug
 *
 * Copyright ProfitBricks GmbH 2012
 * Copyright (C) 2014 Red Hat Inc
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>
 */

#include "qemu/osdep.h"
#include "hw/mem/pc-dimm.h"
#include "qapi/error.h"
#include "qemu/config-file.h"
#include "qapi/visitor.h"
#include "qemu/range.h"
#include "sysemu/numa.h"
#include "sysemu/kvm.h"
#include "trace.h"
#include "hw/virtio/vhost.h"

typedef struct pc_dimms_capacity {
     uint64_t size;
     Error    **errp;
} pc_dimms_capacity;

void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
                         MemoryRegion *mr, uint64_t align, Error **errp)
{
    int slot;
    MachineState *machine = MACHINE(qdev_get_machine());
    PCDIMMDevice *dimm = PC_DIMM(dev);
    PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);
    MemoryRegion *vmstate_mr = ddc->get_vmstate_memory_region(dimm);
    Error *local_err = NULL;
    uint64_t existing_dimms_capacity = 0;
    uint64_t addr;

    addr = object_property_get_uint(OBJECT(dimm),
                                    PC_DIMM_ADDR_PROP, &local_err);
    if (local_err) {
        goto out;
    }

    addr = pc_dimm_get_free_addr(hpms->base,
                                 memory_region_size(&hpms->mr),
                                 !addr ? NULL : &addr, align,
                                 memory_region_size(mr), &local_err);
    if (local_err) {
        goto out;
    }

    existing_dimms_capacity = pc_existing_dimms_capacity(&local_err);
    if (local_err) {
        goto out;
    }

    if (existing_dimms_capacity + memory_region_size(mr) >
        machine->maxram_size - machine->ram_size) {
        error_setg(&local_err, "not enough space, currently 0x%" PRIx64
                   " in use of total hot pluggable 0x" RAM_ADDR_FMT,
                   existing_dimms_capacity,
                   machine->maxram_size - machine->ram_size);
        goto out;
    }

    object_property_set_uint(OBJECT(dev), addr, PC_DIMM_ADDR_PROP, &local_err);
    if (local_err) {
        goto out;
    }
    trace_mhp_pc_dimm_assigned_address(addr);

    slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP, &local_err);
    if (local_err) {
        goto out;
    }

    slot = pc_dimm_get_free_slot(slot == PC_DIMM_UNASSIGNED_SLOT ? NULL : &slot,
                                 machine->ram_slots, &local_err);
    if (local_err) {
        goto out;
    }
    object_property_set_int(OBJECT(dev), slot, PC_DIMM_SLOT_PROP, &local_err);
    if (local_err) {
        goto out;
    }
    trace_mhp_pc_dimm_assigned_slot(slot);

    if (kvm_enabled() && !kvm_has_free_slot(machine)) {
        error_setg(&local_err, "hypervisor has no free memory slots left");
        goto out;
    }

    if (!vhost_has_free_slot()) {
        error_setg(&local_err, "a used vhost backend has no free"
                               " memory slots left");
        goto out;
    }

    memory_region_add_subregion(&hpms->mr, addr - hpms->base, mr);
    vmstate_register_ram(vmstate_mr, dev);
    numa_set_mem_node_id(addr, memory_region_size(mr), dimm->node);

out:
    error_propagate(errp, local_err);
}

void pc_dimm_memory_unplug(DeviceState *dev, MemoryHotplugState *hpms,
                           MemoryRegion *mr)
{
    PCDIMMDevice *dimm = PC_DIMM(dev);
    PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);
    MemoryRegion *vmstate_mr = ddc->get_vmstate_memory_region(dimm);

    numa_unset_mem_node_id(dimm->addr, memory_region_size(mr), dimm->node);
    memory_region_del_subregion(&hpms->mr, mr);
    vmstate_unregister_ram(vmstate_mr, dev);
}

static int pc_existing_dimms_capacity_internal(Object *obj, void *opaque)
{
    pc_dimms_capacity *cap = opaque;
    uint64_t *size = &cap->size;

    if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
        DeviceState *dev = DEVICE(obj);

        if (dev->realized) {
            (*size) += object_property_get_uint(obj, PC_DIMM_SIZE_PROP,
                cap->errp);
        }

        if (cap->errp && *cap->errp) {
            return 1;
        }
    }
    object_child_foreach(obj, pc_existing_dimms_capacity_internal, opaque);
    return 0;
}

uint64_t pc_existing_dimms_capacity(Error **errp)
{
    pc_dimms_capacity cap;

    cap.size = 0;
    cap.errp = errp;

    pc_existing_dimms_capacity_internal(qdev_get_machine(), &cap);
    return cap.size;
}

int qmp_pc_dimm_device_list(Object *obj, void *opaque)
{
    MemoryDeviceInfoList ***prev = opaque;

    if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
        DeviceState *dev = DEVICE(obj);

        if (dev->realized) {
            MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);
            MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);
            PCDIMMDeviceInfo *di = g_new0(PCDIMMDeviceInfo, 1);
            DeviceClass *dc = DEVICE_GET_CLASS(obj);
            PCDIMMDevice *dimm = PC_DIMM(obj);

            if (dev->id) {
                di->has_id = true;
                di->id = g_strdup(dev->id);
            }
            di->hotplugged = dev->hotplugged;
            di->hotpluggable = dc->hotpluggable;
            di->addr = dimm->addr;
            di->slot = dimm->slot;
            di->node = dimm->node;
            di->size = object_property_get_uint(OBJECT(dimm), PC_DIMM_SIZE_PROP,
                                                NULL);
            di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem));

            info->u.dimm.data = di;
            elem->value = info;
            elem->next = NULL;
            **prev = elem;
            *prev = &elem->next;
        }
    }

    object_child_foreach(obj, qmp_pc_dimm_device_list, opaque);
    return 0;
}

static int pc_dimm_slot2bitmap(Object *obj, void *opaque)
{
    unsigned long *bitmap = opaque;

    if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
        DeviceState *dev = DEVICE(obj);
        if (dev->realized) { /* count only realized DIMMs */
            PCDIMMDevice *d = PC_DIMM(obj);
            set_bit(d->slot, bitmap);
        }
    }

    object_child_foreach(obj, pc_dimm_slot2bitmap, opaque);
    return 0;
}

int pc_dimm_get_free_slot(const int *hint, int max_slots, Error **errp)
{
    unsigned long *bitmap = bitmap_new(max_slots);
    int slot = 0;

    object_child_foreach(qdev_get_machine(), pc_dimm_slot2bitmap, bitmap);

    /* check if requested slot is not occupied */
    if (hint) {
        if (*hint >= max_slots) {
            error_setg(errp, "invalid slot# %d, should be less than %d",
                       *hint, max_slots);
        } else if (!test_bit(*hint, bitmap)) {
            slot = *hint;
        } else {
            error_setg(errp, "slot %d is busy", *hint);
        }
        goto out;
    }

    /* search for free slot */
    slot = find_first_zero_bit(bitmap, max_slots);
    if (slot == max_slots) {
        error_setg(errp, "no free slots available");
    }
out:
    g_free(bitmap);
    return slot;
}

static gint pc_dimm_addr_sort(gconstpointer a, gconstpointer b)
{
    PCDIMMDevice *x = PC_DIMM(a);
    PCDIMMDevice *y = PC_DIMM(b);
    Int128 diff = int128_sub(int128_make64(x->addr), int128_make64(y->addr));

    if (int128_lt(diff, int128_zero())) {
        return -1;
    } else if (int128_gt(diff, int128_zero())) {
        return 1;
    }
    return 0;
}

static int pc_dimm_built_list(Object *obj, void *opaque)
{
    GSList **list = opaque;

    if (object_dynamic_cast(obj, TYPE_PC_DIMM)) {
        DeviceState *dev = DEVICE(obj);
        if (dev->realized) { /* only realized DIMMs matter */
            *list = g_slist_insert_sorted(*list, dev, pc_dimm_addr_sort);
        }
    }

    object_child_foreach(obj, pc_dimm_built_list, opaque);
    return 0;
}

uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
                               uint64_t address_space_size,
                               uint64_t *hint, uint64_t align, uint64_t size,
                               Error **errp)
{
    GSList *list = NULL, *item;
    uint64_t new_addr, ret = 0;
    uint64_t address_space_end = address_space_start + address_space_size;

    g_assert(QEMU_ALIGN_UP(address_space_start, align) == address_space_start);

    if (!address_space_size) {
        error_setg(errp, "memory hotplug is not enabled, "
                         "please add maxmem option");
        goto out;
    }

    if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) {
        error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes",
                   align);
        goto out;
    }

    if (QEMU_ALIGN_UP(size, align) != size) {
        error_setg(errp, "backend memory size must be multiple of 0x%"
                   PRIx64, align);
        goto out;
    }

    assert(address_space_end > address_space_start);
    object_child_foreach(qdev_get_machine(), pc_dimm_built_list, &list);

    if (hint) {
        new_addr = *hint;
    } else {
        new_addr = address_space_start;
    }

    /* find address range that will fit new DIMM */
    for (item = list; item; item = g_slist_next(item)) {
        PCDIMMDevice *dimm = item->data;
        uint64_t dimm_size = object_property_get_uint(OBJECT(dimm),
                                                      PC_DIMM_SIZE_PROP,
                                                      errp);
        if (errp && *errp) {
            goto out;
        }

        if (ranges_overlap(dimm->addr, dimm_size, new_addr, size)) {
            if (hint) {
                DeviceState *d = DEVICE(dimm);
                error_setg(errp, "address range conflicts with '%s'", d->id);
                goto out;
            }
            new_addr = QEMU_ALIGN_UP(dimm->addr + dimm_size, align);
        }
    }
    ret = new_addr;

    if (new_addr < address_space_start) {
        error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
                   "] at 0x%" PRIx64, new_addr, size, address_space_start);
    } else if ((new_addr + size) > address_space_end) {
        error_setg(errp, "can't add memory [0x%" PRIx64 ":0x%" PRIx64
                   "] beyond 0x%" PRIx64, new_addr, size, address_space_end);
    }

out:
    g_slist_free(list);
    return ret;
}

static Property pc_dimm_properties[] = {
    DEFINE_PROP_UINT64(PC_DIMM_ADDR_PROP, PCDIMMDevice, addr, 0),
    DEFINE_PROP_UINT32(PC_DIMM_NODE_PROP, PCDIMMDevice, node, 0),
    DEFINE_PROP_INT32(PC_DIMM_SLOT_PROP, PCDIMMDevice, slot,
                      PC_DIMM_UNASSIGNED_SLOT),
    DEFINE_PROP_END_OF_LIST(),
};

static void pc_dimm_get_size(Object *obj, Visitor *v, const char *name,
                             void *opaque, Error **errp)
{
    uint64_t value;
    MemoryRegion *mr;
    PCDIMMDevice *dimm = PC_DIMM(obj);
    PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(obj);

    mr = ddc->get_memory_region(dimm);
    value = memory_region_size(mr);

    visit_type_uint64(v, name, &value, errp);
}

static void pc_dimm_check_memdev_is_busy(const Object *obj, const char *name,
                                      Object *val, Error **errp)
{
    Error *local_err = NULL;

    if (host_memory_backend_is_mapped(MEMORY_BACKEND(val))) {
        char *path = object_get_canonical_path_component(val);
        error_setg(&local_err, "can't use already busy memdev: %s", path);
        g_free(path);
    } else {
        qdev_prop_allow_set_link_before_realize(obj, name, val, &local_err);
    }

    error_propagate(errp, local_err);
}

static void pc_dimm_init(Object *obj)
{
    PCDIMMDevice *dimm = PC_DIMM(obj);

    object_property_add(obj, PC_DIMM_SIZE_PROP, "uint64", pc_dimm_get_size,
                        NULL, NULL, NULL, &error_abort);
    object_property_add_link(obj, PC_DIMM_MEMDEV_PROP, TYPE_MEMORY_BACKEND,
                             (Object **)&dimm->hostmem,
                             pc_dimm_check_memdev_is_busy,
                             OBJ_PROP_LINK_UNREF_ON_RELEASE,
                             &error_abort);
}

static void pc_dimm_realize(DeviceState *dev, Error **errp)
{
    PCDIMMDevice *dimm = PC_DIMM(dev);
    PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);

    if (!dimm->hostmem) {
        error_setg(errp, "'" PC_DIMM_MEMDEV_PROP "' property is not set");
        return;
    }
    if (((nb_numa_nodes > 0) && (dimm->node >= nb_numa_nodes)) ||
        (!nb_numa_nodes && dimm->node)) {
        error_setg(errp, "'DIMM property " PC_DIMM_NODE_PROP " has value %"
                   PRIu32 "' which exceeds the number of numa nodes: %d",
                   dimm->node, nb_numa_nodes ? nb_numa_nodes : 1);
        return;
    }

    if (ddc->realize) {
        ddc->realize(dimm, errp);
    }

    host_memory_backend_set_mapped(dimm->hostmem, true);
}

static void pc_dimm_unrealize(DeviceState *dev, Error **errp)
{
    PCDIMMDevice *dimm = PC_DIMM(dev);

    host_memory_backend_set_mapped(dimm->hostmem, false);
}

static MemoryRegion *pc_dimm_get_memory_region(PCDIMMDevice *dimm)
{
    return host_memory_backend_get_memory(dimm->hostmem, &error_abort);
}

static MemoryRegion *pc_dimm_get_vmstate_memory_region(PCDIMMDevice *dimm)
{
    return host_memory_backend_get_memory(dimm->hostmem, &error_abort);
}

static void pc_dimm_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);
    PCDIMMDeviceClass *ddc = PC_DIMM_CLASS(oc);

    dc->realize = pc_dimm_realize;
    dc->unrealize = pc_dimm_unrealize;
    dc->props = pc_dimm_properties;
    dc->desc = "DIMM memory module";

    ddc->get_memory_region = pc_dimm_get_memory_region;
    ddc->get_vmstate_memory_region = pc_dimm_get_vmstate_memory_region;
}

static TypeInfo pc_dimm_info = {
    .name          = TYPE_PC_DIMM,
    .parent        = TYPE_DEVICE,
    .instance_size = sizeof(PCDIMMDevice),
    .instance_init = pc_dimm_init,
    .class_init    = pc_dimm_class_init,
    .class_size    = sizeof(PCDIMMDeviceClass),
};

static void pc_dimm_register_types(void)
{
    type_register_static(&pc_dimm_info);
}

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