Skip to contentSkip to conversation

kvm-unit-tests: VMX: Test nested EPT features

PATCH In review Arthur Chunqi Li 3 participants 11 messages Sep 9, 2013 KVM

lore
Share & tools
lore
#0 lore raw

cover kvm-unit-tests: VMX: Test nested EPT features

This series of patches provide the framework of nested EPT and some test cases for nested EPT features.

Arthur Chunqi Li (2):
kvm-unit-tests: VMX: The framework of EPT for nested VMX testing
kvm-unit-tests: VMX: Test cases for nested EPT

 x86/vmx.c       |  159 ++++++++++++++++++++++++++++++++-
 x86/vmx.h       |   76 ++++++++++++++++
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 497 insertions(+), 4 deletions(-)
Signature · 1 line
1.7.9.5
#1 lore raw

PATCH 1/2 kvm-unit-tests: VMX: The framework of EPT for nested VMX testing

The framework of EPT for nested VMX, including functions to build up EPT paging structures, read/set EPT PTEs and setup a range of 1:1 map EPT.

---
 x86/vmx.c |  159 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 x86/vmx.h |   76 +++++++++++++++++++++++++++++
 2 files changed, 231 insertions(+), 4 deletions(-)
x86/vmx.c +155 -4
index ca36d35..87d1d55 100644
@@ -143,6 +143,159 @@ asm(
 	"	call hypercall\n\t"
 );
 
+/* EPT paging structure related functions */
+/* install_ept_entry : Install a page to a given level in EPT
+		@pml4 : addr of pml4 table
+		@pte_level : level of PTE to set
+		@guest_addr : physical address of guest
+		@pte : pte value to set
+		@pt_page : address of page table, NULL for a new page
+ */
+void install_ept_entry(unsigned long *pml4,
+		int pte_level,
+		unsigned long guest_addr,
+		unsigned long pte,
+		unsigned long *pt_page)
+{
+	int level;
+	unsigned long *pt = pml4;
+	unsigned offset;
+
+	for (level = EPT_PAGE_LEVEL; level > pte_level; --level) {
+		offset = (guest_addr >> ((level-1) * EPT_PGDIR_WIDTH + 12))
+				& EPT_PGDIR_MASK;
+		if (!(pt[offset] & (EPT_PRESENT))) {
+			unsigned long *new_pt = pt_page;
+			if (!new_pt)
+				new_pt = alloc_page();
+			else
+				pt_page = 0;
+			memset(new_pt, 0, PAGE_SIZE);
+			pt[offset] = virt_to_phys(new_pt)
+					| EPT_RA | EPT_WA | EPT_EA;
+		}
+		pt = phys_to_virt(pt[offset] & 0xffffffffff000ull);
+	}
+	offset = ((unsigned long)guest_addr >> ((level-1) *
+			EPT_PGDIR_WIDTH + 12)) & EPT_PGDIR_MASK;
+	pt[offset] = pte;
+}
+
+/* Map a page, @perm is the permission of the page */
+void install_ept(unsigned long *pml4,
+		unsigned long phys,
+		unsigned long guest_addr,
+		u64 perm)
+{
+	install_ept_entry(pml4, 1, guest_addr, (phys & PAGE_MASK) | perm, 0);
+}
+
+/* Map a 1G-size page */
+void install_1g_ept(unsigned long *pml4,
+		unsigned long phys,
+		unsigned long guest_addr,
+		u64 perm)
+{
+	install_ept_entry(pml4, 3, guest_addr,
+			(phys & PAGE_MASK) | perm | EPT_LARGE_PAGE, 0);
+}
+
+/* Map a 2M-size page */
+void install_2m_ept(unsigned long *pml4,
+		unsigned long phys,
+		unsigned long guest_addr,
+		u64 perm)
+{
+	install_ept_entry(pml4, 2, guest_addr,
+			(phys & PAGE_MASK) | perm | EPT_LARGE_PAGE, 0);
+}
+
+/* setup_ept_range : Setup a range of 1:1 mapped page to EPT paging structure.
+		@start : start address of guest page
+		@len : length of address to be mapped
+		@map_1g : whether 1G page map is used
+		@map_2m : whether 2M page map is used
+		@perm : permission for every page
+ */
+int setup_ept_range(unsigned long *pml4, unsigned long start,
+		unsigned long len, int map_1g, int map_2m, u64 perm)
+{
+	u64 phys = start;
+	u64 max = (u64)len + (u64)start;
+
+	if (map_1g) {
+		while (phys + PAGE_SIZE_1G <= max) {
+			install_1g_ept(pml4, phys, phys, perm);
+			phys += PAGE_SIZE_1G;
+		}
+	}
+	if (map_2m) {
+		while (phys + PAGE_SIZE_2M <= max) {
+			install_2m_ept(pml4, phys, phys, perm);
+			phys += PAGE_SIZE_2M;
+		}
+	}
+	while (phys + PAGE_SIZE <= max) {
+		install_ept(pml4, phys, phys, perm);
+		phys += PAGE_SIZE;
+	}
+	return 0;
+}
+
+/* get_ept_pte : Get the PTE of a given level in EPT,
+    @level == 1 means get the latest level*/
+unsigned long get_ept_pte(unsigned long *pml4,
+		unsigned long guest_addr, int level)
+{
+	int l;
+	unsigned long *pt = pml4, pte;
+	unsigned offset;
+
+	for (l = EPT_PAGE_LEVEL; l > 1; --l) {
+		offset = (guest_addr >> (((l-1) * EPT_PGDIR_WIDTH) + 12))
+				& EPT_PGDIR_MASK;
+		pte = pt[offset];
+		if (!(pte & (EPT_PRESENT)))
+			return 0;
+		if (l == level)
+			return pte;
+		if (l < 4 && (pte & EPT_LARGE_PAGE))
+			return pte;
+		pt = (unsigned long *)(pte & 0xffffffffff000ull);
+	}
+	offset = (guest_addr >> (((l-1) * EPT_PGDIR_WIDTH) + 12))
+			& EPT_PGDIR_MASK;
+	pte = pt[offset];
+	return pte;
+}
+
+int set_ept_pte(unsigned long *pml4, unsigned long guest_addr,
+		int level, u64 pte_val)
+{
+	int l;
+	unsigned long *pt = pml4;
+	unsigned offset;
+
+	if (level < 1 || level > 3)
+		return -1;
+	for (l = EPT_PAGE_LEVEL; l > 1; --l) {
+		offset = (guest_addr >> (((l-1) * EPT_PGDIR_WIDTH) + 12))
+				& EPT_PGDIR_MASK;
+		if (l == level) {
+			pt[offset] = pte_val;
+			return 0;
+		}
+		if (!(pt[offset] & (EPT_PRESENT)))
+			return -1;
+		pt = (unsigned long *)(pt[offset] & 0xffffffffff000ull);
+	}
+	offset = (guest_addr >> (((l-1) * EPT_PGDIR_WIDTH) + 12))
+			& EPT_PGDIR_MASK;
+	pt[offset] = pte_val;
+	return 0;
+}
+
+
 static void init_vmcs_ctrl(void)
 {
 	/* 26.2 CHECKS ON VMX CONTROLS AND HOST-STATE AREA */
@@ -336,10 +489,8 @@ static void init_vmx(void)
 			: MSR_IA32_VMX_ENTRY_CTLS);
 	ctrl_cpu_rev[0].val = rdmsr(basic.ctrl ? MSR_IA32_VMX_TRUE_PROC
 			: MSR_IA32_VMX_PROCBASED_CTLS);
-	if (ctrl_cpu_rev[0].set & CPU_SECONDARY)
-		ctrl_cpu_rev[1].val = rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2);
-	if (ctrl_cpu_rev[1].set & CPU_EPT || ctrl_cpu_rev[1].set & CPU_VPID)
-		ept_vpid.val = rdmsr(MSR_IA32_VMX_EPT_VPID_CAP);
+	ctrl_cpu_rev[1].val = rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2);
+	ept_vpid.val = rdmsr(MSR_IA32_VMX_EPT_VPID_CAP);
 
 	write_cr0((read_cr0() & fix_cr0_clr) | fix_cr0_set);
 	write_cr4((read_cr4() & fix_cr4_clr) | fix_cr4_set | X86_CR4_VMXE);
