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