Commit cc8f8ba7 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/ehabkost/tags/machine-next-pull-request' into staging 



Machine queue, 2018-05-07

* pc-dimm: factor out MemoryDevice
  (virtio-pmem and virtio-mem will make use of the new abstraction later)
* scripts/device-crash-test: Removed fixed CAN entries

# gpg: Signature made Mon 07 May 2018 18:01:42 BST
# gpg:                using RSA key 2807936F984DC5A6
# gpg: Good signature from "Eduardo Habkost <ehabkost@redhat.com>"
# Primary key fingerprint: 5A32 2FD5 ABC4 D3DB ACCF  D1AA 2807 936F 984D C5A6

* remotes/ehabkost/tags/machine-next-pull-request:
  scripts/device-crash-test: Removed fixed CAN entries
  vl: allow 'maxmem' without 'slot'
  spapr: rename "hotplug memory" terminology to "device memory"
  pc: rename "hotplug memory" terminology to "device memory"
  machine: rename MemoryHotplugState to DeviceMemoryState
  pc-dimm: move actual plug/unplug of a memory region to MemoryDevice
  pc-dimm: factor out capacity and slot checks into MemoryDevice
  pc-dimm: factor out address search into MemoryDevice code
  pc-dimm: pass in the machine and to the MemoryHotplugState
  pc-dimm: no need to pass the memory region
  machine: make MemoryHotplugState accessible via the machine
  pc-dimm: factor out MemoryDevice interface

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents d01beac1 b40dffde

hw/i386/acpi-build.c

+4 −3
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ 
#include "hw/acpi/vmgenid.h"

#include "sysemu/tpm_backend.h"

#include "hw/timer/mc146818rtc_regs.h"

#include "hw/mem/memory-device.h"

#include "sysemu/numa.h"



/* Supported chipsets: */
@@ -2253,7 +2254,7 @@ build_tpm2(GArray *table_data, BIOSLinker *linker, GArray *tcpalog) 
static void build_srat_hotpluggable_memory(GArray *table_data, uint64_t base,

                                           uint64_t len, int default_node)