x86/vmx.h +76 -0

90 lines not on this page · raw message

Signature · 1 line
1.7.9.5
maintainer
#2 lore raw

Re: [PATCH 1/2] kvm-unit-tests: VMX: The framework of EPT for nested VMX testing

Il 09/09/2013 06:57, Arthur Chunqi Li ha scritto:

Quoted 11 lines

The framework of EPT for nested VMX, including functions to build up EPT paging structures, read/set EPT PTEs and setup a range of 1:1 map EPT.

---
 x86/vmx.c |  159 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 x86/vmx.h |   76 +++++++++++++++++++++++++++++
 2 files changed, 231 insertions(+), 4 deletions(-)

x86/vmx.c static void init_vmx(void) · line 493

Quoted 9 lines
x86/vmx.c +2 -4
@@ -336,10 +489,8 @@ static void init_vmx(void)
 			: MSR_IA32_VMX_ENTRY_CTLS);
 	ctrl_cpu_rev[0].val = rdmsr(basic.ctrl ? MSR_IA32_VMX_TRUE_PROC
 			: MSR_IA32_VMX_PROCBASED_CTLS);
-	if (ctrl_cpu_rev[0].set & CPU_SECONDARY)
-		ctrl_cpu_rev[1].val = rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2);
-	if (ctrl_cpu_rev[1].set & CPU_EPT || ctrl_cpu_rev[1].set & CPU_VPID)
-		ept_vpid.val = rdmsr(MSR_IA32_VMX_EPT_VPID_CAP);
+	ctrl_cpu_rev[1].val = rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2);
+	ept_vpid.val = rdmsr(MSR_IA32_VMX_EPT_VPID_CAP);

This is because these MSRs are confusing.

Your definitions are:

union vmx_ctrl_cpu {
        u64 val;
        struct { 
                u32 set, clr; 
        };
};

so "set" are the low 32-bit and "clr" are the high 32-bits.

This is how the SDM's description should be read:

set clr
0 0 if bit is 0, ok. if bit is 1, fail
=> reserved, must be 0
0 1 if bit is 0, ok. if bit is 1, ok
=> supported by processor
1 0 if bit is 0, fail. if bit is 1, fail
=> impossible
1 1 if bit is 0, fail. if bit is 1, ok
=> reserved, must be 1
So the right fix is:

        if ((ctrl_cpu_rev[0].clr & CPU_SECONDARY) != 0)
                ctrl_cpu_rev[1].val = rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2);
        if ((ctrl_cpu_rev[1].clr & (CPU_EPT | CPU_VPID)) != 0)
                ept_vpid.val = rdmsr(MSR_IA32_VMX_EPT_VPID_CAP);

While looking at this I found another related bug. This line:

	ctrl_cpu[1] |= ctrl_cpu_rev[1].set & ctrl_cpu_rev[1].clr;

should be

	ctrl_cpu[1] = (ctrl_cpu[1] | ctrl_cpu_rev[1].set) & ctrl_cpu_rev[1].clr;

which is the same as other lines using the MSRs.

Paolo

Quoted 99 lines
x86/vmx.c +0 -0
 	write_cr0((read_cr0() & fix_cr0_clr) | fix_cr0_set);
 	write_cr4((read_cr4() & fix_cr4_clr) | fix_cr4_set | X86_CR4_VMXE);
x86/vmx.h +76 -0
index 28595d8..742c2b2 100644
@@ -432,6 +432,59 @@ enum Ctrl1 {
 #define HYPERCALL_MASK		0xFFF
 #define HYPERCALL_VMEXIT	0x1
 
+#define EPTP_PG_WALK_LEN_SHIFT	3ul
+#define EPTP_AD_FLAG			(1ul << 6)
+
+#define EPT_MEM_TYPE_UC	0ul
+#define EPT_MEM_TYPE_WC	1ul
+#define EPT_MEM_TYPE_WT	4ul
+#define EPT_MEM_TYPE_WP	5ul
+#define EPT_MEM_TYPE_WB	6ul
+
+#define EPT_RA			1ul
+#define EPT_WA			2ul
+#define EPT_EA			4ul
+#define EPT_PRESENT		(EPT_RA | EPT_WA | EPT_EA)	
+#define EPT_ACCESS_FLAG	(1ul << 8)
+#define EPT_DIRTY_FLAG		(1ul << 9)
+#define EPT_LARGE_PAGE		(1ul << 7)
+#define EPT_MEM_TYPE_SHIFT	3ul
+#define EPT_IGNORE_PAT		(1ul << 6)
+#define EPT_SUPPRESS_VE	(1ull << 63)
+
+#define EPT_CAP_WT		1ull
+#define EPT_CAP_PWL4		(1ull << 6)
+#define EPT_CAP_UC		(1ull << 8)
+#define EPT_CAP_WB		(1ull << 14)
+#define EPT_CAP_2M_PAGE	(1ull << 16)
+#define EPT_CAP_1G_PAGE	(1ull << 17)
+#define EPT_CAP_INVEPT		(1ull << 20)
+#define EPT_CAP_INVEPT_SINGLE	(1ull << 25)
+#define EPT_CAP_INVEPT_ALL	(1ull << 26)
+#define EPT_CAP_AD_FLAG	(1ull << 21)
+
+#define PAGE_SIZE_2M		(512 * PAGE_SIZE)
+#define PAGE_SIZE_1G		(512 * PAGE_SIZE_2M)
+#define	EPT_PAGE_LEVEL	4
+#define	EPT_PGDIR_WIDTH	9
+#define	EPT_PGDIR_MASK	511
+#define PAGE_MASK (~(PAGE_SIZE-1))
+
+#define EPT_VLT_RD		1
+#define EPT_VLT_WR		(1 << 1)
+#define EPT_VLT_FETCH		(1 << 2)
+#define EPT_VLT_PERM_RD	(1 << 3)
+#define EPT_VLT_PERM_WR	(1 << 4)
+#define EPT_VLT_PERM_EX	(1 << 5)
+#define EPT_VLT_LADDR_VLD	(1 << 7)
+#define EPT_VLT_PADDR		(1 << 8)
+
+#define MAGIC_VAL_1		0x12345678ul
+#define MAGIC_VAL_2		0x87654321ul
+#define MAGIC_VAL_3		0xfffffffful
+
+#define INVEPT_SINGLE		1
+#define INVEPT_GLOBAL		2
 
 extern struct regs regs;
 
@@ -472,8 +525,31 @@ static inline int vmcs_save(struct vmcs **vmcs)
 	return ret;
 }
 
+static inline void invept(unsigned long type, u64 eptp)
+{
+	struct {
+		u64 eptp, gpa;
+	} operand = {eptp, 0};
+	asm volatile("invept %0, %1\n" ::"m"(operand),"r"(type));
+}
+
 void report(const char *name, int result);
 void print_vmexit_info();
+void install_ept_entry(unsigned long *pml4, int pte_level,
+		unsigned long guest_addr, unsigned long pte,
+		unsigned long *pt_page);
+void install_1g_ept(unsigned long *pml4, unsigned long phys,
+		unsigned long guest_addr, u64 perm);
+void install_2m_ept(unsigned long *pml4, unsigned long phys,
+		unsigned long guest_addr, u64 perm);
+void install_ept(unsigned long *pml4, unsigned long phys,
+		unsigned long guest_addr, u64 perm);
+int setup_ept_range(unsigned long *pml4, unsigned long start,
+		unsigned long len, int map_1g, int map_2m, u64 perm);
+unsigned long get_ept_pte(unsigned long *pml4,
+		unsigned long guest_addr, int level);
+int set_ept_pte(unsigned long *pml4, unsigned long guest_addr,
+		int level, u64 pte_val);
 
 #endif
 
