1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * tools/testing/selftests/kvm/include/kvm_util_base.h
4  *
5  * Copyright (C) 2018, Google LLC.
6  */
7 #ifndef SELFTEST_KVM_UTIL_BASE_H
8 #define SELFTEST_KVM_UTIL_BASE_H
9 
10 #include "test_util.h"
11 
12 #include <linux/compiler.h>
13 #include "linux/hashtable.h"
14 #include "linux/list.h"
15 #include <linux/kernel.h>
16 #include <linux/kvm.h>
17 #include "linux/rbtree.h"
18 
19 #include <asm/atomic.h>
20 
21 #include <sys/ioctl.h>
22 
23 #include "sparsebit.h"
24 
25 /*
26  * Provide a version of static_assert() that is guaranteed to have an optional
27  * message param.  If _ISOC11_SOURCE is defined, glibc (/usr/include/assert.h)
28  * #undefs and #defines static_assert() as a direct alias to _Static_assert(),
29  * i.e. effectively makes the message mandatory.  Many KVM selftests #define
30  * _GNU_SOURCE for various reasons, and _GNU_SOURCE implies _ISOC11_SOURCE.  As
31  * a result, static_assert() behavior is non-deterministic and may or may not
32  * require a message depending on #include order.
33  */
34 #define __kvm_static_assert(expr, msg, ...) _Static_assert(expr, msg)
35 #define kvm_static_assert(expr, ...) __kvm_static_assert(expr, ##__VA_ARGS__, #expr)
36 
37 #define KVM_DEV_PATH "/dev/kvm"
38 #define KVM_MAX_VCPUS 512
39 
40 #define NSEC_PER_SEC 1000000000L
41 
42 typedef uint64_t vm_paddr_t; /* Virtual Machine (Guest) physical address */
43 typedef uint64_t vm_vaddr_t; /* Virtual Machine (Guest) virtual address */
44 
45 struct userspace_mem_region {
46 	struct kvm_userspace_memory_region region;
47 	struct sparsebit *unused_phy_pages;
48 	int fd;
49 	off_t offset;
50 	enum vm_mem_backing_src_type backing_src_type;
51 	void *host_mem;
52 	void *host_alias;
53 	void *mmap_start;
54 	void *mmap_alias;
55 	size_t mmap_size;
56 	struct rb_node gpa_node;
57 	struct rb_node hva_node;
58 	struct hlist_node slot_node;
59 };
60 
61 struct kvm_vcpu {
62 	struct list_head list;
63 	uint32_t id;
64 	int fd;
65 	struct kvm_vm *vm;
66 	struct kvm_run *run;
67 #ifdef __x86_64__
68 	struct kvm_cpuid2 *cpuid;
69 #endif
70 	struct kvm_dirty_gfn *dirty_gfns;
71 	uint32_t fetch_index;
72 	uint32_t dirty_gfns_count;
73 };
74 
75 struct userspace_mem_regions {
76 	struct rb_root gpa_tree;
77 	struct rb_root hva_tree;
78 	DECLARE_HASHTABLE(slot_hash, 9);
79 };
80 
81 enum kvm_mem_region_type {
82 	MEM_REGION_CODE,
83 	MEM_REGION_DATA,
84 	MEM_REGION_PT,
85 	MEM_REGION_TEST_DATA,
86 	NR_MEM_REGIONS,
87 };
88 
89 struct kvm_vm {
90 	int mode;
91 	unsigned long type;
92 	int kvm_fd;
93 	int fd;
94 	unsigned int pgtable_levels;
95 	unsigned int page_size;
96 	unsigned int page_shift;
97 	unsigned int pa_bits;
98 	unsigned int va_bits;
99 	uint64_t max_gfn;
100 	struct list_head vcpus;
101 	struct userspace_mem_regions regions;
102 	struct sparsebit *vpages_valid;
103 	struct sparsebit *vpages_mapped;
104 	bool has_irqchip;
105 	bool pgd_created;
106 	vm_paddr_t ucall_mmio_addr;
107 	vm_paddr_t pgd;
108 	vm_vaddr_t gdt;
109 	vm_vaddr_t tss;
110 	vm_vaddr_t idt;
111 	vm_vaddr_t handlers;
112 	uint32_t dirty_ring_size;
113 
114 	/* Cache of information for binary stats interface */
115 	int stats_fd;
116 	struct kvm_stats_header stats_header;
117 	struct kvm_stats_desc *stats_desc;
118 
119 	/*
120 	 * KVM region slots. These are the default memslots used by page
121 	 * allocators, e.g., lib/elf uses the memslots[MEM_REGION_CODE]
122 	 * memslot.
123 	 */
124 	uint32_t memslots[NR_MEM_REGIONS];
125 };
126 
127 
128 #define kvm_for_each_vcpu(vm, i, vcpu)			\
129 	for ((i) = 0; (i) <= (vm)->last_vcpu_id; (i)++)	\
130 		if (!((vcpu) = vm->vcpus[i]))		\
131 			continue;			\
132 		else
133 
134 struct userspace_mem_region *
135 memslot2region(struct kvm_vm *vm, uint32_t memslot);
136 
137 static inline struct userspace_mem_region *vm_get_mem_region(struct kvm_vm *vm,
138 							     enum kvm_mem_region_type type)
139 {
140 	assert(type < NR_MEM_REGIONS);
141 	return memslot2region(vm, vm->memslots[type]);
142 }
143 
144 /* Minimum allocated guest virtual and physical addresses */
145 #define KVM_UTIL_MIN_VADDR		0x2000
146 #define KVM_GUEST_PAGE_TABLE_MIN_PADDR	0x180000
147 
148 #define DEFAULT_GUEST_STACK_VADDR_MIN	0xab6000
149 #define DEFAULT_STACK_PGS		5
150 
151 enum vm_guest_mode {
152 	VM_MODE_P52V48_4K,
153 	VM_MODE_P52V48_64K,
154 	VM_MODE_P48V48_4K,
155 	VM_MODE_P48V48_16K,
156 	VM_MODE_P48V48_64K,
157 	VM_MODE_P40V48_4K,
158 	VM_MODE_P40V48_16K,
159 	VM_MODE_P40V48_64K,
160 	VM_MODE_PXXV48_4K,	/* For 48bits VA but ANY bits PA */
161 	VM_MODE_P47V64_4K,
162 	VM_MODE_P44V64_4K,
163 	VM_MODE_P36V48_4K,
164 	VM_MODE_P36V48_16K,
165 	VM_MODE_P36V48_64K,
166 	VM_MODE_P36V47_16K,
167 	NUM_VM_MODES,
168 };
169 
170 #if defined(__aarch64__)
171 
172 extern enum vm_guest_mode vm_mode_default;
173 
174 #define VM_MODE_DEFAULT			vm_mode_default
175 #define MIN_PAGE_SHIFT			12U
176 #define ptes_per_page(page_size)	((page_size) / 8)
177 
178 #elif defined(__x86_64__)
179 
180 #define VM_MODE_DEFAULT			VM_MODE_PXXV48_4K
181 #define MIN_PAGE_SHIFT			12U
182 #define ptes_per_page(page_size)	((page_size) / 8)
183 
184 #elif defined(__s390x__)
185 
186 #define VM_MODE_DEFAULT			VM_MODE_P44V64_4K
187 #define MIN_PAGE_SHIFT			12U
188 #define ptes_per_page(page_size)	((page_size) / 16)
189 
190 #elif defined(__riscv)
191 
192 #if __riscv_xlen == 32
193 #error "RISC-V 32-bit kvm selftests not supported"
194 #endif
195 
196 #define VM_MODE_DEFAULT			VM_MODE_P40V48_4K
197 #define MIN_PAGE_SHIFT			12U
198 #define ptes_per_page(page_size)	((page_size) / 8)
199 
200 #endif
201 
202 #define MIN_PAGE_SIZE		(1U << MIN_PAGE_SHIFT)
203 #define PTES_PER_MIN_PAGE	ptes_per_page(MIN_PAGE_SIZE)
204 
205 struct vm_guest_mode_params {
206 	unsigned int pa_bits;
207 	unsigned int va_bits;
208 	unsigned int page_size;
209 	unsigned int page_shift;
210 };
211 extern const struct vm_guest_mode_params vm_guest_mode_params[];
212 
213 int open_path_or_exit(const char *path, int flags);
214 int open_kvm_dev_path_or_exit(void);
215 
216 bool get_kvm_intel_param_bool(const char *param);
217 bool get_kvm_amd_param_bool(const char *param);
218 
219 unsigned int kvm_check_cap(long cap);
220 
221 static inline bool kvm_has_cap(long cap)
222 {
223 	return kvm_check_cap(cap);
224 }
225 
226 #define __KVM_SYSCALL_ERROR(_name, _ret) \
227 	"%s failed, rc: %i errno: %i (%s)", (_name), (_ret), errno, strerror(errno)
228 
229 #define __KVM_IOCTL_ERROR(_name, _ret)	__KVM_SYSCALL_ERROR(_name, _ret)
230 #define KVM_IOCTL_ERROR(_ioctl, _ret) __KVM_IOCTL_ERROR(#_ioctl, _ret)
231 
232 #define kvm_do_ioctl(fd, cmd, arg)						\
233 ({										\
234 	kvm_static_assert(!_IOC_SIZE(cmd) || sizeof(*arg) == _IOC_SIZE(cmd));	\
235 	ioctl(fd, cmd, arg);							\
236 })
237 
238 #define __kvm_ioctl(kvm_fd, cmd, arg)				\
239 	kvm_do_ioctl(kvm_fd, cmd, arg)
240 
241 
242 #define _kvm_ioctl(kvm_fd, cmd, name, arg)			\
243 ({								\
244 	int ret = __kvm_ioctl(kvm_fd, cmd, arg);		\
245 								\
246 	TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));	\
247 })
248 
249 #define kvm_ioctl(kvm_fd, cmd, arg) \
250 	_kvm_ioctl(kvm_fd, cmd, #cmd, arg)
251 
252 static __always_inline void static_assert_is_vm(struct kvm_vm *vm) { }
253 
254 #define __vm_ioctl(vm, cmd, arg)				\
255 ({								\
256 	static_assert_is_vm(vm);				\
257 	kvm_do_ioctl((vm)->fd, cmd, arg);			\
258 })
259 
260 #define _vm_ioctl(vm, cmd, name, arg)				\
261 ({								\
262 	int ret = __vm_ioctl(vm, cmd, arg);			\
263 								\
264 	TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));	\
265 })
266 
267 #define vm_ioctl(vm, cmd, arg)					\
268 	_vm_ioctl(vm, cmd, #cmd, arg)
269 
270 
271 static __always_inline void static_assert_is_vcpu(struct kvm_vcpu *vcpu) { }
272 
273 #define __vcpu_ioctl(vcpu, cmd, arg)				\
274 ({								\
275 	static_assert_is_vcpu(vcpu);				\
276 	kvm_do_ioctl((vcpu)->fd, cmd, arg);			\
277 })
278 
279 #define _vcpu_ioctl(vcpu, cmd, name, arg)			\
280 ({								\
281 	int ret = __vcpu_ioctl(vcpu, cmd, arg);			\
282 								\
283 	TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));	\
284 })
285 
286 #define vcpu_ioctl(vcpu, cmd, arg)				\
287 	_vcpu_ioctl(vcpu, cmd, #cmd, arg)
288 
289 /*
290  * Looks up and returns the value corresponding to the capability
291  * (KVM_CAP_*) given by cap.
292  */
293 static inline int vm_check_cap(struct kvm_vm *vm, long cap)
294 {
295 	int ret =  __vm_ioctl(vm, KVM_CHECK_EXTENSION, (void *)cap);
296 
297 	TEST_ASSERT(ret >= 0, KVM_IOCTL_ERROR(KVM_CHECK_EXTENSION, ret));
298 	return ret;
299 }
300 
301 static inline int __vm_enable_cap(struct kvm_vm *vm, uint32_t cap, uint64_t arg0)
302 {
303 	struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
304 
305 	return __vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
306 }
307 static inline void vm_enable_cap(struct kvm_vm *vm, uint32_t cap, uint64_t arg0)
308 {
309 	struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
310 
311 	vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap);
312 }
313 
314 void vm_enable_dirty_ring(struct kvm_vm *vm, uint32_t ring_size);
315 const char *vm_guest_mode_string(uint32_t i);
316 
317 void kvm_vm_free(struct kvm_vm *vmp);
318 void kvm_vm_restart(struct kvm_vm *vmp);
319 void kvm_vm_release(struct kvm_vm *vmp);
320 int kvm_memcmp_hva_gva(void *hva, struct kvm_vm *vm, const vm_vaddr_t gva,
321 		       size_t len);
322 void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename);
323 int kvm_memfd_alloc(size_t size, bool hugepages);
324 
325 void vm_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent);
326 
327 static inline void kvm_vm_get_dirty_log(struct kvm_vm *vm, int slot, void *log)
328 {
329 	struct kvm_dirty_log args = { .dirty_bitmap = log, .slot = slot };
330 
331 	vm_ioctl(vm, KVM_GET_DIRTY_LOG, &args);
332 }
333 
334 static inline void kvm_vm_clear_dirty_log(struct kvm_vm *vm, int slot, void *log,
335 					  uint64_t first_page, uint32_t num_pages)
336 {
337 	struct kvm_clear_dirty_log args = {
338 		.dirty_bitmap = log,
339 		.slot = slot,
340 		.first_page = first_page,
341 		.num_pages = num_pages
342 	};
343 
344 	vm_ioctl(vm, KVM_CLEAR_DIRTY_LOG, &args);
345 }
346 
347 static inline uint32_t kvm_vm_reset_dirty_ring(struct kvm_vm *vm)
348 {
349 	return __vm_ioctl(vm, KVM_RESET_DIRTY_RINGS, NULL);
350 }
351 
352 static inline int vm_get_stats_fd(struct kvm_vm *vm)
353 {
354 	int fd = __vm_ioctl(vm, KVM_GET_STATS_FD, NULL);
355 
356 	TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_GET_STATS_FD, fd));
357 	return fd;
358 }
359 
360 static inline void read_stats_header(int stats_fd, struct kvm_stats_header *header)
361 {
362 	ssize_t ret;
363 
364 	ret = read(stats_fd, header, sizeof(*header));
365 	TEST_ASSERT(ret == sizeof(*header), "Read stats header");
366 }
367 
368 struct kvm_stats_desc *read_stats_descriptors(int stats_fd,
369 					      struct kvm_stats_header *header);
370 
371 static inline ssize_t get_stats_descriptor_size(struct kvm_stats_header *header)
372 {
373 	 /*
374 	  * The base size of the descriptor is defined by KVM's ABI, but the
375 	  * size of the name field is variable, as far as KVM's ABI is
376 	  * concerned. For a given instance of KVM, the name field is the same
377 	  * size for all stats and is provided in the overall stats header.
378 	  */
379 	return sizeof(struct kvm_stats_desc) + header->name_size;
380 }
381 
382 static inline struct kvm_stats_desc *get_stats_descriptor(struct kvm_stats_desc *stats,
383 							  int index,
384 							  struct kvm_stats_header *header)
385 {
386 	/*
387 	 * Note, size_desc includes the size of the name field, which is
388 	 * variable. i.e. this is NOT equivalent to &stats_desc[i].
389 	 */
390 	return (void *)stats + index * get_stats_descriptor_size(header);
391 }
392 
393 void read_stat_data(int stats_fd, struct kvm_stats_header *header,
394 		    struct kvm_stats_desc *desc, uint64_t *data,
395 		    size_t max_elements);
396 
397 void __vm_get_stat(struct kvm_vm *vm, const char *stat_name, uint64_t *data,
398 		   size_t max_elements);
399 
400 static inline uint64_t vm_get_stat(struct kvm_vm *vm, const char *stat_name)
401 {
402 	uint64_t data;
403 
404 	__vm_get_stat(vm, stat_name, &data, 1);
405 	return data;
406 }
407 
408 void vm_create_irqchip(struct kvm_vm *vm);
409 
410 void vm_set_user_memory_region(struct kvm_vm *vm, uint32_t slot, uint32_t flags,
411 			       uint64_t gpa, uint64_t size, void *hva);
412 int __vm_set_user_memory_region(struct kvm_vm *vm, uint32_t slot, uint32_t flags,
413 				uint64_t gpa, uint64_t size, void *hva);
414 void vm_userspace_mem_region_add(struct kvm_vm *vm,
415 	enum vm_mem_backing_src_type src_type,
416 	uint64_t guest_paddr, uint32_t slot, uint64_t npages,
417 	uint32_t flags);
418 
419 void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags);
420 void vm_mem_region_move(struct kvm_vm *vm, uint32_t slot, uint64_t new_gpa);
421 void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot);
422 struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id);
423 void vm_populate_vaddr_bitmap(struct kvm_vm *vm);
424 vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min);
425 vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min);
426 vm_vaddr_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min,
427 			    enum kvm_mem_region_type type);
428 vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages);
429 vm_vaddr_t __vm_vaddr_alloc_page(struct kvm_vm *vm,
430 				 enum kvm_mem_region_type type);
431 vm_vaddr_t vm_vaddr_alloc_page(struct kvm_vm *vm);
432 
433 void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
434 	      unsigned int npages);
435 void *addr_gpa2hva(struct kvm_vm *vm, vm_paddr_t gpa);
436 void *addr_gva2hva(struct kvm_vm *vm, vm_vaddr_t gva);
437 vm_paddr_t addr_hva2gpa(struct kvm_vm *vm, void *hva);
438 void *addr_gpa2alias(struct kvm_vm *vm, vm_paddr_t gpa);
439 
440 void vcpu_run(struct kvm_vcpu *vcpu);
441 int _vcpu_run(struct kvm_vcpu *vcpu);
442 
443 static inline int __vcpu_run(struct kvm_vcpu *vcpu)
444 {
445 	return __vcpu_ioctl(vcpu, KVM_RUN, NULL);
446 }
447 
448 void vcpu_run_complete_io(struct kvm_vcpu *vcpu);
449 struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vcpu *vcpu);
450 
451 static inline void vcpu_enable_cap(struct kvm_vcpu *vcpu, uint32_t cap,
452 				   uint64_t arg0)
453 {
454 	struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } };
455 
456 	vcpu_ioctl(vcpu, KVM_ENABLE_CAP, &enable_cap);
457 }
458 
459 static inline void vcpu_guest_debug_set(struct kvm_vcpu *vcpu,
460 					struct kvm_guest_debug *debug)
461 {
462 	vcpu_ioctl(vcpu, KVM_SET_GUEST_DEBUG, debug);
463 }
464 
465 static inline void vcpu_mp_state_get(struct kvm_vcpu *vcpu,
466 				     struct kvm_mp_state *mp_state)
467 {
468 	vcpu_ioctl(vcpu, KVM_GET_MP_STATE, mp_state);
469 }
470 static inline void vcpu_mp_state_set(struct kvm_vcpu *vcpu,
471 				     struct kvm_mp_state *mp_state)
472 {
473 	vcpu_ioctl(vcpu, KVM_SET_MP_STATE, mp_state);
474 }
475 
476 static inline void vcpu_regs_get(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
477 {
478 	vcpu_ioctl(vcpu, KVM_GET_REGS, regs);
479 }
480 
481 static inline void vcpu_regs_set(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
482 {
483 	vcpu_ioctl(vcpu, KVM_SET_REGS, regs);
484 }
485 static inline void vcpu_sregs_get(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
486 {
487 	vcpu_ioctl(vcpu, KVM_GET_SREGS, sregs);
488 
489 }
490 static inline void vcpu_sregs_set(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
491 {
492 	vcpu_ioctl(vcpu, KVM_SET_SREGS, sregs);
493 }
494 static inline int _vcpu_sregs_set(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs)
495 {
496 	return __vcpu_ioctl(vcpu, KVM_SET_SREGS, sregs);
497 }
498 static inline void vcpu_fpu_get(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
499 {
500 	vcpu_ioctl(vcpu, KVM_GET_FPU, fpu);
501 }
502 static inline void vcpu_fpu_set(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
503 {
504 	vcpu_ioctl(vcpu, KVM_SET_FPU, fpu);
505 }
506 
507 static inline int __vcpu_get_reg(struct kvm_vcpu *vcpu, uint64_t id, void *addr)
508 {
509 	struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)addr };
510 
511 	return __vcpu_ioctl(vcpu, KVM_GET_ONE_REG, &reg);
512 }
513 static inline int __vcpu_set_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t val)
514 {
515 	struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)&val };
516 
517 	return __vcpu_ioctl(vcpu, KVM_SET_ONE_REG, &reg);
518 }
519 static inline void vcpu_get_reg(struct kvm_vcpu *vcpu, uint64_t id, void *addr)
520 {
521 	struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)addr };
522 
523 	vcpu_ioctl(vcpu, KVM_GET_ONE_REG, &reg);
524 }
525 static inline void vcpu_set_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t val)
526 {
527 	struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)&val };
528 
529 	vcpu_ioctl(vcpu, KVM_SET_ONE_REG, &reg);
530 }
531 
532 #ifdef __KVM_HAVE_VCPU_EVENTS
533 static inline void vcpu_events_get(struct kvm_vcpu *vcpu,
534 				   struct kvm_vcpu_events *events)
535 {
536 	vcpu_ioctl(vcpu, KVM_GET_VCPU_EVENTS, events);
537 }
538 static inline void vcpu_events_set(struct kvm_vcpu *vcpu,
539 				   struct kvm_vcpu_events *events)
540 {
541 	vcpu_ioctl(vcpu, KVM_SET_VCPU_EVENTS, events);
542 }
543 #endif
544 #ifdef __x86_64__
545 static inline void vcpu_nested_state_get(struct kvm_vcpu *vcpu,
546 					 struct kvm_nested_state *state)
547 {
548 	vcpu_ioctl(vcpu, KVM_GET_NESTED_STATE, state);
549 }
550 static inline int __vcpu_nested_state_set(struct kvm_vcpu *vcpu,
551 					  struct kvm_nested_state *state)
552 {
553 	return __vcpu_ioctl(vcpu, KVM_SET_NESTED_STATE, state);
554 }
555 
556 static inline void vcpu_nested_state_set(struct kvm_vcpu *vcpu,
557 					 struct kvm_nested_state *state)
558 {
559 	vcpu_ioctl(vcpu, KVM_SET_NESTED_STATE, state);
560 }
561 #endif
562 static inline int vcpu_get_stats_fd(struct kvm_vcpu *vcpu)
563 {
564 	int fd = __vcpu_ioctl(vcpu, KVM_GET_STATS_FD, NULL);
565 
566 	TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_GET_STATS_FD, fd));
567 	return fd;
568 }
569 
570 int __kvm_has_device_attr(int dev_fd, uint32_t group, uint64_t attr);
571 
572 static inline void kvm_has_device_attr(int dev_fd, uint32_t group, uint64_t attr)
573 {
574 	int ret = __kvm_has_device_attr(dev_fd, group, attr);
575 
576 	TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
577 }
578 
579 int __kvm_device_attr_get(int dev_fd, uint32_t group, uint64_t attr, void *val);
580 
581 static inline void kvm_device_attr_get(int dev_fd, uint32_t group,
582 				       uint64_t attr, void *val)
583 {
584 	int ret = __kvm_device_attr_get(dev_fd, group, attr, val);
585 
586 	TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_GET_DEVICE_ATTR, ret));
587 }
588 
589 int __kvm_device_attr_set(int dev_fd, uint32_t group, uint64_t attr, void *val);
590 
591 static inline void kvm_device_attr_set(int dev_fd, uint32_t group,
592 				       uint64_t attr, void *val)
593 {
594 	int ret = __kvm_device_attr_set(dev_fd, group, attr, val);
595 
596 	TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_SET_DEVICE_ATTR, ret));
597 }
598 
599 static inline int __vcpu_has_device_attr(struct kvm_vcpu *vcpu, uint32_t group,
600 					 uint64_t attr)
601 {
602 	return __kvm_has_device_attr(vcpu->fd, group, attr);
603 }
604 
605 static inline void vcpu_has_device_attr(struct kvm_vcpu *vcpu, uint32_t group,
606 					uint64_t attr)
607 {
608 	kvm_has_device_attr(vcpu->fd, group, attr);
609 }
610 
611 static inline int __vcpu_device_attr_get(struct kvm_vcpu *vcpu, uint32_t group,
612 					 uint64_t attr, void *val)
613 {
614 	return __kvm_device_attr_get(vcpu->fd, group, attr, val);
615 }
616 
617 static inline void vcpu_device_attr_get(struct kvm_vcpu *vcpu, uint32_t group,
618 					uint64_t attr, void *val)
619 {
620 	kvm_device_attr_get(vcpu->fd, group, attr, val);
621 }
622 
623 static inline int __vcpu_device_attr_set(struct kvm_vcpu *vcpu, uint32_t group,
624 					 uint64_t attr, void *val)
625 {
626 	return __kvm_device_attr_set(vcpu->fd, group, attr, val);
627 }
628 
629 static inline void vcpu_device_attr_set(struct kvm_vcpu *vcpu, uint32_t group,
630 					uint64_t attr, void *val)
631 {
632 	kvm_device_attr_set(vcpu->fd, group, attr, val);
633 }
634 
635 int __kvm_test_create_device(struct kvm_vm *vm, uint64_t type);
636 int __kvm_create_device(struct kvm_vm *vm, uint64_t type);
637 
638 static inline int kvm_create_device(struct kvm_vm *vm, uint64_t type)
639 {
640 	int fd = __kvm_create_device(vm, type);
641 
642 	TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_CREATE_DEVICE, fd));
643 	return fd;
644 }
645 
646 void *vcpu_map_dirty_ring(struct kvm_vcpu *vcpu);
647 
648 /*
649  * VM VCPU Args Set
650  *
651  * Input Args:
652  *   vm - Virtual Machine
653  *   num - number of arguments
654  *   ... - arguments, each of type uint64_t
655  *
656  * Output Args: None
657  *
658  * Return: None
659  *
660  * Sets the first @num input parameters for the function at @vcpu's entry point,
661  * per the C calling convention of the architecture, to the values given as
662  * variable args. Each of the variable args is expected to be of type uint64_t.
663  * The maximum @num can be is specific to the architecture.
664  */
665 void vcpu_args_set(struct kvm_vcpu *vcpu, unsigned int num, ...);
666 
667 void kvm_irq_line(struct kvm_vm *vm, uint32_t irq, int level);
668 int _kvm_irq_line(struct kvm_vm *vm, uint32_t irq, int level);
669 
670 #define KVM_MAX_IRQ_ROUTES		4096
671 
672 struct kvm_irq_routing *kvm_gsi_routing_create(void);
673 void kvm_gsi_routing_irqchip_add(struct kvm_irq_routing *routing,
674 		uint32_t gsi, uint32_t pin);
675 int _kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing);
676 void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing);
677 
678 const char *exit_reason_str(unsigned int exit_reason);
679 
680 vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,
681 			     uint32_t memslot);
682 vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num,
683 			      vm_paddr_t paddr_min, uint32_t memslot);
684 vm_paddr_t vm_alloc_page_table(struct kvm_vm *vm);
685 
686 /*
687  * ____vm_create() does KVM_CREATE_VM and little else.  __vm_create() also
688  * loads the test binary into guest memory and creates an IRQ chip (x86 only).
689  * __vm_create() does NOT create vCPUs, @nr_runnable_vcpus is used purely to
690  * calculate the amount of memory needed for per-vCPU data, e.g. stacks.
691  */
692 struct kvm_vm *____vm_create(enum vm_guest_mode mode);
693 struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus,
694 			   uint64_t nr_extra_pages);
695 
696 static inline struct kvm_vm *vm_create_barebones(void)
697 {
698 	return ____vm_create(VM_MODE_DEFAULT);
699 }
700 
701 static inline struct kvm_vm *vm_create(uint32_t nr_runnable_vcpus)
702 {
703 	return __vm_create(VM_MODE_DEFAULT, nr_runnable_vcpus, 0);
704 }
705 
706 struct kvm_vm *__vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,
707 				      uint64_t extra_mem_pages,
708 				      void *guest_code, struct kvm_vcpu *vcpus[]);
709 
710 static inline struct kvm_vm *vm_create_with_vcpus(uint32_t nr_vcpus,
711 						  void *guest_code,
712 						  struct kvm_vcpu *vcpus[])
713 {
714 	return __vm_create_with_vcpus(VM_MODE_DEFAULT, nr_vcpus, 0,
715 				      guest_code, vcpus);
716 }
717 
718 /*
719  * Create a VM with a single vCPU with reasonable defaults and @extra_mem_pages
720  * additional pages of guest memory.  Returns the VM and vCPU (via out param).
721  */
722 struct kvm_vm *__vm_create_with_one_vcpu(struct kvm_vcpu **vcpu,
723 					 uint64_t extra_mem_pages,
724 					 void *guest_code);
725 
726 static inline struct kvm_vm *vm_create_with_one_vcpu(struct kvm_vcpu **vcpu,
727 						     void *guest_code)
728 {
729 	return __vm_create_with_one_vcpu(vcpu, 0, guest_code);
730 }
731 
732 struct kvm_vcpu *vm_recreate_with_one_vcpu(struct kvm_vm *vm);
733 
734 void kvm_pin_this_task_to_pcpu(uint32_t pcpu);
735 void kvm_parse_vcpu_pinning(const char *pcpus_string, uint32_t vcpu_to_pcpu[],
736 			    int nr_vcpus);
737 
738 unsigned long vm_compute_max_gfn(struct kvm_vm *vm);
739 unsigned int vm_calc_num_guest_pages(enum vm_guest_mode mode, size_t size);
740 unsigned int vm_num_host_pages(enum vm_guest_mode mode, unsigned int num_guest_pages);
741 unsigned int vm_num_guest_pages(enum vm_guest_mode mode, unsigned int num_host_pages);
742 static inline unsigned int
743 vm_adjust_num_guest_pages(enum vm_guest_mode mode, unsigned int num_guest_pages)
744 {
745 	unsigned int n;
746 	n = vm_num_guest_pages(mode, vm_num_host_pages(mode, num_guest_pages));
747 #ifdef __s390x__
748 	/* s390 requires 1M aligned guest sizes */
749 	n = (n + 255) & ~255;
750 #endif
751 	return n;
752 }
753 
754 struct kvm_userspace_memory_region *
755 kvm_userspace_memory_region_find(struct kvm_vm *vm, uint64_t start,
756 				 uint64_t end);
757 
758 #define sync_global_to_guest(vm, g) ({				\
759 	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
760 	memcpy(_p, &(g), sizeof(g));				\
761 })
762 
763 #define sync_global_from_guest(vm, g) ({			\
764 	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
765 	memcpy(&(g), _p, sizeof(g));				\
766 })
767 
768 /*
769  * Write a global value, but only in the VM's (guest's) domain.  Primarily used
770  * for "globals" that hold per-VM values (VMs always duplicate code and global
771  * data into their own region of physical memory), but can be used anytime it's
772  * undesirable to change the host's copy of the global.
773  */
774 #define write_guest_global(vm, g, val) ({			\
775 	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
776 	typeof(g) _val = val;					\
777 								\
778 	memcpy(_p, &(_val), sizeof(g));				\
779 })
780 
781 void assert_on_unhandled_exception(struct kvm_vcpu *vcpu);
782 
783 void vcpu_arch_dump(FILE *stream, struct kvm_vcpu *vcpu,
784 		    uint8_t indent);
785 
786 static inline void vcpu_dump(FILE *stream, struct kvm_vcpu *vcpu,
787 			     uint8_t indent)
788 {
789 	vcpu_arch_dump(stream, vcpu, indent);
790 }
791 
792 /*
793  * Adds a vCPU with reasonable defaults (e.g. a stack)
794  *
795  * Input Args:
796  *   vm - Virtual Machine
797  *   vcpu_id - The id of the VCPU to add to the VM.
798  *   guest_code - The vCPU's entry point
799  */
800 struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,
801 				  void *guest_code);
802 
803 static inline struct kvm_vcpu *vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,
804 					   void *guest_code)
805 {
806 	return vm_arch_vcpu_add(vm, vcpu_id, guest_code);
807 }
808 
809 /* Re-create a vCPU after restarting a VM, e.g. for state save/restore tests. */
810 struct kvm_vcpu *vm_arch_vcpu_recreate(struct kvm_vm *vm, uint32_t vcpu_id);
811 
812 static inline struct kvm_vcpu *vm_vcpu_recreate(struct kvm_vm *vm,
813 						uint32_t vcpu_id)
814 {
815 	return vm_arch_vcpu_recreate(vm, vcpu_id);
816 }
817 
818 void vcpu_arch_free(struct kvm_vcpu *vcpu);
819 
820 void virt_arch_pgd_alloc(struct kvm_vm *vm);
821 
822 static inline void virt_pgd_alloc(struct kvm_vm *vm)
823 {
824 	virt_arch_pgd_alloc(vm);
825 }
826 
827 /*
828  * VM Virtual Page Map
829  *
830  * Input Args:
831  *   vm - Virtual Machine
832  *   vaddr - VM Virtual Address
833  *   paddr - VM Physical Address
834  *   memslot - Memory region slot for new virtual translation tables
835  *
836  * Output Args: None
837  *
838  * Return: None
839  *
840  * Within @vm, creates a virtual translation for the page starting
841  * at @vaddr to the page starting at @paddr.
842  */
843 void virt_arch_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr);
844 
845 static inline void virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr)
846 {
847 	virt_arch_pg_map(vm, vaddr, paddr);
848 }
849 
850 
851 /*
852  * Address Guest Virtual to Guest Physical
853  *
854  * Input Args:
855  *   vm - Virtual Machine
856  *   gva - VM virtual address
857  *
858  * Output Args: None
859  *
860  * Return:
861  *   Equivalent VM physical address
862  *
863  * Returns the VM physical address of the translated VM virtual
864  * address given by @gva.
865  */
866 vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva);
867 
868 static inline vm_paddr_t addr_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva)
869 {
870 	return addr_arch_gva2gpa(vm, gva);
871 }
872 
873 /*
874  * Virtual Translation Tables Dump
875  *
876  * Input Args:
877  *   stream - Output FILE stream
878  *   vm     - Virtual Machine
879  *   indent - Left margin indent amount
880  *
881  * Output Args: None
882  *
883  * Return: None
884  *
885  * Dumps to the FILE stream given by @stream, the contents of all the
886  * virtual translation tables for the VM given by @vm.
887  */
888 void virt_arch_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent);
889 
890 static inline void virt_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent)
891 {
892 	virt_arch_dump(stream, vm, indent);
893 }
894 
895 
896 static inline int __vm_disable_nx_huge_pages(struct kvm_vm *vm)
897 {
898 	return __vm_enable_cap(vm, KVM_CAP_VM_DISABLE_NX_HUGE_PAGES, 0);
899 }
900 
901 /*
902  * Arch hook that is invoked via a constructor, i.e. before exeucting main(),
903  * to allow for arch-specific setup that is common to all tests, e.g. computing
904  * the default guest "mode".
905  */
906 void kvm_selftest_arch_init(void);
907 
908 void kvm_arch_vm_post_create(struct kvm_vm *vm);
909 
910 #endif /* SELFTEST_KVM_UTIL_BASE_H */
911