projects/linux·blob master · refs

1309 lines · 34.0 KiB

1/* SPDX-License-Identifier: GPL-2.0-only */
2/*
3 * Copyright (C) 2018, Google LLC.
4 */
5#ifndef SELFTEST_KVM_UTIL_H
6#define SELFTEST_KVM_UTIL_H
7
8#include "test_util.h"
9
10#include <linux/compiler.h>
11#include "linux/hashtable.h"
12#include "linux/list.h"
13#include <linux/kernel.h>
14#include <linux/kvm.h>
15#include "linux/rbtree.h"
16#include <linux/types.h>
17
18#include <asm/atomic.h>
19#include <asm/kvm.h>
20
21#include <sys/eventfd.h>
22#include <sys/ioctl.h>
23
24#include <pthread.h>
25
26#include "kvm_syscalls.h"
27#include "kvm_util_arch.h"
28#include "kvm_util_types.h"
29#include "sparsebit.h"
30
31#define KVM_DEV_PATH "/dev/kvm"
32#define KVM_MAX_VCPUS 512
33
34#define NSEC_PER_SEC 1000000000L
35
36struct userspace_mem_region {
37 struct kvm_userspace_memory_region2 region;
38 struct sparsebit *unused_phy_pages;
39 struct sparsebit *protected_phy_pages;
40 int fd;
41 off_t offset;
42 enum vm_mem_backing_src_type backing_src_type;
43 void *host_mem;
44 void *host_alias;
45 void *mmap_start;
46 void *mmap_alias;
47 size_t mmap_size;
48 struct rb_node gpa_node;
49 struct rb_node hva_node;
50 struct hlist_node slot_node;
51};
52
53struct kvm_binary_stats {
54 int fd;
55 struct kvm_stats_header header;
56 struct kvm_stats_desc *desc;
57};
58
59struct kvm_vcpu {
60 struct list_head list;
61 u32 id;
62 int fd;
63 struct kvm_vm *vm;
64 struct kvm_run *run;
65#ifdef __x86_64__
66 struct kvm_cpuid2 *cpuid;
67#endif
68#ifdef __aarch64__
69 struct kvm_vcpu_init init;
70#endif
71 struct kvm_binary_stats stats;
72 struct kvm_dirty_gfn *dirty_gfns;
73 u32 fetch_index;
74 u32 dirty_gfns_count;
75};
76
77struct userspace_mem_regions {
78 struct rb_root gpa_tree;
79 struct rb_root hva_tree;
80 DECLARE_HASHTABLE(slot_hash, 9);
81};
82
83enum kvm_mem_region_type {
84 MEM_REGION_CODE,
85 MEM_REGION_DATA,
86 MEM_REGION_PT,
87 MEM_REGION_TEST_DATA,
88 NR_MEM_REGIONS,
89};
90
91struct kvm_mmu {
92 bool pgd_created;
93 u64 pgd;
94 int pgtable_levels;
95
96 struct kvm_mmu_arch arch;
97};
98
99struct kvm_vm {
100 int mode;
101 unsigned long type;
102 int kvm_fd;
103 int fd;
104 unsigned int page_size;
105 unsigned int page_shift;
106 unsigned int pa_bits;
107 unsigned int va_bits;
108 u64 max_gfn;
109 struct list_head vcpus;
110 struct userspace_mem_regions regions;
111 struct sparsebit *vpages_valid;
112 struct sparsebit *vpages_mapped;
113 bool has_irqchip;
114 gpa_t ucall_mmio_addr;
115 gva_t handlers;
116 u32 dirty_ring_size;
117 gpa_t gpa_tag_mask;
118
119 /*
120 * "mmu" is the guest's stage-1, with a short name because the vast
121 * majority of tests only care about the stage-1 MMU.
122 */
123 struct kvm_mmu mmu;
124 struct kvm_mmu stage2_mmu;
125
126 struct kvm_vm_arch arch;
127
128 struct kvm_binary_stats stats;
129
130 /*
131 * KVM region slots. These are the default memslots used by page
132 * allocators, e.g., lib/elf uses the memslots[MEM_REGION_CODE]
133 * memslot.
134 */
135 u32 memslots[NR_MEM_REGIONS];
136};
137
138struct vcpu_reg_sublist {
139 const char *name;
140 long capability;
141 int feature;
142 int feature_type;
143 bool finalize;
144 __u64 *regs;
145 __u64 regs_n;
146 __u64 *rejects_set;
147 __u64 rejects_set_n;
148 __u64 *skips_set;
149 __u64 skips_set_n;
150};
151
152struct vcpu_reg_list {
153 char *name;
154 struct vcpu_reg_sublist sublists[];
155};
156
157#define for_each_sublist(c, s) \
158 for ((s) = &(c)->sublists[0]; (s)->regs; ++(s))
159
160#define kvm_for_each_vcpu(vm, i, vcpu) \
161 for ((i) = 0; (i) <= (vm)->last_vcpu_id; (i)++) \
162 if (!((vcpu) = vm->vcpus[i])) \
163 continue; \
164 else
165
166struct userspace_mem_region *
167memslot2region(struct kvm_vm *vm, u32 memslot);
168
169static inline struct userspace_mem_region *vm_get_mem_region(struct kvm_vm *vm,
170 enum kvm_mem_region_type type)
171{
172 assert(type < NR_MEM_REGIONS);
173 return memslot2region(vm, vm->memslots[type]);
174}
175
176/* Minimum allocated guest virtual and physical addresses */
177#define KVM_UTIL_MIN_VADDR 0x2000
178#define KVM_GUEST_PAGE_TABLE_MIN_PADDR 0x180000
179
180#define DEFAULT_GUEST_STACK_VADDR_MIN 0xab6000
181#define DEFAULT_STACK_PGS 5
182
183enum vm_guest_mode {
184 VM_MODE_P52V48_4K,
185 VM_MODE_P52V48_16K,
186 VM_MODE_P52V48_64K,
187 VM_MODE_P48V48_4K,
188 VM_MODE_P48V48_16K,
189 VM_MODE_P48V48_64K,
190 VM_MODE_P40V48_4K,
191 VM_MODE_P40V48_16K,
192 VM_MODE_P40V48_64K,
193 VM_MODE_PXXVYY_4K, /* For 48-bit or 57-bit VA, depending on host support */
194 VM_MODE_P47V64_4K,
195 VM_MODE_P44V64_4K,
196 VM_MODE_P36V48_4K,
197 VM_MODE_P36V48_16K,
198 VM_MODE_P36V48_64K,
199 VM_MODE_P47V47_16K,
200 VM_MODE_P36V47_16K,
201
202 VM_MODE_P56V57_4K, /* For riscv64 */
203 VM_MODE_P56V48_4K,
204 VM_MODE_P56V39_4K,
205 VM_MODE_P50V57_4K,
206 VM_MODE_P50V48_4K,
207 VM_MODE_P50V39_4K,
208 VM_MODE_P41V57_4K,
209 VM_MODE_P41V48_4K,
210 VM_MODE_P41V39_4K,
211
212 NUM_VM_MODES,
213};
214
215struct vm_shape {
216 u32 type;
217 u8 mode;
218 u8 pad0;
219 u16 pad1;
220};
221
222kvm_static_assert(sizeof(struct vm_shape) == sizeof(u64));
223
224#define VM_TYPE_DEFAULT 0
225
226#define VM_SHAPE(__mode) \
227({ \
228 struct vm_shape shape = { \
229 .mode = (__mode), \
230 .type = VM_TYPE_DEFAULT \
231 }; \
232 \
233 shape; \
234})
235
236extern enum vm_guest_mode vm_mode_default;
237
238#if defined(__aarch64__)
239
240#define VM_MODE_DEFAULT vm_mode_default
241#define MIN_PAGE_SHIFT 12U
242#define ptes_per_page(page_size) ((page_size) / 8)
243
244#elif defined(__x86_64__)
245
246#define VM_MODE_DEFAULT VM_MODE_PXXVYY_4K
247#define MIN_PAGE_SHIFT 12U
248#define ptes_per_page(page_size) ((page_size) / 8)
249
250#elif defined(__s390x__)
251
252#define VM_MODE_DEFAULT VM_MODE_P44V64_4K
253#define MIN_PAGE_SHIFT 12U
254#define ptes_per_page(page_size) ((page_size) / 16)
255
256#elif defined(__riscv)
257
258#if __riscv_xlen == 32
259#error "RISC-V 32-bit kvm selftests not supported"
260#endif
261
262#define VM_MODE_DEFAULT vm_mode_default
263#define MIN_PAGE_SHIFT 12U
264#define ptes_per_page(page_size) ((page_size) / 8)
265
266#elif defined(__loongarch__)
267#define VM_MODE_DEFAULT VM_MODE_P47V47_16K
268#define MIN_PAGE_SHIFT 12U
269#define ptes_per_page(page_size) ((page_size) / 8)
270
271#endif
272
273#define VM_SHAPE_DEFAULT VM_SHAPE(VM_MODE_DEFAULT)
274
275#define MIN_PAGE_SIZE (1U << MIN_PAGE_SHIFT)
276#define PTES_PER_MIN_PAGE ptes_per_page(MIN_PAGE_SIZE)
277
278struct vm_guest_mode_params {
279 unsigned int pa_bits;
280 unsigned int va_bits;
281 unsigned int page_size;
282 unsigned int page_shift;
283};
284extern const struct vm_guest_mode_params vm_guest_mode_params[];
285
286int __open_path_or_exit(const char *path, int flags, const char *enoent_help);
287int open_path_or_exit(const char *path, int flags);
288int open_kvm_dev_path_or_exit(void);
289
290int kvm_get_module_param_integer(const char *module_name, const char *param);
291bool kvm_get_module_param_bool(const char *module_name, const char *param);
292
293static inline bool get_kvm_param_bool(const char *param)
294{
295 return kvm_get_module_param_bool("kvm", param);
296}
297
298static inline int get_kvm_param_integer(const char *param)
299{
300 return kvm_get_module_param_integer("kvm", param);
301}
302
303unsigned int kvm_check_cap(long cap);
304
305static inline bool kvm_has_cap(long cap)
306{
307 return kvm_check_cap(cap);
308}
309
310/*
311 * Use the "inner", double-underscore macro when reporting errors from within
312 * other macros so that the name of ioctl() and not its literal numeric value
313 * is printed on error. The "outer" macro is strongly preferred when reporting
314 * errors "directly", i.e. without an additional layer of macros, as it reduces
315 * the probability of passing in the wrong string.
316 */
317#define __KVM_IOCTL_ERROR(_name, _ret) __KVM_SYSCALL_ERROR(_name, _ret)
318#define KVM_IOCTL_ERROR(_ioctl, _ret) __KVM_IOCTL_ERROR(#_ioctl, _ret)
319
320#define kvm_do_ioctl(fd, cmd, arg) \
321({ \
322 kvm_static_assert(!_IOC_SIZE(cmd) || sizeof(*arg) == _IOC_SIZE(cmd)); \
323 ioctl(fd, cmd, arg); \
324})
325
326#define __kvm_ioctl(kvm_fd, cmd, arg) \
327 kvm_do_ioctl(kvm_fd, cmd, arg)
328
329#define kvm_ioctl(kvm_fd, cmd, arg) \
330({ \
331 int ret = __kvm_ioctl(kvm_fd, cmd, arg); \
332 \
333 TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(#cmd, ret)); \
334})
335
336static __always_inline void static_assert_is_vm(struct kvm_vm *vm) { }
337
338#define __vm_ioctl(vm, cmd, arg) \
339({ \
340 static_assert_is_vm(vm); \
341 kvm_do_ioctl((vm)->fd, cmd, arg); \
342})
343
344/*
345 * Assert that a VM or vCPU ioctl() succeeded, with extra magic to detect if
346 * the ioctl() failed because KVM killed/bugged the VM. To detect a dead VM,
347 * probe KVM_CAP_USER_MEMORY, which (a) has been supported by KVM since before
348 * selftests existed and (b) should never outright fail, i.e. is supposed to
349 * return 0 or 1. If KVM kills a VM, KVM returns -EIO for all ioctl()s for the
350 * VM and its vCPUs, including KVM_CHECK_EXTENSION.
351 */
352#define __TEST_ASSERT_VM_VCPU_IOCTL(cond, name, ret, vm) \
353do { \
354 int __errno = errno; \
355 \
356 static_assert_is_vm(vm); \
357 \
358 if (cond) \
359 break; \
360 \
361 if (errno == EIO && \
362 __vm_ioctl(vm, KVM_CHECK_EXTENSION, (void *)KVM_CAP_USER_MEMORY) < 0) { \
363 TEST_ASSERT(errno == EIO, "KVM killed the VM, should return -EIO"); \
364 TEST_FAIL("KVM killed/bugged the VM, check the kernel log for clues"); \
365 } \
366 errno = __errno; \
367 TEST_ASSERT(cond, __KVM_IOCTL_ERROR(name, ret)); \
368} while (0)
369
370#define TEST_ASSERT_VM_VCPU_IOCTL(cond, cmd, ret, vm) \
371 __TEST_ASSERT_VM_VCPU_IOCTL(cond, #cmd, ret, vm)
372
373#define vm_ioctl(vm, cmd, arg) \
374({ \
375 int ret = __vm_ioctl(vm, cmd, arg); \
376 \
377 __TEST_ASSERT_VM_VCPU_IOCTL(!ret, #cmd, ret, vm); \
378})
379
380static __always_inline void static_assert_is_vcpu(struct kvm_vcpu *vcpu) { }
381
382#define __vcpu_ioctl(vcpu, cmd, arg) \
383({ \
384 static_assert_is_vcpu(vcpu); \
385 kvm_do_ioctl((vcpu)->fd, cmd, arg); \
386})
387
388#define vcpu_ioctl(vcpu, cmd, arg) \
389({ \
390 int ret = __vcpu_ioctl(vcpu, cmd, arg); \
391 \
392 __TEST_ASSERT_VM_VCPU_IOCTL(!ret, #cmd, ret, (vcpu)->vm); \
393})
394
395/*
396 * Looks up and returns the value corresponding to the capability
397 * (KVM_CAP_*) given by cap.
398 */
399static inline int vm_check_cap(struct kvm_vm *vm, long cap)
400{
401 int ret = __vm_ioctl(vm, KVM_CHECK_EXTENSION, (void *)cap);
402
403 TEST_ASSERT_VM_VCPU_IOCTL(ret >= 0, KVM_CHECK_EXTENSION, ret, vm);
404 return ret;
405}
406
407static inline int __vm_enable_cap(struct kvm_vm *vm, u32 cap, u64 arg0)
408{
409 struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
410
411 return __vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
412}
413
414static inline void vm_enable_cap(struct kvm_vm *vm, u32 cap, u64 arg0)
415{
416 struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
417
418 vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
419}
420
421static inline void vm_set_memory_attributes(struct kvm_vm *vm, gpa_t gpa,
422 u64 size, u64 attributes)
423{
424 struct kvm_memory_attributes attr = {
425 .attributes = attributes,
426 .address = gpa,
427 .size = size,
428 .flags = 0,
429 };
430
431 /*
432 * KVM_SET_MEMORY_ATTRIBUTES overwrites _all_ attributes. These flows
433 * need significant enhancements to support multiple attributes.
434 */
435 TEST_ASSERT(!attributes || attributes == KVM_MEMORY_ATTRIBUTE_PRIVATE,
436 "Update me to support multiple attributes!");
437
438 vm_ioctl(vm, KVM_SET_MEMORY_ATTRIBUTES, &attr);
439}
440
441
442static inline void vm_mem_set_private(struct kvm_vm *vm, gpa_t gpa,
443 u64 size)
444{
445 vm_set_memory_attributes(vm, gpa, size, KVM_MEMORY_ATTRIBUTE_PRIVATE);
446}
447
448static inline void vm_mem_set_shared(struct kvm_vm *vm, gpa_t gpa,
449 u64 size)
450{
451 vm_set_memory_attributes(vm, gpa, size, 0);
452}
453
454void vm_guest_mem_fallocate(struct kvm_vm *vm, gpa_t gpa, u64 size,
455 bool punch_hole);
456
457static inline void vm_guest_mem_punch_hole(struct kvm_vm *vm, gpa_t gpa,
458 u64 size)
459{
460 vm_guest_mem_fallocate(vm, gpa, size, true);
461}
462
463static inline void vm_guest_mem_allocate(struct kvm_vm *vm, gpa_t gpa,
464 u64 size)
465{
466 vm_guest_mem_fallocate(vm, gpa, size, false);
467}
468
469void vm_enable_dirty_ring(struct kvm_vm *vm, u32 ring_size);
470const char *vm_guest_mode_string(u32 i);
471
472void kvm_vm_free(struct kvm_vm *vmp);
473void kvm_vm_restart(struct kvm_vm *vmp);
474void kvm_vm_release(struct kvm_vm *vmp);
475void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename);
476int kvm_memfd_alloc(size_t size, bool hugepages);
477
478void vm_dump(FILE *stream, struct kvm_vm *vm, u8 indent);
479
480static inline void kvm_vm_get_dirty_log(struct kvm_vm *vm, int slot, void *log)
481{
482 struct kvm_dirty_log args = { .dirty_bitmap = log, .slot = slot };
483
484 vm_ioctl(vm, KVM_GET_DIRTY_LOG, &args);
485}
486
487static inline void kvm_vm_clear_dirty_log(struct kvm_vm *vm, int slot, void *log,
488 u64 first_page, u32 num_pages)
489{
490 struct kvm_clear_dirty_log args = {
491 .dirty_bitmap = log,
492 .slot = slot,
493 .first_page = first_page,
494 .num_pages = num_pages
495 };
496
497 vm_ioctl(vm, KVM_CLEAR_DIRTY_LOG, &args);
498}
499
500static inline u32 kvm_vm_reset_dirty_ring(struct kvm_vm *vm)
501{
502 return __vm_ioctl(vm, KVM_RESET_DIRTY_RINGS, NULL);
503}
504
505static inline void kvm_vm_register_coalesced_io(struct kvm_vm *vm,
506 u64 address,
507 u64 size, bool pio)
508{
509 struct kvm_coalesced_mmio_zone zone = {
510 .addr = address,
511 .size = size,
512 .pio = pio,
513 };
514
515 vm_ioctl(vm, KVM_REGISTER_COALESCED_MMIO, &zone);
516}
517
518static inline void kvm_vm_unregister_coalesced_io(struct kvm_vm *vm,
519 u64 address,
520 u64 size, bool pio)
521{
522 struct kvm_coalesced_mmio_zone zone = {
523 .addr = address,
524 .size = size,
525 .pio = pio,
526 };
527
528 vm_ioctl(vm, KVM_UNREGISTER_COALESCED_MMIO, &zone);
529}
530
531static inline int vm_get_stats_fd(struct kvm_vm *vm)
532{
533 int fd = __vm_ioctl(vm, KVM_GET_STATS_FD, NULL);
534
535 TEST_ASSERT_VM_VCPU_IOCTL(fd >= 0, KVM_GET_STATS_FD, fd, vm);
536 return fd;
537}
538
539static inline int __kvm_irqfd(struct kvm_vm *vm, u32 gsi, int eventfd,
540 u32 flags)
541{
542 struct kvm_irqfd irqfd = {
543 .fd = eventfd,
544 .gsi = gsi,
545 .flags = flags,
546 .resamplefd = -1,
547 };
548
549 return __vm_ioctl(vm, KVM_IRQFD, &irqfd);
550}
551
552static inline void kvm_irqfd(struct kvm_vm *vm, u32 gsi, int eventfd, u32 flags)
553{
554 int ret = __kvm_irqfd(vm, gsi, eventfd, flags);
555
556 TEST_ASSERT_VM_VCPU_IOCTL(!ret, KVM_IRQFD, ret, vm);
557}
558
559static inline void kvm_assign_irqfd(struct kvm_vm *vm, u32 gsi, int eventfd)
560{
561 kvm_irqfd(vm, gsi, eventfd, 0);
562}
563
564static inline void kvm_deassign_irqfd(struct kvm_vm *vm, u32 gsi, int eventfd)
565{
566 kvm_irqfd(vm, gsi, eventfd, KVM_IRQFD_FLAG_DEASSIGN);
567}
568
569static inline int kvm_new_eventfd(void)
570{
571 int fd = eventfd(0, 0);
572
573 TEST_ASSERT(fd >= 0, __KVM_SYSCALL_ERROR("eventfd()", fd));
574 return fd;
575}
576
577static inline void read_stats_header(int stats_fd, struct kvm_stats_header *header)
578{
579 ssize_t ret;
580
581 ret = pread(stats_fd, header, sizeof(*header), 0);
582 TEST_ASSERT(ret == sizeof(*header),
583 "Failed to read '%lu' header bytes, ret = '%ld'",
584 sizeof(*header), ret);
585}
586
587struct kvm_stats_desc *read_stats_descriptors(int stats_fd,
588 struct kvm_stats_header *header);
589
590static inline ssize_t get_stats_descriptor_size(struct kvm_stats_header *header)
591{
592 /*
593 * The base size of the descriptor is defined by KVM's ABI, but the
594 * size of the name field is variable, as far as KVM's ABI is
595 * concerned. For a given instance of KVM, the name field is the same
596 * size for all stats and is provided in the overall stats header.
597 */
598 return sizeof(struct kvm_stats_desc) + header->name_size;
599}
600
601static inline struct kvm_stats_desc *get_stats_descriptor(struct kvm_stats_desc *stats,
602 int index,
603 struct kvm_stats_header *header)
604{
605 /*
606 * Note, size_desc includes the size of the name field, which is
607 * variable. i.e. this is NOT equivalent to &stats_desc[i].
608 */
609 return (void *)stats + index * get_stats_descriptor_size(header);
610}
611
612void read_stat_data(int stats_fd, struct kvm_stats_header *header,
613 struct kvm_stats_desc *desc, u64 *data,
614 size_t max_elements);
615
616void kvm_get_stat(struct kvm_binary_stats *stats, const char *name,
617 u64 *data, size_t max_elements);
618
619#define __get_stat(stats, stat) \
620({ \
621 u64 data; \
622 \
623 kvm_get_stat(stats, #stat, &data, 1); \
624 data; \
625})
626
627#define vm_get_stat(vm, stat) __get_stat(&(vm)->stats, stat)
628#define vcpu_get_stat(vcpu, stat) __get_stat(&(vcpu)->stats, stat)
629
630static inline bool read_smt_control(char *buf, size_t buf_size)
631{
632 FILE *f = fopen("/sys/devices/system/cpu/smt/control", "r");
633 bool ret;
634
635 if (!f)
636 return false;
637
638 ret = fread(buf, sizeof(*buf), buf_size, f) > 0;
639 fclose(f);
640
641 return ret;
642}
643
644static inline bool is_smt_possible(void)
645{
646 char buf[16];
647
648 if (read_smt_control(buf, sizeof(buf)) &&
649 (!strncmp(buf, "forceoff", 8) || !strncmp(buf, "notsupported", 12)))
650 return false;
651
652 return true;
653}
654
655static inline bool is_smt_on(void)
656{
657 char buf[16];
658
659 if (read_smt_control(buf, sizeof(buf)) && !strncmp(buf, "on", 2))
660 return true;
661
662 return false;
663}
664
665void vm_create_irqchip(struct kvm_vm *vm);
666
667static inline int __vm_create_guest_memfd(struct kvm_vm *vm, u64 size,
668 u64 flags)
669{
670 struct kvm_create_guest_memfd guest_memfd = {
671 .size = size,
672 .flags = flags,
673 };
674
675 return __vm_ioctl(vm, KVM_CREATE_GUEST_MEMFD, &guest_memfd);
676}
677
678static inline int vm_create_guest_memfd(struct kvm_vm *vm, u64 size,
679 u64 flags)
680{
681 int fd = __vm_create_guest_memfd(vm, size, flags);
682
683 TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_CREATE_GUEST_MEMFD, fd));
684 return fd;
685}
686
687void vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
688 gpa_t gpa, u64 size, void *hva);
689int __vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
690 gpa_t gpa, u64 size, void *hva);
691void vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
692 gpa_t gpa, u64 size, void *hva,
693 u32 guest_memfd, u64 guest_memfd_offset);
694int __vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
695 gpa_t gpa, u64 size, void *hva,
696 u32 guest_memfd, u64 guest_memfd_offset);
697
698void vm_userspace_mem_region_add(struct kvm_vm *vm,
699 enum vm_mem_backing_src_type src_type,
700 gpa_t gpa, u32 slot, u64 npages, u32 flags);
701void vm_mem_add(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,
702 gpa_t gpa, u32 slot, u64 npages, u32 flags,
703 int guest_memfd_fd, u64 guest_memfd_offset);
704
705#ifndef vm_arch_has_protected_memory
706static inline bool vm_arch_has_protected_memory(struct kvm_vm *vm)
707{
708 return false;
709}
710#endif
711
712void vm_mem_region_set_flags(struct kvm_vm *vm, u32 slot, u32 flags);
713void vm_mem_region_reload(struct kvm_vm *vm, u32 slot);
714void vm_mem_region_move(struct kvm_vm *vm, u32 slot, u64 new_gpa);
715void vm_mem_region_delete(struct kvm_vm *vm, u32 slot);
716struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, u32 vcpu_id);
717void vm_populate_gva_bitmap(struct kvm_vm *vm);
718gva_t vm_unused_gva_gap(struct kvm_vm *vm, size_t sz, gva_t min_gva);
719gva_t vm_alloc(struct kvm_vm *vm, size_t sz, gva_t min_gva);
720gva_t __vm_alloc(struct kvm_vm *vm, size_t sz, gva_t min_gva,
721 enum kvm_mem_region_type type);
722gva_t vm_alloc_shared(struct kvm_vm *vm, size_t sz, gva_t min_gva,
723 enum kvm_mem_region_type type);
724gva_t vm_alloc_pages(struct kvm_vm *vm, int nr_pages);
725gva_t __vm_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type);
726gva_t vm_alloc_page(struct kvm_vm *vm);
727
728void virt_map(struct kvm_vm *vm, gva_t gva, gpa_t gpa,
729 unsigned int npages);
730void *addr_gpa2hva(struct kvm_vm *vm, gpa_t gpa);
731void *addr_gva2hva(struct kvm_vm *vm, gva_t gva);
732gpa_t addr_hva2gpa(struct kvm_vm *vm, void *hva);
733void *addr_gpa2alias(struct kvm_vm *vm, gpa_t gpa);
734
735#ifndef vcpu_arch_put_guest
736#define vcpu_arch_put_guest(mem, val) do { (mem) = (val); } while (0)
737#endif
738
739static inline gpa_t vm_untag_gpa(struct kvm_vm *vm, gpa_t gpa)
740{
741 return gpa & ~vm->gpa_tag_mask;
742}
743
744void vcpu_run(struct kvm_vcpu *vcpu);
745int _vcpu_run(struct kvm_vcpu *vcpu);
746
747static inline int __vcpu_run(struct kvm_vcpu *vcpu)
748{
749 return __vcpu_ioctl(vcpu, KVM_RUN, NULL);
750}
751
752void vcpu_run_complete_io(struct kvm_vcpu *vcpu);
753struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vcpu *vcpu);
754
755static inline void vcpu_enable_cap(struct kvm_vcpu *vcpu, u32 cap,
756 u64 arg0)
757{
758 struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
759
760 vcpu_ioctl(vcpu, KVM_ENABLE_CAP, &enable_cap);
761}
762
763static inline void vcpu_guest_debug_set(struct kvm_vcpu *vcpu,
764 struct kvm_guest_debug *debug)
765{
766 vcpu_ioctl(vcpu, KVM_SET_GUEST_DEBUG, debug);
767}
768
769static inline void vcpu_mp_state_get(struct kvm_vcpu *vcpu,
770 struct kvm_mp_state *mp_state)
771{
772 vcpu_ioctl(vcpu, KVM_GET_MP_STATE, mp_state);
773}
774static inline void vcpu_mp_state_set(struct kvm_vcpu *vcpu,
775 struct kvm_mp_state *mp_state)
776{
777 vcpu_ioctl(vcpu, KVM_SET_MP_STATE, mp_state);
778}
779
780static inline void vcpu_regs_get(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
781{
782 vcpu_ioctl(vcpu, KVM_GET_REGS, regs);
783}
784
785static inline void vcpu_regs_set(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
786{
787 vcpu_ioctl(vcpu, KVM_SET_REGS, regs);
788}
789static inline void vcpu_sregs_get(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
790{
791 vcpu_ioctl(vcpu, KVM_GET_SREGS, sregs);
792
793}
794static inline void vcpu_sregs_set(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
795{
796 vcpu_ioctl(vcpu, KVM_SET_SREGS, sregs);
797}
798static inline int _vcpu_sregs_set(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
799{
800 return __vcpu_ioctl(vcpu, KVM_SET_SREGS, sregs);
801}
802static inline void vcpu_fpu_get(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
803{
804 vcpu_ioctl(vcpu, KVM_GET_FPU, fpu);
805}
806static inline void vcpu_fpu_set(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
807{
808 vcpu_ioctl(vcpu, KVM_SET_FPU, fpu);
809}
810
811static inline int __vcpu_get_reg(struct kvm_vcpu *vcpu, u64 id, void *addr)
812{
813 struct kvm_one_reg reg = { .id = id, .addr = (u64)addr };
814
815 return __vcpu_ioctl(vcpu, KVM_GET_ONE_REG, &reg);
816}
817
818static inline int __vcpu_set_reg(struct kvm_vcpu *vcpu, u64 id, u64 val)
819{
820 struct kvm_one_reg reg = { .id = id, .addr = (u64)&val };
821
822 return __vcpu_ioctl(vcpu, KVM_SET_ONE_REG, &reg);
823}
824
825static inline u64 vcpu_get_reg(struct kvm_vcpu *vcpu, u64 id)
826{
827 u64 val;
828 struct kvm_one_reg reg = { .id = id, .addr = (u64)&val };
829
830 TEST_ASSERT(KVM_REG_SIZE(id) <= sizeof(val), "Reg %lx too big", id);
831
832 vcpu_ioctl(vcpu, KVM_GET_ONE_REG, &reg);
833 return val;
834}
835
836static inline void vcpu_set_reg(struct kvm_vcpu *vcpu, u64 id, u64 val)
837{
838 struct kvm_one_reg reg = { .id = id, .addr = (u64)&val };
839
840 TEST_ASSERT(KVM_REG_SIZE(id) <= sizeof(val), "Reg %lx too big", id);
841
842 vcpu_ioctl(vcpu, KVM_SET_ONE_REG, &reg);
843}
844
845#ifdef __KVM_HAVE_VCPU_EVENTS
846static inline void vcpu_events_get(struct kvm_vcpu *vcpu,
847 struct kvm_vcpu_events *events)
848{
849 vcpu_ioctl(vcpu, KVM_GET_VCPU_EVENTS, events);
850}
851static inline void vcpu_events_set(struct kvm_vcpu *vcpu,
852 struct kvm_vcpu_events *events)
853{
854 vcpu_ioctl(vcpu, KVM_SET_VCPU_EVENTS, events);
855}
856#endif
857#ifdef __x86_64__
858static inline void vcpu_nested_state_get(struct kvm_vcpu *vcpu,
859 struct kvm_nested_state *state)
860{
861 vcpu_ioctl(vcpu, KVM_GET_NESTED_STATE, state);
862}
863static inline int __vcpu_nested_state_set(struct kvm_vcpu *vcpu,
864 struct kvm_nested_state *state)
865{
866 return __vcpu_ioctl(vcpu, KVM_SET_NESTED_STATE, state);
867}
868
869static inline void vcpu_nested_state_set(struct kvm_vcpu *vcpu,
870 struct kvm_nested_state *state)
871{
872 vcpu_ioctl(vcpu, KVM_SET_NESTED_STATE, state);
873}
874#endif
875static inline int vcpu_get_stats_fd(struct kvm_vcpu *vcpu)
876{
877 int fd = __vcpu_ioctl(vcpu, KVM_GET_STATS_FD, NULL);
878
879 TEST_ASSERT_VM_VCPU_IOCTL(fd >= 0, KVM_GET_STATS_FD, fd, vcpu->vm);
880 return fd;
881}
882
883int __kvm_has_device_attr(int dev_fd, u32 group, u64 attr);
884
885static inline void kvm_has_device_attr(int dev_fd, u32 group, u64 attr)
886{
887 int ret = __kvm_has_device_attr(dev_fd, group, attr);
888
889 TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
890}
891
892int __kvm_device_attr_get(int dev_fd, u32 group, u64 attr, void *val);
893
894static inline void kvm_device_attr_get(int dev_fd, u32 group,
895 u64 attr, void *val)
896{
897 int ret = __kvm_device_attr_get(dev_fd, group, attr, val);
898
899 TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_GET_DEVICE_ATTR, ret));
900}
901
902int __kvm_device_attr_set(int dev_fd, u32 group, u64 attr, void *val);
903
904static inline void kvm_device_attr_set(int dev_fd, u32 group,
905 u64 attr, void *val)
906{
907 int ret = __kvm_device_attr_set(dev_fd, group, attr, val);
908
909 TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_SET_DEVICE_ATTR, ret));
910}
911
912static inline int __vcpu_has_device_attr(struct kvm_vcpu *vcpu, u32 group,
913 u64 attr)
914{
915 return __kvm_has_device_attr(vcpu->fd, group, attr);
916}
917
918static inline void vcpu_has_device_attr(struct kvm_vcpu *vcpu, u32 group,
919 u64 attr)
920{
921 kvm_has_device_attr(vcpu->fd, group, attr);
922}
923
924static inline int __vcpu_device_attr_get(struct kvm_vcpu *vcpu, u32 group,
925 u64 attr, void *val)
926{
927 return __kvm_device_attr_get(vcpu->fd, group, attr, val);
928}
929
930static inline void vcpu_device_attr_get(struct kvm_vcpu *vcpu, u32 group,
931 u64 attr, void *val)
932{
933 kvm_device_attr_get(vcpu->fd, group, attr, val);
934}
935
936static inline int __vcpu_device_attr_set(struct kvm_vcpu *vcpu, u32 group,
937 u64 attr, void *val)
938{
939 return __kvm_device_attr_set(vcpu->fd, group, attr, val);
940}
941
942static inline void vcpu_device_attr_set(struct kvm_vcpu *vcpu, u32 group,
943 u64 attr, void *val)
944{
945 kvm_device_attr_set(vcpu->fd, group, attr, val);
946}
947
948int __kvm_test_create_device(struct kvm_vm *vm, u64 type);
949int __kvm_create_device(struct kvm_vm *vm, u64 type);
950
951static inline int kvm_create_device(struct kvm_vm *vm, u64 type)
952{
953 int fd = __kvm_create_device(vm, type);
954
955 TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_CREATE_DEVICE, fd));
956 return fd;
957}
958
959void *vcpu_map_dirty_ring(struct kvm_vcpu *vcpu);
960
961/*
962 * VM VCPU Args Set
963 *
964 * Input Args:
965 * vcpu - vCPU
966 * num - number of arguments
967 * ... - arguments, each of type u64
968 *
969 * Output Args: None
970 *
971 * Return: None
972 *
973 * Sets the first @num input parameters for the function at @vcpu's entry point,
974 * per the C calling convention of the architecture, to the values given as
975 * variable args. Each of the variable args is expected to be of type u64.
976 * The maximum @num can be is specific to the architecture.
977 */
978void vcpu_args_set(struct kvm_vcpu *vcpu, unsigned int num, ...);
979
980void kvm_irq_line(struct kvm_vm *vm, u32 irq, int level);
981int _kvm_irq_line(struct kvm_vm *vm, u32 irq, int level);
982
983#define KVM_MAX_IRQ_ROUTES 4096
984
985struct kvm_irq_routing *kvm_gsi_routing_create(void);
986void kvm_gsi_routing_irqchip_add(struct kvm_irq_routing *routing,
987 u32 gsi, u32 pin);
988int _kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing);
989void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing);
990
991const char *exit_reason_str(unsigned int exit_reason);
992
993gpa_t vm_phy_page_alloc(struct kvm_vm *vm, gpa_t min_gpa, u32 memslot);
994gpa_t __vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, gpa_t min_gpa,
995 u32 memslot, bool protected);
996gpa_t vm_alloc_page_table(struct kvm_vm *vm);
997
998static inline gpa_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num,
999 gpa_t min_gpa, u32 memslot)
1000{
1001 /*
1002 * By default, allocate memory as protected for VMs that support
1003 * protected memory, as the majority of memory for such VMs is
1004 * protected, i.e. using shared memory is effectively opt-in.
1005 */
1006 return __vm_phy_pages_alloc(vm, num, min_gpa, memslot,
1007 vm_arch_has_protected_memory(vm));
1008}
1009
1010/*
1011 * ____vm_create() does KVM_CREATE_VM and little else. __vm_create() also
1012 * loads the test binary into guest memory and creates an IRQ chip (x86 only).
1013 * __vm_create() does NOT create vCPUs, @nr_runnable_vcpus is used purely to
1014 * calculate the amount of memory needed for per-vCPU data, e.g. stacks.
1015 */
1016struct kvm_vm *____vm_create(struct vm_shape shape);
1017struct kvm_vm *__vm_create(struct vm_shape shape, u32 nr_runnable_vcpus,
1018 u64 nr_extra_pages);
1019
1020static inline struct kvm_vm *vm_create_barebones(void)
1021{
1022 return ____vm_create(VM_SHAPE_DEFAULT);
1023}
1024
1025static inline struct kvm_vm *vm_create_barebones_type(unsigned long type)
1026{
1027 const struct vm_shape shape = {
1028 .mode = VM_MODE_DEFAULT,
1029 .type = type,
1030 };
1031
1032 return ____vm_create(shape);
1033}
1034
1035static inline struct kvm_vm *vm_create(u32 nr_runnable_vcpus)
1036{
1037 return __vm_create(VM_SHAPE_DEFAULT, nr_runnable_vcpus, 0);
1038}
1039
1040struct kvm_vm *__vm_create_with_vcpus(struct vm_shape shape, u32 nr_vcpus,
1041 u64 extra_mem_pages,
1042 void *guest_code, struct kvm_vcpu *vcpus[]);
1043
1044static inline struct kvm_vm *vm_create_with_vcpus(u32 nr_vcpus,
1045 void *guest_code,
1046 struct kvm_vcpu *vcpus[])
1047{
1048 return __vm_create_with_vcpus(VM_SHAPE_DEFAULT, nr_vcpus, 0,
1049 guest_code, vcpus);
1050}
1051
1052
1053struct kvm_vm *__vm_create_shape_with_one_vcpu(struct vm_shape shape,
1054 struct kvm_vcpu **vcpu,
1055 u64 extra_mem_pages,
1056 void *guest_code);
1057
1058/*
1059 * Create a VM with a single vCPU with reasonable defaults and @extra_mem_pages
1060 * additional pages of guest memory. Returns the VM and vCPU (via out param).
1061 */
1062static inline struct kvm_vm *__vm_create_with_one_vcpu(struct kvm_vcpu **vcpu,
1063 u64 extra_mem_pages,
1064 void *guest_code)
1065{
1066 return __vm_create_shape_with_one_vcpu(VM_SHAPE_DEFAULT, vcpu,
1067 extra_mem_pages, guest_code);
1068}
1069
1070static inline struct kvm_vm *vm_create_with_one_vcpu(struct kvm_vcpu **vcpu,
1071 void *guest_code)
1072{
1073 return __vm_create_with_one_vcpu(vcpu, 0, guest_code);
1074}
1075
1076static inline struct kvm_vm *vm_create_shape_with_one_vcpu(struct vm_shape shape,
1077 struct kvm_vcpu **vcpu,
1078 void *guest_code)
1079{
1080 return __vm_create_shape_with_one_vcpu(shape, vcpu, 0, guest_code);
1081}
1082
1083struct kvm_vcpu *vm_recreate_with_one_vcpu(struct kvm_vm *vm);
1084
1085void kvm_set_files_rlimit(u32 nr_vcpus);
1086
1087int kvm_pick_random_cpu(cpu_set_t *possible_cpus);
1088
1089int __pin_task_to_cpu(pthread_t task, int cpu);
1090
1091static inline void pin_task_to_cpu(pthread_t task, int cpu)
1092{
1093 int r;
1094
1095 r = __pin_task_to_cpu(task, cpu);
1096 TEST_ASSERT(!r, "Failed to set thread affinity to pCPU '%u'", cpu);
1097}
1098
1099static inline int pin_task_to_random_cpu(pthread_t task, cpu_set_t *possible_cpus)
1100{
1101 int cpu;
1102
1103 cpu = kvm_pick_random_cpu(possible_cpus);
1104 pin_task_to_cpu(task, cpu);
1105 return cpu;
1106}
1107
1108static inline int pin_task_to_any_cpu(pthread_t task)
1109{
1110 int cpu = sched_getcpu();
1111
1112 pin_task_to_cpu(task, cpu);
1113 return cpu;
1114}
1115
1116static inline void pin_self_to_cpu(int cpu)
1117{
1118 pin_task_to_cpu(pthread_self(), cpu);
1119}
1120
1121static inline int pin_self_to_any_cpu(void)
1122{
1123 return pin_task_to_any_cpu(pthread_self());
1124}
1125
1126void kvm_print_vcpu_pinning_help(void);
1127void kvm_parse_vcpu_pinning(const char *pcpus_string, u32 vcpu_to_pcpu[],
1128 int nr_vcpus);
1129
1130unsigned long vm_compute_max_gfn(struct kvm_vm *vm);
1131unsigned int vm_calc_num_guest_pages(enum vm_guest_mode mode, size_t size);
1132unsigned int vm_num_host_pages(enum vm_guest_mode mode, unsigned int num_guest_pages);
1133unsigned int vm_num_guest_pages(enum vm_guest_mode mode, unsigned int num_host_pages);
1134static inline unsigned int
1135vm_adjust_num_guest_pages(enum vm_guest_mode mode, unsigned int num_guest_pages)
1136{
1137 unsigned int n;
1138 n = vm_num_guest_pages(mode, vm_num_host_pages(mode, num_guest_pages));
1139 return n;
1140}
1141
1142#define sync_global_to_guest(vm, g) ({ \
1143 typeof(g) *_p = addr_gva2hva(vm, (gva_t)&(g)); \
1144 memcpy(_p, &(g), sizeof(g)); \
1145})
1146
1147#define sync_global_from_guest(vm, g) ({ \
1148 typeof(g) *_p = addr_gva2hva(vm, (gva_t)&(g)); \
1149 memcpy(&(g), _p, sizeof(g)); \
1150})
1151
1152#define SYNC_FROM_GUEST_AND_READ(_vm, _variable) ({ \
1153 sync_global_from_guest(_vm, _variable); \
1154 READ_ONCE(_variable); \
1155})
1156
1157#define WRITE_AND_SYNC_TO_GUEST(_vm, _variable, _value) do { \
1158 WRITE_ONCE(_variable, _value); \
1159 sync_global_to_guest(_vm, _variable); \
1160} while (0)
1161
1162/*
1163 * Write a global value, but only in the VM's (guest's) domain. Primarily used
1164 * for "globals" that hold per-VM values (VMs always duplicate code and global
1165 * data into their own region of physical memory), but can be used anytime it's
1166 * undesirable to change the host's copy of the global.
1167 */
1168#define write_guest_global(vm, g, val) ({ \
1169 typeof(g) *_p = addr_gva2hva(vm, (gva_t)&(g)); \
1170 typeof(g) _val = val; \
1171 \
1172 memcpy(_p, &(_val), sizeof(g)); \
1173})
1174
1175void assert_on_unhandled_exception(struct kvm_vcpu *vcpu);
1176
1177void vcpu_arch_dump(FILE *stream, struct kvm_vcpu *vcpu,
1178 u8 indent);
1179
1180static inline void vcpu_dump(FILE *stream, struct kvm_vcpu *vcpu,
1181 u8 indent)
1182{
1183 vcpu_arch_dump(stream, vcpu, indent);
1184}
1185
1186/*
1187 * Adds a vCPU with reasonable defaults (e.g. a stack)
1188 *
1189 * Input Args:
1190 * vm - Virtual Machine
1191 * vcpu_id - The id of the VCPU to add to the VM.
1192 */
1193struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, u32 vcpu_id);
1194void vcpu_arch_set_entry_point(struct kvm_vcpu *vcpu, void *guest_code);
1195
1196static inline struct kvm_vcpu *vm_vcpu_add(struct kvm_vm *vm, u32 vcpu_id,
1197 void *guest_code)
1198{
1199 struct kvm_vcpu *vcpu = vm_arch_vcpu_add(vm, vcpu_id);
1200
1201 vcpu_arch_set_entry_point(vcpu, guest_code);
1202
1203 return vcpu;
1204}
1205
1206/* Re-create a vCPU after restarting a VM, e.g. for state save/restore tests. */
1207struct kvm_vcpu *vm_arch_vcpu_recreate(struct kvm_vm *vm, u32 vcpu_id);
1208
1209static inline struct kvm_vcpu *vm_vcpu_recreate(struct kvm_vm *vm,
1210 u32 vcpu_id)
1211{
1212 return vm_arch_vcpu_recreate(vm, vcpu_id);
1213}
1214
1215void vcpu_arch_free(struct kvm_vcpu *vcpu);
1216
1217void virt_arch_pgd_alloc(struct kvm_vm *vm);
1218
1219static inline void virt_pgd_alloc(struct kvm_vm *vm)
1220{
1221 virt_arch_pgd_alloc(vm);
1222}
1223
1224/*
1225 * Within @vm, creates a virtual translation for the page starting
1226 * at @gva to the page starting at @gpa.
1227 */
1228void virt_arch_pg_map(struct kvm_vm *vm, gva_t gva, gpa_t gpa);
1229
1230static inline void virt_pg_map(struct kvm_vm *vm, gva_t gva, gpa_t gpa)
1231{
1232 virt_arch_pg_map(vm, gva, gpa);
1233 sparsebit_set(vm->vpages_mapped, gva >> vm->page_shift);
1234}
1235
1236
1237/*
1238 * Address Guest Virtual to Guest Physical
1239 *
1240 * Input Args:
1241 * vm - Virtual Machine
1242 * gva - VM virtual address
1243 *
1244 * Output Args: None
1245 *
1246 * Return:
1247 * Equivalent VM physical address
1248 *
1249 * Returns the VM physical address of the translated VM virtual
1250 * address given by @gva.
1251 */
1252gpa_t addr_arch_gva2gpa(struct kvm_vm *vm, gva_t gva);
1253
1254static inline gpa_t addr_gva2gpa(struct kvm_vm *vm, gva_t gva)
1255{
1256 return addr_arch_gva2gpa(vm, gva);
1257}
1258
1259/*
1260 * Virtual Translation Tables Dump
1261 *
1262 * Input Args:
1263 * stream - Output FILE stream
1264 * vm - Virtual Machine
1265 * indent - Left margin indent amount
1266 *
1267 * Output Args: None
1268 *
1269 * Return: None
1270 *
1271 * Dumps to the FILE stream given by @stream, the contents of all the
1272 * virtual translation tables for the VM given by @vm.
1273 */
1274void virt_arch_dump(FILE *stream, struct kvm_vm *vm, u8 indent);
1275
1276static inline void virt_dump(FILE *stream, struct kvm_vm *vm, u8 indent)
1277{
1278 virt_arch_dump(stream, vm, indent);
1279}
1280
1281
1282static inline int __vm_disable_nx_huge_pages(struct kvm_vm *vm)
1283{
1284 return __vm_enable_cap(vm, KVM_CAP_VM_DISABLE_NX_HUGE_PAGES, 0);
1285}
1286
1287static inline u64 vm_page_align(struct kvm_vm *vm, u64 v)
1288{
1289 return (v + vm->page_size - 1) & ~(vm->page_size - 1);
1290}
1291
1292/*
1293 * Arch hook that is invoked via a constructor, i.e. before executing main(),
1294 * to allow for arch-specific setup that is common to all tests, e.g. computing
1295 * the default guest "mode".
1296 */
1297void kvm_selftest_arch_init(void);
1298
1299void kvm_arch_vm_post_create(struct kvm_vm *vm, unsigned int nr_vcpus);
1300void kvm_arch_vm_finalize_vcpus(struct kvm_vm *vm);
1301void kvm_arch_vm_release(struct kvm_vm *vm);
1302
1303bool vm_is_gpa_protected(struct kvm_vm *vm, gpa_t gpa);
1304
1305u32 guest_get_vcpuid(void);
1306
1307bool kvm_arch_has_default_irqchip(void);
1308
1309#endif /* SELFTEST_KVM_UTIL_H */