#3 lore raw

PATCH 2/2 kvm-unit-tests: VMX: Test cases for nested EPT

In reply to Arthur Chunqi Li

Some test cases for nested EPT features, including:
1. EPT basic framework tests: read, write and remap.
2. EPT misconfigurations test cases: page permission mieconfiguration and memory type misconfiguration
3. EPT violations test cases: page permission violation and paging structure violation

---
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 266 insertions(+)
x86/vmx_tests.c +266 -0
index c1b39f4..a0b9824 100644
@@ -1,4 +1,36 @@
 #include "vmx.h"
+#include "processor.h"
+#include "vm.h"
+#include "msr.h"
+#include "fwcfg.h"
+
+volatile u32 stage;
+volatile bool init_fail;
+unsigned long *pml4;
+u64 eptp;
+void *data_page1, *data_page2;
+
+static inline void set_stage(u32 s)
+{
+	barrier();
+	stage = s;
+	barrier();
+}
+
+static inline u32 get_stage()
+{
+	u32 s;
+
+	barrier();
+	s = stage;
+	barrier();
+	return s;
+}
+
+static inline void vmcall()
+{
+	asm volatile ("vmcall");
+}
 
 void basic_init()
 {
@@ -76,6 +108,238 @@ int vmenter_exit_handler()
 	return VMX_TEST_VMEXIT;
 }
 
