[linux-2.6-block.git] / tools / testing / selftests / x86 / entry_from_vm86.c

/*
 * entry_from_vm86.c - tests kernel entries from vm86 mode
 * Copyright (c) 2014-2015 Andrew Lutomirski
 *
 * This exercises a few paths that need to special-case vm86 mode.
 *
 * GPL v2.
 */

#define _GNU_SOURCE

#include <assert.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/signal.h>
#include <sys/ucontext.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <err.h>
#include <stddef.h>
#include <stdbool.h>
#include <errno.h>
#include <sys/vm86.h>

static unsigned long load_addr = 0x10000;
static int nerrs = 0;

static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
		       int flags)
{
	struct sigaction sa;
	memset(&sa, 0, sizeof(sa));
	sa.sa_sigaction = handler;
	sa.sa_flags = SA_SIGINFO | flags;
	sigemptyset(&sa.sa_mask);
	if (sigaction(sig, &sa, 0))
		err(1, "sigaction");
}

static void clearhandler(int sig)
{
	struct sigaction sa;
	memset(&sa, 0, sizeof(sa));
	sa.sa_handler = SIG_DFL;
	sigemptyset(&sa.sa_mask);
	if (sigaction(sig, &sa, 0))
		err(1, "sigaction");
}

static sig_atomic_t got_signal;

static void sighandler(int sig, siginfo_t *info, void *ctx_void)
{
	ucontext_t *ctx = (ucontext_t*)ctx_void;

	if (ctx->uc_mcontext.gregs[REG_EFL] & X86_EFLAGS_VM ||
	    (ctx->uc_mcontext.gregs[REG_CS] & 3) != 3) {
		printf("[FAIL]\tSignal frame should not reflect vm86 mode\n");
		nerrs++;
	}

	const char *signame;
	if (sig == SIGSEGV)
		signame = "SIGSEGV";
	else if (sig == SIGILL)
		signame = "SIGILL";
	else
		signame = "unexpected signal";

	printf("[INFO]\t%s: FLAGS = 0x%lx, CS = 0x%hx\n", signame,
	       (unsigned long)ctx->uc_mcontext.gregs[REG_EFL],
	       (unsigned short)ctx->uc_mcontext.gregs[REG_CS]);

	got_signal = 1;
}

asm (
	".pushsection .rodata\n\t"
	".type vmcode_bound, @object\n\t"
	"vmcode:\n\t"
	"vmcode_bound:\n\t"
	".code16\n\t"
	"bound %ax, (2048)\n\t"
	"int3\n\t"
	"vmcode_sysenter:\n\t"
	"sysenter\n\t"
	"vmcode_syscall:\n\t"
	"syscall\n\t"
	"vmcode_sti:\n\t"
	"sti\n\t"
	"vmcode_int3:\n\t"
	"int3\n\t"
	"vmcode_int80:\n\t"
	"int $0x80\n\t"
	"vmcode_popf_hlt:\n\t"
	"push %ax\n\t"
	"popf\n\t"
	"hlt\n\t"
	"vmcode_umip:\n\t"
	/* addressing via displacements */
	"smsw (2052)\n\t"
	"sidt (2054)\n\t"
	"sgdt (2060)\n\t"
	/* addressing via registers */
	"mov $2066, %bx\n\t"
	"smsw (%bx)\n\t"
	"mov $2068, %bx\n\t"
	"sidt (%bx)\n\t"
	"mov $2074, %bx\n\t"
	"sgdt (%bx)\n\t"
	/* register operands, only for smsw */
	"smsw %ax\n\t"
	"mov %ax, (2080)\n\t"
	"int3\n\t"
	"vmcode_umip_str:\n\t"
	"str %eax\n\t"
	"vmcode_umip_sldt:\n\t"
	"sldt %eax\n\t"
	"int3\n\t"
	".size vmcode, . - vmcode\n\t"
	"end_vmcode:\n\t"
	".code32\n\t"
	".popsection"
	);

