The following changes since commit e5cd695266c5709308aa95b1baae499e4b5d4544:

Merge remote-tracking branch 'remotes/cody/tags/block-pull-request' into staging (2018-05-08 17:05:58 +0100)

git://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20180510

for you to fetch changes up to 9a9f1f59521f46e8ff4527d9a2b52f83577e2aa3:

target/arm: Clear SVE high bits for FMOV (2018-05-10 18:10:58 +0100)

* hw/arm/iotkit.c: fix minor memory leak

* softfloat: fix wrong-exception-flags bug for multiply-add corner case

* arm: isolate and clean up DTB generation

* implement Arm v8.1-Atomics extension

* Fix some bugs and missing instructions in the v8.2-FP16 extension

Igor Mammedov (4):

pc: simplify MachineClass::get_hotplug_handler handling

platform-bus-device: use device plug callback instead of machine_done notifier

arm/boot: split load_dtb() from arm_load_kernel()

make sure that we aren't overwriting mc->get_hotplug_handler by accident

Peter Maydell (3):

hw/arm/iotkit.c: fix minor memory leak

softfloat: Handle default NaN mode after pickNaNMulAdd, not before

atomic.h: Work around gcc spurious "unused value" warning

Richard Henderson (14):

tcg: Introduce helpers for integer min/max

target/arm: Use new min/max expanders

target/xtensa: Use new min/max expanders

tcg: Introduce atomic helpers for integer min/max

tcg: Use GEN_ATOMIC_HELPER_FN for opposite endian atomic add

target/riscv: Use new atomic min/max expanders

target/arm: Introduce ARM_FEATURE_V8_ATOMICS and initial decode

target/arm: Fill in disas_ldst_atomic

target/arm: Implement CAS and CASP

target/arm: Enable ARM_FEATURE_V8_ATOMICS for user-only

target/arm: Implement vector shifted SCVF/UCVF for fp16

target/arm: Implement vector shifted FCVT for fp16

target/arm: Fix float16 to/from int16

target/arm: Clear SVE high bits for FMOV

accel/tcg/atomic_template.h | 112 ++++++----

accel/tcg/tcg-runtime.h | 8 +

hw/ppc/e500.h | 5 +

include/hw/arm/arm.h | 45 +++-

include/hw/arm/sysbus-fdt.h | 37 +---

include/hw/arm/virt.h | 1 +

include/hw/i386/pc.h | 8 -

include/hw/platform-bus.h | 4 +-

include/qemu/atomic.h | 2 +-

target/arm/cpu.h | 1 +

target/arm/helper-a64.h | 2 +

target/arm/helper.h | 4 +-

tcg/tcg-op.h | 50 +++++

tcg/tcg.h | 8 +

fpu/softfloat.c | 52 +++--

hw/arm/boot.c | 72 ++-----

hw/arm/iotkit.c | 1 +

hw/arm/sysbus-fdt.c | 64 +-----

hw/arm/virt.c | 96 ++++++---

hw/core/platform-bus.c | 29 +--

hw/i386/pc.c | 7 +-

hw/ppc/e500.c | 38 ++--

hw/ppc/e500plat.c | 32 +++

hw/ppc/spapr.c | 1 +

hw/s390x/s390-virtio-ccw.c | 1 +

linux-user/elfload.c | 1 +

target/arm/cpu64.c | 1 +

target/arm/helper-a64.c | 43 ++++

target/arm/helper.c | 53 ++++-

target/arm/translate-a64.c | 490 +++++++++++++++++++++++++++++++++-----------

target/riscv/translate.c | 72 ++-----

target/xtensa/translate.c | 50 +++--

tcg/tcg-op.c | 48 +++++

33 files changed, 934 insertions(+), 504 deletions(-)

Coverity (CID1390573) spots that we forgot to free the

gpioname strings in a loop in the iotkit realize function.

Correct the error.

This isn't a significant leak, because this function

only ever runs once.

Reviewed-by: Peter Xu <peterx@redhat.com>

Message-id: 20180427110137.19304-1-peter.maydell@linaro.org

hw/arm/iotkit.c | 1 +

1 file changed, 1 insertion(+)

diff --git a/hw/arm/iotkit.c b/hw/arm/iotkit.c

--- a/hw/arm/iotkit.c

+++ b/hw/arm/iotkit.c

@@ -XXX,XX +XXX,XX @@ static void iotkit_realize(DeviceState *dev, Error **errp)

qdev_get_gpio_in(DEVICE(&s->ppc_irq_orgate), i));

qdev_connect_gpio_out_named(DEVICE(ppc), "irq", 0,

qdev_get_gpio_in(devs, 0));

+ g_free(gpioname);

}

iotkit_forward_sec_resp_cfg(s);

2.17.0

From: Igor Mammedov <imammedo@redhat.com>

platform-bus were using machine_done notifier to get and map

(assign irq/mmio resources) dynamically added sysbus devices

after all '-device' options had been processed.

That however creates non obvious dependencies on ordering of

machine_done notifiers and requires carefull line juggling

to keep it working. For example see comment above

create_platform_bus() and 'straitforward' arm_load_kernel()

had to converted to machine_done notifier and that lead to

yet another machine_done notifier to keep it working

arm_register_platform_bus_fdt_creator().

Instead of hiding resource assignment in platform-bus-device

to magically initialize sysbus devices, use device plug

callback and assign resources explicitly at board level

at the moment each -device option is being processed.

That adds a bunch of machine declaration boiler plate to

