1 /* 2 * tools/testing/selftests/kvm/lib/kvm_util.c 3 * 4 * Copyright (C) 2018, Google LLC. 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2. 7 */ 8 9 #include "test_util.h" 10 #include "kvm_util.h" 11 #include "kvm_util_internal.h" 12 13 #include <assert.h> 14 #include <sys/mman.h> 15 #include <sys/types.h> 16 #include <sys/stat.h> 17 #include <linux/kernel.h> 18 19 #define KVM_UTIL_PGS_PER_HUGEPG 512 20 #define KVM_UTIL_MIN_PFN 2 21 22 /* Aligns x up to the next multiple of size. Size must be a power of 2. */ 23 static void *align(void *x, size_t size) 24 { 25 size_t mask = size - 1; 26 TEST_ASSERT(size != 0 && !(size & (size - 1)), 27 "size not a power of 2: %lu", size); 28 return (void *) (((size_t) x + mask) & ~mask); 29 } 30 31 /* 32 * Capability 33 * 34 * Input Args: 35 * cap - Capability 36 * 37 * Output Args: None 38 * 39 * Return: 40 * On success, the Value corresponding to the capability (KVM_CAP_*) 41 * specified by the value of cap. On failure a TEST_ASSERT failure 42 * is produced. 43 * 44 * Looks up and returns the value corresponding to the capability 45 * (KVM_CAP_*) given by cap. 46 */ 47 int kvm_check_cap(long cap) 48 { 49 int ret; 50 int kvm_fd; 51 52 kvm_fd = open(KVM_DEV_PATH, O_RDONLY); 53 if (kvm_fd < 0) 54 exit(KSFT_SKIP); 55 56 ret = ioctl(kvm_fd, KVM_CHECK_EXTENSION, cap); 57 TEST_ASSERT(ret != -1, "KVM_CHECK_EXTENSION IOCTL failed,\n" 58 " rc: %i errno: %i", ret, errno); 59 60 close(kvm_fd); 61 62 return ret; 63 } 64 65 /* VM Enable Capability 66 * 67 * Input Args: 68 * vm - Virtual Machine 69 * cap - Capability 70 * 71 * Output Args: None 72 * 73 * Return: On success, 0. On failure a TEST_ASSERT failure is produced. 74 * 75 * Enables a capability (KVM_CAP_*) on the VM. 76 */ 77 int vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap) 78 { 79 int ret; 80 81 ret = ioctl(vm->fd, KVM_ENABLE_CAP, cap); 82 TEST_ASSERT(ret == 0, "KVM_ENABLE_CAP IOCTL failed,\n" 83 " rc: %i errno: %i", ret, errno); 84 85 return ret; 86 } 87 88 static void vm_open(struct kvm_vm *vm, int perm) 89 { 90 vm->kvm_fd = open(KVM_DEV_PATH, perm); 91 if (vm->kvm_fd < 0) 92 exit(KSFT_SKIP); 93 94 vm->fd = ioctl(vm->kvm_fd, KVM_CREATE_VM, NULL); 95 TEST_ASSERT(vm->fd >= 0, "KVM_CREATE_VM ioctl failed, " 96 "rc: %i errno: %i", vm->fd, errno); 97 } 98 99 const char * const vm_guest_mode_string[] = { 100 "PA-bits:52, VA-bits:48, 4K pages", 101 "PA-bits:52, VA-bits:48, 64K pages", 102 "PA-bits:40, VA-bits:48, 4K pages", 103 "PA-bits:40, VA-bits:48, 64K pages", 104 }; 105 106 /* 107 * VM Create 108 * 109 * Input Args: 110 * mode - VM Mode (e.g. VM_MODE_P52V48_4K) 111 * phy_pages - Physical memory pages 112 * perm - permission 113 * 114 * Output Args: None 115 * 116 * Return: 117 * Pointer to opaque structure that describes the created VM. 118 * 119 * Creates a VM with the mode specified by mode (e.g. VM_MODE_P52V48_4K). 120 * When phy_pages is non-zero, a memory region of phy_pages physical pages 121 * is created and mapped starting at guest physical address 0. The file 122 * descriptor to control the created VM is created with the permissions 123 * given by perm (e.g. O_RDWR). 124 */ 125 struct kvm_vm *vm_create(enum vm_guest_mode mode, uint64_t phy_pages, int perm) 126 { 127 struct kvm_vm *vm; 128 int kvm_fd; 129 130 vm = calloc(1, sizeof(*vm)); 131 TEST_ASSERT(vm != NULL, "Insufficient Memory"); 132 133 vm->mode = mode; 134 vm_open(vm, perm); 135 136 /* Setup mode specific traits. */ 137 switch (vm->mode) { 138 case VM_MODE_P52V48_4K: 139 vm->pgtable_levels = 4; 140 vm->page_size = 0x1000; 141 vm->page_shift = 12; 142 vm->va_bits = 48; 143 break; 144 case VM_MODE_P52V48_64K: 145 vm->pgtable_levels = 3; 146 vm->pa_bits = 52; 147 vm->page_size = 0x10000; 148 vm->page_shift = 16; 149 vm->va_bits = 48; 150 break; 151 case VM_MODE_P40V48_4K: 152 vm->pgtable_levels = 4; 153 vm->pa_bits = 40; 154 vm->va_bits = 48; 155 vm->page_size = 0x1000; 156 vm->page_shift = 12; 157 break; 158 case VM_MODE_P40V48_64K: 159 vm->pgtable_levels = 3; 160 vm->pa_bits = 40; 161 vm->va_bits = 48; 162 vm->page_size = 0x10000; 163 vm->page_shift = 16; 164 break; 165 default: 166 TEST_ASSERT(false, "Unknown guest mode, mode: 0x%x", mode); 167 } 168 169 /* Limit to VA-bit canonical virtual addresses. */ 170 vm->vpages_valid = sparsebit_alloc(); 171 sparsebit_set_num(vm->vpages_valid, 172 0, (1ULL << (vm->va_bits - 1)) >> vm->page_shift); 173 sparsebit_set_num(vm->vpages_valid, 174 (~((1ULL << (vm->va_bits - 1)) - 1)) >> vm->page_shift, 175 (1ULL << (vm->va_bits - 1)) >> vm->page_shift); 176 177 /* Limit physical addresses to PA-bits. */ 178 vm->max_gfn = ((1ULL << vm->pa_bits) >> vm->page_shift) - 1; 179 180 /* Allocate and setup memory for guest. */ 181 vm->vpages_mapped = sparsebit_alloc(); 182 if (phy_pages != 0) 183 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, 184 0, 0, phy_pages, 0); 185 186 return vm; 187 } 188 189 /* 190 * VM Restart 191 * 192 * Input Args: 193 * vm - VM that has been released before 194 * perm - permission 195 * 196 * Output Args: None 197 * 198 * Reopens the file descriptors associated to the VM and reinstates the 199 * global state, such as the irqchip and the memory regions that are mapped 200 * into the guest. 201 */ 202 void kvm_vm_restart(struct kvm_vm *vmp, int perm) 203 { 204 struct userspace_mem_region *region; 205 206 vm_open(vmp, perm); 207 if (vmp->has_irqchip) 208 vm_create_irqchip(vmp); 209 210 for (region = vmp->userspace_mem_region_head; region; 211 region = region->next) { 212 int ret = ioctl(vmp->fd, KVM_SET_USER_MEMORY_REGION, ®ion->region); 213 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION IOCTL failed,\n" 214 " rc: %i errno: %i\n" 215 " slot: %u flags: 0x%x\n" 216 " guest_phys_addr: 0x%lx size: 0x%lx", 217 ret, errno, region->region.slot, 218 region->region.flags, 219 region->region.guest_phys_addr, 220 region->region.memory_size); 221 } 222 } 223 224 void kvm_vm_get_dirty_log(struct kvm_vm *vm, int slot, void *log) 225 { 226 struct kvm_dirty_log args = { .dirty_bitmap = log, .slot = slot }; 227 int ret; 228 229 ret = ioctl(vm->fd, KVM_GET_DIRTY_LOG, &args); 230 TEST_ASSERT(ret == 0, "%s: KVM_GET_DIRTY_LOG failed: %s", 231 strerror(-ret)); 232 } 233 234 /* 235 * Userspace Memory Region Find 236 * 237 * Input Args: 238 * vm - Virtual Machine 239 * start - Starting VM physical address 240 * end - Ending VM physical address, inclusive. 241 * 242 * Output Args: None 243 * 244 * Return: 245 * Pointer to overlapping region, NULL if no such region. 246 * 247 * Searches for a region with any physical memory that overlaps with 248 * any portion of the guest physical addresses from start to end 249 * inclusive. If multiple overlapping regions exist, a pointer to any 250 * of the regions is returned. Null is returned only when no overlapping 251 * region exists. 252 */ 253 static struct userspace_mem_region * 254 userspace_mem_region_find(struct kvm_vm *vm, uint64_t start, uint64_t end) 255 { 256 struct userspace_mem_region *region; 257 258 for (region = vm->userspace_mem_region_head; region; 259 region = region->next) { 260 uint64_t existing_start = region->region.guest_phys_addr; 261 uint64_t existing_end = region->region.guest_phys_addr 262 + region->region.memory_size - 1; 263 if (start <= existing_end && end >= existing_start) 264 return region; 265 } 266 267 return NULL; 268 } 269 270 /* 271 * KVM Userspace Memory Region Find 272 * 273 * Input Args: 274 * vm - Virtual Machine 275 * start - Starting VM physical address 276 * end - Ending VM physical address, inclusive. 277 * 278 * Output Args: None 279 * 280 * Return: 281 * Pointer to overlapping region, NULL if no such region. 282 * 283 * Public interface to userspace_mem_region_find. Allows tests to look up 284 * the memslot datastructure for a given range of guest physical memory. 285 */ 286 struct kvm_userspace_memory_region * 287 kvm_userspace_memory_region_find(struct kvm_vm *vm, uint64_t start, 288 uint64_t end) 289 { 290 struct userspace_mem_region *region; 291 292 region = userspace_mem_region_find(vm, start, end); 293 if (!region) 294 return NULL; 295 296 return ®ion->region; 297 } 298 299 /* 300 * VCPU Find 301 * 302 * Input Args: 303 * vm - Virtual Machine 304 * vcpuid - VCPU ID 305 * 306 * Output Args: None 307 * 308 * Return: 309 * Pointer to VCPU structure 310 * 311 * Locates a vcpu structure that describes the VCPU specified by vcpuid and 312 * returns a pointer to it. Returns NULL if the VM doesn't contain a VCPU 313 * for the specified vcpuid. 314 */ 315 struct vcpu *vcpu_find(struct kvm_vm *vm, uint32_t vcpuid) 316 { 317 struct vcpu *vcpup; 318 319 for (vcpup = vm->vcpu_head; vcpup; vcpup = vcpup->next) { 320 if (vcpup->id == vcpuid) 321 return vcpup; 322 } 323 324 return NULL; 325 } 326 327 /* 328 * VM VCPU Remove 329 * 330 * Input Args: 331 * vm - Virtual Machine 332 * vcpuid - VCPU ID 333 * 334 * Output Args: None 335 * 336 * Return: None, TEST_ASSERT failures for all error conditions 337 * 338 * Within the VM specified by vm, removes the VCPU given by vcpuid. 339 */ 340 static void vm_vcpu_rm(struct kvm_vm *vm, uint32_t vcpuid) 341 { 342 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 343 int ret; 344 345 ret = munmap(vcpu->state, sizeof(*vcpu->state)); 346 TEST_ASSERT(ret == 0, "munmap of VCPU fd failed, rc: %i " 347 "errno: %i", ret, errno); 348 close(vcpu->fd); 349 TEST_ASSERT(ret == 0, "Close of VCPU fd failed, rc: %i " 350 "errno: %i", ret, errno); 351 352 if (vcpu->next) 353 vcpu->next->prev = vcpu->prev; 354 if (vcpu->prev) 355 vcpu->prev->next = vcpu->next; 356 else 357 vm->vcpu_head = vcpu->next; 358 free(vcpu); 359 } 360 361 void kvm_vm_release(struct kvm_vm *vmp) 362 { 363 int ret; 364 365 while (vmp->vcpu_head) 366 vm_vcpu_rm(vmp, vmp->vcpu_head->id); 367 368 ret = close(vmp->fd); 369 TEST_ASSERT(ret == 0, "Close of vm fd failed,\n" 370 " vmp->fd: %i rc: %i errno: %i", vmp->fd, ret, errno); 371 372 close(vmp->kvm_fd); 373 TEST_ASSERT(ret == 0, "Close of /dev/kvm fd failed,\n" 374 " vmp->kvm_fd: %i rc: %i errno: %i", vmp->kvm_fd, ret, errno); 375 } 376 377 /* 378 * Destroys and frees the VM pointed to by vmp. 379 */ 380 void kvm_vm_free(struct kvm_vm *vmp) 381 { 382 int ret; 383 384 if (vmp == NULL) 385 return; 386 387 /* Free userspace_mem_regions. */ 388 while (vmp->userspace_mem_region_head) { 389 struct userspace_mem_region *region 390 = vmp->userspace_mem_region_head; 391 392 region->region.memory_size = 0; 393 ret = ioctl(vmp->fd, KVM_SET_USER_MEMORY_REGION, 394 ®ion->region); 395 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION IOCTL failed, " 396 "rc: %i errno: %i", ret, errno); 397 398 vmp->userspace_mem_region_head = region->next; 399 sparsebit_free(®ion->unused_phy_pages); 400 ret = munmap(region->mmap_start, region->mmap_size); 401 TEST_ASSERT(ret == 0, "munmap failed, rc: %i errno: %i", 402 ret, errno); 403 404 free(region); 405 } 406 407 /* Free sparsebit arrays. */ 408 sparsebit_free(&vmp->vpages_valid); 409 sparsebit_free(&vmp->vpages_mapped); 410 411 kvm_vm_release(vmp); 412 413 /* Free the structure describing the VM. */ 414 free(vmp); 415 } 416 417 /* 418 * Memory Compare, host virtual to guest virtual 419 * 420 * Input Args: 421 * hva - Starting host virtual address 422 * vm - Virtual Machine 423 * gva - Starting guest virtual address 424 * len - number of bytes to compare 425 * 426 * Output Args: None 427 * 428 * Input/Output Args: None 429 * 430 * Return: 431 * Returns 0 if the bytes starting at hva for a length of len 432 * are equal the guest virtual bytes starting at gva. Returns 433 * a value < 0, if bytes at hva are less than those at gva. 434 * Otherwise a value > 0 is returned. 435 * 436 * Compares the bytes starting at the host virtual address hva, for 437 * a length of len, to the guest bytes starting at the guest virtual 438 * address given by gva. 439 */ 440 int kvm_memcmp_hva_gva(void *hva, struct kvm_vm *vm, vm_vaddr_t gva, size_t len) 441 { 442 size_t amt; 443 444 /* 445 * Compare a batch of bytes until either a match is found 446 * or all the bytes have been compared. 447 */ 448 for (uintptr_t offset = 0; offset < len; offset += amt) { 449 uintptr_t ptr1 = (uintptr_t)hva + offset; 450 451 /* 452 * Determine host address for guest virtual address 453 * at offset. 454 */ 455 uintptr_t ptr2 = (uintptr_t)addr_gva2hva(vm, gva + offset); 456 457 /* 458 * Determine amount to compare on this pass. 459 * Don't allow the comparsion to cross a page boundary. 460 */ 461 amt = len - offset; 462 if ((ptr1 >> vm->page_shift) != ((ptr1 + amt) >> vm->page_shift)) 463 amt = vm->page_size - (ptr1 % vm->page_size); 464 if ((ptr2 >> vm->page_shift) != ((ptr2 + amt) >> vm->page_shift)) 465 amt = vm->page_size - (ptr2 % vm->page_size); 466 467 assert((ptr1 >> vm->page_shift) == ((ptr1 + amt - 1) >> vm->page_shift)); 468 assert((ptr2 >> vm->page_shift) == ((ptr2 + amt - 1) >> vm->page_shift)); 469 470 /* 471 * Perform the comparison. If there is a difference 472 * return that result to the caller, otherwise need 473 * to continue on looking for a mismatch. 474 */ 475 int ret = memcmp((void *)ptr1, (void *)ptr2, amt); 476 if (ret != 0) 477 return ret; 478 } 479 480 /* 481 * No mismatch found. Let the caller know the two memory 482 * areas are equal. 483 */ 484 return 0; 485 } 486 487 /* 488 * VM Userspace Memory Region Add 489 * 490 * Input Args: 491 * vm - Virtual Machine 492 * backing_src - Storage source for this region. 493 * NULL to use anonymous memory. 494 * guest_paddr - Starting guest physical address 495 * slot - KVM region slot 496 * npages - Number of physical pages 497 * flags - KVM memory region flags (e.g. KVM_MEM_LOG_DIRTY_PAGES) 498 * 499 * Output Args: None 500 * 501 * Return: None 502 * 503 * Allocates a memory area of the number of pages specified by npages 504 * and maps it to the VM specified by vm, at a starting physical address 505 * given by guest_paddr. The region is created with a KVM region slot 506 * given by slot, which must be unique and < KVM_MEM_SLOTS_NUM. The 507 * region is created with the flags given by flags. 508 */ 509 void vm_userspace_mem_region_add(struct kvm_vm *vm, 510 enum vm_mem_backing_src_type src_type, 511 uint64_t guest_paddr, uint32_t slot, uint64_t npages, 512 uint32_t flags) 513 { 514 int ret; 515 unsigned long pmem_size = 0; 516 struct userspace_mem_region *region; 517 size_t huge_page_size = KVM_UTIL_PGS_PER_HUGEPG * vm->page_size; 518 519 TEST_ASSERT((guest_paddr % vm->page_size) == 0, "Guest physical " 520 "address not on a page boundary.\n" 521 " guest_paddr: 0x%lx vm->page_size: 0x%x", 522 guest_paddr, vm->page_size); 523 TEST_ASSERT((((guest_paddr >> vm->page_shift) + npages) - 1) 524 <= vm->max_gfn, "Physical range beyond maximum " 525 "supported physical address,\n" 526 " guest_paddr: 0x%lx npages: 0x%lx\n" 527 " vm->max_gfn: 0x%lx vm->page_size: 0x%x", 528 guest_paddr, npages, vm->max_gfn, vm->page_size); 529 530 /* 531 * Confirm a mem region with an overlapping address doesn't 532 * already exist. 533 */ 534 region = (struct userspace_mem_region *) userspace_mem_region_find( 535 vm, guest_paddr, guest_paddr + npages * vm->page_size); 536 if (region != NULL) 537 TEST_ASSERT(false, "overlapping userspace_mem_region already " 538 "exists\n" 539 " requested guest_paddr: 0x%lx npages: 0x%lx " 540 "page_size: 0x%x\n" 541 " existing guest_paddr: 0x%lx size: 0x%lx", 542 guest_paddr, npages, vm->page_size, 543 (uint64_t) region->region.guest_phys_addr, 544 (uint64_t) region->region.memory_size); 545 546 /* Confirm no region with the requested slot already exists. */ 547 for (region = vm->userspace_mem_region_head; region; 548 region = region->next) { 549 if (region->region.slot == slot) 550 break; 551 if ((guest_paddr <= (region->region.guest_phys_addr 552 + region->region.memory_size)) 553 && ((guest_paddr + npages * vm->page_size) 554 >= region->region.guest_phys_addr)) 555 break; 556 } 557 if (region != NULL) 558 TEST_ASSERT(false, "A mem region with the requested slot " 559 "or overlapping physical memory range already exists.\n" 560 " requested slot: %u paddr: 0x%lx npages: 0x%lx\n" 561 " existing slot: %u paddr: 0x%lx size: 0x%lx", 562 slot, guest_paddr, npages, 563 region->region.slot, 564 (uint64_t) region->region.guest_phys_addr, 565 (uint64_t) region->region.memory_size); 566 567 /* Allocate and initialize new mem region structure. */ 568 region = calloc(1, sizeof(*region)); 569 TEST_ASSERT(region != NULL, "Insufficient Memory"); 570 region->mmap_size = npages * vm->page_size; 571 572 /* Enough memory to align up to a huge page. */ 573 if (src_type == VM_MEM_SRC_ANONYMOUS_THP) 574 region->mmap_size += huge_page_size; 575 region->mmap_start = mmap(NULL, region->mmap_size, 576 PROT_READ | PROT_WRITE, 577 MAP_PRIVATE | MAP_ANONYMOUS 578 | (src_type == VM_MEM_SRC_ANONYMOUS_HUGETLB ? MAP_HUGETLB : 0), 579 -1, 0); 580 TEST_ASSERT(region->mmap_start != MAP_FAILED, 581 "test_malloc failed, mmap_start: %p errno: %i", 582 region->mmap_start, errno); 583 584 /* Align THP allocation up to start of a huge page. */ 585 region->host_mem = align(region->mmap_start, 586 src_type == VM_MEM_SRC_ANONYMOUS_THP ? huge_page_size : 1); 587 588 /* As needed perform madvise */ 589 if (src_type == VM_MEM_SRC_ANONYMOUS || src_type == VM_MEM_SRC_ANONYMOUS_THP) { 590 ret = madvise(region->host_mem, npages * vm->page_size, 591 src_type == VM_MEM_SRC_ANONYMOUS ? MADV_NOHUGEPAGE : MADV_HUGEPAGE); 592 TEST_ASSERT(ret == 0, "madvise failed,\n" 593 " addr: %p\n" 594 " length: 0x%lx\n" 595 " src_type: %x", 596 region->host_mem, npages * vm->page_size, src_type); 597 } 598 599 region->unused_phy_pages = sparsebit_alloc(); 600 sparsebit_set_num(region->unused_phy_pages, 601 guest_paddr >> vm->page_shift, npages); 602 region->region.slot = slot; 603 region->region.flags = flags; 604 region->region.guest_phys_addr = guest_paddr; 605 region->region.memory_size = npages * vm->page_size; 606 region->region.userspace_addr = (uintptr_t) region->host_mem; 607 ret = ioctl(vm->fd, KVM_SET_USER_MEMORY_REGION, ®ion->region); 608 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION IOCTL failed,\n" 609 " rc: %i errno: %i\n" 610 " slot: %u flags: 0x%x\n" 611 " guest_phys_addr: 0x%lx size: 0x%lx", 612 ret, errno, slot, flags, 613 guest_paddr, (uint64_t) region->region.memory_size); 614 615 /* Add to linked-list of memory regions. */ 616 if (vm->userspace_mem_region_head) 617 vm->userspace_mem_region_head->prev = region; 618 region->next = vm->userspace_mem_region_head; 619 vm->userspace_mem_region_head = region; 620 } 621 622 /* 623 * Memslot to region 624 * 625 * Input Args: 626 * vm - Virtual Machine 627 * memslot - KVM memory slot ID 628 * 629 * Output Args: None 630 * 631 * Return: 632 * Pointer to memory region structure that describe memory region 633 * using kvm memory slot ID given by memslot. TEST_ASSERT failure 634 * on error (e.g. currently no memory region using memslot as a KVM 635 * memory slot ID). 636 */ 637 static struct userspace_mem_region * 638 memslot2region(struct kvm_vm *vm, uint32_t memslot) 639 { 640 struct userspace_mem_region *region; 641 642 for (region = vm->userspace_mem_region_head; region; 643 region = region->next) { 644 if (region->region.slot == memslot) 645 break; 646 } 647 if (region == NULL) { 648 fprintf(stderr, "No mem region with the requested slot found,\n" 649 " requested slot: %u\n", memslot); 650 fputs("---- vm dump ----\n", stderr); 651 vm_dump(stderr, vm, 2); 652 TEST_ASSERT(false, "Mem region not found"); 653 } 654 655 return region; 656 } 657 658 /* 659 * VM Memory Region Flags Set 660 * 661 * Input Args: 662 * vm - Virtual Machine 663 * flags - Starting guest physical address 664 * 665 * Output Args: None 666 * 667 * Return: None 668 * 669 * Sets the flags of the memory region specified by the value of slot, 670 * to the values given by flags. 671 */ 672 void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags) 673 { 674 int ret; 675 struct userspace_mem_region *region; 676 677 region = memslot2region(vm, slot); 678 679 region->region.flags = flags; 680 681 ret = ioctl(vm->fd, KVM_SET_USER_MEMORY_REGION, ®ion->region); 682 683 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION IOCTL failed,\n" 684 " rc: %i errno: %i slot: %u flags: 0x%x", 685 ret, errno, slot, flags); 686 } 687 688 /* 689 * VCPU mmap Size 690 * 691 * Input Args: None 692 * 693 * Output Args: None 694 * 695 * Return: 696 * Size of VCPU state 697 * 698 * Returns the size of the structure pointed to by the return value 699 * of vcpu_state(). 700 */ 701 static int vcpu_mmap_sz(void) 702 { 703 int dev_fd, ret; 704 705 dev_fd = open(KVM_DEV_PATH, O_RDONLY); 706 if (dev_fd < 0) 707 exit(KSFT_SKIP); 708 709 ret = ioctl(dev_fd, KVM_GET_VCPU_MMAP_SIZE, NULL); 710 TEST_ASSERT(ret >= sizeof(struct kvm_run), 711 "%s KVM_GET_VCPU_MMAP_SIZE ioctl failed, rc: %i errno: %i", 712 __func__, ret, errno); 713 714 close(dev_fd); 715 716 return ret; 717 } 718 719 /* 720 * VM VCPU Add 721 * 722 * Input Args: 723 * vm - Virtual Machine 724 * vcpuid - VCPU ID 725 * 726 * Output Args: None 727 * 728 * Return: None 729 * 730 * Creates and adds to the VM specified by vm and virtual CPU with 731 * the ID given by vcpuid. 732 */ 733 void vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpuid, int pgd_memslot, 734 int gdt_memslot) 735 { 736 struct vcpu *vcpu; 737 738 /* Confirm a vcpu with the specified id doesn't already exist. */ 739 vcpu = vcpu_find(vm, vcpuid); 740 if (vcpu != NULL) 741 TEST_ASSERT(false, "vcpu with the specified id " 742 "already exists,\n" 743 " requested vcpuid: %u\n" 744 " existing vcpuid: %u state: %p", 745 vcpuid, vcpu->id, vcpu->state); 746 747 /* Allocate and initialize new vcpu structure. */ 748 vcpu = calloc(1, sizeof(*vcpu)); 749 TEST_ASSERT(vcpu != NULL, "Insufficient Memory"); 750 vcpu->id = vcpuid; 751 vcpu->fd = ioctl(vm->fd, KVM_CREATE_VCPU, vcpuid); 752 TEST_ASSERT(vcpu->fd >= 0, "KVM_CREATE_VCPU failed, rc: %i errno: %i", 753 vcpu->fd, errno); 754 755 TEST_ASSERT(vcpu_mmap_sz() >= sizeof(*vcpu->state), "vcpu mmap size " 756 "smaller than expected, vcpu_mmap_sz: %i expected_min: %zi", 757 vcpu_mmap_sz(), sizeof(*vcpu->state)); 758 vcpu->state = (struct kvm_run *) mmap(NULL, sizeof(*vcpu->state), 759 PROT_READ | PROT_WRITE, MAP_SHARED, vcpu->fd, 0); 760 TEST_ASSERT(vcpu->state != MAP_FAILED, "mmap vcpu_state failed, " 761 "vcpu id: %u errno: %i", vcpuid, errno); 762 763 /* Add to linked-list of VCPUs. */ 764 if (vm->vcpu_head) 765 vm->vcpu_head->prev = vcpu; 766 vcpu->next = vm->vcpu_head; 767 vm->vcpu_head = vcpu; 768 769 vcpu_setup(vm, vcpuid, pgd_memslot, gdt_memslot); 770 } 771 772 /* 773 * VM Virtual Address Unused Gap 774 * 775 * Input Args: 776 * vm - Virtual Machine 777 * sz - Size (bytes) 778 * vaddr_min - Minimum Virtual Address 779 * 780 * Output Args: None 781 * 782 * Return: 783 * Lowest virtual address at or below vaddr_min, with at least 784 * sz unused bytes. TEST_ASSERT failure if no area of at least 785 * size sz is available. 786 * 787 * Within the VM specified by vm, locates the lowest starting virtual 788 * address >= vaddr_min, that has at least sz unallocated bytes. A 789 * TEST_ASSERT failure occurs for invalid input or no area of at least 790 * sz unallocated bytes >= vaddr_min is available. 791 */ 792 static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, 793 vm_vaddr_t vaddr_min) 794 { 795 uint64_t pages = (sz + vm->page_size - 1) >> vm->page_shift; 796 797 /* Determine lowest permitted virtual page index. */ 798 uint64_t pgidx_start = (vaddr_min + vm->page_size - 1) >> vm->page_shift; 799 if ((pgidx_start * vm->page_size) < vaddr_min) 800 goto no_va_found; 801 802 /* Loop over section with enough valid virtual page indexes. */ 803 if (!sparsebit_is_set_num(vm->vpages_valid, 804 pgidx_start, pages)) 805 pgidx_start = sparsebit_next_set_num(vm->vpages_valid, 806 pgidx_start, pages); 807 do { 808 /* 809 * Are there enough unused virtual pages available at 810 * the currently proposed starting virtual page index. 811 * If not, adjust proposed starting index to next 812 * possible. 813 */ 814 if (sparsebit_is_clear_num(vm->vpages_mapped, 815 pgidx_start, pages)) 816 goto va_found; 817 pgidx_start = sparsebit_next_clear_num(vm->vpages_mapped, 818 pgidx_start, pages); 819 if (pgidx_start == 0) 820 goto no_va_found; 821 822 /* 823 * If needed, adjust proposed starting virtual address, 824 * to next range of valid virtual addresses. 825 */ 826 if (!sparsebit_is_set_num(vm->vpages_valid, 827 pgidx_start, pages)) { 828 pgidx_start = sparsebit_next_set_num( 829 vm->vpages_valid, pgidx_start, pages); 830 if (pgidx_start == 0) 831 goto no_va_found; 832 } 833 } while (pgidx_start != 0); 834 835 no_va_found: 836 TEST_ASSERT(false, "No vaddr of specified pages available, " 837 "pages: 0x%lx", pages); 838 839 /* NOT REACHED */ 840 return -1; 841 842 va_found: 843 TEST_ASSERT(sparsebit_is_set_num(vm->vpages_valid, 844 pgidx_start, pages), 845 "Unexpected, invalid virtual page index range,\n" 846 " pgidx_start: 0x%lx\n" 847 " pages: 0x%lx", 848 pgidx_start, pages); 849 TEST_ASSERT(sparsebit_is_clear_num(vm->vpages_mapped, 850 pgidx_start, pages), 851 "Unexpected, pages already mapped,\n" 852 " pgidx_start: 0x%lx\n" 853 " pages: 0x%lx", 854 pgidx_start, pages); 855 856 return pgidx_start * vm->page_size; 857 } 858 859 /* 860 * VM Virtual Address Allocate 861 * 862 * Input Args: 863 * vm - Virtual Machine 864 * sz - Size in bytes 865 * vaddr_min - Minimum starting virtual address 866 * data_memslot - Memory region slot for data pages 867 * pgd_memslot - Memory region slot for new virtual translation tables 868 * 869 * Output Args: None 870 * 871 * Return: 872 * Starting guest virtual address 873 * 874 * Allocates at least sz bytes within the virtual address space of the vm 875 * given by vm. The allocated bytes are mapped to a virtual address >= 876 * the address given by vaddr_min. Note that each allocation uses a 877 * a unique set of pages, with the minimum real allocation being at least 878 * a page. 879 */ 880 vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min, 881 uint32_t data_memslot, uint32_t pgd_memslot) 882 { 883 uint64_t pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0); 884 885 virt_pgd_alloc(vm, pgd_memslot); 886 887 /* 888 * Find an unused range of virtual page addresses of at least 889 * pages in length. 890 */ 891 vm_vaddr_t vaddr_start = vm_vaddr_unused_gap(vm, sz, vaddr_min); 892 893 /* Map the virtual pages. */ 894 for (vm_vaddr_t vaddr = vaddr_start; pages > 0; 895 pages--, vaddr += vm->page_size) { 896 vm_paddr_t paddr; 897 898 paddr = vm_phy_page_alloc(vm, 899 KVM_UTIL_MIN_PFN * vm->page_size, data_memslot); 900 901 virt_pg_map(vm, vaddr, paddr, pgd_memslot); 902 903 sparsebit_set(vm->vpages_mapped, 904 vaddr >> vm->page_shift); 905 } 906 907 return vaddr_start; 908 } 909 910 /* 911 * Map a range of VM virtual address to the VM's physical address 912 * 913 * Input Args: 914 * vm - Virtual Machine 915 * vaddr - Virtuall address to map 916 * paddr - VM Physical Address 917 * size - The size of the range to map 918 * pgd_memslot - Memory region slot for new virtual translation tables 919 * 920 * Output Args: None 921 * 922 * Return: None 923 * 924 * Within the VM given by vm, creates a virtual translation for the 925 * page range starting at vaddr to the page range starting at paddr. 926 */ 927 void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, 928 size_t size, uint32_t pgd_memslot) 929 { 930 size_t page_size = vm->page_size; 931 size_t npages = size / page_size; 932 933 TEST_ASSERT(vaddr + size > vaddr, "Vaddr overflow"); 934 TEST_ASSERT(paddr + size > paddr, "Paddr overflow"); 935 936 while (npages--) { 937 virt_pg_map(vm, vaddr, paddr, pgd_memslot); 938 vaddr += page_size; 939 paddr += page_size; 940 } 941 } 942 943 /* 944 * Address VM Physical to Host Virtual 945 * 946 * Input Args: 947 * vm - Virtual Machine 948 * gpa - VM physical address 949 * 950 * Output Args: None 951 * 952 * Return: 953 * Equivalent host virtual address 954 * 955 * Locates the memory region containing the VM physical address given 956 * by gpa, within the VM given by vm. When found, the host virtual 957 * address providing the memory to the vm physical address is returned. 958 * A TEST_ASSERT failure occurs if no region containing gpa exists. 959 */ 960 void *addr_gpa2hva(struct kvm_vm *vm, vm_paddr_t gpa) 961 { 962 struct userspace_mem_region *region; 963 for (region = vm->userspace_mem_region_head; region; 964 region = region->next) { 965 if ((gpa >= region->region.guest_phys_addr) 966 && (gpa <= (region->region.guest_phys_addr 967 + region->region.memory_size - 1))) 968 return (void *) ((uintptr_t) region->host_mem 969 + (gpa - region->region.guest_phys_addr)); 970 } 971 972 TEST_ASSERT(false, "No vm physical memory at 0x%lx", gpa); 973 return NULL; 974 } 975 976 /* 977 * Address Host Virtual to VM Physical 978 * 979 * Input Args: 980 * vm - Virtual Machine 981 * hva - Host virtual address 982 * 983 * Output Args: None 984 * 985 * Return: 986 * Equivalent VM physical address 987 * 988 * Locates the memory region containing the host virtual address given 989 * by hva, within the VM given by vm. When found, the equivalent 990 * VM physical address is returned. A TEST_ASSERT failure occurs if no 991 * region containing hva exists. 992 */ 993 vm_paddr_t addr_hva2gpa(struct kvm_vm *vm, void *hva) 994 { 995 struct userspace_mem_region *region; 996 for (region = vm->userspace_mem_region_head; region; 997 region = region->next) { 998 if ((hva >= region->host_mem) 999 && (hva <= (region->host_mem 1000 + region->region.memory_size - 1))) 1001 return (vm_paddr_t) ((uintptr_t) 1002 region->region.guest_phys_addr 1003 + (hva - (uintptr_t) region->host_mem)); 1004 } 1005 1006 TEST_ASSERT(false, "No mapping to a guest physical address, " 1007 "hva: %p", hva); 1008 return -1; 1009 } 1010 1011 /* 1012 * VM Create IRQ Chip 1013 * 1014 * Input Args: 1015 * vm - Virtual Machine 1016 * 1017 * Output Args: None 1018 * 1019 * Return: None 1020 * 1021 * Creates an interrupt controller chip for the VM specified by vm. 1022 */ 1023 void vm_create_irqchip(struct kvm_vm *vm) 1024 { 1025 int ret; 1026 1027 ret = ioctl(vm->fd, KVM_CREATE_IRQCHIP, 0); 1028 TEST_ASSERT(ret == 0, "KVM_CREATE_IRQCHIP IOCTL failed, " 1029 "rc: %i errno: %i", ret, errno); 1030 1031 vm->has_irqchip = true; 1032 } 1033 1034 /* 1035 * VM VCPU State 1036 * 1037 * Input Args: 1038 * vm - Virtual Machine 1039 * vcpuid - VCPU ID 1040 * 1041 * Output Args: None 1042 * 1043 * Return: 1044 * Pointer to structure that describes the state of the VCPU. 1045 * 1046 * Locates and returns a pointer to a structure that describes the 1047 * state of the VCPU with the given vcpuid. 1048 */ 1049 struct kvm_run *vcpu_state(struct kvm_vm *vm, uint32_t vcpuid) 1050 { 1051 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1052 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1053 1054 return vcpu->state; 1055 } 1056 1057 /* 1058 * VM VCPU Run 1059 * 1060 * Input Args: 1061 * vm - Virtual Machine 1062 * vcpuid - VCPU ID 1063 * 1064 * Output Args: None 1065 * 1066 * Return: None 1067 * 1068 * Switch to executing the code for the VCPU given by vcpuid, within the VM 1069 * given by vm. 1070 */ 1071 void vcpu_run(struct kvm_vm *vm, uint32_t vcpuid) 1072 { 1073 int ret = _vcpu_run(vm, vcpuid); 1074 TEST_ASSERT(ret == 0, "KVM_RUN IOCTL failed, " 1075 "rc: %i errno: %i", ret, errno); 1076 } 1077 1078 int _vcpu_run(struct kvm_vm *vm, uint32_t vcpuid) 1079 { 1080 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1081 int rc; 1082 1083 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1084 do { 1085 rc = ioctl(vcpu->fd, KVM_RUN, NULL); 1086 } while (rc == -1 && errno == EINTR); 1087 return rc; 1088 } 1089 1090 /* 1091 * VM VCPU Set MP State 1092 * 1093 * Input Args: 1094 * vm - Virtual Machine 1095 * vcpuid - VCPU ID 1096 * mp_state - mp_state to be set 1097 * 1098 * Output Args: None 1099 * 1100 * Return: None 1101 * 1102 * Sets the MP state of the VCPU given by vcpuid, to the state given 1103 * by mp_state. 1104 */ 1105 void vcpu_set_mp_state(struct kvm_vm *vm, uint32_t vcpuid, 1106 struct kvm_mp_state *mp_state) 1107 { 1108 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1109 int ret; 1110 1111 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1112 1113 ret = ioctl(vcpu->fd, KVM_SET_MP_STATE, mp_state); 1114 TEST_ASSERT(ret == 0, "KVM_SET_MP_STATE IOCTL failed, " 1115 "rc: %i errno: %i", ret, errno); 1116 } 1117 1118 /* 1119 * VM VCPU Regs Get 1120 * 1121 * Input Args: 1122 * vm - Virtual Machine 1123 * vcpuid - VCPU ID 1124 * 1125 * Output Args: 1126 * regs - current state of VCPU regs 1127 * 1128 * Return: None 1129 * 1130 * Obtains the current register state for the VCPU specified by vcpuid 1131 * and stores it at the location given by regs. 1132 */ 1133 void vcpu_regs_get(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_regs *regs) 1134 { 1135 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1136 int ret; 1137 1138 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1139 1140 ret = ioctl(vcpu->fd, KVM_GET_REGS, regs); 1141 TEST_ASSERT(ret == 0, "KVM_GET_REGS failed, rc: %i errno: %i", 1142 ret, errno); 1143 } 1144 1145 /* 1146 * VM VCPU Regs Set 1147 * 1148 * Input Args: 1149 * vm - Virtual Machine 1150 * vcpuid - VCPU ID 1151 * regs - Values to set VCPU regs to 1152 * 1153 * Output Args: None 1154 * 1155 * Return: None 1156 * 1157 * Sets the regs of the VCPU specified by vcpuid to the values 1158 * given by regs. 1159 */ 1160 void vcpu_regs_set(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_regs *regs) 1161 { 1162 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1163 int ret; 1164 1165 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1166 1167 ret = ioctl(vcpu->fd, KVM_SET_REGS, regs); 1168 TEST_ASSERT(ret == 0, "KVM_SET_REGS failed, rc: %i errno: %i", 1169 ret, errno); 1170 } 1171 1172 void vcpu_events_get(struct kvm_vm *vm, uint32_t vcpuid, 1173 struct kvm_vcpu_events *events) 1174 { 1175 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1176 int ret; 1177 1178 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1179 1180 ret = ioctl(vcpu->fd, KVM_GET_VCPU_EVENTS, events); 1181 TEST_ASSERT(ret == 0, "KVM_GET_VCPU_EVENTS, failed, rc: %i errno: %i", 1182 ret, errno); 1183 } 1184 1185 void vcpu_events_set(struct kvm_vm *vm, uint32_t vcpuid, 1186 struct kvm_vcpu_events *events) 1187 { 1188 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1189 int ret; 1190 1191 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1192 1193 ret = ioctl(vcpu->fd, KVM_SET_VCPU_EVENTS, events); 1194 TEST_ASSERT(ret == 0, "KVM_SET_VCPU_EVENTS, failed, rc: %i errno: %i", 1195 ret, errno); 1196 } 1197 1198 /* 1199 * VM VCPU System Regs Get 1200 * 1201 * Input Args: 1202 * vm - Virtual Machine 1203 * vcpuid - VCPU ID 1204 * 1205 * Output Args: 1206 * sregs - current state of VCPU system regs 1207 * 1208 * Return: None 1209 * 1210 * Obtains the current system register state for the VCPU specified by 1211 * vcpuid and stores it at the location given by sregs. 1212 */ 1213 void vcpu_sregs_get(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_sregs *sregs) 1214 { 1215 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1216 int ret; 1217 1218 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1219 1220 ret = ioctl(vcpu->fd, KVM_GET_SREGS, sregs); 1221 TEST_ASSERT(ret == 0, "KVM_GET_SREGS failed, rc: %i errno: %i", 1222 ret, errno); 1223 } 1224 1225 /* 1226 * VM VCPU System Regs Set 1227 * 1228 * Input Args: 1229 * vm - Virtual Machine 1230 * vcpuid - VCPU ID 1231 * sregs - Values to set VCPU system regs to 1232 * 1233 * Output Args: None 1234 * 1235 * Return: None 1236 * 1237 * Sets the system regs of the VCPU specified by vcpuid to the values 1238 * given by sregs. 1239 */ 1240 void vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_sregs *sregs) 1241 { 1242 int ret = _vcpu_sregs_set(vm, vcpuid, sregs); 1243 TEST_ASSERT(ret == 0, "KVM_RUN IOCTL failed, " 1244 "rc: %i errno: %i", ret, errno); 1245 } 1246 1247 int _vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_sregs *sregs) 1248 { 1249 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1250 int ret; 1251 1252 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1253 1254 return ioctl(vcpu->fd, KVM_SET_SREGS, sregs); 1255 } 1256 1257 /* 1258 * VCPU Ioctl 1259 * 1260 * Input Args: 1261 * vm - Virtual Machine 1262 * vcpuid - VCPU ID 1263 * cmd - Ioctl number 1264 * arg - Argument to pass to the ioctl 1265 * 1266 * Return: None 1267 * 1268 * Issues an arbitrary ioctl on a VCPU fd. 1269 */ 1270 void vcpu_ioctl(struct kvm_vm *vm, uint32_t vcpuid, 1271 unsigned long cmd, void *arg) 1272 { 1273 struct vcpu *vcpu = vcpu_find(vm, vcpuid); 1274 int ret; 1275 1276 TEST_ASSERT(vcpu != NULL, "vcpu not found, vcpuid: %u", vcpuid); 1277 1278 ret = ioctl(vcpu->fd, cmd, arg); 1279 TEST_ASSERT(ret == 0, "vcpu ioctl %lu failed, rc: %i errno: %i (%s)", 1280 cmd, ret, errno, strerror(errno)); 1281 } 1282 1283 /* 1284 * VM Ioctl 1285 * 1286 * Input Args: 1287 * vm - Virtual Machine 1288 * cmd - Ioctl number 1289 * arg - Argument to pass to the ioctl 1290 * 1291 * Return: None 1292 * 1293 * Issues an arbitrary ioctl on a VM fd. 1294 */ 1295 void vm_ioctl(struct kvm_vm *vm, unsigned long cmd, void *arg) 1296 { 1297 int ret; 1298 1299 ret = ioctl(vm->fd, cmd, arg); 1300 TEST_ASSERT(ret == 0, "vm ioctl %lu failed, rc: %i errno: %i (%s)", 1301 cmd, ret, errno, strerror(errno)); 1302 } 1303 1304 /* 1305 * VM Dump 1306 * 1307 * Input Args: 1308 * vm - Virtual Machine 1309 * indent - Left margin indent amount 1310 * 1311 * Output Args: 1312 * stream - Output FILE stream 1313 * 1314 * Return: None 1315 * 1316 * Dumps the current state of the VM given by vm, to the FILE stream 1317 * given by stream. 1318 */ 1319 void vm_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent) 1320 { 1321 struct userspace_mem_region *region; 1322 struct vcpu *vcpu; 1323 1324 fprintf(stream, "%*smode: 0x%x\n", indent, "", vm->mode); 1325 fprintf(stream, "%*sfd: %i\n", indent, "", vm->fd); 1326 fprintf(stream, "%*spage_size: 0x%x\n", indent, "", vm->page_size); 1327 fprintf(stream, "%*sMem Regions:\n", indent, ""); 1328 for (region = vm->userspace_mem_region_head; region; 1329 region = region->next) { 1330 fprintf(stream, "%*sguest_phys: 0x%lx size: 0x%lx " 1331 "host_virt: %p\n", indent + 2, "", 1332 (uint64_t) region->region.guest_phys_addr, 1333 (uint64_t) region->region.memory_size, 1334 region->host_mem); 1335 fprintf(stream, "%*sunused_phy_pages: ", indent + 2, ""); 1336 sparsebit_dump(stream, region->unused_phy_pages, 0); 1337 } 1338 fprintf(stream, "%*sMapped Virtual Pages:\n", indent, ""); 1339 sparsebit_dump(stream, vm->vpages_mapped, indent + 2); 1340 fprintf(stream, "%*spgd_created: %u\n", indent, "", 1341 vm->pgd_created); 1342 if (vm->pgd_created) { 1343 fprintf(stream, "%*sVirtual Translation Tables:\n", 1344 indent + 2, ""); 1345 virt_dump(stream, vm, indent + 4); 1346 } 1347 fprintf(stream, "%*sVCPUs:\n", indent, ""); 1348 for (vcpu = vm->vcpu_head; vcpu; vcpu = vcpu->next) 1349 vcpu_dump(stream, vm, vcpu->id, indent + 2); 1350 } 1351 1352 /* Known KVM exit reasons */ 1353 static struct exit_reason { 1354 unsigned int reason; 1355 const char *name; 1356 } exit_reasons_known[] = { 1357 {KVM_EXIT_UNKNOWN, "UNKNOWN"}, 1358 {KVM_EXIT_EXCEPTION, "EXCEPTION"}, 1359 {KVM_EXIT_IO, "IO"}, 1360 {KVM_EXIT_HYPERCALL, "HYPERCALL"}, 1361 {KVM_EXIT_DEBUG, "DEBUG"}, 1362 {KVM_EXIT_HLT, "HLT"}, 1363 {KVM_EXIT_MMIO, "MMIO"}, 1364 {KVM_EXIT_IRQ_WINDOW_OPEN, "IRQ_WINDOW_OPEN"}, 1365 {KVM_EXIT_SHUTDOWN, "SHUTDOWN"}, 1366 {KVM_EXIT_FAIL_ENTRY, "FAIL_ENTRY"}, 1367 {KVM_EXIT_INTR, "INTR"}, 1368 {KVM_EXIT_SET_TPR, "SET_TPR"}, 1369 {KVM_EXIT_TPR_ACCESS, "TPR_ACCESS"}, 1370 {KVM_EXIT_S390_SIEIC, "S390_SIEIC"}, 1371 {KVM_EXIT_S390_RESET, "S390_RESET"}, 1372 {KVM_EXIT_DCR, "DCR"}, 1373 {KVM_EXIT_NMI, "NMI"}, 1374 {KVM_EXIT_INTERNAL_ERROR, "INTERNAL_ERROR"}, 1375 {KVM_EXIT_OSI, "OSI"}, 1376 {KVM_EXIT_PAPR_HCALL, "PAPR_HCALL"}, 1377 #ifdef KVM_EXIT_MEMORY_NOT_PRESENT 1378 {KVM_EXIT_MEMORY_NOT_PRESENT, "MEMORY_NOT_PRESENT"}, 1379 #endif 1380 }; 1381 1382 /* 1383 * Exit Reason String 1384 * 1385 * Input Args: 1386 * exit_reason - Exit reason 1387 * 1388 * Output Args: None 1389 * 1390 * Return: 1391 * Constant string pointer describing the exit reason. 1392 * 1393 * Locates and returns a constant string that describes the KVM exit 1394 * reason given by exit_reason. If no such string is found, a constant 1395 * string of "Unknown" is returned. 1396 */ 1397 const char *exit_reason_str(unsigned int exit_reason) 1398 { 1399 unsigned int n1; 1400 1401 for (n1 = 0; n1 < ARRAY_SIZE(exit_reasons_known); n1++) { 1402 if (exit_reason == exit_reasons_known[n1].reason) 1403 return exit_reasons_known[n1].name; 1404 } 1405 1406 return "Unknown"; 1407 } 1408 1409 /* 1410 * Physical Contiguous Page Allocator 1411 * 1412 * Input Args: 1413 * vm - Virtual Machine 1414 * num - number of pages 1415 * paddr_min - Physical address minimum 1416 * memslot - Memory region to allocate page from 1417 * 1418 * Output Args: None 1419 * 1420 * Return: 1421 * Starting physical address 1422 * 1423 * Within the VM specified by vm, locates a range of available physical 1424 * pages at or above paddr_min. If found, the pages are marked as in use 1425 * and thier base address is returned. A TEST_ASSERT failure occurs if 1426 * not enough pages are available at or above paddr_min. 1427 */ 1428 vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, 1429 vm_paddr_t paddr_min, uint32_t memslot) 1430 { 1431 struct userspace_mem_region *region; 1432 sparsebit_idx_t pg, base; 1433 1434 TEST_ASSERT(num > 0, "Must allocate at least one page"); 1435 1436 TEST_ASSERT((paddr_min % vm->page_size) == 0, "Min physical address " 1437 "not divisible by page size.\n" 1438 " paddr_min: 0x%lx page_size: 0x%x", 1439 paddr_min, vm->page_size); 1440 1441 region = memslot2region(vm, memslot); 1442 base = pg = paddr_min >> vm->page_shift; 1443 1444 do { 1445 for (; pg < base + num; ++pg) { 1446 if (!sparsebit_is_set(region->unused_phy_pages, pg)) { 1447 base = pg = sparsebit_next_set(region->unused_phy_pages, pg); 1448 break; 1449 } 1450 } 1451 } while (pg && pg != base + num); 1452 1453 if (pg == 0) { 1454 fprintf(stderr, "No guest physical page available, " 1455 "paddr_min: 0x%lx page_size: 0x%x memslot: %u\n", 1456 paddr_min, vm->page_size, memslot); 1457 fputs("---- vm dump ----\n", stderr); 1458 vm_dump(stderr, vm, 2); 1459 abort(); 1460 } 1461 1462 for (pg = base; pg < base + num; ++pg) 1463 sparsebit_clear(region->unused_phy_pages, pg); 1464 1465 return base * vm->page_size; 1466 } 1467 1468 vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min, 1469 uint32_t memslot) 1470 { 1471 return vm_phy_pages_alloc(vm, 1, paddr_min, memslot); 1472 } 1473 1474 /* 1475 * Address Guest Virtual to Host Virtual 1476 * 1477 * Input Args: 1478 * vm - Virtual Machine 1479 * gva - VM virtual address 1480 * 1481 * Output Args: None 1482 * 1483 * Return: 1484 * Equivalent host virtual address 1485 */ 1486 void *addr_gva2hva(struct kvm_vm *vm, vm_vaddr_t gva) 1487 { 1488 return addr_gpa2hva(vm, addr_gva2gpa(vm, gva)); 1489 } 1490
