Merge branch 'xarray' of git://git.infradead.org/users/willy/linux-dax
[muen/linux.git] / tools / testing / selftests / kvm / lib / kvm_util.c
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, "Insufficent 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, &region->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 &region->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                         &region->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(&region->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, &region->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, &region->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 }