+static int setup_ept()
+{
+	int support_2m;
+	unsigned long end_of_memory;
+
+	if (!(ept_vpid.val & EPT_CAP_UC) &&
+			!(ept_vpid.val & EPT_CAP_WB)) {
+		printf("\tEPT paging-structure memory type "
+				"UC&WB are not supported\n");
+		return 1;
+	}
+	if (ept_vpid.val & EPT_CAP_UC)
+		eptp = EPT_MEM_TYPE_UC;
+	else
+		eptp = EPT_MEM_TYPE_WB;
+	if (!(ept_vpid.val & EPT_CAP_PWL4)) {
+		printf("\tPWL4 is not supported\n");
+		return 1;
+	}
+	eptp |= (3 << EPTP_PG_WALK_LEN_SHIFT);
+	pml4 = alloc_page();
+	memset(pml4, 0, PAGE_SIZE);
+	eptp |= virt_to_phys(pml4);
+	vmcs_write(EPTP, eptp);
+	support_2m = !!(ept_vpid.val & EPT_CAP_2M_PAGE);
+	end_of_memory = fwcfg_get_u64(FW_CFG_RAM_SIZE);
+	if (end_of_memory < (1ul << 32))
+		end_of_memory = (1ul << 32);
+	if (setup_ept_range(pml4, 0, end_of_memory,
+			0, support_2m, EPT_WA | EPT_RA | EPT_EA)) {
+		printf("\tSet ept tables failed.\n");
+		return 1;
+	}
+	return 0;
+}
+
+static void ept_init()
+{
+	u32 ctrl_cpu[2];
+
+	init_fail = false;
+	ctrl_cpu[0] = vmcs_read(CPU_EXEC_CTRL0);
+	ctrl_cpu[1] = vmcs_read(CPU_EXEC_CTRL1);
+	ctrl_cpu[0] = (ctrl_cpu[0] | CPU_SECONDARY)
+		& ctrl_cpu_rev[0].clr;
+	ctrl_cpu[1] = (ctrl_cpu[1] | CPU_EPT)
+		& ctrl_cpu_rev[1].clr;
+	vmcs_write(CPU_EXEC_CTRL0, ctrl_cpu[0]);
+	vmcs_write(CPU_EXEC_CTRL1, ctrl_cpu[1] | CPU_EPT);
+	if (setup_ept())
+		init_fail = true;
+	data_page1 = alloc_page();
+	data_page2 = alloc_page();
+	memset(data_page1, 0x0, PAGE_SIZE);
+	memset(data_page2, 0x0, PAGE_SIZE);
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	*((u32 *)data_page2) = MAGIC_VAL_2;
+	install_ept(pml4, (unsigned long)data_page1, (unsigned long)data_page2,
+			EPT_RA | EPT_WA | EPT_EA);
+}
+
+static void ept_main()
+{
+	if (init_fail)
+		return;
+	if (!(ctrl_cpu_rev[0].clr & CPU_SECONDARY)
+		&& !(ctrl_cpu_rev[1].clr & CPU_EPT)) {
+		printf("\tEPT is not supported");
+		return;
+	}
+	set_stage(0);
+	if (*((u32 *)data_page2) != MAGIC_VAL_1 &&
+			*((u32 *)data_page1) != MAGIC_VAL_1)
+		report("EPT basic framework - read", 0);
+	else {
+		*((u32 *)data_page2) = MAGIC_VAL_3;
+		vmcall();
+		if (get_stage() == 1) {
+			if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+					*((u32 *)data_page2) == MAGIC_VAL_2)
+				report("EPT basic framework", 1);
+			else
+				report("EPT basic framework - remap", 1);
+		}
+	}
+	// Test EPT Misconfigurations
+	set_stage(1);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	if (get_stage() != 2) {
+		report("EPT misconfigurations", 0);
+		goto t1;
+	}
+	set_stage(2);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	if (get_stage() != 3) {
+		report("EPT misconfigurations", 0);
+		goto t1;
+	}
+	report("EPT misconfigurations", 1);
+t1:
+	// Test EPT violation
+	set_stage(3);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	if (get_stage() == 4)
+		report("EPT violation - page permission", 1);
+	else
+		report("EPT violation - page permission", 0);
+	// Violation caused by EPT paging structure
+	set_stage(4);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_2;
+	if (get_stage() == 5)
+		report("EPT violation - paging structure", 1);
+	else
+		report("EPT violation - paging structure", 0);
+	return;
+}
+
+static int ept_exit_handler()
+{
+	u64 guest_rip;
+	ulong reason;
+	u32 insn_len;
+	u32 exit_qual;
+	static unsigned long data_page1_pte, data_page1_pte_pte;
+
+	guest_rip = vmcs_read(GUEST_RIP);
+	reason = vmcs_read(EXI_REASON) & 0xff;
+	insn_len = vmcs_read(EXI_INST_LEN);
+	exit_qual = vmcs_read(EXI_QUALIFICATION);
+	switch (reason) {
+	case VMX_VMCALL:
+		switch (get_stage()) {
+		case 0:
+			if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+					*((u32 *)data_page2) == MAGIC_VAL_2) {
+				set_stage(get_stage() + 1);
+				install_ept(pml4, (unsigned long)data_page2,
+						(unsigned long)data_page2,
+						EPT_RA | EPT_WA | EPT_EA);
+			} else
+				report("EPT basic framework - write\n", 0);
+			break;
+		case 1:
+			install_ept(pml4, (unsigned long)data_page1,
+ 				(unsigned long)data_page1, EPT_WA);
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 2:
+			install_ept(pml4, (unsigned long)data_page1,
+ 				(unsigned long)data_page1,
+ 				EPT_RA | EPT_WA | EPT_EA |
+ 				(2 << EPT_MEM_TYPE_SHIFT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 3:
+			data_page1_pte = get_ept_pte(pml4,
+				(unsigned long)data_page1, 1);
+			set_ept_pte(pml4, (unsigned long)data_page1, 
+				1, data_page1_pte & (~EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 4:
+			data_page1_pte = get_ept_pte(pml4,
+				(unsigned long)data_page1, 2);
+			data_page1_pte &= PAGE_MASK;
+			data_page1_pte_pte = get_ept_pte(pml4, data_page1_pte, 2);
+			set_ept_pte(pml4, data_page1_pte, 2,
+				data_page1_pte_pte & (~EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		// Should not reach here
+		default:
+			printf("ERROR - unknown stage, %d.\n", get_stage());
+			print_vmexit_info();
+			return VMX_TEST_VMEXIT;
+		}
+		vmcs_write(GUEST_RIP, guest_rip + insn_len);
+		return VMX_TEST_RESUME;
+	case VMX_EPT_MISCONFIG:
+		switch (get_stage()) {
+		case 1:
+		case 2:
+			set_stage(get_stage() + 1);
+			install_ept(pml4, (unsigned long)data_page1,
+ 				(unsigned long)data_page1,
+ 				EPT_RA | EPT_WA | EPT_EA);
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		// Should not reach here
+		default:
+			printf("ERROR - unknown stage, %d.\n", get_stage());
+			print_vmexit_info();
+			return VMX_TEST_VMEXIT;
+		}
+		vmcs_write(GUEST_RIP, guest_rip + insn_len);
+		return VMX_TEST_RESUME;
+	case VMX_EPT_VIOLATION:
+		switch(get_stage()) {
+		case 3:
+			if (exit_qual == (EPT_VLT_WR | EPT_VLT_LADDR_VLD |
+					EPT_VLT_PADDR))
+				set_stage(get_stage() + 1);
+			set_ept_pte(pml4, (unsigned long)data_page1, 
+				1, data_page1_pte | (EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 4:
+			if (exit_qual == (EPT_VLT_RD | EPT_VLT_LADDR_VLD))
+				set_stage(get_stage() + 1);
+			set_ept_pte(pml4, data_page1_pte, 2,
+				data_page1_pte_pte | (EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		default:
+			// Should not reach here
+			printf("ERROR : unknown stage, %d\n", get_stage());
+			print_vmexit_info();
+			return VMX_TEST_VMEXIT;
+		}
+		vmcs_write(GUEST_RIP, guest_rip + insn_len);
+		return VMX_TEST_RESUME;
+	default:
+		printf("Unknown exit reason, %d\n", reason);
+		print_vmexit_info();
+	}
+	return VMX_TEST_VMEXIT;
+}
+
 /* name/init/guest_main/exit_handler/syscall_handler/guest_regs
    basic_* just implement some basic functions */
 struct vmx_test vmx_tests[] = {
@@ -83,5 +347,7 @@ struct vmx_test vmx_tests[] = {
 		basic_syscall_handler, {0} },
 	{ "vmenter", basic_init, vmenter_main, vmenter_exit_handler,
 		basic_syscall_handler, {0} },
+	{ "EPT framework", ept_init, ept_main, ept_exit_handler,
+		basic_syscall_handler, {0} },
 	{ NULL, NULL, NULL, NULL, NULL, {0} },
 };
Signature · 1 line
1.7.9.5
maintainer
#4 lore raw

Re: [PATCH 2/2] kvm-unit-tests: VMX: Test cases for nested EPT

Il 09/09/2013 06:57, Arthur Chunqi Li ha scritto:

Quoted 17 lines

Some test cases for nested EPT features, including:
1. EPT basic framework tests: read, write and remap.
2. EPT misconfigurations test cases: page permission mieconfiguration and memory type misconfiguration
3. EPT violations test cases: page permission violation and paging structure violation

---
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 266 insertions(+)
x86/vmx_tests.c +0 -0
index c1b39f4..a0b9824 100644

x86/vmx_tests.c line 8

Quoted 8 lines
x86/vmx_tests.c +7 -0
@@ -1,4 +1,36 @@
 #include "vmx.h"
+#include "processor.h"
+#include "vm.h"
+#include "msr.h"
+#include "fwcfg.h"
+
+volatile u32 stage;
+volatile bool init_fail;

Why volatile?

The patch looks good.

Quoted 276 lines
x86/vmx_tests.c +259 -0
+unsigned long *pml4;
+u64 eptp;
+void *data_page1, *data_page2;
+
+static inline void set_stage(u32 s)
+{
+	barrier();
+	stage = s;
+	barrier();
+}
+
+static inline u32 get_stage()
+{
+	u32 s;
+
+	barrier();
+	s = stage;
+	barrier();
+	return s;
+}
+
+static inline void vmcall()
+{
+	asm volatile ("vmcall");
+}
 
 void basic_init()
 {
@@ -76,6 +108,238 @@ int vmenter_exit_handler()
 	return VMX_TEST_VMEXIT;
 }
 
+static int setup_ept()
+{
+	int support_2m;
+	unsigned long end_of_memory;
+
+	if (!(ept_vpid.val & EPT_CAP_UC) &&
+			!(ept_vpid.val & EPT_CAP_WB)) {
+		printf("\tEPT paging-structure memory type "
+				"UC&WB are not supported\n");
+		return 1;
+	}
+	if (ept_vpid.val & EPT_CAP_UC)
+		eptp = EPT_MEM_TYPE_UC;
+	else
+		eptp = EPT_MEM_TYPE_WB;
+	if (!(ept_vpid.val & EPT_CAP_PWL4)) {
+		printf("\tPWL4 is not supported\n");
+		return 1;
+	}
+	eptp |= (3 << EPTP_PG_WALK_LEN_SHIFT);
+	pml4 = alloc_page();
+	memset(pml4, 0, PAGE_SIZE);
+	eptp |= virt_to_phys(pml4);
+	vmcs_write(EPTP, eptp);
+	support_2m = !!(ept_vpid.val & EPT_CAP_2M_PAGE);
+	end_of_memory = fwcfg_get_u64(FW_CFG_RAM_SIZE);
+	if (end_of_memory < (1ul << 32))
+		end_of_memory = (1ul << 32);
+	if (setup_ept_range(pml4, 0, end_of_memory,
+			0, support_2m, EPT_WA | EPT_RA | EPT_EA)) {
+		printf("\tSet ept tables failed.\n");
+		return 1;
+	}
+	return 0;
+}
+
+static void ept_init()
+{
+	u32 ctrl_cpu[2];
+
+	init_fail = false;
+	ctrl_cpu[0] = vmcs_read(CPU_EXEC_CTRL0);
+	ctrl_cpu[1] = vmcs_read(CPU_EXEC_CTRL1);
+	ctrl_cpu[0] = (ctrl_cpu[0] | CPU_SECONDARY)
+		& ctrl_cpu_rev[0].clr;
+	ctrl_cpu[1] = (ctrl_cpu[1] | CPU_EPT)
+		& ctrl_cpu_rev[1].clr;
+	vmcs_write(CPU_EXEC_CTRL0, ctrl_cpu[0]);
+	vmcs_write(CPU_EXEC_CTRL1, ctrl_cpu[1] | CPU_EPT);
+	if (setup_ept())
+		init_fail = true;
+	data_page1 = alloc_page();
+	data_page2 = alloc_page();
+	memset(data_page1, 0x0, PAGE_SIZE);
+	memset(data_page2, 0x0, PAGE_SIZE);
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	*((u32 *)data_page2) = MAGIC_VAL_2;
+	install_ept(pml4, (unsigned long)data_page1, (unsigned long)data_page2,
+			EPT_RA | EPT_WA | EPT_EA);
+}
+
+static void ept_main()
+{
+	if (init_fail)
+		return;
+	if (!(ctrl_cpu_rev[0].clr & CPU_SECONDARY)
+		&& !(ctrl_cpu_rev[1].clr & CPU_EPT)) {
+		printf("\tEPT is not supported");
+		return;
+	}
+	set_stage(0);
+	if (*((u32 *)data_page2) != MAGIC_VAL_1 &&
+			*((u32 *)data_page1) != MAGIC_VAL_1)
+		report("EPT basic framework - read", 0);
+	else {
+		*((u32 *)data_page2) = MAGIC_VAL_3;
+		vmcall();
+		if (get_stage() == 1) {
+			if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+					*((u32 *)data_page2) == MAGIC_VAL_2)
+				report("EPT basic framework", 1);
+			else
+				report("EPT basic framework - remap", 1);
+		}
+	}
+	// Test EPT Misconfigurations
+	set_stage(1);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	if (get_stage() != 2) {
+		report("EPT misconfigurations", 0);
+		goto t1;
+	}
+	set_stage(2);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	if (get_stage() != 3) {
+		report("EPT misconfigurations", 0);
+		goto t1;
+	}
+	report("EPT misconfigurations", 1);
+t1:
+	// Test EPT violation
+	set_stage(3);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_1;
+	if (get_stage() == 4)
+		report("EPT violation - page permission", 1);
+	else
+		report("EPT violation - page permission", 0);
+	// Violation caused by EPT paging structure
+	set_stage(4);
+	vmcall();
+	*((u32 *)data_page1) = MAGIC_VAL_2;
+	if (get_stage() == 5)
+		report("EPT violation - paging structure", 1);
+	else
+		report("EPT violation - paging structure", 0);
+	return;
+}
+
+static int ept_exit_handler()
+{
+	u64 guest_rip;
+	ulong reason;
+	u32 insn_len;
+	u32 exit_qual;
+	static unsigned long data_page1_pte, data_page1_pte_pte;
+
+	guest_rip = vmcs_read(GUEST_RIP);
+	reason = vmcs_read(EXI_REASON) & 0xff;
+	insn_len = vmcs_read(EXI_INST_LEN);
+	exit_qual = vmcs_read(EXI_QUALIFICATION);
+	switch (reason) {
+	case VMX_VMCALL:
+		switch (get_stage()) {
+		case 0:
+			if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+					*((u32 *)data_page2) == MAGIC_VAL_2) {
+				set_stage(get_stage() + 1);
+				install_ept(pml4, (unsigned long)data_page2,
+						(unsigned long)data_page2,
+						EPT_RA | EPT_WA | EPT_EA);
+			} else
+				report("EPT basic framework - write\n", 0);
+			break;
+		case 1:
+			install_ept(pml4, (unsigned long)data_page1,
+ 				(unsigned long)data_page1, EPT_WA);
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 2:
+			install_ept(pml4, (unsigned long)data_page1,
+ 				(unsigned long)data_page1,
+ 				EPT_RA | EPT_WA | EPT_EA |
+ 				(2 << EPT_MEM_TYPE_SHIFT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 3:
+			data_page1_pte = get_ept_pte(pml4,
+				(unsigned long)data_page1, 1);
+			set_ept_pte(pml4, (unsigned long)data_page1, 
+				1, data_page1_pte & (~EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 4:
+			data_page1_pte = get_ept_pte(pml4,
+				(unsigned long)data_page1, 2);
+			data_page1_pte &= PAGE_MASK;
+			data_page1_pte_pte = get_ept_pte(pml4, data_page1_pte, 2);
+			set_ept_pte(pml4, data_page1_pte, 2,
+				data_page1_pte_pte & (~EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		// Should not reach here
+		default:
+			printf("ERROR - unknown stage, %d.\n", get_stage());
+			print_vmexit_info();
+			return VMX_TEST_VMEXIT;
+		}
+		vmcs_write(GUEST_RIP, guest_rip + insn_len);
+		return VMX_TEST_RESUME;
+	case VMX_EPT_MISCONFIG:
+		switch (get_stage()) {
+		case 1:
+		case 2:
+			set_stage(get_stage() + 1);
+			install_ept(pml4, (unsigned long)data_page1,
+ 				(unsigned long)data_page1,
+ 				EPT_RA | EPT_WA | EPT_EA);
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		// Should not reach here
+		default:
+			printf("ERROR - unknown stage, %d.\n", get_stage());
+			print_vmexit_info();
+			return VMX_TEST_VMEXIT;
+		}
+		vmcs_write(GUEST_RIP, guest_rip + insn_len);
+		return VMX_TEST_RESUME;
+	case VMX_EPT_VIOLATION:
+		switch(get_stage()) {
+		case 3:
+			if (exit_qual == (EPT_VLT_WR | EPT_VLT_LADDR_VLD |
+					EPT_VLT_PADDR))
+				set_stage(get_stage() + 1);
+			set_ept_pte(pml4, (unsigned long)data_page1, 
+				1, data_page1_pte | (EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		case 4:
+			if (exit_qual == (EPT_VLT_RD | EPT_VLT_LADDR_VLD))
+				set_stage(get_stage() + 1);
+			set_ept_pte(pml4, data_page1_pte, 2,
+				data_page1_pte_pte | (EPT_PRESENT));
+			invept(INVEPT_SINGLE, eptp);
+			break;
+		default:
+			// Should not reach here
+			printf("ERROR : unknown stage, %d\n", get_stage());
+			print_vmexit_info();
+			return VMX_TEST_VMEXIT;
+		}
+		vmcs_write(GUEST_RIP, guest_rip + insn_len);
+		return VMX_TEST_RESUME;
+	default:
+		printf("Unknown exit reason, %d\n", reason);
+		print_vmexit_info();
+	}
+	return VMX_TEST_VMEXIT;
+}
+
 /* name/init/guest_main/exit_handler/syscall_handler/guest_regs
    basic_* just implement some basic functions */
 struct vmx_test vmx_tests[] = {
@@ -83,5 +347,7 @@ struct vmx_test vmx_tests[] = {
 		basic_syscall_handler, {0} },
 	{ "vmenter", basic_init, vmenter_main, vmenter_exit_handler,
 		basic_syscall_handler, {0} },
+	{ "EPT framework", ept_init, ept_main, ept_exit_handler,
+		basic_syscall_handler, {0} },
 	{ NULL, NULL, NULL, NULL, NULL, {0} },
 };
#5 lore raw

Re: [PATCH 2/2] kvm-unit-tests: VMX: Test cases for nested EPT

Quoted 13 lines · Paolo Bonzini

Il 09/09/2013 06:57, Arthur Chunqi Li ha scritto:

Quoted 12 lines

Some test cases for nested EPT features, including:
1. EPT basic framework tests: read, write and remap.
2. EPT misconfigurations test cases: page permission mieconfiguration and memory type misconfiguration
3. EPT violations test cases: page permission violation and paging structure violation

---
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 266 insertions(+)
Quoted 15 lines

x86/vmx_tests.c line 8

Quoted 13 lines
x86/vmx_tests.c +7 -0
index c1b39f4..a0b9824 100644
@@ -1,4 +1,36 @@
 #include "vmx.h"
+#include "processor.h"
+#include "vm.h"
+#include "msr.h"
+#include "fwcfg.h"
+
+volatile u32 stage;
+volatile bool init_fail;

Why volatile?

Because init_fail is only set but not used later in ept_init(), and if I don't add volatile, compiler may optimize the setting to init_fail.

This occasion firstly occurred when I write set_stage/get_stage. If one variant is set in a function but not used later, the compiler usually optimizes this setting as redundant assignment and remove it.

Arthur

Quoted 280 lines

The patch looks good.

Quoted 276 lines
x86/vmx_tests.c +259 -0
+unsigned long *pml4;
+u64 eptp;
+void *data_page1, *data_page2;
+
+static inline void set_stage(u32 s)
+{
+     barrier();
+     stage = s;
+     barrier();
+}
+
+static inline u32 get_stage()
+{
+     u32 s;
+
+     barrier();
+     s = stage;
+     barrier();
+     return s;
+}
+
+static inline void vmcall()
+{
+     asm volatile ("vmcall");
+}
 
 void basic_init()
 {
@@ -76,6 +108,238 @@ int vmenter_exit_handler()
      return VMX_TEST_VMEXIT;
 }
 
+static int setup_ept()
+{
+     int support_2m;
+     unsigned long end_of_memory;
+
+     if (!(ept_vpid.val & EPT_CAP_UC) &&
+                     !(ept_vpid.val & EPT_CAP_WB)) {
+             printf("\tEPT paging-structure memory type "
+                             "UC&WB are not supported\n");
+             return 1;
+     }
+     if (ept_vpid.val & EPT_CAP_UC)
+             eptp = EPT_MEM_TYPE_UC;
+     else
+             eptp = EPT_MEM_TYPE_WB;
+     if (!(ept_vpid.val & EPT_CAP_PWL4)) {
+             printf("\tPWL4 is not supported\n");
+             return 1;
+     }
+     eptp |= (3 << EPTP_PG_WALK_LEN_SHIFT);
+     pml4 = alloc_page();
+     memset(pml4, 0, PAGE_SIZE);
+     eptp |= virt_to_phys(pml4);
+     vmcs_write(EPTP, eptp);
+     support_2m = !!(ept_vpid.val & EPT_CAP_2M_PAGE);
+     end_of_memory = fwcfg_get_u64(FW_CFG_RAM_SIZE);
+     if (end_of_memory < (1ul << 32))
+             end_of_memory = (1ul << 32);
+     if (setup_ept_range(pml4, 0, end_of_memory,
+                     0, support_2m, EPT_WA | EPT_RA | EPT_EA)) {
+             printf("\tSet ept tables failed.\n");
+             return 1;
+     }
+     return 0;
+}
+
+static void ept_init()
+{
+     u32 ctrl_cpu[2];
+
+     init_fail = false;
+     ctrl_cpu[0] = vmcs_read(CPU_EXEC_CTRL0);
+     ctrl_cpu[1] = vmcs_read(CPU_EXEC_CTRL1);
+     ctrl_cpu[0] = (ctrl_cpu[0] | CPU_SECONDARY)
+             & ctrl_cpu_rev[0].clr;
+     ctrl_cpu[1] = (ctrl_cpu[1] | CPU_EPT)
+             & ctrl_cpu_rev[1].clr;
+     vmcs_write(CPU_EXEC_CTRL0, ctrl_cpu[0]);
+     vmcs_write(CPU_EXEC_CTRL1, ctrl_cpu[1] | CPU_EPT);
+     if (setup_ept())
+             init_fail = true;
+     data_page1 = alloc_page();
+     data_page2 = alloc_page();
+     memset(data_page1, 0x0, PAGE_SIZE);
+     memset(data_page2, 0x0, PAGE_SIZE);
+     *((u32 *)data_page1) = MAGIC_VAL_1;
+     *((u32 *)data_page2) = MAGIC_VAL_2;
+     install_ept(pml4, (unsigned long)data_page1, (unsigned long)data_page2,
+                     EPT_RA | EPT_WA | EPT_EA);
+}
+
+static void ept_main()
+{
+     if (init_fail)
+             return;
+     if (!(ctrl_cpu_rev[0].clr & CPU_SECONDARY)
+             && !(ctrl_cpu_rev[1].clr & CPU_EPT)) {
+             printf("\tEPT is not supported");
+             return;
+     }
+     set_stage(0);
+     if (*((u32 *)data_page2) != MAGIC_VAL_1 &&
+                     *((u32 *)data_page1) != MAGIC_VAL_1)
+             report("EPT basic framework - read", 0);
+     else {
+             *((u32 *)data_page2) = MAGIC_VAL_3;
+             vmcall();
+             if (get_stage() == 1) {
+                     if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+                                     *((u32 *)data_page2) == MAGIC_VAL_2)
+                             report("EPT basic framework", 1);
+                     else
+                             report("EPT basic framework - remap", 1);
+             }
+     }
+     // Test EPT Misconfigurations
+     set_stage(1);
+     vmcall();
+     *((u32 *)data_page1) = MAGIC_VAL_1;
+     if (get_stage() != 2) {
+             report("EPT misconfigurations", 0);
+             goto t1;
+     }
+     set_stage(2);
+     vmcall();
+     *((u32 *)data_page1) = MAGIC_VAL_1;
+     if (get_stage() != 3) {
+             report("EPT misconfigurations", 0);
+             goto t1;
+     }
+     report("EPT misconfigurations", 1);
+t1:
+     // Test EPT violation
+     set_stage(3);
+     vmcall();
+     *((u32 *)data_page1) = MAGIC_VAL_1;
+     if (get_stage() == 4)
+             report("EPT violation - page permission", 1);
+     else
+             report("EPT violation - page permission", 0);
+     // Violation caused by EPT paging structure
+     set_stage(4);
+     vmcall();
+     *((u32 *)data_page1) = MAGIC_VAL_2;
+     if (get_stage() == 5)
+             report("EPT violation - paging structure", 1);
+     else
+             report("EPT violation - paging structure", 0);
+     return;
+}
+
+static int ept_exit_handler()
+{
+     u64 guest_rip;
+     ulong reason;
+     u32 insn_len;
+     u32 exit_qual;
+     static unsigned long data_page1_pte, data_page1_pte_pte;
+
+     guest_rip = vmcs_read(GUEST_RIP);
+     reason = vmcs_read(EXI_REASON) & 0xff;
+     insn_len = vmcs_read(EXI_INST_LEN);
+     exit_qual = vmcs_read(EXI_QUALIFICATION);
+     switch (reason) {
+     case VMX_VMCALL:
+             switch (get_stage()) {
+             case 0:
+                     if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+                                     *((u32 *)data_page2) == MAGIC_VAL_2) {
+                             set_stage(get_stage() + 1);
+                             install_ept(pml4, (unsigned long)data_page2,
+                                             (unsigned long)data_page2,
+                                             EPT_RA | EPT_WA | EPT_EA);
+                     } else
+                             report("EPT basic framework - write\n", 0);
+                     break;
+             case 1:
+                     install_ept(pml4, (unsigned long)data_page1,
+                             (unsigned long)data_page1, EPT_WA);
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             case 2:
+                     install_ept(pml4, (unsigned long)data_page1,
+                             (unsigned long)data_page1,
+                             EPT_RA | EPT_WA | EPT_EA |
+                             (2 << EPT_MEM_TYPE_SHIFT));
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             case 3:
+                     data_page1_pte = get_ept_pte(pml4,
+                             (unsigned long)data_page1, 1);
+                     set_ept_pte(pml4, (unsigned long)data_page1,
+                             1, data_page1_pte & (~EPT_PRESENT));
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             case 4:
+                     data_page1_pte = get_ept_pte(pml4,
+                             (unsigned long)data_page1, 2);
+                     data_page1_pte &= PAGE_MASK;
+                     data_page1_pte_pte = get_ept_pte(pml4, data_page1_pte, 2);
+                     set_ept_pte(pml4, data_page1_pte, 2,
+                             data_page1_pte_pte & (~EPT_PRESENT));
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             // Should not reach here
+             default:
+                     printf("ERROR - unknown stage, %d.\n", get_stage());
+                     print_vmexit_info();
+                     return VMX_TEST_VMEXIT;
+             }
+             vmcs_write(GUEST_RIP, guest_rip + insn_len);
+             return VMX_TEST_RESUME;
+     case VMX_EPT_MISCONFIG:
+             switch (get_stage()) {
+             case 1:
+             case 2:
+                     set_stage(get_stage() + 1);
+                     install_ept(pml4, (unsigned long)data_page1,
+                             (unsigned long)data_page1,
+                             EPT_RA | EPT_WA | EPT_EA);
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             // Should not reach here
+             default:
+                     printf("ERROR - unknown stage, %d.\n", get_stage());
+                     print_vmexit_info();
+                     return VMX_TEST_VMEXIT;
+             }
+             vmcs_write(GUEST_RIP, guest_rip + insn_len);
+             return VMX_TEST_RESUME;
+     case VMX_EPT_VIOLATION:
+             switch(get_stage()) {
+             case 3:
+                     if (exit_qual == (EPT_VLT_WR | EPT_VLT_LADDR_VLD |
+                                     EPT_VLT_PADDR))
+                             set_stage(get_stage() + 1);
+                     set_ept_pte(pml4, (unsigned long)data_page1,
+                             1, data_page1_pte | (EPT_PRESENT));
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             case 4:
+                     if (exit_qual == (EPT_VLT_RD | EPT_VLT_LADDR_VLD))
+                             set_stage(get_stage() + 1);
+                     set_ept_pte(pml4, data_page1_pte, 2,
+                             data_page1_pte_pte | (EPT_PRESENT));
+                     invept(INVEPT_SINGLE, eptp);
+                     break;
+             default:
+                     // Should not reach here
+                     printf("ERROR : unknown stage, %d\n", get_stage());
+                     print_vmexit_info();
+                     return VMX_TEST_VMEXIT;
+             }
+             vmcs_write(GUEST_RIP, guest_rip + insn_len);
+             return VMX_TEST_RESUME;
+     default:
+             printf("Unknown exit reason, %d\n", reason);
+             print_vmexit_info();
+     }
+     return VMX_TEST_VMEXIT;
+}
+
 /* name/init/guest_main/exit_handler/syscall_handler/guest_regs
    basic_* just implement some basic functions */
 struct vmx_test vmx_tests[] = {
@@ -83,5 +347,7 @@ struct vmx_test vmx_tests[] = {
              basic_syscall_handler, {0} },
      { "vmenter", basic_init, vmenter_main, vmenter_exit_handler,
              basic_syscall_handler, {0} },
+     { "EPT framework", ept_init, ept_main, ept_exit_handler,
+             basic_syscall_handler, {0} },
      { NULL, NULL, NULL, NULL, NULL, {0} },
 };
maintainer
#6 lore raw

Re: [PATCH 2/2] kvm-unit-tests: VMX: Test cases for nested EPT

Il 09/09/2013 16:11, Arthur Chunqi Li ha scritto:

Quoted 10 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines

x86/vmx_tests.c line 8

Quoted 2 lines
x86/vmx_tests.c +2 -0
+volatile u32 stage;
+volatile bool init_fail;

Why volatile?

Because init_fail is only set but not used later in ept_init(), and if I don't add volatile, compiler may optimize the setting to init_fail.

This occasion firstly occurred when I write set_stage/get_stage. If one variant is set in a function but not used later, the compiler usually optimizes this setting as redundant assignment and remove it.

No, the two are different. "stage" is written several times in the same function, with no code in the middle:

	stage++;
	*p = 1;
	stage++;

To the compiler, the first store is dead. The compiler doesn't know that "*p = 1" traps to the hypervisor.

But this is not the case for "init_fail".

Paolo

#7 lore raw

Re: [PATCH 2/2] kvm-unit-tests: VMX: Test cases for nested EPT

In reply to Arthur Chunqi Li
Quoted 271 lines · Arthur Chunqi Li

Some test cases for nested EPT features, including:
1. EPT basic framework tests: read, write and remap.
2. EPT misconfigurations test cases: page permission mieconfiguration and memory type misconfiguration
3. EPT violations test cases: page permission violation and paging structure violation

---
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 266 insertions(+)
x86/vmx_tests.c +246 -0
index c1b39f4..a0b9824 100644
@@ -1,4 +1,36 @@
 #include "vmx.h"
+#include "processor.h"
+#include "vm.h"
+#include "msr.h"
+#include "fwcfg.h"
+
+volatile u32 stage;
+volatile bool init_fail;
+unsigned long *pml4;
+u64 eptp;
+void *data_page1, *data_page2;
+
+static inline void set_stage(u32 s)
+{
+       barrier();
+       stage = s;
+       barrier();
+}
+
+static inline u32 get_stage()
+{
+       u32 s;
+
+       barrier();
+       s = stage;
+       barrier();
+       return s;
+}
+
+static inline void vmcall()
+{
+       asm volatile ("vmcall");
+}
 
 void basic_init()
 {
@@ -76,6 +108,238 @@ int vmenter_exit_handler()
        return VMX_TEST_VMEXIT;
 }
 
+static int setup_ept()
+{
+       int support_2m;
+       unsigned long end_of_memory;
+
+       if (!(ept_vpid.val & EPT_CAP_UC) &&
+                       !(ept_vpid.val & EPT_CAP_WB)) {
+               printf("\tEPT paging-structure memory type "
+                               "UC&WB are not supported\n");
+               return 1;
+       }
+       if (ept_vpid.val & EPT_CAP_UC)
+               eptp = EPT_MEM_TYPE_UC;
+       else
+               eptp = EPT_MEM_TYPE_WB;
+       if (!(ept_vpid.val & EPT_CAP_PWL4)) {
+               printf("\tPWL4 is not supported\n");
+               return 1;
+       }
+       eptp |= (3 << EPTP_PG_WALK_LEN_SHIFT);
+       pml4 = alloc_page();
+       memset(pml4, 0, PAGE_SIZE);
+       eptp |= virt_to_phys(pml4);
+       vmcs_write(EPTP, eptp);
+       support_2m = !!(ept_vpid.val & EPT_CAP_2M_PAGE);
+       end_of_memory = fwcfg_get_u64(FW_CFG_RAM_SIZE);
+       if (end_of_memory < (1ul << 32))
+               end_of_memory = (1ul << 32);
+       if (setup_ept_range(pml4, 0, end_of_memory,
+                       0, support_2m, EPT_WA | EPT_RA | EPT_EA)) {
+               printf("\tSet ept tables failed.\n");
+               return 1;
+       }
+       return 0;
+}
+
+static void ept_init()
+{
+       u32 ctrl_cpu[2];
+
+       init_fail = false;
+       ctrl_cpu[0] = vmcs_read(CPU_EXEC_CTRL0);
+       ctrl_cpu[1] = vmcs_read(CPU_EXEC_CTRL1);
+       ctrl_cpu[0] = (ctrl_cpu[0] | CPU_SECONDARY)
+               & ctrl_cpu_rev[0].clr;
+       ctrl_cpu[1] = (ctrl_cpu[1] | CPU_EPT)
+               & ctrl_cpu_rev[1].clr;
+       vmcs_write(CPU_EXEC_CTRL0, ctrl_cpu[0]);
+       vmcs_write(CPU_EXEC_CTRL1, ctrl_cpu[1] | CPU_EPT);
+       if (setup_ept())
+               init_fail = true;
+       data_page1 = alloc_page();
+       data_page2 = alloc_page();
+       memset(data_page1, 0x0, PAGE_SIZE);
+       memset(data_page2, 0x0, PAGE_SIZE);
+       *((u32 *)data_page1) = MAGIC_VAL_1;
+       *((u32 *)data_page2) = MAGIC_VAL_2;
+       install_ept(pml4, (unsigned long)data_page1, (unsigned long)data_page2,
+                       EPT_RA | EPT_WA | EPT_EA);
+}
+
+static void ept_main()
+{
+       if (init_fail)
+               return;
+       if (!(ctrl_cpu_rev[0].clr & CPU_SECONDARY)
+               && !(ctrl_cpu_rev[1].clr & CPU_EPT)) {
+               printf("\tEPT is not supported");
+               return;
+       }
+       set_stage(0);
+       if (*((u32 *)data_page2) != MAGIC_VAL_1 &&
+                       *((u32 *)data_page1) != MAGIC_VAL_1)
+               report("EPT basic framework - read", 0);
+       else {
+               *((u32 *)data_page2) = MAGIC_VAL_3;
+               vmcall();
+               if (get_stage() == 1) {
+                       if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+                                       *((u32 *)data_page2) == MAGIC_VAL_2)
+                               report("EPT basic framework", 1);
+                       else
+                               report("EPT basic framework - remap", 1);
+               }
+       }
+       // Test EPT Misconfigurations
+       set_stage(1);
+       vmcall();
+       *((u32 *)data_page1) = MAGIC_VAL_1;
+       if (get_stage() != 2) {
+               report("EPT misconfigurations", 0);
+               goto t1;
+       }
+       set_stage(2);
+       vmcall();
+       *((u32 *)data_page1) = MAGIC_VAL_1;
+       if (get_stage() != 3) {
+               report("EPT misconfigurations", 0);
+               goto t1;
+       }
+       report("EPT misconfigurations", 1);
+t1:
+       // Test EPT violation
+       set_stage(3);
+       vmcall();
+       *((u32 *)data_page1) = MAGIC_VAL_1;
+       if (get_stage() == 4)
+               report("EPT violation - page permission", 1);
+       else
+               report("EPT violation - page permission", 0);
+       // Violation caused by EPT paging structure
+       set_stage(4);
+       vmcall();
+       *((u32 *)data_page1) = MAGIC_VAL_2;
+       if (get_stage() == 5)
+               report("EPT violation - paging structure", 1);
+       else
+               report("EPT violation - paging structure", 0);
+       return;
+}
+
+static int ept_exit_handler()
+{
+       u64 guest_rip;
+       ulong reason;
+       u32 insn_len;
+       u32 exit_qual;
+       static unsigned long data_page1_pte, data_page1_pte_pte;
+
+       guest_rip = vmcs_read(GUEST_RIP);
+       reason = vmcs_read(EXI_REASON) & 0xff;
+       insn_len = vmcs_read(EXI_INST_LEN);
+       exit_qual = vmcs_read(EXI_QUALIFICATION);
+       switch (reason) {
+       case VMX_VMCALL:
+               switch (get_stage()) {
+               case 0:
+                       if (*((u32 *)data_page1) == MAGIC_VAL_3 &&
+                                       *((u32 *)data_page2) == MAGIC_VAL_2) {
+                               set_stage(get_stage() + 1);
+                               install_ept(pml4, (unsigned long)data_page2,
+                                               (unsigned long)data_page2,
+                                               EPT_RA | EPT_WA | EPT_EA);
+                       } else
+                               report("EPT basic framework - write\n", 0);
+                       break;
+               case 1:
+                       install_ept(pml4, (unsigned long)data_page1,
+                               (unsigned long)data_page1, EPT_WA);
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               case 2:
+                       install_ept(pml4, (unsigned long)data_page1,
+                               (unsigned long)data_page1,
+                               EPT_RA | EPT_WA | EPT_EA |
+                               (2 << EPT_MEM_TYPE_SHIFT));
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               case 3:
+                       data_page1_pte = get_ept_pte(pml4,
+                               (unsigned long)data_page1, 1);
+                       set_ept_pte(pml4, (unsigned long)data_page1,
+                               1, data_page1_pte & (~EPT_PRESENT));
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               case 4:
+                       data_page1_pte = get_ept_pte(pml4,
+                               (unsigned long)data_page1, 2);
+                       data_page1_pte &= PAGE_MASK;
+                       data_page1_pte_pte = get_ept_pte(pml4, data_page1_pte, 2);
+                       set_ept_pte(pml4, data_page1_pte, 2,
+                               data_page1_pte_pte & (~EPT_PRESENT));
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               // Should not reach here
+               default:
+                       printf("ERROR - unknown stage, %d.\n", get_stage());
+                       print_vmexit_info();
+                       return VMX_TEST_VMEXIT;
+               }
+               vmcs_write(GUEST_RIP, guest_rip + insn_len);
+               return VMX_TEST_RESUME;
+       case VMX_EPT_MISCONFIG:
+               switch (get_stage()) {
+               case 1:
+               case 2:
+                       set_stage(get_stage() + 1);
+                       install_ept(pml4, (unsigned long)data_page1,
+                               (unsigned long)data_page1,
+                               EPT_RA | EPT_WA | EPT_EA);
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               // Should not reach here
+               default:
+                       printf("ERROR - unknown stage, %d.\n", get_stage());
+                       print_vmexit_info();
+                       return VMX_TEST_VMEXIT;
+               }
+               vmcs_write(GUEST_RIP, guest_rip + insn_len);
+               return VMX_TEST_RESUME;
+       case VMX_EPT_VIOLATION:
+               switch(get_stage()) {
+               case 3:
+                       if (exit_qual == (EPT_VLT_WR | EPT_VLT_LADDR_VLD |
+                                       EPT_VLT_PADDR))
+                               set_stage(get_stage() + 1);
+                       set_ept_pte(pml4, (unsigned long)data_page1,
+                               1, data_page1_pte | (EPT_PRESENT));
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               case 4:
+                       if (exit_qual == (EPT_VLT_RD | EPT_VLT_LADDR_VLD))
+                               set_stage(get_stage() + 1);
+                       set_ept_pte(pml4, data_page1_pte, 2,

x86/vmx_tests.c int vmenter_exit_handler() · line 334

Quoted 10 lines
x86/vmx_tests.c +10 -0
+                               data_page1_pte_pte | (EPT_PRESENT));
+                       invept(INVEPT_SINGLE, eptp);
+                       break;
+               default:
+                       // Should not reach here
+                       printf("ERROR : unknown stage, %d\n", get_stage());
+                       print_vmexit_info();
+                       return VMX_TEST_VMEXIT;
+               }
+               vmcs_write(GUEST_RIP, guest_rip + insn_len);

Hi Paolo,
I noticed another possible bug of this patch. Stage 4 of this patch test the scenario that the page of a paging structure is not present, then this will cause EPT violation vmexit with bit 8 of exit_qual unset. My question is: will instruction length be correctly set on this scenario? I got wrong insn_len in "case 4" of VMX_EPT_VIOLATION, which may cause triple fault vmexit.

Quoted 22 lines
x86/vmx_tests.c +10 -1
+               return VMX_TEST_RESUME;
+       default:
+               printf("Unknown exit reason, %d\n", reason);
+               print_vmexit_info();
+       }
+       return VMX_TEST_VMEXIT;
+}
+
 /* name/init/guest_main/exit_handler/syscall_handler/guest_regs
    basic_* just implement some basic functions */
 struct vmx_test vmx_tests[] = {
@@ -83,5 +347,7 @@ struct vmx_test vmx_tests[] = {
                basic_syscall_handler, {0} },
        { "vmenter", basic_init, vmenter_main, vmenter_exit_handler,
                basic_syscall_handler, {0} },
+       { "EPT framework", ept_init, ept_main, ept_exit_handler,
+               basic_syscall_handler, {0} },
        { NULL, NULL, NULL, NULL, NULL, {0} },
 };
--

1.7.9.5

maintainer
#8 lore raw

Re: [PATCH 2/2] kvm-unit-tests: VMX: Test cases for nested EPT

Il 09/09/2013 17:29, Arthur Chunqi Li ha scritto:

Quoted 7 lines

Hi Paolo,
I noticed another possible bug of this patch. Stage 4 of this patch test the scenario that the page of a paging structure is not present, then this will cause EPT violation vmexit with bit 8 of exit_qual unset. My question is: will instruction length be correctly set on this scenario? I got wrong insn_len in "case 4" of VMX_EPT_VIOLATION, which may cause triple fault vmexit.

It's plausible that the instruction length is wrong, since the processor might be fetching the instruction itself and doesn't know the length.

Paolo

#9 lore raw
In reply to Arthur Chunqi Li
Quoted 12 lines · Arthur Chunqi Li

This series of patches provide the framework of nested EPT and some test cases for nested EPT features.

Arthur Chunqi Li (2):
kvm-unit-tests: VMX: The framework of EPT for nested VMX testing
kvm-unit-tests: VMX: Test cases for nested EPT

 x86/vmx.c       |  159 ++++++++++++++++++++++++++++++++-
 x86/vmx.h       |   76 ++++++++++++++++
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 497 insertions(+), 4 deletions(-)

I suppose this is v2 of the previous patch? What is the delta? A meta changelog could go here.

Jan

#10 lore raw
Quoted 8 lines · Jan Kiszka
Quoted 7 lines · Arthur Chunqi Li

This series of patches provide the framework of nested EPT and some test cases for nested EPT features.

Arthur Chunqi Li (2):
kvm-unit-tests: VMX: The framework of EPT for nested VMX testing
kvm-unit-tests: VMX: Test cases for nested EPT

Quoted 8 lines
Quoted 5 lines
 x86/vmx.c       |  159 ++++++++++++++++++++++++++++++++-
 x86/vmx.h       |   76 ++++++++++++++++
 x86/vmx_tests.c |  266 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 497 insertions(+), 4 deletions(-)

I suppose this is v2 of the previous patch? What is the delta? A meta changelog could go here.

Yes, v1 just provide the framework of EPT (similar to the first patch of this series), and some more tests about nested EPT is added in this series (the second patch).

Arthur

Quoted 3 lines

Jan