Kernel/linux-next
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git synced 2025-01-10 07:50:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

KVM: selftests: Convert emulator_error_test away from VCPU_ID

Browse Source 
Convert emulator_error_test to use vm_create_with_one_vcpu() and pass
around a 'struct kvm_vcpu' object instead of using a global VCPU_ID.  Note,
this is a "functional" change in the sense that the test now creates a vCPU
with vcpu_id==0 instead of vcpu_id==5.  The non-zero VCPU_ID was 100%
arbitrary and added little to no validation coverage.  If testing non-zero
vCPU IDs is desirable for generic tests, that can be done in the future by
tweaking the VM creation helpers.

Opportunistically use vcpu_run() instead of _vcpu_run() with an open
coded assert that KVM_RUN succeeded.

Signed-off-by: Sean Christopherson <seanjc@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Sean Christopherson 2022-02-15 17:02:44 -08:00 committed by Paolo Bonzini
parent be0dff8610
commit 42975c2199
1 changed files with 28 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
tools/testing/selftests/kvm/x86_64/emulator_error_test.c
View File

@ -11,7 +11,6 @@
#include "kvm_util.h"
#include "vmx.h"
#define VCPU_ID 1
#define MAXPHYADDR 36
#define MEM_REGION_GVA 0x0000123456789000
@ -27,14 +26,6 @@ static void guest_code(void)
GUEST_DONE();
}
static void run_guest(struct kvm_vm *vm)
{
int rc;
rc = _vcpu_run(vm, VCPU_ID);
TEST_ASSERT(rc == 0, "vcpu_run failed: %d\n", rc);
}
/*
* Accessors to get R/M, REG, and Mod bits described in the SDM vol 2,
* figure 2-2 "Table Interpretation of ModR/M Byte (C8H)".
@ -56,9 +47,9 @@ static bool is_flds(uint8_t *insn_bytes, uint8_t insn_size)
GET_RM(insn_bytes[1]) != 0x5;
}
static void process_exit_on_emulation_error(struct kvm_vm *vm)
static void process_exit_on_emulation_error(struct kvm_vcpu *vcpu)
{
struct kvm_run *run = vcpu_state(vm, VCPU_ID);
struct kvm_run *run = vcpu->run;
struct kvm_regs regs;
uint8_t *insn_bytes;
uint8_t insn_size;
@ -92,50 +83,49 @@ static void process_exit_on_emulation_error(struct kvm_vm *vm)
* contained an flds instruction that is 2-bytes in
* length (ie: no prefix, no SIB, no displacement).
*/
vcpu_regs_get(vm, VCPU_ID, &regs);
vcpu_regs_get(vcpu->vm, vcpu->id, &regs);
regs.rip += 2;
vcpu_regs_set(vm, VCPU_ID, &regs);
vcpu_regs_set(vcpu->vm, vcpu->id, &regs);
}
}
}
static void do_guest_assert(struct kvm_vm *vm, struct ucall *uc)
static void do_guest_assert(struct ucall *uc)
{
TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0], __FILE__,
uc->args[1]);
}
static void check_for_guest_assert(struct kvm_vm *vm)
static void check_for_guest_assert(struct kvm_vcpu *vcpu)
{
struct kvm_run *run = vcpu_state(vm, VCPU_ID);
struct ucall uc;
if (run->exit_reason == KVM_EXIT_IO &&
get_ucall(vm, VCPU_ID, &uc) == UCALL_ABORT) {
do_guest_assert(vm, &uc);
if (vcpu->run->exit_reason == KVM_EXIT_IO &&
get_ucall(vcpu->vm, vcpu->id, &uc) == UCALL_ABORT) {
do_guest_assert(&uc);
}
}
static void process_ucall_done(struct kvm_vm *vm)
static void process_ucall_done(struct kvm_vcpu *vcpu)
{
struct kvm_run *run = vcpu_state(vm, VCPU_ID);
struct kvm_run *run = vcpu->run;
struct ucall uc;
check_for_guest_assert(vm);
check_for_guest_assert(vcpu);
TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
"Unexpected exit reason: %u (%s)",
run->exit_reason,
exit_reason_str(run->exit_reason));
TEST_ASSERT(get_ucall(vm, VCPU_ID, &uc) == UCALL_DONE,
TEST_ASSERT(get_ucall(vcpu->vm, vcpu->id, &uc) == UCALL_DONE,
"Unexpected ucall command: %lu, expected UCALL_DONE (%d)",
uc.cmd, UCALL_DONE);
}
static uint64_t process_ucall(struct kvm_vm *vm)
static uint64_t process_ucall(struct kvm_vcpu *vcpu)
{
struct kvm_run *run = vcpu_state(vm, VCPU_ID);
struct kvm_run *run = vcpu->run;
struct ucall uc;
TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
@ -143,14 +133,14 @@ static uint64_t process_ucall(struct kvm_vm *vm)
run->exit_reason,
exit_reason_str(run->exit_reason));
switch (get_ucall(vm, VCPU_ID, &uc)) {
switch (get_ucall(vcpu->vm, vcpu->id, &uc)) {
case UCALL_SYNC:
break;
case UCALL_ABORT:
do_guest_assert(vm, &uc);
do_guest_assert(&uc);
break;
case UCALL_DONE:
process_ucall_done(vm);
process_ucall_done(vcpu);
break;
default:
TEST_ASSERT(false, "Unexpected ucall");
@ -163,6 +153,7 @@ int main(int argc, char *argv[])
{
struct kvm_cpuid_entry2 *entry;
struct kvm_cpuid2 *cpuid;
struct kvm_vcpu *vcpu;
struct kvm_vm *vm;
uint64_t gpa, pte;
uint64_t *hva;
@ -171,20 +162,20 @@ int main(int argc, char *argv[])
/* Tell stdout not to buffer its content */
setbuf(stdout, NULL);
vm = vm_create_default(VCPU_ID, 0, guest_code);
if (!kvm_check_cap(KVM_CAP_SMALLER_MAXPHYADDR)) {
printf("module parameter 'allow_smaller_maxphyaddr' is not set. Skipping test.\n");
return 0;
}
vm = vm_create_with_one_vcpu(&vcpu, guest_code);
cpuid = kvm_get_supported_cpuid();
entry = kvm_get_supported_cpuid_index(0x80000008, 0);
entry->eax = (entry->eax & 0xffffff00) | MAXPHYADDR;
set_cpuid(cpuid, entry);
vcpu_set_cpuid(vm, VCPU_ID, cpuid);
vcpu_set_cpuid(vm, vcpu->id, cpuid);
rc = kvm_check_cap(KVM_CAP_EXIT_ON_EMULATION_FAILURE);
TEST_ASSERT(rc, "KVM_CAP_EXIT_ON_EMULATION_FAILURE is unavailable");
@ -199,14 +190,14 @@ int main(int argc, char *argv[])
virt_map(vm, MEM_REGION_GVA, MEM_REGION_GPA, 1);
hva = addr_gpa2hva(vm, MEM_REGION_GPA);
memset(hva, 0, PAGE_SIZE);
pte = vm_get_page_table_entry(vm, VCPU_ID, MEM_REGION_GVA);
vm_set_page_table_entry(vm, VCPU_ID, MEM_REGION_GVA, pte | (1ull << 36));
pte = vm_get_page_table_entry(vm, vcpu->id, MEM_REGION_GVA);
vm_set_page_table_entry(vm, vcpu->id, MEM_REGION_GVA, pte | (1ull << 36));
run_guest(vm);
process_exit_on_emulation_error(vm);
run_guest(vm);
vcpu_run(vm, vcpu->id);
process_exit_on_emulation_error(vcpu);
vcpu_run(vm, vcpu->id);
TEST_ASSERT(process_ucall(vm) == UCALL_DONE, "Expected UCALL_DONE");
TEST_ASSERT(process_ucall(vcpu) == UCALL_DONE, "Expected UCALL_DONE");
kvm_vm_free(vm);