extern unsigned char vmcode[], end_vmcode[];
extern unsigned char vmcode_bound[], vmcode_sysenter[], vmcode_syscall[],
	vmcode_sti[], vmcode_int3[], vmcode_int80[], vmcode_popf_hlt[],
	vmcode_umip[], vmcode_umip_str[], vmcode_umip_sldt[];

/* Returns false if the test was skipped. */
static bool do_test(struct vm86plus_struct *v86, unsigned long eip,
		    unsigned int rettype, unsigned int retarg,
		    const char *text)
{
	long ret;

	printf("[RUN]\t%s from vm86 mode\n", text);
	v86->regs.eip = eip;
	ret = vm86(VM86_ENTER, v86);

	if (ret == -1 && (errno == ENOSYS || errno == EPERM)) {
		printf("[SKIP]\tvm86 %s\n",
		       errno == ENOSYS ? "not supported" : "not allowed");
		return false;
	}

	if (VM86_TYPE(ret) == VM86_INTx) {
		char trapname[32];
		int trapno = VM86_ARG(ret);
		if (trapno == 13)
			strcpy(trapname, "GP");
		else if (trapno == 5)
			strcpy(trapname, "BR");
		else if (trapno == 14)
			strcpy(trapname, "PF");
		else
			sprintf(trapname, "%d", trapno);

		printf("[INFO]\tExited vm86 mode due to #%s\n", trapname);
	} else if (VM86_TYPE(ret) == VM86_UNKNOWN) {
		printf("[INFO]\tExited vm86 mode due to unhandled GP fault\n");
	} else if (VM86_TYPE(ret) == VM86_TRAP) {
		printf("[INFO]\tExited vm86 mode due to a trap (arg=%ld)\n",
		       VM86_ARG(ret));
	} else if (VM86_TYPE(ret) == VM86_SIGNAL) {
		printf("[INFO]\tExited vm86 mode due to a signal\n");
	} else if (VM86_TYPE(ret) == VM86_STI) {
		printf("[INFO]\tExited vm86 mode due to STI\n");
	} else {
		printf("[INFO]\tExited vm86 mode due to type %ld, arg %ld\n",
		       VM86_TYPE(ret), VM86_ARG(ret));
	}

	if (rettype == -1 ||
	    (VM86_TYPE(ret) == rettype && VM86_ARG(ret) == retarg)) {
		printf("[OK]\tReturned correctly\n");
	} else {
		printf("[FAIL]\tIncorrect return reason (started at eip = 0x%lx, ended at eip = 0x%lx)\n", eip, v86->regs.eip);
		nerrs++;
	}

	return true;
}

