183 void vm_enable_dirty_ring(struct kvm_vm *vm, uint32_t ring_size)  in vm_enable_dirty_ring()  argument
185 	if (vm_check_cap(vm, KVM_CAP_DIRTY_LOG_RING_ACQ_REL))  in vm_enable_dirty_ring()
186 		vm_enable_cap(vm, KVM_CAP_DIRTY_LOG_RING_ACQ_REL, ring_size);  in vm_enable_dirty_ring()
188 		vm_enable_cap(vm, KVM_CAP_DIRTY_LOG_RING, ring_size);  in vm_enable_dirty_ring()
189 	vm->dirty_ring_size = ring_size;  in vm_enable_dirty_ring()
192 static void vm_open(struct kvm_vm *vm)  in vm_open()  argument
194 	vm->kvm_fd = _open_kvm_dev_path_or_exit(O_RDWR);  in vm_open()
198 	vm->fd = __kvm_ioctl(vm->kvm_fd, KVM_CREATE_VM, (void *)vm->type);  in vm_open()
199 	TEST_ASSERT(vm->fd >= 0, KVM_IOCTL_ERROR(KVM_CREATE_VM, vm->fd));  in vm_open()
202 		vm->stats.fd = vm_get_stats_fd(vm);  in vm_open()
204 		vm->stats.fd = -1;  in vm_open()
257  * Initializes vm->vpages_valid to match the canonical VA space of the
265 __weak void vm_vaddr_populate_bitmap(struct kvm_vm *vm)  in vm_vaddr_populate_bitmap()  argument
267 	sparsebit_set_num(vm->vpages_valid,  in vm_vaddr_populate_bitmap()
268 		0, (1ULL << (vm->va_bits - 1)) >> vm->page_shift);  in vm_vaddr_populate_bitmap()
269 	sparsebit_set_num(vm->vpages_valid,  in vm_vaddr_populate_bitmap()
270 		(~((1ULL << (vm->va_bits - 1)) - 1)) >> vm->page_shift,  in vm_vaddr_populate_bitmap()
271 		(1ULL << (vm->va_bits - 1)) >> vm->page_shift);  in vm_vaddr_populate_bitmap()
276 	struct kvm_vm *vm;  in ____vm_create()  local
278 	vm = calloc(1, sizeof(*vm));  in ____vm_create()
279 	TEST_ASSERT(vm != NULL, "Insufficient Memory");  in ____vm_create()
281 	INIT_LIST_HEAD(&vm->vcpus);  in ____vm_create()
282 	vm->regions.gpa_tree = RB_ROOT;  in ____vm_create()
283 	vm->regions.hva_tree = RB_ROOT;  in ____vm_create()
284 	hash_init(vm->regions.slot_hash);  in ____vm_create()
286 	vm->mode = shape.mode;  in ____vm_create()
287 	vm->type = shape.type;  in ____vm_create()
289 	vm->pa_bits = vm_guest_mode_params[vm->mode].pa_bits;  in ____vm_create()
290 	vm->va_bits = vm_guest_mode_params[vm->mode].va_bits;  in ____vm_create()
291 	vm->page_size = vm_guest_mode_params[vm->mode].page_size;  in ____vm_create()
292 	vm->page_shift = vm_guest_mode_params[vm->mode].page_shift;  in ____vm_create()
295 	switch (vm->mode) {  in ____vm_create()
297 		vm->pgtable_levels = 4;  in ____vm_create()
300 		vm->pgtable_levels = 3;  in ____vm_create()
303 		vm->pgtable_levels = 4;  in ____vm_create()
306 		vm->pgtable_levels = 3;  in ____vm_create()
310 		vm->pgtable_levels = 4;  in ____vm_create()
314 		vm->pgtable_levels = 3;  in ____vm_create()
320 		vm->pgtable_levels = 4;  in ____vm_create()
323 		vm->pgtable_levels = 3;  in ____vm_create()
327 		kvm_get_cpu_address_width(&vm->pa_bits, &vm->va_bits);  in ____vm_create()
328 		kvm_init_vm_address_properties(vm);  in ____vm_create()
330 		 * Ignore KVM support for 5-level paging (vm->va_bits == 57),  in ____vm_create()
334 		TEST_ASSERT(vm->va_bits == 48 || vm->va_bits == 57,  in ____vm_create()
336 			    vm->va_bits);  in ____vm_create()
338 			 vm->pa_bits);  in ____vm_create()
339 		vm->pgtable_levels = 4;  in ____vm_create()
340 		vm->va_bits = 48;  in ____vm_create()
346 		vm->pgtable_levels = 5;  in ____vm_create()
349 		vm->pgtable_levels = 5;  in ____vm_create()
352 		TEST_FAIL("Unknown guest mode: 0x%x", vm->mode);  in ____vm_create()
356 	TEST_ASSERT(!vm->type, "ARM doesn't support test-provided types");  in ____vm_create()
357 	if (vm->pa_bits != 40)  in ____vm_create()
358 		vm->type = KVM_VM_TYPE_ARM_IPA_SIZE(vm->pa_bits);  in ____vm_create()
361 	vm_open(vm);  in ____vm_create()
364 	vm->vpages_valid = sparsebit_alloc();  in ____vm_create()
365 	vm_vaddr_populate_bitmap(vm);  in ____vm_create()
368 	vm->max_gfn = vm_compute_max_gfn(vm);  in ____vm_create()
371 	vm->vpages_mapped = sparsebit_alloc();  in ____vm_create()
373 	return vm;  in ____vm_create()
392 	 * test code and other per-VM assets that will be loaded into memslot0.  in vm_nr_pages_required()
453 	struct kvm_vm *vm;  in __vm_create()  local
461 	vm = ____vm_create(shape);  in __vm_create()
463 	vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, 0, 0, nr_pages, 0);  in __vm_create()
465 		vm->memslots[i] = 0;  in __vm_create()
467 	kvm_vm_elf_load(vm, program_invocation_name);  in __vm_create()
475 	slot0 = memslot2region(vm, 0);  in __vm_create()
476 	ucall_init(vm, slot0->region.guest_phys_addr + slot0->region.memory_size);  in __vm_create()
483 	sync_global_to_guest(vm, guest_rng);  in __vm_create()
485 	kvm_arch_vm_post_create(vm);  in __vm_create()
487 	return vm;  in __vm_create()
491  * VM Create with customized parameters
494  *   mode - VM Mode (e.g. VM_MODE_P52V48_4K)
503  *   Pointer to opaque structure that describes the created VM.
505  * Creates a VM with the mode specified by mode (e.g. VM_MODE_P52V48_4K).
513 	struct kvm_vm *vm;  in __vm_create_with_vcpus()  local
518 	vm = __vm_create(shape, nr_vcpus, extra_mem_pages);  in __vm_create_with_vcpus()
521 		vcpus[i] = vm_vcpu_add(vm, i, guest_code);  in __vm_create_with_vcpus()
523 	return vm;  in __vm_create_with_vcpus()
532 	struct kvm_vm *vm;  in __vm_create_shape_with_one_vcpu()  local
534 	vm = __vm_create_with_vcpus(shape, 1, extra_mem_pages, guest_code, vcpus);  in __vm_create_shape_with_one_vcpu()
537 	return vm;  in __vm_create_shape_with_one_vcpu()
541  * VM Restart
544  *   vm - VM that has been released before
548  * Reopens the file descriptors associated to the VM and reinstates the
575 __weak struct kvm_vcpu *vm_arch_vcpu_recreate(struct kvm_vm *vm,  in vm_arch_vcpu_recreate()  argument
578 	return __vm_vcpu_add(vm, vcpu_id);  in vm_arch_vcpu_recreate()
581 struct kvm_vcpu *vm_recreate_with_one_vcpu(struct kvm_vm *vm)  in vm_recreate_with_one_vcpu()  argument
583 	kvm_vm_restart(vm);  in vm_recreate_with_one_vcpu()
585 	return vm_vcpu_recreate(vm, 0);  in vm_recreate_with_one_vcpu()
662  *   vm - Virtual Machine
663  *   start - Starting VM physical address
664  *   end - Ending VM physical address, inclusive.
678 userspace_mem_region_find(struct kvm_vm *vm, uint64_t start, uint64_t end)  in userspace_mem_region_find()  argument
682 	for (node = vm->regions.gpa_tree.rb_node; node; ) {  in userspace_mem_region_find()
723  * VM VCPU Remove
732  * Removes a vCPU from a VM and frees its resources.
734 static void vm_vcpu_rm(struct kvm_vm *vm, struct kvm_vcpu *vcpu)  in vm_vcpu_rm()  argument
739 		ret = munmap(vcpu->dirty_gfns, vm->dirty_ring_size);  in vm_vcpu_rm()
776 static void __vm_mem_region_delete(struct kvm_vm *vm,  in __vm_mem_region_delete()  argument
781 	rb_erase(&region->gpa_node, &vm->regions.gpa_tree);  in __vm_mem_region_delete()
782 	rb_erase(&region->hva_node, &vm->regions.hva_tree);  in __vm_mem_region_delete()
802  * Destroys and frees the VM pointed to by vmp.
823 	/* Free the structure describing the VM. */  in kvm_vm_free()
899 int __vm_set_user_memory_region(struct kvm_vm *vm, uint32_t slot, uint32_t flags,  in __vm_set_user_memory_region()  argument
910 	return ioctl(vm->fd, KVM_SET_USER_MEMORY_REGION, &region);  in __vm_set_user_memory_region()
913 void vm_set_user_memory_region(struct kvm_vm *vm, uint32_t slot, uint32_t flags,  in vm_set_user_memory_region()  argument
916 	int ret = __vm_set_user_memory_region(vm, slot, flags, gpa, size, hva);  in vm_set_user_memory_region()
926 int __vm_set_user_memory_region2(struct kvm_vm *vm, uint32_t slot, uint32_t flags,  in __vm_set_user_memory_region2()  argument
942 	return ioctl(vm->fd, KVM_SET_USER_MEMORY_REGION2, &region);  in __vm_set_user_memory_region2()
945 void vm_set_user_memory_region2(struct kvm_vm *vm, uint32_t slot, uint32_t flags,  in vm_set_user_memory_region2()  argument
949 	int ret = __vm_set_user_memory_region2(vm, slot, flags, gpa, size, hva,  in vm_set_user_memory_region2()
958 void vm_mem_add(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,  in vm_mem_add()  argument
965 	size_t mem_size = npages * vm->page_size;  in vm_mem_add()
970 	TEST_ASSERT(vm_adjust_num_guest_pages(vm->mode, npages) == npages,  in vm_mem_add()
972 		"Try npages=%d", vm_adjust_num_guest_pages(vm->mode, npages));  in vm_mem_add()
974 	TEST_ASSERT((guest_paddr % vm->page_size) == 0, "Guest physical "  in vm_mem_add()
976 		"  guest_paddr: 0x%lx vm->page_size: 0x%x",  in vm_mem_add()
977 		guest_paddr, vm->page_size);  in vm_mem_add()
978 	TEST_ASSERT((((guest_paddr >> vm->page_shift) + npages) - 1)  in vm_mem_add()
979 		<= vm->max_gfn, "Physical range beyond maximum "  in vm_mem_add()
982 		"  vm->max_gfn: 0x%lx vm->page_size: 0x%x",  in vm_mem_add()
983 		guest_paddr, npages, vm->max_gfn, vm->page_size);  in vm_mem_add()
990 		vm, guest_paddr, (guest_paddr + npages * vm->page_size) - 1);  in vm_mem_add()
997 			guest_paddr, npages, vm->page_size,  in vm_mem_add()
1002 	hash_for_each_possible(vm->regions.slot_hash, region, slot_node,  in vm_mem_add()
1081 			guest_memfd = vm_create_guest_memfd(vm, mem_size, guest_memfd_flags);  in vm_mem_add()
1100 	if (vm_arch_has_protected_memory(vm))  in vm_mem_add()
1103 		guest_paddr >> vm->page_shift, npages);  in vm_mem_add()
1107 	region->region.memory_size = npages * vm->page_size;  in vm_mem_add()
1109 	ret = __vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);  in vm_mem_add()
1119 	vm_userspace_mem_region_gpa_insert(&vm->regions.gpa_tree, region);  in vm_mem_add()
1120 	vm_userspace_mem_region_hva_insert(&vm->regions.hva_tree, region);  in vm_mem_add()
1121 	hash_add(vm->regions.slot_hash, &region->slot_node, slot);  in vm_mem_add()
1137 void vm_userspace_mem_region_add(struct kvm_vm *vm,  in vm_userspace_mem_region_add()  argument
1142 	vm_mem_add(vm, src_type, guest_paddr, slot, npages, flags, -1, 0);  in vm_userspace_mem_region_add()
1149  *   vm - Virtual Machine
1161 memslot2region(struct kvm_vm *vm, uint32_t memslot)  in memslot2region()  argument
1165 	hash_for_each_possible(vm->regions.slot_hash, region, slot_node,  in memslot2region()
1172 	fputs("---- vm dump ----\n", stderr);  in memslot2region()
1173 	vm_dump(stderr, vm, 2);  in memslot2region()
1179  * VM Memory Region Flags Set
1182  *   vm - Virtual Machine
1192 void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags)  in vm_mem_region_set_flags()  argument
1197 	region = memslot2region(vm, slot);  in vm_mem_region_set_flags()
1201 	ret = __vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);  in vm_mem_region_set_flags()
1209  * VM Memory Region Move
1212  *   vm - Virtual Machine
1222 void vm_mem_region_move(struct kvm_vm *vm, uint32_t slot, uint64_t new_gpa)  in vm_mem_region_move()  argument
1227 	region = memslot2region(vm, slot);  in vm_mem_region_move()
1231 	ret = __vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);  in vm_mem_region_move()
1239  * VM Memory Region Delete
1242  *   vm - Virtual Machine
1251 void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot)  in vm_mem_region_delete()  argument
1253 	struct userspace_mem_region *region = memslot2region(vm, slot);  in vm_mem_region_delete()
1256 	vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);  in vm_mem_region_delete()
1258 	__vm_mem_region_delete(vm, region);  in vm_mem_region_delete()
1261 void vm_guest_mem_fallocate(struct kvm_vm *vm, uint64_t base, uint64_t size,  in vm_guest_mem_fallocate()  argument
1274 		region = userspace_mem_region_find(vm, gpa, gpa);  in vm_guest_mem_fallocate()
1305 static bool vcpu_exists(struct kvm_vm *vm, uint32_t vcpu_id)  in vcpu_exists()  argument
1309 	list_for_each_entry(vcpu, &vm->vcpus, list) {  in vcpu_exists()
1318  * Adds a virtual CPU to the VM specified by vm with the ID given by vcpu_id.
1321 struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id)  in __vm_vcpu_add()  argument
1326 	TEST_ASSERT(!vcpu_exists(vm, vcpu_id), "vCPU%d already exists", vcpu_id);  in __vm_vcpu_add()
1332 	vcpu->vm = vm;  in __vm_vcpu_add()
1334 	vcpu->fd = __vm_ioctl(vm, KVM_CREATE_VCPU, (void *)(unsigned long)vcpu_id);  in __vm_vcpu_add()
1335 	TEST_ASSERT_VM_VCPU_IOCTL(vcpu->fd >= 0, KVM_CREATE_VCPU, vcpu->fd, vm);  in __vm_vcpu_add()
1351 	list_add(&vcpu->list, &vm->vcpus);  in __vm_vcpu_add()
1357  * VM Virtual Address Unused Gap
1360  *   vm - Virtual Machine
1371  * Within the VM specified by vm, locates the lowest starting virtual
1376 vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz,  in vm_vaddr_unused_gap()  argument
1379 	uint64_t pages = (sz + vm->page_size - 1) >> vm->page_shift;  in vm_vaddr_unused_gap()
1382 	uint64_t pgidx_start = (vaddr_min + vm->page_size - 1) >> vm->page_shift;  in vm_vaddr_unused_gap()
1383 	if ((pgidx_start * vm->page_size) < vaddr_min)  in vm_vaddr_unused_gap()
1387 	if (!sparsebit_is_set_num(vm->vpages_valid,  in vm_vaddr_unused_gap()
1389 		pgidx_start = sparsebit_next_set_num(vm->vpages_valid,  in vm_vaddr_unused_gap()
1398 		if (sparsebit_is_clear_num(vm->vpages_mapped,  in vm_vaddr_unused_gap()
1401 		pgidx_start = sparsebit_next_clear_num(vm->vpages_mapped,  in vm_vaddr_unused_gap()
1410 		if (!sparsebit_is_set_num(vm->vpages_valid,  in vm_vaddr_unused_gap()
1413 				vm->vpages_valid, pgidx_start, pages);  in vm_vaddr_unused_gap()
1426 	TEST_ASSERT(sparsebit_is_set_num(vm->vpages_valid,  in vm_vaddr_unused_gap()
1432 	TEST_ASSERT(sparsebit_is_clear_num(vm->vpages_mapped,  in vm_vaddr_unused_gap()
1439 	return pgidx_start * vm->page_size;  in vm_vaddr_unused_gap()
1442 static vm_vaddr_t ____vm_vaddr_alloc(struct kvm_vm *vm, size_t sz,  in ____vm_vaddr_alloc()  argument
1447 	uint64_t pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0);  in ____vm_vaddr_alloc()
1449 	virt_pgd_alloc(vm);  in ____vm_vaddr_alloc()
1450 	vm_paddr_t paddr = __vm_phy_pages_alloc(vm, pages,  in ____vm_vaddr_alloc()
1451 						KVM_UTIL_MIN_PFN * vm->page_size,  in ____vm_vaddr_alloc()
1452 						vm->memslots[type], protected);  in ____vm_vaddr_alloc()
1458 	vm_vaddr_t vaddr_start = vm_vaddr_unused_gap(vm, sz, vaddr_min);  in ____vm_vaddr_alloc()
1462 		pages--, vaddr += vm->page_size, paddr += vm->page_size) {  in ____vm_vaddr_alloc()
1464 		virt_pg_map(vm, vaddr, paddr);  in ____vm_vaddr_alloc()
1466 		sparsebit_set(vm->vpages_mapped, vaddr >> vm->page_shift);  in ____vm_vaddr_alloc()
1472 vm_vaddr_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min,  in __vm_vaddr_alloc()  argument
1475 	return ____vm_vaddr_alloc(vm, sz, vaddr_min, type,  in __vm_vaddr_alloc()
1476 				  vm_arch_has_protected_memory(vm));  in __vm_vaddr_alloc()
1479 vm_vaddr_t vm_vaddr_alloc_shared(struct kvm_vm *vm, size_t sz,  in vm_vaddr_alloc_shared()  argument
1483 	return ____vm_vaddr_alloc(vm, sz, vaddr_min, type, false);  in vm_vaddr_alloc_shared()
1487  * VM Virtual Address Allocate
1490  *   vm - Virtual Machine
1499  * Allocates at least sz bytes within the virtual address space of the vm
1500  * given by vm.  The allocated bytes are mapped to a virtual address >=
1505 vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min)  in vm_vaddr_alloc()  argument
1507 	return __vm_vaddr_alloc(vm, sz, vaddr_min, MEM_REGION_TEST_DATA);  in vm_vaddr_alloc()
1511  * VM Virtual Address Allocate Pages
1514  *   vm - Virtual Machine
1522  * space of the vm.
1524 vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages)  in vm_vaddr_alloc_pages()  argument
1526 	return vm_vaddr_alloc(vm, nr_pages * getpagesize(), KVM_UTIL_MIN_VADDR);  in vm_vaddr_alloc_pages()
1529 vm_vaddr_t __vm_vaddr_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type)  in __vm_vaddr_alloc_page()  argument
1531 	return __vm_vaddr_alloc(vm, getpagesize(), KVM_UTIL_MIN_VADDR, type);  in __vm_vaddr_alloc_page()
1535  * VM Virtual Address Allocate Page
1538  *   vm - Virtual Machine
1546  * space of the vm.
1548 vm_vaddr_t vm_vaddr_alloc_page(struct kvm_vm *vm)  in vm_vaddr_alloc_page()  argument
1550 	return vm_vaddr_alloc_pages(vm, 1);  in vm_vaddr_alloc_page()
1554  * Map a range of VM virtual address to the VM's physical address
1557  *   vm - Virtual Machine
1559  *   paddr - VM Physical Address
1566  * Within the VM given by @vm, creates a virtual translation for
1569 void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,  in virt_map()  argument
1572 	size_t page_size = vm->page_size;  in virt_map()
1579 		virt_pg_map(vm, vaddr, paddr);  in virt_map()
1580 		sparsebit_set(vm->vpages_mapped, vaddr >> vm->page_shift);  in virt_map()
1588  * Address VM Physical to Host Virtual
1591  *   vm - Virtual Machine
1592  *   gpa - VM physical address
1599  * Locates the memory region containing the VM physical address given
1600  * by gpa, within the VM given by vm.  When found, the host virtual
1601  * address providing the memory to the vm physical address is returned.
1604 void *addr_gpa2hva(struct kvm_vm *vm, vm_paddr_t gpa)  in addr_gpa2hva()  argument
1608 	gpa = vm_untag_gpa(vm, gpa);  in addr_gpa2hva()
1610 	region = userspace_mem_region_find(vm, gpa, gpa);  in addr_gpa2hva()
1612 		TEST_FAIL("No vm physical memory at 0x%lx", gpa);  in addr_gpa2hva()
1621  * Address Host Virtual to VM Physical
1624  *   vm - Virtual Machine
1630  *   Equivalent VM physical address
1633  * by hva, within the VM given by vm.  When found, the equivalent
1634  * VM physical address is returned. A TEST_ASSERT failure occurs if no
1637 vm_paddr_t addr_hva2gpa(struct kvm_vm *vm, void *hva)  in addr_hva2gpa()  argument
1641 	for (node = vm->regions.hva_tree.rb_node; node; ) {  in addr_hva2gpa()
1662  * Address VM physical to Host Virtual *alias*.
1665  *   vm - Virtual Machine
1666  *   gpa - VM physical address
1680 void *addr_gpa2alias(struct kvm_vm *vm, vm_paddr_t gpa)  in addr_gpa2alias()  argument
1685 	region = userspace_mem_region_find(vm, gpa, gpa);  in addr_gpa2alias()
1696 /* Create an interrupt controller chip for the specified VM. */
1697 void vm_create_irqchip(struct kvm_vm *vm)  in vm_create_irqchip()  argument
1699 	vm_ioctl(vm, KVM_CREATE_IRQCHIP, NULL);  in vm_create_irqchip()
1701 	vm->has_irqchip = true;  in vm_create_irqchip()
1764 	uint32_t size = vcpu->vm->dirty_ring_size;  in vcpu_map_dirty_ring()
1805 int __kvm_test_create_device(struct kvm_vm *vm, uint64_t type)  in __kvm_test_create_device()  argument
1812 	return __vm_ioctl(vm, KVM_CREATE_DEVICE, &create_dev);  in __kvm_test_create_device()
1815 int __kvm_create_device(struct kvm_vm *vm, uint64_t type)  in __kvm_create_device()  argument
1824 	err = __vm_ioctl(vm, KVM_CREATE_DEVICE, &create_dev);  in __kvm_create_device()
1857 int _kvm_irq_line(struct kvm_vm *vm, uint32_t irq, int level)  in _kvm_irq_line()  argument
1864 	return __vm_ioctl(vm, KVM_IRQ_LINE, &irq_level);  in _kvm_irq_line()
1867 void kvm_irq_line(struct kvm_vm *vm, uint32_t irq, int level)  in kvm_irq_line()  argument
1869 	int ret = _kvm_irq_line(vm, irq, level);  in kvm_irq_line()
1905 int _kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing)  in _kvm_gsi_routing_write()  argument
1910 	ret = __vm_ioctl(vm, KVM_SET_GSI_ROUTING, routing);  in _kvm_gsi_routing_write()
1916 void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing)  in kvm_gsi_routing_write()  argument
1920 	ret = _kvm_gsi_routing_write(vm, routing);  in kvm_gsi_routing_write()
1925  * VM Dump
1928  *   vm - Virtual Machine
1936  * Dumps the current state of the VM given by vm, to the FILE stream
1939 void vm_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent)  in vm_dump()  argument
1945 	fprintf(stream, "%*smode: 0x%x\n", indent, "", vm->mode);  in vm_dump()
1946 	fprintf(stream, "%*sfd: %i\n", indent, "", vm->fd);  in vm_dump()
1947 	fprintf(stream, "%*spage_size: 0x%x\n", indent, "", vm->page_size);  in vm_dump()
1949 	hash_for_each(vm->regions.slot_hash, ctr, region, slot_node) {  in vm_dump()
1963 	sparsebit_dump(stream, vm->vpages_mapped, indent + 2);  in vm_dump()
1965 		vm->pgd_created);  in vm_dump()
1966 	if (vm->pgd_created) {  in vm_dump()
1969 		virt_dump(stream, vm, indent + 4);  in vm_dump()
1973 	list_for_each_entry(vcpu, &vm->vcpus, list)  in vm_dump()
2057  *   vm - Virtual Machine
2068  * Within the VM specified by vm, locates a range of available physical
2073 vm_paddr_t __vm_phy_pages_alloc(struct kvm_vm *vm, size_t num,  in __vm_phy_pages_alloc()  argument
2082 	TEST_ASSERT((paddr_min % vm->page_size) == 0, "Min physical address "  in __vm_phy_pages_alloc()
2085 		paddr_min, vm->page_size);  in __vm_phy_pages_alloc()
2087 	region = memslot2region(vm, memslot);  in __vm_phy_pages_alloc()
2091 	base = pg = paddr_min >> vm->page_shift;  in __vm_phy_pages_alloc()
2104 			paddr_min, vm->page_size, memslot);  in __vm_phy_pages_alloc()
2105 		fputs("---- vm dump ----\n", stderr);  in __vm_phy_pages_alloc()
2106 		vm_dump(stderr, vm, 2);  in __vm_phy_pages_alloc()
2116 	return base * vm->page_size;  in __vm_phy_pages_alloc()
2119 vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,  in vm_phy_page_alloc()  argument
2122 	return vm_phy_pages_alloc(vm, 1, paddr_min, memslot);  in vm_phy_page_alloc()
2125 vm_paddr_t vm_alloc_page_table(struct kvm_vm *vm)  in vm_alloc_page_table()  argument
2127 	return vm_phy_page_alloc(vm, KVM_GUEST_PAGE_TABLE_MIN_PADDR,  in vm_alloc_page_table()
2128 				 vm->memslots[MEM_REGION_PT]);  in vm_alloc_page_table()
2135  *   vm - Virtual Machine
2136  *   gva - VM virtual address
2143 void *addr_gva2hva(struct kvm_vm *vm, vm_vaddr_t gva)  in addr_gva2hva()  argument
2145 	return addr_gpa2hva(vm, addr_gva2gpa(vm, gva));  in addr_gva2hva()
2148 unsigned long __weak vm_compute_max_gfn(struct kvm_vm *vm)  in vm_compute_max_gfn()  argument
2150 	return ((1ULL << vm->pa_bits) >> vm->page_shift) - 1;  in vm_compute_max_gfn()
2288 __weak void kvm_arch_vm_post_create(struct kvm_vm *vm)  in kvm_arch_vm_post_create()  argument
2307 bool vm_is_gpa_protected(struct kvm_vm *vm, vm_paddr_t paddr)  in vm_is_gpa_protected()  argument
2312 	if (!vm_arch_has_protected_memory(vm))  in vm_is_gpa_protected()
2315 	region = userspace_mem_region_find(vm, paddr, paddr);  in vm_is_gpa_protected()
2316 	TEST_ASSERT(region, "No vm physical memory at 0x%lx", paddr);  in vm_is_gpa_protected()
2318 	pg = paddr >> vm->page_shift;  in vm_is_gpa_protected()