1 // SPDX-License-Identifier: GPL-2.0
2 #include <fcntl.h>
3 #include <pthread.h>
4 #include <sched.h>
5 #include <semaphore.h>
6 #include <signal.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <sys/ioctl.h>
11 #include <sys/mman.h>
12
13 #include <linux/compiler.h>
14
15 #include <test_util.h>
16 #include <kvm_util.h>
17 #include <processor.h>
18
19 /*
20 * s390x needs at least 1MB alignment, and the x86_64 MOVE/DELETE tests need a
21 * 2MB sized and aligned region so that the initial region corresponds to
22 * exactly one large page.
23 */
24 #define MEM_REGION_SIZE 0x200000
25
26 #ifdef __x86_64__
27 /*
28 * Somewhat arbitrary location and slot, intended to not overlap anything.
29 */
30 #define MEM_REGION_GPA 0xc0000000
31 #define MEM_REGION_SLOT 10
32
33 static const uint64_t MMIO_VAL = 0xbeefull;
34
35 extern const uint64_t final_rip_start;
36 extern const uint64_t final_rip_end;
37
38 static sem_t vcpu_ready;
39
guest_spin_on_val(uint64_t spin_val)40 static inline uint64_t guest_spin_on_val(uint64_t spin_val)
41 {
42 uint64_t val;
43
44 do {
45 val = READ_ONCE(*((uint64_t *)MEM_REGION_GPA));
46 } while (val == spin_val);
47
48 GUEST_SYNC(0);
49 return val;
50 }
51
vcpu_worker(void * data)52 static void *vcpu_worker(void *data)
53 {
54 struct kvm_vcpu *vcpu = data;
55 struct kvm_run *run = vcpu->run;
56 struct ucall uc;
57 uint64_t cmd;
58
59 /*
60 * Loop until the guest is done. Re-enter the guest on all MMIO exits,
61 * which will occur if the guest attempts to access a memslot after it
62 * has been deleted or while it is being moved .
63 */
64 while (1) {
65 vcpu_run(vcpu);
66
67 if (run->exit_reason == KVM_EXIT_IO) {
68 cmd = get_ucall(vcpu, &uc);
69 if (cmd != UCALL_SYNC)
70 break;
71
72 sem_post(&vcpu_ready);
73 continue;
74 }
75
76 if (run->exit_reason != KVM_EXIT_MMIO)
77 break;
78
79 TEST_ASSERT(!run->mmio.is_write, "Unexpected exit mmio write");
80 TEST_ASSERT(run->mmio.len == 8,
81 "Unexpected exit mmio size = %u", run->mmio.len);
82
83 TEST_ASSERT(run->mmio.phys_addr == MEM_REGION_GPA,
84 "Unexpected exit mmio address = 0x%llx",
85 run->mmio.phys_addr);
86 memcpy(run->mmio.data, &MMIO_VAL, 8);
87 }
88
89 if (run->exit_reason == KVM_EXIT_IO && cmd == UCALL_ABORT)
90 REPORT_GUEST_ASSERT(uc);
91
92 return NULL;
93 }
94
wait_for_vcpu(void)95 static void wait_for_vcpu(void)
96 {
97 struct timespec ts;
98
99 TEST_ASSERT(!clock_gettime(CLOCK_REALTIME, &ts),
100 "clock_gettime() failed: %d", errno);
101
102 ts.tv_sec += 2;
103 TEST_ASSERT(!sem_timedwait(&vcpu_ready, &ts),
104 "sem_timedwait() failed: %d", errno);
105
106 /* Wait for the vCPU thread to reenter the guest. */
107 usleep(100000);
108 }
109
spawn_vm(struct kvm_vcpu ** vcpu,pthread_t * vcpu_thread,void * guest_code)110 static struct kvm_vm *spawn_vm(struct kvm_vcpu **vcpu, pthread_t *vcpu_thread,
111 void *guest_code)
112 {
113 struct kvm_vm *vm;
114 uint64_t *hva;
115 uint64_t gpa;
116
117 vm = vm_create_with_one_vcpu(vcpu, guest_code);
118
119 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS_THP,
120 MEM_REGION_GPA, MEM_REGION_SLOT,
121 MEM_REGION_SIZE / getpagesize(), 0);
122
123 /*
124 * Allocate and map two pages so that the GPA accessed by guest_code()
125 * stays valid across the memslot move.
126 */
127 gpa = vm_phy_pages_alloc(vm, 2, MEM_REGION_GPA, MEM_REGION_SLOT);
128 TEST_ASSERT(gpa == MEM_REGION_GPA, "Failed vm_phy_pages_alloc\n");
129
130 virt_map(vm, MEM_REGION_GPA, MEM_REGION_GPA, 2);
131
132 /* Ditto for the host mapping so that both pages can be zeroed. */
133 hva = addr_gpa2hva(vm, MEM_REGION_GPA);
134 memset(hva, 0, 2 * 4096);
135
136 pthread_create(vcpu_thread, NULL, vcpu_worker, *vcpu);
137
138 /* Ensure the guest thread is spun up. */
139 wait_for_vcpu();
140
141 return vm;
142 }
143
144
guest_code_move_memory_region(void)145 static void guest_code_move_memory_region(void)
146 {
147 uint64_t val;
148
149 GUEST_SYNC(0);
150
151 /*
152 * Spin until the memory region starts getting moved to a
153 * misaligned address.
154 * Every region move may or may not trigger MMIO, as the
155 * window where the memslot is invalid is usually quite small.
156 */
157 val = guest_spin_on_val(0);
158 __GUEST_ASSERT(val == 1 || val == MMIO_VAL,
159 "Expected '1' or MMIO ('%lx'), got '%lx'", MMIO_VAL, val);
160
161 /* Spin until the misaligning memory region move completes. */
162 val = guest_spin_on_val(MMIO_VAL);
163 __GUEST_ASSERT(val == 1 || val == 0,
164 "Expected '0' or '1' (no MMIO), got '%lx'", val);
165
166 /* Spin until the memory region starts to get re-aligned. */
167 val = guest_spin_on_val(0);
168 __GUEST_ASSERT(val == 1 || val == MMIO_VAL,
169 "Expected '1' or MMIO ('%lx'), got '%lx'", MMIO_VAL, val);
170
171 /* Spin until the re-aligning memory region move completes. */
172 val = guest_spin_on_val(MMIO_VAL);
173 GUEST_ASSERT_EQ(val, 1);
174
175 GUEST_DONE();
176 }
177
test_move_memory_region(bool disable_slot_zap_quirk)178 static void test_move_memory_region(bool disable_slot_zap_quirk)
179 {
180 pthread_t vcpu_thread;
181 struct kvm_vcpu *vcpu;
182 struct kvm_vm *vm;
183 uint64_t *hva;
184
185 vm = spawn_vm(&vcpu, &vcpu_thread, guest_code_move_memory_region);
186
187 if (disable_slot_zap_quirk)
188 vm_enable_cap(vm, KVM_CAP_DISABLE_QUIRKS2, KVM_X86_QUIRK_SLOT_ZAP_ALL);
189
190 hva = addr_gpa2hva(vm, MEM_REGION_GPA);
191
192 /*
193 * Shift the region's base GPA. The guest should not see "2" as the
194 * hva->gpa translation is misaligned, i.e. the guest is accessing a
195 * different host pfn.
196 */
197 vm_mem_region_move(vm, MEM_REGION_SLOT, MEM_REGION_GPA - 4096);
198 WRITE_ONCE(*hva, 2);
199
200 /*
201 * The guest _might_ see an invalid memslot and trigger MMIO, but it's
202 * a tiny window. Spin and defer the sync until the memslot is
203 * restored and guest behavior is once again deterministic.
204 */
205 usleep(100000);
206
207 /*
208 * Note, value in memory needs to be changed *before* restoring the
209 * memslot, else the guest could race the update and see "2".
210 */
211 WRITE_ONCE(*hva, 1);
212
213 /* Restore the original base, the guest should see "1". */
214 vm_mem_region_move(vm, MEM_REGION_SLOT, MEM_REGION_GPA);
215 wait_for_vcpu();
216 /* Defered sync from when the memslot was misaligned (above). */
217 wait_for_vcpu();
218
219 pthread_join(vcpu_thread, NULL);
220
221 kvm_vm_free(vm);
222 }
223
guest_code_delete_memory_region(void)224 static void guest_code_delete_memory_region(void)
225 {
226 struct desc_ptr idt;
227 uint64_t val;
228
229 /*
230 * Clobber the IDT so that a #PF due to the memory region being deleted
231 * escalates to triple-fault shutdown. Because the memory region is
232 * deleted, there will be no valid mappings. As a result, KVM will
233 * repeatedly intercepts the state-2 page fault that occurs when trying
234 * to vector the guest's #PF. I.e. trying to actually handle the #PF
235 * in the guest will never succeed, and so isn't an option.
236 */
237 memset(&idt, 0, sizeof(idt));
238 __asm__ __volatile__("lidt %0" :: "m"(idt));
239
240 GUEST_SYNC(0);
241
242 /* Spin until the memory region is deleted. */
243 val = guest_spin_on_val(0);
244 GUEST_ASSERT_EQ(val, MMIO_VAL);
245
246 /* Spin until the memory region is recreated. */
247 val = guest_spin_on_val(MMIO_VAL);
248 GUEST_ASSERT_EQ(val, 0);
249
250 /* Spin until the memory region is deleted. */
251 val = guest_spin_on_val(0);
252 GUEST_ASSERT_EQ(val, MMIO_VAL);
253
254 asm("1:\n\t"
255 ".pushsection .rodata\n\t"
256 ".global final_rip_start\n\t"
257 "final_rip_start: .quad 1b\n\t"
258 ".popsection");
259
260 /* Spin indefinitely (until the code memslot is deleted). */
261 guest_spin_on_val(MMIO_VAL);
262
263 asm("1:\n\t"
264 ".pushsection .rodata\n\t"
265 ".global final_rip_end\n\t"
266 "final_rip_end: .quad 1b\n\t"
267 ".popsection");
268
269 GUEST_ASSERT(0);
270 }
271
test_delete_memory_region(bool disable_slot_zap_quirk)272 static void test_delete_memory_region(bool disable_slot_zap_quirk)
273 {
274 pthread_t vcpu_thread;
275 struct kvm_vcpu *vcpu;
276 struct kvm_regs regs;
277 struct kvm_run *run;
278 struct kvm_vm *vm;
279
280 vm = spawn_vm(&vcpu, &vcpu_thread, guest_code_delete_memory_region);
281
282 if (disable_slot_zap_quirk)
283 vm_enable_cap(vm, KVM_CAP_DISABLE_QUIRKS2, KVM_X86_QUIRK_SLOT_ZAP_ALL);
284
285 /* Delete the memory region, the guest should not die. */
286 vm_mem_region_delete(vm, MEM_REGION_SLOT);
287 wait_for_vcpu();
288
289 /* Recreate the memory region. The guest should see "0". */
290 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS_THP,
291 MEM_REGION_GPA, MEM_REGION_SLOT,
292 MEM_REGION_SIZE / getpagesize(), 0);
293 wait_for_vcpu();
294
295 /* Delete the region again so that there's only one memslot left. */
296 vm_mem_region_delete(vm, MEM_REGION_SLOT);
297 wait_for_vcpu();
298
299 /*
300 * Delete the primary memslot. This should cause an emulation error or
301 * shutdown due to the page tables getting nuked.
302 */
303 vm_mem_region_delete(vm, 0);
304
305 pthread_join(vcpu_thread, NULL);
306
307 run = vcpu->run;
308
309 TEST_ASSERT(run->exit_reason == KVM_EXIT_SHUTDOWN ||
310 run->exit_reason == KVM_EXIT_INTERNAL_ERROR,
311 "Unexpected exit reason = %d", run->exit_reason);
312
313 vcpu_regs_get(vcpu, ®s);
314
315 /*
316 * On AMD, after KVM_EXIT_SHUTDOWN the VMCB has been reinitialized already,
317 * so the instruction pointer would point to the reset vector.
318 */
319 if (run->exit_reason == KVM_EXIT_INTERNAL_ERROR)
320 TEST_ASSERT(regs.rip >= final_rip_start &&
321 regs.rip < final_rip_end,
322 "Bad rip, expected 0x%lx - 0x%lx, got 0x%llx",
323 final_rip_start, final_rip_end, regs.rip);
324
325 kvm_vm_free(vm);
326 }
327
test_zero_memory_regions(void)328 static void test_zero_memory_regions(void)
329 {
330 struct kvm_vcpu *vcpu;
331 struct kvm_vm *vm;
332
333 pr_info("Testing KVM_RUN with zero added memory regions\n");
334
335 vm = vm_create_barebones();
336 vcpu = __vm_vcpu_add(vm, 0);
337
338 vm_ioctl(vm, KVM_SET_NR_MMU_PAGES, (void *)64ul);
339 vcpu_run(vcpu);
340 TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_INTERNAL_ERROR);
341
342 kvm_vm_free(vm);
343 }
344 #endif /* __x86_64__ */
345
test_invalid_memory_region_flags(void)346 static void test_invalid_memory_region_flags(void)
347 {
348 uint32_t supported_flags = KVM_MEM_LOG_DIRTY_PAGES;
349 const uint32_t v2_only_flags = KVM_MEM_GUEST_MEMFD;
350 struct kvm_vm *vm;
351 int r, i;
352
353 #if defined __aarch64__ || defined __riscv || defined __x86_64__
354 supported_flags |= KVM_MEM_READONLY;
355 #endif
356
357 #ifdef __x86_64__
358 if (kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(KVM_X86_SW_PROTECTED_VM))
359 vm = vm_create_barebones_type(KVM_X86_SW_PROTECTED_VM);
360 else
361 #endif
362 vm = vm_create_barebones();
363
364 if (kvm_check_cap(KVM_CAP_MEMORY_ATTRIBUTES) & KVM_MEMORY_ATTRIBUTE_PRIVATE)
365 supported_flags |= KVM_MEM_GUEST_MEMFD;
366
367 for (i = 0; i < 32; i++) {
368 if ((supported_flags & BIT(i)) && !(v2_only_flags & BIT(i)))
369 continue;
370
371 r = __vm_set_user_memory_region(vm, 0, BIT(i),
372 0, MEM_REGION_SIZE, NULL);
373
374 TEST_ASSERT(r && errno == EINVAL,
375 "KVM_SET_USER_MEMORY_REGION should have failed on v2 only flag 0x%lx", BIT(i));
376
377 if (supported_flags & BIT(i))
378 continue;
379
380 r = __vm_set_user_memory_region2(vm, 0, BIT(i),
381 0, MEM_REGION_SIZE, NULL, 0, 0);
382 TEST_ASSERT(r && errno == EINVAL,
383 "KVM_SET_USER_MEMORY_REGION2 should have failed on unsupported flag 0x%lx", BIT(i));
384 }
385
386 if (supported_flags & KVM_MEM_GUEST_MEMFD) {
387 int guest_memfd = vm_create_guest_memfd(vm, MEM_REGION_SIZE, 0);
388
389 r = __vm_set_user_memory_region2(vm, 0,
390 KVM_MEM_LOG_DIRTY_PAGES | KVM_MEM_GUEST_MEMFD,
391 0, MEM_REGION_SIZE, NULL, guest_memfd, 0);
392 TEST_ASSERT(r && errno == EINVAL,
393 "KVM_SET_USER_MEMORY_REGION2 should have failed, dirty logging private memory is unsupported");
394
395 r = __vm_set_user_memory_region2(vm, 0,
396 KVM_MEM_READONLY | KVM_MEM_GUEST_MEMFD,
397 0, MEM_REGION_SIZE, NULL, guest_memfd, 0);
398 TEST_ASSERT(r && errno == EINVAL,
399 "KVM_SET_USER_MEMORY_REGION2 should have failed, read-only GUEST_MEMFD memslots are unsupported");
400
401 close(guest_memfd);
402 }
403 }
404
405 /*
406 * Test it can be added memory slots up to KVM_CAP_NR_MEMSLOTS, then any
407 * tentative to add further slots should fail.
408 */
test_add_max_memory_regions(void)409 static void test_add_max_memory_regions(void)
410 {
411 int ret;
412 struct kvm_vm *vm;
413 uint32_t max_mem_slots;
414 uint32_t slot;
415 void *mem, *mem_aligned, *mem_extra;
416 size_t alignment;
417
418 #ifdef __s390x__
419 /* On s390x, the host address must be aligned to 1M (due to PGSTEs) */
420 alignment = 0x100000;
421 #else
422 alignment = 1;
423 #endif
424
425 max_mem_slots = kvm_check_cap(KVM_CAP_NR_MEMSLOTS);
426 TEST_ASSERT(max_mem_slots > 0,
427 "KVM_CAP_NR_MEMSLOTS should be greater than 0");
428 pr_info("Allowed number of memory slots: %i\n", max_mem_slots);
429
430 vm = vm_create_barebones();
431
432 /* Check it can be added memory slots up to the maximum allowed */
433 pr_info("Adding slots 0..%i, each memory region with %dK size\n",
434 (max_mem_slots - 1), MEM_REGION_SIZE >> 10);
435
436 mem = mmap(NULL, (size_t)max_mem_slots * MEM_REGION_SIZE + alignment,
437 PROT_READ | PROT_WRITE,
438 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
439 TEST_ASSERT(mem != MAP_FAILED, "Failed to mmap() host");
440 mem_aligned = (void *)(((size_t) mem + alignment - 1) & ~(alignment - 1));
441
442 for (slot = 0; slot < max_mem_slots; slot++)
443 vm_set_user_memory_region(vm, slot, 0,
444 ((uint64_t)slot * MEM_REGION_SIZE),
445 MEM_REGION_SIZE,
446 mem_aligned + (uint64_t)slot * MEM_REGION_SIZE);
447
448 /* Check it cannot be added memory slots beyond the limit */
449 mem_extra = mmap(NULL, MEM_REGION_SIZE, PROT_READ | PROT_WRITE,
450 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
451 TEST_ASSERT(mem_extra != MAP_FAILED, "Failed to mmap() host");
452
453 ret = __vm_set_user_memory_region(vm, max_mem_slots, 0,
454 (uint64_t)max_mem_slots * MEM_REGION_SIZE,
455 MEM_REGION_SIZE, mem_extra);
456 TEST_ASSERT(ret == -1 && errno == EINVAL,
457 "Adding one more memory slot should fail with EINVAL");
458
459 munmap(mem, (size_t)max_mem_slots * MEM_REGION_SIZE + alignment);
460 munmap(mem_extra, MEM_REGION_SIZE);
461 kvm_vm_free(vm);
462 }
463
464
465 #ifdef __x86_64__
test_invalid_guest_memfd(struct kvm_vm * vm,int memfd,size_t offset,const char * msg)466 static void test_invalid_guest_memfd(struct kvm_vm *vm, int memfd,
467 size_t offset, const char *msg)
468 {
469 int r = __vm_set_user_memory_region2(vm, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
470 MEM_REGION_GPA, MEM_REGION_SIZE,
471 0, memfd, offset);
472 TEST_ASSERT(r == -1 && errno == EINVAL, "%s", msg);
473 }
474
test_add_private_memory_region(void)475 static void test_add_private_memory_region(void)
476 {
477 struct kvm_vm *vm, *vm2;
478 int memfd, i;
479
480 pr_info("Testing ADD of KVM_MEM_GUEST_MEMFD memory regions\n");
481
482 vm = vm_create_barebones_type(KVM_X86_SW_PROTECTED_VM);
483
484 test_invalid_guest_memfd(vm, vm->kvm_fd, 0, "KVM fd should fail");
485 test_invalid_guest_memfd(vm, vm->fd, 0, "VM's fd should fail");
486
487 memfd = kvm_memfd_alloc(MEM_REGION_SIZE, false);
488 test_invalid_guest_memfd(vm, memfd, 0, "Regular memfd() should fail");
489 close(memfd);
490
491 vm2 = vm_create_barebones_type(KVM_X86_SW_PROTECTED_VM);
492 memfd = vm_create_guest_memfd(vm2, MEM_REGION_SIZE, 0);
493 test_invalid_guest_memfd(vm, memfd, 0, "Other VM's guest_memfd() should fail");
494
495 vm_set_user_memory_region2(vm2, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
496 MEM_REGION_GPA, MEM_REGION_SIZE, 0, memfd, 0);
497 close(memfd);
498 kvm_vm_free(vm2);
499
500 memfd = vm_create_guest_memfd(vm, MEM_REGION_SIZE, 0);
501 for (i = 1; i < PAGE_SIZE; i++)
502 test_invalid_guest_memfd(vm, memfd, i, "Unaligned offset should fail");
503
504 vm_set_user_memory_region2(vm, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
505 MEM_REGION_GPA, MEM_REGION_SIZE, 0, memfd, 0);
506 close(memfd);
507
508 kvm_vm_free(vm);
509 }
510
test_add_overlapping_private_memory_regions(void)511 static void test_add_overlapping_private_memory_regions(void)
512 {
513 struct kvm_vm *vm;
514 int memfd;
515 int r;
516
517 pr_info("Testing ADD of overlapping KVM_MEM_GUEST_MEMFD memory regions\n");
518
519 vm = vm_create_barebones_type(KVM_X86_SW_PROTECTED_VM);
520
521 memfd = vm_create_guest_memfd(vm, MEM_REGION_SIZE * 4, 0);
522
523 vm_set_user_memory_region2(vm, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
524 MEM_REGION_GPA, MEM_REGION_SIZE * 2, 0, memfd, 0);
525
526 vm_set_user_memory_region2(vm, MEM_REGION_SLOT + 1, KVM_MEM_GUEST_MEMFD,
527 MEM_REGION_GPA * 2, MEM_REGION_SIZE * 2,
528 0, memfd, MEM_REGION_SIZE * 2);
529
530 /*
531 * Delete the first memslot, and then attempt to recreate it except
532 * with a "bad" offset that results in overlap in the guest_memfd().
533 */
534 vm_set_user_memory_region2(vm, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
535 MEM_REGION_GPA, 0, NULL, -1, 0);
536
537 /* Overlap the front half of the other slot. */
538 r = __vm_set_user_memory_region2(vm, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
539 MEM_REGION_GPA * 2 - MEM_REGION_SIZE,
540 MEM_REGION_SIZE * 2,
541 0, memfd, 0);
542 TEST_ASSERT(r == -1 && errno == EEXIST, "%s",
543 "Overlapping guest_memfd() bindings should fail with EEXIST");
544
545 /* And now the back half of the other slot. */
546 r = __vm_set_user_memory_region2(vm, MEM_REGION_SLOT, KVM_MEM_GUEST_MEMFD,
547 MEM_REGION_GPA * 2 + MEM_REGION_SIZE,
548 MEM_REGION_SIZE * 2,
549 0, memfd, 0);
550 TEST_ASSERT(r == -1 && errno == EEXIST, "%s",
551 "Overlapping guest_memfd() bindings should fail with EEXIST");
552
553 close(memfd);
554 kvm_vm_free(vm);
555 }
556 #endif
557
main(int argc,char * argv[])558 int main(int argc, char *argv[])
559 {
560 #ifdef __x86_64__
561 int i, loops;
562 int j, disable_slot_zap_quirk = 0;
563
564 if (kvm_check_cap(KVM_CAP_DISABLE_QUIRKS2) & KVM_X86_QUIRK_SLOT_ZAP_ALL)
565 disable_slot_zap_quirk = 1;
566 /*
567 * FIXME: the zero-memslot test fails on aarch64 and s390x because
568 * KVM_RUN fails with ENOEXEC or EFAULT.
569 */
570 test_zero_memory_regions();
571 #endif
572
573 test_invalid_memory_region_flags();
574
575 test_add_max_memory_regions();
576
577 #ifdef __x86_64__
578 if (kvm_has_cap(KVM_CAP_GUEST_MEMFD) &&
579 (kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(KVM_X86_SW_PROTECTED_VM))) {
580 test_add_private_memory_region();
581 test_add_overlapping_private_memory_regions();
582 } else {
583 pr_info("Skipping tests for KVM_MEM_GUEST_MEMFD memory regions\n");
584 }
585
586 if (argc > 1)
587 loops = atoi_positive("Number of iterations", argv[1]);
588 else
589 loops = 10;
590
591 for (j = 0; j <= disable_slot_zap_quirk; j++) {
592 pr_info("Testing MOVE of in-use region, %d loops, slot zap quirk %s\n",
593 loops, j ? "disabled" : "enabled");
594 for (i = 0; i < loops; i++)
595 test_move_memory_region(!!j);
596
597 pr_info("Testing DELETE of in-use region, %d loops, slot zap quirk %s\n",
598 loops, j ? "disabled" : "enabled");
599 for (i = 0; i < loops; i++)
600 test_delete_memory_region(!!j);
601 }
602 #endif
603
604 return 0;
605 }
606