Align x86/vmx.h' enum Reasons with Linux's arch/x86/include/uapi/asm/vmx.h EXIT_REASON_* definitions. Given how exit codes are wired up already in KUT, it doesn't make a whole lot of sense to switch to the uapi header itself; however, aligning the definitions makes it easier to grok from one code base to another. Note: this change picks up several previously undefined exit reasons, such as UMWAIT, TPAUSE, BUS_LOCK, NOTIFY, TDCALL but does not add test cases for them. Note: Fixed misc indentation issues picked up by checkpatch along the way. No functional change intended. Signed-off-by: Jon Kohler --- x86/vmx.c | 134 ++++++++++++----------- x86/vmx.h | 125 +++++++++++---------- x86/vmx_tests.c | 283 +++++++++++++++++++++++++----------------------- 3 files changed, 280 insertions(+), 262 deletions(-) diff --git a/x86/vmx.c b/x86/vmx.c index 7be93a72..98b05754 100644 --- a/x86/vmx.c +++ b/x86/vmx.c @@ -582,67 +582,71 @@ static void __attribute__((__used__)) syscall_handler(u64 syscall_no) current->syscall_handler(syscall_no); } +/* Naming scheme aligns with Linux's arch/x86/include/uapi/asm/vmx.h */ static const char * const exit_reason_descriptions[] = { - [VMX_EXC_NMI] = "VMX_EXC_NMI", - [VMX_EXTINT] = "VMX_EXTINT", - [VMX_TRIPLE_FAULT] = "VMX_TRIPLE_FAULT", - [VMX_INIT] = "VMX_INIT", - [VMX_SIPI] = "VMX_SIPI", - [VMX_SMI_IO] = "VMX_SMI_IO", - [VMX_SMI_OTHER] = "VMX_SMI_OTHER", - [VMX_INTR_WINDOW] = "VMX_INTR_WINDOW", - [VMX_NMI_WINDOW] = "VMX_NMI_WINDOW", - [VMX_TASK_SWITCH] = "VMX_TASK_SWITCH", - [VMX_CPUID] = "VMX_CPUID", - [VMX_GETSEC] = "VMX_GETSEC", - [VMX_HLT] = "VMX_HLT", - [VMX_INVD] = "VMX_INVD", - [VMX_INVLPG] = "VMX_INVLPG", - [VMX_RDPMC] = "VMX_RDPMC", - [VMX_RDTSC] = "VMX_RDTSC", - [VMX_RSM] = "VMX_RSM", - [VMX_VMCALL] = "VMX_VMCALL", - [VMX_VMCLEAR] = "VMX_VMCLEAR", - [VMX_VMLAUNCH] = "VMX_VMLAUNCH", - [VMX_VMPTRLD] = "VMX_VMPTRLD", - [VMX_VMPTRST] = "VMX_VMPTRST", - [VMX_VMREAD] = "VMX_VMREAD", - [VMX_VMRESUME] = "VMX_VMRESUME", - [VMX_VMWRITE] = "VMX_VMWRITE", - [VMX_VMXOFF] = "VMX_VMXOFF", - [VMX_VMXON] = "VMX_VMXON", - [VMX_CR] = "VMX_CR", - [VMX_DR] = "VMX_DR", - [VMX_IO] = "VMX_IO", - [VMX_RDMSR] = "VMX_RDMSR", - [VMX_WRMSR] = "VMX_WRMSR", - [VMX_FAIL_STATE] = "VMX_FAIL_STATE", - [VMX_FAIL_MSR] = "VMX_FAIL_MSR", - [VMX_MWAIT] = "VMX_MWAIT", - [VMX_MTF] = "VMX_MTF", - [VMX_MONITOR] = "VMX_MONITOR", - [VMX_PAUSE] = "VMX_PAUSE", - [VMX_FAIL_MCHECK] = "VMX_FAIL_MCHECK", - [VMX_TPR_THRESHOLD] = "VMX_TPR_THRESHOLD", - [VMX_APIC_ACCESS] = "VMX_APIC_ACCESS", - [VMX_EOI_INDUCED] = "VMX_EOI_INDUCED", - [VMX_GDTR_IDTR] = "VMX_GDTR_IDTR", - [VMX_LDTR_TR] = "VMX_LDTR_TR", - [VMX_EPT_VIOLATION] = "VMX_EPT_VIOLATION", - [VMX_EPT_MISCONFIG] = "VMX_EPT_MISCONFIG", - [VMX_INVEPT] = "VMX_INVEPT", - [VMX_PREEMPT] = "VMX_PREEMPT", - [VMX_INVVPID] = "VMX_INVVPID", - [VMX_WBINVD] = "VMX_WBINVD", - [VMX_XSETBV] = "VMX_XSETBV", - [VMX_APIC_WRITE] = "VMX_APIC_WRITE", - [VMX_RDRAND] = "VMX_RDRAND", - [VMX_INVPCID] = "VMX_INVPCID", - [VMX_VMFUNC] = "VMX_VMFUNC", - [VMX_RDSEED] = "VMX_RDSEED", - [VMX_PML_FULL] = "VMX_PML_FULL", - [VMX_XSAVES] = "VMX_XSAVES", - [VMX_XRSTORS] = "VMX_XRSTORS", + [EXIT_REASON_EXCEPTION_NMI] = "EXCEPTION_NMI", + [EXIT_REASON_EXTERNAL_INTERRUPT] = "EXTERNAL_INTERRUPT", + [EXIT_REASON_TRIPLE_FAULT] = "TRIPLE_FAULT", + [EXIT_REASON_INIT_SIGNAL] = "INIT_SIGNAL", + [EXIT_REASON_SIPI_SIGNAL] = "SIPI_SIGNAL", + [EXIT_REASON_INTERRUPT_WINDOW] = "INTERRUPT_WINDOW", + [EXIT_REASON_NMI_WINDOW] = "NMI_WINDOW", + [EXIT_REASON_TASK_SWITCH] = "TASK_SWITCH", + [EXIT_REASON_CPUID] = "CPUID", + [EXIT_REASON_HLT] = "HLT", + [EXIT_REASON_INVD] = "INVD", + [EXIT_REASON_INVLPG] = "INVLPG", + [EXIT_REASON_RDPMC] = "RDPMC", + [EXIT_REASON_RDTSC] = "RDTSC", + [EXIT_REASON_VMCALL] = "VMCALL", + [EXIT_REASON_VMCLEAR] = "VMCLEAR", + [EXIT_REASON_VMLAUNCH] = "VMLAUNCH", + [EXIT_REASON_VMPTRLD] = "VMPTRLD", + [EXIT_REASON_VMPTRST] = "VMPTRST", + [EXIT_REASON_VMREAD] = "VMREAD", + [EXIT_REASON_VMRESUME] = "VMRESUME", + [EXIT_REASON_VMWRITE] = "VMWRITE", + [EXIT_REASON_VMOFF] = "VMOFF", + [EXIT_REASON_VMON] = "VMON", + [EXIT_REASON_CR_ACCESS] = "CR_ACCESS", + [EXIT_REASON_DR_ACCESS] = "DR_ACCESS", + [EXIT_REASON_IO_INSTRUCTION] = "IO_INSTRUCTION", + [EXIT_REASON_MSR_READ] = "MSR_READ", + [EXIT_REASON_MSR_WRITE] = "MSR_WRITE", + [EXIT_REASON_INVALID_STATE] = "INVALID_STATE", + [EXIT_REASON_MSR_LOAD_FAIL] = "MSR_LOAD_FAIL", + [EXIT_REASON_MWAIT_INSTRUCTION] = "MWAIT_INSTRUCTION", + [EXIT_REASON_MONITOR_TRAP_FLAG] = "MONITOR_TRAP_FLAG", + [EXIT_REASON_MONITOR_INSTRUCTION] = "MONITOR_INSTRUCTION", + [EXIT_REASON_PAUSE_INSTRUCTION] = "PAUSE_INSTRUCTION", + [EXIT_REASON_MCE_DURING_VMENTRY] = "MCE_DURING_VMENTRY", + [EXIT_REASON_TPR_BELOW_THRESHOLD] = "TPR_BELOW_THRESHOLD", + [EXIT_REASON_APIC_ACCESS] = "APIC_ACCESS", + [EXIT_REASON_EOI_INDUCED] = "EOI_INDUCED", + [EXIT_REASON_GDTR_IDTR] = "GDTR_IDTR", + [EXIT_REASON_LDTR_TR] = "LDTR_TR", + [EXIT_REASON_EPT_VIOLATION] = "EPT_VIOLATION", + [EXIT_REASON_EPT_MISCONFIG] = "EPT_MISCONFIG", + [EXIT_REASON_INVEPT] = "INVEPT", + [EXIT_REASON_RDTSCP] = "RDTSCP", + [EXIT_REASON_PREEMPTION_TIMER] = "PREEMPTION_TIMER", + [EXIT_REASON_INVVPID] = "INVVPID", + [EXIT_REASON_WBINVD] = "WBINVD", + [EXIT_REASON_XSETBV] = "XSETBV", + [EXIT_REASON_APIC_WRITE] = "APIC_WRITE", + [EXIT_REASON_RDRAND] = "RDRAND", + [EXIT_REASON_INVPCID] = "INVPCID", + [EXIT_REASON_VMFUNC] = "VMFUNC", + [EXIT_REASON_ENCLS] = "ENCLS", + [EXIT_REASON_RDSEED] = "RDSEED", + [EXIT_REASON_PML_FULL] = "PML_FULL", + [EXIT_REASON_XSAVES] = "XSAVES", + [EXIT_REASON_XRSTORS] = "XRSTORS", + [EXIT_REASON_UMWAIT] = "UMWAIT", + [EXIT_REASON_TPAUSE] = "TPAUSE", + [EXIT_REASON_BUS_LOCK] = "BUS_LOCK", + [EXIT_REASON_NOTIFY] = "NOTIFY", + [EXIT_REASON_TDCALL] = "TDCALL", }; const char *exit_reason_description(u64 reason) @@ -698,13 +702,13 @@ void print_vmentry_failure_info(struct vmentry_result *result) result->instr, result->exit_reason.full, qual); switch (result->exit_reason.basic) { - case VMX_FAIL_STATE: + case EXIT_REASON_INVALID_STATE: printf("invalid guest state\n"); break; - case VMX_FAIL_MSR: + case EXIT_REASON_MSR_LOAD_FAIL: printf("MSR loading\n"); break; - case VMX_FAIL_MCHECK: + case EXIT_REASON_MCE_DURING_VMENTRY: printf("machine-check event\n"); break; default: @@ -1681,7 +1685,7 @@ void __attribute__((__used__)) hypercall(u32 hypercall_no) static bool is_hypercall(union exit_reason exit_reason) { - return exit_reason.basic == VMX_VMCALL && + return exit_reason.basic == EXIT_REASON_VMCALL && (hypercall_field & HYPERCALL_BIT); } @@ -2002,7 +2006,7 @@ void __enter_guest(u8 abort_flag, struct vmentry_result *result) } if (result->exit_reason.failed_vmentry) { if ((abort_flag & ABORT_ON_INVALID_GUEST_STATE) || - result->exit_reason.basic != VMX_FAIL_STATE) + result->exit_reason.basic != EXIT_REASON_INVALID_STATE) goto do_abort; return; } diff --git a/x86/vmx.h b/x86/vmx.h index 99ba7e52..5001886b 100644 --- a/x86/vmx.h +++ b/x86/vmx.h @@ -343,67 +343,72 @@ enum Encoding { #define VMX_ENTRY_FLAGS (X86_EFLAGS_CF | X86_EFLAGS_PF | X86_EFLAGS_AF | \ X86_EFLAGS_ZF | X86_EFLAGS_SF | X86_EFLAGS_OF) +/* Naming scheme aligns with Linux's arch/x86/include/uapi/asm/vmx.h */ enum Reason { - VMX_EXC_NMI = 0, - VMX_EXTINT = 1, - VMX_TRIPLE_FAULT = 2, - VMX_INIT = 3, - VMX_SIPI = 4, - VMX_SMI_IO = 5, - VMX_SMI_OTHER = 6, - VMX_INTR_WINDOW = 7, - VMX_NMI_WINDOW = 8, - VMX_TASK_SWITCH = 9, - VMX_CPUID = 10, - VMX_GETSEC = 11, - VMX_HLT = 12, - VMX_INVD = 13, - VMX_INVLPG = 14, - VMX_RDPMC = 15, - VMX_RDTSC = 16, - VMX_RSM = 17, - VMX_VMCALL = 18, - VMX_VMCLEAR = 19, - VMX_VMLAUNCH = 20, - VMX_VMPTRLD = 21, - VMX_VMPTRST = 22, - VMX_VMREAD = 23, - VMX_VMRESUME = 24, - VMX_VMWRITE = 25, - VMX_VMXOFF = 26, - VMX_VMXON = 27, - VMX_CR = 28, - VMX_DR = 29, - VMX_IO = 30, - VMX_RDMSR = 31, - VMX_WRMSR = 32, - VMX_FAIL_STATE = 33, - VMX_FAIL_MSR = 34, - VMX_MWAIT = 36, - VMX_MTF = 37, - VMX_MONITOR = 39, - VMX_PAUSE = 40, - VMX_FAIL_MCHECK = 41, - VMX_TPR_THRESHOLD = 43, - VMX_APIC_ACCESS = 44, - VMX_EOI_INDUCED = 45, - VMX_GDTR_IDTR = 46, - VMX_LDTR_TR = 47, - VMX_EPT_VIOLATION = 48, - VMX_EPT_MISCONFIG = 49, - VMX_INVEPT = 50, - VMX_PREEMPT = 52, - VMX_INVVPID = 53, - VMX_WBINVD = 54, - VMX_XSETBV = 55, - VMX_APIC_WRITE = 56, - VMX_RDRAND = 57, - VMX_INVPCID = 58, - VMX_VMFUNC = 59, - VMX_RDSEED = 61, - VMX_PML_FULL = 62, - VMX_XSAVES = 63, - VMX_XRSTORS = 64, + EXIT_REASON_EXCEPTION_NMI = 0, + EXIT_REASON_EXTERNAL_INTERRUPT = 1, + EXIT_REASON_TRIPLE_FAULT = 2, + EXIT_REASON_INIT_SIGNAL = 3, + EXIT_REASON_SIPI_SIGNAL = 4, + EXIT_REASON_OTHER_SMI = 6, + EXIT_REASON_INTERRUPT_WINDOW = 7, + EXIT_REASON_NMI_WINDOW = 8, + EXIT_REASON_TASK_SWITCH = 9, + EXIT_REASON_CPUID = 10, + EXIT_REASON_HLT = 12, + EXIT_REASON_INVD = 13, + EXIT_REASON_INVLPG = 14, + EXIT_REASON_RDPMC = 15, + EXIT_REASON_RDTSC = 16, + EXIT_REASON_VMCALL = 18, + EXIT_REASON_VMCLEAR = 19, + EXIT_REASON_VMLAUNCH = 20, + EXIT_REASON_VMPTRLD = 21, + EXIT_REASON_VMPTRST = 22, + EXIT_REASON_VMREAD = 23, + EXIT_REASON_VMRESUME = 24, + EXIT_REASON_VMWRITE = 25, + EXIT_REASON_VMOFF = 26, + EXIT_REASON_VMON = 27, + EXIT_REASON_CR_ACCESS = 28, + EXIT_REASON_DR_ACCESS = 29, + EXIT_REASON_IO_INSTRUCTION = 30, + EXIT_REASON_MSR_READ = 31, + EXIT_REASON_MSR_WRITE = 32, + EXIT_REASON_INVALID_STATE = 33, + EXIT_REASON_MSR_LOAD_FAIL = 34, + EXIT_REASON_MWAIT_INSTRUCTION = 36, + EXIT_REASON_MONITOR_TRAP_FLAG = 37, + EXIT_REASON_MONITOR_INSTRUCTION = 39, + EXIT_REASON_PAUSE_INSTRUCTION = 40, + EXIT_REASON_MCE_DURING_VMENTRY = 41, + EXIT_REASON_TPR_BELOW_THRESHOLD = 43, + EXIT_REASON_APIC_ACCESS = 44, + EXIT_REASON_EOI_INDUCED = 45, + EXIT_REASON_GDTR_IDTR = 46, + EXIT_REASON_LDTR_TR = 47, + EXIT_REASON_EPT_VIOLATION = 48, + EXIT_REASON_EPT_MISCONFIG = 49, + EXIT_REASON_INVEPT = 50, + EXIT_REASON_RDTSCP = 51, + EXIT_REASON_PREEMPTION_TIMER = 52, + EXIT_REASON_INVVPID = 53, + EXIT_REASON_WBINVD = 54, + EXIT_REASON_XSETBV = 55, + EXIT_REASON_APIC_WRITE = 56, + EXIT_REASON_RDRAND = 57, + EXIT_REASON_INVPCID = 58, + EXIT_REASON_VMFUNC = 59, + EXIT_REASON_ENCLS = 60, + EXIT_REASON_RDSEED = 61, + EXIT_REASON_PML_FULL = 62, + EXIT_REASON_XSAVES = 63, + EXIT_REASON_XRSTORS = 64, + EXIT_REASON_UMWAIT = 67, + EXIT_REASON_TPAUSE = 68, + EXIT_REASON_BUS_LOCK = 74, + EXIT_REASON_NOTIFY = 75, + EXIT_REASON_TDCALL = 77, }; diff --git a/x86/vmx_tests.c b/x86/vmx_tests.c index 338e39b0..dd4bd43c 100644 --- a/x86/vmx_tests.c +++ b/x86/vmx_tests.c @@ -106,7 +106,7 @@ static int vmenter_exit_handler(union exit_reason exit_reason) u64 guest_rip = vmcs_read(GUEST_RIP); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: if (regs.rax != 0xABCD) { report_fail("test vmresume"); return VMX_TEST_VMEXIT; @@ -178,7 +178,7 @@ static int preemption_timer_exit_handler(union exit_reason exit_reason) guest_rip = vmcs_read(GUEST_RIP); insn_len = vmcs_read(EXI_INST_LEN); switch (exit_reason.basic) { - case VMX_PREEMPT: + case EXIT_REASON_PREEMPTION_TIMER: switch (vmx_get_test_stage()) { case 1: case 2: @@ -212,7 +212,7 @@ static int preemption_timer_exit_handler(union exit_reason exit_reason) break; } break; - case VMX_VMCALL: + case EXIT_REASON_VMCALL: vmcs_write(GUEST_RIP, guest_rip + insn_len); switch (vmx_get_test_stage()) { case 0: @@ -361,7 +361,7 @@ static int test_ctrl_pat_exit_handler(union exit_reason exit_reason) guest_rip = vmcs_read(GUEST_RIP); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: guest_pat = vmcs_read(GUEST_PAT); if (!(ctrl_exit_rev.clr & VM_EXIT_SAVE_IA32_PAT)) { printf("\tEXI_SAVE_PAT is not supported\n"); @@ -429,7 +429,7 @@ static int test_ctrl_efer_exit_handler(union exit_reason exit_reason) guest_rip = vmcs_read(GUEST_RIP); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: guest_efer = vmcs_read(GUEST_EFER); if (!(ctrl_exit_rev.clr & VM_EXIT_SAVE_IA32_EFER)) { printf("\tEXI_SAVE_EFER is not supported\n"); @@ -556,7 +556,7 @@ static int cr_shadowing_exit_handler(union exit_reason exit_reason) insn_len = vmcs_read(EXI_INST_LEN); exit_qual = vmcs_read(EXI_QUALIFICATION); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 0: report(guest_cr0 == vmcs_read(GUEST_CR0), @@ -599,7 +599,7 @@ static int cr_shadowing_exit_handler(union exit_reason exit_reason) } vmcs_write(GUEST_RIP, guest_rip + insn_len); return VMX_TEST_RESUME; - case VMX_CR: + case EXIT_REASON_CR_ACCESS: switch (vmx_get_test_stage()) { case 4: report_fail("Read shadowing CR0"); @@ -719,7 +719,7 @@ static int iobmp_exit_handler(union exit_reason exit_reason) exit_qual = vmcs_read(EXI_QUALIFICATION); insn_len = vmcs_read(EXI_INST_LEN); switch (exit_reason.basic) { - case VMX_IO: + case EXIT_REASON_IO_INSTRUCTION: switch (vmx_get_test_stage()) { case 0: case 1: @@ -776,7 +776,7 @@ static int iobmp_exit_handler(union exit_reason exit_reason) } vmcs_write(GUEST_RIP, guest_rip + insn_len); return VMX_TEST_RESUME; - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 9: ctrl_cpu0 = vmcs_read(CPU_EXEC_CTRL0); @@ -936,9 +936,9 @@ static struct insn_table insn_table[] = { 0, 0, 0}, /* LTR causes a #GP if done with a busy selector, so it is not tested. */ {"RDRAND", SECONDARY_EXEC_RDRAND_EXITING, insn_rdrand, INSN_CPU1, - VMX_RDRAND, 0, 0, 0}, + EXIT_REASON_RDRAND, 0, 0, 0}, {"RDSEED", SECONDARY_EXEC_RDSEED_EXITING, insn_rdseed, INSN_CPU1, - VMX_RDSEED, 0, 0, 0}, + EXIT_REASON_RDSEED, 0, 0, 0}, // Instructions always trap {"CPUID", 0, insn_cpuid, INSN_ALWAYS_TRAP, 10, 0, 0, 0}, {"INVD", 0, insn_invd, INSN_ALWAYS_TRAP, 13, 0, 0, 0}, @@ -1024,7 +1024,7 @@ static int insn_intercept_exit_handler(union exit_reason exit_reason) insn_len = vmcs_read(EXI_INST_LEN); insn_info = vmcs_read(EXI_INST_INFO); - if (exit_reason.basic == VMX_VMCALL) { + if (exit_reason.basic == EXIT_REASON_VMCALL) { u32 val = 0; if (insn_table[cur_insn].type == INSN_CPU0) @@ -1323,7 +1323,7 @@ static int pml_exit_handler(union exit_reason exit_reason) u32 insn_len = vmcs_read(EXI_INST_LEN); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 0: index = vmcs_read(GUEST_PML_INDEX); @@ -1348,7 +1348,7 @@ static int pml_exit_handler(union exit_reason exit_reason) } vmcs_write(GUEST_RIP, guest_rip + insn_len); return VMX_TEST_RESUME; - case VMX_PML_FULL: + case EXIT_REASON_PML_FULL: vmx_inc_test_stage(); vmcs_write(GUEST_PML_INDEX, PML_INDEX - 1); return VMX_TEST_RESUME; @@ -1374,7 +1374,7 @@ static int ept_exit_handler_common(union exit_reason exit_reason, bool have_ad) exit_qual = vmcs_read(EXI_QUALIFICATION); pteval_t *ptep; switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 0: check_ept_ad(pml4, guest_cr3, @@ -1452,7 +1452,7 @@ static int ept_exit_handler_common(union exit_reason exit_reason, bool have_ad) } vmcs_write(GUEST_RIP, guest_rip + insn_len); return VMX_TEST_RESUME; - case VMX_EPT_MISCONFIG: + case EXIT_REASON_EPT_MISCONFIG: switch (vmx_get_test_stage()) { case 1: case 2: @@ -1472,7 +1472,7 @@ static int ept_exit_handler_common(union exit_reason exit_reason, bool have_ad) return VMX_TEST_VMEXIT; } return VMX_TEST_RESUME; - case VMX_EPT_VIOLATION: + case EXIT_REASON_EPT_VIOLATION: /* * Exit-qualifications are masked not to account for advanced * VM-exit information. Once KVM supports this feature, this @@ -1731,7 +1731,7 @@ static int interrupt_exit_handler(union exit_reason exit_reason) u32 insn_len = vmcs_read(EXI_INST_LEN); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 0: case 2: @@ -1770,7 +1770,7 @@ static int interrupt_exit_handler(union exit_reason exit_reason) vmx_inc_test_stage(); vmcs_write(GUEST_RIP, guest_rip + insn_len); return VMX_TEST_RESUME; - case VMX_EXTINT: + case EXIT_REASON_EXTERNAL_INTERRUPT: if (vmcs_read(EXI_CONTROLS) & VM_EXIT_ACK_INTR_ON_EXIT) { int vector = vmcs_read(EXI_INTR_INFO) & 0xff; handle_external_interrupt(vector); @@ -1867,11 +1867,11 @@ static int nmi_hlt_exit_handler(union exit_reason exit_reason) switch (vmx_get_test_stage()) { case 1: - if (exit_reason.basic != VMX_VMCALL) { - report_fail("VMEXIT not due to vmcall. Exit reason 0x%x", - exit_reason.full); - print_vmexit_info(exit_reason); - return VMX_TEST_VMEXIT; + if (exit_reason.basic != EXIT_REASON_VMCALL) { + report_fail("VMEXIT not due to vmcall. Exit reason 0x%x", + exit_reason.full); + print_vmexit_info(exit_reason); + return VMX_TEST_VMEXIT; } vmcs_write(PIN_CONTROLS, @@ -1882,15 +1882,15 @@ static int nmi_hlt_exit_handler(union exit_reason exit_reason) break; case 2: - if (exit_reason.basic != VMX_EXC_NMI) { - report_fail("VMEXIT not due to NMI intercept. Exit reason 0x%x", - exit_reason.full); - print_vmexit_info(exit_reason); - return VMX_TEST_VMEXIT; - } - report_pass("NMI intercept while running guest"); - vmcs_write(GUEST_ACTV_STATE, ACTV_ACTIVE); - break; + if (exit_reason.basic != EXIT_REASON_EXCEPTION_NMI) { + report_fail("VMEXIT not due to NMI intercept. Exit reason 0x%x", + exit_reason.full); + print_vmexit_info(exit_reason); + return VMX_TEST_VMEXIT; + } + report_pass("NMI intercept while running guest"); + vmcs_write(GUEST_ACTV_STATE, ACTV_ACTIVE); + break; case 3: break; @@ -1982,7 +1982,7 @@ static int dbgctls_exit_handler(union exit_reason exit_reason) debugctl = rdmsr(MSR_IA32_DEBUGCTLMSR); switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 0: if (dr7 == 0x400 && debugctl == 0 && @@ -2061,7 +2061,8 @@ static void msr_switch_main(void) static int msr_switch_exit_handler(union exit_reason exit_reason) { - if (exit_reason.basic == VMX_VMCALL && vmx_get_test_stage() == 2) { + if (exit_reason.basic == EXIT_REASON_VMCALL && + vmx_get_test_stage() == 2) { report(exit_msr_store[0].value == MSR_MAGIC + 1, "VM exit MSR store"); report(rdmsr(MSR_KERNEL_GS_BASE) == MSR_MAGIC + 2, @@ -2083,7 +2084,7 @@ static int msr_switch_entry_failure(struct vmentry_result *result) } if (result->exit_reason.failed_vmentry && - result->exit_reason.basic == VMX_FAIL_MSR && + result->exit_reason.basic == EXIT_REASON_MSR_LOAD_FAIL && vmx_get_test_stage() == 3) { report(vmcs_read(EXI_QUALIFICATION) == 1, "VM entry MSR load: try to load FS_BASE"); @@ -2113,11 +2114,11 @@ static void vmmcall_main(void) static int vmmcall_exit_handler(union exit_reason exit_reason) { switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: printf("here\n"); report_fail("VMMCALL triggers #UD"); break; - case VMX_EXC_NMI: + case EXIT_REASON_EXCEPTION_NMI: report((vmcs_read(EXI_INTR_INFO) & 0xff) == UD_VECTOR, "VMMCALL triggers #UD"); break; @@ -2177,7 +2178,7 @@ static void disable_rdtscp_main(void) static int disable_rdtscp_exit_handler(union exit_reason exit_reason) { switch (exit_reason.basic) { - case VMX_VMCALL: + case EXIT_REASON_VMCALL: switch (vmx_get_test_stage()) { case 0: report_fail("RDTSCP triggers #UD"); @@ -2230,7 +2231,7 @@ static void skip_exit_insn(void) static void skip_exit_vmcall(void) { - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); skip_exit_insn(); } @@ -2410,7 +2411,7 @@ static void do_ept_violation(bool leaf, enum ept_access_op op, /* Try the access and observe the violation. */ do_ept_access_op(op); - assert_exit_reason(VMX_EPT_VIOLATION); + assert_exit_reason(EXIT_REASON_EPT_VIOLATION); qual = vmcs_read(EXI_QUALIFICATION); @@ -2661,7 +2662,7 @@ static void ept_misconfig_at_level_mkhuge_op(bool mkhuge, int level, orig_pte = ept_twiddle(data->gpa, mkhuge, level, clear, set); do_ept_access_op(op); - assert_exit_reason(VMX_EPT_MISCONFIG); + assert_exit_reason(EXIT_REASON_EPT_MISCONFIG); /* Intel 27.2.1, "For all other VM exits, this field is cleared." */ #if 0 @@ -3522,8 +3523,8 @@ static bool vmlaunch(void) return false; success: exit_reason = vmcs_read(EXI_REASON); - TEST_ASSERT(exit_reason == (VMX_FAIL_STATE | VMX_ENTRY_FAILURE) || - exit_reason == (VMX_FAIL_MSR | VMX_ENTRY_FAILURE)); + TEST_ASSERT(exit_reason == (EXIT_REASON_INVALID_STATE | VMX_ENTRY_FAILURE) || + exit_reason == (EXIT_REASON_MSR_LOAD_FAIL | VMX_ENTRY_FAILURE)); return true; } @@ -5239,7 +5240,7 @@ static void report_mtf(const char *insn_name, unsigned long exp_rip) { unsigned long rip = vmcs_read(GUEST_RIP); - assert_exit_reason(VMX_MTF); + assert_exit_reason(EXIT_REASON_MONITOR_TRAP_FLAG); report(rip == exp_rip, "MTF VM-exit after %s. RIP: 0x%lx (expected 0x%lx)", insn_name, rip, exp_rip); } @@ -5464,7 +5465,7 @@ static void vmx_mtf_pdpte_test(void) enable_mtf(); enter_guest(); - assert_exit_reason(VMX_MTF); + assert_exit_reason(EXIT_REASON_MONITOR_TRAP_FLAG); disable_mtf(); /* @@ -5626,10 +5627,10 @@ static void test_guest_state(const char *test, bool xfail, u64 field, __enter_guest(abort_flags, &result); report(result.exit_reason.failed_vmentry == xfail && - ((xfail && result.exit_reason.basic == VMX_FAIL_STATE) || - (!xfail && result.exit_reason.basic == VMX_VMCALL)) && + ((xfail && result.exit_reason.basic == EXIT_REASON_INVALID_STATE) || + (!xfail && result.exit_reason.basic == EXIT_REASON_VMCALL)) && (!xfail || vmcs_read(EXI_QUALIFICATION) == ENTRY_FAIL_DEFAULT), - "%s, %s = %lx", test, field_name, field); + "%s, %s = %lx", test, field_name, field); if (!result.exit_reason.failed_vmentry) skip_exit_insn(); @@ -5810,21 +5811,21 @@ static bool apic_reg_virt_exit_expectation( config->virtualize_apic_accesses && config->activate_secondary_controls; if (virtualize_apic_accesses_only) { - expectation->rd_exit_reason = VMX_APIC_ACCESS; - expectation->wr_exit_reason = VMX_APIC_ACCESS; + expectation->rd_exit_reason = EXIT_REASON_APIC_ACCESS; + expectation->wr_exit_reason = EXIT_REASON_APIC_ACCESS; } else if (virtualize_apic_accesses_and_use_tpr_shadow) { switch (reg) { case APIC_TASKPRI: - expectation->rd_exit_reason = VMX_VMCALL; - expectation->wr_exit_reason = VMX_VMCALL; + expectation->rd_exit_reason = EXIT_REASON_VMCALL; + expectation->wr_exit_reason = EXIT_REASON_VMCALL; expectation->virt_fn = apic_virt_nibble1; break; default: - expectation->rd_exit_reason = VMX_APIC_ACCESS; - expectation->wr_exit_reason = VMX_APIC_ACCESS; + expectation->rd_exit_reason = EXIT_REASON_APIC_ACCESS; + expectation->wr_exit_reason = EXIT_REASON_APIC_ACCESS; } } else if (apic_register_virtualization) { - expectation->rd_exit_reason = VMX_VMCALL; + expectation->rd_exit_reason = EXIT_REASON_VMCALL; switch (reg) { case APIC_ID: @@ -5842,25 +5843,25 @@ static bool apic_reg_virt_exit_expectation( case APIC_LVTERR: case APIC_TMICT: case APIC_TDCR: - expectation->wr_exit_reason = VMX_APIC_WRITE; + expectation->wr_exit_reason = EXIT_REASON_APIC_WRITE; break; case APIC_LVR: case APIC_ISR ... APIC_ISR + 0x70: case APIC_TMR ... APIC_TMR + 0x70: case APIC_IRR ... APIC_IRR + 0x70: - expectation->wr_exit_reason = VMX_APIC_ACCESS; + expectation->wr_exit_reason = EXIT_REASON_APIC_ACCESS; break; case APIC_TASKPRI: - expectation->wr_exit_reason = VMX_VMCALL; + expectation->wr_exit_reason = EXIT_REASON_VMCALL; expectation->virt_fn = apic_virt_nibble1; break; case APIC_ICR2: - expectation->wr_exit_reason = VMX_VMCALL; + expectation->wr_exit_reason = EXIT_REASON_VMCALL; expectation->virt_fn = apic_virt_byte3; break; default: - expectation->rd_exit_reason = VMX_APIC_ACCESS; - expectation->wr_exit_reason = VMX_APIC_ACCESS; + expectation->rd_exit_reason = EXIT_REASON_APIC_ACCESS; + expectation->wr_exit_reason = EXIT_REASON_APIC_ACCESS; } } else if (!expectation->virtualize_apic_accesses) { /* @@ -5869,8 +5870,8 @@ static bool apic_reg_virt_exit_expectation( * the use TPR shadow control, but not through directly * accessing VTPR. */ - expectation->rd_exit_reason = VMX_VMCALL; - expectation->wr_exit_reason = VMX_VMCALL; + expectation->rd_exit_reason = EXIT_REASON_VMCALL; + expectation->wr_exit_reason = EXIT_REASON_VMCALL; } else { printf("Cannot parse APIC register virtualization config:\n" "\tvirtualize_apic_accesses: %d\n" @@ -6111,14 +6112,14 @@ static void test_xapic_rd( args->apic_access_address = apic_access_address; args->reg = reg; args->val = val; - args->check_rd = exit_reason_want == VMX_VMCALL; + args->check_rd = exit_reason_want == EXIT_REASON_VMCALL; args->virt_fn = expectation->virt_fn; /* Setup virtual APIC page */ if (!expectation->virtualize_apic_accesses) { apic_access_address[apic_reg_index(reg)] = val; virtual_apic_page[apic_reg_index(reg)] = 0; - } else if (exit_reason_want == VMX_VMCALL) { + } else if (exit_reason_want == EXIT_REASON_VMCALL) { apic_access_address[apic_reg_index(reg)] = 0; virtual_apic_page[apic_reg_index(reg)] = val; } @@ -6130,7 +6131,7 @@ static void test_xapic_rd( * Validate the behavior and * pass a magic value back to the guest. */ - if (exit_reason_want == VMX_APIC_ACCESS) { + if (exit_reason_want == EXIT_REASON_APIC_ACCESS) { u32 apic_page_offset = vmcs_read(EXI_QUALIFICATION) & 0xfff; assert_exit_reason(exit_reason_want); @@ -6141,7 +6142,7 @@ static void test_xapic_rd( /* Reenter guest so it can consume/check rcx and exit again. */ enter_guest(); - } else if (exit_reason_want != VMX_VMCALL) { + } else if (exit_reason_want != EXIT_REASON_VMCALL) { report_fail("Oops, bad exit expectation: %u.", exit_reason_want); } @@ -6158,8 +6159,8 @@ static void test_xapic_wr( struct apic_reg_virt_guest_args *args = &apic_reg_virt_guest_args; bool virtualized = expectation->virtualize_apic_accesses && - (exit_reason_want == VMX_APIC_WRITE || - exit_reason_want == VMX_VMCALL); + (exit_reason_want == EXIT_REASON_APIC_WRITE || + exit_reason_want == EXIT_REASON_VMCALL); bool checked = false; report_prefix_pushf("xapic - writing 0x%x to 0x%03x", val, reg); @@ -6183,7 +6184,7 @@ static void test_xapic_wr( * Validate the behavior and * pass a magic value back to the guest. */ - if (exit_reason_want == VMX_APIC_ACCESS) { + if (exit_reason_want == EXIT_REASON_APIC_ACCESS) { u32 apic_page_offset = vmcs_read(EXI_QUALIFICATION) & 0xfff; assert_exit_reason(exit_reason_want); @@ -6194,7 +6195,7 @@ static void test_xapic_wr( /* Reenter guest so it can consume/check rcx and exit again. */ enter_guest(); - } else if (exit_reason_want == VMX_APIC_WRITE) { + } else if (exit_reason_want == EXIT_REASON_APIC_WRITE) { assert_exit_reason(exit_reason_want); report(virtual_apic_page[apic_reg_index(reg)] == val, "got APIC write exit @ page offset 0x%03x; val is 0x%x, want 0x%x", @@ -6204,11 +6205,11 @@ static void test_xapic_wr( /* Reenter guest so it can consume/check rcx and exit again. */ enter_guest(); - } else if (exit_reason_want != VMX_VMCALL) { + } else if (exit_reason_want != EXIT_REASON_VMCALL) { report_fail("Oops, bad exit expectation: %u.", exit_reason_want); } - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); if (virtualized && !checked) { u32 want = expectation->virt_fn(val); u32 got = virtual_apic_page[apic_reg_index(reg)]; @@ -6398,7 +6399,7 @@ static void apic_reg_virt_test(void) vmcs_write(CPU_EXEC_CTRL1, cpu_exec_ctrl1); args->op = TERMINATE; enter_guest(); - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); } struct virt_x2apic_mode_config { @@ -6461,7 +6462,7 @@ static void virt_x2apic_mode_rd_expectation( { enum x2apic_reg_semantics semantics = get_x2apic_reg_semantics(reg); - expectation->rd_exit_reason = VMX_VMCALL; + expectation->rd_exit_reason = EXIT_REASON_VMCALL; expectation->virt_fn = virt_x2apic_mode_identity; if (virt_x2apic_mode_on && apic_register_virtualization) { expectation->rd_val = MAGIC_VAL_1; @@ -6569,7 +6570,7 @@ static void virt_x2apic_mode_wr_expectation( bool virt_int_delivery, struct virt_x2apic_mode_expectation *expectation) { - expectation->wr_exit_reason = VMX_VMCALL; + expectation->wr_exit_reason = EXIT_REASON_VMCALL; expectation->wr_val = MAGIC_VAL_1; expectation->wr_only = false; @@ -6578,14 +6579,14 @@ static void virt_x2apic_mode_wr_expectation( virt_int_delivery)) { expectation->wr_behavior = X2APIC_ACCESS_VIRTUALIZED; if (reg == APIC_SELF_IPI) - expectation->wr_exit_reason = VMX_APIC_WRITE; + expectation->wr_exit_reason = EXIT_REASON_APIC_WRITE; } else if (!disable_x2apic && get_x2apic_wr_val(reg, &expectation->wr_val)) { expectation->wr_behavior = X2APIC_ACCESS_PASSED_THROUGH; if (reg == APIC_EOI || reg == APIC_SELF_IPI) expectation->wr_only = true; if (reg == APIC_ICR) - expectation->wr_exit_reason = VMX_EXTINT; + expectation->wr_exit_reason = EXIT_REASON_EXTERNAL_INTERRUPT; } else { expectation->wr_behavior = X2APIC_ACCESS_TRIGGERS_GP; /* @@ -6928,9 +6929,8 @@ static void test_x2apic_rd( /* Enter guest */ enter_guest(); - if (exit_reason_want != VMX_VMCALL) { + if (exit_reason_want != EXIT_REASON_VMCALL) report_fail("Oops, bad exit expectation: %u.", exit_reason_want); - } skip_exit_vmcall(); report_prefix_pop(); @@ -6978,7 +6978,7 @@ static void test_x2apic_wr( * Validate the behavior and * pass a magic value back to the guest. */ - if (exit_reason_want == VMX_EXTINT) { + if (exit_reason_want == EXIT_REASON_EXTERNAL_INTERRUPT) { assert_exit_reason(exit_reason_want); /* Clear the external interrupt. */ @@ -6987,7 +6987,7 @@ static void test_x2apic_wr( "Got pending interrupt after IRQ enabled."); enter_guest(); - } else if (exit_reason_want == VMX_APIC_WRITE) { + } else if (exit_reason_want == EXIT_REASON_APIC_WRITE) { assert_exit_reason(exit_reason_want); report(virtual_apic_page[apic_reg_index(reg)] == val, "got APIC write exit @ page offset 0x%03x; val is 0x%x, want 0x%lx", @@ -6996,11 +6996,11 @@ static void test_x2apic_wr( /* Reenter guest so it can consume/check rcx and exit again. */ enter_guest(); - } else if (exit_reason_want != VMX_VMCALL) { + } else if (exit_reason_want != EXIT_REASON_VMCALL) { report_fail("Oops, bad exit expectation: %u.", exit_reason_want); } - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); if (expectation->wr_behavior == X2APIC_ACCESS_VIRTUALIZED) { u64 want = val; u32 got = virtual_apic_page[apic_reg_index(reg)]; @@ -7180,7 +7180,7 @@ static void virt_x2apic_mode_test(void) vmcs_write(CPU_EXEC_CTRL1, cpu_exec_ctrl1); args->op = X2APIC_TERMINATE; enter_guest(); - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); } static void test_ctl_reg(const char *cr_name, u64 cr, u64 fixed0, u64 fixed1) @@ -7663,7 +7663,7 @@ static void test_perf_global_ctrl(u32 nr, const char *name, u32 ctrl_nr, val = 1ull << i; vmcs_write(nr, val); report_prefix_pushf("%s = 0x%lx", name, val); - test_pgc_vmlaunch(0, VMX_VMCALL, false, host); + test_pgc_vmlaunch(0, EXIT_REASON_VMCALL, false, host); report_prefix_pop(); } report_prefix_pop(); @@ -7678,7 +7678,7 @@ static void test_perf_global_ctrl(u32 nr, const char *name, u32 ctrl_nr, vmcs_write(nr, val); report_prefix_pushf("%s = 0x%lx", name, val); if (valid_pgc(val)) { - test_pgc_vmlaunch(0, VMX_VMCALL, false, host); + test_pgc_vmlaunch(0, EXIT_REASON_VMCALL, false, host); } else { if (host) test_pgc_vmlaunch( @@ -7689,7 +7689,8 @@ static void test_perf_global_ctrl(u32 nr, const char *name, u32 ctrl_nr, else test_pgc_vmlaunch( 0, - VMX_ENTRY_FAILURE | VMX_FAIL_STATE, + VMX_ENTRY_FAILURE | + EXIT_REASON_INVALID_STATE, true, host); } @@ -8709,7 +8710,7 @@ static void vmx_pending_event_test_core(bool guest_hlt) enter_guest(); - assert_exit_reason(VMX_EXTINT); + assert_exit_reason(EXIT_REASON_EXTERNAL_INTERRUPT); report(!vmx_pending_event_guest_run, "Guest did not run before host received IPI"); @@ -8756,7 +8757,7 @@ static void verify_nmi_window_exit(u64 rip) { u32 exit_reason = vmcs_read(EXI_REASON); - report(exit_reason == VMX_NMI_WINDOW, + report(exit_reason == EXIT_REASON_NMI_WINDOW, "Exit reason (%d) is 'NMI window'", exit_reason); report(vmcs_read(GUEST_RIP) == rip, "RIP (%#lx) is %#lx", vmcs_read(GUEST_RIP), rip); @@ -8890,7 +8891,7 @@ static void verify_intr_window_exit(u64 rip) { u32 exit_reason = vmcs_read(EXI_REASON); - report(exit_reason == VMX_INTR_WINDOW, + report(exit_reason == EXIT_REASON_INTERRUPT_WINDOW, "Exit reason (%d) is 'interrupt window'", exit_reason); report(vmcs_read(GUEST_RIP) == rip, "RIP (%#lx) is %#lx", vmcs_read(GUEST_RIP), rip); @@ -8920,7 +8921,7 @@ static void vmx_intr_window_test(void) report_prefix_push("interrupt-window"); test_set_guest(vmx_intr_window_test_guest); enter_guest(); - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); vmcall_addr = vmcs_read(GUEST_RIP); /* @@ -9126,9 +9127,9 @@ static void vmx_preemption_timer_zero_expect_preempt_at_rip(u64 expected_rip) u32 reason = (u32)vmcs_read(EXI_REASON); u64 guest_rip = vmcs_read(GUEST_RIP); - report(reason == VMX_PREEMPT && guest_rip == expected_rip, + report(reason == EXIT_REASON_PREEMPTION_TIMER && guest_rip == expected_rip, "Exit reason is 0x%x (expected 0x%x) and guest RIP is %lx (0x%lx expected).", - reason, VMX_PREEMPT, guest_rip, expected_rip); + reason, EXIT_REASON_PREEMPTION_TIMER, guest_rip, expected_rip); } /* @@ -9191,8 +9192,9 @@ static void vmx_preemption_timer_zero_test(void) vmx_set_test_stage(3); vmx_preemption_timer_zero_set_pending_dbg(1 << DB_VECTOR); reason = (u32)vmcs_read(EXI_REASON); - report(reason == VMX_EXC_NMI, "Exit reason is 0x%x (expected 0x%x)", - reason, VMX_EXC_NMI); + report(reason == EXIT_REASON_EXCEPTION_NMI, + "Exit reason is 0x%x (expected 0x%x)", + reason, EXIT_REASON_EXCEPTION_NMI); vmcs_clear_bits(PIN_CONTROLS, PIN_BASED_VMX_PREEMPTION_TIMER); enter_guest(); @@ -9287,14 +9289,14 @@ static void vmx_preemption_timer_tf_test(void) for (i = 0; i < 10000; i++) { enter_guest(); reason = (u32)vmcs_read(EXI_REASON); - if (reason == VMX_PREEMPT) + if (reason == EXIT_REASON_PREEMPTION_TIMER) continue; - TEST_ASSERT(reason == VMX_VMCALL); + TEST_ASSERT(reason == EXIT_REASON_VMCALL); skip_exit_insn(); break; } - report(reason == VMX_PREEMPT, "No single-step traps skipped"); + report(reason == EXIT_REASON_PREEMPTION_TIMER, "No single-step traps skipped"); vmx_set_test_stage(2); vmcs_clear_bits(PIN_CONTROLS, PIN_BASED_VMX_PREEMPTION_TIMER); @@ -9369,7 +9371,7 @@ static void vmx_preemption_timer_expiry_test(void) enter_guest(); reason = (u32)vmcs_read(EXI_REASON); - TEST_ASSERT(reason == VMX_PREEMPT); + TEST_ASSERT(reason == EXIT_REASON_PREEMPTION_TIMER); tsc_deadline = ((vmx_preemption_timer_expiry_start >> misc.pt_bit) << misc.pt_bit) + (preemption_timer_value << misc.pt_bit); @@ -9448,7 +9450,7 @@ static void check_db_exit(bool xfail_qual, bool xfail_dr6, bool xfail_pdbg, const u32 expected_intr_info = INTR_INFO_VALID_MASK | INTR_TYPE_HARD_EXCEPTION | DB_VECTOR; - report(reason == VMX_EXC_NMI && intr_info == expected_intr_info, + report(reason == EXIT_REASON_EXCEPTION_NMI && intr_info == expected_intr_info, "Expected #DB VM-exit"); report((u64)expected_rip == guest_rip, "Expected RIP %p (actual %lx)", expected_rip, guest_rip); @@ -9640,7 +9642,9 @@ static void irq_79_handler_guest(isr_regs_t *regs) { eoi(); - /* L1 expects vmexit on VMX_VMCALL and not VMX_EOI_INDUCED */ + /* L1 expects vmexit on EXIT_REASON_VMCALL + * and not EXIT_REASON_EOI_INDUCED. + */ vmcall(); } @@ -9685,9 +9689,10 @@ static void vmx_eoi_bitmap_ioapic_scan_test(void) /* * Launch L2. - * We expect the exit reason to be VMX_VMCALL (and not EOI INDUCED). - * In case the reason isn't VMX_VMCALL, the assertion inside - * skip_exit_vmcall() will fail. + * We expect the exit reason to be EXIT_REASON_VMCALL + * (and not EXIT_REASON_EOI_INDUCED). In case the reason isn't + * EXIT_REASON_VMCALL, the assertion inside skip_exit_vmcall() + * will fail. */ enter_guest(); skip_exit_vmcall(); @@ -9928,7 +9933,8 @@ static void init_signal_test_thread(void *data) /* * Signal to BSP CPU that we continue as usual as INIT signal - * should have been consumed by VMX_INIT exit from guest + * should have been consumed by EXIT_REASON_INIT_SIGNAL exit from + * guest */ vmx_set_test_stage(7); @@ -10011,10 +10017,10 @@ static void vmx_init_signal_test(void) report_fail("Pending INIT signal didn't result in VMX exit"); return; } - report(init_signal_test_exit_reason == VMX_INIT, - "INIT signal during VMX non-root mode result in exit-reason %s (%lu)", - exit_reason_description(init_signal_test_exit_reason), - init_signal_test_exit_reason); + report(init_signal_test_exit_reason == EXIT_REASON_INIT_SIGNAL, + "INIT signal during VMX non-root mode result in exit-reason %s (%lu)", + exit_reason_description(init_signal_test_exit_reason), + init_signal_test_exit_reason); /* Run guest to completion */ make_vmcs_current(test_vmcs); @@ -10027,7 +10033,7 @@ static void vmx_init_signal_test(void) /* Wait reasonable amount of time for other CPU to exit VMX operation */ delay(INIT_SIGNAL_TEST_DELAY); report(vmx_get_test_stage() == 7, - "INIT signal consumed on VMX_INIT exit"); + "INIT signal consumed on EXIT_REASON_INIT_SIGNAL exit"); /* No point to continue if we failed at this point */ if (vmx_get_test_stage() != 7) return; @@ -10138,7 +10144,7 @@ static void sipi_test_ap_thread(void *data) /* AP enter guest */ enter_guest(); - if (vmcs_read(EXI_REASON) == VMX_SIPI) { + if (vmcs_read(EXI_REASON) == EXIT_REASON_SIPI_SIGNAL) { report_pass("AP: Handle SIPI VMExit"); vmcs_write(GUEST_ACTV_STATE, ACTV_ACTIVE); vmx_set_test_stage(2); @@ -10151,7 +10157,7 @@ static void sipi_test_ap_thread(void *data) /* AP enter guest */ enter_guest(); - report(vmcs_read(EXI_REASON) != VMX_SIPI, + report(vmcs_read(EXI_REASON) != EXIT_REASON_SIPI_SIGNAL, "AP: should no SIPI VMExit since activity is not in WAIT_SIPI state"); /* notify BSP that AP is already exit from non-root mode */ @@ -10290,7 +10296,7 @@ static void vmcs_shadow_test_access(u8 *bitmap[2], enum vmcs_access access) vmcs_write(VMX_INST_ERROR, 0); enter_guest(); c->reason = vmcs_read(EXI_REASON) & 0xffff; - if (c->reason != VMX_VMCALL) { + if (c->reason != EXIT_REASON_VMCALL) { skip_exit_insn(); enter_guest(); } @@ -10332,9 +10338,9 @@ static void vmcs_shadow_test_field(u8 *bitmap[2], u64 field) set_bit(field, bitmap[ACCESS_VMWRITE]); } vmcs_shadow_test_access(bitmap, ACCESS_VMWRITE); - report(c->reason == VMX_VMWRITE, "not shadowed for VMWRITE"); + report(c->reason == EXIT_REASON_VMWRITE, "not shadowed for VMWRITE"); vmcs_shadow_test_access(bitmap, ACCESS_VMREAD); - report(c->reason == VMX_VMREAD, "not shadowed for VMREAD"); + report(c->reason == EXIT_REASON_VMREAD, "not shadowed for VMREAD"); report_prefix_pop(); if (field >> VMCS_FIELD_RESERVED_SHIFT) @@ -10347,10 +10353,11 @@ static void vmcs_shadow_test_field(u8 *bitmap[2], u64 field) if (good_shadow) value = vmwrite_to_shadow(field, MAGIC_VAL_1 + field); vmcs_shadow_test_access(bitmap, ACCESS_VMWRITE); - report(c->reason == VMX_VMWRITE, "not shadowed for VMWRITE"); + report(c->reason == EXIT_REASON_VMWRITE, "not shadowed for VMWRITE"); vmcs_shadow_test_access(bitmap, ACCESS_VMREAD); vmx_inst_error = vmcs_read(VMX_INST_ERROR); - report(c->reason == VMX_VMCALL, "shadowed for VMREAD (in %ld cycles)", + report(c->reason == EXIT_REASON_VMCALL, + "shadowed for VMREAD (in %ld cycles)", c->time); report(c->flags == flags[ACCESS_VMREAD], "ALU flags after VMREAD (%lx) are as expected (%lx)", @@ -10373,7 +10380,7 @@ static void vmcs_shadow_test_field(u8 *bitmap[2], u64 field) vmwrite_to_shadow(field, MAGIC_VAL_1 + field); vmcs_shadow_test_access(bitmap, ACCESS_VMWRITE); vmx_inst_error = vmcs_read(VMX_INST_ERROR); - report(c->reason == VMX_VMCALL, + report(c->reason == EXIT_REASON_VMCALL, "shadowed for VMWRITE (in %ld cycles)", c->time); report(c->flags == flags[ACCESS_VMREAD], @@ -10390,7 +10397,7 @@ static void vmcs_shadow_test_field(u8 *bitmap[2], u64 field) vmx_inst_error, VMXERR_UNSUPPORTED_VMCS_COMPONENT); } vmcs_shadow_test_access(bitmap, ACCESS_VMREAD); - report(c->reason == VMX_VMREAD, "not shadowed for VMREAD"); + report(c->reason == EXIT_REASON_VMREAD, "not shadowed for VMREAD"); report_prefix_pop(); /* Permit shadowed VMREAD and VMWRITE. */ @@ -10401,7 +10408,7 @@ static void vmcs_shadow_test_field(u8 *bitmap[2], u64 field) vmwrite_to_shadow(field, MAGIC_VAL_1 + field); vmcs_shadow_test_access(bitmap, ACCESS_VMWRITE); vmx_inst_error = vmcs_read(VMX_INST_ERROR); - report(c->reason == VMX_VMCALL, + report(c->reason == EXIT_REASON_VMCALL, "shadowed for VMWRITE (in %ld cycles)", c->time); report(c->flags == flags[ACCESS_VMREAD], @@ -10419,7 +10426,8 @@ static void vmcs_shadow_test_field(u8 *bitmap[2], u64 field) } vmcs_shadow_test_access(bitmap, ACCESS_VMREAD); vmx_inst_error = vmcs_read(VMX_INST_ERROR); - report(c->reason == VMX_VMCALL, "shadowed for VMREAD (in %ld cycles)", + report(c->reason == EXIT_REASON_VMCALL, + "shadowed for VMREAD (in %ld cycles)", c->time); report(c->flags == flags[ACCESS_VMREAD], "ALU flags after VMREAD (%lx) are as expected (%lx)", @@ -10645,7 +10653,8 @@ static int invalid_msr_exit_handler(union exit_reason exit_reason) static int invalid_msr_entry_failure(struct vmentry_result *result) { report(result->exit_reason.failed_vmentry && - result->exit_reason.basic == VMX_FAIL_MSR, "Invalid MSR load"); + result->exit_reason.basic == EXIT_REASON_MSR_LOAD_FAIL, + "Invalid MSR load"); return VMX_TEST_VMEXIT; } @@ -10735,7 +10744,7 @@ static void atomic_switch_msrs_test(int count) if (count <= max_allowed) { enter_guest(); - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); skip_exit_vmcall(); } else { u32 exit_qual; @@ -10804,20 +10813,20 @@ static void __vmx_pf_exception_test(invalidate_tlb_t inv_fn, void *data, enter_guest(); - while (vmcs_read(EXI_REASON) != VMX_VMCALL) { + while (vmcs_read(EXI_REASON) != EXIT_REASON_VMCALL) { switch (vmcs_read(EXI_REASON)) { - case VMX_RDMSR: + case EXIT_REASON_MSR_READ: assert(regs.rcx == MSR_EFER); efer = vmcs_read(GUEST_EFER); regs.rdx = efer >> 32; regs.rax = efer & 0xffffffff; break; - case VMX_WRMSR: + case EXIT_REASON_MSR_WRITE: assert(regs.rcx == MSR_EFER); efer = regs.rdx << 32 | (regs.rax & 0xffffffff); vmcs_write(GUEST_EFER, efer); break; - case VMX_CPUID: + case EXIT_REASON_CPUID: cpuid = (struct cpuid) {0, 0, 0, 0}; cpuid = raw_cpuid(regs.rax, regs.rcx); regs.rax = cpuid.a; @@ -10825,7 +10834,7 @@ static void __vmx_pf_exception_test(invalidate_tlb_t inv_fn, void *data, regs.rcx = cpuid.c; regs.rdx = cpuid.d; break; - case VMX_INVLPG: + case EXIT_REASON_INVLPG: inv_fn(data); break; default: @@ -10838,7 +10847,7 @@ static void __vmx_pf_exception_test(invalidate_tlb_t inv_fn, void *data, enter_guest(); } - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); } static void vmx_pf_exception_test(void) @@ -10965,7 +10974,7 @@ static void handle_exception_in_l2(u8 vector) vmx_exception_test_vector = vector; enter_guest(); - report(vmcs_read(EXI_REASON) == VMX_VMCALL, + report(vmcs_read(EXI_REASON) == EXIT_REASON_VMCALL, "%s handled by L2", exception_mnemonic(vector)); handle_exception(vector, old_handler); @@ -10987,7 +10996,7 @@ static void handle_exception_in_l1(u32 vector) intr_type = EVENT_TYPE_HWEXC; intr_info = vmcs_read(EXI_INTR_INFO); - report((vmcs_read(EXI_REASON) == VMX_EXC_NMI) && + report((vmcs_read(EXI_REASON) == EXIT_REASON_EXCEPTION_NMI) && (intr_info & INTR_INFO_VALID_MASK) && (intr_info & INTR_INFO_VECTOR_MASK) == vector && ((intr_info & INTR_INFO_INTR_TYPE_MASK) >> INTR_INFO_INTR_TYPE_SHIFT) == intr_type, @@ -11396,10 +11405,10 @@ static void test_basic_vid(u8 nr, u8 tpr, enum Vid_op op, u32 isr_exec_cnt_want, if (eoi_exit_induced) { u32 exit_cnt; - assert_exit_reason(VMX_EOI_INDUCED); + assert_exit_reason(EXIT_REASON_EOI_INDUCED); for (exit_cnt = 1; exit_cnt < isr_exec_cnt_want; exit_cnt++) { enter_guest(); - assert_exit_reason(VMX_EOI_INDUCED); + assert_exit_reason(EXIT_REASON_EOI_INDUCED); } enter_guest(); } @@ -11468,7 +11477,7 @@ static void vmx_basic_vid_test(void) /* Terminate the guest */ args->op = VID_OP_TERMINATE; enter_guest(); - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); } static void test_eoi_virt(u8 nr, u8 lo_pri_nr, bool eoi_exit_induced) @@ -11526,7 +11535,7 @@ static void vmx_eoi_virt_test(void) /* Terminate the guest */ args->op = VID_OP_TERMINATE; enter_guest(); - assert_exit_reason(VMX_VMCALL); + assert_exit_reason(EXIT_REASON_VMCALL); } static void vmx_posted_interrupts_test(void) -- 2.43.0