1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * page_fault_test.c - Test stage 2 faults. 4 * 5 * This test tries different combinations of guest accesses (e.g., write, 6 * S1PTW), backing source type (e.g., anon) and types of faults (e.g., read on 7 * hugetlbfs with a hole). It checks that the expected handling method is 8 * called (e.g., uffd faults with the right address and write/read flag). 9 */ 10 #define _GNU_SOURCE 11 #include <linux/bitmap.h> 12 #include <fcntl.h> 13 #include <test_util.h> 14 #include <kvm_util.h> 15 #include <processor.h> 16 #include <asm/sysreg.h> 17 #include <linux/bitfield.h> 18 #include "guest_modes.h" 19 #include "userfaultfd_util.h" 20 21 /* Guest virtual addresses that point to the test page and its PTE. */ 22 #define TEST_GVA 0xc0000000 23 #define TEST_EXEC_GVA (TEST_GVA + 0x8) 24 #define TEST_PTE_GVA 0xb0000000 25 #define TEST_DATA 0x0123456789ABCDEF 26 27 static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA; 28 29 #define CMD_NONE (0) 30 #define CMD_SKIP_TEST (1ULL << 1) 31 #define CMD_HOLE_PT (1ULL << 2) 32 #define CMD_HOLE_DATA (1ULL << 3) 33 #define CMD_CHECK_WRITE_IN_DIRTY_LOG (1ULL << 4) 34 #define CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG (1ULL << 5) 35 #define CMD_CHECK_NO_WRITE_IN_DIRTY_LOG (1ULL << 6) 36 #define CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG (1ULL << 7) 37 #define CMD_SET_PTE_AF (1ULL << 8) 38 39 #define PREPARE_FN_NR 10 40 #define CHECK_FN_NR 10 41 42 static struct event_cnt { 43 int mmio_exits; 44 int fail_vcpu_runs; 45 int uffd_faults; 46 /* uffd_faults is incremented from multiple threads. */ 47 pthread_mutex_t uffd_faults_mutex; 48 } events; 49 50 struct test_desc { 51 const char *name; 52 uint64_t mem_mark_cmd; 53 /* Skip the test if any prepare function returns false */ 54 bool (*guest_prepare[PREPARE_FN_NR])(void); 55 void (*guest_test)(void); 56 void (*guest_test_check[CHECK_FN_NR])(void); 57 uffd_handler_t uffd_pt_handler; 58 uffd_handler_t uffd_data_handler; 59 void (*dabt_handler)(struct ex_regs *regs); 60 void (*iabt_handler)(struct ex_regs *regs); 61 void (*mmio_handler)(struct kvm_vm *vm, struct kvm_run *run); 62 void (*fail_vcpu_run_handler)(int ret); 63 uint32_t pt_memslot_flags; 64 uint32_t data_memslot_flags; 65 bool skip; 66 struct event_cnt expected_events; 67 }; 68 69 struct test_params { 70 enum vm_mem_backing_src_type src_type; 71 struct test_desc *test_desc; 72 }; 73 74 static inline void flush_tlb_page(uint64_t vaddr) 75 { 76 uint64_t page = vaddr >> 12; 77 78 dsb(ishst); 79 asm volatile("tlbi vaae1is, %0" :: "r" (page)); 80 dsb(ish); 81 isb(); 82 } 83 84 static void guest_write64(void) 85 { 86 uint64_t val; 87 88 WRITE_ONCE(*guest_test_memory, TEST_DATA); 89 val = READ_ONCE(*guest_test_memory); 90 GUEST_ASSERT_EQ(val, TEST_DATA); 91 } 92 93 /* Check the system for atomic instructions. */ 94 static bool guest_check_lse(void) 95 { 96 uint64_t isar0 = read_sysreg(id_aa64isar0_el1); 97 uint64_t atomic; 98 99 atomic = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64ISAR0_ATOMICS), isar0); 100 return atomic >= 2; 101 } 102 103 static bool guest_check_dc_zva(void) 104 { 105 uint64_t dczid = read_sysreg(dczid_el0); 106 uint64_t dzp = FIELD_GET(ARM64_FEATURE_MASK(DCZID_DZP), dczid); 107 108 return dzp == 0; 109 } 110 111 /* Compare and swap instruction. */ 112 static void guest_cas(void) 113 { 114 uint64_t val; 115 116 GUEST_ASSERT(guest_check_lse()); 117 asm volatile(".arch_extension lse\n" 118 "casal %0, %1, [%2]\n" 119 :: "r" (0ul), "r" (TEST_DATA), "r" (guest_test_memory)); 120 val = READ_ONCE(*guest_test_memory); 121 GUEST_ASSERT_EQ(val, TEST_DATA); 122 } 123 124 static void guest_read64(void) 125 { 126 uint64_t val; 127 128 val = READ_ONCE(*guest_test_memory); 129 GUEST_ASSERT_EQ(val, 0); 130 } 131 132 /* Address translation instruction */ 133 static void guest_at(void) 134 { 135 uint64_t par; 136 137 asm volatile("at s1e1r, %0" :: "r" (guest_test_memory)); 138 par = read_sysreg(par_el1); 139 isb(); 140 141 /* Bit 1 indicates whether the AT was successful */ 142 GUEST_ASSERT_EQ(par & 1, 0); 143 } 144 145 /* 146 * The size of the block written by "dc zva" is guaranteed to be between (2 << 147 * 0) and (2 << 9), which is safe in our case as we need the write to happen 148 * for at least a word, and not more than a page. 149 */ 150 static void guest_dc_zva(void) 151 { 152 uint16_t val; 153 154 asm volatile("dc zva, %0" :: "r" (guest_test_memory)); 155 dsb(ish); 156 val = READ_ONCE(*guest_test_memory); 157 GUEST_ASSERT_EQ(val, 0); 158 } 159 160 /* 161 * Pre-indexing loads and stores don't have a valid syndrome (ESR_EL2.ISV==0). 162 * And that's special because KVM must take special care with those: they 163 * should still count as accesses for dirty logging or user-faulting, but 164 * should be handled differently on mmio. 165 */ 166 static void guest_ld_preidx(void) 167 { 168 uint64_t val; 169 uint64_t addr = TEST_GVA - 8; 170 171 /* 172 * This ends up accessing "TEST_GVA + 8 - 8", where "TEST_GVA - 8" is 173 * in a gap between memslots not backing by anything. 174 */ 175 asm volatile("ldr %0, [%1, #8]!" 176 : "=r" (val), "+r" (addr)); 177 GUEST_ASSERT_EQ(val, 0); 178 GUEST_ASSERT_EQ(addr, TEST_GVA); 179 } 180 181 static void guest_st_preidx(void) 182 { 183 uint64_t val = TEST_DATA; 184 uint64_t addr = TEST_GVA - 8; 185 186 asm volatile("str %0, [%1, #8]!" 187 : "+r" (val), "+r" (addr)); 188 189 GUEST_ASSERT_EQ(addr, TEST_GVA); 190 val = READ_ONCE(*guest_test_memory); 191 } 192 193 static bool guest_set_ha(void) 194 { 195 uint64_t mmfr1 = read_sysreg(id_aa64mmfr1_el1); 196 uint64_t hadbs, tcr; 197 198 /* Skip if HA is not supported. */ 199 hadbs = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64MMFR1_HADBS), mmfr1); 200 if (hadbs == 0) 201 return false; 202 203 tcr = read_sysreg(tcr_el1) | TCR_EL1_HA; 204 write_sysreg(tcr, tcr_el1); 205 isb(); 206 207 return true; 208 } 209 210 static bool guest_clear_pte_af(void) 211 { 212 *((uint64_t *)TEST_PTE_GVA) &= ~PTE_AF; 213 flush_tlb_page(TEST_GVA); 214 215 return true; 216 } 217 218 static void guest_check_pte_af(void) 219 { 220 dsb(ish); 221 GUEST_ASSERT_EQ(*((uint64_t *)TEST_PTE_GVA) & PTE_AF, PTE_AF); 222 } 223 224 static void guest_check_write_in_dirty_log(void) 225 { 226 GUEST_SYNC(CMD_CHECK_WRITE_IN_DIRTY_LOG); 227 } 228 229 static void guest_check_no_write_in_dirty_log(void) 230 { 231 GUEST_SYNC(CMD_CHECK_NO_WRITE_IN_DIRTY_LOG); 232 } 233 234 static void guest_check_s1ptw_wr_in_dirty_log(void) 235 { 236 GUEST_SYNC(CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG); 237 } 238 239 static void guest_check_no_s1ptw_wr_in_dirty_log(void) 240 { 241 GUEST_SYNC(CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG); 242 } 243 244 static void guest_exec(void) 245 { 246 int (*code)(void) = (int (*)(void))TEST_EXEC_GVA; 247 int ret; 248 249 ret = code(); 250 GUEST_ASSERT_EQ(ret, 0x77); 251 } 252 253 static bool guest_prepare(struct test_desc *test) 254 { 255 bool (*prepare_fn)(void); 256 int i; 257 258 for (i = 0; i < PREPARE_FN_NR; i++) { 259 prepare_fn = test->guest_prepare[i]; 260 if (prepare_fn && !prepare_fn()) 261 return false; 262 } 263 264 return true; 265 } 266 267 static void guest_test_check(struct test_desc *test) 268 { 269 void (*check_fn)(void); 270 int i; 271 272 for (i = 0; i < CHECK_FN_NR; i++) { 273 check_fn = test->guest_test_check[i]; 274 if (check_fn) 275 check_fn(); 276 } 277 } 278 279 static void guest_code(struct test_desc *test) 280 { 281 if (!guest_prepare(test)) 282 GUEST_SYNC(CMD_SKIP_TEST); 283 284 GUEST_SYNC(test->mem_mark_cmd); 285 286 if (test->guest_test) 287 test->guest_test(); 288 289 guest_test_check(test); 290 GUEST_DONE(); 291 } 292 293 static void no_dabt_handler(struct ex_regs *regs) 294 { 295 GUEST_FAIL("Unexpected dabt, far_el1 = 0x%llx", read_sysreg(far_el1)); 296 } 297 298 static void no_iabt_handler(struct ex_regs *regs) 299 { 300 GUEST_FAIL("Unexpected iabt, pc = 0x%lx", regs->pc); 301 } 302 303 static struct uffd_args { 304 char *copy; 305 void *hva; 306 uint64_t paging_size; 307 } pt_args, data_args; 308 309 /* Returns true to continue the test, and false if it should be skipped. */ 310 static int uffd_generic_handler(int uffd_mode, int uffd, struct uffd_msg *msg, 311 struct uffd_args *args) 312 { 313 uint64_t addr = msg->arg.pagefault.address; 314 uint64_t flags = msg->arg.pagefault.flags; 315 struct uffdio_copy copy; 316 int ret; 317 318 TEST_ASSERT(uffd_mode == UFFDIO_REGISTER_MODE_MISSING, 319 "The only expected UFFD mode is MISSING"); 320 TEST_ASSERT_EQ(addr, (uint64_t)args->hva); 321 322 pr_debug("uffd fault: addr=%p write=%d\n", 323 (void *)addr, !!(flags & UFFD_PAGEFAULT_FLAG_WRITE)); 324 325 copy.src = (uint64_t)args->copy; 326 copy.dst = addr; 327 copy.len = args->paging_size; 328 copy.mode = 0; 329 330 ret = ioctl(uffd, UFFDIO_COPY, ©); 331 if (ret == -1) { 332 pr_info("Failed UFFDIO_COPY in 0x%lx with errno: %d\n", 333 addr, errno); 334 return ret; 335 } 336 337 pthread_mutex_lock(&events.uffd_faults_mutex); 338 events.uffd_faults += 1; 339 pthread_mutex_unlock(&events.uffd_faults_mutex); 340 return 0; 341 } 342 343 static int uffd_pt_handler(int mode, int uffd, struct uffd_msg *msg) 344 { 345 return uffd_generic_handler(mode, uffd, msg, &pt_args); 346 } 347 348 static int uffd_data_handler(int mode, int uffd, struct uffd_msg *msg) 349 { 350 return uffd_generic_handler(mode, uffd, msg, &data_args); 351 } 352 353 static void setup_uffd_args(struct userspace_mem_region *region, 354 struct uffd_args *args) 355 { 356 args->hva = (void *)region->region.userspace_addr; 357 args->paging_size = region->region.memory_size; 358 359 args->copy = malloc(args->paging_size); 360 TEST_ASSERT(args->copy, "Failed to allocate data copy."); 361 memcpy(args->copy, args->hva, args->paging_size); 362 } 363 364 static void setup_uffd(struct kvm_vm *vm, struct test_params *p, 365 struct uffd_desc **pt_uffd, struct uffd_desc **data_uffd) 366 { 367 struct test_desc *test = p->test_desc; 368 int uffd_mode = UFFDIO_REGISTER_MODE_MISSING; 369 370 setup_uffd_args(vm_get_mem_region(vm, MEM_REGION_PT), &pt_args); 371 setup_uffd_args(vm_get_mem_region(vm, MEM_REGION_TEST_DATA), &data_args); 372 373 *pt_uffd = NULL; 374 if (test->uffd_pt_handler) 375 *pt_uffd = uffd_setup_demand_paging(uffd_mode, 0, 376 pt_args.hva, 377 pt_args.paging_size, 378 test->uffd_pt_handler); 379 380 *data_uffd = NULL; 381 if (test->uffd_data_handler) 382 *data_uffd = uffd_setup_demand_paging(uffd_mode, 0, 383 data_args.hva, 384 data_args.paging_size, 385 test->uffd_data_handler); 386 } 387 388 static void free_uffd(struct test_desc *test, struct uffd_desc *pt_uffd, 389 struct uffd_desc *data_uffd) 390 { 391 if (test->uffd_pt_handler) 392 uffd_stop_demand_paging(pt_uffd); 393 if (test->uffd_data_handler) 394 uffd_stop_demand_paging(data_uffd); 395 396 free(pt_args.copy); 397 free(data_args.copy); 398 } 399 400 static int uffd_no_handler(int mode, int uffd, struct uffd_msg *msg) 401 { 402 TEST_FAIL("There was no UFFD fault expected."); 403 return -1; 404 } 405 406 /* Returns false if the test should be skipped. */ 407 static bool punch_hole_in_backing_store(struct kvm_vm *vm, 408 struct userspace_mem_region *region) 409 { 410 void *hva = (void *)region->region.userspace_addr; 411 uint64_t paging_size = region->region.memory_size; 412 int ret, fd = region->fd; 413 414 if (fd != -1) { 415 ret = fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 416 0, paging_size); 417 TEST_ASSERT(ret == 0, "fallocate failed\n"); 418 } else { 419 ret = madvise(hva, paging_size, MADV_DONTNEED); 420 TEST_ASSERT(ret == 0, "madvise failed\n"); 421 } 422 423 return true; 424 } 425 426 static void mmio_on_test_gpa_handler(struct kvm_vm *vm, struct kvm_run *run) 427 { 428 struct userspace_mem_region *region; 429 void *hva; 430 431 region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); 432 hva = (void *)region->region.userspace_addr; 433 434 TEST_ASSERT_EQ(run->mmio.phys_addr, region->region.guest_phys_addr); 435 436 memcpy(hva, run->mmio.data, run->mmio.len); 437 events.mmio_exits += 1; 438 } 439 440 static void mmio_no_handler(struct kvm_vm *vm, struct kvm_run *run) 441 { 442 uint64_t data; 443 444 memcpy(&data, run->mmio.data, sizeof(data)); 445 pr_debug("addr=%lld len=%d w=%d data=%lx\n", 446 run->mmio.phys_addr, run->mmio.len, 447 run->mmio.is_write, data); 448 TEST_FAIL("There was no MMIO exit expected."); 449 } 450 451 static bool check_write_in_dirty_log(struct kvm_vm *vm, 452 struct userspace_mem_region *region, 453 uint64_t host_pg_nr) 454 { 455 unsigned long *bmap; 456 bool first_page_dirty; 457 uint64_t size = region->region.memory_size; 458 459 /* getpage_size() is not always equal to vm->page_size */ 460 bmap = bitmap_zalloc(size / getpagesize()); 461 kvm_vm_get_dirty_log(vm, region->region.slot, bmap); 462 first_page_dirty = test_bit(host_pg_nr, bmap); 463 free(bmap); 464 return first_page_dirty; 465 } 466 467 /* Returns true to continue the test, and false if it should be skipped. */ 468 static bool handle_cmd(struct kvm_vm *vm, int cmd) 469 { 470 struct userspace_mem_region *data_region, *pt_region; 471 bool continue_test = true; 472 uint64_t pte_gpa, pte_pg; 473 474 data_region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); 475 pt_region = vm_get_mem_region(vm, MEM_REGION_PT); 476 pte_gpa = addr_hva2gpa(vm, virt_get_pte_hva(vm, TEST_GVA)); 477 pte_pg = (pte_gpa - pt_region->region.guest_phys_addr) / getpagesize(); 478 479 if (cmd == CMD_SKIP_TEST) 480 continue_test = false; 481 482 if (cmd & CMD_HOLE_PT) 483 continue_test = punch_hole_in_backing_store(vm, pt_region); 484 if (cmd & CMD_HOLE_DATA) 485 continue_test = punch_hole_in_backing_store(vm, data_region); 486 if (cmd & CMD_CHECK_WRITE_IN_DIRTY_LOG) 487 TEST_ASSERT(check_write_in_dirty_log(vm, data_region, 0), 488 "Missing write in dirty log"); 489 if (cmd & CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG) 490 TEST_ASSERT(check_write_in_dirty_log(vm, pt_region, pte_pg), 491 "Missing s1ptw write in dirty log"); 492 if (cmd & CMD_CHECK_NO_WRITE_IN_DIRTY_LOG) 493 TEST_ASSERT(!check_write_in_dirty_log(vm, data_region, 0), 494 "Unexpected write in dirty log"); 495 if (cmd & CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG) 496 TEST_ASSERT(!check_write_in_dirty_log(vm, pt_region, pte_pg), 497 "Unexpected s1ptw write in dirty log"); 498 499 return continue_test; 500 } 501 502 void fail_vcpu_run_no_handler(int ret) 503 { 504 TEST_FAIL("Unexpected vcpu run failure\n"); 505 } 506 507 void fail_vcpu_run_mmio_no_syndrome_handler(int ret) 508 { 509 TEST_ASSERT(errno == ENOSYS, 510 "The mmio handler should have returned not implemented."); 511 events.fail_vcpu_runs += 1; 512 } 513 514 typedef uint32_t aarch64_insn_t; 515 extern aarch64_insn_t __exec_test[2]; 516 517 noinline void __return_0x77(void) 518 { 519 asm volatile("__exec_test: mov x0, #0x77\n" 520 "ret\n"); 521 } 522 523 /* 524 * Note that this function runs on the host before the test VM starts: there's 525 * no need to sync the D$ and I$ caches. 526 */ 527 static void load_exec_code_for_test(struct kvm_vm *vm) 528 { 529 uint64_t *code; 530 struct userspace_mem_region *region; 531 void *hva; 532 533 region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); 534 hva = (void *)region->region.userspace_addr; 535 536 assert(TEST_EXEC_GVA > TEST_GVA); 537 code = hva + TEST_EXEC_GVA - TEST_GVA; 538 memcpy(code, __exec_test, sizeof(__exec_test)); 539 } 540 541 static void setup_abort_handlers(struct kvm_vm *vm, struct kvm_vcpu *vcpu, 542 struct test_desc *test) 543 { 544 vm_init_descriptor_tables(vm); 545 vcpu_init_descriptor_tables(vcpu); 546 547 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 548 ESR_EC_DABT, no_dabt_handler); 549 vm_install_sync_handler(vm, VECTOR_SYNC_CURRENT, 550 ESR_EC_IABT, no_iabt_handler); 551 } 552 553 static void setup_gva_maps(struct kvm_vm *vm) 554 { 555 struct userspace_mem_region *region; 556 uint64_t pte_gpa; 557 558 region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); 559 /* Map TEST_GVA first. This will install a new PTE. */ 560 virt_pg_map(vm, TEST_GVA, region->region.guest_phys_addr); 561 /* Then map TEST_PTE_GVA to the above PTE. */ 562 pte_gpa = addr_hva2gpa(vm, virt_get_pte_hva(vm, TEST_GVA)); 563 virt_pg_map(vm, TEST_PTE_GVA, pte_gpa); 564 } 565 566 enum pf_test_memslots { 567 CODE_AND_DATA_MEMSLOT, 568 PAGE_TABLE_MEMSLOT, 569 TEST_DATA_MEMSLOT, 570 }; 571 572 /* 573 * Create a memslot for code and data at pfn=0, and test-data and PT ones 574 * at max_gfn. 575 */ 576 static void setup_memslots(struct kvm_vm *vm, struct test_params *p) 577 { 578 uint64_t backing_src_pagesz = get_backing_src_pagesz(p->src_type); 579 uint64_t guest_page_size = vm->page_size; 580 uint64_t max_gfn = vm_compute_max_gfn(vm); 581 /* Enough for 2M of code when using 4K guest pages. */ 582 uint64_t code_npages = 512; 583 uint64_t pt_size, data_size, data_gpa; 584 585 /* 586 * This test requires 1 pgd, 2 pud, 4 pmd, and 6 pte pages when using 587 * VM_MODE_P48V48_4K. Note that the .text takes ~1.6MBs. That's 13 588 * pages. VM_MODE_P48V48_4K is the mode with most PT pages; let's use 589 * twice that just in case. 590 */ 591 pt_size = 26 * guest_page_size; 592 593 /* memslot sizes and gpa's must be aligned to the backing page size */ 594 pt_size = align_up(pt_size, backing_src_pagesz); 595 data_size = align_up(guest_page_size, backing_src_pagesz); 596 data_gpa = (max_gfn * guest_page_size) - data_size; 597 data_gpa = align_down(data_gpa, backing_src_pagesz); 598 599 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, 0, 600 CODE_AND_DATA_MEMSLOT, code_npages, 0); 601 vm->memslots[MEM_REGION_CODE] = CODE_AND_DATA_MEMSLOT; 602 vm->memslots[MEM_REGION_DATA] = CODE_AND_DATA_MEMSLOT; 603 604 vm_userspace_mem_region_add(vm, p->src_type, data_gpa - pt_size, 605 PAGE_TABLE_MEMSLOT, pt_size / guest_page_size, 606 p->test_desc->pt_memslot_flags); 607 vm->memslots[MEM_REGION_PT] = PAGE_TABLE_MEMSLOT; 608 609 vm_userspace_mem_region_add(vm, p->src_type, data_gpa, TEST_DATA_MEMSLOT, 610 data_size / guest_page_size, 611 p->test_desc->data_memslot_flags); 612 vm->memslots[MEM_REGION_TEST_DATA] = TEST_DATA_MEMSLOT; 613 } 614 615 static void setup_ucall(struct kvm_vm *vm) 616 { 617 struct userspace_mem_region *region = vm_get_mem_region(vm, MEM_REGION_TEST_DATA); 618 619 ucall_init(vm, region->region.guest_phys_addr + region->region.memory_size); 620 } 621 622 static void setup_default_handlers(struct test_desc *test) 623 { 624 if (!test->mmio_handler) 625 test->mmio_handler = mmio_no_handler; 626 627 if (!test->fail_vcpu_run_handler) 628 test->fail_vcpu_run_handler = fail_vcpu_run_no_handler; 629 } 630 631 static void check_event_counts(struct test_desc *test) 632 { 633 TEST_ASSERT_EQ(test->expected_events.uffd_faults, events.uffd_faults); 634 TEST_ASSERT_EQ(test->expected_events.mmio_exits, events.mmio_exits); 635 TEST_ASSERT_EQ(test->expected_events.fail_vcpu_runs, events.fail_vcpu_runs); 636 } 637 638 static void print_test_banner(enum vm_guest_mode mode, struct test_params *p) 639 { 640 struct test_desc *test = p->test_desc; 641 642 pr_debug("Test: %s\n", test->name); 643 pr_debug("Testing guest mode: %s\n", vm_guest_mode_string(mode)); 644 pr_debug("Testing memory backing src type: %s\n", 645 vm_mem_backing_src_alias(p->src_type)->name); 646 } 647 648 static void reset_event_counts(void) 649 { 650 memset(&events, 0, sizeof(events)); 651 } 652 653 /* 654 * This function either succeeds, skips the test (after setting test->skip), or 655 * fails with a TEST_FAIL that aborts all tests. 656 */ 657 static void vcpu_run_loop(struct kvm_vm *vm, struct kvm_vcpu *vcpu, 658 struct test_desc *test) 659 { 660 struct kvm_run *run; 661 struct ucall uc; 662 int ret; 663 664 run = vcpu->run; 665 666 for (;;) { 667 ret = _vcpu_run(vcpu); 668 if (ret) { 669 test->fail_vcpu_run_handler(ret); 670 goto done; 671 } 672 673 switch (get_ucall(vcpu, &uc)) { 674 case UCALL_SYNC: 675 if (!handle_cmd(vm, uc.args[1])) { 676 test->skip = true; 677 goto done; 678 } 679 break; 680 case UCALL_ABORT: 681 REPORT_GUEST_ASSERT(uc); 682 break; 683 case UCALL_DONE: 684 goto done; 685 case UCALL_NONE: 686 if (run->exit_reason == KVM_EXIT_MMIO) 687 test->mmio_handler(vm, run); 688 break; 689 default: 690 TEST_FAIL("Unknown ucall %lu", uc.cmd); 691 } 692 } 693 694 done: 695 pr_debug(test->skip ? "Skipped.\n" : "Done.\n"); 696 } 697 698 static void run_test(enum vm_guest_mode mode, void *arg) 699 { 700 struct test_params *p = (struct test_params *)arg; 701 struct test_desc *test = p->test_desc; 702 struct kvm_vm *vm; 703 struct kvm_vcpu *vcpu; 704 struct uffd_desc *pt_uffd, *data_uffd; 705 706 print_test_banner(mode, p); 707 708 vm = ____vm_create(mode); 709 setup_memslots(vm, p); 710 kvm_vm_elf_load(vm, program_invocation_name); 711 setup_ucall(vm); 712 vcpu = vm_vcpu_add(vm, 0, guest_code); 713 714 setup_gva_maps(vm); 715 716 reset_event_counts(); 717 718 /* 719 * Set some code in the data memslot for the guest to execute (only 720 * applicable to the EXEC tests). This has to be done before 721 * setup_uffd() as that function copies the memslot data for the uffd 722 * handler. 723 */ 724 load_exec_code_for_test(vm); 725 setup_uffd(vm, p, &pt_uffd, &data_uffd); 726 setup_abort_handlers(vm, vcpu, test); 727 setup_default_handlers(test); 728 vcpu_args_set(vcpu, 1, test); 729 730 vcpu_run_loop(vm, vcpu, test); 731 732 kvm_vm_free(vm); 733 free_uffd(test, pt_uffd, data_uffd); 734 735 /* 736 * Make sure we check the events after the uffd threads have exited, 737 * which means they updated their respective event counters. 738 */ 739 if (!test->skip) 740 check_event_counts(test); 741 } 742 743 static void help(char *name) 744 { 745 puts(""); 746 printf("usage: %s [-h] [-s mem-type]\n", name); 747 puts(""); 748 guest_modes_help(); 749 backing_src_help("-s"); 750 puts(""); 751 } 752 753 #define SNAME(s) #s 754 #define SCAT2(a, b) SNAME(a ## _ ## b) 755 #define SCAT3(a, b, c) SCAT2(a, SCAT2(b, c)) 756 #define SCAT4(a, b, c, d) SCAT2(a, SCAT3(b, c, d)) 757 758 #define _CHECK(_test) _CHECK_##_test 759 #define _PREPARE(_test) _PREPARE_##_test 760 #define _PREPARE_guest_read64 NULL 761 #define _PREPARE_guest_ld_preidx NULL 762 #define _PREPARE_guest_write64 NULL 763 #define _PREPARE_guest_st_preidx NULL 764 #define _PREPARE_guest_exec NULL 765 #define _PREPARE_guest_at NULL 766 #define _PREPARE_guest_dc_zva guest_check_dc_zva 767 #define _PREPARE_guest_cas guest_check_lse 768 769 /* With or without access flag checks */ 770 #define _PREPARE_with_af guest_set_ha, guest_clear_pte_af 771 #define _PREPARE_no_af NULL 772 #define _CHECK_with_af guest_check_pte_af 773 #define _CHECK_no_af NULL 774 775 /* Performs an access and checks that no faults were triggered. */ 776 #define TEST_ACCESS(_access, _with_af, _mark_cmd) \ 777 { \ 778 .name = SCAT3(_access, _with_af, #_mark_cmd), \ 779 .guest_prepare = { _PREPARE(_with_af), \ 780 _PREPARE(_access) }, \ 781 .mem_mark_cmd = _mark_cmd, \ 782 .guest_test = _access, \ 783 .guest_test_check = { _CHECK(_with_af) }, \ 784 .expected_events = { 0 }, \ 785 } 786 787 #define TEST_UFFD(_access, _with_af, _mark_cmd, \ 788 _uffd_data_handler, _uffd_pt_handler, _uffd_faults) \ 789 { \ 790 .name = SCAT4(uffd, _access, _with_af, #_mark_cmd), \ 791 .guest_prepare = { _PREPARE(_with_af), \ 792 _PREPARE(_access) }, \ 793 .guest_test = _access, \ 794 .mem_mark_cmd = _mark_cmd, \ 795 .guest_test_check = { _CHECK(_with_af) }, \ 796 .uffd_data_handler = _uffd_data_handler, \ 797 .uffd_pt_handler = _uffd_pt_handler, \ 798 .expected_events = { .uffd_faults = _uffd_faults, }, \ 799 } 800 801 #define TEST_DIRTY_LOG(_access, _with_af, _test_check, _pt_check) \ 802 { \ 803 .name = SCAT3(dirty_log, _access, _with_af), \ 804 .data_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ 805 .pt_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ 806 .guest_prepare = { _PREPARE(_with_af), \ 807 _PREPARE(_access) }, \ 808 .guest_test = _access, \ 809 .guest_test_check = { _CHECK(_with_af), _test_check, _pt_check }, \ 810 .expected_events = { 0 }, \ 811 } 812 813 #define TEST_UFFD_AND_DIRTY_LOG(_access, _with_af, _uffd_data_handler, \ 814 _uffd_faults, _test_check, _pt_check) \ 815 { \ 816 .name = SCAT3(uffd_and_dirty_log, _access, _with_af), \ 817 .data_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ 818 .pt_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ 819 .guest_prepare = { _PREPARE(_with_af), \ 820 _PREPARE(_access) }, \ 821 .guest_test = _access, \ 822 .mem_mark_cmd = CMD_HOLE_DATA | CMD_HOLE_PT, \ 823 .guest_test_check = { _CHECK(_with_af), _test_check, _pt_check }, \ 824 .uffd_data_handler = _uffd_data_handler, \ 825 .uffd_pt_handler = uffd_pt_handler, \ 826 .expected_events = { .uffd_faults = _uffd_faults, }, \ 827 } 828 829 #define TEST_RO_MEMSLOT(_access, _mmio_handler, _mmio_exits) \ 830 { \ 831 .name = SCAT2(ro_memslot, _access), \ 832 .data_memslot_flags = KVM_MEM_READONLY, \ 833 .pt_memslot_flags = KVM_MEM_READONLY, \ 834 .guest_prepare = { _PREPARE(_access) }, \ 835 .guest_test = _access, \ 836 .mmio_handler = _mmio_handler, \ 837 .expected_events = { .mmio_exits = _mmio_exits }, \ 838 } 839 840 #define TEST_RO_MEMSLOT_NO_SYNDROME(_access) \ 841 { \ 842 .name = SCAT2(ro_memslot_no_syndrome, _access), \ 843 .data_memslot_flags = KVM_MEM_READONLY, \ 844 .pt_memslot_flags = KVM_MEM_READONLY, \ 845 .guest_test = _access, \ 846 .fail_vcpu_run_handler = fail_vcpu_run_mmio_no_syndrome_handler, \ 847 .expected_events = { .fail_vcpu_runs = 1 }, \ 848 } 849 850 #define TEST_RO_MEMSLOT_AND_DIRTY_LOG(_access, _mmio_handler, _mmio_exits, \ 851 _test_check) \ 852 { \ 853 .name = SCAT2(ro_memslot, _access), \ 854 .data_memslot_flags = KVM_MEM_READONLY | KVM_MEM_LOG_DIRTY_PAGES, \ 855 .pt_memslot_flags = KVM_MEM_READONLY | KVM_MEM_LOG_DIRTY_PAGES, \ 856 .guest_prepare = { _PREPARE(_access) }, \ 857 .guest_test = _access, \ 858 .guest_test_check = { _test_check }, \ 859 .mmio_handler = _mmio_handler, \ 860 .expected_events = { .mmio_exits = _mmio_exits}, \ 861 } 862 863 #define TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG(_access, _test_check) \ 864 { \ 865 .name = SCAT2(ro_memslot_no_syn_and_dlog, _access), \ 866 .data_memslot_flags = KVM_MEM_READONLY | KVM_MEM_LOG_DIRTY_PAGES, \ 867 .pt_memslot_flags = KVM_MEM_READONLY | KVM_MEM_LOG_DIRTY_PAGES, \ 868 .guest_test = _access, \ 869 .guest_test_check = { _test_check }, \ 870 .fail_vcpu_run_handler = fail_vcpu_run_mmio_no_syndrome_handler, \ 871 .expected_events = { .fail_vcpu_runs = 1 }, \ 872 } 873 874 #define TEST_RO_MEMSLOT_AND_UFFD(_access, _mmio_handler, _mmio_exits, \ 875 _uffd_data_handler, _uffd_faults) \ 876 { \ 877 .name = SCAT2(ro_memslot_uffd, _access), \ 878 .data_memslot_flags = KVM_MEM_READONLY, \ 879 .pt_memslot_flags = KVM_MEM_READONLY, \ 880 .mem_mark_cmd = CMD_HOLE_DATA | CMD_HOLE_PT, \ 881 .guest_prepare = { _PREPARE(_access) }, \ 882 .guest_test = _access, \ 883 .uffd_data_handler = _uffd_data_handler, \ 884 .uffd_pt_handler = uffd_pt_handler, \ 885 .mmio_handler = _mmio_handler, \ 886 .expected_events = { .mmio_exits = _mmio_exits, \ 887 .uffd_faults = _uffd_faults }, \ 888 } 889 890 #define TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD(_access, _uffd_data_handler, \ 891 _uffd_faults) \ 892 { \ 893 .name = SCAT2(ro_memslot_no_syndrome, _access), \ 894 .data_memslot_flags = KVM_MEM_READONLY, \ 895 .pt_memslot_flags = KVM_MEM_READONLY, \ 896 .mem_mark_cmd = CMD_HOLE_DATA | CMD_HOLE_PT, \ 897 .guest_test = _access, \ 898 .uffd_data_handler = _uffd_data_handler, \ 899 .uffd_pt_handler = uffd_pt_handler, \ 900 .fail_vcpu_run_handler = fail_vcpu_run_mmio_no_syndrome_handler, \ 901 .expected_events = { .fail_vcpu_runs = 1, \ 902 .uffd_faults = _uffd_faults }, \ 903 } 904 905 static struct test_desc tests[] = { 906 907 /* Check that HW is setting the Access Flag (AF) (sanity checks). */ 908 TEST_ACCESS(guest_read64, with_af, CMD_NONE), 909 TEST_ACCESS(guest_ld_preidx, with_af, CMD_NONE), 910 TEST_ACCESS(guest_cas, with_af, CMD_NONE), 911 TEST_ACCESS(guest_write64, with_af, CMD_NONE), 912 TEST_ACCESS(guest_st_preidx, with_af, CMD_NONE), 913 TEST_ACCESS(guest_dc_zva, with_af, CMD_NONE), 914 TEST_ACCESS(guest_exec, with_af, CMD_NONE), 915 916 /* 917 * Punch a hole in the data backing store, and then try multiple 918 * accesses: reads should rturn zeroes, and writes should 919 * re-populate the page. Moreover, the test also check that no 920 * exception was generated in the guest. Note that this 921 * reading/writing behavior is the same as reading/writing a 922 * punched page (with fallocate(FALLOC_FL_PUNCH_HOLE)) from 923 * userspace. 924 */ 925 TEST_ACCESS(guest_read64, no_af, CMD_HOLE_DATA), 926 TEST_ACCESS(guest_cas, no_af, CMD_HOLE_DATA), 927 TEST_ACCESS(guest_ld_preidx, no_af, CMD_HOLE_DATA), 928 TEST_ACCESS(guest_write64, no_af, CMD_HOLE_DATA), 929 TEST_ACCESS(guest_st_preidx, no_af, CMD_HOLE_DATA), 930 TEST_ACCESS(guest_at, no_af, CMD_HOLE_DATA), 931 TEST_ACCESS(guest_dc_zva, no_af, CMD_HOLE_DATA), 932 933 /* 934 * Punch holes in the data and PT backing stores and mark them for 935 * userfaultfd handling. This should result in 2 faults: the access 936 * on the data backing store, and its respective S1 page table walk 937 * (S1PTW). 938 */ 939 TEST_UFFD(guest_read64, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 940 uffd_data_handler, uffd_pt_handler, 2), 941 TEST_UFFD(guest_read64, no_af, CMD_HOLE_DATA | CMD_HOLE_PT, 942 uffd_data_handler, uffd_pt_handler, 2), 943 TEST_UFFD(guest_cas, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 944 uffd_data_handler, uffd_pt_handler, 2), 945 /* 946 * Can't test guest_at with_af as it's IMPDEF whether the AF is set. 947 * The S1PTW fault should still be marked as a write. 948 */ 949 TEST_UFFD(guest_at, no_af, CMD_HOLE_DATA | CMD_HOLE_PT, 950 uffd_no_handler, uffd_pt_handler, 1), 951 TEST_UFFD(guest_ld_preidx, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 952 uffd_data_handler, uffd_pt_handler, 2), 953 TEST_UFFD(guest_write64, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 954 uffd_data_handler, uffd_pt_handler, 2), 955 TEST_UFFD(guest_dc_zva, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 956 uffd_data_handler, uffd_pt_handler, 2), 957 TEST_UFFD(guest_st_preidx, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 958 uffd_data_handler, uffd_pt_handler, 2), 959 TEST_UFFD(guest_exec, with_af, CMD_HOLE_DATA | CMD_HOLE_PT, 960 uffd_data_handler, uffd_pt_handler, 2), 961 962 /* 963 * Try accesses when the data and PT memory regions are both 964 * tracked for dirty logging. 965 */ 966 TEST_DIRTY_LOG(guest_read64, with_af, guest_check_no_write_in_dirty_log, 967 guest_check_s1ptw_wr_in_dirty_log), 968 TEST_DIRTY_LOG(guest_read64, no_af, guest_check_no_write_in_dirty_log, 969 guest_check_no_s1ptw_wr_in_dirty_log), 970 TEST_DIRTY_LOG(guest_ld_preidx, with_af, 971 guest_check_no_write_in_dirty_log, 972 guest_check_s1ptw_wr_in_dirty_log), 973 TEST_DIRTY_LOG(guest_at, no_af, guest_check_no_write_in_dirty_log, 974 guest_check_no_s1ptw_wr_in_dirty_log), 975 TEST_DIRTY_LOG(guest_exec, with_af, guest_check_no_write_in_dirty_log, 976 guest_check_s1ptw_wr_in_dirty_log), 977 TEST_DIRTY_LOG(guest_write64, with_af, guest_check_write_in_dirty_log, 978 guest_check_s1ptw_wr_in_dirty_log), 979 TEST_DIRTY_LOG(guest_cas, with_af, guest_check_write_in_dirty_log, 980 guest_check_s1ptw_wr_in_dirty_log), 981 TEST_DIRTY_LOG(guest_dc_zva, with_af, guest_check_write_in_dirty_log, 982 guest_check_s1ptw_wr_in_dirty_log), 983 TEST_DIRTY_LOG(guest_st_preidx, with_af, guest_check_write_in_dirty_log, 984 guest_check_s1ptw_wr_in_dirty_log), 985 986 /* 987 * Access when the data and PT memory regions are both marked for 988 * dirty logging and UFFD at the same time. The expected result is 989 * that writes should mark the dirty log and trigger a userfaultfd 990 * write fault. Reads/execs should result in a read userfaultfd 991 * fault, and nothing in the dirty log. Any S1PTW should result in 992 * a write in the dirty log and a userfaultfd write. 993 */ 994 TEST_UFFD_AND_DIRTY_LOG(guest_read64, with_af, 995 uffd_data_handler, 2, 996 guest_check_no_write_in_dirty_log, 997 guest_check_s1ptw_wr_in_dirty_log), 998 TEST_UFFD_AND_DIRTY_LOG(guest_read64, no_af, 999 uffd_data_handler, 2, 1000 guest_check_no_write_in_dirty_log, 1001 guest_check_no_s1ptw_wr_in_dirty_log), 1002 TEST_UFFD_AND_DIRTY_LOG(guest_ld_preidx, with_af, 1003 uffd_data_handler, 1004 2, guest_check_no_write_in_dirty_log, 1005 guest_check_s1ptw_wr_in_dirty_log), 1006 TEST_UFFD_AND_DIRTY_LOG(guest_at, with_af, uffd_no_handler, 1, 1007 guest_check_no_write_in_dirty_log, 1008 guest_check_s1ptw_wr_in_dirty_log), 1009 TEST_UFFD_AND_DIRTY_LOG(guest_exec, with_af, 1010 uffd_data_handler, 2, 1011 guest_check_no_write_in_dirty_log, 1012 guest_check_s1ptw_wr_in_dirty_log), 1013 TEST_UFFD_AND_DIRTY_LOG(guest_write64, with_af, 1014 uffd_data_handler, 1015 2, guest_check_write_in_dirty_log, 1016 guest_check_s1ptw_wr_in_dirty_log), 1017 TEST_UFFD_AND_DIRTY_LOG(guest_cas, with_af, 1018 uffd_data_handler, 2, 1019 guest_check_write_in_dirty_log, 1020 guest_check_s1ptw_wr_in_dirty_log), 1021 TEST_UFFD_AND_DIRTY_LOG(guest_dc_zva, with_af, 1022 uffd_data_handler, 1023 2, guest_check_write_in_dirty_log, 1024 guest_check_s1ptw_wr_in_dirty_log), 1025 TEST_UFFD_AND_DIRTY_LOG(guest_st_preidx, with_af, 1026 uffd_data_handler, 2, 1027 guest_check_write_in_dirty_log, 1028 guest_check_s1ptw_wr_in_dirty_log), 1029 /* 1030 * Access when both the PT and data regions are marked read-only 1031 * (with KVM_MEM_READONLY). Writes with a syndrome result in an 1032 * MMIO exit, writes with no syndrome (e.g., CAS) result in a 1033 * failed vcpu run, and reads/execs with and without syndroms do 1034 * not fault. 1035 */ 1036 TEST_RO_MEMSLOT(guest_read64, 0, 0), 1037 TEST_RO_MEMSLOT(guest_ld_preidx, 0, 0), 1038 TEST_RO_MEMSLOT(guest_at, 0, 0), 1039 TEST_RO_MEMSLOT(guest_exec, 0, 0), 1040 TEST_RO_MEMSLOT(guest_write64, mmio_on_test_gpa_handler, 1), 1041 TEST_RO_MEMSLOT_NO_SYNDROME(guest_dc_zva), 1042 TEST_RO_MEMSLOT_NO_SYNDROME(guest_cas), 1043 TEST_RO_MEMSLOT_NO_SYNDROME(guest_st_preidx), 1044 1045 /* 1046 * The PT and data regions are both read-only and marked 1047 * for dirty logging at the same time. The expected result is that 1048 * for writes there should be no write in the dirty log. The 1049 * readonly handling is the same as if the memslot was not marked 1050 * for dirty logging: writes with a syndrome result in an MMIO 1051 * exit, and writes with no syndrome result in a failed vcpu run. 1052 */ 1053 TEST_RO_MEMSLOT_AND_DIRTY_LOG(guest_read64, 0, 0, 1054 guest_check_no_write_in_dirty_log), 1055 TEST_RO_MEMSLOT_AND_DIRTY_LOG(guest_ld_preidx, 0, 0, 1056 guest_check_no_write_in_dirty_log), 1057 TEST_RO_MEMSLOT_AND_DIRTY_LOG(guest_at, 0, 0, 1058 guest_check_no_write_in_dirty_log), 1059 TEST_RO_MEMSLOT_AND_DIRTY_LOG(guest_exec, 0, 0, 1060 guest_check_no_write_in_dirty_log), 1061 TEST_RO_MEMSLOT_AND_DIRTY_LOG(guest_write64, mmio_on_test_gpa_handler, 1062 1, guest_check_no_write_in_dirty_log), 1063 TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG(guest_dc_zva, 1064 guest_check_no_write_in_dirty_log), 1065 TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG(guest_cas, 1066 guest_check_no_write_in_dirty_log), 1067 TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG(guest_st_preidx, 1068 guest_check_no_write_in_dirty_log), 1069 1070 /* 1071 * The PT and data regions are both read-only and punched with 1072 * holes tracked with userfaultfd. The expected result is the 1073 * union of both userfaultfd and read-only behaviors. For example, 1074 * write accesses result in a userfaultfd write fault and an MMIO 1075 * exit. Writes with no syndrome result in a failed vcpu run and 1076 * no userfaultfd write fault. Reads result in userfaultfd getting 1077 * triggered. 1078 */ 1079 TEST_RO_MEMSLOT_AND_UFFD(guest_read64, 0, 0, uffd_data_handler, 2), 1080 TEST_RO_MEMSLOT_AND_UFFD(guest_ld_preidx, 0, 0, uffd_data_handler, 2), 1081 TEST_RO_MEMSLOT_AND_UFFD(guest_at, 0, 0, uffd_no_handler, 1), 1082 TEST_RO_MEMSLOT_AND_UFFD(guest_exec, 0, 0, uffd_data_handler, 2), 1083 TEST_RO_MEMSLOT_AND_UFFD(guest_write64, mmio_on_test_gpa_handler, 1, 1084 uffd_data_handler, 2), 1085 TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD(guest_cas, uffd_data_handler, 2), 1086 TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD(guest_dc_zva, uffd_no_handler, 1), 1087 TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD(guest_st_preidx, uffd_no_handler, 1), 1088 1089 { 0 } 1090 }; 1091 1092 static void for_each_test_and_guest_mode(enum vm_mem_backing_src_type src_type) 1093 { 1094 struct test_desc *t; 1095 1096 for (t = &tests[0]; t->name; t++) { 1097 if (t->skip) 1098 continue; 1099 1100 struct test_params p = { 1101 .src_type = src_type, 1102 .test_desc = t, 1103 }; 1104 1105 for_each_guest_mode(run_test, &p); 1106 } 1107 } 1108 1109 int main(int argc, char *argv[]) 1110 { 1111 enum vm_mem_backing_src_type src_type; 1112 int opt; 1113 1114 src_type = DEFAULT_VM_MEM_SRC; 1115 1116 while ((opt = getopt(argc, argv, "hm:s:")) != -1) { 1117 switch (opt) { 1118 case 'm': 1119 guest_modes_cmdline(optarg); 1120 break; 1121 case 's': 1122 src_type = parse_backing_src_type(optarg); 1123 break; 1124 case 'h': 1125 default: 1126 help(argv[0]); 1127 exit(0); 1128 } 1129 } 1130 1131 for_each_test_and_guest_mode(src_type); 1132 return 0; 1133 } 1134