289c2b4db8
Add printf-based GUEST_ASSERT macros and accompanying host-side support to
provide an assert-specific versions of GUEST_PRINTF(). To make it easier
to parse assert messages, for humans and bots alike, preserve/use the same
layout as host asserts, e.g. in the example below, the reported expression,
file, line number, and message are from the guest assertion, not the host
reporting of the assertion.
The call stack still captures the host reporting, but capturing the guest
stack is a less pressing concern, i.e. can be done in the future, and an
optimal solution would capture *both* the host and guest stacks, i.e.
capturing the host stack isn't an outright bug.
Running soft int test
==== Test Assertion Failure ====
x86_64/svm_nested_soft_inject_test.c:39: regs->rip != (unsigned long)l2_guest_code_int
pid=214104 tid=214104 errno=4 - Interrupted system call
1 0x0000000000401b35: run_test at svm_nested_soft_inject_test.c:191
2 0x00000000004017d2: main at svm_nested_soft_inject_test.c:212
3 0x0000000000415b03: __libc_start_call_main at libc-start.o:?
4 0x000000000041714f: __libc_start_main_impl at ??:?
5 0x0000000000401660: _start at ??:?
Expected IRQ at RIP 0x401e50, received IRQ at 0x401e50
Don't bother sharing code between ucall_assert() and ucall_fmt(), as
forwarding the variable arguments would either require using macros or
building a va_list, i.e. would make the code less readable and/or require
just as much copy+paste code anyways.
Gate the new macros with a flag so that tests can more or less be switched
over one-by-one. The slow conversion won't be perfect, e.g. library code
won't pick up the flag, but the only asserts in library code are of the
vanilla GUEST_ASSERT() variety, i.e. don't print out variables.
Add a temporary alias to GUEST_ASSERT_1() to fudge around ARM's
arch_timer.h header using GUEST_ASSERT_1(), thus thwarting any attempt to
convert tests one-by-one.
Link: https://lore.kernel.org/r/20230729003643.1053367-9-seanjc@google.com
Signed-off-by: Sean Christopherson <seanjc@google.com>
159 lines
3.2 KiB
C
159 lines
3.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
#include "kvm_util.h"
|
|
#include "linux/types.h"
|
|
#include "linux/bitmap.h"
|
|
#include "linux/atomic.h"
|
|
|
|
#define GUEST_UCALL_FAILED -1
|
|
|
|
struct ucall_header {
|
|
DECLARE_BITMAP(in_use, KVM_MAX_VCPUS);
|
|
struct ucall ucalls[KVM_MAX_VCPUS];
|
|
};
|
|
|
|
int ucall_nr_pages_required(uint64_t page_size)
|
|
{
|
|
return align_up(sizeof(struct ucall_header), page_size) / page_size;
|
|
}
|
|
|
|
/*
|
|
* ucall_pool holds per-VM values (global data is duplicated by each VM), it
|
|
* must not be accessed from host code.
|
|
*/
|
|
static struct ucall_header *ucall_pool;
|
|
|
|
void ucall_init(struct kvm_vm *vm, vm_paddr_t mmio_gpa)
|
|
{
|
|
struct ucall_header *hdr;
|
|
struct ucall *uc;
|
|
vm_vaddr_t vaddr;
|
|
int i;
|
|
|
|
vaddr = __vm_vaddr_alloc(vm, sizeof(*hdr), KVM_UTIL_MIN_VADDR, MEM_REGION_DATA);
|
|
hdr = (struct ucall_header *)addr_gva2hva(vm, vaddr);
|
|
memset(hdr, 0, sizeof(*hdr));
|
|
|
|
for (i = 0; i < KVM_MAX_VCPUS; ++i) {
|
|
uc = &hdr->ucalls[i];
|
|
uc->hva = uc;
|
|
}
|
|
|
|
write_guest_global(vm, ucall_pool, (struct ucall_header *)vaddr);
|
|
|
|
ucall_arch_init(vm, mmio_gpa);
|
|
}
|
|
|
|
static struct ucall *ucall_alloc(void)
|
|
{
|
|
struct ucall *uc;
|
|
int i;
|
|
|
|
if (!ucall_pool)
|
|
goto ucall_failed;
|
|
|
|
for (i = 0; i < KVM_MAX_VCPUS; ++i) {
|
|
if (!test_and_set_bit(i, ucall_pool->in_use)) {
|
|
uc = &ucall_pool->ucalls[i];
|
|
memset(uc->args, 0, sizeof(uc->args));
|
|
return uc;
|
|
}
|
|
}
|
|
|
|
ucall_failed:
|
|
/*
|
|
* If the vCPU cannot grab a ucall structure, make a bare ucall with a
|
|
* magic value to signal to get_ucall() that things went sideways.
|
|
* GUEST_ASSERT() depends on ucall_alloc() and so cannot be used here.
|
|
*/
|
|
ucall_arch_do_ucall(GUEST_UCALL_FAILED);
|
|
return NULL;
|
|
}
|
|
|
|
static void ucall_free(struct ucall *uc)
|
|
{
|
|
/* Beware, here be pointer arithmetic. */
|
|
clear_bit(uc - ucall_pool->ucalls, ucall_pool->in_use);
|
|
}
|
|
|
|
void ucall_assert(uint64_t cmd, const char *exp, const char *file,
|
|
unsigned int line, const char *fmt, ...)
|
|
{
|
|
struct ucall *uc;
|
|
va_list va;
|
|
|
|
uc = ucall_alloc();
|
|
uc->cmd = cmd;
|
|
|
|
WRITE_ONCE(uc->args[GUEST_ERROR_STRING], (uint64_t)(exp));
|
|
WRITE_ONCE(uc->args[GUEST_FILE], (uint64_t)(file));
|
|
WRITE_ONCE(uc->args[GUEST_LINE], line);
|
|
|
|
va_start(va, fmt);
|
|
guest_vsnprintf(uc->buffer, UCALL_BUFFER_LEN, fmt, va);
|
|
va_end(va);
|
|
|
|
ucall_arch_do_ucall((vm_vaddr_t)uc->hva);
|
|
|
|
ucall_free(uc);
|
|
}
|
|
|
|
void ucall_fmt(uint64_t cmd, const char *fmt, ...)
|
|
{
|
|
struct ucall *uc;
|
|
va_list va;
|
|
|
|
uc = ucall_alloc();
|
|
uc->cmd = cmd;
|
|
|
|
va_start(va, fmt);
|
|
guest_vsnprintf(uc->buffer, UCALL_BUFFER_LEN, fmt, va);
|
|
va_end(va);
|
|
|
|
ucall_arch_do_ucall((vm_vaddr_t)uc->hva);
|
|
|
|
ucall_free(uc);
|
|
}
|
|
|
|
void ucall(uint64_t cmd, int nargs, ...)
|
|
{
|
|
struct ucall *uc;
|
|
va_list va;
|
|
int i;
|
|
|
|
uc = ucall_alloc();
|
|
|
|
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);
|
|
|
|
ucall_arch_do_ucall((vm_vaddr_t)uc->hva);
|
|
|
|
ucall_free(uc);
|
|
}
|
|
|
|
uint64_t get_ucall(struct kvm_vcpu *vcpu, struct ucall *uc)
|
|
{
|
|
struct ucall ucall;
|
|
void *addr;
|
|
|
|
if (!uc)
|
|
uc = &ucall;
|
|
|
|
addr = ucall_arch_get_ucall(vcpu);
|
|
if (addr) {
|
|
TEST_ASSERT(addr != (void *)GUEST_UCALL_FAILED,
|
|
"Guest failed to allocate ucall struct");
|
|
|
|
memcpy(uc, addr, sizeof(*uc));
|
|
vcpu_run_complete_io(vcpu);
|
|
} else {
|
|
memset(uc, 0, sizeof(*uc));
|
|
}
|
|
|
|
return uc->cmd;
|
|
}
|