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

target-arm: Use MemoryListener to identify GIC base address for KVM 



When using an in-kernel GIC with KVM, we need to tell the kernel where
the GIC's memory mapped registers live. Do this by registering a
MemoryListener which tracks where the board model maps the A15's
private peripherals, so we can finish the GIC initialisation
when the GIC is actually mapped.

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
Reviewed-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 53111180

target-arm/kvm.c

+87 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include "qemu/timer.h"

#include "sysemu/sysemu.h"

#include "sysemu/kvm.h"

#include "kvm_arm.h"

#include "cpu.h"

#include "hw/arm-misc.h"
@@ -67,6 +68,92 @@ int kvm_arch_init_vcpu(CPUState *cs) 
    return ret;

}



/* We track all the KVM devices which need their memory addresses

 * passing to the kernel in a list of these structures.

 * When board init is complete we run through the list and

 * tell the kernel the base addresses of the memory regions.

 * We use a MemoryListener to track mapping and unmapping of

 * the regions during board creation, so the board models don't

 * need to do anything special for the KVM case.

 */

typedef struct KVMDevice {

    struct kvm_arm_device_addr kda;

    MemoryRegion *mr;

    QSLIST_ENTRY(KVMDevice) entries;

} KVMDevice;



static QSLIST_HEAD(kvm_devices_head, KVMDevice) kvm_devices_head;



static void kvm_arm_devlistener_add(MemoryListener *listener,

                                    MemoryRegionSection *section)

{

    KVMDevice *kd;



    QSLIST_FOREACH(kd, &kvm_devices_head, entries) {

        if (section->mr == kd->mr) {

            kd->kda.addr = section->offset_within_address_space;

        }

    }

}



static void kvm_arm_devlistener_del(MemoryListener *listener,

                                    MemoryRegionSection *section)

{

    KVMDevice *kd;



    QSLIST_FOREACH(kd, &kvm_devices_head, entries) {

        if (section->mr == kd->mr) {

            kd->kda.addr = -1;

        }

    }

}



static MemoryListener devlistener = {

    .region_add = kvm_arm_devlistener_add,

    .region_del = kvm_arm_devlistener_del,

};



static void kvm_arm_machine_init_done(Notifier *notifier, void *data)

{

    KVMDevice *kd, *tkd;



    memory_listener_unregister(&devlistener);

    QSLIST_FOREACH_SAFE(kd, &kvm_devices_head, entries, tkd) {

        if (kd->kda.addr != -1) {

            if (kvm_vm_ioctl(kvm_state, KVM_ARM_SET_DEVICE_ADDR,

                             &kd->kda) < 0) {

                fprintf(stderr, "KVM_ARM_SET_DEVICE_ADDRESS failed: %s\n",

                        strerror(errno));

                abort();

            }

        }

        g_free(kd);

    }

}



static Notifier notify = {

    .notify = kvm_arm_machine_init_done,

};



void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid)

{

    KVMDevice *kd;



    if (!kvm_irqchip_in_kernel()) {

        return;

    }



    if (QSLIST_EMPTY(&kvm_devices_head)) {

        memory_listener_register(&devlistener, NULL);

        qemu_add_machine_init_done_notifier(&notify);

    }

    kd = g_new0(KVMDevice, 1);

    kd->mr = mr;

    kd->kda.id = devid;

    kd->kda.addr = -1;

    QSLIST_INSERT_HEAD(&kvm_devices_head, kd, entries);

}



typedef struct Reg {

    uint64_t id;

    int offset;

target-arm/kvm_arm.h

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

 * QEMU KVM support -- ARM specific functions.

 *

 * Copyright (c) 2012 Linaro Limited

 *

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

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

 *

 */



#ifndef QEMU_KVM_ARM_H

#define QEMU_KVM_ARM_H



#include "sysemu/kvm.h"

#include "exec/memory.h"



/**

 * kvm_arm_register_device:

 * @mr: memory region for this device

 * @devid: the KVM device ID

 *

 * Remember the memory region @mr, and when it is mapped by the

 * machine model, tell the kernel that base address using the

 * KVM_SET_DEVICE_ADDRESS ioctl. @devid should be the ID of

 * the device as defined by KVM_SET_DEVICE_ADDRESS.

 * The machine model may map and unmap the device multiple times;

 * the kernel will only be told the final address at the point

 * where machine init is complete.

 */

void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid);



#endif