1fcf5ef2aSThomas Huth /* 2fcf5ef2aSThomas Huth * ARM implementation of KVM hooks 3fcf5ef2aSThomas Huth * 4fcf5ef2aSThomas Huth * Copyright Christoffer Dall 2009-2010 5fcf5ef2aSThomas Huth * 6fcf5ef2aSThomas Huth * This work is licensed under the terms of the GNU GPL, version 2 or later. 7fcf5ef2aSThomas Huth * See the COPYING file in the top-level directory. 8fcf5ef2aSThomas Huth * 9fcf5ef2aSThomas Huth */ 10fcf5ef2aSThomas Huth 11fcf5ef2aSThomas Huth #include "qemu/osdep.h" 12fcf5ef2aSThomas Huth #include <sys/ioctl.h> 13fcf5ef2aSThomas Huth 14fcf5ef2aSThomas Huth #include <linux/kvm.h> 15fcf5ef2aSThomas Huth 16fcf5ef2aSThomas Huth #include "qemu-common.h" 17fcf5ef2aSThomas Huth #include "qemu/timer.h" 18fcf5ef2aSThomas Huth #include "qemu/error-report.h" 19fcf5ef2aSThomas Huth #include "sysemu/sysemu.h" 20fcf5ef2aSThomas Huth #include "sysemu/kvm.h" 21fcf5ef2aSThomas Huth #include "kvm_arm.h" 22fcf5ef2aSThomas Huth #include "cpu.h" 23b05c81d2SEric Auger #include "trace.h" 24fcf5ef2aSThomas Huth #include "internals.h" 25fcf5ef2aSThomas Huth #include "hw/arm/arm.h" 26b05c81d2SEric Auger #include "hw/pci/pci.h" 27fcf5ef2aSThomas Huth #include "exec/memattrs.h" 28fcf5ef2aSThomas Huth #include "exec/address-spaces.h" 29fcf5ef2aSThomas Huth #include "hw/boards.h" 30fcf5ef2aSThomas Huth #include "qemu/log.h" 31fcf5ef2aSThomas Huth 32fcf5ef2aSThomas Huth const KVMCapabilityInfo kvm_arch_required_capabilities[] = { 33fcf5ef2aSThomas Huth KVM_CAP_LAST_INFO 34fcf5ef2aSThomas Huth }; 35fcf5ef2aSThomas Huth 36fcf5ef2aSThomas Huth static bool cap_has_mp_state; 37fcf5ef2aSThomas Huth 38c4487d76SPeter Maydell static ARMHostCPUFeatures arm_host_cpu_features; 39c4487d76SPeter Maydell 40fcf5ef2aSThomas Huth int kvm_arm_vcpu_init(CPUState *cs) 41fcf5ef2aSThomas Huth { 42fcf5ef2aSThomas Huth ARMCPU *cpu = ARM_CPU(cs); 43fcf5ef2aSThomas Huth struct kvm_vcpu_init init; 44fcf5ef2aSThomas Huth 45fcf5ef2aSThomas Huth init.target = cpu->kvm_target; 46fcf5ef2aSThomas Huth memcpy(init.features, cpu->kvm_init_features, sizeof(init.features)); 47fcf5ef2aSThomas Huth 48fcf5ef2aSThomas Huth return kvm_vcpu_ioctl(cs, KVM_ARM_VCPU_INIT, &init); 49fcf5ef2aSThomas Huth } 50fcf5ef2aSThomas Huth 51fcf5ef2aSThomas Huth bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try, 52fcf5ef2aSThomas Huth int *fdarray, 53fcf5ef2aSThomas Huth struct kvm_vcpu_init *init) 54fcf5ef2aSThomas Huth { 55fcf5ef2aSThomas Huth int ret, kvmfd = -1, vmfd = -1, cpufd = -1; 56fcf5ef2aSThomas Huth 57fcf5ef2aSThomas Huth kvmfd = qemu_open("/dev/kvm", O_RDWR); 58fcf5ef2aSThomas Huth if (kvmfd < 0) { 59fcf5ef2aSThomas Huth goto err; 60fcf5ef2aSThomas Huth } 61fcf5ef2aSThomas Huth vmfd = ioctl(kvmfd, KVM_CREATE_VM, 0); 62fcf5ef2aSThomas Huth if (vmfd < 0) { 63fcf5ef2aSThomas Huth goto err; 64fcf5ef2aSThomas Huth } 65fcf5ef2aSThomas Huth cpufd = ioctl(vmfd, KVM_CREATE_VCPU, 0); 66fcf5ef2aSThomas Huth if (cpufd < 0) { 67fcf5ef2aSThomas Huth goto err; 68fcf5ef2aSThomas Huth } 69fcf5ef2aSThomas Huth 70fcf5ef2aSThomas Huth if (!init) { 71fcf5ef2aSThomas Huth /* Caller doesn't want the VCPU to be initialized, so skip it */ 72fcf5ef2aSThomas Huth goto finish; 73fcf5ef2aSThomas Huth } 74fcf5ef2aSThomas Huth 75fcf5ef2aSThomas Huth ret = ioctl(vmfd, KVM_ARM_PREFERRED_TARGET, init); 76fcf5ef2aSThomas Huth if (ret >= 0) { 77fcf5ef2aSThomas Huth ret = ioctl(cpufd, KVM_ARM_VCPU_INIT, init); 78fcf5ef2aSThomas Huth if (ret < 0) { 79fcf5ef2aSThomas Huth goto err; 80fcf5ef2aSThomas Huth } 81fcf5ef2aSThomas Huth } else if (cpus_to_try) { 82fcf5ef2aSThomas Huth /* Old kernel which doesn't know about the 83fcf5ef2aSThomas Huth * PREFERRED_TARGET ioctl: we know it will only support 84fcf5ef2aSThomas Huth * creating one kind of guest CPU which is its preferred 85fcf5ef2aSThomas Huth * CPU type. 86fcf5ef2aSThomas Huth */ 87fcf5ef2aSThomas Huth while (*cpus_to_try != QEMU_KVM_ARM_TARGET_NONE) { 88fcf5ef2aSThomas Huth init->target = *cpus_to_try++; 89fcf5ef2aSThomas Huth memset(init->features, 0, sizeof(init->features)); 90fcf5ef2aSThomas Huth ret = ioctl(cpufd, KVM_ARM_VCPU_INIT, init); 91fcf5ef2aSThomas Huth if (ret >= 0) { 92fcf5ef2aSThomas Huth break; 93fcf5ef2aSThomas Huth } 94fcf5ef2aSThomas Huth } 95fcf5ef2aSThomas Huth if (ret < 0) { 96fcf5ef2aSThomas Huth goto err; 97fcf5ef2aSThomas Huth } 98fcf5ef2aSThomas Huth } else { 99fcf5ef2aSThomas Huth /* Treat a NULL cpus_to_try argument the same as an empty 100fcf5ef2aSThomas Huth * list, which means we will fail the call since this must 101fcf5ef2aSThomas Huth * be an old kernel which doesn't support PREFERRED_TARGET. 102fcf5ef2aSThomas Huth */ 103fcf5ef2aSThomas Huth goto err; 104fcf5ef2aSThomas Huth } 105fcf5ef2aSThomas Huth 106fcf5ef2aSThomas Huth finish: 107fcf5ef2aSThomas Huth fdarray[0] = kvmfd; 108fcf5ef2aSThomas Huth fdarray[1] = vmfd; 109fcf5ef2aSThomas Huth fdarray[2] = cpufd; 110fcf5ef2aSThomas Huth 111fcf5ef2aSThomas Huth return true; 112fcf5ef2aSThomas Huth 113fcf5ef2aSThomas Huth err: 114fcf5ef2aSThomas Huth if (cpufd >= 0) { 115fcf5ef2aSThomas Huth close(cpufd); 116fcf5ef2aSThomas Huth } 117fcf5ef2aSThomas Huth if (vmfd >= 0) { 118fcf5ef2aSThomas Huth close(vmfd); 119fcf5ef2aSThomas Huth } 120fcf5ef2aSThomas Huth if (kvmfd >= 0) { 121fcf5ef2aSThomas Huth close(kvmfd); 122fcf5ef2aSThomas Huth } 123fcf5ef2aSThomas Huth 124fcf5ef2aSThomas Huth return false; 125fcf5ef2aSThomas Huth } 126fcf5ef2aSThomas Huth 127fcf5ef2aSThomas Huth void kvm_arm_destroy_scratch_host_vcpu(int *fdarray) 128fcf5ef2aSThomas Huth { 129fcf5ef2aSThomas Huth int i; 130fcf5ef2aSThomas Huth 131fcf5ef2aSThomas Huth for (i = 2; i >= 0; i--) { 132fcf5ef2aSThomas Huth close(fdarray[i]); 133fcf5ef2aSThomas Huth } 134fcf5ef2aSThomas Huth } 135fcf5ef2aSThomas Huth 136c4487d76SPeter Maydell void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu) 137fcf5ef2aSThomas Huth { 138c4487d76SPeter Maydell CPUARMState *env = &cpu->env; 139fcf5ef2aSThomas Huth 140c4487d76SPeter Maydell if (!arm_host_cpu_features.dtb_compatible) { 141c4487d76SPeter Maydell if (!kvm_enabled() || 142c4487d76SPeter Maydell !kvm_arm_get_host_cpu_features(&arm_host_cpu_features)) { 143c4487d76SPeter Maydell /* We can't report this error yet, so flag that we need to 144c4487d76SPeter Maydell * in arm_cpu_realizefn(). 145fcf5ef2aSThomas Huth */ 146c4487d76SPeter Maydell cpu->kvm_target = QEMU_KVM_ARM_TARGET_NONE; 147c4487d76SPeter Maydell cpu->host_cpu_probe_failed = true; 148c4487d76SPeter Maydell return; 149fcf5ef2aSThomas Huth } 150fcf5ef2aSThomas Huth } 151fcf5ef2aSThomas Huth 152c4487d76SPeter Maydell cpu->kvm_target = arm_host_cpu_features.target; 153c4487d76SPeter Maydell cpu->dtb_compatible = arm_host_cpu_features.dtb_compatible; 154c4487d76SPeter Maydell env->features = arm_host_cpu_features.features; 155c4487d76SPeter Maydell } 156c4487d76SPeter Maydell 157fcf5ef2aSThomas Huth int kvm_arch_init(MachineState *ms, KVMState *s) 158fcf5ef2aSThomas Huth { 159fcf5ef2aSThomas Huth /* For ARM interrupt delivery is always asynchronous, 160fcf5ef2aSThomas Huth * whether we are using an in-kernel VGIC or not. 161fcf5ef2aSThomas Huth */ 162fcf5ef2aSThomas Huth kvm_async_interrupts_allowed = true; 163fcf5ef2aSThomas Huth 1645d721b78SAlexander Graf /* 1655d721b78SAlexander Graf * PSCI wakes up secondary cores, so we always need to 1665d721b78SAlexander Graf * have vCPUs waiting in kernel space 1675d721b78SAlexander Graf */ 1685d721b78SAlexander Graf kvm_halt_in_kernel_allowed = true; 1695d721b78SAlexander Graf 170fcf5ef2aSThomas Huth cap_has_mp_state = kvm_check_extension(s, KVM_CAP_MP_STATE); 171fcf5ef2aSThomas Huth 172fcf5ef2aSThomas Huth return 0; 173fcf5ef2aSThomas Huth } 174fcf5ef2aSThomas Huth 175fcf5ef2aSThomas Huth unsigned long kvm_arch_vcpu_id(CPUState *cpu) 176fcf5ef2aSThomas Huth { 177fcf5ef2aSThomas Huth return cpu->cpu_index; 178fcf5ef2aSThomas Huth } 179fcf5ef2aSThomas Huth 180fcf5ef2aSThomas Huth /* We track all the KVM devices which need their memory addresses 181fcf5ef2aSThomas Huth * passing to the kernel in a list of these structures. 182fcf5ef2aSThomas Huth * When board init is complete we run through the list and 183fcf5ef2aSThomas Huth * tell the kernel the base addresses of the memory regions. 184fcf5ef2aSThomas Huth * We use a MemoryListener to track mapping and unmapping of 185fcf5ef2aSThomas Huth * the regions during board creation, so the board models don't 186fcf5ef2aSThomas Huth * need to do anything special for the KVM case. 187fcf5ef2aSThomas Huth */ 188fcf5ef2aSThomas Huth typedef struct KVMDevice { 189fcf5ef2aSThomas Huth struct kvm_arm_device_addr kda; 190fcf5ef2aSThomas Huth struct kvm_device_attr kdattr; 191fcf5ef2aSThomas Huth MemoryRegion *mr; 192fcf5ef2aSThomas Huth QSLIST_ENTRY(KVMDevice) entries; 193fcf5ef2aSThomas Huth int dev_fd; 194fcf5ef2aSThomas Huth } KVMDevice; 195fcf5ef2aSThomas Huth 196fcf5ef2aSThomas Huth static QSLIST_HEAD(kvm_devices_head, KVMDevice) kvm_devices_head; 197fcf5ef2aSThomas Huth 198fcf5ef2aSThomas Huth static void kvm_arm_devlistener_add(MemoryListener *listener, 199fcf5ef2aSThomas Huth MemoryRegionSection *section) 200fcf5ef2aSThomas Huth { 201fcf5ef2aSThomas Huth KVMDevice *kd; 202fcf5ef2aSThomas Huth 203fcf5ef2aSThomas Huth QSLIST_FOREACH(kd, &kvm_devices_head, entries) { 204fcf5ef2aSThomas Huth if (section->mr == kd->mr) { 205fcf5ef2aSThomas Huth kd->kda.addr = section->offset_within_address_space; 206fcf5ef2aSThomas Huth } 207fcf5ef2aSThomas Huth } 208fcf5ef2aSThomas Huth } 209fcf5ef2aSThomas Huth 210fcf5ef2aSThomas Huth static void kvm_arm_devlistener_del(MemoryListener *listener, 211fcf5ef2aSThomas Huth MemoryRegionSection *section) 212fcf5ef2aSThomas Huth { 213fcf5ef2aSThomas Huth KVMDevice *kd; 214fcf5ef2aSThomas Huth 215fcf5ef2aSThomas Huth QSLIST_FOREACH(kd, &kvm_devices_head, entries) { 216fcf5ef2aSThomas Huth if (section->mr == kd->mr) { 217fcf5ef2aSThomas Huth kd->kda.addr = -1; 218fcf5ef2aSThomas Huth } 219fcf5ef2aSThomas Huth } 220fcf5ef2aSThomas Huth } 221fcf5ef2aSThomas Huth 222fcf5ef2aSThomas Huth static MemoryListener devlistener = { 223fcf5ef2aSThomas Huth .region_add = kvm_arm_devlistener_add, 224fcf5ef2aSThomas Huth .region_del = kvm_arm_devlistener_del, 225fcf5ef2aSThomas Huth }; 226fcf5ef2aSThomas Huth 227fcf5ef2aSThomas Huth static void kvm_arm_set_device_addr(KVMDevice *kd) 228fcf5ef2aSThomas Huth { 229fcf5ef2aSThomas Huth struct kvm_device_attr *attr = &kd->kdattr; 230fcf5ef2aSThomas Huth int ret; 231fcf5ef2aSThomas Huth 232fcf5ef2aSThomas Huth /* If the device control API is available and we have a device fd on the 233fcf5ef2aSThomas Huth * KVMDevice struct, let's use the newer API 234fcf5ef2aSThomas Huth */ 235fcf5ef2aSThomas Huth if (kd->dev_fd >= 0) { 236fcf5ef2aSThomas Huth uint64_t addr = kd->kda.addr; 237fcf5ef2aSThomas Huth attr->addr = (uintptr_t)&addr; 238fcf5ef2aSThomas Huth ret = kvm_device_ioctl(kd->dev_fd, KVM_SET_DEVICE_ATTR, attr); 239fcf5ef2aSThomas Huth } else { 240fcf5ef2aSThomas Huth ret = kvm_vm_ioctl(kvm_state, KVM_ARM_SET_DEVICE_ADDR, &kd->kda); 241fcf5ef2aSThomas Huth } 242fcf5ef2aSThomas Huth 243fcf5ef2aSThomas Huth if (ret < 0) { 244fcf5ef2aSThomas Huth fprintf(stderr, "Failed to set device address: %s\n", 245fcf5ef2aSThomas Huth strerror(-ret)); 246fcf5ef2aSThomas Huth abort(); 247fcf5ef2aSThomas Huth } 248fcf5ef2aSThomas Huth } 249fcf5ef2aSThomas Huth 250fcf5ef2aSThomas Huth static void kvm_arm_machine_init_done(Notifier *notifier, void *data) 251fcf5ef2aSThomas Huth { 252fcf5ef2aSThomas Huth KVMDevice *kd, *tkd; 253fcf5ef2aSThomas Huth 254fcf5ef2aSThomas Huth QSLIST_FOREACH_SAFE(kd, &kvm_devices_head, entries, tkd) { 255fcf5ef2aSThomas Huth if (kd->kda.addr != -1) { 256fcf5ef2aSThomas Huth kvm_arm_set_device_addr(kd); 257fcf5ef2aSThomas Huth } 258fcf5ef2aSThomas Huth memory_region_unref(kd->mr); 259*5ff9aaabSZheng Xiang QSLIST_REMOVE_HEAD(&kvm_devices_head, entries); 260fcf5ef2aSThomas Huth g_free(kd); 261fcf5ef2aSThomas Huth } 2620bbe4354SPeter Xu memory_listener_unregister(&devlistener); 263fcf5ef2aSThomas Huth } 264fcf5ef2aSThomas Huth 265fcf5ef2aSThomas Huth static Notifier notify = { 266fcf5ef2aSThomas Huth .notify = kvm_arm_machine_init_done, 267fcf5ef2aSThomas Huth }; 268fcf5ef2aSThomas Huth 269fcf5ef2aSThomas Huth void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group, 270fcf5ef2aSThomas Huth uint64_t attr, int dev_fd) 271fcf5ef2aSThomas Huth { 272fcf5ef2aSThomas Huth KVMDevice *kd; 273fcf5ef2aSThomas Huth 274fcf5ef2aSThomas Huth if (!kvm_irqchip_in_kernel()) { 275fcf5ef2aSThomas Huth return; 276fcf5ef2aSThomas Huth } 277fcf5ef2aSThomas Huth 278fcf5ef2aSThomas Huth if (QSLIST_EMPTY(&kvm_devices_head)) { 279fcf5ef2aSThomas Huth memory_listener_register(&devlistener, &address_space_memory); 280fcf5ef2aSThomas Huth qemu_add_machine_init_done_notifier(¬ify); 281fcf5ef2aSThomas Huth } 282fcf5ef2aSThomas Huth kd = g_new0(KVMDevice, 1); 283fcf5ef2aSThomas Huth kd->mr = mr; 284fcf5ef2aSThomas Huth kd->kda.id = devid; 285fcf5ef2aSThomas Huth kd->kda.addr = -1; 286fcf5ef2aSThomas Huth kd->kdattr.flags = 0; 287fcf5ef2aSThomas Huth kd->kdattr.group = group; 288fcf5ef2aSThomas Huth kd->kdattr.attr = attr; 289fcf5ef2aSThomas Huth kd->dev_fd = dev_fd; 290fcf5ef2aSThomas Huth QSLIST_INSERT_HEAD(&kvm_devices_head, kd, entries); 291fcf5ef2aSThomas Huth memory_region_ref(kd->mr); 292fcf5ef2aSThomas Huth } 293fcf5ef2aSThomas Huth 294fcf5ef2aSThomas Huth static int compare_u64(const void *a, const void *b) 295fcf5ef2aSThomas Huth { 296fcf5ef2aSThomas Huth if (*(uint64_t *)a > *(uint64_t *)b) { 297fcf5ef2aSThomas Huth return 1; 298fcf5ef2aSThomas Huth } 299fcf5ef2aSThomas Huth if (*(uint64_t *)a < *(uint64_t *)b) { 300fcf5ef2aSThomas Huth return -1; 301fcf5ef2aSThomas Huth } 302fcf5ef2aSThomas Huth return 0; 303fcf5ef2aSThomas Huth } 304fcf5ef2aSThomas Huth 305fcf5ef2aSThomas Huth /* Initialize the CPUState's cpreg list according to the kernel's 306fcf5ef2aSThomas Huth * definition of what CPU registers it knows about (and throw away 307fcf5ef2aSThomas Huth * the previous TCG-created cpreg list). 308fcf5ef2aSThomas Huth */ 309fcf5ef2aSThomas Huth int kvm_arm_init_cpreg_list(ARMCPU *cpu) 310fcf5ef2aSThomas Huth { 311fcf5ef2aSThomas Huth struct kvm_reg_list rl; 312fcf5ef2aSThomas Huth struct kvm_reg_list *rlp; 313fcf5ef2aSThomas Huth int i, ret, arraylen; 314fcf5ef2aSThomas Huth CPUState *cs = CPU(cpu); 315fcf5ef2aSThomas Huth 316fcf5ef2aSThomas Huth rl.n = 0; 317fcf5ef2aSThomas Huth ret = kvm_vcpu_ioctl(cs, KVM_GET_REG_LIST, &rl); 318fcf5ef2aSThomas Huth if (ret != -E2BIG) { 319fcf5ef2aSThomas Huth return ret; 320fcf5ef2aSThomas Huth } 321fcf5ef2aSThomas Huth rlp = g_malloc(sizeof(struct kvm_reg_list) + rl.n * sizeof(uint64_t)); 322fcf5ef2aSThomas Huth rlp->n = rl.n; 323fcf5ef2aSThomas Huth ret = kvm_vcpu_ioctl(cs, KVM_GET_REG_LIST, rlp); 324fcf5ef2aSThomas Huth if (ret) { 325fcf5ef2aSThomas Huth goto out; 326fcf5ef2aSThomas Huth } 327fcf5ef2aSThomas Huth /* Sort the list we get back from the kernel, since cpreg_tuples 328fcf5ef2aSThomas Huth * must be in strictly ascending order. 329fcf5ef2aSThomas Huth */ 330fcf5ef2aSThomas Huth qsort(&rlp->reg, rlp->n, sizeof(rlp->reg[0]), compare_u64); 331fcf5ef2aSThomas Huth 332fcf5ef2aSThomas Huth for (i = 0, arraylen = 0; i < rlp->n; i++) { 333fcf5ef2aSThomas Huth if (!kvm_arm_reg_syncs_via_cpreg_list(rlp->reg[i])) { 334fcf5ef2aSThomas Huth continue; 335fcf5ef2aSThomas Huth } 336fcf5ef2aSThomas Huth switch (rlp->reg[i] & KVM_REG_SIZE_MASK) { 337fcf5ef2aSThomas Huth case KVM_REG_SIZE_U32: 338fcf5ef2aSThomas Huth case KVM_REG_SIZE_U64: 339fcf5ef2aSThomas Huth break; 340fcf5ef2aSThomas Huth default: 341fcf5ef2aSThomas Huth fprintf(stderr, "Can't handle size of register in kernel list\n"); 342fcf5ef2aSThomas Huth ret = -EINVAL; 343fcf5ef2aSThomas Huth goto out; 344fcf5ef2aSThomas Huth } 345fcf5ef2aSThomas Huth 346fcf5ef2aSThomas Huth arraylen++; 347fcf5ef2aSThomas Huth } 348fcf5ef2aSThomas Huth 349fcf5ef2aSThomas Huth cpu->cpreg_indexes = g_renew(uint64_t, cpu->cpreg_indexes, arraylen); 350fcf5ef2aSThomas Huth cpu->cpreg_values = g_renew(uint64_t, cpu->cpreg_values, arraylen); 351fcf5ef2aSThomas Huth cpu->cpreg_vmstate_indexes = g_renew(uint64_t, cpu->cpreg_vmstate_indexes, 352fcf5ef2aSThomas Huth arraylen); 353fcf5ef2aSThomas Huth cpu->cpreg_vmstate_values = g_renew(uint64_t, cpu->cpreg_vmstate_values, 354fcf5ef2aSThomas Huth arraylen); 355fcf5ef2aSThomas Huth cpu->cpreg_array_len = arraylen; 356fcf5ef2aSThomas Huth cpu->cpreg_vmstate_array_len = arraylen; 357fcf5ef2aSThomas Huth 358fcf5ef2aSThomas Huth for (i = 0, arraylen = 0; i < rlp->n; i++) { 359fcf5ef2aSThomas Huth uint64_t regidx = rlp->reg[i]; 360fcf5ef2aSThomas Huth if (!kvm_arm_reg_syncs_via_cpreg_list(regidx)) { 361fcf5ef2aSThomas Huth continue; 362fcf5ef2aSThomas Huth } 363fcf5ef2aSThomas Huth cpu->cpreg_indexes[arraylen] = regidx; 364fcf5ef2aSThomas Huth arraylen++; 365fcf5ef2aSThomas Huth } 366fcf5ef2aSThomas Huth assert(cpu->cpreg_array_len == arraylen); 367fcf5ef2aSThomas Huth 368fcf5ef2aSThomas Huth if (!write_kvmstate_to_list(cpu)) { 369fcf5ef2aSThomas Huth /* Shouldn't happen unless kernel is inconsistent about 370fcf5ef2aSThomas Huth * what registers exist. 371fcf5ef2aSThomas Huth */ 372fcf5ef2aSThomas Huth fprintf(stderr, "Initial read of kernel register state failed\n"); 373fcf5ef2aSThomas Huth ret = -EINVAL; 374fcf5ef2aSThomas Huth goto out; 375fcf5ef2aSThomas Huth } 376fcf5ef2aSThomas Huth 377fcf5ef2aSThomas Huth out: 378fcf5ef2aSThomas Huth g_free(rlp); 379fcf5ef2aSThomas Huth return ret; 380fcf5ef2aSThomas Huth } 381fcf5ef2aSThomas Huth 382fcf5ef2aSThomas Huth bool write_kvmstate_to_list(ARMCPU *cpu) 383fcf5ef2aSThomas Huth { 384fcf5ef2aSThomas Huth CPUState *cs = CPU(cpu); 385fcf5ef2aSThomas Huth int i; 386fcf5ef2aSThomas Huth bool ok = true; 387fcf5ef2aSThomas Huth 388fcf5ef2aSThomas Huth for (i = 0; i < cpu->cpreg_array_len; i++) { 389fcf5ef2aSThomas Huth struct kvm_one_reg r; 390fcf5ef2aSThomas Huth uint64_t regidx = cpu->cpreg_indexes[i]; 391fcf5ef2aSThomas Huth uint32_t v32; 392fcf5ef2aSThomas Huth int ret; 393fcf5ef2aSThomas Huth 394fcf5ef2aSThomas Huth r.id = regidx; 395fcf5ef2aSThomas Huth 396fcf5ef2aSThomas Huth switch (regidx & KVM_REG_SIZE_MASK) { 397fcf5ef2aSThomas Huth case KVM_REG_SIZE_U32: 398fcf5ef2aSThomas Huth r.addr = (uintptr_t)&v32; 399fcf5ef2aSThomas Huth ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r); 400fcf5ef2aSThomas Huth if (!ret) { 401fcf5ef2aSThomas Huth cpu->cpreg_values[i] = v32; 402fcf5ef2aSThomas Huth } 403fcf5ef2aSThomas Huth break; 404fcf5ef2aSThomas Huth case KVM_REG_SIZE_U64: 405fcf5ef2aSThomas Huth r.addr = (uintptr_t)(cpu->cpreg_values + i); 406fcf5ef2aSThomas Huth ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r); 407fcf5ef2aSThomas Huth break; 408fcf5ef2aSThomas Huth default: 409fcf5ef2aSThomas Huth abort(); 410fcf5ef2aSThomas Huth } 411fcf5ef2aSThomas Huth if (ret) { 412fcf5ef2aSThomas Huth ok = false; 413fcf5ef2aSThomas Huth } 414fcf5ef2aSThomas Huth } 415fcf5ef2aSThomas Huth return ok; 416fcf5ef2aSThomas Huth } 417fcf5ef2aSThomas Huth 418fcf5ef2aSThomas Huth bool write_list_to_kvmstate(ARMCPU *cpu, int level) 419fcf5ef2aSThomas Huth { 420fcf5ef2aSThomas Huth CPUState *cs = CPU(cpu); 421fcf5ef2aSThomas Huth int i; 422fcf5ef2aSThomas Huth bool ok = true; 423fcf5ef2aSThomas Huth 424fcf5ef2aSThomas Huth for (i = 0; i < cpu->cpreg_array_len; i++) { 425fcf5ef2aSThomas Huth struct kvm_one_reg r; 426fcf5ef2aSThomas Huth uint64_t regidx = cpu->cpreg_indexes[i]; 427fcf5ef2aSThomas Huth uint32_t v32; 428fcf5ef2aSThomas Huth int ret; 429fcf5ef2aSThomas Huth 430fcf5ef2aSThomas Huth if (kvm_arm_cpreg_level(regidx) > level) { 431fcf5ef2aSThomas Huth continue; 432fcf5ef2aSThomas Huth } 433fcf5ef2aSThomas Huth 434fcf5ef2aSThomas Huth r.id = regidx; 435fcf5ef2aSThomas Huth switch (regidx & KVM_REG_SIZE_MASK) { 436fcf5ef2aSThomas Huth case KVM_REG_SIZE_U32: 437fcf5ef2aSThomas Huth v32 = cpu->cpreg_values[i]; 438fcf5ef2aSThomas Huth r.addr = (uintptr_t)&v32; 439fcf5ef2aSThomas Huth break; 440fcf5ef2aSThomas Huth case KVM_REG_SIZE_U64: 441fcf5ef2aSThomas Huth r.addr = (uintptr_t)(cpu->cpreg_values + i); 442fcf5ef2aSThomas Huth break; 443fcf5ef2aSThomas Huth default: 444fcf5ef2aSThomas Huth abort(); 445fcf5ef2aSThomas Huth } 446fcf5ef2aSThomas Huth ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r); 447fcf5ef2aSThomas Huth if (ret) { 448fcf5ef2aSThomas Huth /* We might fail for "unknown register" and also for 449fcf5ef2aSThomas Huth * "you tried to set a register which is constant with 450fcf5ef2aSThomas Huth * a different value from what it actually contains". 451fcf5ef2aSThomas Huth */ 452fcf5ef2aSThomas Huth ok = false; 453fcf5ef2aSThomas Huth } 454fcf5ef2aSThomas Huth } 455fcf5ef2aSThomas Huth return ok; 456fcf5ef2aSThomas Huth } 457fcf5ef2aSThomas Huth 458fcf5ef2aSThomas Huth void kvm_arm_reset_vcpu(ARMCPU *cpu) 459fcf5ef2aSThomas Huth { 460fcf5ef2aSThomas Huth int ret; 461fcf5ef2aSThomas Huth 462fcf5ef2aSThomas Huth /* Re-init VCPU so that all registers are set to 463fcf5ef2aSThomas Huth * their respective reset values. 464fcf5ef2aSThomas Huth */ 465fcf5ef2aSThomas Huth ret = kvm_arm_vcpu_init(CPU(cpu)); 466fcf5ef2aSThomas Huth if (ret < 0) { 467fcf5ef2aSThomas Huth fprintf(stderr, "kvm_arm_vcpu_init failed: %s\n", strerror(-ret)); 468fcf5ef2aSThomas Huth abort(); 469fcf5ef2aSThomas Huth } 470fcf5ef2aSThomas Huth if (!write_kvmstate_to_list(cpu)) { 471fcf5ef2aSThomas Huth fprintf(stderr, "write_kvmstate_to_list failed\n"); 472fcf5ef2aSThomas Huth abort(); 473fcf5ef2aSThomas Huth } 474fcf5ef2aSThomas Huth } 475fcf5ef2aSThomas Huth 476fcf5ef2aSThomas Huth /* 477fcf5ef2aSThomas Huth * Update KVM's MP_STATE based on what QEMU thinks it is 478fcf5ef2aSThomas Huth */ 479fcf5ef2aSThomas Huth int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu) 480fcf5ef2aSThomas Huth { 481fcf5ef2aSThomas Huth if (cap_has_mp_state) { 482fcf5ef2aSThomas Huth struct kvm_mp_state mp_state = { 483062ba099SAlex Bennée .mp_state = (cpu->power_state == PSCI_OFF) ? 484062ba099SAlex Bennée KVM_MP_STATE_STOPPED : KVM_MP_STATE_RUNNABLE 485fcf5ef2aSThomas Huth }; 486fcf5ef2aSThomas Huth int ret = kvm_vcpu_ioctl(CPU(cpu), KVM_SET_MP_STATE, &mp_state); 487fcf5ef2aSThomas Huth if (ret) { 488fcf5ef2aSThomas Huth fprintf(stderr, "%s: failed to set MP_STATE %d/%s\n", 489fcf5ef2aSThomas Huth __func__, ret, strerror(-ret)); 490fcf5ef2aSThomas Huth return -1; 491fcf5ef2aSThomas Huth } 492fcf5ef2aSThomas Huth } 493fcf5ef2aSThomas Huth 494fcf5ef2aSThomas Huth return 0; 495fcf5ef2aSThomas Huth } 496fcf5ef2aSThomas Huth 497fcf5ef2aSThomas Huth /* 498fcf5ef2aSThomas Huth * Sync the KVM MP_STATE into QEMU 499fcf5ef2aSThomas Huth */ 500fcf5ef2aSThomas Huth int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu) 501fcf5ef2aSThomas Huth { 502fcf5ef2aSThomas Huth if (cap_has_mp_state) { 503fcf5ef2aSThomas Huth struct kvm_mp_state mp_state; 504fcf5ef2aSThomas Huth int ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MP_STATE, &mp_state); 505fcf5ef2aSThomas Huth if (ret) { 506fcf5ef2aSThomas Huth fprintf(stderr, "%s: failed to get MP_STATE %d/%s\n", 507fcf5ef2aSThomas Huth __func__, ret, strerror(-ret)); 508fcf5ef2aSThomas Huth abort(); 509fcf5ef2aSThomas Huth } 510062ba099SAlex Bennée cpu->power_state = (mp_state.mp_state == KVM_MP_STATE_STOPPED) ? 511062ba099SAlex Bennée PSCI_OFF : PSCI_ON; 512fcf5ef2aSThomas Huth } 513fcf5ef2aSThomas Huth 514fcf5ef2aSThomas Huth return 0; 515fcf5ef2aSThomas Huth } 516fcf5ef2aSThomas Huth 517fcf5ef2aSThomas Huth void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run) 518fcf5ef2aSThomas Huth { 519fcf5ef2aSThomas Huth } 520fcf5ef2aSThomas Huth 521fcf5ef2aSThomas Huth MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run) 522fcf5ef2aSThomas Huth { 5235d721b78SAlexander Graf ARMCPU *cpu; 5245d721b78SAlexander Graf uint32_t switched_level; 5255d721b78SAlexander Graf 5265d721b78SAlexander Graf if (kvm_irqchip_in_kernel()) { 5275d721b78SAlexander Graf /* 5285d721b78SAlexander Graf * We only need to sync timer states with user-space interrupt 5295d721b78SAlexander Graf * controllers, so return early and save cycles if we don't. 5305d721b78SAlexander Graf */ 5315d721b78SAlexander Graf return MEMTXATTRS_UNSPECIFIED; 5325d721b78SAlexander Graf } 5335d721b78SAlexander Graf 5345d721b78SAlexander Graf cpu = ARM_CPU(cs); 5355d721b78SAlexander Graf 5365d721b78SAlexander Graf /* Synchronize our shadowed in-kernel device irq lines with the kvm ones */ 5375d721b78SAlexander Graf if (run->s.regs.device_irq_level != cpu->device_irq_level) { 5385d721b78SAlexander Graf switched_level = cpu->device_irq_level ^ run->s.regs.device_irq_level; 5395d721b78SAlexander Graf 5405d721b78SAlexander Graf qemu_mutex_lock_iothread(); 5415d721b78SAlexander Graf 5425d721b78SAlexander Graf if (switched_level & KVM_ARM_DEV_EL1_VTIMER) { 5435d721b78SAlexander Graf qemu_set_irq(cpu->gt_timer_outputs[GTIMER_VIRT], 5445d721b78SAlexander Graf !!(run->s.regs.device_irq_level & 5455d721b78SAlexander Graf KVM_ARM_DEV_EL1_VTIMER)); 5465d721b78SAlexander Graf switched_level &= ~KVM_ARM_DEV_EL1_VTIMER; 5475d721b78SAlexander Graf } 5485d721b78SAlexander Graf 5495d721b78SAlexander Graf if (switched_level & KVM_ARM_DEV_EL1_PTIMER) { 5505d721b78SAlexander Graf qemu_set_irq(cpu->gt_timer_outputs[GTIMER_PHYS], 5515d721b78SAlexander Graf !!(run->s.regs.device_irq_level & 5525d721b78SAlexander Graf KVM_ARM_DEV_EL1_PTIMER)); 5535d721b78SAlexander Graf switched_level &= ~KVM_ARM_DEV_EL1_PTIMER; 5545d721b78SAlexander Graf } 5555d721b78SAlexander Graf 556b1659527SAndrew Jones if (switched_level & KVM_ARM_DEV_PMU) { 557b1659527SAndrew Jones qemu_set_irq(cpu->pmu_interrupt, 558b1659527SAndrew Jones !!(run->s.regs.device_irq_level & KVM_ARM_DEV_PMU)); 559b1659527SAndrew Jones switched_level &= ~KVM_ARM_DEV_PMU; 560b1659527SAndrew Jones } 5615d721b78SAlexander Graf 5625d721b78SAlexander Graf if (switched_level) { 5635d721b78SAlexander Graf qemu_log_mask(LOG_UNIMP, "%s: unhandled in-kernel device IRQ %x\n", 5645d721b78SAlexander Graf __func__, switched_level); 5655d721b78SAlexander Graf } 5665d721b78SAlexander Graf 5675d721b78SAlexander Graf /* We also mark unknown levels as processed to not waste cycles */ 5685d721b78SAlexander Graf cpu->device_irq_level = run->s.regs.device_irq_level; 5695d721b78SAlexander Graf qemu_mutex_unlock_iothread(); 5705d721b78SAlexander Graf } 5715d721b78SAlexander Graf 572fcf5ef2aSThomas Huth return MEMTXATTRS_UNSPECIFIED; 573fcf5ef2aSThomas Huth } 574fcf5ef2aSThomas Huth 575fcf5ef2aSThomas Huth 576fcf5ef2aSThomas Huth int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) 577fcf5ef2aSThomas Huth { 578fcf5ef2aSThomas Huth int ret = 0; 579fcf5ef2aSThomas Huth 580fcf5ef2aSThomas Huth switch (run->exit_reason) { 581fcf5ef2aSThomas Huth case KVM_EXIT_DEBUG: 582fcf5ef2aSThomas Huth if (kvm_arm_handle_debug(cs, &run->debug.arch)) { 583fcf5ef2aSThomas Huth ret = EXCP_DEBUG; 584fcf5ef2aSThomas Huth } /* otherwise return to guest */ 585fcf5ef2aSThomas Huth break; 586fcf5ef2aSThomas Huth default: 587fcf5ef2aSThomas Huth qemu_log_mask(LOG_UNIMP, "%s: un-handled exit reason %d\n", 588fcf5ef2aSThomas Huth __func__, run->exit_reason); 589fcf5ef2aSThomas Huth break; 590fcf5ef2aSThomas Huth } 591fcf5ef2aSThomas Huth return ret; 592fcf5ef2aSThomas Huth } 593fcf5ef2aSThomas Huth 594fcf5ef2aSThomas Huth bool kvm_arch_stop_on_emulation_error(CPUState *cs) 595fcf5ef2aSThomas Huth { 596fcf5ef2aSThomas Huth return true; 597fcf5ef2aSThomas Huth } 598fcf5ef2aSThomas Huth 599fcf5ef2aSThomas Huth int kvm_arch_process_async_events(CPUState *cs) 600fcf5ef2aSThomas Huth { 601fcf5ef2aSThomas Huth return 0; 602fcf5ef2aSThomas Huth } 603fcf5ef2aSThomas Huth 604fcf5ef2aSThomas Huth /* The #ifdef protections are until 32bit headers are imported and can 605fcf5ef2aSThomas Huth * be removed once both 32 and 64 bit reach feature parity. 606fcf5ef2aSThomas Huth */ 607fcf5ef2aSThomas Huth void kvm_arch_update_guest_debug(CPUState *cs, struct kvm_guest_debug *dbg) 608fcf5ef2aSThomas Huth { 609fcf5ef2aSThomas Huth #ifdef KVM_GUESTDBG_USE_SW_BP 610fcf5ef2aSThomas Huth if (kvm_sw_breakpoints_active(cs)) { 611fcf5ef2aSThomas Huth dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP; 612fcf5ef2aSThomas Huth } 613fcf5ef2aSThomas Huth #endif 614fcf5ef2aSThomas Huth #ifdef KVM_GUESTDBG_USE_HW 615fcf5ef2aSThomas Huth if (kvm_arm_hw_debug_active(cs)) { 616fcf5ef2aSThomas Huth dbg->control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_HW; 617fcf5ef2aSThomas Huth kvm_arm_copy_hw_debug_data(&dbg->arch); 618fcf5ef2aSThomas Huth } 619fcf5ef2aSThomas Huth #endif 620fcf5ef2aSThomas Huth } 621fcf5ef2aSThomas Huth 622fcf5ef2aSThomas Huth void kvm_arch_init_irq_routing(KVMState *s) 623fcf5ef2aSThomas Huth { 624fcf5ef2aSThomas Huth } 625fcf5ef2aSThomas Huth 626fcf5ef2aSThomas Huth int kvm_arch_irqchip_create(MachineState *ms, KVMState *s) 627fcf5ef2aSThomas Huth { 628fcf5ef2aSThomas Huth if (machine_kernel_irqchip_split(ms)) { 629fcf5ef2aSThomas Huth perror("-machine kernel_irqchip=split is not supported on ARM."); 630fcf5ef2aSThomas Huth exit(1); 631fcf5ef2aSThomas Huth } 632fcf5ef2aSThomas Huth 633fcf5ef2aSThomas Huth /* If we can create the VGIC using the newer device control API, we 634fcf5ef2aSThomas Huth * let the device do this when it initializes itself, otherwise we 635fcf5ef2aSThomas Huth * fall back to the old API */ 636fcf5ef2aSThomas Huth return kvm_check_extension(s, KVM_CAP_DEVICE_CTRL); 637fcf5ef2aSThomas Huth } 638fcf5ef2aSThomas Huth 639fcf5ef2aSThomas Huth int kvm_arm_vgic_probe(void) 640fcf5ef2aSThomas Huth { 641fcf5ef2aSThomas Huth if (kvm_create_device(kvm_state, 642fcf5ef2aSThomas Huth KVM_DEV_TYPE_ARM_VGIC_V3, true) == 0) { 643fcf5ef2aSThomas Huth return 3; 644fcf5ef2aSThomas Huth } else if (kvm_create_device(kvm_state, 645fcf5ef2aSThomas Huth KVM_DEV_TYPE_ARM_VGIC_V2, true) == 0) { 646fcf5ef2aSThomas Huth return 2; 647fcf5ef2aSThomas Huth } else { 648fcf5ef2aSThomas Huth return 0; 649fcf5ef2aSThomas Huth } 650fcf5ef2aSThomas Huth } 651fcf5ef2aSThomas Huth 652fcf5ef2aSThomas Huth int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route, 653fcf5ef2aSThomas Huth uint64_t address, uint32_t data, PCIDevice *dev) 654fcf5ef2aSThomas Huth { 655b05c81d2SEric Auger AddressSpace *as = pci_device_iommu_address_space(dev); 656b05c81d2SEric Auger hwaddr xlat, len, doorbell_gpa; 657b05c81d2SEric Auger MemoryRegionSection mrs; 658b05c81d2SEric Auger MemoryRegion *mr; 659b05c81d2SEric Auger int ret = 1; 660b05c81d2SEric Auger 661b05c81d2SEric Auger if (as == &address_space_memory) { 662fcf5ef2aSThomas Huth return 0; 663fcf5ef2aSThomas Huth } 664fcf5ef2aSThomas Huth 665b05c81d2SEric Auger /* MSI doorbell address is translated by an IOMMU */ 666b05c81d2SEric Auger 667b05c81d2SEric Auger rcu_read_lock(); 668bc6b1cecSPeter Maydell mr = address_space_translate(as, address, &xlat, &len, true, 669bc6b1cecSPeter Maydell MEMTXATTRS_UNSPECIFIED); 670b05c81d2SEric Auger if (!mr) { 671b05c81d2SEric Auger goto unlock; 672b05c81d2SEric Auger } 673b05c81d2SEric Auger mrs = memory_region_find(mr, xlat, 1); 674b05c81d2SEric Auger if (!mrs.mr) { 675b05c81d2SEric Auger goto unlock; 676b05c81d2SEric Auger } 677b05c81d2SEric Auger 678b05c81d2SEric Auger doorbell_gpa = mrs.offset_within_address_space; 679b05c81d2SEric Auger memory_region_unref(mrs.mr); 680b05c81d2SEric Auger 681b05c81d2SEric Auger route->u.msi.address_lo = doorbell_gpa; 682b05c81d2SEric Auger route->u.msi.address_hi = doorbell_gpa >> 32; 683b05c81d2SEric Auger 684b05c81d2SEric Auger trace_kvm_arm_fixup_msi_route(address, doorbell_gpa); 685b05c81d2SEric Auger 686b05c81d2SEric Auger ret = 0; 687b05c81d2SEric Auger 688b05c81d2SEric Auger unlock: 689b05c81d2SEric Auger rcu_read_unlock(); 690b05c81d2SEric Auger return ret; 691b05c81d2SEric Auger } 692b05c81d2SEric Auger 693fcf5ef2aSThomas Huth int kvm_arch_add_msi_route_post(struct kvm_irq_routing_entry *route, 694fcf5ef2aSThomas Huth int vector, PCIDevice *dev) 695fcf5ef2aSThomas Huth { 696fcf5ef2aSThomas Huth return 0; 697fcf5ef2aSThomas Huth } 698fcf5ef2aSThomas Huth 699fcf5ef2aSThomas Huth int kvm_arch_release_virq_post(int virq) 700fcf5ef2aSThomas Huth { 701fcf5ef2aSThomas Huth return 0; 702fcf5ef2aSThomas Huth } 703fcf5ef2aSThomas Huth 704fcf5ef2aSThomas Huth int kvm_arch_msi_data_to_gsi(uint32_t data) 705fcf5ef2aSThomas Huth { 706fcf5ef2aSThomas Huth return (data - 32) & 0xffff; 707fcf5ef2aSThomas Huth } 708