projects/linux·blob master · refs

2330 lines · 62.3 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * tools/testing/selftests/kvm/lib/kvm_util.c
4 *
5 * Copyright (C) 2018, Google LLC.
6 */
7#include "test_util.h"
8#include "kvm_syscalls.h"
9#include "kvm_util.h"
10#include "processor.h"
11#include "ucall_common.h"
12
13#include <assert.h>
14#include <sched.h>
15#include <sys/resource.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18#include <time.h>
19#include <unistd.h>
20#include <linux/kernel.h>
21
22#define KVM_UTIL_MIN_PFN 2
23
24u32 kvm_random_seed;
25struct kvm_random_state kvm_rng;
26static u32 last_kvm_seed;
27
28static void kvm_seed_rng(u32 seed)
29{
30 kvm_random_seed = last_kvm_seed = seed;
31 pr_info("Random seed: 0x%x\n", kvm_random_seed);
32 kvm_rng = new_kvm_random_state(kvm_random_seed);
33}
34
35static size_t vcpu_mmap_sz(void);
36
37int __open_path_or_exit(const char *path, int flags, const char *enoent_help)
38{
39 int fd;
40
41 fd = open(path, flags);
42 if (fd < 0)
43 goto error;
44
45 return fd;
46
47error:
48 if (errno == EACCES || errno == ENOENT)
49 ksft_exit_skip("- Cannot open '%s': %s. %s\n",
50 path, strerror(errno),
51 errno == EACCES ? "Root required?" : enoent_help);
52 TEST_FAIL("Failed to open '%s'", path);
53}
54
55int open_path_or_exit(const char *path, int flags)
56{
57 return __open_path_or_exit(path, flags, "");
58}
59
60/*
61 * Open KVM_DEV_PATH if available, otherwise exit the entire program.
62 *
63 * Input Args:
64 * flags - The flags to pass when opening KVM_DEV_PATH.
65 *
66 * Return:
67 * The opened file descriptor of /dev/kvm.
68 */
69static int _open_kvm_dev_path_or_exit(int flags)
70{
71 return __open_path_or_exit(KVM_DEV_PATH, flags, "Is KVM loaded and enabled?");
72}
73
74int open_kvm_dev_path_or_exit(void)
75{
76 return _open_kvm_dev_path_or_exit(O_RDONLY);
77}
78
79static ssize_t get_module_param(const char *module_name, const char *param,
80 void *buffer, size_t buffer_size)
81{
82 const int path_size = 128;
83 char path[path_size];
84 ssize_t bytes_read;
85 int fd, r;
86
87 /* Verify KVM is loaded, to provide a more helpful SKIP message. */
88 fd = open_kvm_dev_path_or_exit();
89 kvm_free_fd(fd);
90
91 r = snprintf(path, path_size, "/sys/module/%s/parameters/%s",
92 module_name, param);
93 TEST_ASSERT(r < path_size,
94 "Failed to construct sysfs path in %d bytes.", path_size);
95
96 fd = open_path_or_exit(path, O_RDONLY);
97
98 bytes_read = read(fd, buffer, buffer_size);
99 TEST_ASSERT(bytes_read > 0, "read(%s) returned %ld, wanted %ld bytes",
100 path, bytes_read, buffer_size);
101
102 kvm_free_fd(fd);
103 return bytes_read;
104}
105
106int kvm_get_module_param_integer(const char *module_name, const char *param)
107{
108 /*
109 * 16 bytes to hold a 64-bit value (1 byte per char), 1 byte for the
110 * NUL char, and 1 byte because the kernel sucks and inserts a newline
111 * at the end.
112 */
113 char value[16 + 1 + 1];
114 ssize_t r;
115
116 memset(value, '\0', sizeof(value));
117
118 r = get_module_param(module_name, param, value, sizeof(value));
119 TEST_ASSERT(value[r - 1] == '\n',
120 "Expected trailing newline, got char '%c'", value[r - 1]);
121
122 /*
123 * Squash the newline, otherwise atoi_paranoid() will complain about
124 * trailing non-NUL characters in the string.
125 */
126 value[r - 1] = '\0';
127 return atoi_paranoid(value);
128}
129
130bool kvm_get_module_param_bool(const char *module_name, const char *param)
131{
132 char value;
133 ssize_t r;
134
135 r = get_module_param(module_name, param, &value, sizeof(value));
136 TEST_ASSERT_EQ(r, 1);
137
138 if (value == 'Y')
139 return true;
140 else if (value == 'N')
141 return false;
142
143 TEST_FAIL("Unrecognized value '%c' for boolean module param", value);
144}
145
146/*
147 * Capability
148 *
149 * Input Args:
150 * cap - Capability
151 *
152 * Output Args: None
153 *
154 * Return:
155 * On success, the Value corresponding to the capability (KVM_CAP_*)
156 * specified by the value of cap. On failure a TEST_ASSERT failure
157 * is produced.
158 *
159 * Looks up and returns the value corresponding to the capability
160 * (KVM_CAP_*) given by cap.
161 */
162unsigned int kvm_check_cap(long cap)
163{
164 int ret;
165 int kvm_fd;
166
167 kvm_fd = open_kvm_dev_path_or_exit();
168 ret = __kvm_ioctl(kvm_fd, KVM_CHECK_EXTENSION, (void *)cap);
169 TEST_ASSERT(ret >= 0, KVM_IOCTL_ERROR(KVM_CHECK_EXTENSION, ret));
170
171 kvm_free_fd(kvm_fd);
172
173 return (unsigned int)ret;
174}
175
176void vm_enable_dirty_ring(struct kvm_vm *vm, u32 ring_size)
177{
178 if (vm_check_cap(vm, KVM_CAP_DIRTY_LOG_RING_ACQ_REL))
179 vm_enable_cap(vm, KVM_CAP_DIRTY_LOG_RING_ACQ_REL, ring_size);
180 else
181 vm_enable_cap(vm, KVM_CAP_DIRTY_LOG_RING, ring_size);
182 vm->dirty_ring_size = ring_size;
183}
184
185static void vm_open(struct kvm_vm *vm)
186{
187 vm->kvm_fd = _open_kvm_dev_path_or_exit(O_RDWR);
188
189 TEST_REQUIRE(kvm_has_cap(KVM_CAP_IMMEDIATE_EXIT));
190
191 vm->fd = __kvm_ioctl(vm->kvm_fd, KVM_CREATE_VM, (void *)vm->type);
192 TEST_ASSERT(vm->fd >= 0, KVM_IOCTL_ERROR(KVM_CREATE_VM, vm->fd));
193
194 if (kvm_has_cap(KVM_CAP_BINARY_STATS_FD))
195 vm->stats.fd = vm_get_stats_fd(vm);
196 else
197 vm->stats.fd = -1;
198}
199
200const char *vm_guest_mode_string(u32 i)
201{
202 static const char * const strings[] = {
203 [VM_MODE_P52V48_4K] = "PA-bits:52, VA-bits:48, 4K pages",
204 [VM_MODE_P52V48_16K] = "PA-bits:52, VA-bits:48, 16K pages",
205 [VM_MODE_P52V48_64K] = "PA-bits:52, VA-bits:48, 64K pages",
206 [VM_MODE_P48V48_4K] = "PA-bits:48, VA-bits:48, 4K pages",
207 [VM_MODE_P48V48_16K] = "PA-bits:48, VA-bits:48, 16K pages",
208 [VM_MODE_P48V48_64K] = "PA-bits:48, VA-bits:48, 64K pages",
209 [VM_MODE_P40V48_4K] = "PA-bits:40, VA-bits:48, 4K pages",
210 [VM_MODE_P40V48_16K] = "PA-bits:40, VA-bits:48, 16K pages",
211 [VM_MODE_P40V48_64K] = "PA-bits:40, VA-bits:48, 64K pages",
212 [VM_MODE_PXXVYY_4K] = "PA-bits:ANY, VA-bits:48 or 57, 4K pages",
213 [VM_MODE_P47V64_4K] = "PA-bits:47, VA-bits:64, 4K pages",
214 [VM_MODE_P44V64_4K] = "PA-bits:44, VA-bits:64, 4K pages",
215 [VM_MODE_P36V48_4K] = "PA-bits:36, VA-bits:48, 4K pages",
216 [VM_MODE_P36V48_16K] = "PA-bits:36, VA-bits:48, 16K pages",
217 [VM_MODE_P36V48_64K] = "PA-bits:36, VA-bits:48, 64K pages",
218 [VM_MODE_P47V47_16K] = "PA-bits:47, VA-bits:47, 16K pages",
219 [VM_MODE_P36V47_16K] = "PA-bits:36, VA-bits:47, 16K pages",
220 [VM_MODE_P56V57_4K] = "PA-bits:56, VA-bits:57, 4K pages",
221 [VM_MODE_P56V48_4K] = "PA-bits:56, VA-bits:48, 4K pages",
222 [VM_MODE_P56V39_4K] = "PA-bits:56, VA-bits:39, 4K pages",
223 [VM_MODE_P50V57_4K] = "PA-bits:50, VA-bits:57, 4K pages",
224 [VM_MODE_P50V48_4K] = "PA-bits:50, VA-bits:48, 4K pages",
225 [VM_MODE_P50V39_4K] = "PA-bits:50, VA-bits:39, 4K pages",
226 [VM_MODE_P41V57_4K] = "PA-bits:41, VA-bits:57, 4K pages",
227 [VM_MODE_P41V48_4K] = "PA-bits:41, VA-bits:48, 4K pages",
228 [VM_MODE_P41V39_4K] = "PA-bits:41, VA-bits:39, 4K pages",
229 };
230 _Static_assert(sizeof(strings)/sizeof(char *) == NUM_VM_MODES,
231 "Missing new mode strings?");
232
233 TEST_ASSERT(i < NUM_VM_MODES, "Guest mode ID %d too big", i);
234
235 return strings[i];
236}
237
238const struct vm_guest_mode_params vm_guest_mode_params[] = {
239 [VM_MODE_P52V48_4K] = { 52, 48, 0x1000, 12 },
240 [VM_MODE_P52V48_16K] = { 52, 48, 0x4000, 14 },
241 [VM_MODE_P52V48_64K] = { 52, 48, 0x10000, 16 },
242 [VM_MODE_P48V48_4K] = { 48, 48, 0x1000, 12 },
243 [VM_MODE_P48V48_16K] = { 48, 48, 0x4000, 14 },
244 [VM_MODE_P48V48_64K] = { 48, 48, 0x10000, 16 },
245 [VM_MODE_P40V48_4K] = { 40, 48, 0x1000, 12 },
246 [VM_MODE_P40V48_16K] = { 40, 48, 0x4000, 14 },
247 [VM_MODE_P40V48_64K] = { 40, 48, 0x10000, 16 },
248 [VM_MODE_PXXVYY_4K] = { 0, 0, 0x1000, 12 },
249 [VM_MODE_P47V64_4K] = { 47, 64, 0x1000, 12 },
250 [VM_MODE_P44V64_4K] = { 44, 64, 0x1000, 12 },
251 [VM_MODE_P36V48_4K] = { 36, 48, 0x1000, 12 },
252 [VM_MODE_P36V48_16K] = { 36, 48, 0x4000, 14 },
253 [VM_MODE_P36V48_64K] = { 36, 48, 0x10000, 16 },
254 [VM_MODE_P47V47_16K] = { 47, 47, 0x4000, 14 },
255 [VM_MODE_P36V47_16K] = { 36, 47, 0x4000, 14 },
256 [VM_MODE_P56V57_4K] = { 56, 57, 0x1000, 12 },
257 [VM_MODE_P56V48_4K] = { 56, 48, 0x1000, 12 },
258 [VM_MODE_P56V39_4K] = { 56, 39, 0x1000, 12 },
259 [VM_MODE_P50V57_4K] = { 50, 57, 0x1000, 12 },
260 [VM_MODE_P50V48_4K] = { 50, 48, 0x1000, 12 },
261 [VM_MODE_P50V39_4K] = { 50, 39, 0x1000, 12 },
262 [VM_MODE_P41V57_4K] = { 41, 57, 0x1000, 12 },
263 [VM_MODE_P41V48_4K] = { 41, 48, 0x1000, 12 },
264 [VM_MODE_P41V39_4K] = { 41, 39, 0x1000, 12 },
265};
266_Static_assert(sizeof(vm_guest_mode_params)/sizeof(struct vm_guest_mode_params) == NUM_VM_MODES,
267 "Missing new mode params?");
268
269/*
270 * Initializes vm->vpages_valid to match the canonical VA space of the
271 * architecture.
272 *
273 * The default implementation is valid for architectures which split the
274 * range addressed by a single page table into a low and high region
275 * based on the MSB of the VA. On architectures with this behavior
276 * the VA region spans [0, 2^(va_bits - 1)), [-(2^(va_bits - 1), -1].
277 */
278__weak void vm_populate_gva_bitmap(struct kvm_vm *vm)
279{
280 sparsebit_set_num(vm->vpages_valid,
281 0, (1ULL << (vm->va_bits - 1)) >> vm->page_shift);
282 sparsebit_set_num(vm->vpages_valid,
283 (~((1ULL << (vm->va_bits - 1)) - 1)) >> vm->page_shift,
284 (1ULL << (vm->va_bits - 1)) >> vm->page_shift);
285}
286
287struct kvm_vm *____vm_create(struct vm_shape shape)
288{
289 struct kvm_vm *vm;
290
291 vm = calloc(1, sizeof(*vm));
292 TEST_ASSERT(vm != NULL, "Insufficient Memory");
293
294 INIT_LIST_HEAD(&vm->vcpus);
295 vm->regions.gpa_tree = RB_ROOT;
296 vm->regions.hva_tree = RB_ROOT;
297 hash_init(vm->regions.slot_hash);
298
299 vm->mode = shape.mode;
300 vm->type = shape.type;
301
302 vm->pa_bits = vm_guest_mode_params[vm->mode].pa_bits;
303 vm->va_bits = vm_guest_mode_params[vm->mode].va_bits;
304 vm->page_size = vm_guest_mode_params[vm->mode].page_size;
305 vm->page_shift = vm_guest_mode_params[vm->mode].page_shift;
306
307 /* Setup mode specific traits. */
308 switch (vm->mode) {
309 case VM_MODE_P52V48_4K:
310 vm->mmu.pgtable_levels = 4;
311 break;
312 case VM_MODE_P52V48_64K:
313 vm->mmu.pgtable_levels = 3;
314 break;
315 case VM_MODE_P48V48_4K:
316 vm->mmu.pgtable_levels = 4;
317 break;
318 case VM_MODE_P48V48_64K:
319 vm->mmu.pgtable_levels = 3;
320 break;
321 case VM_MODE_P40V48_4K:
322 case VM_MODE_P36V48_4K:
323 vm->mmu.pgtable_levels = 4;
324 break;
325 case VM_MODE_P40V48_64K:
326 case VM_MODE_P36V48_64K:
327 vm->mmu.pgtable_levels = 3;
328 break;
329 case VM_MODE_P52V48_16K:
330 case VM_MODE_P48V48_16K:
331 case VM_MODE_P40V48_16K:
332 case VM_MODE_P36V48_16K:
333 vm->mmu.pgtable_levels = 4;
334 break;
335 case VM_MODE_P47V47_16K:
336 case VM_MODE_P36V47_16K:
337 vm->mmu.pgtable_levels = 3;
338 break;
339 case VM_MODE_PXXVYY_4K:
340#ifdef __x86_64__
341 kvm_get_cpu_address_width(&vm->pa_bits, &vm->va_bits);
342 kvm_init_vm_address_properties(vm);
343
344 pr_debug("Guest physical address width detected: %d\n",
345 vm->pa_bits);
346 pr_debug("Guest virtual address width detected: %d\n",
347 vm->va_bits);
348
349 if (vm->va_bits == 57) {
350 vm->mmu.pgtable_levels = 5;
351 } else {
352 TEST_ASSERT(vm->va_bits == 48,
353 "Unexpected guest virtual address width: %d",
354 vm->va_bits);
355 vm->mmu.pgtable_levels = 4;
356 }
357#else
358 TEST_FAIL("VM_MODE_PXXVYY_4K not supported on non-x86 platforms");
359#endif
360 break;
361 case VM_MODE_P47V64_4K:
362 vm->mmu.pgtable_levels = 5;
363 break;
364 case VM_MODE_P44V64_4K:
365 vm->mmu.pgtable_levels = 5;
366 break;
367 case VM_MODE_P56V57_4K:
368 case VM_MODE_P50V57_4K:
369 case VM_MODE_P41V57_4K:
370 vm->mmu.pgtable_levels = 5;
371 break;
372 case VM_MODE_P56V48_4K:
373 case VM_MODE_P50V48_4K:
374 case VM_MODE_P41V48_4K:
375 vm->mmu.pgtable_levels = 4;
376 break;
377 case VM_MODE_P56V39_4K:
378 case VM_MODE_P50V39_4K:
379 case VM_MODE_P41V39_4K:
380 vm->mmu.pgtable_levels = 3;
381 break;
382 default:
383 TEST_FAIL("Unknown guest mode: 0x%x", vm->mode);
384 }
385
386#ifdef __aarch64__
387 TEST_ASSERT(!vm->type, "ARM doesn't support test-provided types");
388 if (vm->pa_bits != 40)
389 vm->type = KVM_VM_TYPE_ARM_IPA_SIZE(vm->pa_bits);
390#endif
391
392 vm_open(vm);
393
394 /* Limit to VA-bit canonical virtual addresses. */
395 vm->vpages_valid = sparsebit_alloc();
396 vm_populate_gva_bitmap(vm);
397
398 /* Limit physical addresses to PA-bits. */
399 vm->max_gfn = vm_compute_max_gfn(vm);
400
401 /* Allocate and setup memory for guest. */
402 vm->vpages_mapped = sparsebit_alloc();
403
404 return vm;
405}
406
407static u64 vm_nr_pages_required(enum vm_guest_mode mode,
408 u32 nr_runnable_vcpus,
409 u64 extra_mem_pages)
410{
411 u64 page_size = vm_guest_mode_params[mode].page_size;
412 u64 nr_pages;
413
414 TEST_ASSERT(nr_runnable_vcpus,
415 "Use vm_create_barebones() for VMs that _never_ have vCPUs");
416
417 TEST_ASSERT(nr_runnable_vcpus <= kvm_check_cap(KVM_CAP_MAX_VCPUS),
418 "nr_vcpus = %d too large for host, max-vcpus = %d",
419 nr_runnable_vcpus, kvm_check_cap(KVM_CAP_MAX_VCPUS));
420
421 /*
422 * Arbitrarily allocate 512 pages (2mb when page size is 4kb) for the
423 * test code and other per-VM assets that will be loaded into memslot0.
424 */
425 nr_pages = 512;
426
427 /* Account for the per-vCPU stacks on behalf of the test. */
428 nr_pages += nr_runnable_vcpus * DEFAULT_STACK_PGS;
429
430 /*
431 * Account for the number of pages needed for the page tables. The
432 * maximum page table size for a memory region will be when the
433 * smallest page size is used. Considering each page contains x page
434 * table descriptors, the total extra size for page tables (for extra
435 * N pages) will be: N/x+N/x^2+N/x^3+... which is definitely smaller
436 * than N/x*2.
437 */
438 nr_pages += (nr_pages + extra_mem_pages) / PTES_PER_MIN_PAGE * 2;
439
440 /* Account for the number of pages needed by ucall. */
441 nr_pages += ucall_nr_pages_required(page_size);
442
443 return vm_adjust_num_guest_pages(mode, nr_pages);
444}
445
446void kvm_set_files_rlimit(u32 nr_vcpus)
447{
448 /*
449 * Each vCPU will open two file descriptors: the vCPU itself and the
450 * vCPU's binary stats file descriptor. Add an arbitrary amount of
451 * buffer for all other files a test may open.
452 */
453 int nr_fds_wanted = nr_vcpus * 2 + 100;
454 struct rlimit rl;
455
456 /*
457 * Check that we're allowed to open nr_fds_wanted file descriptors and
458 * try raising the limits if needed.
459 */
460 TEST_ASSERT(!getrlimit(RLIMIT_NOFILE, &rl), "getrlimit() failed!");
461
462 if (rl.rlim_cur < nr_fds_wanted) {
463 rl.rlim_cur = nr_fds_wanted;
464 if (rl.rlim_max < nr_fds_wanted) {
465 int old_rlim_max = rl.rlim_max;
466
467 rl.rlim_max = nr_fds_wanted;
468 __TEST_REQUIRE(setrlimit(RLIMIT_NOFILE, &rl) >= 0,
469 "RLIMIT_NOFILE hard limit is too low (%d, wanted %d)",
470 old_rlim_max, nr_fds_wanted);
471 } else {
472 TEST_ASSERT(!setrlimit(RLIMIT_NOFILE, &rl), "setrlimit() failed!");
473 }
474 }
475
476}
477
478static bool is_guest_memfd_required(struct vm_shape shape)
479{
480#ifdef __x86_64__
481 return shape.type == KVM_X86_SNP_VM;
482#else
483 return false;
484#endif
485}
486
487struct kvm_vm *__vm_create(struct vm_shape shape, u32 nr_runnable_vcpus,
488 u64 nr_extra_pages)
489{
490 u64 nr_pages = vm_nr_pages_required(shape.mode, nr_runnable_vcpus,
491 nr_extra_pages);
492 struct userspace_mem_region *slot0;
493 struct kvm_vm *vm;
494 int i, flags;
495
496 kvm_set_files_rlimit(nr_runnable_vcpus);
497
498 pr_debug("%s: mode='%s' type='%d', pages='%ld'\n", __func__,
499 vm_guest_mode_string(shape.mode), shape.type, nr_pages);
500
501 vm = ____vm_create(shape);
502
503 /*
504 * Force GUEST_MEMFD for the primary memory region if necessary, e.g.
505 * for CoCo VMs that require GUEST_MEMFD backed private memory.
506 */
507 flags = 0;
508 if (is_guest_memfd_required(shape))
509 flags |= KVM_MEM_GUEST_MEMFD;
510
511 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, 0, 0, nr_pages, flags);
512 for (i = 0; i < NR_MEM_REGIONS; i++)
513 vm->memslots[i] = 0;
514
515 kvm_vm_elf_load(vm, program_invocation_name);
516
517 /*
518 * TODO: Add proper defines to protect the library's memslots, and then
519 * carve out memslot1 for the ucall MMIO address. KVM treats writes to
520 * read-only memslots as MMIO, and creating a read-only memslot for the
521 * MMIO region would prevent silently clobbering the MMIO region.
522 */
523 slot0 = memslot2region(vm, 0);
524 ucall_init(vm, slot0->region.guest_phys_addr + slot0->region.memory_size);
525
526 if (kvm_random_seed != last_kvm_seed)
527 kvm_seed_rng(kvm_random_seed);
528
529 sync_global_to_guest(vm, kvm_rng);
530
531 kvm_arch_vm_post_create(vm, nr_runnable_vcpus);
532
533 return vm;
534}
535
536/*
537 * VM Create with customized parameters
538 *
539 * Input Args:
540 * mode - VM Mode (e.g. VM_MODE_P52V48_4K)
541 * nr_vcpus - VCPU count
542 * extra_mem_pages - Non-slot0 physical memory total size
543 * guest_code - Guest entry point
544 * vcpuids - VCPU IDs
545 *
546 * Output Args: None
547 *
548 * Return:
549 * Pointer to opaque structure that describes the created VM.
550 *
551 * Creates a VM with the mode specified by mode (e.g. VM_MODE_P52V48_4K).
552 * extra_mem_pages is only used to calculate the maximum page table size,
553 * no real memory allocation for non-slot0 memory in this function.
554 */
555struct kvm_vm *__vm_create_with_vcpus(struct vm_shape shape, u32 nr_vcpus,
556 u64 extra_mem_pages,
557 void *guest_code, struct kvm_vcpu *vcpus[])
558{
559 struct kvm_vm *vm;
560 int i;
561
562 TEST_ASSERT(!nr_vcpus || vcpus, "Must provide vCPU array");
563
564 vm = __vm_create(shape, nr_vcpus, extra_mem_pages);
565
566 for (i = 0; i < nr_vcpus; ++i)
567 vcpus[i] = vm_vcpu_add(vm, i, guest_code);
568
569 kvm_arch_vm_finalize_vcpus(vm);
570 return vm;
571}
572
573struct kvm_vm *__vm_create_shape_with_one_vcpu(struct vm_shape shape,
574 struct kvm_vcpu **vcpu,
575 u64 extra_mem_pages,
576 void *guest_code)
577{
578 struct kvm_vcpu *vcpus[1];
579 struct kvm_vm *vm;
580
581 vm = __vm_create_with_vcpus(shape, 1, extra_mem_pages, guest_code, vcpus);
582
583 *vcpu = vcpus[0];
584 return vm;
585}
586
587/*
588 * VM Restart
589 *
590 * Input Args:
591 * vm - VM that has been released before
592 *
593 * Output Args: None
594 *
595 * Reopens the file descriptors associated to the VM and reinstates the
596 * global state, such as the irqchip and the memory regions that are mapped
597 * into the guest.
598 */
599void kvm_vm_restart(struct kvm_vm *vmp)
600{
601 int ctr;
602 struct userspace_mem_region *region;
603
604 vm_open(vmp);
605 if (vmp->has_irqchip)
606 vm_create_irqchip(vmp);
607
608 hash_for_each(vmp->regions.slot_hash, ctr, region, slot_node) {
609 int ret = ioctl(vmp->fd, KVM_SET_USER_MEMORY_REGION2, &region->region);
610
611 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION2 IOCTL failed,\n"
612 " rc: %i errno: %i\n"
613 " slot: %u flags: 0x%x\n"
614 " guest_phys_addr: 0x%llx size: 0x%llx",
615 ret, errno, region->region.slot,
616 region->region.flags,
617 region->region.guest_phys_addr,
618 region->region.memory_size);
619 }
620}
621
622__weak struct kvm_vcpu *vm_arch_vcpu_recreate(struct kvm_vm *vm,
623 u32 vcpu_id)
624{
625 return __vm_vcpu_add(vm, vcpu_id);
626}
627
628struct kvm_vcpu *vm_recreate_with_one_vcpu(struct kvm_vm *vm)
629{
630 kvm_vm_restart(vm);
631
632 return vm_vcpu_recreate(vm, 0);
633}
634
635int __pin_task_to_cpu(pthread_t task, int cpu)
636{
637 cpu_set_t cpuset;
638
639 CPU_ZERO(&cpuset);
640 CPU_SET(cpu, &cpuset);
641
642 return pthread_setaffinity_np(task, sizeof(cpuset), &cpuset);
643}
644
645static u32 parse_pcpu(const char *cpu_str, const cpu_set_t *allowed_mask)
646{
647 u32 pcpu = atoi_non_negative("CPU number", cpu_str);
648
649 TEST_ASSERT(CPU_ISSET(pcpu, allowed_mask),
650 "Not allowed to run on pCPU '%d', check cgroups?", pcpu);
651 return pcpu;
652}
653
654void kvm_print_vcpu_pinning_help(void)
655{
656 const char *name = program_invocation_name;
657
658 printf(" -c: Pin tasks to physical CPUs. Takes a list of comma separated\n"
659 " values (target pCPU), one for each vCPU, plus an optional\n"
660 " entry for the main application task (specified via entry\n"
661 " <nr_vcpus + 1>). If used, entries must be provided for all\n"
662 " vCPUs, i.e. pinning vCPUs is all or nothing.\n\n"
663 " E.g. to create 3 vCPUs, pin vCPU0=>pCPU22, vCPU1=>pCPU23,\n"
664 " vCPU2=>pCPU24, and pin the application task to pCPU50:\n\n"
665 " %s -v 3 -c 22,23,24,50\n\n"
666 " To leave the application task unpinned, drop the final entry:\n\n"
667 " %s -v 3 -c 22,23,24\n\n"
668 " (default: no pinning)\n", name, name);
669}
670
671int kvm_pick_random_cpu(cpu_set_t *possible_cpus)
672{
673 int target_idx;
674 int nr_cpus;
675 int cpu;
676
677 nr_cpus = CPU_COUNT(possible_cpus);
678 TEST_ASSERT(nr_cpus > 0, "No CPUs available in possible_cpus");
679
680 target_idx = kvm_random_u64(&kvm_rng) % nr_cpus;
681
682 for (cpu = 0; cpu < CPU_SETSIZE; cpu++) {
683 if (CPU_ISSET(cpu, possible_cpus) && target_idx-- == 0)
684 return cpu;
685 }
686 TEST_FAIL("Failed to find random CPU in possible_cpus");
687 return -1;
688}
689
690void kvm_parse_vcpu_pinning(const char *pcpus_string, u32 vcpu_to_pcpu[],
691 int nr_vcpus)
692{
693 cpu_set_t allowed_mask;
694 char *cpu, *cpu_list;
695 char delim[2] = ",";
696 int i;
697
698 cpu_list = strdup(pcpus_string);
699 TEST_ASSERT(cpu_list, "strdup() allocation failed.");
700
701 kvm_sched_getaffinity(0, sizeof(allowed_mask), &allowed_mask);
702
703 cpu = strtok(cpu_list, delim);
704
705 /* 1. Get all pcpus for vcpus. */
706 for (i = 0; i < nr_vcpus; i++) {
707 TEST_ASSERT(cpu, "pCPU not provided for vCPU '%d'", i);
708 vcpu_to_pcpu[i] = parse_pcpu(cpu, &allowed_mask);
709 cpu = strtok(NULL, delim);
710 }
711
712 /* 2. Check if the main worker needs to be pinned. */
713 if (cpu) {
714 pin_self_to_cpu(parse_pcpu(cpu, &allowed_mask));
715 cpu = strtok(NULL, delim);
716 }
717
718 TEST_ASSERT(!cpu, "pCPU list contains trailing garbage characters '%s'", cpu);
719 free(cpu_list);
720}
721
722/*
723 * Userspace Memory Region Find
724 *
725 * Input Args:
726 * vm - Virtual Machine
727 * start - Starting VM physical address
728 * end - Ending VM physical address, inclusive.
729 *
730 * Output Args: None
731 *
732 * Return:
733 * Pointer to overlapping region, NULL if no such region.
734 *
735 * Searches for a region with any physical memory that overlaps with
736 * any portion of the guest physical addresses from start to end
737 * inclusive. If multiple overlapping regions exist, a pointer to any
738 * of the regions is returned. Null is returned only when no overlapping
739 * region exists.
740 */
741static struct userspace_mem_region *
742userspace_mem_region_find(struct kvm_vm *vm, u64 start, u64 end)
743{
744 struct rb_node *node;
745
746 for (node = vm->regions.gpa_tree.rb_node; node; ) {
747 struct userspace_mem_region *region =
748 container_of(node, struct userspace_mem_region, gpa_node);
749 u64 existing_start = region->region.guest_phys_addr;
750 u64 existing_end = region->region.guest_phys_addr
751 + region->region.memory_size - 1;
752 if (start <= existing_end && end >= existing_start)
753 return region;
754
755 if (start < existing_start)
756 node = node->rb_left;
757 else
758 node = node->rb_right;
759 }
760
761 return NULL;
762}
763
764static void kvm_stats_release(struct kvm_binary_stats *stats)
765{
766 if (stats->fd < 0)
767 return;
768
769 if (stats->desc) {
770 free(stats->desc);
771 stats->desc = NULL;
772 }
773
774 kvm_free_fd(stats->fd);
775}
776
777__weak void vcpu_arch_free(struct kvm_vcpu *vcpu)
778{
779
780}
781
782/*
783 * VM VCPU Remove
784 *
785 * Input Args:
786 * vcpu - VCPU to remove
787 *
788 * Output Args: None
789 *
790 * Return: None, TEST_ASSERT failures for all error conditions
791 *
792 * Removes a vCPU from a VM and frees its resources.
793 */
794static void vm_vcpu_rm(struct kvm_vm *vm, struct kvm_vcpu *vcpu)
795{
796 if (vcpu->dirty_gfns) {
797 kvm_munmap(vcpu->dirty_gfns, vm->dirty_ring_size);
798 vcpu->dirty_gfns = NULL;
799 }
800
801 kvm_munmap(vcpu->run, vcpu_mmap_sz());
802
803 kvm_free_fd(vcpu->fd);
804 kvm_stats_release(&vcpu->stats);
805
806 list_del(&vcpu->list);
807
808 vcpu_arch_free(vcpu);
809 free(vcpu);
810}
811
812void kvm_vm_release(struct kvm_vm *vmp)
813{
814 struct kvm_vcpu *vcpu, *tmp;
815
816 list_for_each_entry_safe(vcpu, tmp, &vmp->vcpus, list)
817 vm_vcpu_rm(vmp, vcpu);
818
819 kvm_free_fd(vmp->fd);
820 kvm_free_fd(vmp->kvm_fd);
821
822 /* Free cached stats metadata and close FD */
823 kvm_stats_release(&vmp->stats);
824
825 kvm_arch_vm_release(vmp);
826}
827
828static void __vm_mem_region_delete(struct kvm_vm *vm,
829 struct userspace_mem_region *region)
830{
831 rb_erase(&region->gpa_node, &vm->regions.gpa_tree);
832 rb_erase(&region->hva_node, &vm->regions.hva_tree);
833 hash_del(&region->slot_node);
834
835 sparsebit_free(&region->unused_phy_pages);
836 sparsebit_free(&region->protected_phy_pages);
837 kvm_munmap(region->mmap_start, region->mmap_size);
838 if (region->fd >= 0) {
839 /* There's an extra map when using shared memory. */
840 kvm_munmap(region->mmap_alias, region->mmap_size);
841 kvm_free_fd(region->fd);
842 }
843 if ((int)region->region.guest_memfd >= 0)
844 kvm_free_fd(region->region.guest_memfd);
845
846 free(region);
847}
848
849/*
850 * Destroys and frees the VM pointed to by vmp.
851 */
852void kvm_vm_free(struct kvm_vm *vmp)
853{
854 int ctr;
855 struct hlist_node *node;
856 struct userspace_mem_region *region;
857
858 if (vmp == NULL)
859 return;
860
861 /* Free userspace_mem_regions. */
862 hash_for_each_safe(vmp->regions.slot_hash, ctr, node, region, slot_node)
863 __vm_mem_region_delete(vmp, region);
864
865 /* Free sparsebit arrays. */
866 sparsebit_free(&vmp->vpages_valid);
867 sparsebit_free(&vmp->vpages_mapped);
868
869 kvm_vm_release(vmp);
870
871 /* Free the structure describing the VM. */
872 free(vmp);
873}
874
875int kvm_memfd_alloc(size_t size, bool hugepages)
876{
877 int memfd_flags = MFD_CLOEXEC;
878 int fd;
879
880 if (hugepages)
881 memfd_flags |= MFD_HUGETLB;
882
883 fd = memfd_create("kvm_selftest", memfd_flags);
884 TEST_ASSERT(fd != -1, __KVM_SYSCALL_ERROR("memfd_create()", fd));
885
886 kvm_ftruncate(fd, size);
887 kvm_fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 0, size);
888
889 return fd;
890}
891
892static void vm_userspace_mem_region_gpa_insert(struct rb_root *gpa_tree,
893 struct userspace_mem_region *region)
894{
895 struct rb_node **cur, *parent;
896
897 for (cur = &gpa_tree->rb_node, parent = NULL; *cur; ) {
898 struct userspace_mem_region *cregion;
899
900 cregion = container_of(*cur, typeof(*cregion), gpa_node);
901 parent = *cur;
902 if (region->region.guest_phys_addr <
903 cregion->region.guest_phys_addr)
904 cur = &(*cur)->rb_left;
905 else {
906 TEST_ASSERT(region->region.guest_phys_addr !=
907 cregion->region.guest_phys_addr,
908 "Duplicate GPA in region tree");
909
910 cur = &(*cur)->rb_right;
911 }
912 }
913
914 rb_link_node(&region->gpa_node, parent, cur);
915 rb_insert_color(&region->gpa_node, gpa_tree);
916}
917
918static void vm_userspace_mem_region_hva_insert(struct rb_root *hva_tree,
919 struct userspace_mem_region *region)
920{
921 struct rb_node **cur, *parent;
922
923 for (cur = &hva_tree->rb_node, parent = NULL; *cur; ) {
924 struct userspace_mem_region *cregion;
925
926 cregion = container_of(*cur, typeof(*cregion), hva_node);
927 parent = *cur;
928 if (region->host_mem < cregion->host_mem)
929 cur = &(*cur)->rb_left;
930 else {
931 TEST_ASSERT(region->host_mem !=
932 cregion->host_mem,
933 "Duplicate HVA in region tree");
934
935 cur = &(*cur)->rb_right;
936 }
937 }
938
939 rb_link_node(&region->hva_node, parent, cur);
940 rb_insert_color(&region->hva_node, hva_tree);
941}
942
943
944int __vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
945 gpa_t gpa, u64 size, void *hva)
946{
947 struct kvm_userspace_memory_region region = {
948 .slot = slot,
949 .flags = flags,
950 .guest_phys_addr = gpa,
951 .memory_size = size,
952 .userspace_addr = (uintptr_t)hva,
953 };
954
955 return ioctl(vm->fd, KVM_SET_USER_MEMORY_REGION, &region);
956}
957
958void vm_set_user_memory_region(struct kvm_vm *vm, u32 slot, u32 flags,
959 gpa_t gpa, u64 size, void *hva)
960{
961 int ret = __vm_set_user_memory_region(vm, slot, flags, gpa, size, hva);
962
963 TEST_ASSERT(!ret, "KVM_SET_USER_MEMORY_REGION failed, errno = %d (%s)",
964 errno, strerror(errno));
965}
966
967#define TEST_REQUIRE_SET_USER_MEMORY_REGION2() \
968 __TEST_REQUIRE(kvm_has_cap(KVM_CAP_USER_MEMORY2), \
969 "KVM selftests now require KVM_SET_USER_MEMORY_REGION2 (introduced in v6.8)")
970
971int __vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
972 gpa_t gpa, u64 size, void *hva,
973 u32 guest_memfd, u64 guest_memfd_offset)
974{
975 struct kvm_userspace_memory_region2 region = {
976 .slot = slot,
977 .flags = flags,
978 .guest_phys_addr = gpa,
979 .memory_size = size,
980 .userspace_addr = (uintptr_t)hva,
981 .guest_memfd = guest_memfd,
982 .guest_memfd_offset = guest_memfd_offset,
983 };
984
985 TEST_REQUIRE_SET_USER_MEMORY_REGION2();
986
987 return ioctl(vm->fd, KVM_SET_USER_MEMORY_REGION2, &region);
988}
989
990void vm_set_user_memory_region2(struct kvm_vm *vm, u32 slot, u32 flags,
991 gpa_t gpa, u64 size, void *hva,
992 u32 guest_memfd, u64 guest_memfd_offset)
993{
994 int ret = __vm_set_user_memory_region2(vm, slot, flags, gpa, size, hva,
995 guest_memfd, guest_memfd_offset);
996
997 TEST_ASSERT(!ret, "KVM_SET_USER_MEMORY_REGION2 failed, errno = %d (%s)",
998 errno, strerror(errno));
999}
1000
1001
1002/* FIXME: This thing needs to be ripped apart and rewritten. */
1003void vm_mem_add(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,
1004 gpa_t gpa, u32 slot, u64 npages, u32 flags,
1005 int guest_memfd, u64 guest_memfd_offset)
1006{
1007 int ret;
1008 struct userspace_mem_region *region;
1009 size_t backing_src_pagesz = get_backing_src_pagesz(src_type);
1010 size_t mem_size = npages * vm->page_size;
1011 size_t alignment = 1;
1012
1013 TEST_REQUIRE_SET_USER_MEMORY_REGION2();
1014
1015 TEST_ASSERT(vm_adjust_num_guest_pages(vm->mode, npages) == npages,
1016 "Number of guest pages is not compatible with the host. "
1017 "Try npages=%d", vm_adjust_num_guest_pages(vm->mode, npages));
1018
1019 TEST_ASSERT((gpa % vm->page_size) == 0, "Guest physical "
1020 "address not on a page boundary.\n"
1021 " gpa: 0x%lx vm->page_size: 0x%x",
1022 gpa, vm->page_size);
1023 TEST_ASSERT((((gpa >> vm->page_shift) + npages) - 1)
1024 <= vm->max_gfn, "Physical range beyond maximum "
1025 "supported physical address,\n"
1026 " gpa: 0x%lx npages: 0x%lx\n"
1027 " vm->max_gfn: 0x%lx vm->page_size: 0x%x",
1028 gpa, npages, vm->max_gfn, vm->page_size);
1029
1030 /*
1031 * Confirm a mem region with an overlapping address doesn't
1032 * already exist.
1033 */
1034 region = (struct userspace_mem_region *) userspace_mem_region_find(
1035 vm, gpa, (gpa + npages * vm->page_size) - 1);
1036 if (region != NULL)
1037 TEST_FAIL("overlapping userspace_mem_region already "
1038 "exists\n"
1039 " requested gpa: 0x%lx npages: 0x%lx page_size: 0x%x\n"
1040 " existing gpa: 0x%lx size: 0x%lx",
1041 gpa, npages, vm->page_size,
1042 (u64)region->region.guest_phys_addr,
1043 (u64)region->region.memory_size);
1044
1045 /* Confirm no region with the requested slot already exists. */
1046 hash_for_each_possible(vm->regions.slot_hash, region, slot_node,
1047 slot) {
1048 if (region->region.slot != slot)
1049 continue;
1050
1051 TEST_FAIL("A mem region with the requested slot "
1052 "already exists.\n"
1053 " requested slot: %u gpa: 0x%lx npages: 0x%lx\n"
1054 " existing slot: %u gpa: 0x%lx size: 0x%lx",
1055 slot, gpa, npages, region->region.slot,
1056 (u64)region->region.guest_phys_addr,
1057 (u64)region->region.memory_size);
1058 }
1059
1060 /* Allocate and initialize new mem region structure. */
1061 region = calloc(1, sizeof(*region));
1062 TEST_ASSERT(region != NULL, "Insufficient Memory");
1063 region->mmap_size = mem_size;
1064
1065 /*
1066 * When using THP mmap is not guaranteed to returned a hugepage aligned
1067 * address so we have to pad the mmap. Padding is not needed for HugeTLB
1068 * because mmap will always return an address aligned to the HugeTLB
1069 * page size.
1070 */
1071 if (src_type == VM_MEM_SRC_ANONYMOUS_THP)
1072 alignment = max(backing_src_pagesz, alignment);
1073
1074 TEST_ASSERT_EQ(gpa, align_up(gpa, backing_src_pagesz));
1075
1076 /* Add enough memory to align up if necessary */
1077 if (alignment > 1)
1078 region->mmap_size += alignment;
1079
1080 region->fd = -1;
1081 if (backing_src_is_shared(src_type))
1082 region->fd = kvm_memfd_alloc(region->mmap_size,
1083 src_type == VM_MEM_SRC_SHARED_HUGETLB);
1084
1085 region->mmap_start = kvm_mmap(region->mmap_size, PROT_READ | PROT_WRITE,
1086 vm_mem_backing_src_alias(src_type)->flag,
1087 region->fd);
1088
1089 TEST_ASSERT(!is_backing_src_hugetlb(src_type) ||
1090 region->mmap_start == align_ptr_up(region->mmap_start, backing_src_pagesz),
1091 "mmap_start %p is not aligned to HugeTLB page size 0x%lx",
1092 region->mmap_start, backing_src_pagesz);
1093
1094 /* Align host address */
1095 region->host_mem = align_ptr_up(region->mmap_start, alignment);
1096
1097 /* As needed perform madvise */
1098 if ((src_type == VM_MEM_SRC_ANONYMOUS ||
1099 src_type == VM_MEM_SRC_ANONYMOUS_THP) && thp_configured()) {
1100 ret = madvise(region->host_mem, mem_size,
1101 src_type == VM_MEM_SRC_ANONYMOUS ? MADV_NOHUGEPAGE : MADV_HUGEPAGE);
1102 TEST_ASSERT(ret == 0, "madvise failed, addr: %p length: 0x%lx src_type: %s",
1103 region->host_mem, mem_size,
1104 vm_mem_backing_src_alias(src_type)->name);
1105 }
1106
1107 region->backing_src_type = src_type;
1108
1109 if (flags & KVM_MEM_GUEST_MEMFD) {
1110 if (guest_memfd < 0) {
1111 u32 guest_memfd_flags = 0;
1112 TEST_ASSERT(!guest_memfd_offset,
1113 "Offset must be zero when creating new guest_memfd");
1114 guest_memfd = vm_create_guest_memfd(vm, mem_size, guest_memfd_flags);
1115 } else {
1116 /*
1117 * Install a unique fd for each memslot so that the fd
1118 * can be closed when the region is deleted without
1119 * needing to track if the fd is owned by the framework
1120 * or by the caller.
1121 */
1122 guest_memfd = kvm_dup(guest_memfd);
1123 }
1124
1125 region->region.guest_memfd = guest_memfd;
1126 region->region.guest_memfd_offset = guest_memfd_offset;
1127 } else {
1128 region->region.guest_memfd = -1;
1129 }
1130
1131 region->unused_phy_pages = sparsebit_alloc();
1132 if (vm_arch_has_protected_memory(vm))
1133 region->protected_phy_pages = sparsebit_alloc();
1134 sparsebit_set_num(region->unused_phy_pages, gpa >> vm->page_shift, npages);
1135 region->region.slot = slot;
1136 region->region.flags = flags;
1137 region->region.guest_phys_addr = gpa;
1138 region->region.memory_size = npages * vm->page_size;
1139 region->region.userspace_addr = (uintptr_t) region->host_mem;
1140 ret = __vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);
1141 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION2 IOCTL failed,\n"
1142 " rc: %i errno: %i\n"
1143 " slot: %u flags: 0x%x\n"
1144 " guest_phys_addr: 0x%lx size: 0x%llx guest_memfd: %d",
1145 ret, errno, slot, flags, gpa, region->region.memory_size,
1146 region->region.guest_memfd);
1147
1148 /* Add to quick lookup data structures */
1149 vm_userspace_mem_region_gpa_insert(&vm->regions.gpa_tree, region);
1150 vm_userspace_mem_region_hva_insert(&vm->regions.hva_tree, region);
1151 hash_add(vm->regions.slot_hash, &region->slot_node, slot);
1152
1153 /* If shared memory, create an alias. */
1154 if (region->fd >= 0) {
1155 region->mmap_alias = kvm_mmap(region->mmap_size,
1156 PROT_READ | PROT_WRITE,
1157 vm_mem_backing_src_alias(src_type)->flag,
1158 region->fd);
1159
1160 /* Align host alias address */
1161 region->host_alias = align_ptr_up(region->mmap_alias, alignment);
1162 }
1163}
1164
1165void vm_userspace_mem_region_add(struct kvm_vm *vm,
1166 enum vm_mem_backing_src_type src_type,
1167 gpa_t gpa, u32 slot, u64 npages, u32 flags)
1168{
1169 vm_mem_add(vm, src_type, gpa, slot, npages, flags, -1, 0);
1170}
1171
1172/*
1173 * Memslot to region
1174 *
1175 * Input Args:
1176 * vm - Virtual Machine
1177 * memslot - KVM memory slot ID
1178 *
1179 * Output Args: None
1180 *
1181 * Return:
1182 * Pointer to memory region structure that describe memory region
1183 * using kvm memory slot ID given by memslot. TEST_ASSERT failure
1184 * on error (e.g. currently no memory region using memslot as a KVM
1185 * memory slot ID).
1186 */
1187struct userspace_mem_region *
1188memslot2region(struct kvm_vm *vm, u32 memslot)
1189{
1190 struct userspace_mem_region *region;
1191
1192 hash_for_each_possible(vm->regions.slot_hash, region, slot_node,
1193 memslot)
1194 if (region->region.slot == memslot)
1195 return region;
1196
1197 fprintf(stderr, "No mem region with the requested slot found,\n"
1198 " requested slot: %u\n", memslot);
1199 fputs("---- vm dump ----\n", stderr);
1200 vm_dump(stderr, vm, 2);
1201 TEST_FAIL("Mem region not found");
1202 return NULL;
1203}
1204
1205/*
1206 * VM Memory Region Flags Set
1207 *
1208 * Input Args:
1209 * vm - Virtual Machine
1210 * flags - Starting guest physical address
1211 *
1212 * Output Args: None
1213 *
1214 * Return: None
1215 *
1216 * Sets the flags of the memory region specified by the value of slot,
1217 * to the values given by flags.
1218 */
1219void vm_mem_region_set_flags(struct kvm_vm *vm, u32 slot, u32 flags)
1220{
1221 int ret;
1222 struct userspace_mem_region *region;
1223
1224 region = memslot2region(vm, slot);
1225
1226 region->region.flags = flags;
1227
1228 ret = __vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);
1229
1230 TEST_ASSERT(ret == 0, "KVM_SET_USER_MEMORY_REGION2 IOCTL failed,\n"
1231 " rc: %i errno: %i slot: %u flags: 0x%x",
1232 ret, errno, slot, flags);
1233}
1234
1235void vm_mem_region_reload(struct kvm_vm *vm, u32 slot)
1236{
1237 struct userspace_mem_region *region = memslot2region(vm, slot);
1238 struct kvm_userspace_memory_region2 tmp = region->region;
1239
1240 tmp.memory_size = 0;
1241 vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &tmp);
1242 vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);
1243}
1244
1245/*
1246 * VM Memory Region Move
1247 *
1248 * Input Args:
1249 * vm - Virtual Machine
1250 * slot - Slot of the memory region to move
1251 * new_gpa - Starting guest physical address
1252 *
1253 * Output Args: None
1254 *
1255 * Return: None
1256 *
1257 * Change the gpa of a memory region.
1258 */
1259void vm_mem_region_move(struct kvm_vm *vm, u32 slot, u64 new_gpa)
1260{
1261 struct userspace_mem_region *region;
1262 int ret;
1263
1264 region = memslot2region(vm, slot);
1265
1266 region->region.guest_phys_addr = new_gpa;
1267
1268 ret = __vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);
1269
1270 TEST_ASSERT(!ret, "KVM_SET_USER_MEMORY_REGION2 failed\n"
1271 "ret: %i errno: %i slot: %u new_gpa: 0x%lx",
1272 ret, errno, slot, new_gpa);
1273}
1274
1275/*
1276 * VM Memory Region Delete
1277 *
1278 * Input Args:
1279 * vm - Virtual Machine
1280 * slot - Slot of the memory region to delete
1281 *
1282 * Output Args: None
1283 *
1284 * Return: None
1285 *
1286 * Delete a memory region.
1287 */
1288void vm_mem_region_delete(struct kvm_vm *vm, u32 slot)
1289{
1290 struct userspace_mem_region *region = memslot2region(vm, slot);
1291
1292 region->region.memory_size = 0;
1293 vm_ioctl(vm, KVM_SET_USER_MEMORY_REGION2, &region->region);
1294
1295 __vm_mem_region_delete(vm, region);
1296}
1297
1298void vm_guest_mem_fallocate(struct kvm_vm *vm, u64 base, u64 size,
1299 bool punch_hole)
1300{
1301 const int mode = FALLOC_FL_KEEP_SIZE | (punch_hole ? FALLOC_FL_PUNCH_HOLE : 0);
1302 struct userspace_mem_region *region;
1303 u64 end = base + size;
1304 gpa_t gpa, len;
1305 off_t fd_offset;
1306 int ret;
1307
1308 for (gpa = base; gpa < end; gpa += len) {
1309 u64 offset;
1310
1311 region = userspace_mem_region_find(vm, gpa, gpa);
1312 TEST_ASSERT(region && region->region.flags & KVM_MEM_GUEST_MEMFD,
1313 "Private memory region not found for GPA 0x%lx", gpa);
1314
1315 offset = gpa - region->region.guest_phys_addr;
1316 fd_offset = region->region.guest_memfd_offset + offset;
1317 len = min_t(u64, end - gpa, region->region.memory_size - offset);
1318
1319 ret = fallocate(region->region.guest_memfd, mode, fd_offset, len);
1320 TEST_ASSERT(!ret, "fallocate() failed to %s at %lx (len = %lu), fd = %d, mode = %x, offset = %lx",
1321 punch_hole ? "punch hole" : "allocate", gpa, len,
1322 region->region.guest_memfd, mode, fd_offset);
1323 }
1324}
1325
1326/* Returns the size of a vCPU's kvm_run structure. */
1327static size_t vcpu_mmap_sz(void)
1328{
1329 int dev_fd, ret;
1330
1331 dev_fd = open_kvm_dev_path_or_exit();
1332
1333 ret = ioctl(dev_fd, KVM_GET_VCPU_MMAP_SIZE, NULL);
1334 TEST_ASSERT(ret >= 0 && ret >= sizeof(struct kvm_run),
1335 KVM_IOCTL_ERROR(KVM_GET_VCPU_MMAP_SIZE, ret));
1336
1337 kvm_free_fd(dev_fd);
1338
1339 return ret;
1340}
1341
1342static bool vcpu_exists(struct kvm_vm *vm, u32 vcpu_id)
1343{
1344 struct kvm_vcpu *vcpu;
1345
1346 list_for_each_entry(vcpu, &vm->vcpus, list) {
1347 if (vcpu->id == vcpu_id)
1348 return true;
1349 }
1350
1351 return false;
1352}
1353
1354/*
1355 * Adds a virtual CPU to the VM specified by vm with the ID given by vcpu_id.
1356 * No additional vCPU setup is done. Returns the vCPU.
1357 */
1358struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, u32 vcpu_id)
1359{
1360 struct kvm_vcpu *vcpu;
1361
1362 /* Confirm a vcpu with the specified id doesn't already exist. */
1363 TEST_ASSERT(!vcpu_exists(vm, vcpu_id), "vCPU%d already exists", vcpu_id);
1364
1365 /* Allocate and initialize new vcpu structure. */
1366 vcpu = calloc(1, sizeof(*vcpu));
1367 TEST_ASSERT(vcpu != NULL, "Insufficient Memory");
1368
1369 vcpu->vm = vm;
1370 vcpu->id = vcpu_id;
1371 vcpu->fd = __vm_ioctl(vm, KVM_CREATE_VCPU, (void *)(unsigned long)vcpu_id);
1372 TEST_ASSERT_VM_VCPU_IOCTL(vcpu->fd >= 0, KVM_CREATE_VCPU, vcpu->fd, vm);
1373
1374 TEST_ASSERT(vcpu_mmap_sz() >= sizeof(*vcpu->run), "vcpu mmap size "
1375 "smaller than expected, vcpu_mmap_sz: %zi expected_min: %zi",
1376 vcpu_mmap_sz(), sizeof(*vcpu->run));
1377 vcpu->run = kvm_mmap(vcpu_mmap_sz(), PROT_READ | PROT_WRITE,
1378 MAP_SHARED, vcpu->fd);
1379
1380 if (kvm_has_cap(KVM_CAP_BINARY_STATS_FD))
1381 vcpu->stats.fd = vcpu_get_stats_fd(vcpu);
1382 else
1383 vcpu->stats.fd = -1;
1384
1385 /* Add to linked-list of VCPUs. */
1386 list_add(&vcpu->list, &vm->vcpus);
1387
1388 return vcpu;
1389}
1390
1391/*
1392 * Within the VM specified by @vm, locates the lowest starting guest virtual
1393 * address >= @min_gva, that has at least @sz unallocated bytes. A
1394 * TEST_ASSERT failure occurs for invalid input or no area of at least
1395 * @sz unallocated bytes >= @min_gva is available.
1396 */
1397gva_t vm_unused_gva_gap(struct kvm_vm *vm, size_t sz, gva_t min_gva)
1398{
1399 u64 pages = (sz + vm->page_size - 1) >> vm->page_shift;
1400
1401 /* Determine lowest permitted virtual page index. */
1402 u64 pgidx_start = (min_gva + vm->page_size - 1) >> vm->page_shift;
1403 if ((pgidx_start * vm->page_size) < min_gva)
1404 goto no_va_found;
1405
1406 /* Loop over section with enough valid virtual page indexes. */
1407 if (!sparsebit_is_set_num(vm->vpages_valid,
1408 pgidx_start, pages))
1409 pgidx_start = sparsebit_next_set_num(vm->vpages_valid,
1410 pgidx_start, pages);
1411 do {
1412 /*
1413 * Are there enough unused virtual pages available at
1414 * the currently proposed starting virtual page index.
1415 * If not, adjust proposed starting index to next
1416 * possible.
1417 */
1418 if (sparsebit_is_clear_num(vm->vpages_mapped,
1419 pgidx_start, pages))
1420 goto va_found;
1421 pgidx_start = sparsebit_next_clear_num(vm->vpages_mapped,
1422 pgidx_start, pages);
1423 if (pgidx_start == 0)
1424 goto no_va_found;
1425
1426 /*
1427 * If needed, adjust proposed starting virtual address,
1428 * to next range of valid virtual addresses.
1429 */
1430 if (!sparsebit_is_set_num(vm->vpages_valid,
1431 pgidx_start, pages)) {
1432 pgidx_start = sparsebit_next_set_num(
1433 vm->vpages_valid, pgidx_start, pages);
1434 if (pgidx_start == 0)
1435 goto no_va_found;
1436 }
1437 } while (pgidx_start != 0);
1438
1439no_va_found:
1440 TEST_FAIL("No gva of specified pages available, pages: 0x%lx", pages);
1441
1442 /* NOT REACHED */
1443 return -1;
1444
1445va_found:
1446 TEST_ASSERT(sparsebit_is_set_num(vm->vpages_valid,
1447 pgidx_start, pages),
1448 "Unexpected, invalid virtual page index range,\n"
1449 " pgidx_start: 0x%lx\n"
1450 " pages: 0x%lx",
1451 pgidx_start, pages);
1452 TEST_ASSERT(sparsebit_is_clear_num(vm->vpages_mapped,
1453 pgidx_start, pages),
1454 "Unexpected, pages already mapped,\n"
1455 " pgidx_start: 0x%lx\n"
1456 " pages: 0x%lx",
1457 pgidx_start, pages);
1458
1459 return pgidx_start * vm->page_size;
1460}
1461
1462static gva_t ____vm_alloc(struct kvm_vm *vm, size_t sz, gva_t min_gva,
1463 enum kvm_mem_region_type type, bool protected)
1464{
1465 u64 pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0);
1466
1467 virt_pgd_alloc(vm);
1468 gpa_t gpa = __vm_phy_pages_alloc(vm, pages,
1469 KVM_UTIL_MIN_PFN * vm->page_size,
1470 vm->memslots[type], protected);
1471
1472 /*
1473 * Find an unused range of virtual page addresses of at least
1474 * pages in length.
1475 */
1476 gva_t gva_start = vm_unused_gva_gap(vm, sz, min_gva);
1477
1478 /* Map the virtual pages. */
1479 for (gva_t gva = gva_start; pages > 0;
1480 pages--, gva += vm->page_size, gpa += vm->page_size) {
1481
1482 virt_pg_map(vm, gva, gpa);
1483 }
1484
1485 return gva_start;
1486}
1487
1488gva_t __vm_alloc(struct kvm_vm *vm, size_t sz, gva_t min_gva,
1489 enum kvm_mem_region_type type)
1490{
1491 return ____vm_alloc(vm, sz, min_gva, type,
1492 vm_arch_has_protected_memory(vm));
1493}
1494
1495gva_t vm_alloc_shared(struct kvm_vm *vm, size_t sz, gva_t min_gva,
1496 enum kvm_mem_region_type type)
1497{
1498 return ____vm_alloc(vm, sz, min_gva, type, false);
1499}
1500
1501/*
1502 * Allocates at least sz bytes within the virtual address space of the VM
1503 * given by @vm. The allocated bytes are mapped to a virtual address >= the
1504 * address given by @min_gva. Note that each allocation uses a a unique set
1505 * of pages, with the minimum real allocation being at least a page. The
1506 * allocated physical space comes from the TEST_DATA memory region.
1507 */
1508gva_t vm_alloc(struct kvm_vm *vm, size_t sz, gva_t min_gva)
1509{
1510 return __vm_alloc(vm, sz, min_gva, MEM_REGION_TEST_DATA);
1511}
1512
1513gva_t vm_alloc_pages(struct kvm_vm *vm, int nr_pages)
1514{
1515 return vm_alloc(vm, nr_pages * getpagesize(), KVM_UTIL_MIN_VADDR);
1516}
1517
1518gva_t __vm_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type)
1519{
1520 return __vm_alloc(vm, getpagesize(), KVM_UTIL_MIN_VADDR, type);
1521}
1522
1523gva_t vm_alloc_page(struct kvm_vm *vm)
1524{
1525 return vm_alloc_pages(vm, 1);
1526}
1527
1528/*
1529 * Map a range of VM virtual address to the VM's physical address.
1530 *
1531 * Within the VM given by @vm, creates a virtual translation for @npages
1532 * starting at @gva to the page range starting at @gpa.
1533 */
1534void virt_map(struct kvm_vm *vm, gva_t gva, gpa_t gpa, unsigned int npages)
1535{
1536 size_t page_size = vm->page_size;
1537 size_t size = npages * page_size;
1538
1539 TEST_ASSERT(gva + size > gva, "Vaddr overflow");
1540 TEST_ASSERT(gpa + size > gpa, "Paddr overflow");
1541
1542 while (npages--) {
1543 virt_pg_map(vm, gva, gpa);
1544
1545 gva += page_size;
1546 gpa += page_size;
1547 }
1548}
1549
1550/*
1551 * Address VM Physical to Host Virtual
1552 *
1553 * Input Args:
1554 * vm - Virtual Machine
1555 * gpa - VM physical address
1556 *
1557 * Output Args: None
1558 *
1559 * Return:
1560 * Equivalent host virtual address
1561 *
1562 * Locates the memory region containing the VM physical address given
1563 * by gpa, within the VM given by vm. When found, the host virtual
1564 * address providing the memory to the vm physical address is returned.
1565 * A TEST_ASSERT failure occurs if no region containing gpa exists.
1566 */
1567void *addr_gpa2hva(struct kvm_vm *vm, gpa_t gpa)
1568{
1569 struct userspace_mem_region *region;
1570
1571 gpa = vm_untag_gpa(vm, gpa);
1572
1573 region = userspace_mem_region_find(vm, gpa, gpa);
1574 if (!region) {
1575 TEST_FAIL("No vm physical memory at 0x%lx", gpa);
1576 return NULL;
1577 }
1578
1579 return (void *)((uintptr_t)region->host_mem
1580 + (gpa - region->region.guest_phys_addr));
1581}
1582
1583/*
1584 * Address Host Virtual to VM Physical
1585 *
1586 * Input Args:
1587 * vm - Virtual Machine
1588 * hva - Host virtual address
1589 *
1590 * Output Args: None
1591 *
1592 * Return:
1593 * Equivalent VM physical address
1594 *
1595 * Locates the memory region containing the host virtual address given
1596 * by hva, within the VM given by vm. When found, the equivalent
1597 * VM physical address is returned. A TEST_ASSERT failure occurs if no
1598 * region containing hva exists.
1599 */
1600gpa_t addr_hva2gpa(struct kvm_vm *vm, void *hva)
1601{
1602 struct rb_node *node;
1603
1604 for (node = vm->regions.hva_tree.rb_node; node; ) {
1605 struct userspace_mem_region *region =
1606 container_of(node, struct userspace_mem_region, hva_node);
1607
1608 if (hva >= region->host_mem) {
1609 if (hva <= (region->host_mem
1610 + region->region.memory_size - 1))
1611 return (gpa_t)((uintptr_t)
1612 region->region.guest_phys_addr
1613 + (hva - (uintptr_t)region->host_mem));
1614
1615 node = node->rb_right;
1616 } else
1617 node = node->rb_left;
1618 }
1619
1620 TEST_FAIL("No mapping to a guest physical address, hva: %p", hva);
1621 return -1;
1622}
1623
1624/*
1625 * Address VM physical to Host Virtual *alias*.
1626 *
1627 * Input Args:
1628 * vm - Virtual Machine
1629 * gpa - VM physical address
1630 *
1631 * Output Args: None
1632 *
1633 * Return:
1634 * Equivalent address within the host virtual *alias* area, or NULL
1635 * (without failing the test) if the guest memory is not shared (so
1636 * no alias exists).
1637 *
1638 * Create a writable, shared virtual=>physical alias for the specific GPA.
1639 * The primary use case is to allow the host selftest to manipulate guest
1640 * memory without mapping said memory in the guest's address space. And, for
1641 * userfaultfd-based demand paging, to do so without triggering userfaults.
1642 */
1643void *addr_gpa2alias(struct kvm_vm *vm, gpa_t gpa)
1644{
1645 struct userspace_mem_region *region;
1646 uintptr_t offset;
1647
1648 region = userspace_mem_region_find(vm, gpa, gpa);
1649 if (!region)
1650 return NULL;
1651
1652 if (!region->host_alias)
1653 return NULL;
1654
1655 offset = gpa - region->region.guest_phys_addr;
1656 return (void *) ((uintptr_t) region->host_alias + offset);
1657}
1658
1659/* Create an interrupt controller chip for the specified VM. */
1660void vm_create_irqchip(struct kvm_vm *vm)
1661{
1662 int r;
1663
1664 /*
1665 * Allocate a fully in-kernel IRQ chip by default, but fall back to a
1666 * split model (x86 only) if that fails (KVM x86 allows compiling out
1667 * support for KVM_CREATE_IRQCHIP).
1668 */
1669 r = __vm_ioctl(vm, KVM_CREATE_IRQCHIP, NULL);
1670 if (r && errno == ENOTTY && kvm_has_cap(KVM_CAP_SPLIT_IRQCHIP))
1671 vm_enable_cap(vm, KVM_CAP_SPLIT_IRQCHIP, 24);
1672 else
1673 TEST_ASSERT_VM_VCPU_IOCTL(!r, KVM_CREATE_IRQCHIP, r, vm);
1674
1675 vm->has_irqchip = true;
1676}
1677
1678int _vcpu_run(struct kvm_vcpu *vcpu)
1679{
1680 int rc;
1681
1682 do {
1683 rc = __vcpu_run(vcpu);
1684 } while (rc == -1 && errno == EINTR);
1685
1686 if (!rc)
1687 assert_on_unhandled_exception(vcpu);
1688
1689 return rc;
1690}
1691
1692/*
1693 * Invoke KVM_RUN on a vCPU until KVM returns something other than -EINTR.
1694 * Assert if the KVM returns an error (other than -EINTR).
1695 */
1696void vcpu_run(struct kvm_vcpu *vcpu)
1697{
1698 int ret = _vcpu_run(vcpu);
1699
1700 TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_RUN, ret));
1701}
1702
1703void vcpu_run_complete_io(struct kvm_vcpu *vcpu)
1704{
1705 int ret;
1706
1707 vcpu->run->immediate_exit = 1;
1708 ret = __vcpu_run(vcpu);
1709 vcpu->run->immediate_exit = 0;
1710
1711 TEST_ASSERT(ret == -1 && errno == EINTR,
1712 "KVM_RUN IOCTL didn't exit immediately, rc: %i, errno: %i",
1713 ret, errno);
1714}
1715
1716/*
1717 * Get the list of guest registers which are supported for
1718 * KVM_GET_ONE_REG/KVM_SET_ONE_REG ioctls. Returns a kvm_reg_list pointer,
1719 * it is the caller's responsibility to free the list.
1720 */
1721struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vcpu *vcpu)
1722{
1723 struct kvm_reg_list reg_list_n = { .n = 0 }, *reg_list;
1724 int ret;
1725
1726 ret = __vcpu_ioctl(vcpu, KVM_GET_REG_LIST, &reg_list_n);
1727 TEST_ASSERT(ret == -1 && errno == E2BIG, "KVM_GET_REG_LIST n=0");
1728
1729 reg_list = calloc(1, sizeof(*reg_list) + reg_list_n.n * sizeof(__u64));
1730 reg_list->n = reg_list_n.n;
1731 vcpu_ioctl(vcpu, KVM_GET_REG_LIST, reg_list);
1732 return reg_list;
1733}
1734
1735void *vcpu_map_dirty_ring(struct kvm_vcpu *vcpu)
1736{
1737 u32 page_size = getpagesize();
1738 u32 size = vcpu->vm->dirty_ring_size;
1739
1740 TEST_ASSERT(size > 0, "Should enable dirty ring first");
1741
1742 if (!vcpu->dirty_gfns) {
1743 void *addr;
1744
1745 addr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, vcpu->fd,
1746 page_size * KVM_DIRTY_LOG_PAGE_OFFSET);
1747 TEST_ASSERT(addr == MAP_FAILED, "Dirty ring mapped private");
1748
1749 addr = mmap(NULL, size, PROT_READ | PROT_EXEC, MAP_PRIVATE, vcpu->fd,
1750 page_size * KVM_DIRTY_LOG_PAGE_OFFSET);
1751 TEST_ASSERT(addr == MAP_FAILED, "Dirty ring mapped exec");
1752
1753 addr = __kvm_mmap(size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpu->fd,
1754 page_size * KVM_DIRTY_LOG_PAGE_OFFSET);
1755
1756 vcpu->dirty_gfns = addr;
1757 vcpu->dirty_gfns_count = size / sizeof(struct kvm_dirty_gfn);
1758 }
1759
1760 return vcpu->dirty_gfns;
1761}
1762
1763/*
1764 * Device Ioctl
1765 */
1766
1767int __kvm_has_device_attr(int dev_fd, u32 group, u64 attr)
1768{
1769 struct kvm_device_attr attribute = {
1770 .group = group,
1771 .attr = attr,
1772 .flags = 0,
1773 };
1774
1775 return ioctl(dev_fd, KVM_HAS_DEVICE_ATTR, &attribute);
1776}
1777
1778int __kvm_test_create_device(struct kvm_vm *vm, u64 type)
1779{
1780 struct kvm_create_device create_dev = {
1781 .type = type,
1782 .flags = KVM_CREATE_DEVICE_TEST,
1783 };
1784
1785 return __vm_ioctl(vm, KVM_CREATE_DEVICE, &create_dev);
1786}
1787
1788int __kvm_create_device(struct kvm_vm *vm, u64 type)
1789{
1790 struct kvm_create_device create_dev = {
1791 .type = type,
1792 .fd = -1,
1793 .flags = 0,
1794 };
1795 int err;
1796
1797 err = __vm_ioctl(vm, KVM_CREATE_DEVICE, &create_dev);
1798 TEST_ASSERT(err <= 0, "KVM_CREATE_DEVICE shouldn't return a positive value");
1799 return err ? : create_dev.fd;
1800}
1801
1802int __kvm_device_attr_get(int dev_fd, u32 group, u64 attr, void *val)
1803{
1804 struct kvm_device_attr kvmattr = {
1805 .group = group,
1806 .attr = attr,
1807 .flags = 0,
1808 .addr = (uintptr_t)val,
1809 };
1810
1811 return __kvm_ioctl(dev_fd, KVM_GET_DEVICE_ATTR, &kvmattr);
1812}
1813
1814int __kvm_device_attr_set(int dev_fd, u32 group, u64 attr, void *val)
1815{
1816 struct kvm_device_attr kvmattr = {
1817 .group = group,
1818 .attr = attr,
1819 .flags = 0,
1820 .addr = (uintptr_t)val,
1821 };
1822
1823 return __kvm_ioctl(dev_fd, KVM_SET_DEVICE_ATTR, &kvmattr);
1824}
1825
1826/*
1827 * IRQ related functions.
1828 */
1829
1830int _kvm_irq_line(struct kvm_vm *vm, u32 irq, int level)
1831{
1832 struct kvm_irq_level irq_level = {
1833 .irq = irq,
1834 .level = level,
1835 };
1836
1837 return __vm_ioctl(vm, KVM_IRQ_LINE, &irq_level);
1838}
1839
1840void kvm_irq_line(struct kvm_vm *vm, u32 irq, int level)
1841{
1842 int ret = _kvm_irq_line(vm, irq, level);
1843
1844 TEST_ASSERT(ret >= 0, KVM_IOCTL_ERROR(KVM_IRQ_LINE, ret));
1845}
1846
1847struct kvm_irq_routing *kvm_gsi_routing_create(void)
1848{
1849 struct kvm_irq_routing *routing;
1850 size_t size;
1851
1852 size = sizeof(struct kvm_irq_routing);
1853 /* Allocate space for the max number of entries: this wastes 196 KBs. */
1854 size += KVM_MAX_IRQ_ROUTES * sizeof(struct kvm_irq_routing_entry);
1855 routing = calloc(1, size);
1856 assert(routing);
1857
1858 return routing;
1859}
1860
1861void kvm_gsi_routing_irqchip_add(struct kvm_irq_routing *routing,
1862 u32 gsi, u32 pin)
1863{
1864 int i;
1865
1866 assert(routing);
1867 assert(routing->nr < KVM_MAX_IRQ_ROUTES);
1868
1869 i = routing->nr;
1870 routing->entries[i].gsi = gsi;
1871 routing->entries[i].type = KVM_IRQ_ROUTING_IRQCHIP;
1872 routing->entries[i].flags = 0;
1873 routing->entries[i].u.irqchip.irqchip = 0;
1874 routing->entries[i].u.irqchip.pin = pin;
1875 routing->nr++;
1876}
1877
1878int _kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing)
1879{
1880 int ret;
1881
1882 assert(routing);
1883 ret = __vm_ioctl(vm, KVM_SET_GSI_ROUTING, routing);
1884 free(routing);
1885
1886 return ret;
1887}
1888
1889void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing)
1890{
1891 int ret;
1892
1893 ret = _kvm_gsi_routing_write(vm, routing);
1894 TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_SET_GSI_ROUTING, ret));
1895}
1896
1897/*
1898 * VM Dump
1899 *
1900 * Input Args:
1901 * vm - Virtual Machine
1902 * indent - Left margin indent amount
1903 *
1904 * Output Args:
1905 * stream - Output FILE stream
1906 *
1907 * Return: None
1908 *
1909 * Dumps the current state of the VM given by vm, to the FILE stream
1910 * given by stream.
1911 */
1912void vm_dump(FILE *stream, struct kvm_vm *vm, u8 indent)
1913{
1914 int ctr;
1915 struct userspace_mem_region *region;
1916 struct kvm_vcpu *vcpu;
1917
1918 fprintf(stream, "%*smode: 0x%x\n", indent, "", vm->mode);
1919 fprintf(stream, "%*sfd: %i\n", indent, "", vm->fd);
1920 fprintf(stream, "%*spage_size: 0x%x\n", indent, "", vm->page_size);
1921 fprintf(stream, "%*sMem Regions:\n", indent, "");
1922 hash_for_each(vm->regions.slot_hash, ctr, region, slot_node) {
1923 fprintf(stream, "%*sguest_phys: 0x%lx size: 0x%lx "
1924 "host_virt: %p\n", indent + 2, "",
1925 (u64)region->region.guest_phys_addr,
1926 (u64)region->region.memory_size,
1927 region->host_mem);
1928 fprintf(stream, "%*sunused_phy_pages: ", indent + 2, "");
1929 sparsebit_dump(stream, region->unused_phy_pages, 0);
1930 if (region->protected_phy_pages) {
1931 fprintf(stream, "%*sprotected_phy_pages: ", indent + 2, "");
1932 sparsebit_dump(stream, region->protected_phy_pages, 0);
1933 }
1934 }
1935 fprintf(stream, "%*sMapped Virtual Pages:\n", indent, "");
1936 sparsebit_dump(stream, vm->vpages_mapped, indent + 2);
1937 fprintf(stream, "%*spgd_created: %u\n", indent, "",
1938 vm->mmu.pgd_created);
1939 if (vm->mmu.pgd_created) {
1940 fprintf(stream, "%*sVirtual Translation Tables:\n",
1941 indent + 2, "");
1942 virt_dump(stream, vm, indent + 4);
1943 }
1944 fprintf(stream, "%*sVCPUs:\n", indent, "");
1945
1946 list_for_each_entry(vcpu, &vm->vcpus, list)
1947 vcpu_dump(stream, vcpu, indent + 2);
1948}
1949
1950#define KVM_EXIT_STRING(x) {KVM_EXIT_##x, #x}
1951
1952/* Known KVM exit reasons */
1953static struct exit_reason {
1954 unsigned int reason;
1955 const char *name;
1956} exit_reasons_known[] = {
1957 KVM_EXIT_STRING(UNKNOWN),
1958 KVM_EXIT_STRING(EXCEPTION),
1959 KVM_EXIT_STRING(IO),
1960 KVM_EXIT_STRING(HYPERCALL),
1961 KVM_EXIT_STRING(DEBUG),
1962 KVM_EXIT_STRING(HLT),
1963 KVM_EXIT_STRING(MMIO),
1964 KVM_EXIT_STRING(IRQ_WINDOW_OPEN),
1965 KVM_EXIT_STRING(SHUTDOWN),
1966 KVM_EXIT_STRING(FAIL_ENTRY),
1967 KVM_EXIT_STRING(INTR),
1968 KVM_EXIT_STRING(SET_TPR),
1969 KVM_EXIT_STRING(TPR_ACCESS),
1970 KVM_EXIT_STRING(S390_SIEIC),
1971 KVM_EXIT_STRING(S390_RESET),
1972 KVM_EXIT_STRING(DCR),
1973 KVM_EXIT_STRING(NMI),
1974 KVM_EXIT_STRING(INTERNAL_ERROR),
1975 KVM_EXIT_STRING(OSI),
1976 KVM_EXIT_STRING(PAPR_HCALL),
1977 KVM_EXIT_STRING(S390_UCONTROL),
1978 KVM_EXIT_STRING(WATCHDOG),
1979 KVM_EXIT_STRING(S390_TSCH),
1980 KVM_EXIT_STRING(EPR),
1981 KVM_EXIT_STRING(SYSTEM_EVENT),
1982 KVM_EXIT_STRING(S390_STSI),
1983 KVM_EXIT_STRING(IOAPIC_EOI),
1984 KVM_EXIT_STRING(HYPERV),
1985 KVM_EXIT_STRING(ARM_NISV),
1986 KVM_EXIT_STRING(X86_RDMSR),
1987 KVM_EXIT_STRING(X86_WRMSR),
1988 KVM_EXIT_STRING(DIRTY_RING_FULL),
1989 KVM_EXIT_STRING(AP_RESET_HOLD),
1990 KVM_EXIT_STRING(X86_BUS_LOCK),
1991 KVM_EXIT_STRING(XEN),
1992 KVM_EXIT_STRING(RISCV_SBI),
1993 KVM_EXIT_STRING(RISCV_CSR),
1994 KVM_EXIT_STRING(NOTIFY),
1995 KVM_EXIT_STRING(LOONGARCH_IOCSR),
1996 KVM_EXIT_STRING(MEMORY_FAULT),
1997 KVM_EXIT_STRING(ARM_SEA),
1998};
1999
2000/*
2001 * Exit Reason String
2002 *
2003 * Input Args:
2004 * exit_reason - Exit reason
2005 *
2006 * Output Args: None
2007 *
2008 * Return:
2009 * Constant string pointer describing the exit reason.
2010 *
2011 * Locates and returns a constant string that describes the KVM exit
2012 * reason given by exit_reason. If no such string is found, a constant
2013 * string of "Unknown" is returned.
2014 */
2015const char *exit_reason_str(unsigned int exit_reason)
2016{
2017 unsigned int n1;
2018
2019 for (n1 = 0; n1 < ARRAY_SIZE(exit_reasons_known); n1++) {
2020 if (exit_reason == exit_reasons_known[n1].reason)
2021 return exit_reasons_known[n1].name;
2022 }
2023
2024 return "Unknown";
2025}
2026
2027/*
2028 * Physical Contiguous Page Allocator
2029 *
2030 * Input Args:
2031 * vm - Virtual Machine
2032 * num - number of pages
2033 * min_gpa - Physical address minimum
2034 * memslot - Memory region to allocate page from
2035 * protected - True if the pages will be used as protected/private memory
2036 *
2037 * Output Args: None
2038 *
2039 * Return:
2040 * Starting physical address
2041 *
2042 * Within the VM specified by vm, locates a range of available physical
2043 * pages at or above min_gpa. If found, the pages are marked as in use
2044 * and their base address is returned. A TEST_ASSERT failure occurs if
2045 * not enough pages are available at or above min_gpa.
2046 */
2047gpa_t __vm_phy_pages_alloc(struct kvm_vm *vm, size_t num,
2048 gpa_t min_gpa, u32 memslot,
2049 bool protected)
2050{
2051 struct userspace_mem_region *region;
2052 sparsebit_idx_t pg, base;
2053
2054 TEST_ASSERT(num > 0, "Must allocate at least one page");
2055
2056 TEST_ASSERT((min_gpa % vm->page_size) == 0, "Min physical address "
2057 "not divisible by page size.\n"
2058 " min_gpa: 0x%lx page_size: 0x%x",
2059 min_gpa, vm->page_size);
2060
2061 region = memslot2region(vm, memslot);
2062 TEST_ASSERT(!protected || region->protected_phy_pages,
2063 "Region doesn't support protected memory");
2064
2065 base = pg = min_gpa >> vm->page_shift;
2066 do {
2067 for (; pg < base + num; ++pg) {
2068 if (!sparsebit_is_set(region->unused_phy_pages, pg)) {
2069 base = pg = sparsebit_next_set(region->unused_phy_pages, pg);
2070 break;
2071 }
2072 }
2073 } while (pg && pg != base + num);
2074
2075 if (pg == 0) {
2076 fprintf(stderr, "No guest physical page available, "
2077 "min_gpa: 0x%lx page_size: 0x%x memslot: %u\n",
2078 min_gpa, vm->page_size, memslot);
2079 fputs("---- vm dump ----\n", stderr);
2080 vm_dump(stderr, vm, 2);
2081 abort();
2082 }
2083
2084 for (pg = base; pg < base + num; ++pg) {
2085 sparsebit_clear(region->unused_phy_pages, pg);
2086 if (protected)
2087 sparsebit_set(region->protected_phy_pages, pg);
2088 }
2089
2090 return base * vm->page_size;
2091}
2092
2093gpa_t vm_phy_page_alloc(struct kvm_vm *vm, gpa_t min_gpa, u32 memslot)
2094{
2095 return vm_phy_pages_alloc(vm, 1, min_gpa, memslot);
2096}
2097
2098gpa_t vm_alloc_page_table(struct kvm_vm *vm)
2099{
2100 return vm_phy_page_alloc(vm, KVM_GUEST_PAGE_TABLE_MIN_PADDR,
2101 vm->memslots[MEM_REGION_PT]);
2102}
2103
2104/*
2105 * Address Guest Virtual to Host Virtual
2106 *
2107 * Input Args:
2108 * vm - Virtual Machine
2109 * gva - VM virtual address
2110 *
2111 * Output Args: None
2112 *
2113 * Return:
2114 * Equivalent host virtual address
2115 */
2116void *addr_gva2hva(struct kvm_vm *vm, gva_t gva)
2117{
2118 return addr_gpa2hva(vm, addr_gva2gpa(vm, gva));
2119}
2120
2121unsigned long __weak vm_compute_max_gfn(struct kvm_vm *vm)
2122{
2123 return ((1ULL << vm->pa_bits) >> vm->page_shift) - 1;
2124}
2125
2126static unsigned int vm_calc_num_pages(unsigned int num_pages,
2127 unsigned int page_shift,
2128 unsigned int new_page_shift,
2129 bool ceil)
2130{
2131 unsigned int n = 1 << (new_page_shift - page_shift);
2132
2133 if (page_shift >= new_page_shift)
2134 return num_pages * (1 << (page_shift - new_page_shift));
2135
2136 return num_pages / n + !!(ceil && num_pages % n);
2137}
2138
2139static inline int getpageshift(void)
2140{
2141 return __builtin_ffs(getpagesize()) - 1;
2142}
2143
2144unsigned int
2145vm_num_host_pages(enum vm_guest_mode mode, unsigned int num_guest_pages)
2146{
2147 return vm_calc_num_pages(num_guest_pages,
2148 vm_guest_mode_params[mode].page_shift,
2149 getpageshift(), true);
2150}
2151
2152unsigned int
2153vm_num_guest_pages(enum vm_guest_mode mode, unsigned int num_host_pages)
2154{
2155 return vm_calc_num_pages(num_host_pages, getpageshift(),
2156 vm_guest_mode_params[mode].page_shift, false);
2157}
2158
2159unsigned int vm_calc_num_guest_pages(enum vm_guest_mode mode, size_t size)
2160{
2161 unsigned int n;
2162 n = DIV_ROUND_UP(size, vm_guest_mode_params[mode].page_size);
2163 return vm_adjust_num_guest_pages(mode, n);
2164}
2165
2166/*
2167 * Read binary stats descriptors
2168 *
2169 * Input Args:
2170 * stats_fd - the file descriptor for the binary stats file from which to read
2171 * header - the binary stats metadata header corresponding to the given FD
2172 *
2173 * Output Args: None
2174 *
2175 * Return:
2176 * A pointer to a newly allocated series of stat descriptors.
2177 * Caller is responsible for freeing the returned kvm_stats_desc.
2178 *
2179 * Read the stats descriptors from the binary stats interface.
2180 */
2181struct kvm_stats_desc *read_stats_descriptors(int stats_fd,
2182 struct kvm_stats_header *header)
2183{
2184 struct kvm_stats_desc *stats_desc;
2185 ssize_t desc_size, total_size, ret;
2186
2187 desc_size = get_stats_descriptor_size(header);
2188 total_size = header->num_desc * desc_size;
2189
2190 stats_desc = calloc(header->num_desc, desc_size);
2191 TEST_ASSERT(stats_desc, "Allocate memory for stats descriptors");
2192
2193 ret = pread(stats_fd, stats_desc, total_size, header->desc_offset);
2194 TEST_ASSERT(ret == total_size, "Read KVM stats descriptors");
2195
2196 return stats_desc;
2197}
2198
2199/*
2200 * Read stat data for a particular stat
2201 *
2202 * Input Args:
2203 * stats_fd - the file descriptor for the binary stats file from which to read
2204 * header - the binary stats metadata header corresponding to the given FD
2205 * desc - the binary stat metadata for the particular stat to be read
2206 * max_elements - the maximum number of 8-byte values to read into data
2207 *
2208 * Output Args:
2209 * data - the buffer into which stat data should be read
2210 *
2211 * Read the data values of a specified stat from the binary stats interface.
2212 */
2213void read_stat_data(int stats_fd, struct kvm_stats_header *header,
2214 struct kvm_stats_desc *desc, u64 *data,
2215 size_t max_elements)
2216{
2217 size_t nr_elements = min_t(ssize_t, desc->size, max_elements);
2218 size_t size = nr_elements * sizeof(*data);
2219 ssize_t ret;
2220
2221 TEST_ASSERT(desc->size, "No elements in stat '%s'", desc->name);
2222 TEST_ASSERT(max_elements, "Zero elements requested for stat '%s'", desc->name);
2223
2224 ret = pread(stats_fd, data, size,
2225 header->data_offset + desc->offset);
2226
2227 TEST_ASSERT(ret >= 0, "pread() failed on stat '%s', errno: %i (%s)",
2228 desc->name, errno, strerror(errno));
2229 TEST_ASSERT(ret == size,
2230 "pread() on stat '%s' read %ld bytes, wanted %lu bytes",
2231 desc->name, size, ret);
2232}
2233
2234void kvm_get_stat(struct kvm_binary_stats *stats, const char *name,
2235 u64 *data, size_t max_elements)
2236{
2237 struct kvm_stats_desc *desc;
2238 size_t size_desc;
2239 int i;
2240
2241 if (!stats->desc) {
2242 read_stats_header(stats->fd, &stats->header);
2243 stats->desc = read_stats_descriptors(stats->fd, &stats->header);
2244 }
2245
2246 size_desc = get_stats_descriptor_size(&stats->header);
2247
2248 for (i = 0; i < stats->header.num_desc; ++i) {
2249 desc = (void *)stats->desc + (i * size_desc);
2250
2251 if (strcmp(desc->name, name))
2252 continue;
2253
2254 read_stat_data(stats->fd, &stats->header, desc, data, max_elements);
2255 return;
2256 }
2257
2258 TEST_FAIL("Unable to find stat '%s'", name);
2259}
2260
2261__weak void kvm_arch_vm_post_create(struct kvm_vm *vm, unsigned int nr_vcpus)
2262{
2263}
2264
2265__weak void kvm_arch_vm_finalize_vcpus(struct kvm_vm *vm)
2266{
2267}
2268
2269__weak void kvm_arch_vm_release(struct kvm_vm *vm)
2270{
2271}
2272
2273__weak void kvm_selftest_arch_init(void)
2274{
2275}
2276
2277static void report_unexpected_signal(int signum)
2278{
2279#define KVM_CASE_SIGNUM(sig) \
2280 case sig: TEST_FAIL("Unexpected " #sig " (%d)\n", signum)
2281
2282 switch (signum) {
2283 KVM_CASE_SIGNUM(SIGBUS);
2284 KVM_CASE_SIGNUM(SIGSEGV);
2285 KVM_CASE_SIGNUM(SIGILL);
2286 KVM_CASE_SIGNUM(SIGFPE);
2287 default:
2288 TEST_FAIL("Unexpected signal %d\n", signum);
2289 }
2290}
2291
2292void __attribute((constructor)) kvm_selftest_init(void)
2293{
2294 struct sigaction sig_sa = {
2295 .sa_handler = report_unexpected_signal,
2296 };
2297
2298 /* Tell stdout not to buffer its content. */
2299 setbuf(stdout, NULL);
2300
2301 sigaction(SIGBUS, &sig_sa, NULL);
2302 sigaction(SIGSEGV, &sig_sa, NULL);
2303 sigaction(SIGILL, &sig_sa, NULL);
2304 sigaction(SIGFPE, &sig_sa, NULL);
2305
2306 srandom(time(0));
2307 kvm_seed_rng(random());
2308
2309 kvm_selftest_arch_init();
2310}
2311
2312bool vm_is_gpa_protected(struct kvm_vm *vm, gpa_t gpa)
2313{
2314 sparsebit_idx_t pg = 0;
2315 struct userspace_mem_region *region;
2316
2317 if (!vm_arch_has_protected_memory(vm))
2318 return false;
2319
2320 region = userspace_mem_region_find(vm, gpa, gpa);
2321 TEST_ASSERT(region, "No vm physical memory at 0x%lx", gpa);
2322
2323 pg = gpa >> vm->page_shift;
2324 return sparsebit_is_set(region->protected_phy_pages, pg);
2325}
2326
2327__weak bool kvm_arch_has_default_irqchip(void)
2328{
2329 return false;
2330}