1 // SPDX-License-Identifier: GPL-2.0-only 2 #include "test_util.h" 3 #include "kvm_util.h" 4 #include "processor.h" 5 6 #include <signal.h> 7 #include <string.h> 8 #include <sys/ioctl.h> 9 #include <sys/time.h> 10 11 #include "kselftest.h" 12 13 static void guest_ud_handler(struct ex_regs *regs) 14 { 15 /* Loop on the ud2 until guest state is made invalid. */ 16 } 17 18 static void guest_code(void) 19 { 20 asm volatile("ud2"); 21 } 22 23 static void __run_vcpu_with_invalid_state(struct kvm_vcpu *vcpu) 24 { 25 struct kvm_run *run = vcpu->run; 26 27 vcpu_run(vcpu); 28 29 TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_INTERNAL_ERROR); 30 TEST_ASSERT(run->emulation_failure.suberror == KVM_INTERNAL_ERROR_EMULATION, 31 "Expected emulation failure, got %d\n", 32 run->emulation_failure.suberror); 33 } 34 35 static void run_vcpu_with_invalid_state(struct kvm_vcpu *vcpu) 36 { 37 /* 38 * Always run twice to verify KVM handles the case where _KVM_ queues 39 * an exception with invalid state and then exits to userspace, i.e. 40 * that KVM doesn't explode if userspace ignores the initial error. 41 */ 42 __run_vcpu_with_invalid_state(vcpu); 43 __run_vcpu_with_invalid_state(vcpu); 44 } 45 46 static void set_timer(void) 47 { 48 struct itimerval timer; 49 50 timer.it_value.tv_sec = 0; 51 timer.it_value.tv_usec = 200; 52 timer.it_interval = timer.it_value; 53 ASSERT_EQ(setitimer(ITIMER_REAL, &timer, NULL), 0); 54 } 55 56 static void set_or_clear_invalid_guest_state(struct kvm_vcpu *vcpu, bool set) 57 { 58 static struct kvm_sregs sregs; 59 60 if (!sregs.cr0) 61 vcpu_sregs_get(vcpu, &sregs); 62 sregs.tr.unusable = !!set; 63 vcpu_sregs_set(vcpu, &sregs); 64 } 65 66 static void set_invalid_guest_state(struct kvm_vcpu *vcpu) 67 { 68 set_or_clear_invalid_guest_state(vcpu, true); 69 } 70 71 static void clear_invalid_guest_state(struct kvm_vcpu *vcpu) 72 { 73 set_or_clear_invalid_guest_state(vcpu, false); 74 } 75 76 static struct kvm_vcpu *get_set_sigalrm_vcpu(struct kvm_vcpu *__vcpu) 77 { 78 static struct kvm_vcpu *vcpu = NULL; 79 80 if (__vcpu) 81 vcpu = __vcpu; 82 return vcpu; 83 } 84 85 static void sigalrm_handler(int sig) 86 { 87 struct kvm_vcpu *vcpu = get_set_sigalrm_vcpu(NULL); 88 struct kvm_vcpu_events events; 89 90 TEST_ASSERT(sig == SIGALRM, "Unexpected signal = %d", sig); 91 92 vcpu_events_get(vcpu, &events); 93 94 /* 95 * If an exception is pending, attempt KVM_RUN with invalid guest, 96 * otherwise rearm the timer and keep doing so until the timer fires 97 * between KVM queueing an exception and re-entering the guest. 98 */ 99 if (events.exception.pending) { 100 set_invalid_guest_state(vcpu); 101 run_vcpu_with_invalid_state(vcpu); 102 } else { 103 set_timer(); 104 } 105 } 106 107 int main(int argc, char *argv[]) 108 { 109 struct kvm_vcpu *vcpu; 110 struct kvm_vm *vm; 111 112 TEST_REQUIRE(host_cpu_is_intel); 113 TEST_REQUIRE(!vm_is_unrestricted_guest(NULL)); 114 115 vm = vm_create_with_one_vcpu(&vcpu, guest_code); 116 get_set_sigalrm_vcpu(vcpu); 117 118 vm_init_descriptor_tables(vm); 119 vcpu_init_descriptor_tables(vcpu); 120 121 vm_install_exception_handler(vm, UD_VECTOR, guest_ud_handler); 122 123 /* 124 * Stuff invalid guest state for L2 by making TR unusuable. The next 125 * KVM_RUN should induce a TRIPLE_FAULT in L2 as KVM doesn't support 126 * emulating invalid guest state for L2. 127 */ 128 set_invalid_guest_state(vcpu); 129 run_vcpu_with_invalid_state(vcpu); 130 131 /* 132 * Verify KVM also handles the case where userspace gains control while 133 * an exception is pending and stuffs invalid state. Run with valid 134 * guest state and a timer firing every 200us, and attempt to enter the 135 * guest with invalid state when the handler interrupts KVM with an 136 * exception pending. 137 */ 138 clear_invalid_guest_state(vcpu); 139 TEST_ASSERT(signal(SIGALRM, sigalrm_handler) != SIG_ERR, 140 "Failed to register SIGALRM handler, errno = %d (%s)", 141 errno, strerror(errno)); 142 143 set_timer(); 144 run_vcpu_with_invalid_state(vcpu); 145 } 146