1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2024, Intel, Inc 4 * 5 * Author: 6 * Isaku Yamahata <isaku.yamahata at gmail.com> 7 */ 8 #include <linux/sizes.h> 9 10 #include <test_util.h> 11 #include <kvm_util.h> 12 #include <processor.h> 13 #include <pthread.h> 14 #include <ucall_common.h> 15 16 /* Arbitrarily chosen values */ 17 #define TEST_SIZE (SZ_2M + PAGE_SIZE) 18 #define TEST_NPAGES (TEST_SIZE / PAGE_SIZE) 19 #define TEST_SLOT 10 20 21 static void guest_code(u64 base_gva) 22 { 23 volatile u64 val __used; 24 int i; 25 26 for (i = 0; i < TEST_NPAGES; i++) { 27 u64 *src = (u64 *)(base_gva + i * PAGE_SIZE); 28 29 val = *src; 30 } 31 32 GUEST_DONE(); 33 } 34 35 struct slot_worker_data { 36 struct kvm_vm *vm; 37 gpa_t gpa; 38 u32 flags; 39 bool worker_ready; 40 bool prefault_ready; 41 bool recreate_slot; 42 }; 43 44 static void *delete_slot_worker(void *__data) 45 { 46 struct slot_worker_data *data = __data; 47 struct kvm_vm *vm = data->vm; 48 49 WRITE_ONCE(data->worker_ready, true); 50 51 while (!READ_ONCE(data->prefault_ready)) 52 cpu_relax(); 53 54 vm_mem_region_delete(vm, TEST_SLOT); 55 56 while (!READ_ONCE(data->recreate_slot)) 57 cpu_relax(); 58 59 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, data->gpa, 60 TEST_SLOT, TEST_NPAGES, data->flags); 61 62 return NULL; 63 } 64 65 static void pre_fault_memory(struct kvm_vcpu *vcpu, u64 base_gpa, u64 offset, 66 u64 size, u64 expected_left, bool private) 67 { 68 struct kvm_pre_fault_memory range = { 69 .gpa = base_gpa + offset, 70 .size = size, 71 .flags = 0, 72 }; 73 struct slot_worker_data data = { 74 .vm = vcpu->vm, 75 .gpa = base_gpa, 76 .flags = private ? KVM_MEM_GUEST_MEMFD : 0, 77 }; 78 bool slot_recreated = false; 79 pthread_t slot_worker; 80 int ret, save_errno; 81 u64 prev; 82 83 /* 84 * Concurrently delete (and recreate) the slot to test KVM's handling 85 * of a racing memslot deletion with prefaulting. 86 */ 87 pthread_create(&slot_worker, NULL, delete_slot_worker, &data); 88 89 while (!READ_ONCE(data.worker_ready)) 90 cpu_relax(); 91 92 WRITE_ONCE(data.prefault_ready, true); 93 94 for (;;) { 95 prev = range.size; 96 ret = __vcpu_ioctl(vcpu, KVM_PRE_FAULT_MEMORY, &range); 97 save_errno = errno; 98 TEST_ASSERT((range.size < prev) ^ (ret < 0), 99 "%sexpecting range.size to change on %s", 100 ret < 0 ? "not " : "", 101 ret < 0 ? "failure" : "success"); 102 103 /* 104 * Immediately retry prefaulting if KVM was interrupted by an 105 * unrelated signal/event. 106 */ 107 if (ret < 0 && save_errno == EINTR) 108 continue; 109 110 /* 111 * Tell the worker to recreate the slot in order to complete 112 * prefaulting (if prefault didn't already succeed before the 113 * slot was deleted) and/or to prepare for the next testcase. 114 * Wait for the worker to exit so that the next invocation of 115 * prefaulting is guaranteed to complete (assuming no KVM bugs). 116 */ 117 if (!slot_recreated) { 118 WRITE_ONCE(data.recreate_slot, true); 119 pthread_join(slot_worker, NULL); 120 slot_recreated = true; 121 122 /* 123 * Retry prefaulting to get a stable result, i.e. to 124 * avoid seeing random EAGAIN failures. Don't retry if 125 * prefaulting already succeeded, as KVM disallows 126 * prefaulting with size=0, i.e. blindly retrying would 127 * result in test failures due to EINVAL. KVM should 128 * always return success if all bytes are prefaulted, 129 * i.e. there is no need to guard against EAGAIN being 130 * returned. 131 */ 132 if (range.size) 133 continue; 134 } 135 136 /* 137 * All done if there are no remaining bytes to prefault, or if 138 * prefaulting failed (EINTR was handled above, and EAGAIN due 139 * to prefaulting a memslot that's being actively deleted should 140 * be impossible since the memslot has already been recreated). 141 */ 142 if (!range.size || ret < 0) 143 break; 144 } 145 146 TEST_ASSERT(range.size == expected_left, 147 "Completed with %llu bytes left, expected %lu", 148 range.size, expected_left); 149 150 /* 151 * Assert success if prefaulting the entire range should succeed, i.e. 152 * complete with no bytes remaining. Otherwise prefaulting should have 153 * failed due to ENOENT (due to RET_PF_EMULATE for emulated MMIO when 154 * no memslot exists). 155 */ 156 if (!expected_left) 157 TEST_ASSERT_VM_VCPU_IOCTL(!ret, KVM_PRE_FAULT_MEMORY, ret, vcpu->vm); 158 else 159 TEST_ASSERT_VM_VCPU_IOCTL(ret && save_errno == ENOENT, 160 KVM_PRE_FAULT_MEMORY, ret, vcpu->vm); 161 } 162 163 static void __test_pre_fault_memory(unsigned long vm_type, bool private) 164 { 165 gpa_t gpa, gva, alignment, guest_page_size; 166 const struct vm_shape shape = { 167 .mode = VM_MODE_DEFAULT, 168 .type = vm_type, 169 }; 170 struct kvm_vcpu *vcpu; 171 struct kvm_vm *vm; 172 struct ucall uc; 173 174 vm = vm_create_shape_with_one_vcpu(shape, &vcpu, guest_code); 175 176 alignment = guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size; 177 gpa = (vm->max_gfn - TEST_NPAGES) * guest_page_size; 178 alignment = SZ_2M; 179 gpa = align_down(gpa, alignment); 180 gva = gpa & ((1ULL << (vm->va_bits - 1)) - 1); 181 182 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, gpa, TEST_SLOT, 183 TEST_NPAGES, private ? KVM_MEM_GUEST_MEMFD : 0); 184 virt_map(vm, gva, gpa, TEST_NPAGES); 185 186 if (private) 187 vm_mem_set_private(vm, gpa, TEST_SIZE); 188 189 pre_fault_memory(vcpu, gpa, 0, SZ_2M, 0, private); 190 pre_fault_memory(vcpu, gpa, SZ_2M, PAGE_SIZE * 2, PAGE_SIZE, private); 191 pre_fault_memory(vcpu, gpa, TEST_SIZE, PAGE_SIZE, PAGE_SIZE, private); 192 193 vcpu_args_set(vcpu, 1, gva); 194 vcpu_run(vcpu); 195 196 switch (get_ucall(vcpu, &uc)) { 197 case UCALL_ABORT: 198 REPORT_GUEST_ASSERT(uc); 199 break; 200 case UCALL_DONE: 201 break; 202 default: 203 TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd); 204 break; 205 } 206 207 kvm_vm_free(vm); 208 } 209 210 static void test_pre_fault_memory(unsigned long vm_type, bool private) 211 { 212 if (vm_type && !(kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(vm_type))) { 213 pr_info("Skipping tests for vm_type 0x%lx\n", vm_type); 214 return; 215 } 216 217 __test_pre_fault_memory(vm_type, private); 218 } 219 220 int main(int argc, char *argv[]) 221 { 222 TEST_REQUIRE(kvm_check_cap(KVM_CAP_PRE_FAULT_MEMORY)); 223 224 test_pre_fault_memory(0, false); 225 #ifdef __x86_64__ 226 test_pre_fault_memory(KVM_X86_SW_PROTECTED_VM, false); 227 test_pre_fault_memory(KVM_X86_SW_PROTECTED_VM, true); 228 #endif 229 return 0; 230 } 231