{

    MemoryDeviceInfoList *info_list = qmp_pc_dimm_device_list();

    MemoryDeviceInfoList *info_list = qmp_memory_device_list();

    MemoryDeviceInfoList *info;

    MemoryDeviceInfo *mi;

    PCDIMMDeviceInfo *di;
@@ -2312,7 +2313,7 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine) 
    const CPUArchIdList *apic_ids = mc->possible_cpu_arch_ids(machine);

    PCMachineState *pcms = PC_MACHINE(machine);

    ram_addr_t hotplugabble_address_space_size =

        object_property_get_int(OBJECT(pcms), PC_MACHINE_MEMHP_REGION_SIZE,

        object_property_get_int(OBJECT(pcms), PC_MACHINE_DEVMEM_REGION_SIZE,

                                NULL);



    srat_start = table_data->len;
@@ -2410,7 +2411,7 @@ build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine) 
     * providing _PXM method if necessary.

     */

    if (hotplugabble_address_space_size) {

        build_srat_hotpluggable_memory(table_data, pcms->hotplug_memory.base,

        build_srat_hotpluggable_memory(table_data, machine->device_memory->base,

                                       hotplugabble_address_space_size,

                                       pcms->numa_nodes - 1);

    }

hw/i386/pc.c

+30 −35
Original line number Diff line number Diff line
@@ -1371,11 +1371,13 @@ void pc_memory_init(PCMachineState *pcms, 
        exit(EXIT_FAILURE);

    }



    /* initialize hotplug memory address space */

    /* always allocate the device memory information */

    machine->device_memory = g_malloc0(sizeof(*machine->device_memory));



    /* initialize device memory address space */

    if (pcmc->has_reserved_memory &&

        (machine->ram_size < machine->maxram_size)) {

        ram_addr_t hotplug_mem_size =

            machine->maxram_size - machine->ram_size;

        ram_addr_t device_mem_size = machine->maxram_size - machine->ram_size;



        if (machine->ram_slots > ACPI_MAX_RAM_SLOTS) {

            error_report("unsupported amount of memory slots: %"PRIu64,
@@ -1390,25 +1392,25 @@ void pc_memory_init(PCMachineState *pcms, 
            exit(EXIT_FAILURE);

        }



        pcms->hotplug_memory.base =

        machine->device_memory->base =

            ROUND_UP(0x100000000ULL + pcms->above_4g_mem_size, 1ULL << 30);



        if (pcmc->enforce_aligned_dimm) {

            /* size hotplug region assuming 1G page max alignment per slot */

            hotplug_mem_size += (1ULL << 30) * machine->ram_slots;

            /* size device region assuming 1G page max alignment per slot */

            device_mem_size += (1ULL << 30) * machine->ram_slots;

        }



        if ((pcms->hotplug_memory.base + hotplug_mem_size) <

            hotplug_mem_size) {

        if ((machine->device_memory->base + device_mem_size) <

            device_mem_size) {

            error_report("unsupported amount of maximum memory: " RAM_ADDR_FMT,

                         machine->maxram_size);

            exit(EXIT_FAILURE);

        }



        memory_region_init(&pcms->hotplug_memory.mr, OBJECT(pcms),

                           "hotplug-memory", hotplug_mem_size);

        memory_region_add_subregion(system_memory, pcms->hotplug_memory.base,

                                    &pcms->hotplug_memory.mr);

        memory_region_init(&machine->device_memory->mr, OBJECT(pcms),

                           "device-memory", device_mem_size);

        memory_region_add_subregion(system_memory, machine->device_memory->base,

                                    &machine->device_memory->mr);

    }



    /* Initialize PC system firmware */
@@ -1429,13 +1431,13 @@ void pc_memory_init(PCMachineState *pcms, 


    rom_set_fw(fw_cfg);



    if (pcmc->has_reserved_memory && pcms->hotplug_memory.base) {

    if (pcmc->has_reserved_memory && machine->device_memory->base) {

        uint64_t *val = g_malloc(sizeof(*val));

        PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);

        uint64_t res_mem_end = pcms->hotplug_memory.base;

        uint64_t res_mem_end = machine->device_memory->base;



        if (!pcmc->broken_reserved_end) {

            res_mem_end += memory_region_size(&pcms->hotplug_memory.mr);

            res_mem_end += memory_region_size(&machine->device_memory->mr);

        }

        *val = cpu_to_le64(ROUND_UP(res_mem_end, 0x1ULL << 30));

        fw_cfg_add_file(fw_cfg, "etc/reserved-memory-end", val, sizeof(*val));
@@ -1462,12 +1464,13 @@ uint64_t pc_pci_hole64_start(void) 
{

    PCMachineState *pcms = PC_MACHINE(qdev_get_machine());

    PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);

    MachineState *ms = MACHINE(pcms);

    uint64_t hole64_start = 0;



    if (pcmc->has_reserved_memory && pcms->hotplug_memory.base) {

        hole64_start = pcms->hotplug_memory.base;

    if (pcmc->has_reserved_memory && ms->device_memory->base) {

        hole64_start = ms->device_memory->base;

        if (!pcmc->broken_reserved_end) {

            hole64_start += memory_region_size(&pcms->hotplug_memory.mr);

            hole64_start += memory_region_size(&ms->device_memory->mr);

        }

    } else {

        hole64_start = 0x100000000ULL + pcms->above_4g_mem_size;
@@ -1711,7 +1714,7 @@ static void pc_dimm_plug(HotplugHandler *hotplug_dev, 
        goto out;

    }



    pc_dimm_memory_plug(dev, &pcms->hotplug_memory, mr, align, &local_err);

    pc_dimm_memory_plug(dev, MACHINE(pcms), align, &local_err);

    if (local_err) {

        goto out;

    }
@@ -1761,17 +1764,9 @@ static void pc_dimm_unplug(HotplugHandler *hotplug_dev, 
                           DeviceState *dev, Error **errp)

{

    PCMachineState *pcms = PC_MACHINE(hotplug_dev);

    PCDIMMDevice *dimm = PC_DIMM(dev);

    PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);

    MemoryRegion *mr;

    HotplugHandlerClass *hhc;

    Error *local_err = NULL;



    mr = ddc->get_memory_region(dimm, &local_err);

    if (local_err) {

        goto out;

    }



    hhc = HOTPLUG_HANDLER_GET_CLASS(pcms->acpi_dev);

    hhc->unplug(HOTPLUG_HANDLER(pcms->acpi_dev), dev, &local_err);
@@ -1779,7 +1774,7 @@ static void pc_dimm_unplug(HotplugHandler *hotplug_dev, 
        goto out;

    }



    pc_dimm_memory_unplug(dev, &pcms->hotplug_memory, mr);

    pc_dimm_memory_unplug(dev, MACHINE(pcms));

    object_unparent(OBJECT(dev));



 out:
@@ -2068,12 +2063,12 @@ static HotplugHandler *pc_get_hotpug_handler(MachineState *machine, 
}



static void

pc_machine_get_hotplug_memory_region_size(Object *obj, Visitor *v,

pc_machine_get_device_memory_region_size(Object *obj, Visitor *v,

                                         const char *name, void *opaque,

                                         Error **errp)

{

    PCMachineState *pcms = PC_MACHINE(obj);

    int64_t value = memory_region_size(&pcms->hotplug_memory.mr);

    MachineState *ms = MACHINE(obj);

    int64_t value = memory_region_size(&ms->device_memory->mr);



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

}
@@ -2377,8 +2372,8 @@ static void pc_machine_class_init(ObjectClass *oc, void *data) 
    nc->nmi_monitor_handler = x86_nmi;

    mc->default_cpu_type = TARGET_DEFAULT_CPU_TYPE;



    object_class_property_add(oc, PC_MACHINE_MEMHP_REGION_SIZE, "int",

        pc_machine_get_hotplug_memory_region_size, NULL,

    object_class_property_add(oc, PC_MACHINE_DEVMEM_REGION_SIZE, "int",

        pc_machine_get_device_memory_region_size, NULL,

        NULL, NULL, &error_abort);



    object_class_property_add(oc, PC_MACHINE_MAX_RAM_BELOW_4G, "size",

hw/mem/Makefile.objs

+1 −0
Original line number Diff line number Diff line 
common-obj-$(CONFIG_MEM_HOTPLUG) += pc-dimm.o

common-obj-$(CONFIG_MEM_HOTPLUG) += memory-device.o

common-obj-$(CONFIG_NVDIMM) += nvdimm.o

hw/mem/memory-device.c

0 → 100644
+275 −0
Original line number Diff line number Diff line 
/*

 * Memory Device Interface

 *

 * Copyright ProfitBricks GmbH 2012

 * Copyright (C) 2014 Red Hat Inc

 * Copyright (c) 2018 Red Hat Inc

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 */



#include "qemu/osdep.h"

#include "hw/mem/memory-device.h"

#include "hw/qdev.h"

#include "qapi/error.h"

#include "hw/boards.h"

#include "qemu/range.h"

#include "hw/virtio/vhost.h"

#include "sysemu/kvm.h"



static gint memory_device_addr_sort(gconstpointer a, gconstpointer b)

{

    const MemoryDeviceState *md_a = MEMORY_DEVICE(a);

    const MemoryDeviceState *md_b = MEMORY_DEVICE(b);

    const MemoryDeviceClass *mdc_a = MEMORY_DEVICE_GET_CLASS(a);

    const MemoryDeviceClass *mdc_b = MEMORY_DEVICE_GET_CLASS(b);

    const uint64_t addr_a = mdc_a->get_addr(md_a);

    const uint64_t addr_b = mdc_b->get_addr(md_b);



    if (addr_a > addr_b) {

        return 1;

    } else if (addr_a < addr_b) {

        return -1;

    }

    return 0;

}



static int memory_device_build_list(Object *obj, void *opaque)

{

    GSList **list = opaque;



    if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {

        DeviceState *dev = DEVICE(obj);

        if (dev->realized) { /* only realized memory devices matter */

            *list = g_slist_insert_sorted(*list, dev, memory_device_addr_sort);

        }

    }



    object_child_foreach(obj, memory_device_build_list, opaque);

    return 0;

}



static int memory_device_used_region_size(Object *obj, void *opaque)

{

    uint64_t *size = opaque;



    if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {

        const DeviceState *dev = DEVICE(obj);

        const MemoryDeviceState *md = MEMORY_DEVICE(obj);

        const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj);



        if (dev->realized) {

            *size += mdc->get_region_size(md);

        }

    }



    object_child_foreach(obj, memory_device_used_region_size, opaque);

    return 0;

}



static void memory_device_check_addable(MachineState *ms, uint64_t size,

                                        Error **errp)

{

    uint64_t used_region_size = 0;



    /* we will need a new memory slot for kvm and vhost */

    if (kvm_enabled() && !kvm_has_free_slot(ms)) {

        error_setg(errp, "hypervisor has no free memory slots left");

        return;

    }

    if (!vhost_has_free_slot()) {

        error_setg(errp, "a used vhost backend has no free memory slots left");

        return;

    }



    /* will we exceed the total amount of memory specified */

    memory_device_used_region_size(OBJECT(ms), &used_region_size);

    if (used_region_size + size > ms->maxram_size - ms->ram_size) {

        error_setg(errp, "not enough space, currently 0x%" PRIx64

                   " in use of total hot pluggable 0x" RAM_ADDR_FMT,

                   used_region_size, ms->maxram_size - ms->ram_size);

        return;

    }



}



uint64_t memory_device_get_free_addr(MachineState *ms, const uint64_t *hint,

                                     uint64_t align, uint64_t size,

                                     Error **errp)

{

    uint64_t address_space_start, address_space_end;

    GSList *list = NULL, *item;

    uint64_t new_addr = 0;



    if (!ms->device_memory) {

        error_setg(errp, "memory devices (e.g. for memory hotplug) are not "

                         "supported by the machine");

        return 0;

    }



    if (!memory_region_size(&ms->device_memory->mr)) {

        error_setg(errp, "memory devices (e.g. for memory hotplug) are not "

                         "enabled, please specify the maxmem option");

        return 0;

    }

    address_space_start = ms->device_memory->base;

    address_space_end = address_space_start +

                        memory_region_size(&ms->device_memory->mr);

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

    g_assert(address_space_end >= address_space_start);



    memory_device_check_addable(ms, size, errp);

    if (*errp) {

        return 0;

    }



    if (hint && QEMU_ALIGN_UP(*hint, align) != *hint) {

        error_setg(errp, "address must be aligned to 0x%" PRIx64 " bytes",

                   align);

        return 0;

    }



    if (QEMU_ALIGN_UP(size, align) != size) {

        error_setg(errp, "backend memory size must be multiple of 0x%"

                   PRIx64, align);

        return 0;

    }



    if (hint) {

        new_addr = *hint;

        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);

            return 0;

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

            return 0;

        }

    } else {

        new_addr = address_space_start;

    }



    /* find address range that will fit new memory device */

    object_child_foreach(OBJECT(ms), memory_device_build_list, &list);

    for (item = list; item; item = g_slist_next(item)) {

        const MemoryDeviceState *md = item->data;

        const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(OBJECT(md));

        uint64_t md_size, md_addr;



        md_addr = mdc->get_addr(md);

        md_size = mdc->get_region_size(md);

        if (*errp) {

            goto out;

        }



        if (ranges_overlap(md_addr, md_size, new_addr, size)) {

            if (hint) {

                const DeviceState *d = DEVICE(md);

                error_setg(errp, "address range conflicts with '%s'", d->id);

                goto out;

            }

            new_addr = QEMU_ALIGN_UP(md_addr + md_size, align);

        }

    }



    if (new_addr + size > address_space_end) {

        error_setg(errp, "could not find position in guest address space for "

                   "memory device - memory fragmented due to alignments");

        goto out;

    }

out:

    g_slist_free(list);

    return new_addr;

}



MemoryDeviceInfoList *qmp_memory_device_list(void)

{

    GSList *devices = NULL, *item;

    MemoryDeviceInfoList *list = NULL, *prev = NULL;



    object_child_foreach(qdev_get_machine(), memory_device_build_list,

                         &devices);



    for (item = devices; item; item = g_slist_next(item)) {

        const MemoryDeviceState *md = MEMORY_DEVICE(item->data);

        const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(item->data);

        MemoryDeviceInfoList *elem = g_new0(MemoryDeviceInfoList, 1);

        MemoryDeviceInfo *info = g_new0(MemoryDeviceInfo, 1);



        mdc->fill_device_info(md, info);



        elem->value = info;

        elem->next = NULL;

        if (prev) {

            prev->next = elem;

        } else {

            list = elem;

        }

        prev = elem;

    }



    g_slist_free(devices);



    return list;

}



static int memory_device_plugged_size(Object *obj, void *opaque)

{

    uint64_t *size = opaque;



    if (object_dynamic_cast(obj, TYPE_MEMORY_DEVICE)) {

        const DeviceState *dev = DEVICE(obj);

        const MemoryDeviceState *md = MEMORY_DEVICE(obj);

        const MemoryDeviceClass *mdc = MEMORY_DEVICE_GET_CLASS(obj);



        if (dev->realized) {

            *size += mdc->get_plugged_size(md);

        }

    }



    object_child_foreach(obj, memory_device_plugged_size, opaque);

    return 0;

}



uint64_t get_plugged_memory_size(void)

{

    uint64_t size = 0;



    memory_device_plugged_size(qdev_get_machine(), &size);



    return size;

}



void memory_device_plug_region(MachineState *ms, MemoryRegion *mr,

                               uint64_t addr)

{

    /* we expect a previous call to memory_device_get_free_addr() */

    g_assert(ms->device_memory);



    memory_region_add_subregion(&ms->device_memory->mr,

                                addr - ms->device_memory->base, mr);

}



void memory_device_unplug_region(MachineState *ms, MemoryRegion *mr)

{

    /* we expect a previous call to memory_device_get_free_addr() */

    g_assert(ms->device_memory);



    memory_region_del_subregion(&ms->device_memory->mr, mr);

}



static const TypeInfo memory_device_info = {

    .name          = TYPE_MEMORY_DEVICE,

    .parent        = TYPE_INTERFACE,

    .class_size = sizeof(MemoryDeviceClass),

};



static void memory_device_register_types(void)

{

    type_register_static(&memory_device_info);

}



type_init(memory_device_register_types)

hw/mem/pc-dimm.c

+76 −228

File changed.

Preview size limit exceeded, changes collapsed.