e500plat board, similar to ARM/x86 but gets rid of hidden

machine_done notifier and would allow to remove the dependent

notifiers in ARM code simplifying it and making code flow

easier to follow.

Signed-off-by: Igor Mammedov <imammedo@redhat.com>

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

Acked-by: David Gibson <david@gibson.dropbear.id.au>

Message-id: 1525691524-32265-3-git-send-email-imammedo@redhat.com

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

---

hw/ppc/e500.h | 5 +++++

include/hw/arm/virt.h | 1 +

include/hw/platform-bus.h | 4 ++--

hw/arm/sysbus-fdt.c | 3 ---

hw/arm/virt.c | 31 +++++++++++++++++++++++++++++++

hw/core/platform-bus.c | 29 +++++------------------------

hw/ppc/e500.c | 38 +++++++++++++++++---------------------

hw/ppc/e500plat.c | 31 +++++++++++++++++++++++++++++++

8 files changed, 92 insertions(+), 50 deletions(-)

diff --git a/hw/ppc/e500.h b/hw/ppc/e500.h

index XXXXXXX..XXXXXXX 100644

--- a/hw/ppc/e500.h

+++ b/hw/ppc/e500.h

@@ -XXX,XX +XXX,XX @@

#define PPCE500_H

#include "hw/boards.h"

+#include "hw/platform-bus.h"

typedef struct PPCE500MachineState {

/*< private >*/

MachineState parent_obj;

+ /* points to instance of TYPE_PLATFORM_BUS_DEVICE if

+ * board supports dynamic sysbus devices

+ */

+ PlatformBusDevice *pbus_dev;

} PPCE500MachineState;

