63f4b21041
KVM/s390, KVM/x86 and common infrastructure changes for 5.20 x86: * Permit guests to ignore single-bit ECC errors * Fix races in gfn->pfn cache refresh; do not pin pages tracked by the cache * Intel IPI virtualization * Allow getting/setting pending triple fault with KVM_GET/SET_VCPU_EVENTS * PEBS virtualization * Simplify PMU emulation by just using PERF_TYPE_RAW events * More accurate event reinjection on SVM (avoid retrying instructions) * Allow getting/setting the state of the speaker port data bit * Refuse starting the kvm-intel module if VM-Entry/VM-Exit controls are inconsistent * "Notify" VM exit (detect microarchitectural hangs) for Intel * Cleanups for MCE MSR emulation s390: * add an interface to provide a hypervisor dump for secure guests * improve selftests to use TAP interface * enable interpretive execution of zPCI instructions (for PCI passthrough) * First part of deferred teardown * CPU Topology * PV attestation * Minor fixes Generic: * new selftests API using struct kvm_vcpu instead of a (vm, id) tuple x86: * Use try_cmpxchg64 instead of cmpxchg64 * Bugfixes * Ignore benign host accesses to PMU MSRs when PMU is disabled * Allow disabling KVM's "MONITOR/MWAIT are NOPs!" behavior * x86/MMU: Allow NX huge pages to be disabled on a per-vm basis * Port eager page splitting to shadow MMU as well * Enable CMCI capability by default and handle injected UCNA errors * Expose pid of vcpu threads in debugfs * x2AVIC support for AMD * cleanup PIO emulation * Fixes for LLDT/LTR emulation * Don't require refcounted "struct page" to create huge SPTEs x86 cleanups: * Use separate namespaces for guest PTEs and shadow PTEs bitmasks * PIO emulation * Reorganize rmap API, mostly around rmap destruction * Do not workaround very old KVM bugs for L0 that runs with nesting enabled * new selftests API for CPUID
113 lines
2.9 KiB
C
113 lines
2.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* ucall support. A ucall is a "hypercall to userspace".
|
|
*
|
|
* Copyright (C) 2018, Red Hat, Inc.
|
|
*/
|
|
#include "kvm_util.h"
|
|
|
|
static vm_vaddr_t *ucall_exit_mmio_addr;
|
|
|
|
static bool ucall_mmio_init(struct kvm_vm *vm, vm_paddr_t gpa)
|
|
{
|
|
if (kvm_userspace_memory_region_find(vm, gpa, gpa + 1))
|
|
return false;
|
|
|
|
virt_pg_map(vm, gpa, gpa);
|
|
|
|
ucall_exit_mmio_addr = (vm_vaddr_t *)gpa;
|
|
sync_global_to_guest(vm, ucall_exit_mmio_addr);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ucall_init(struct kvm_vm *vm, void *arg)
|
|
{
|
|
vm_paddr_t gpa, start, end, step, offset;
|
|
unsigned int bits;
|
|
bool ret;
|
|
|
|
if (arg) {
|
|
gpa = (vm_paddr_t)arg;
|
|
ret = ucall_mmio_init(vm, gpa);
|
|
TEST_ASSERT(ret, "Can't set ucall mmio address to %lx", gpa);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Find an address within the allowed physical and virtual address
|
|
* spaces, that does _not_ have a KVM memory region associated with
|
|
* it. Identity mapping an address like this allows the guest to
|
|
* access it, but as KVM doesn't know what to do with it, it
|
|
* will assume it's something userspace handles and exit with
|
|
* KVM_EXIT_MMIO. Well, at least that's how it works for AArch64.
|
|
* Here we start with a guess that the addresses around 5/8th
|
|
* of the allowed space are unmapped and then work both down and
|
|
* up from there in 1/16th allowed space sized steps.
|
|
*
|
|
* Note, we need to use VA-bits - 1 when calculating the allowed
|
|
* virtual address space for an identity mapping because the upper
|
|
* half of the virtual address space is the two's complement of the
|
|
* lower and won't match physical addresses.
|
|
*/
|
|
bits = vm->va_bits - 1;
|
|
bits = min(vm->pa_bits, bits);
|
|
end = 1ul << bits;
|
|
start = end * 5 / 8;
|
|
step = end / 16;
|
|
for (offset = 0; offset < end - start; offset += step) {
|
|
if (ucall_mmio_init(vm, start - offset))
|
|
return;
|
|
if (ucall_mmio_init(vm, start + offset))
|
|
return;
|
|
}
|
|
TEST_FAIL("Can't find a ucall mmio address");
|
|
}
|
|
|
|
void ucall_uninit(struct kvm_vm *vm)
|
|
{
|
|
ucall_exit_mmio_addr = 0;
|
|
sync_global_to_guest(vm, ucall_exit_mmio_addr);
|
|
}
|
|
|
|
void ucall(uint64_t cmd, int nargs, ...)
|
|
{
|
|
struct ucall uc = {};
|
|
va_list va;
|
|
int i;
|
|
|
|
WRITE_ONCE(uc.cmd, cmd);
|
|
nargs = min(nargs, UCALL_MAX_ARGS);
|
|
|
|
va_start(va, nargs);
|
|
for (i = 0; i < nargs; ++i)
|
|
WRITE_ONCE(uc.args[i], va_arg(va, uint64_t));
|
|
va_end(va);
|
|
|
|
WRITE_ONCE(*ucall_exit_mmio_addr, (vm_vaddr_t)&uc);
|
|
}
|
|
|
|
uint64_t get_ucall(struct kvm_vcpu *vcpu, struct ucall *uc)
|
|
{
|
|
struct kvm_run *run = vcpu->run;
|
|
struct ucall ucall = {};
|
|
|
|
if (uc)
|
|
memset(uc, 0, sizeof(*uc));
|
|
|
|
if (run->exit_reason == KVM_EXIT_MMIO &&
|
|
run->mmio.phys_addr == (uint64_t)ucall_exit_mmio_addr) {
|
|
vm_vaddr_t gva;
|
|
|
|
TEST_ASSERT(run->mmio.is_write && run->mmio.len == 8,
|
|
"Unexpected ucall exit mmio address access");
|
|
memcpy(&gva, run->mmio.data, sizeof(gva));
|
|
memcpy(&ucall, addr_gva2hva(vcpu->vm, gva), sizeof(ucall));
|
|
|
|
vcpu_run_complete_io(vcpu);
|
|
if (uc)
|
|
memcpy(uc, &ucall, sizeof(ucall));
|
|
}
|
|
|
|
return ucall.cmd;
|
|
}
|