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 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 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 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 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 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 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 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 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 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 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 */ 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__ 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 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 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 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