void do_umip_tests(struct vm86plus_struct *vm86, unsigned char *test_mem)
{
	struct table_desc {
		unsigned short limit;
		unsigned long base;
	} __attribute__((packed));

	/* Initialize variables with arbitrary values */
	struct table_desc gdt1 = { .base = 0x3c3c3c3c, .limit = 0x9999 };
	struct table_desc gdt2 = { .base = 0x1a1a1a1a, .limit = 0xaeae };
	struct table_desc idt1 = { .base = 0x7b7b7b7b, .limit = 0xf1f1 };
	struct table_desc idt2 = { .base = 0x89898989, .limit = 0x1313 };
	unsigned short msw1 = 0x1414, msw2 = 0x2525, msw3 = 3737;

	/* UMIP -- exit with INT3 unless kernel emulation did not trap #GP */
	do_test(vm86, vmcode_umip - vmcode, VM86_TRAP, 3, "UMIP tests");

	/* Results from displacement-only addressing */
	msw1 = *(unsigned short *)(test_mem + 2052);
	memcpy(&idt1, test_mem + 2054, sizeof(idt1));
	memcpy(&gdt1, test_mem + 2060, sizeof(gdt1));

	/* Results from register-indirect addressing */
	msw2 = *(unsigned short *)(test_mem + 2066);
	memcpy(&idt2, test_mem + 2068, sizeof(idt2));
	memcpy(&gdt2, test_mem + 2074, sizeof(gdt2));

	/* Results when using register operands */
	msw3 = *(unsigned short *)(test_mem + 2080);

	printf("[INFO]\tResult from SMSW:[0x%04x]\n", msw1);
	printf("[INFO]\tResult from SIDT: limit[0x%04x]base[0x%08lx]\n",
	       idt1.limit, idt1.base);
	printf("[INFO]\tResult from SGDT: limit[0x%04x]base[0x%08lx]\n",
	       gdt1.limit, gdt1.base);

	if (msw1 != msw2 || msw1 != msw3)
		printf("[FAIL]\tAll the results of SMSW should be the same.\n");
	else
		printf("[PASS]\tAll the results from SMSW are identical.\n");

	if (memcmp(&gdt1, &gdt2, sizeof(gdt1)))
		printf("[FAIL]\tAll the results of SGDT should be the same.\n");
	else
		printf("[PASS]\tAll the results from SGDT are identical.\n");

	if (memcmp(&idt1, &idt2, sizeof(idt1)))
		printf("[FAIL]\tAll the results of SIDT should be the same.\n");
	else
		printf("[PASS]\tAll the results from SIDT are identical.\n");

	sethandler(SIGILL, sighandler, 0);
	do_test(vm86, vmcode_umip_str - vmcode, VM86_SIGNAL, 0,
		"STR instruction");
	clearhandler(SIGILL);

	sethandler(SIGILL, sighandler, 0);
	do_test(vm86, vmcode_umip_sldt - vmcode, VM86_SIGNAL, 0,
		"SLDT instruction");
	clearhandler(SIGILL);
}

