[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 "hw/mem/pc-dimm.h"
#include "qemu/config-file.h"
#include "qapi/visitor.h"
#include "qemu/range.h"
#include "sysemu/numa.h"

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

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_int(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_int(OBJECT(dimm), PC_DIMM_SIZE_PROP,
                                               NULL);
            di->memdev = object_get_canonical_path(OBJECT(dimm->hostmem));

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

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

ram_addr_t get_current_ram_size(void)
{
    MemoryDeviceInfoList *info_list = NULL;
    MemoryDeviceInfoList **prev = &info_list;
    MemoryDeviceInfoList *info;
    ram_addr_t size = ram_size;

    qmp_pc_dimm_device_list(qdev_get_machine(), &prev);
    for (info = info_list; info; info = info->next) {
        MemoryDeviceInfo *value = info->value;

        if (value) {
            switch (value->kind) {
            case MEMORY_DEVICE_INFO_KIND_DIMM:
                size += value->dimm->size;
                break;
            default:
                break;
            }
        }
    }
    qapi_free_MemoryDeviceInfoList(info_list);

    return size;
}

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);
    g_assert(QEMU_ALIGN_UP(address_space_size, align) == address_space_size);

    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_int(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, void *opaque,
                          const char *name, Error **errp)
{
    int64_t value;
    MemoryRegion *mr;
    PCDIMMDevice *dimm = PC_DIMM(obj);

    mr = host_memory_backend_get_memory(dimm->hostmem, errp);
    value = memory_region_size(mr);

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

static void pc_dimm_check_memdev_is_busy(Object *obj, const char *name,
                                      Object *val, Error **errp)
{
    MemoryRegion *mr;

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

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

    object_property_add(obj, PC_DIMM_SIZE_PROP, "int", 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);

    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)) {
        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);
        return;
    }
}

static MemoryRegion *pc_dimm_get_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->props = pc_dimm_properties;
    dc->desc = "DIMM memory module";

    ddc->get_memory_region = pc_dimm_get_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
	21	#include "hw/mem/pc-dimm.h"
	22	#include "qemu/config-file.h"
	23	#include "qapi/visitor.h"
0b312571	24	#include "qemu/range.h"
e35704ba	25	#include "sysemu/numa.h"
9967c949	26
37153450 BR	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)
9967c949	33	{
37153450 BR	34	pc_dimms_capacity *cap = opaque;
37153450 BR	35	uint64_t *size = &cap->size;
9967c949 BR	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,
37153450	42	cap->errp);
9967c949 BR	43	}
9967c949 BR	44
37153450	45	if (cap->errp && *cap->errp) {
9967c949 BR	46	return 1;
	47	}
	48	}
37153450	49	object_child_foreach(obj, pc_existing_dimms_capacity_internal, opaque);
9967c949 BR	50	return 0;
9967c949 BR	51	}
0b312571	52
37153450 BR	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
6f2e2730 IM	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
87a45cfe HZ	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
0cd03d89 IM	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
0b312571 IM	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,
92a37a04	206	uint64_t *hint, uint64_t align, uint64_t size,
0b312571 IM	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
0c0de1b6 IM	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
9b79a76c IM	216	if (!address_space_size) {
	217	error_setg(errp, "memory hotplug is not enabled, "
	218	"please add maxmem option");
	219	goto out;
	220	}
	221
92a37a04 IM	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
9b79a76c	234	assert(address_space_end > address_space_start);
0b312571 IM	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	}
0c0de1b6	259	new_addr = QEMU_ALIGN_UP(dimm->addr + dimm_size, align);
0b312571 IM	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	}
10b7e74b VL	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
7bb5d6ad IM	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
10b7e74b VL	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,
7bb5d6ad	321	pc_dimm_check_memdev_is_busy,
10b7e74b VL	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	}
fc50ff06	334	if ((nb_numa_nodes > 0) && (dimm->node >= nb_numa_nodes)) {
988eba0f MT	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);
cfe0ffd0 HT	338	return;
cfe0ffd0 HT	339	}
10b7e74b VL	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;
bdd09778	354	dc->desc = "DIMM memory module";
10b7e74b VL	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)