typedef struct PPCE500MachineClass {

diff --git a/include/hw/arm/virt.h b/include/hw/arm/virt.h

index XXXXXXX..XXXXXXX 100644

--- a/include/hw/arm/virt.h

+++ b/include/hw/arm/virt.h

@@ -XXX,XX +XXX,XX @@ typedef struct {

typedef struct {

MachineState parent;

Notifier machine_done;

+ DeviceState *platform_bus_dev;

FWCfgState *fw_cfg;

bool secure;

bool highmem;

diff --git a/include/hw/platform-bus.h b/include/hw/platform-bus.h

index XXXXXXX..XXXXXXX 100644

--- a/include/hw/platform-bus.h

+++ b/include/hw/platform-bus.h

@@ -XXX,XX +XXX,XX @@ typedef struct PlatformBusDevice PlatformBusDevice;

struct PlatformBusDevice {

/*< private >*/

SysBusDevice parent_obj;

- Notifier notifier;

- bool done_gathering;

/*< public >*/

uint32_t mmio_size;

@@ -XXX,XX +XXX,XX @@ int platform_bus_get_irqn(PlatformBusDevice *platform_bus, SysBusDevice *sbdev,

hwaddr platform_bus_get_mmio_addr(PlatformBusDevice *pbus, SysBusDevice *sbdev,

int n);

+void platform_bus_link_device(PlatformBusDevice *pbus, SysBusDevice *sbdev);

+

#endif /* HW_PLATFORM_BUS_H */

diff --git a/hw/arm/sysbus-fdt.c b/hw/arm/sysbus-fdt.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/arm/sysbus-fdt.c

+++ b/hw/arm/sysbus-fdt.c

@@ -XXX,XX +XXX,XX @@ static void add_all_platform_bus_fdt_nodes(ARMPlatformBusFDTParams *fdt_params)

dev = qdev_find_recursive(sysbus_get_default(), TYPE_PLATFORM_BUS_DEVICE);

pbus = PLATFORM_BUS_DEVICE(dev);

- /* We can only create dt nodes for dynamic devices when they're ready */

- assert(pbus->done_gathering);

-

PlatformBusFDTData data = {

.fdt = fdt,

.irq_start = irq_start,

diff --git a/hw/arm/virt.c b/hw/arm/virt.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/arm/virt.c

+++ b/hw/arm/virt.c

@@ -XXX,XX +XXX,XX @@ static void create_platform_bus(VirtMachineState *vms, qemu_irq *pic)

qdev_prop_set_uint32(dev, "mmio_size",

platform_bus_params.platform_bus_size);

qdev_init_nofail(dev);

+ vms->platform_bus_dev = dev;

s = SYS_BUS_DEVICE(dev);

for (i = 0; i < platform_bus_params.platform_bus_num_irqs; i++) {

@@ -XXX,XX +XXX,XX @@ static const CPUArchIdList *virt_possible_cpu_arch_ids(MachineState *ms)

return ms->possible_cpus;

}

+static void virt_machine_device_plug_cb(HotplugHandler *hotplug_dev,

+ DeviceState *dev, Error **errp)

+{

+ VirtMachineState *vms = VIRT_MACHINE(hotplug_dev);

+

+ if (vms->platform_bus_dev) {

+ if (object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE)) {

+ platform_bus_link_device(PLATFORM_BUS_DEVICE(vms->platform_bus_dev),

+ SYS_BUS_DEVICE(dev));

+ }

+ }

+}

+

+static HotplugHandler *virt_machine_get_hotplug_handler(MachineState *machine,

+ DeviceState *dev)

+{

+ if (object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE)) {

+ return HOTPLUG_HANDLER(machine);

+ }

+

+ return NULL;

+}

+

static void virt_machine_class_init(ObjectClass *oc, void *data)

{

MachineClass *mc = MACHINE_CLASS(oc);

+ HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);

mc->init = machvirt_init;

/* Start max_cpus at the maximum QEMU supports. We'll further restrict

@@ -XXX,XX +XXX,XX @@ static void virt_machine_class_init(ObjectClass *oc, void *data)

mc->cpu_index_to_instance_props = virt_cpu_index_to_props;

mc->default_cpu_type = ARM_CPU_TYPE_NAME("cortex-a15");

mc->get_default_cpu_node_id = virt_get_default_cpu_node_id;

+ mc->get_hotplug_handler = virt_machine_get_hotplug_handler;

+ hc->plug = virt_machine_device_plug_cb;

}

static const TypeInfo virt_machine_info = {

@@ -XXX,XX +XXX,XX @@ static const TypeInfo virt_machine_info = {

.instance_size = sizeof(VirtMachineState),

.class_size = sizeof(VirtMachineClass),

.class_init = virt_machine_class_init,

+ .interfaces = (InterfaceInfo[]) {

+ { TYPE_HOTPLUG_HANDLER },

+ { }

+ },

};

static void machvirt_machine_init(void)

diff --git a/hw/core/platform-bus.c b/hw/core/platform-bus.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/core/platform-bus.c

+++ b/hw/core/platform-bus.c

@@ -XXX,XX +XXX,XX @@ static void plaform_bus_refresh_irqs(PlatformBusDevice *pbus)

{

bitmap_zero(pbus->used_irqs, pbus->num_irqs);

foreach_dynamic_sysbus_device(platform_bus_count_irqs, pbus);

- pbus->done_gathering = true;

}

static void platform_bus_map_irq(PlatformBusDevice *pbus, SysBusDevice *sbdev,

@@ -XXX,XX +XXX,XX @@ static void platform_bus_map_mmio(PlatformBusDevice *pbus, SysBusDevice *sbdev,

}

/*

- * For each sysbus device, look for unassigned IRQ lines as well as

- * unassociated MMIO regions. Connect them to the platform bus if available.

+ * Look for unassigned IRQ lines as well as unassociated MMIO regions.

+ * Connect them to the platform bus if available.

*/

-static void link_sysbus_device(SysBusDevice *sbdev, void *opaque)

+void platform_bus_link_device(PlatformBusDevice *pbus, SysBusDevice *sbdev)

{

- PlatformBusDevice *pbus = opaque;

int i;

for (i = 0; sysbus_has_irq(sbdev, i); i++) {

@@ -XXX,XX +XXX,XX @@ static void link_sysbus_device(SysBusDevice *sbdev, void *opaque)

}

}

-static void platform_bus_init_notify(Notifier *notifier, void *data)

-{

- PlatformBusDevice *pb = container_of(notifier, PlatformBusDevice, notifier);

-

- /*

- * Generate a bitmap of used IRQ lines, as the user might have specified

- * them on the command line.

- */

- plaform_bus_refresh_irqs(pb);

-

- foreach_dynamic_sysbus_device(link_sysbus_device, pb);

-}

-

static void platform_bus_realize(DeviceState *dev, Error **errp)

{

PlatformBusDevice *pbus;

@@ -XXX,XX +XXX,XX @@ static void platform_bus_realize(DeviceState *dev, Error **errp)

sysbus_init_irq(d, &pbus->irqs[i]);

}

- /*

- * Register notifier that allows us to gather dangling devices once the

- * machine is completely assembled

- */

- pbus->notifier.notify = platform_bus_init_notify;

- qemu_add_machine_init_done_notifier(&pbus->notifier);

+ /* some devices might be initialized before so update used IRQs map */

+ plaform_bus_refresh_irqs(pbus);

}

static Property platform_bus_properties[] = {

diff --git a/hw/ppc/e500.c b/hw/ppc/e500.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/ppc/e500.c

+++ b/hw/ppc/e500.c

@@ -XXX,XX +XXX,XX @@ static void sysbus_device_create_devtree(SysBusDevice *sbdev, void *opaque)

}

}

-static void platform_bus_create_devtree(const PPCE500MachineClass *pmc,

+static void platform_bus_create_devtree(PPCE500MachineState *pms,

void *fdt, const char *mpic)

{

+ const PPCE500MachineClass *pmc = PPCE500_MACHINE_GET_CLASS(pms);

gchar *node = g_strdup_printf("/platform@%"PRIx64, pmc->platform_bus_base);

const char platcomp[] = "qemu,platform\0simple-bus";

uint64_t addr = pmc->platform_bus_base;

uint64_t size = pmc->platform_bus_size;

int irq_start = pmc->platform_bus_first_irq;

- PlatformBusDevice *pbus;

- DeviceState *dev;

/* Create a /platform node that we can put all devices into */

@@ -XXX,XX +XXX,XX @@ static void platform_bus_create_devtree(const PPCE500MachineClass *pmc,

qemu_fdt_setprop_phandle(fdt, node, "interrupt-parent", mpic);

- dev = qdev_find_recursive(sysbus_get_default(), TYPE_PLATFORM_BUS_DEVICE);

- pbus = PLATFORM_BUS_DEVICE(dev);

+ /* Create dt nodes for dynamic devices */

+ PlatformDevtreeData data = {

+ .fdt = fdt,

+ .mpic = mpic,

+ .irq_start = irq_start,

+ .node = node,

+ .pbus = pms->pbus_dev,

+ };

- /* We can only create dt nodes for dynamic devices when they're ready */

- if (pbus->done_gathering) {

- PlatformDevtreeData data = {

- .fdt = fdt,

- .mpic = mpic,

- .irq_start = irq_start,

- .node = node,

- .pbus = pbus,

- };

-

- /* Loop through all dynamic sysbus devices and create nodes for them */

- foreach_dynamic_sysbus_device(sysbus_device_create_devtree, &data);

- }

+ /* Loop through all dynamic sysbus devices and create nodes for them */

+ foreach_dynamic_sysbus_device(sysbus_device_create_devtree, &data);

g_free(node);

}

@@ -XXX,XX +XXX,XX @@ static int ppce500_load_device_tree(PPCE500MachineState *pms,

}

g_free(soc);

- if (pmc->has_platform_bus) {

- platform_bus_create_devtree(pmc, fdt, mpic);

+ if (pms->pbus_dev) {

+ platform_bus_create_devtree(pms, fdt, mpic);

}

g_free(mpic);

@@ -XXX,XX +XXX,XX @@ void ppce500_init(MachineState *machine)

qdev_prop_set_uint32(dev, "num_irqs", pmc->platform_bus_num_irqs);

qdev_prop_set_uint32(dev, "mmio_size", pmc->platform_bus_size);

qdev_init_nofail(dev);

- s = SYS_BUS_DEVICE(dev);

+ pms->pbus_dev = PLATFORM_BUS_DEVICE(dev);

+ s = SYS_BUS_DEVICE(pms->pbus_dev);

for (i = 0; i < pmc->platform_bus_num_irqs; i++) {

int irqn = pmc->platform_bus_first_irq + i;

sysbus_connect_irq(s, i, qdev_get_gpio_in(mpicdev, irqn));

@@ -XXX,XX +XXX,XX @@ static const TypeInfo ppce500_info = {

.name = TYPE_PPCE500_MACHINE,

.parent = TYPE_MACHINE,

.abstract = true,

+ .instance_size = sizeof(PPCE500MachineState),

.class_size = sizeof(PPCE500MachineClass),

};

diff --git a/hw/ppc/e500plat.c b/hw/ppc/e500plat.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/ppc/e500plat.c

+++ b/hw/ppc/e500plat.c

@@ -XXX,XX +XXX,XX @@ static void e500plat_init(MachineState *machine)

ppce500_init(machine);

}

+static void e500plat_machine_device_plug_cb(HotplugHandler *hotplug_dev,

+ DeviceState *dev, Error **errp)

+{

+ PPCE500MachineState *pms = PPCE500_MACHINE(hotplug_dev);

+

+ if (pms->pbus_dev) {

+ if (object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE)) {

+ platform_bus_link_device(pms->pbus_dev, SYS_BUS_DEVICE(dev));

+ }

+ }

+}

+

+static

+HotplugHandler *e500plat_machine_get_hotpug_handler(MachineState *machine,

+ DeviceState *dev)

+{

+ if (object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE)) {

+ return HOTPLUG_HANDLER(machine);

+ }

+

+ return NULL;

+}

+

#define TYPE_E500PLAT_MACHINE MACHINE_TYPE_NAME("ppce500")

static void e500plat_machine_class_init(ObjectClass *oc, void *data)

{

PPCE500MachineClass *pmc = PPCE500_MACHINE_CLASS(oc);

+ HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);

MachineClass *mc = MACHINE_CLASS(oc);

+ mc->get_hotplug_handler = e500plat_machine_get_hotpug_handler;

+ hc->plug = e500plat_machine_device_plug_cb;

+

pmc->pci_first_slot = 0x1;

pmc->pci_nr_slots = PCI_SLOT_MAX - 1;

pmc->fixup_devtree = e500plat_fixup_devtree;

@@ -XXX,XX +XXX,XX @@ static const TypeInfo e500plat_info = {

.name = TYPE_E500PLAT_MACHINE,

.parent = TYPE_PPCE500_MACHINE,

.class_init = e500plat_machine_class_init,

+ .interfaces = (InterfaceInfo[]) {

+ { TYPE_HOTPLUG_HANDLER },

+ { }

+ }

};

static void e500plat_register_types(void)

--

2.17.0

From: Igor Mammedov <imammedo@redhat.com>

load_dtb() depends on arm_load_kernel() to figure out place

in RAM where it should be loaded, but it's not required for

arm_load_kernel() to work. Sometimes it's neccesary for

devices added with -device/device_add to be enumerated in

DTB as well, which's lead to [1] and surrounding commits to

add 2 more machine_done notifiers with non obvious ordering

to make dynamic sysbus devices initialization happen in

the right order.

However instead of moving whole arm_load_kernel() in to

machine_done, it's sufficient to move only load_dtb() into

virt_machine_done() notifier and remove ArmLoadKernelNotifier/

/PlatformBusFDTNotifierParams notifiers, which saves us ~90LOC

and simplifies code flow quite a bit.

Later would allow to consolidate DTB generation within one

function for 'mach-virt' board and make it reentrant so it

could generate updated DTB in device hotplug secenarios.

While at it rename load_dtb() to arm_load_dtb() since it's

public now.

Add additional field skip_dtb_autoload to struct arm_boot_info

to allow manual DTB load later in mach-virt and to avoid touching

all other boards to explicitly call arm_load_dtb().

1) (ac9d32e hw/arm/boot: arm_load_kernel implemented as a machine init done notifier)

Signed-off-by: Igor Mammedov <imammedo@redhat.com>

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

Reviewed-by: Andrew Jones <drjones@redhat.com>

Message-id: 1525691524-32265-4-git-send-email-imammedo@redhat.com

include/hw/arm/arm.h | 45 +++++++++++++++++------

include/hw/arm/sysbus-fdt.h | 37 ++++---------------

hw/arm/boot.c | 72 ++++++++++---------------------------

hw/arm/sysbus-fdt.c | 61 +++----------------------------

hw/arm/virt.c | 64 ++++++++++++++++-----------------

5 files changed, 94 insertions(+), 185 deletions(-)

diff --git a/include/hw/arm/arm.h b/include/hw/arm/arm.h

index XXXXXXX..XXXXXXX 100644

--- a/include/hw/arm/arm.h

+++ b/include/hw/arm/arm.h

@@ -XXX,XX +XXX,XX @@ DeviceState *armv7m_init(MemoryRegion *system_memory, int mem_size, int num_irq,

*/

void armv7m_load_kernel(ARMCPU *cpu, const char *kernel_filename, int mem_size);

-/*

- * struct used as a parameter of the arm_load_kernel machine init

- * done notifier

- */

-typedef struct {

- Notifier notifier; /* actual notifier */

- ARMCPU *cpu; /* handle to the first cpu object */

-} ArmLoadKernelNotifier;

-

/* arm_boot.c */

struct arm_boot_info {

uint64_t ram_size;

@@ -XXX,XX +XXX,XX @@ struct arm_boot_info {

const char *initrd_filename;

const char *dtb_filename;

hwaddr loader_start;

+ hwaddr dtb_start;

+ hwaddr dtb_limit;

+ /* If set to True, arm_load_kernel() will not load DTB.

+ * It allows board to load DTB manually later.

+ * (default: False)

+ */

+ bool skip_dtb_autoload;

/* multicore boards that use the default secondary core boot functions

* need to put the address of the secondary boot code, the boot reg,

* and the GIC address in the next 3 values, respectively. boards that

@@ -XXX,XX +XXX,XX @@ struct arm_boot_info {

* the user it should implement this hook.

*/

void (*modify_dtb)(const struct arm_boot_info *info, void *fdt);

- /* machine init done notifier executing arm_load_dtb */

- ArmLoadKernelNotifier load_kernel_notifier;

/* Used internally by arm_boot.c */

int is_linux;

hwaddr initrd_start;

@@ -XXX,XX +XXX,XX @@ struct arm_boot_info {

*/

void arm_load_kernel(ARMCPU *cpu, struct arm_boot_info *info);

+AddressSpace *arm_boot_address_space(ARMCPU *cpu,

+ const struct arm_boot_info *info);

+

+/**

+ * arm_load_dtb() - load a device tree binary image into memory

+ * @addr: the address to load the image at

+ * @binfo: struct describing the boot environment

+ * @addr_limit: upper limit of the available memory area at @addr

+ * @as: address space to load image to

+ *

+ * Load a device tree supplied by the machine or by the user with the

+ * '-dtb' command line option, and put it at offset @addr in target

+ * memory.

+ *

+ * If @addr_limit contains a meaningful value (i.e., it is strictly greater

+ * than @addr), the device tree is only loaded if its size does not exceed

+ * the limit.

+ *

+ * Returns: the size of the device tree image on success,

+ * 0 if the image size exceeds the limit,

+ * -1 on errors.

+ *

+ * Note: Must not be called unless have_dtb(binfo) is true.

+ */

+int arm_load_dtb(hwaddr addr, const struct arm_boot_info *binfo,

+ hwaddr addr_limit, AddressSpace *as);

+

/* Write a secure board setup routine with a dummy handler for SMCs */

void arm_write_secure_board_setup_dummy_smc(ARMCPU *cpu,

const struct arm_boot_info *info,

diff --git a/include/hw/arm/sysbus-fdt.h b/include/hw/arm/sysbus-fdt.h

index XXXXXXX..XXXXXXX 100644

--- a/include/hw/arm/sysbus-fdt.h

+++ b/include/hw/arm/sysbus-fdt.h

@@ -XXX,XX +XXX,XX @@

#ifndef HW_ARM_SYSBUS_FDT_H

#define HW_ARM_SYSBUS_FDT_H

-#include "hw/arm/arm.h"

-#include "qemu-common.h"

-#include "hw/sysbus.h"

-

-/*

- * struct that contains dimensioning parameters of the platform bus

- */

-typedef struct {

- hwaddr platform_bus_base; /* start address of the bus */

- hwaddr platform_bus_size; /* size of the bus */

- int platform_bus_first_irq; /* first hwirq assigned to the bus */

- int platform_bus_num_irqs; /* number of hwirq assigned to the bus */

-} ARMPlatformBusSystemParams;

-

-/*

- * struct that contains all relevant info to build the fdt nodes of

- * platform bus and attached dynamic sysbus devices

- * in the future might be augmented with additional info

- * such as PHY, CLK handles ...

- */

-typedef struct {

- const ARMPlatformBusSystemParams *system_params;

- struct arm_boot_info *binfo;

- const char *intc; /* parent interrupt controller name */

-} ARMPlatformBusFDTParams;

+#include "exec/hwaddr.h"

/**

- * arm_register_platform_bus_fdt_creator - register a machine init done

- * notifier that creates the device tree nodes of the platform bus and

- * associated dynamic sysbus devices

+ * platform_bus_add_all_fdt_nodes - create all the platform bus nodes

+ *

+ * builds the parent platform bus node and all the nodes of dynamic

+ * sysbus devices attached to it.

*/

-void arm_register_platform_bus_fdt_creator(ARMPlatformBusFDTParams *fdt_params);

-

+void platform_bus_add_all_fdt_nodes(void *fdt, const char *intc, hwaddr addr,

+ hwaddr bus_size, int irq_start);

#endif

@@ -XXX,XX +XXX,XX @@

#define ARM64_TEXT_OFFSET_OFFSET 8

#define ARM64_MAGIC_OFFSET 56

-static AddressSpace *arm_boot_address_space(ARMCPU *cpu,

- const struct arm_boot_info *info)

+AddressSpace *arm_boot_address_space(ARMCPU *cpu,

+ const struct arm_boot_info *info)

{

/* Return the address space to use for bootloader reads and writes.

* We prefer the secure address space if the CPU has it and we're

@@ -XXX,XX +XXX,XX @@ static void fdt_add_psci_node(void *fdt)

qemu_fdt_setprop_cell(fdt, "/psci", "migrate", migrate_fn);

}

-/**

- * load_dtb() - load a device tree binary image into memory

- * @addr: the address to load the image at

- * @binfo: struct describing the boot environment

- * @addr_limit: upper limit of the available memory area at @addr

- * @as: address space to load image to

- *

- * Load a device tree supplied by the machine or by the user with the

- * '-dtb' command line option, and put it at offset @addr in target

- * memory.

- *

- * If @addr_limit contains a meaningful value (i.e., it is strictly greater

- * than @addr), the device tree is only loaded if its size does not exceed

- * the limit.

- *

- * Returns: the size of the device tree image on success,

- * 0 if the image size exceeds the limit,

- * -1 on errors.

- *

- * Note: Must not be called unless have_dtb(binfo) is true.

- */

-static int load_dtb(hwaddr addr, const struct arm_boot_info *binfo,

- hwaddr addr_limit, AddressSpace *as)

+int arm_load_dtb(hwaddr addr, const struct arm_boot_info *binfo,

+ hwaddr addr_limit, AddressSpace *as)

{

void *fdt = NULL;

int size, rc;

@@ -XXX,XX +XXX,XX @@ static uint64_t load_aarch64_image(const char *filename, hwaddr mem_base,

return size;

}

-static void arm_load_kernel_notify(Notifier *notifier, void *data)

+void arm_load_kernel(ARMCPU *cpu, struct arm_boot_info *info)

{

CPUState *cs;

int kernel_size;

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

int elf_machine;

hwaddr entry;

static const ARMInsnFixup *primary_loader;

- ArmLoadKernelNotifier *n = DO_UPCAST(ArmLoadKernelNotifier,

- notifier, notifier);

- ARMCPU *cpu = n->cpu;

- struct arm_boot_info *info =

- container_of(n, struct arm_boot_info, load_kernel_notifier);

AddressSpace *as = arm_boot_address_space(cpu, info);

/* The board code is not supposed to set secure_board_setup unless

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

assert(!(info->secure_board_setup && kvm_enabled()));

info->dtb_filename = qemu_opt_get(qemu_get_machine_opts(), "dtb");

+ info->dtb_limit = 0;

/* Load the kernel. */

if (!info->kernel_filename || info->firmware_loaded) {

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

* the kernel is supposed to be loaded by the bootloader), copy the

* DTB to the base of RAM for the bootloader to pick up.

*/

- if (load_dtb(info->loader_start, info, 0, as) < 0) {

- exit(1);

- }

+ info->dtb_start = info->loader_start;

}

if (info->kernel_filename) {

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

*/

if (elf_low_addr > info->loader_start

|| elf_high_addr < info->loader_start) {

- /* Pass elf_low_addr as address limit to load_dtb if it may be

+ /* Set elf_low_addr as address limit for arm_load_dtb if it may be

* pointing into RAM, otherwise pass '0' (no limit)

*/

if (elf_low_addr < info->loader_start) {

elf_low_addr = 0;

}

- if (load_dtb(info->loader_start, info, elf_low_addr, as) < 0) {

- exit(1);

- }

+ info->dtb_start = info->loader_start;

+ info->dtb_limit = elf_low_addr;

}

}

entry = elf_entry;

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

*/

if (have_dtb(info)) {

hwaddr align;

- hwaddr dtb_start;

if (elf_machine == EM_AARCH64) {

/*

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

}

/* Place the DTB after the initrd in memory with alignment. */

- dtb_start = QEMU_ALIGN_UP(info->initrd_start + initrd_size, align);

- if (load_dtb(dtb_start, info, 0, as) < 0) {

- exit(1);

- }

- fixupcontext[FIXUP_ARGPTR] = dtb_start;

+ info->dtb_start = QEMU_ALIGN_UP(info->initrd_start + initrd_size,

+ align);

+ fixupcontext[FIXUP_ARGPTR] = info->dtb_start;

} else {

fixupcontext[FIXUP_ARGPTR] = info->loader_start + KERNEL_ARGS_ADDR;

if (info->ram_size >= (1ULL << 32)) {

@@ -XXX,XX +XXX,XX @@ static void arm_load_kernel_notify(Notifier *notifier, void *data)

for (cs = first_cpu; cs; cs = CPU_NEXT(cs)) {

ARM_CPU(cs)->env.boot_info = info;

}

-}

-

-void arm_load_kernel(ARMCPU *cpu, struct arm_boot_info *info)

-{

- CPUState *cs;

-

- info->load_kernel_notifier.cpu = cpu;

- info->load_kernel_notifier.notifier.notify = arm_load_kernel_notify;

- qemu_add_machine_init_done_notifier(&info->load_kernel_notifier.notifier);

/* CPU objects (unlike devices) are not automatically reset on system

* reset, so we must always register a handler to do so. If we're

@@ -XXX,XX +XXX,XX @@ void arm_load_kernel(ARMCPU *cpu, struct arm_boot_info *info)

for (cs = first_cpu; cs; cs = CPU_NEXT(cs)) {

qemu_register_reset(do_cpu_reset, ARM_CPU(cs));

}

+ if (!info->skip_dtb_autoload && have_dtb(info)) {

+ if (arm_load_dtb(info->dtb_start, info, info->dtb_limit, as) < 0) {

+ exit(1);

+ }

+ }

}

static const TypeInfo arm_linux_boot_if_info = {

diff --git a/hw/arm/sysbus-fdt.c b/hw/arm/sysbus-fdt.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/arm/sysbus-fdt.c

+++ b/hw/arm/sysbus-fdt.c

@@ -XXX,XX +XXX,XX @@ typedef struct PlatformBusFDTData {

PlatformBusDevice *pbus;

} PlatformBusFDTData;

-/*

- * struct used when calling the machine init done notifier

- * that constructs the fdt nodes of platform bus devices

- */

-typedef struct PlatformBusFDTNotifierParams {

- Notifier notifier;

- ARMPlatformBusFDTParams *fdt_params;

-} PlatformBusFDTNotifierParams;

-

/* struct that associates a device type name and a node creation function */

typedef struct NodeCreationPair {

const char *typename;

@@ -XXX,XX +XXX,XX @@ static void add_fdt_node(SysBusDevice *sbdev, void *opaque)

exit(1);

}

-/**

- * add_all_platform_bus_fdt_nodes - create all the platform bus nodes

- *

- * builds the parent platform bus node and all the nodes of dynamic

- * sysbus devices attached to it.

- */

-static void add_all_platform_bus_fdt_nodes(ARMPlatformBusFDTParams *fdt_params)

+void platform_bus_add_all_fdt_nodes(void *fdt, const char *intc, hwaddr addr,

+ hwaddr bus_size, int irq_start)

{

const char platcomp[] = "qemu,platform\0simple-bus";

PlatformBusDevice *pbus;

DeviceState *dev;

gchar *node;

- uint64_t addr, size;

- int irq_start, dtb_size;

- struct arm_boot_info *info = fdt_params->binfo;

- const ARMPlatformBusSystemParams *params = fdt_params->system_params;

- const char *intc = fdt_params->intc;

- void *fdt = info->get_dtb(info, &dtb_size);

-

- /*

- * If the user provided a dtb, we assume the dynamic sysbus nodes

- * already are integrated there. This corresponds to a use case where

- * the dynamic sysbus nodes are complex and their generation is not yet

- * supported. In that case the user can take charge of the guest dt

- * while qemu takes charge of the qom stuff.

- */

- if (info->dtb_filename) {

- return;

- }

assert(fdt);

- node = g_strdup_printf("/platform@%"PRIx64, params->platform_bus_base);

- addr = params->platform_bus_base;

- size = params->platform_bus_size;

- irq_start = params->platform_bus_first_irq;

+ node = g_strdup_printf("/platform@%"PRIx64, addr);

/* Create a /platform node that we can put all devices into */

qemu_fdt_add_subnode(fdt, node);

@@ -XXX,XX +XXX,XX @@ static void add_all_platform_bus_fdt_nodes(ARMPlatformBusFDTParams *fdt_params)

*/

qemu_fdt_setprop_cells(fdt, node, "#size-cells", 1);

qemu_fdt_setprop_cells(fdt, node, "#address-cells", 1);

- qemu_fdt_setprop_cells(fdt, node, "ranges", 0, addr >> 32, addr, size);

+ qemu_fdt_setprop_cells(fdt, node, "ranges", 0, addr >> 32, addr, bus_size);

qemu_fdt_setprop_phandle(fdt, node, "interrupt-parent", intc);

@@ -XXX,XX +XXX,XX @@ static void add_all_platform_bus_fdt_nodes(ARMPlatformBusFDTParams *fdt_params)

g_free(node);

}

-

-static void platform_bus_fdt_notify(Notifier *notifier, void *data)

-{

- PlatformBusFDTNotifierParams *p = DO_UPCAST(PlatformBusFDTNotifierParams,

- notifier, notifier);

-

- add_all_platform_bus_fdt_nodes(p->fdt_params);

- g_free(p->fdt_params);

- g_free(p);

-}

-

-void arm_register_platform_bus_fdt_creator(ARMPlatformBusFDTParams *fdt_params)

-{

- PlatformBusFDTNotifierParams *p = g_new(PlatformBusFDTNotifierParams, 1);

-

- p->fdt_params = fdt_params;

- p->notifier.notify = platform_bus_fdt_notify;

- qemu_add_machine_init_done_notifier(&p->notifier);

-}

diff --git a/hw/arm/virt.c b/hw/arm/virt.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/arm/virt.c

+++ b/hw/arm/virt.c

@@ -XXX,XX +XXX,XX @@

#define PLATFORM_BUS_NUM_IRQS 64

-static ARMPlatformBusSystemParams platform_bus_params;

-

/* RAM limit in GB. Since VIRT_MEM starts at the 1GB mark, this means

* RAM can go up to the 256GB mark, leaving 256GB of the physical

* address space unallocated and free for future use between 256G and 512G.

@@ -XXX,XX +XXX,XX @@ static void create_platform_bus(VirtMachineState *vms, qemu_irq *pic)

DeviceState *dev;

SysBusDevice *s;

int i;

- ARMPlatformBusFDTParams *fdt_params = g_new(ARMPlatformBusFDTParams, 1);

MemoryRegion *sysmem = get_system_memory();

- platform_bus_params.platform_bus_base = vms->memmap[VIRT_PLATFORM_BUS].base;

- platform_bus_params.platform_bus_size = vms->memmap[VIRT_PLATFORM_BUS].size;

- platform_bus_params.platform_bus_first_irq = vms->irqmap[VIRT_PLATFORM_BUS];

- platform_bus_params.platform_bus_num_irqs = PLATFORM_BUS_NUM_IRQS;

-

- fdt_params->system_params = &platform_bus_params;

- fdt_params->binfo = &vms->bootinfo;

- fdt_params->intc = "/intc";

- /*

- * register a machine init done notifier that creates the device tree

- * nodes of the platform bus and its children dynamic sysbus devices

- */

- arm_register_platform_bus_fdt_creator(fdt_params);

-

dev = qdev_create(NULL, TYPE_PLATFORM_BUS_DEVICE);

dev->id = TYPE_PLATFORM_BUS_DEVICE;

- qdev_prop_set_uint32(dev, "num_irqs",

- platform_bus_params.platform_bus_num_irqs);

- qdev_prop_set_uint32(dev, "mmio_size",

- platform_bus_params.platform_bus_size);

+ qdev_prop_set_uint32(dev, "num_irqs", PLATFORM_BUS_NUM_IRQS);

+ qdev_prop_set_uint32(dev, "mmio_size", vms->memmap[VIRT_PLATFORM_BUS].size);

qdev_init_nofail(dev);

vms->platform_bus_dev = dev;

- s = SYS_BUS_DEVICE(dev);

- for (i = 0; i < platform_bus_params.platform_bus_num_irqs; i++) {

- int irqn = platform_bus_params.platform_bus_first_irq + i;

+ s = SYS_BUS_DEVICE(dev);

+ for (i = 0; i < PLATFORM_BUS_NUM_IRQS; i++) {

+ int irqn = vms->irqmap[VIRT_PLATFORM_BUS] + i;

sysbus_connect_irq(s, i, pic[irqn]);

}

memory_region_add_subregion(sysmem,

- platform_bus_params.platform_bus_base,

+ vms->memmap[VIRT_PLATFORM_BUS].base,

sysbus_mmio_get_region(s, 0));

}

@@ -XXX,XX +XXX,XX @@ void virt_machine_done(Notifier *notifier, void *data)

{

VirtMachineState *vms = container_of(notifier, VirtMachineState,

machine_done);

+ ARMCPU *cpu = ARM_CPU(first_cpu);

+ struct arm_boot_info *info = &vms->bootinfo;

+ AddressSpace *as = arm_boot_address_space(cpu, info);

+

+ /*

+ * If the user provided a dtb, we assume the dynamic sysbus nodes

+ * already are integrated there. This corresponds to a use case where

+ * the dynamic sysbus nodes are complex and their generation is not yet

+ * supported. In that case the user can take charge of the guest dt

+ * while qemu takes charge of the qom stuff.

+ */

+ if (info->dtb_filename == NULL) {

+ platform_bus_add_all_fdt_nodes(vms->fdt, "/intc",

+ vms->memmap[VIRT_PLATFORM_BUS].base,

+ vms->memmap[VIRT_PLATFORM_BUS].size,

+ vms->irqmap[VIRT_PLATFORM_BUS]);

+ }

+ if (arm_load_dtb(info->dtb_start, info, info->dtb_limit, as) < 0) {

+ exit(1);

+ }

virt_acpi_setup(vms);

virt_build_smbios(vms);

@@ -XXX,XX +XXX,XX @@ static void machvirt_init(MachineState *machine)

vms->fw_cfg = create_fw_cfg(vms, &address_space_memory);

rom_set_fw(vms->fw_cfg);

- vms->machine_done.notify = virt_machine_done;

- qemu_add_machine_init_done_notifier(&vms->machine_done);

+ create_platform_bus(vms, pic);

vms->bootinfo.ram_size = machine->ram_size;

vms->bootinfo.kernel_filename = machine->kernel_filename;

@@ -XXX,XX +XXX,XX @@ static void machvirt_init(MachineState *machine)

vms->bootinfo.board_id = -1;

vms->bootinfo.loader_start = vms->memmap[VIRT_MEM].base;

vms->bootinfo.get_dtb = machvirt_dtb;

+ vms->bootinfo.skip_dtb_autoload = true;

vms->bootinfo.firmware_loaded = firmware_loaded;

arm_load_kernel(ARM_CPU(first_cpu), &vms->bootinfo);

- /*

- * arm_load_kernel machine init done notifier registration must

- * happen before the platform_bus_create call. In this latter,

- * another notifier is registered which adds platform bus nodes.

- * Notifiers are executed in registration reverse order.

- */

- create_platform_bus(vms, pic);

+ vms->machine_done.notify = virt_machine_done;

+ qemu_add_machine_init_done_notifier(&vms->machine_done);

}

static bool virt_get_secure(Object *obj, Error **errp)

2.17.0