int main(void)
{
	struct vm86plus_struct v86;
	unsigned char *addr = mmap((void *)load_addr, 4096,
				   PROT_READ | PROT_WRITE | PROT_EXEC,
				   MAP_ANONYMOUS | MAP_PRIVATE, -1,0);
	if (addr != (unsigned char *)load_addr)
		err(1, "mmap");

	memcpy(addr, vmcode, end_vmcode - vmcode);
	addr[2048] = 2;
	addr[2050] = 3;

	memset(&v86, 0, sizeof(v86));

	v86.regs.cs = load_addr / 16;
	v86.regs.ss = load_addr / 16;
	v86.regs.ds = load_addr / 16;
	v86.regs.es = load_addr / 16;

	/* Use the end of the page as our stack. */
	v86.regs.esp = 4096;

	assert((v86.regs.cs & 3) == 0);	/* Looks like RPL = 0 */

	/* #BR -- should deliver SIG??? */
	do_test(&v86, vmcode_bound - vmcode, VM86_INTx, 5, "#BR");

	/*
	 * SYSENTER -- should cause #GP or #UD depending on CPU.
	 * Expected return type -1 means that we shouldn't validate
	 * the vm86 return value.  This will avoid problems on non-SEP
	 * CPUs.
	 */
	sethandler(SIGILL, sighandler, 0);
	do_test(&v86, vmcode_sysenter - vmcode, -1, 0, "SYSENTER");
	clearhandler(SIGILL);

	/*
	 * SYSCALL would be a disaster in VM86 mode.  Fortunately,
	 * there is no kernel that both enables SYSCALL and sets
	 * EFER.SCE, so it's #UD on all systems.  But vm86 is
	 * buggy (or has a "feature"), so the SIGILL will actually
	 * be delivered.
	 */
	sethandler(SIGILL, sighandler, 0);
	do_test(&v86, vmcode_syscall - vmcode, VM86_SIGNAL, 0, "SYSCALL");
	clearhandler(SIGILL);

	/* STI with VIP set */
	v86.regs.eflags |= X86_EFLAGS_VIP;
	v86.regs.eflags &= ~X86_EFLAGS_IF;
	do_test(&v86, vmcode_sti - vmcode, VM86_STI, 0, "STI with VIP set");

	/* POPF with VIP set but IF clear: should not trap */
	v86.regs.eflags = X86_EFLAGS_VIP;
	v86.regs.eax = 0;
	do_test(&v86, vmcode_popf_hlt - vmcode, VM86_UNKNOWN, 0, "POPF with VIP set and IF clear");

	/* POPF with VIP set and IF set: should trap */
	v86.regs.eflags = X86_EFLAGS_VIP;
	v86.regs.eax = X86_EFLAGS_IF;
	do_test(&v86, vmcode_popf_hlt - vmcode, VM86_STI, 0, "POPF with VIP and IF set");

	/* POPF with VIP clear and IF set: should not trap */
	v86.regs.eflags = 0;
	v86.regs.eax = X86_EFLAGS_IF;
	do_test(&v86, vmcode_popf_hlt - vmcode, VM86_UNKNOWN, 0, "POPF with VIP clear and IF set");

	v86.regs.eflags = 0;

	/* INT3 -- should cause #BP */
	do_test(&v86, vmcode_int3 - vmcode, VM86_TRAP, 3, "INT3");

	/* INT80 -- should exit with "INTx 0x80" */
	v86.regs.eax = (unsigned int)-1;
	do_test(&v86, vmcode_int80 - vmcode, VM86_INTx, 0x80, "int80");

	/* UMIP -- should exit with INTx 0x80 unless UMIP was not disabled */
	do_umip_tests(&v86, addr);

	/* Execute a null pointer */
	v86.regs.cs = 0;
	v86.regs.ss = 0;
	sethandler(SIGSEGV, sighandler, 0);
	got_signal = 0;
	if (do_test(&v86, 0, VM86_SIGNAL, 0, "Execute null pointer") &&
	    !got_signal) {
		printf("[FAIL]\tDid not receive SIGSEGV\n");
		nerrs++;
	}
	clearhandler(SIGSEGV);

	/* Make sure nothing explodes if we fork. */
	if (fork() == 0)
		return 0;

	return (nerrs == 0 ? 0 : 1);
}
Commit	Line	Data
c2affbf9 AL	1	/*
	2	* entry_from_vm86.c - tests kernel entries from vm86 mode
	3	* Copyright (c) 2014-2015 Andrew Lutomirski
	4	*
	5	* This exercises a few paths that need to special-case vm86 mode.
	6	*
	7	* GPL v2.
	8	*/
	9
	10	#define _GNU_SOURCE
	11
	12	#include <assert.h>
	13	#include <stdlib.h>
	14	#include <sys/syscall.h>
	15	#include <sys/signal.h>
	16	#include <sys/ucontext.h>
	17	#include <unistd.h>
	18	#include <stdio.h>
	19	#include <string.h>
	20	#include <inttypes.h>
	21	#include <sys/mman.h>
	22	#include <err.h>
	23	#include <stddef.h>
	24	#include <stdbool.h>
	25	#include <errno.h>
	26	#include <sys/vm86.h>
	27
	28	static unsigned long load_addr = 0x10000;
	29	static int nerrs = 0;
	30
