Fixed indentation errors in svm_tests.c
No functional change intended.
Signed-off-by: Manali Shukla <manali.shukla@xxxxxxx>
---
x86/svm_tests.c | 765 ++++++++++++++++++++++++------------------------
1 file changed, 381 insertions(+), 384 deletions(-)
diff --git a/x86/svm_tests.c b/x86/svm_tests.c
index f9e3f36..f953000 100644
--- a/x86/svm_tests.c
+++ b/x86/svm_tests.c
@@ -2043,18 +2043,18 @@ static void basic_guest_main(struct svm_test *test)
#define SVM_TEST_REG_RESERVED_BITS(start, end, inc, str_name, reg, val, \
resv_mask) \
{ \
- u64 tmp, mask; \
- int i; \
+ u64 tmp, mask; \
+ int i; \
\
- for (i = start; i <= end; i = i + inc) { \
- mask = 1ull << i; \
- if (!(mask & resv_mask)) \
- continue; \
- tmp = val | mask; \
+ for (i = start; i <= end; i = i + inc) { \
+ mask = 1ull << i; \
+ if (!(mask & resv_mask)) \
+ continue; \
+ tmp = val | mask; \
reg = tmp; \
- report(svm_vmrun() == SVM_EXIT_ERR, "Test %s %d:%d: %lx",\
- str_name, end, start, tmp); \
- } \
+ report(svm_vmrun() == SVM_EXIT_ERR, "Test %s %d:%d: %lx", \
+ str_name, end, start, tmp); \
+ } \
}
#define SVM_TEST_CR_RESERVED_BITS(start, end, inc, cr, val, resv_mask, \
@@ -2080,7 +2080,7 @@ static void basic_guest_main(struct svm_test *test)
vmcb->save.cr4 = tmp; \
} \
r = svm_vmrun(); \
- report(r == exit_code, "Test CR%d %s%d:%d: %lx, wanted exit 0x%x, got 0x%x",\
+ report(r == exit_code, "Test CR%d %s%d:%d: %lx, wanted exit 0x%x, got 0x%x", \
cr, test_name, end, start, tmp, exit_code, r); \
} \
}
@@ -2105,9 +2105,9 @@ static void test_efer(void)
efer_saved = vmcb->save.efer;
SVM_TEST_REG_RESERVED_BITS(8, 9, 1, "EFER", vmcb->save.efer,
- efer_saved, SVM_EFER_RESERVED_MASK);
+ efer_saved, SVM_EFER_RESERVED_MASK);
SVM_TEST_REG_RESERVED_BITS(16, 63, 4, "EFER", vmcb->save.efer,
- efer_saved, SVM_EFER_RESERVED_MASK);
+ efer_saved, SVM_EFER_RESERVED_MASK);
/*
* EFER.LME and CR0.PG are both set and CR4.PAE is zero.
@@ -2124,7 +2124,7 @@ static void test_efer(void)
cr4 = cr4_saved & ~X86_CR4_PAE;
vmcb->save.cr4 = cr4;
report(svm_vmrun() == SVM_EXIT_ERR, "EFER.LME=1 (%lx), "
- "CR0.PG=1 (%lx) and CR4.PAE=0 (%lx)", efer, cr0, cr4);
+ "CR0.PG=1 (%lx) and CR4.PAE=0 (%lx)", efer, cr0, cr4);
/*
* EFER.LME and CR0.PG are both set and CR0.PE is zero.
@@ -2137,7 +2137,7 @@ static void test_efer(void)
cr0 &= ~X86_CR0_PE;
vmcb->save.cr0 = cr0;
report(svm_vmrun() == SVM_EXIT_ERR, "EFER.LME=1 (%lx), "
- "CR0.PG=1 and CR0.PE=0 (%lx)", efer, cr0);
+ "CR0.PG=1 and CR0.PE=0 (%lx)", efer, cr0);
/*
* EFER.LME, CR0.PG, CR4.PAE, CS.L, and CS.D are all non-zero.
@@ -2148,11 +2148,11 @@ static void test_efer(void)
cr0 |= X86_CR0_PE;
vmcb->save.cr0 = cr0;
cs_attrib = cs_attrib_saved | SVM_SELECTOR_L_MASK |
- SVM_SELECTOR_DB_MASK;
+ SVM_SELECTOR_DB_MASK;
vmcb->save.cs.attrib = cs_attrib;
report(svm_vmrun() == SVM_EXIT_ERR, "EFER.LME=1 (%lx), "
- "CR0.PG=1 (%lx), CR4.PAE=1 (%lx), CS.L=1 and CS.D=1 (%x)",
- efer, cr0, cr4, cs_attrib);
+ "CR0.PG=1 (%lx), CR4.PAE=1 (%lx), CS.L=1 and CS.D=1 (%x)",
+ efer, cr0, cr4, cs_attrib);
vmcb->save.cr0 = cr0_saved;
vmcb->save.cr4 = cr4_saved;
@@ -2172,20 +2172,20 @@ static void test_cr0(void)
cr0 &= ~X86_CR0_NW;
vmcb->save.cr0 = cr0;
report (svm_vmrun() == SVM_EXIT_VMMCALL, "Test CR0 CD=1,NW=0: %lx",
- cr0);
+ cr0);
cr0 |= X86_CR0_NW;
vmcb->save.cr0 = cr0;
report (svm_vmrun() == SVM_EXIT_VMMCALL, "Test CR0 CD=1,NW=1: %lx",
- cr0);
+ cr0);
cr0 &= ~X86_CR0_NW;
cr0 &= ~X86_CR0_CD;
vmcb->save.cr0 = cr0;
report (svm_vmrun() == SVM_EXIT_VMMCALL, "Test CR0 CD=0,NW=0: %lx",
- cr0);
+ cr0);
cr0 |= X86_CR0_NW;
vmcb->save.cr0 = cr0;
report (svm_vmrun() == SVM_EXIT_ERR, "Test CR0 CD=0,NW=1: %lx",
- cr0);
+ cr0);
vmcb->save.cr0 = cr0_saved;
/*
@@ -2194,7 +2194,7 @@ static void test_cr0(void)
cr0 = cr0_saved;
SVM_TEST_REG_RESERVED_BITS(32, 63, 4, "CR0", vmcb->save.cr0, cr0_saved,
- SVM_CR0_RESERVED_MASK);
+ SVM_CR0_RESERVED_MASK);
vmcb->save.cr0 = cr0_saved;
}
@@ -2207,11 +2207,11 @@ static void test_cr3(void)
u64 cr3_saved = vmcb->save.cr3;
SVM_TEST_CR_RESERVED_BITS(0, 63, 1, 3, cr3_saved,
- SVM_CR3_LONG_MBZ_MASK, SVM_EXIT_ERR, "");
+ SVM_CR3_LONG_MBZ_MASK, SVM_EXIT_ERR, "");
vmcb->save.cr3 = cr3_saved & ~SVM_CR3_LONG_MBZ_MASK;
report(svm_vmrun() == SVM_EXIT_VMMCALL, "Test CR3 63:0: %lx",
- vmcb->save.cr3);
+ vmcb->save.cr3);
/*
* CR3 non-MBZ reserved bits based on different modes:
@@ -2227,11 +2227,11 @@ static void test_cr3(void)
if (this_cpu_has(X86_FEATURE_PCID)) {
vmcb->save.cr4 = cr4_saved | X86_CR4_PCIDE;
SVM_TEST_CR_RESERVED_BITS(0, 11, 1, 3, cr3_saved,
- SVM_CR3_LONG_RESERVED_MASK, SVM_EXIT_VMMCALL, "(PCIDE=1) ");
+ SVM_CR3_LONG_RESERVED_MASK, SVM_EXIT_VMMCALL, "(PCIDE=1) ");
vmcb->save.cr3 = cr3_saved & ~SVM_CR3_LONG_RESERVED_MASK;
report(svm_vmrun() == SVM_EXIT_VMMCALL, "Test CR3 63:0: %lx",
- vmcb->save.cr3);
+ vmcb->save.cr3);
}
vmcb->save.cr4 = cr4_saved & ~X86_CR4_PCIDE;
@@ -2243,7 +2243,7 @@ static void test_cr3(void)
pdpe[0] &= ~1ULL;
SVM_TEST_CR_RESERVED_BITS(0, 11, 1, 3, cr3_saved,
- SVM_CR3_LONG_RESERVED_MASK, SVM_EXIT_NPF, "(PCIDE=0) ");
+ SVM_CR3_LONG_RESERVED_MASK, SVM_EXIT_NPF, "(PCIDE=0) ");
pdpe[0] |= 1ULL;
vmcb->save.cr3 = cr3_saved;
@@ -2254,7 +2254,7 @@ static void test_cr3(void)
pdpe[0] &= ~1ULL;
vmcb->save.cr4 = cr4_saved | X86_CR4_PAE;
SVM_TEST_CR_RESERVED_BITS(0, 2, 1, 3, cr3_saved,
- SVM_CR3_PAE_LEGACY_RESERVED_MASK, SVM_EXIT_NPF, "(PAE) ");
+ SVM_CR3_PAE_LEGACY_RESERVED_MASK, SVM_EXIT_NPF, "(PAE) ");
pdpe[0] |= 1ULL;
@@ -2273,14 +2273,14 @@ static void test_cr4(void)
efer &= ~EFER_LME;
vmcb->save.efer = efer;
SVM_TEST_CR_RESERVED_BITS(12, 31, 1, 4, cr4_saved,
- SVM_CR4_LEGACY_RESERVED_MASK, SVM_EXIT_ERR, "");
+ SVM_CR4_LEGACY_RESERVED_MASK, SVM_EXIT_ERR, "");
efer |= EFER_LME;
vmcb->save.efer = efer;
SVM_TEST_CR_RESERVED_BITS(12, 31, 1, 4, cr4_saved,
- SVM_CR4_RESERVED_MASK, SVM_EXIT_ERR, "");
+ SVM_CR4_RESERVED_MASK, SVM_EXIT_ERR, "");
SVM_TEST_CR_RESERVED_BITS(32, 63, 4, 4, cr4_saved,
- SVM_CR4_RESERVED_MASK, SVM_EXIT_ERR, "");
+ SVM_CR4_RESERVED_MASK, SVM_EXIT_ERR, "");
vmcb->save.cr4 = cr4_saved;
vmcb->save.efer = efer_saved;
@@ -2294,12 +2294,12 @@ static void test_dr(void)
u64 dr_saved = vmcb->save.dr6;
SVM_TEST_REG_RESERVED_BITS(32, 63, 4, "DR6", vmcb->save.dr6, dr_saved,
- SVM_DR6_RESERVED_MASK);
+ SVM_DR6_RESERVED_MASK);
vmcb->save.dr6 = dr_saved;
dr_saved = vmcb->save.dr7;
SVM_TEST_REG_RESERVED_BITS(32, 63, 4, "DR7", vmcb->save.dr7, dr_saved,
- SVM_DR7_RESERVED_MASK);
+ SVM_DR7_RESERVED_MASK);
vmcb->save.dr7 = dr_saved;
}
@@ -2307,14 +2307,14 @@ static void test_dr(void)
/* TODO: verify if high 32-bits are sign- or zero-extended on bare metal */
#define TEST_BITMAP_ADDR(save_intercept, type, addr, exit_code, \
msg) { \
- vmcb->control.intercept = saved_intercept | 1ULL << type; \
- if (type == INTERCEPT_MSR_PROT) \
- vmcb->control.msrpm_base_pa = addr; \
- else \
- vmcb->control.iopm_base_pa = addr; \
- report(svm_vmrun() == exit_code, \
- "Test %s address: %lx", msg, addr); \
-}
+ vmcb->control.intercept = saved_intercept | 1ULL << type; \
+ if (type == INTERCEPT_MSR_PROT) \
+ vmcb->control.msrpm_base_pa = addr; \
+ else \
+ vmcb->control.iopm_base_pa = addr; \
+ report(svm_vmrun() == exit_code, \
+ "Test %s address: %lx", msg, addr); \
+ }
/*
* If the MSR or IOIO intercept table extends to a physical address that
@@ -2339,41 +2339,41 @@ static void test_msrpm_iopm_bitmap_addrs(void)
u64 addr = virt_to_phys(msr_bitmap) & (~((1ull << 12) - 1));
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_MSR_PROT,
- addr_beyond_limit - 2 * PAGE_SIZE, SVM_EXIT_ERR,
- "MSRPM");
+ addr_beyond_limit - 2 * PAGE_SIZE, SVM_EXIT_ERR,
+ "MSRPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_MSR_PROT,
- addr_beyond_limit - 2 * PAGE_SIZE + 1, SVM_EXIT_ERR,
- "MSRPM");
+ addr_beyond_limit - 2 * PAGE_SIZE + 1, SVM_EXIT_ERR,
+ "MSRPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_MSR_PROT,
- addr_beyond_limit - PAGE_SIZE, SVM_EXIT_ERR,
- "MSRPM");
+ addr_beyond_limit - PAGE_SIZE, SVM_EXIT_ERR,
+ "MSRPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_MSR_PROT, addr,
- SVM_EXIT_VMMCALL, "MSRPM");
+ SVM_EXIT_VMMCALL, "MSRPM");
addr |= (1ull << 12) - 1;
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_MSR_PROT, addr,
- SVM_EXIT_VMMCALL, "MSRPM");
+ SVM_EXIT_VMMCALL, "MSRPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT,
- addr_beyond_limit - 4 * PAGE_SIZE, SVM_EXIT_VMMCALL,
- "IOPM");
+ addr_beyond_limit - 4 * PAGE_SIZE, SVM_EXIT_VMMCALL,
+ "IOPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT,
- addr_beyond_limit - 3 * PAGE_SIZE, SVM_EXIT_VMMCALL,
- "IOPM");
+ addr_beyond_limit - 3 * PAGE_SIZE, SVM_EXIT_VMMCALL,
+ "IOPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT,
- addr_beyond_limit - 2 * PAGE_SIZE - 2, SVM_EXIT_VMMCALL,
- "IOPM");
+ addr_beyond_limit - 2 * PAGE_SIZE - 2, SVM_EXIT_VMMCALL,
+ "IOPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT,
- addr_beyond_limit - 2 * PAGE_SIZE, SVM_EXIT_ERR,
- "IOPM");
+ addr_beyond_limit - 2 * PAGE_SIZE, SVM_EXIT_ERR,
+ "IOPM");
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT,
- addr_beyond_limit - PAGE_SIZE, SVM_EXIT_ERR,
- "IOPM");
+ addr_beyond_limit - PAGE_SIZE, SVM_EXIT_ERR,
+ "IOPM");
addr = virt_to_phys(io_bitmap) & (~((1ull << 11) - 1));
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT, addr,
- SVM_EXIT_VMMCALL, "IOPM");
+ SVM_EXIT_VMMCALL, "IOPM");
addr |= (1ull << 12) - 1;
TEST_BITMAP_ADDR(saved_intercept, INTERCEPT_IOIO_PROT, addr,
- SVM_EXIT_VMMCALL, "IOPM");
+ SVM_EXIT_VMMCALL, "IOPM");
vmcb->control.intercept = saved_intercept;
}
@@ -2382,22 +2382,22 @@ static void test_msrpm_iopm_bitmap_addrs(void)
* Unlike VMSAVE, VMRUN seems not to update the value of noncanonical
* segment bases in the VMCB. However, VMENTRY succeeds as documented.
*/
-#define TEST_CANONICAL_VMRUN(seg_base, msg) \
- saved_addr = seg_base; \
+#define TEST_CANONICAL_VMRUN(seg_base, msg) \
+ saved_addr = seg_base; \
seg_base = (seg_base & ((1ul << addr_limit) - 1)) | noncanonical_mask; \
- return_value = svm_vmrun(); \
- report(return_value == SVM_EXIT_VMMCALL, \
- "Successful VMRUN with noncanonical %s.base", msg); \
+ return_value = svm_vmrun(); \
+ report(return_value == SVM_EXIT_VMMCALL, \
+ "Successful VMRUN with noncanonical %s.base", msg); \
seg_base = saved_addr;
-#define TEST_CANONICAL_VMLOAD(seg_base, msg) \
- saved_addr = seg_base; \
+#define TEST_CANONICAL_VMLOAD(seg_base, msg) \
+ saved_addr = seg_base; \
seg_base = (seg_base & ((1ul << addr_limit) - 1)) | noncanonical_mask; \
- asm volatile ("vmload %0" : : "a"(vmcb_phys) : "memory"); \
- asm volatile ("vmsave %0" : : "a"(vmcb_phys) : "memory"); \
- report(is_canonical(seg_base), \
- "Test %s.base for canonical form: %lx", msg, seg_base); \
+ asm volatile ("vmload %0" : : "a"(vmcb_phys) : "memory"); \
+ asm volatile ("vmsave %0" : : "a"(vmcb_phys) : "memory"); \
+ report(is_canonical(seg_base), \
+ "Test %s.base for canonical form: %lx", msg, seg_base); \
seg_base = saved_addr;
static void test_canonicalization(void)
@@ -2477,7 +2477,7 @@ static void svm_test_singlestep(void)
vmcb->save.rflags |= X86_EFLAGS_TF;
report (__svm_vmrun((u64)guest_rflags_test_guest) == SVM_EXIT_VMMCALL &&
guest_rflags_test_trap_rip == (u64)&insn2,
- "Test EFLAGS.TF on VMRUN: trap expected after completion of first guest instruction");
+ "Test EFLAGS.TF on VMRUN: trap expected after completion of first guest instruction");
/*
* No trap expected
*/
@@ -2513,52 +2513,52 @@ static unsigned long volatile physical = 0;
static void gp_isr(struct ex_regs *r)
{
- svm_errata_reproduced = true;
- /* skip over the vmsave instruction*/
- r->rip += 3;
+ svm_errata_reproduced = true;
+ /* skip over the vmsave instruction*/
+ r->rip += 3;
}
static void svm_vmrun_errata_test(void)
{
- unsigned long *last_page = NULL;
+ unsigned long *last_page = NULL;
- handle_exception(GP_VECTOR, gp_isr);
+ handle_exception(GP_VECTOR, gp_isr);
- while (!svm_errata_reproduced) {
+ while (!svm_errata_reproduced) {
- unsigned long *page = alloc_pages(1);
+ unsigned long *page = alloc_pages(1);
- if (!page) {
- report_pass("All guest memory tested, no bug found");
- break;
- }
+ if (!page) {
+ report_pass("All guest memory tested, no bug found");
+ break;
+ }
- physical = virt_to_phys(page);
+ physical = virt_to_phys(page);
- asm volatile (
- "mov %[_physical], %%rax\n\t"
- "vmsave %%rax\n\t"
+ asm volatile (
+ "mov %[_physical], %%rax\n\t"
+ "vmsave %%rax\n\t"
- : [_physical] "=m" (physical)
- : /* no inputs*/
- : "rax" /*clobbers*/
- );
+ : [_physical] "=m" (physical)
+ : /* no inputs*/
+ : "rax" /*clobbers*/
+ );
- if (svm_errata_reproduced) {
- report_fail("Got #GP exception - svm errata reproduced at 0x%lx",
- physical);
- break;
- }
+ if (svm_errata_reproduced) {
+ report_fail("Got #GP exception - svm errata reproduced at 0x%lx",
+ physical);
+ break;
+ }
- *page = (unsigned long)last_page;
- last_page = page;
- }
+ *page = (unsigned long)last_page;
+ last_page = page;
+ }
- while (last_page) {
- unsigned long *page = last_page;
- last_page = (unsigned long *)*last_page;
- free_pages_by_order(page, 1);
- }
+ while (last_page) {
+ unsigned long *page = last_page;
+ last_page = (unsigned long *)*last_page;
+ free_pages_by_order(page, 1);
+ }
}
static void vmload_vmsave_guest_main(struct svm_test *test)
@@ -2583,7 +2583,7 @@ static void svm_vmload_vmsave(void)
vmcb->control.intercept &= ~(1ULL << INTERCEPT_VMSAVE);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMMCALL, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
/*
* Enabling intercept for VMLOAD and VMSAVE causes respective
@@ -2592,102 +2592,101 @@ static void svm_vmload_vmsave(void)
vmcb->control.intercept |= (1ULL << INTERCEPT_VMLOAD);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMLOAD, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMLOAD #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMLOAD #VMEXIT");
vmcb->control.intercept &= ~(1ULL << INTERCEPT_VMLOAD);
vmcb->control.intercept |= (1ULL << INTERCEPT_VMSAVE);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMSAVE, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMSAVE #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMSAVE #VMEXIT");
vmcb->control.intercept &= ~(1ULL << INTERCEPT_VMSAVE);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMMCALL, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
vmcb->control.intercept |= (1ULL << INTERCEPT_VMLOAD);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMLOAD, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMLOAD #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMLOAD #VMEXIT");
vmcb->control.intercept &= ~(1ULL << INTERCEPT_VMLOAD);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMMCALL, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
vmcb->control.intercept |= (1ULL << INTERCEPT_VMSAVE);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMSAVE, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMSAVE #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMSAVE #VMEXIT");
vmcb->control.intercept &= ~(1ULL << INTERCEPT_VMSAVE);
svm_vmrun();
report(vmcb->control.exit_code == SVM_EXIT_VMMCALL, "Test "
- "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
+ "VMLOAD/VMSAVE intercept: Expected VMMCALL #VMEXIT");
vmcb->control.intercept = intercept_saved;
}
static void prepare_vgif_enabled(struct svm_test *test)
{
- default_prepare(test);
+ default_prepare(test);
}
static void test_vgif(struct svm_test *test)
{
- asm volatile ("vmmcall\n\tstgi\n\tvmmcall\n\tclgi\n\tvmmcall\n\t");
-
+ asm volatile ("vmmcall\n\tstgi\n\tvmmcall\n\tclgi\n\tvmmcall\n\t");
}
static bool vgif_finished(struct svm_test *test)
{
- switch (get_test_stage(test))
- {
- case 0:
- if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
- report_fail("VMEXIT not due to vmmcall.");
- return true;
- }
- vmcb->control.int_ctl |= V_GIF_ENABLED_MASK;
- vmcb->save.rip += 3;
- inc_test_stage(test);
- break;
- case 1:
- if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
- report_fail("VMEXIT not due to vmmcall.");
- return true;
- }
- if (!(vmcb->control.int_ctl & V_GIF_MASK)) {
- report_fail("Failed to set VGIF when executing STGI.");
- vmcb->control.int_ctl &= ~V_GIF_ENABLED_MASK;
- return true;
- }
- report_pass("STGI set VGIF bit.");
- vmcb->save.rip += 3;
- inc_test_stage(test);
- break;
- case 2:
- if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
- report_fail("VMEXIT not due to vmmcall.");
- return true;
- }
- if (vmcb->control.int_ctl & V_GIF_MASK) {
- report_fail("Failed to clear VGIF when executing CLGI.");
- vmcb->control.int_ctl &= ~V_GIF_ENABLED_MASK;
- return true;
- }
- report_pass("CLGI cleared VGIF bit.");
- vmcb->save.rip += 3;
- inc_test_stage(test);
- vmcb->control.int_ctl &= ~V_GIF_ENABLED_MASK;
- break;
- default:
- return true;
- break;
- }
-
- return get_test_stage(test) == 3;
+ switch (get_test_stage(test))
+ {
+ case 0:
+ if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
+ report_fail("VMEXIT not due to vmmcall.");
+ return true;
+ }
+ vmcb->control.int_ctl |= V_GIF_ENABLED_MASK;
+ vmcb->save.rip += 3;
+ inc_test_stage(test);
+ break;
+ case 1:
+ if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
+ report_fail("VMEXIT not due to vmmcall.");
+ return true;
+ }
+ if (!(vmcb->control.int_ctl & V_GIF_MASK)) {
+ report_fail("Failed to set VGIF when executing STGI.");
+ vmcb->control.int_ctl &= ~V_GIF_ENABLED_MASK;
+ return true;
+ }
+ report_pass("STGI set VGIF bit.");
+ vmcb->save.rip += 3;
+ inc_test_stage(test);
+ break;
+ case 2:
+ if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
+ report_fail("VMEXIT not due to vmmcall.");
+ return true;
+ }
+ if (vmcb->control.int_ctl & V_GIF_MASK) {
+ report_fail("Failed to clear VGIF when executing CLGI.");
+ vmcb->control.int_ctl &= ~V_GIF_ENABLED_MASK;
+ return true;
+ }
+ report_pass("CLGI cleared VGIF bit.");
+ vmcb->save.rip += 3;
+ inc_test_stage(test);
+ vmcb->control.int_ctl &= ~V_GIF_ENABLED_MASK;
+ break;
+ default:
+ return true;
+ break;
+ }
+
+ return get_test_stage(test) == 3;
}
static bool vgif_check(struct svm_test *test)
{
- return get_test_stage(test) == 3;
+ return get_test_stage(test) == 3;
}
@@ -2696,66 +2695,66 @@ static int wait_counter;
static void pause_filter_test_guest_main(struct svm_test *test)
{
- int i;
- for (i = 0 ; i < pause_test_counter ; i++)
- pause();
+ int i;
+ for (i = 0 ; i < pause_test_counter ; i++)
+ pause();
- if (!wait_counter)
- return;
+ if (!wait_counter)
+ return;
- for (i = 0; i < wait_counter; i++)
- ;
+ for (i = 0; i < wait_counter; i++)
+ ;
- for (i = 0 ; i < pause_test_counter ; i++)
- pause();
+ for (i = 0 ; i < pause_test_counter ; i++)
+ pause();
}
static void pause_filter_run_test(int pause_iterations, int filter_value, int wait_iterations, int threshold)
{
- test_set_guest(pause_filter_test_guest_main);
+ test_set_guest(pause_filter_test_guest_main);
- pause_test_counter = pause_iterations;
- wait_counter = wait_iterations;
+ pause_test_counter = pause_iterations;
+ wait_counter = wait_iterations;
- vmcb->control.pause_filter_count = filter_value;
- vmcb->control.pause_filter_thresh = threshold;
- svm_vmrun();
+ vmcb->control.pause_filter_count = filter_value;
+ vmcb->control.pause_filter_thresh = threshold;
+ svm_vmrun();
- if (filter_value <= pause_iterations || wait_iterations < threshold)
- report(vmcb->control.exit_code == SVM_EXIT_PAUSE, "expected PAUSE vmexit");
- else
- report(vmcb->control.exit_code == SVM_EXIT_VMMCALL, "no expected PAUSE vmexit");
+ if (filter_value <= pause_iterations || wait_iterations < threshold)
+ report(vmcb->control.exit_code == SVM_EXIT_PAUSE, "expected PAUSE vmexit");
+ else
+ report(vmcb->control.exit_code == SVM_EXIT_VMMCALL, "no expected PAUSE vmexit");
}
static void pause_filter_test(void)
{
- if (!pause_filter_supported()) {
- report_skip("PAUSE filter not supported in the guest");
- return;
- }
+ if (!pause_filter_supported()) {
+ report_skip("PAUSE filter not supported in the guest");
+ return;
+ }
- vmcb->control.intercept |= (1 << INTERCEPT_PAUSE);
+ vmcb->control.intercept |= (1 << INTERCEPT_PAUSE);
- // filter count more that pause count - no VMexit
- pause_filter_run_test(10, 9, 0, 0);
+ // filter count more that pause count - no VMexit
+ pause_filter_run_test(10, 9, 0, 0);
- // filter count smaller pause count - no VMexit
- pause_filter_run_test(20, 21, 0, 0);
+ // filter count smaller pause count - no VMexit
+ pause_filter_run_test(20, 21, 0, 0);
- if (pause_threshold_supported()) {
- // filter count smaller pause count - no VMexit + large enough threshold
- // so that filter counter resets
- pause_filter_run_test(20, 21, 1000, 10);
+ if (pause_threshold_supported()) {
+ // filter count smaller pause count - no VMexit + large enough threshold
+ // so that filter counter resets
+ pause_filter_run_test(20, 21, 1000, 10);
- // filter count smaller pause count - no VMexit + small threshold
- // so that filter doesn't reset
- pause_filter_run_test(20, 21, 10, 1000);
- } else {
- report_skip("PAUSE threshold not supported in the guest");
- return;
- }
+ // filter count smaller pause count - no VMexit + small threshold
+ // so that filter doesn't reset
+ pause_filter_run_test(20, 21, 10, 1000);
+ } else {
+ report_skip("PAUSE threshold not supported in the guest");
+ return;
+ }
}
@@ -2763,81 +2762,81 @@ static int of_test_counter;
static void guest_test_of_handler(struct ex_regs *r)
{
- of_test_counter++;
+ of_test_counter++;
}
static void svm_of_test_guest(struct svm_test *test)
{
- struct far_pointer32 fp = {
- .offset = (uintptr_t)&&into,
- .selector = KERNEL_CS32,
- };
- uintptr_t rsp;
+ struct far_pointer32 fp = {
+ .offset = (uintptr_t)&&into,
+ .selector = KERNEL_CS32,
+ };
+ uintptr_t rsp;
- asm volatile ("mov %%rsp, %0" : "=r"(rsp));
+ asm volatile ("mov %%rsp, %0" : "=r"(rsp));
- if (fp.offset != (uintptr_t)&&into) {
- printf("Codee address too high.\n");
- return;
- }
+ if (fp.offset != (uintptr_t)&&into) {
+ printf("Codee address too high.\n");
+ return;
+ }
- if ((u32)rsp != rsp) {
- printf("Stack address too high.\n");
- }
+ if ((u32)rsp != rsp) {
+ printf("Stack address too high.\n");
+ }
- asm goto("lcall *%0" : : "m" (fp) : "rax" : into);
- return;
+ asm goto("lcall *%0" : : "m" (fp) : "rax" : into);
+ return;
into:
- asm volatile (".code32;"
- "movl $0x7fffffff, %eax;"
- "addl %eax, %eax;"
- "into;"
- "lret;"
- ".code64");
- __builtin_unreachable();
+ asm volatile (".code32;"
+ "movl $0x7fffffff, %eax;"
+ "addl %eax, %eax;"
+ "into;"
+ "lret;"
+ ".code64");
+ __builtin_unreachable();
}
static void svm_into_test(void)
{
- handle_exception(OF_VECTOR, guest_test_of_handler);
- test_set_guest(svm_of_test_guest);
- report(svm_vmrun() == SVM_EXIT_VMMCALL && of_test_counter == 1,
- "#OF is generated in L2 exception handler0");
+ handle_exception(OF_VECTOR, guest_test_of_handler);
+ test_set_guest(svm_of_test_guest);
+ report(svm_vmrun() == SVM_EXIT_VMMCALL && of_test_counter == 1,
+ "#OF is generated in L2 exception handler");
}
static int bp_test_counter;
static void guest_test_bp_handler(struct ex_regs *r)
{
- bp_test_counter++;
+ bp_test_counter++;
}
static void svm_bp_test_guest(struct svm_test *test)
{
- asm volatile("int3");
+ asm volatile("int3");
}
static void svm_int3_test(void)
{
- handle_exception(BP_VECTOR, guest_test_bp_handler);
- test_set_guest(svm_bp_test_guest);
- report(svm_vmrun() == SVM_EXIT_VMMCALL && bp_test_counter == 1,
- "#BP is handled in L2 exception handler");
+ handle_exception(BP_VECTOR, guest_test_bp_handler);
+ test_set_guest(svm_bp_test_guest);
+ report(svm_vmrun() == SVM_EXIT_VMMCALL && bp_test_counter == 1,
+ "#BP is handled in L2 exception handler");
}
static int nm_test_counter;
static void guest_test_nm_handler(struct ex_regs *r)
{
- nm_test_counter++;
- write_cr0(read_cr0() & ~X86_CR0_TS);
- write_cr0(read_cr0() & ~X86_CR0_EM);
+ nm_test_counter++;
+ write_cr0(read_cr0() & ~X86_CR0_TS);
+ write_cr0(read_cr0() & ~X86_CR0_EM);
}
static void svm_nm_test_guest(struct svm_test *test)
{
- asm volatile("fnop");
+ asm volatile("fnop");
}
/* This test checks that:
@@ -2854,24 +2853,23 @@ static void svm_nm_test_guest(struct svm_test *test)
static void svm_nm_test(void)
{
- handle_exception(NM_VECTOR, guest_test_nm_handler);
- write_cr0(read_cr0() & ~X86_CR0_TS);
- test_set_guest(svm_nm_test_guest);
+ handle_exception(NM_VECTOR, guest_test_nm_handler);
+ write_cr0(read_cr0() & ~X86_CR0_TS);
+ test_set_guest(svm_nm_test_guest);
- vmcb->save.cr0 = vmcb->save.cr0 | X86_CR0_TS;
- report(svm_vmrun() == SVM_EXIT_VMMCALL && nm_test_counter == 1,
- "fnop with CR0.TS set in L2, #NM is triggered");
+ vmcb->save.cr0 = vmcb->save.cr0 | X86_CR0_TS;
+ report(svm_vmrun() == SVM_EXIT_VMMCALL && nm_test_counter == 1,
+ "fnop with CR0.TS set in L2, #NM is triggered");
- vmcb->save.cr0 = (vmcb->save.cr0 & ~X86_CR0_TS) | X86_CR0_EM;
- report(svm_vmrun() == SVM_EXIT_VMMCALL && nm_test_counter == 2,
- "fnop with CR0.EM set in L2, #NM is triggered");
+ vmcb->save.cr0 = (vmcb->save.cr0 & ~X86_CR0_TS) | X86_CR0_EM;
+ report(svm_vmrun() == SVM_EXIT_VMMCALL && nm_test_counter == 2,
+ "fnop with CR0.EM set in L2, #NM is triggered");
- vmcb->save.cr0 = vmcb->save.cr0 & ~(X86_CR0_TS | X86_CR0_EM);
- report(svm_vmrun() == SVM_EXIT_VMMCALL && nm_test_counter == 2,
- "fnop with CR0.TS and CR0.EM unset no #NM exception");
+ vmcb->save.cr0 = vmcb->save.cr0 & ~(X86_CR0_TS | X86_CR0_EM);
+ report(svm_vmrun() == SVM_EXIT_VMMCALL && nm_test_counter == 2,
+ "fnop with CR0.TS and CR0.EM unset no #NM excpetion");
}
-
static bool check_lbr(u64 *from_excepted, u64 *to_expected)
{
u64 from = rdmsr(MSR_IA32_LASTBRANCHFROMIP);
@@ -2879,13 +2877,13 @@ static bool check_lbr(u64 *from_excepted, u64 *to_expected)
if ((u64)from_excepted != from) {
report(false, "MSR_IA32_LASTBRANCHFROMIP, expected=0x%lx, actual=0x%lx",
- (u64)from_excepted, from);
+ (u64)from_excepted, from);
return false;
}
if ((u64)to_expected != to) {
report(false, "MSR_IA32_LASTBRANCHFROMIP, expected=0x%lx, actual=0x%lx",
- (u64)from_excepted, from);
+ (u64)from_excepted, from);
return false;
}
@@ -2902,15 +2900,15 @@ static bool check_dbgctl(u64 dbgctl, u64 dbgctl_expected)
}
-#define DO_BRANCH(branch_name) \
- asm volatile ( \
- # branch_name "_from:" \
- "jmp " # branch_name "_to\n" \
- "nop\n" \
- "nop\n" \
- # branch_name "_to:" \
- "nop\n" \
- )
+#define DO_BRANCH(branch_name) \
+ asm volatile ( \
+ # branch_name "_from:" \
+ "jmp " # branch_name "_to\n" \
+ "nop\n" \
+ "nop\n" \
+ # branch_name "_to:" \
+ "nop\n" \
+ )
extern u64 guest_branch0_from, guest_branch0_to;
@@ -3010,7 +3008,7 @@ static void svm_lbrv_test1(void)
if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
report(false, "VMEXIT not due to vmmcall. Exit reason 0x%x",
- vmcb->control.exit_code);
+ vmcb->control.exit_code);
return;
}
@@ -3034,7 +3032,7 @@ static void svm_lbrv_test2(void)
if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
report(false, "VMEXIT not due to vmmcall. Exit reason 0x%x",
- vmcb->control.exit_code);
+ vmcb->control.exit_code);
return;
}
@@ -3062,7 +3060,7 @@ static void svm_lbrv_nested_test1(void)
if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
report(false, "VMEXIT not due to vmmcall. Exit reason 0x%x",
- vmcb->control.exit_code);
+ vmcb->control.exit_code);
return;
}
@@ -3074,6 +3072,7 @@ static void svm_lbrv_nested_test1(void)
check_dbgctl(dbgctl, DEBUGCTLMSR_LBR);
check_lbr(&host_branch3_from, &host_branch3_to);
}
+
static void svm_lbrv_nested_test2(void)
{
if (!lbrv_supported()) {
@@ -3097,7 +3096,7 @@ static void svm_lbrv_nested_test2(void)
if (vmcb->control.exit_code != SVM_EXIT_VMMCALL) {
report(false, "VMEXIT not due to vmmcall. Exit reason 0x%x",
- vmcb->control.exit_code);
+ vmcb->control.exit_code);
return;
}
@@ -3206,8 +3205,6 @@ static void svm_intr_intercept_mix_gif(void)
svm_intr_intercept_mix_run_guest(&dummy_isr_recevied, SVM_EXIT_INTR);
}
-
-
// subtest: test that a clever guest can trigger an interrupt by setting GIF
// if GIF is not intercepted and interrupt comes after guest
// started running
@@ -3296,121 +3293,121 @@ static void svm_intr_intercept_mix_smi(void)
int main(int ac, char **av)
{
- setup_vm();
- return run_svm_tests(ac, av);
+ setup_vm();
+ return run_svm_tests(ac, av);
}
struct svm_test svm_tests[] = {
- { "null", default_supported, default_prepare,
- default_prepare_gif_clear, null_test,
- default_finished, null_check },
- { "vmrun", default_supported, default_prepare,
- default_prepare_gif_clear, test_vmrun,
- default_finished, check_vmrun },
- { "ioio", default_supported, prepare_ioio,
- default_prepare_gif_clear, test_ioio,
- ioio_finished, check_ioio },
- { "vmrun intercept check", default_supported, prepare_no_vmrun_int,
- default_prepare_gif_clear, null_test, default_finished,
- check_no_vmrun_int },
- { "rsm", default_supported,
- prepare_rsm_intercept, default_prepare_gif_clear,
- test_rsm_intercept, finished_rsm_intercept, check_rsm_intercept },
- { "cr3 read intercept", default_supported,
- prepare_cr3_intercept, default_prepare_gif_clear,
- test_cr3_intercept, default_finished, check_cr3_intercept },
- { "cr3 read nointercept", default_supported, default_prepare,
- default_prepare_gif_clear, test_cr3_intercept, default_finished,
- check_cr3_nointercept },
- { "cr3 read intercept emulate", smp_supported,
- prepare_cr3_intercept_bypass, default_prepare_gif_clear,
- test_cr3_intercept_bypass, default_finished, check_cr3_intercept },
- { "dr intercept check", default_supported, prepare_dr_intercept,
- default_prepare_gif_clear, test_dr_intercept, dr_intercept_finished,
- check_dr_intercept },
- { "next_rip", next_rip_supported, prepare_next_rip,
- default_prepare_gif_clear, test_next_rip,
- default_finished, check_next_rip },
- { "msr intercept check", default_supported, prepare_msr_intercept,
- default_prepare_gif_clear, test_msr_intercept,
- msr_intercept_finished, check_msr_intercept },
- { "mode_switch", default_supported, prepare_mode_switch,
- default_prepare_gif_clear, test_mode_switch,
- mode_switch_finished, check_mode_switch },
- { "asid_zero", default_supported, prepare_asid_zero,
- default_prepare_gif_clear, test_asid_zero,
- default_finished, check_asid_zero },
- { "sel_cr0_bug", default_supported, sel_cr0_bug_prepare,
- default_prepare_gif_clear, sel_cr0_bug_test,
- sel_cr0_bug_finished, sel_cr0_bug_check },
- { "tsc_adjust", tsc_adjust_supported, tsc_adjust_prepare,
- default_prepare_gif_clear, tsc_adjust_test,
- default_finished, tsc_adjust_check },
- { "latency_run_exit", default_supported, latency_prepare,
- default_prepare_gif_clear, latency_test,
- latency_finished, latency_check },
- { "latency_run_exit_clean", default_supported, latency_prepare,
- default_prepare_gif_clear, latency_test,
- latency_finished_clean, latency_check },
- { "latency_svm_insn", default_supported, lat_svm_insn_prepare,
- default_prepare_gif_clear, null_test,
- lat_svm_insn_finished, lat_svm_insn_check },
- { "exc_inject", default_supported, exc_inject_prepare,
- default_prepare_gif_clear, exc_inject_test,
- exc_inject_finished, exc_inject_check },
- { "pending_event", default_supported, pending_event_prepare,
- default_prepare_gif_clear,
- pending_event_test, pending_event_finished, pending_event_check },
- { "pending_event_cli", default_supported, pending_event_cli_prepare,
- pending_event_cli_prepare_gif_clear,
- pending_event_cli_test, pending_event_cli_finished,
- pending_event_cli_check },
- { "interrupt", default_supported, interrupt_prepare,
- default_prepare_gif_clear, interrupt_test,
- interrupt_finished, interrupt_check },
- { "nmi", default_supported, nmi_prepare,
- default_prepare_gif_clear, nmi_test,
- nmi_finished, nmi_check },
- { "nmi_hlt", smp_supported, nmi_prepare,
- default_prepare_gif_clear, nmi_hlt_test,
- nmi_hlt_finished, nmi_hlt_check },
- { "virq_inject", default_supported, virq_inject_prepare,
- default_prepare_gif_clear, virq_inject_test,
- virq_inject_finished, virq_inject_check },
- { "reg_corruption", default_supported, reg_corruption_prepare,
- default_prepare_gif_clear, reg_corruption_test,
- reg_corruption_finished, reg_corruption_check },
- { "svm_init_startup_test", smp_supported, init_startup_prepare,
- default_prepare_gif_clear, null_test,
- init_startup_finished, init_startup_check },
- { "svm_init_intercept_test", smp_supported, init_intercept_prepare,
- default_prepare_gif_clear, init_intercept_test,
- init_intercept_finished, init_intercept_check, .on_vcpu = 2 },
- { "host_rflags", default_supported, host_rflags_prepare,
- host_rflags_prepare_gif_clear, host_rflags_test,
- host_rflags_finished, host_rflags_check },
- { "vgif", vgif_supported, prepare_vgif_enabled,
- default_prepare_gif_clear, test_vgif, vgif_finished,
- vgif_check },
- TEST(svm_cr4_osxsave_test),
- TEST(svm_guest_state_test),
- TEST(svm_vmrun_errata_test),
- TEST(svm_vmload_vmsave),
- TEST(svm_test_singlestep),
- TEST(svm_nm_test),
- TEST(svm_int3_test),
- TEST(svm_into_test),
- TEST(svm_lbrv_test0),
- TEST(svm_lbrv_test1),
- TEST(svm_lbrv_test2),
- TEST(svm_lbrv_nested_test1),
- TEST(svm_lbrv_nested_test2),
- TEST(svm_intr_intercept_mix_if),
- TEST(svm_intr_intercept_mix_gif),
- TEST(svm_intr_intercept_mix_gif2),
- TEST(svm_intr_intercept_mix_nmi),
- TEST(svm_intr_intercept_mix_smi),
- TEST(svm_tsc_scale_test),
- TEST(pause_filter_test),
- { NULL, NULL, NULL, NULL, NULL, NULL, NULL }
+ { "null", default_supported, default_prepare,
+ default_prepare_gif_clear, null_test,
+ default_finished, null_check },
+ { "vmrun", default_supported, default_prepare,
+ default_prepare_gif_clear, test_vmrun,
+ default_finished, check_vmrun },
+ { "ioio", default_supported, prepare_ioio,
+ default_prepare_gif_clear, test_ioio,
+ ioio_finished, check_ioio },
+ { "vmrun intercept check", default_supported, prepare_no_vmrun_int,
+ default_prepare_gif_clear, null_test, default_finished,
+ check_no_vmrun_int },
+ { "rsm", default_supported,
+ prepare_rsm_intercept, default_prepare_gif_clear,
+ test_rsm_intercept, finished_rsm_intercept, check_rsm_intercept },
+ { "cr3 read intercept", default_supported,
+ prepare_cr3_intercept, default_prepare_gif_clear,
+ test_cr3_intercept, default_finished, check_cr3_intercept },
+ { "cr3 read nointercept", default_supported, default_prepare,
+ default_prepare_gif_clear, test_cr3_intercept, default_finished,
+ check_cr3_nointercept },
+ { "cr3 read intercept emulate", smp_supported,
+ prepare_cr3_intercept_bypass, default_prepare_gif_clear,
+ test_cr3_intercept_bypass, default_finished, check_cr3_intercept },
+ { "dr intercept check", default_supported, prepare_dr_intercept,
+ default_prepare_gif_clear, test_dr_intercept, dr_intercept_finished,
+ check_dr_intercept },
+ { "next_rip", next_rip_supported, prepare_next_rip,
+ default_prepare_gif_clear, test_next_rip,
+ default_finished, check_next_rip },
+ { "msr intercept check", default_supported, prepare_msr_intercept,
+ default_prepare_gif_clear, test_msr_intercept,
+ msr_intercept_finished, check_msr_intercept },
+ { "mode_switch", default_supported, prepare_mode_switch,
+ default_prepare_gif_clear, test_mode_switch,
+ mode_switch_finished, check_mode_switch },
+ { "asid_zero", default_supported, prepare_asid_zero,
+ default_prepare_gif_clear, test_asid_zero,
+ default_finished, check_asid_zero },
+ { "sel_cr0_bug", default_supported, sel_cr0_bug_prepare,
+ default_prepare_gif_clear, sel_cr0_bug_test,
+ sel_cr0_bug_finished, sel_cr0_bug_check },
+ { "tsc_adjust", tsc_adjust_supported, tsc_adjust_prepare,
+ default_prepare_gif_clear, tsc_adjust_test,
+ default_finished, tsc_adjust_check },
+ { "latency_run_exit", default_supported, latency_prepare,
+ default_prepare_gif_clear, latency_test,
+ latency_finished, latency_check },
+ { "latency_run_exit_clean", default_supported, latency_prepare,
+ default_prepare_gif_clear, latency_test,
+ latency_finished_clean, latency_check },
+ { "latency_svm_insn", default_supported, lat_svm_insn_prepare,
+ default_prepare_gif_clear, null_test,
+ lat_svm_insn_finished, lat_svm_insn_check },
+ { "exc_inject", default_supported, exc_inject_prepare,
+ default_prepare_gif_clear, exc_inject_test,
+ exc_inject_finished, exc_inject_check },
+ { "pending_event", default_supported, pending_event_prepare,
+ default_prepare_gif_clear,
+ pending_event_test, pending_event_finished, pending_event_check },
+ { "pending_event_cli", default_supported, pending_event_cli_prepare,
+ pending_event_cli_prepare_gif_clear,
+ pending_event_cli_test, pending_event_cli_finished,
+ pending_event_cli_check },
+ { "interrupt", default_supported, interrupt_prepare,
+ default_prepare_gif_clear, interrupt_test,
+ interrupt_finished, interrupt_check },
+ { "nmi", default_supported, nmi_prepare,
+ default_prepare_gif_clear, nmi_test,
+ nmi_finished, nmi_check },
+ { "nmi_hlt", smp_supported, nmi_prepare,
+ default_prepare_gif_clear, nmi_hlt_test,
+ nmi_hlt_finished, nmi_hlt_check },
+ { "virq_inject", default_supported, virq_inject_prepare,
+ default_prepare_gif_clear, virq_inject_test,
+ virq_inject_finished, virq_inject_check },
+ { "reg_corruption", default_supported, reg_corruption_prepare,
+ default_prepare_gif_clear, reg_corruption_test,
+ reg_corruption_finished, reg_corruption_check },
+ { "svm_init_startup_test", smp_supported, init_startup_prepare,
+ default_prepare_gif_clear, null_test,
+ init_startup_finished, init_startup_check },
+ { "svm_init_intercept_test", smp_supported, init_intercept_prepare,
+ default_prepare_gif_clear, init_intercept_test,
+ init_intercept_finished, init_intercept_check, .on_vcpu = 2 },
+ { "host_rflags", default_supported, host_rflags_prepare,
+ host_rflags_prepare_gif_clear, host_rflags_test,
+ host_rflags_finished, host_rflags_check },
+ { "vgif", vgif_supported, prepare_vgif_enabled,
+ default_prepare_gif_clear, test_vgif, vgif_finished,
+ vgif_check },
+ TEST(svm_cr4_osxsave_test),
+ TEST(svm_guest_state_test),
+ TEST(svm_vmrun_errata_test),
+ TEST(svm_vmload_vmsave),
+ TEST(svm_test_singlestep),
+ TEST(svm_nm_test),
+ TEST(svm_int3_test),
+ TEST(svm_into_test),
+ TEST(svm_lbrv_test0),
+ TEST(svm_lbrv_test1),
+ TEST(svm_lbrv_test2),
+ TEST(svm_lbrv_nested_test1),
+ TEST(svm_lbrv_nested_test2),
+ TEST(svm_intr_intercept_mix_if),
+ TEST(svm_intr_intercept_mix_gif),
+ TEST(svm_intr_intercept_mix_gif2),
+ TEST(svm_intr_intercept_mix_nmi),
+ TEST(svm_intr_intercept_mix_smi),
+ TEST(svm_tsc_scale_test),
+ TEST(pause_filter_test),
+ { NULL, NULL, NULL, NULL, NULL, NULL, NULL }
};
--
2.30.2
