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