f2a50f8b AL	31	static void sethandler(int sig, void (handler)(int, siginfo_t , void *),
	32	int flags)
	33	{
	34	struct sigaction sa;
	35	memset(&sa, 0, sizeof(sa));
	36	sa.sa_sigaction = handler;
	37	sa.sa_flags = SA_SIGINFO \| flags;
	38	sigemptyset(&sa.sa_mask);
	39	if (sigaction(sig, &sa, 0))
	40	err(1, "sigaction");
	41	}
	42
	43	static void clearhandler(int sig)
	44	{
	45	struct sigaction sa;
	46	memset(&sa, 0, sizeof(sa));
	47	sa.sa_handler = SIG_DFL;
	48	sigemptyset(&sa.sa_mask);
	49	if (sigaction(sig, &sa, 0))
	50	err(1, "sigaction");
	51	}
	52
	53	static sig_atomic_t got_signal;
	54
	55	static void sighandler(int sig, siginfo_t info, void ctx_void)
	56	{
	57	ucontext_t ctx = (ucontext_t)ctx_void;
	58
	59	if (ctx->uc_mcontext.gregs[REG_EFL] & X86_EFLAGS_VM \|\|
	60	(ctx->uc_mcontext.gregs[REG_CS] & 3) != 3) {
	61	printf("[FAIL]\tSignal frame should not reflect vm86 mode\n");
	62	nerrs++;
	63	}
	64
	65	const char *signame;
	66	if (sig == SIGSEGV)
	67	signame = "SIGSEGV";
	68	else if (sig == SIGILL)
	69	signame = "SIGILL";
	70	else
	71	signame = "unexpected signal";
	72
	73	printf("[INFO]\t%s: FLAGS = 0x%lx, CS = 0x%hx\n", signame,
	74	(unsigned long)ctx->uc_mcontext.gregs[REG_EFL],
	75	(unsigned short)ctx->uc_mcontext.gregs[REG_CS]);
	76
	77	got_signal = 1;
	78	}
	79
c2affbf9 AL	80	asm (
	81	".pushsection .rodata\n\t"
	82	".type vmcode_bound, @object\n\t"
	83	"vmcode:\n\t"
	84	"vmcode_bound:\n\t"
	85	".code16\n\t"
	86	"bound %ax, (2048)\n\t"
	87	"int3\n\t"
	88	"vmcode_sysenter:\n\t"
	89	"sysenter\n\t"
f2a50f8b AL	90	"vmcode_syscall:\n\t"
	91	"syscall\n\t"
	92	"vmcode_sti:\n\t"
	93	"sti\n\t"
	94	"vmcode_int3:\n\t"
	95	"int3\n\t"
	96	"vmcode_int80:\n\t"
	97	"int $0x80\n\t"
78393fdd AL	98	"vmcode_popf_hlt:\n\t"
	99	"push %ax\n\t"
	100	"popf\n\t"
	101	"hlt\n\t"
9390afeb RN	102	"vmcode_umip:\n\t"
	103	/* addressing via displacements */
	104	"smsw (2052)\n\t"
	105	"sidt (2054)\n\t"
	106	"sgdt (2060)\n\t"
	107	/* addressing via registers */
	108	"mov $2066, %bx\n\t"
	109	"smsw (%bx)\n\t"
	110	"mov $2068, %bx\n\t"
	111	"sidt (%bx)\n\t"
	112	"mov $2074, %bx\n\t"
	113	"sgdt (%bx)\n\t"
	114	/* register operands, only for smsw */
	115	"smsw %ax\n\t"
	116	"mov %ax, (2080)\n\t"
	117	"int3\n\t"
a9e017d5 RN	118	"vmcode_umip_str:\n\t"
	119	"str %eax\n\t"
	120	"vmcode_umip_sldt:\n\t"
	121	"sldt %eax\n\t"
	122	"int3\n\t"
c2affbf9 AL	123	".size vmcode, . - vmcode\n\t"
	124	"end_vmcode:\n\t"
	125	".code32\n\t"
	126	".popsection"
	127	);
	128
	129	extern unsigned char vmcode[], end_vmcode[];
f2a50f8b	130	extern unsigned char vmcode_bound[], vmcode_sysenter[], vmcode_syscall[],
78393fdd AL	131	vmcode_sti[], vmcode_int3[], vmcode_int80[], vmcode_popf_hlt[],
78393fdd AL	132	vmcode_umip[], vmcode_umip_str[], vmcode_umip_sldt[];
c2affbf9	133
e800eb39 AL	134	/* Returns false if the test was skipped. */
e800eb39 AL	135	static bool do_test(struct vm86plus_struct *v86, unsigned long eip,
f2a50f8b	136	unsigned int rettype, unsigned int retarg,
c2affbf9 AL	137	const char *text)
	138	{
	139	long ret;
	140
	141	printf("[RUN]\t%s from vm86 mode\n", text);
	142	v86->regs.eip = eip;
	143	ret = vm86(VM86_ENTER, v86);
	144
76fc5e7b AL	145	if (ret == -1 && (errno == ENOSYS \|\| errno == EPERM)) {
	146	printf("[SKIP]\tvm86 %s\n",
	147	errno == ENOSYS ? "not supported" : "not allowed");
e800eb39	148	return false;
c2affbf9 AL	149	}
	150
	151	if (VM86_TYPE(ret) == VM86_INTx) {
	152	char trapname[32];
	153	int trapno = VM86_ARG(ret);
	154	if (trapno == 13)
	155	strcpy(trapname, "GP");
	156	else if (trapno == 5)
	157	strcpy(trapname, "BR");
	158	else if (trapno == 14)
	159	strcpy(trapname, "PF");
	160	else
	161	sprintf(trapname, "%d", trapno);
	162
f2a50f8b	163	printf("[INFO]\tExited vm86 mode due to #%s\n", trapname);
c2affbf9	164	} else if (VM86_TYPE(ret) == VM86_UNKNOWN) {
f2a50f8b AL	165	printf("[INFO]\tExited vm86 mode due to unhandled GP fault\n");
	166	} else if (VM86_TYPE(ret) == VM86_TRAP) {
	167	printf("[INFO]\tExited vm86 mode due to a trap (arg=%ld)\n",
	168	VM86_ARG(ret));
	169	} else if (VM86_TYPE(ret) == VM86_SIGNAL) {
	170	printf("[INFO]\tExited vm86 mode due to a signal\n");
	171	} else if (VM86_TYPE(ret) == VM86_STI) {
	172	printf("[INFO]\tExited vm86 mode due to STI\n");
c2affbf9	173	} else {
f2a50f8b	174	printf("[INFO]\tExited vm86 mode due to type %ld, arg %ld\n",
c2affbf9 AL	175	VM86_TYPE(ret), VM86_ARG(ret));
c2affbf9 AL	176	}
f2a50f8b AL	177
	178	if (rettype == -1 \|\|
	179	(VM86_TYPE(ret) == rettype && VM86_ARG(ret) == retarg)) {
	180	printf("[OK]\tReturned correctly\n");
	181	} else {
78393fdd	182	printf("[FAIL]\tIncorrect return reason (started at eip = 0x%lx, ended at eip = 0x%lx)\n", eip, v86->regs.eip);
f2a50f8b AL	183	nerrs++;
f2a50f8b AL	184	}
e800eb39 AL	185
e800eb39 AL	186	return true;
c2affbf9 AL	187	}
c2affbf9 AL	188
9390afeb RN	189	void do_umip_tests(struct vm86plus_struct vm86, unsigned char test_mem)
	190	{
	191	struct table_desc {
	192	unsigned short limit;
	193	unsigned long base;
	194	} __attribute__((packed));
	195
	196	/* Initialize variables with arbitrary values */
	197	struct table_desc gdt1 = { .base = 0x3c3c3c3c, .limit = 0x9999 };
	198	struct table_desc gdt2 = { .base = 0x1a1a1a1a, .limit = 0xaeae };
	199	struct table_desc idt1 = { .base = 0x7b7b7b7b, .limit = 0xf1f1 };
	200	struct table_desc idt2 = { .base = 0x89898989, .limit = 0x1313 };
	201	unsigned short msw1 = 0x1414, msw2 = 0x2525, msw3 = 3737;
	202
	203	/* UMIP -- exit with INT3 unless kernel emulation did not trap #GP */
	204	do_test(vm86, vmcode_umip - vmcode, VM86_TRAP, 3, "UMIP tests");
	205
	206	/* Results from displacement-only addressing */
	207	msw1 = (unsigned short )(test_mem + 2052);
	208	memcpy(&idt1, test_mem + 2054, sizeof(idt1));
	209	memcpy(&gdt1, test_mem + 2060, sizeof(gdt1));
	210
	211	/* Results from register-indirect addressing */
	212	msw2 = (unsigned short )(test_mem + 2066);
	213	memcpy(&idt2, test_mem + 2068, sizeof(idt2));
	214	memcpy(&gdt2, test_mem + 2074, sizeof(gdt2));
	215
	216	/* Results when using register operands */
	217	msw3 = (unsigned short )(test_mem + 2080);
	218
	219	printf("[INFO]\tResult from SMSW:[0x%04x]\n", msw1);
	220	printf("[INFO]\tResult from SIDT: limit[0x%04x]base[0x%08lx]\n",
	221	idt1.limit, idt1.base);
	222	printf("[INFO]\tResult from SGDT: limit[0x%04x]base[0x%08lx]\n",
	223	gdt1.limit, gdt1.base);
	224
	225	if (msw1 != msw2 \|\| msw1 != msw3)
	226	printf("[FAIL]\tAll the results of SMSW should be the same.\n");
	227	else
	228	printf("[PASS]\tAll the results from SMSW are identical.\n");
	229
	230	if (memcmp(&gdt1, &gdt2, sizeof(gdt1)))
	231	printf("[FAIL]\tAll the results of SGDT should be the same.\n");
	232	else
	233	printf("[PASS]\tAll the results from SGDT are identical.\n");
	234
	235	if (memcmp(&idt1, &idt2, sizeof(idt1)))
	236	printf("[FAIL]\tAll the results of SIDT should be the same.\n");
	237	else
	238	printf("[PASS]\tAll the results from SIDT are identical.\n");
a9e017d5 RN	239
	240	sethandler(SIGILL, sighandler, 0);
	241	do_test(vm86, vmcode_umip_str - vmcode, VM86_SIGNAL, 0,
	242	"STR instruction");
	243	clearhandler(SIGILL);
	244
	245	sethandler(SIGILL, sighandler, 0);
	246	do_test(vm86, vmcode_umip_sldt - vmcode, VM86_SIGNAL, 0,
	247	"SLDT instruction");
	248	clearhandler(SIGILL);
9390afeb RN	249	}
9390afeb RN	250
c2affbf9 AL	251	int main(void)
	252	{
	253	struct vm86plus_struct v86;
	254	unsigned char addr = mmap((void )load_addr, 4096,
	255	PROT_READ \| PROT_WRITE \| PROT_EXEC,
	256	MAP_ANONYMOUS \| MAP_PRIVATE, -1,0);
	257	if (addr != (unsigned char *)load_addr)
	258	err(1, "mmap");
	259
	260	memcpy(addr, vmcode, end_vmcode - vmcode);
	261	addr[2048] = 2;
	262	addr[2050] = 3;
	263
	264	memset(&v86, 0, sizeof(v86));
	265
	266	v86.regs.cs = load_addr / 16;
	267	v86.regs.ss = load_addr / 16;
	268	v86.regs.ds = load_addr / 16;
	269	v86.regs.es = load_addr / 16;
	270
78393fdd AL	271	/* Use the end of the page as our stack. */
	272	v86.regs.esp = 4096;
	273
c2affbf9 AL	274	assert((v86.regs.cs & 3) == 0); /* Looks like RPL = 0 */
	275
	276	/* #BR -- should deliver SIG??? */
f2a50f8b AL	277	do_test(&v86, vmcode_bound - vmcode, VM86_INTx, 5, "#BR");
	278
	279	/*
	280	* SYSENTER -- should cause #GP or #UD depending on CPU.
	281	* Expected return type -1 means that we shouldn't validate
	282	* the vm86 return value. This will avoid problems on non-SEP
	283	* CPUs.
	284	*/
	285	sethandler(SIGILL, sighandler, 0);
	286	do_test(&v86, vmcode_sysenter - vmcode, -1, 0, "SYSENTER");
	287	clearhandler(SIGILL);
	288
	289	/*
	290	* SYSCALL would be a disaster in VM86 mode. Fortunately,
	291	* there is no kernel that both enables SYSCALL and sets
	292	* EFER.SCE, so it's #UD on all systems. But vm86 is
	293	* buggy (or has a "feature"), so the SIGILL will actually
	294	* be delivered.
	295	*/
	296	sethandler(SIGILL, sighandler, 0);
	297	do_test(&v86, vmcode_syscall - vmcode, VM86_SIGNAL, 0, "SYSCALL");
	298	clearhandler(SIGILL);
	299
	300	/* STI with VIP set */
	301	v86.regs.eflags \|= X86_EFLAGS_VIP;
	302	v86.regs.eflags &= ~X86_EFLAGS_IF;
	303	do_test(&v86, vmcode_sti - vmcode, VM86_STI, 0, "STI with VIP set");
	304
78393fdd AL	305	/* POPF with VIP set but IF clear: should not trap */
	306	v86.regs.eflags = X86_EFLAGS_VIP;
	307	v86.regs.eax = 0;
	308	do_test(&v86, vmcode_popf_hlt - vmcode, VM86_UNKNOWN, 0, "POPF with VIP set and IF clear");
	309
	310	/* POPF with VIP set and IF set: should trap */
	311	v86.regs.eflags = X86_EFLAGS_VIP;
	312	v86.regs.eax = X86_EFLAGS_IF;
	313	do_test(&v86, vmcode_popf_hlt - vmcode, VM86_STI, 0, "POPF with VIP and IF set");
	314
	315	/* POPF with VIP clear and IF set: should not trap */
	316	v86.regs.eflags = 0;
	317	v86.regs.eax = X86_EFLAGS_IF;
	318	do_test(&v86, vmcode_popf_hlt - vmcode, VM86_UNKNOWN, 0, "POPF with VIP clear and IF set");
	319
	320	v86.regs.eflags = 0;
	321
f2a50f8b AL	322	/* INT3 -- should cause #BP */
	323	do_test(&v86, vmcode_int3 - vmcode, VM86_TRAP, 3, "INT3");
	324
	325	/* INT80 -- should exit with "INTx 0x80" */
	326	v86.regs.eax = (unsigned int)-1;
	327	do_test(&v86, vmcode_int80 - vmcode, VM86_INTx, 0x80, "int80");
	328
9390afeb RN	329	/* UMIP -- should exit with INTx 0x80 unless UMIP was not disabled */
	330	do_umip_tests(&v86, addr);
	331
f2a50f8b AL	332	/* Execute a null pointer */
	333	v86.regs.cs = 0;
	334	v86.regs.ss = 0;
	335	sethandler(SIGSEGV, sighandler, 0);
	336	got_signal = 0;
e800eb39 AL	337	if (do_test(&v86, 0, VM86_SIGNAL, 0, "Execute null pointer") &&
e800eb39 AL	338	!got_signal) {
f2a50f8b AL	339	printf("[FAIL]\tDid not receive SIGSEGV\n");
	340	nerrs++;
	341	}
	342	clearhandler(SIGSEGV);
c2affbf9	343
226f1f72	344	/* Make sure nothing explodes if we fork. */
327d53d0	345	if (fork() == 0)
226f1f72 AL	346	return 0;
226f1f72 AL	347
c2affbf9 AL	348	return (nerrs == 0 ? 0 : 1);
c2affbf9 AL	349	}