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_param_bool(const char *param); 217 bool get_kvm_intel_param_bool(const char *param); 218 bool get_kvm_amd_param_bool(const char *param); 219 220 unsigned int kvm_check_cap(long cap); 221 222 static inline bool kvm_has_cap(long cap) 223 { 224 return kvm_check_cap(cap); 225 } 226 227 #define __KVM_SYSCALL_ERROR(_name, _ret) \ 228 "%s failed, rc: %i errno: %i (%s)", (_name), (_ret), errno, strerror(errno) 229 230 #define __KVM_IOCTL_ERROR(_name, _ret) __KVM_SYSCALL_ERROR(_name, _ret) 231 #define KVM_IOCTL_ERROR(_ioctl, _ret) __KVM_IOCTL_ERROR(#_ioctl, _ret) 232 233 #define kvm_do_ioctl(fd, cmd, arg) \ 234 ({ \ 235 kvm_static_assert(!_IOC_SIZE(cmd) || sizeof(*arg) == _IOC_SIZE(cmd)); \ 236 ioctl(fd, cmd, arg); \ 237 }) 238 239 #define __kvm_ioctl(kvm_fd, cmd, arg) \ 240 kvm_do_ioctl(kvm_fd, cmd, arg) 241 242 243 #define _kvm_ioctl(kvm_fd, cmd, name, arg) \ 244 ({ \ 245 int ret = __kvm_ioctl(kvm_fd, cmd, arg); \ 246 \ 247 TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret)); \ 248 }) 249 250 #define kvm_ioctl(kvm_fd, cmd, arg) \ 251 _kvm_ioctl(kvm_fd, cmd, #cmd, arg) 252 253 static __always_inline void static_assert_is_vm(struct kvm_vm *vm) { } 254 255 #define __vm_ioctl(vm, cmd, arg) \ 256 ({ \ 257 static_assert_is_vm(vm); \ 258 kvm_do_ioctl((vm)->fd, cmd, arg); \ 259 }) 260 261 #define _vm_ioctl(vm, cmd, name, arg) \ 262 ({ \ 263 int ret = __vm_ioctl(vm, cmd, arg); \ 264 \ 265 TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret)); \ 266 }) 267 268 #define vm_ioctl(vm, cmd, arg) \ 269 _vm_ioctl(vm, cmd, #cmd, arg) 270 271 272 static __always_inline void static_assert_is_vcpu(struct kvm_vcpu *vcpu) { } 273 274 #define __vcpu_ioctl(vcpu, cmd, arg) \ 275 ({ \ 276 static_assert_is_vcpu(vcpu); \ 277 kvm_do_ioctl((vcpu)->fd, cmd, arg); \ 278 }) 279 280 #define _vcpu_ioctl(vcpu, cmd, name, arg) \ 281 ({ \ 282 int ret = __vcpu_ioctl(vcpu, cmd, arg); \ 283 \ 284 TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret)); \ 285 }) 286 287 #define vcpu_ioctl(vcpu, cmd, arg) \ 288 _vcpu_ioctl(vcpu, cmd, #cmd, arg) 289 290 /* 291 * Looks up and returns the value corresponding to the capability 292 * (KVM_CAP_*) given by cap. 293 */ 294 static inline int vm_check_cap(struct kvm_vm *vm, long cap) 295 { 296 int ret = __vm_ioctl(vm, KVM_CHECK_EXTENSION, (void *)cap); 297 298 TEST_ASSERT(ret >= 0, KVM_IOCTL_ERROR(KVM_CHECK_EXTENSION, ret)); 299 return ret; 300 } 301 302 static inline int __vm_enable_cap(struct kvm_vm *vm, uint32_t cap, uint64_t arg0) 303 { 304 struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } }; 305 306 return __vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap); 307 } 308 static inline void vm_enable_cap(struct kvm_vm *vm, uint32_t cap, uint64_t arg0) 309 { 310 struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } }; 311 312 vm_ioctl(vm, KVM_ENABLE_CAP, &enable_cap); 313 } 314 315 void vm_enable_dirty_ring(struct kvm_vm *vm, uint32_t ring_size); 316 const char *vm_guest_mode_string(uint32_t i); 317 318 void kvm_vm_free(struct kvm_vm *vmp); 319 void kvm_vm_restart(struct kvm_vm *vmp); 320 void kvm_vm_release(struct kvm_vm *vmp); 321 int kvm_memcmp_hva_gva(void *hva, struct kvm_vm *vm, const vm_vaddr_t gva, 322 size_t len); 323 void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename); 324 int kvm_memfd_alloc(size_t size, bool hugepages); 325 326 void vm_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent); 327 328 static inline void kvm_vm_get_dirty_log(struct kvm_vm *vm, int slot, void *log) 329 { 330 struct kvm_dirty_log args = { .dirty_bitmap = log, .slot = slot }; 331 332 vm_ioctl(vm, KVM_GET_DIRTY_LOG, &args); 333 } 334 335 static inline void kvm_vm_clear_dirty_log(struct kvm_vm *vm, int slot, void *log, 336 uint64_t first_page, uint32_t num_pages) 337 { 338 struct kvm_clear_dirty_log args = { 339 .dirty_bitmap = log, 340 .slot = slot, 341 .first_page = first_page, 342 .num_pages = num_pages 343 }; 344 345 vm_ioctl(vm, KVM_CLEAR_DIRTY_LOG, &args); 346 } 347 348 static inline uint32_t kvm_vm_reset_dirty_ring(struct kvm_vm *vm) 349 { 350 return __vm_ioctl(vm, KVM_RESET_DIRTY_RINGS, NULL); 351 } 352 353 static inline int vm_get_stats_fd(struct kvm_vm *vm) 354 { 355 int fd = __vm_ioctl(vm, KVM_GET_STATS_FD, NULL); 356 357 TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_GET_STATS_FD, fd)); 358 return fd; 359 } 360 361 static inline void read_stats_header(int stats_fd, struct kvm_stats_header *header) 362 { 363 ssize_t ret; 364 365 ret = pread(stats_fd, header, sizeof(*header), 0); 366 TEST_ASSERT(ret == sizeof(*header), 367 "Failed to read '%lu' header bytes, ret = '%ld'", 368 sizeof(*header), ret); 369 } 370 371 struct kvm_stats_desc *read_stats_descriptors(int stats_fd, 372 struct kvm_stats_header *header); 373 374 static inline ssize_t get_stats_descriptor_size(struct kvm_stats_header *header) 375 { 376 /* 377 * The base size of the descriptor is defined by KVM's ABI, but the 378 * size of the name field is variable, as far as KVM's ABI is 379 * concerned. For a given instance of KVM, the name field is the same 380 * size for all stats and is provided in the overall stats header. 381 */ 382 return sizeof(struct kvm_stats_desc) + header->name_size; 383 } 384 385 static inline struct kvm_stats_desc *get_stats_descriptor(struct kvm_stats_desc *stats, 386 int index, 387 struct kvm_stats_header *header) 388 { 389 /* 390 * Note, size_desc includes the size of the name field, which is 391 * variable. i.e. this is NOT equivalent to &stats_desc[i]. 392 */ 393 return (void *)stats + index * get_stats_descriptor_size(header); 394 } 395 396 void read_stat_data(int stats_fd, struct kvm_stats_header *header, 397 struct kvm_stats_desc *desc, uint64_t *data, 398 size_t max_elements); 399 400 void __vm_get_stat(struct kvm_vm *vm, const char *stat_name, uint64_t *data, 401 size_t max_elements); 402 403 static inline uint64_t vm_get_stat(struct kvm_vm *vm, const char *stat_name) 404 { 405 uint64_t data; 406 407 __vm_get_stat(vm, stat_name, &data, 1); 408 return data; 409 } 410 411 void vm_create_irqchip(struct kvm_vm *vm); 412 413 void vm_set_user_memory_region(struct kvm_vm *vm, uint32_t slot, uint32_t flags, 414 uint64_t gpa, uint64_t size, void *hva); 415 int __vm_set_user_memory_region(struct kvm_vm *vm, uint32_t slot, uint32_t flags, 416 uint64_t gpa, uint64_t size, void *hva); 417 void vm_userspace_mem_region_add(struct kvm_vm *vm, 418 enum vm_mem_backing_src_type src_type, 419 uint64_t guest_paddr, uint32_t slot, uint64_t npages, 420 uint32_t flags); 421 422 void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags); 423 void vm_mem_region_move(struct kvm_vm *vm, uint32_t slot, uint64_t new_gpa); 424 void vm_mem_region_delete(struct kvm_vm *vm, uint32_t slot); 425 struct kvm_vcpu *__vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id); 426 void vm_populate_vaddr_bitmap(struct kvm_vm *vm); 427 vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); 428 vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); 429 vm_vaddr_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min, 430 enum kvm_mem_region_type type); 431 vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages); 432 vm_vaddr_t __vm_vaddr_alloc_page(struct kvm_vm *vm, 433 enum kvm_mem_region_type type); 434 vm_vaddr_t vm_vaddr_alloc_page(struct kvm_vm *vm); 435 436 void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr, 437 unsigned int npages); 438 void *addr_gpa2hva(struct kvm_vm *vm, vm_paddr_t gpa); 439 void *addr_gva2hva(struct kvm_vm *vm, vm_vaddr_t gva); 440 vm_paddr_t addr_hva2gpa(struct kvm_vm *vm, void *hva); 441 void *addr_gpa2alias(struct kvm_vm *vm, vm_paddr_t gpa); 442 443 void vcpu_run(struct kvm_vcpu *vcpu); 444 int _vcpu_run(struct kvm_vcpu *vcpu); 445 446 static inline int __vcpu_run(struct kvm_vcpu *vcpu) 447 { 448 return __vcpu_ioctl(vcpu, KVM_RUN, NULL); 449 } 450 451 void vcpu_run_complete_io(struct kvm_vcpu *vcpu); 452 struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vcpu *vcpu); 453 454 static inline void vcpu_enable_cap(struct kvm_vcpu *vcpu, uint32_t cap, 455 uint64_t arg0) 456 { 457 struct kvm_enable_cap enable_cap = { .cap = cap, .args = { arg0 } }; 458 459 vcpu_ioctl(vcpu, KVM_ENABLE_CAP, &enable_cap); 460 } 461 462 static inline void vcpu_guest_debug_set(struct kvm_vcpu *vcpu, 463 struct kvm_guest_debug *debug) 464 { 465 vcpu_ioctl(vcpu, KVM_SET_GUEST_DEBUG, debug); 466 } 467 468 static inline void vcpu_mp_state_get(struct kvm_vcpu *vcpu, 469 struct kvm_mp_state *mp_state) 470 { 471 vcpu_ioctl(vcpu, KVM_GET_MP_STATE, mp_state); 472 } 473 static inline void vcpu_mp_state_set(struct kvm_vcpu *vcpu, 474 struct kvm_mp_state *mp_state) 475 { 476 vcpu_ioctl(vcpu, KVM_SET_MP_STATE, mp_state); 477 } 478 479 static inline void vcpu_regs_get(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 480 { 481 vcpu_ioctl(vcpu, KVM_GET_REGS, regs); 482 } 483 484 static inline void vcpu_regs_set(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 485 { 486 vcpu_ioctl(vcpu, KVM_SET_REGS, regs); 487 } 488 static inline void vcpu_sregs_get(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) 489 { 490 vcpu_ioctl(vcpu, KVM_GET_SREGS, sregs); 491 492 } 493 static inline void vcpu_sregs_set(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) 494 { 495 vcpu_ioctl(vcpu, KVM_SET_SREGS, sregs); 496 } 497 static inline int _vcpu_sregs_set(struct kvm_vcpu *vcpu, struct kvm_sregs *sregs) 498 { 499 return __vcpu_ioctl(vcpu, KVM_SET_SREGS, sregs); 500 } 501 static inline void vcpu_fpu_get(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 502 { 503 vcpu_ioctl(vcpu, KVM_GET_FPU, fpu); 504 } 505 static inline void vcpu_fpu_set(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 506 { 507 vcpu_ioctl(vcpu, KVM_SET_FPU, fpu); 508 } 509 510 static inline int __vcpu_get_reg(struct kvm_vcpu *vcpu, uint64_t id, void *addr) 511 { 512 struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)addr }; 513 514 return __vcpu_ioctl(vcpu, KVM_GET_ONE_REG, ®); 515 } 516 static inline int __vcpu_set_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t val) 517 { 518 struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)&val }; 519 520 return __vcpu_ioctl(vcpu, KVM_SET_ONE_REG, ®); 521 } 522 static inline void vcpu_get_reg(struct kvm_vcpu *vcpu, uint64_t id, void *addr) 523 { 524 struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)addr }; 525 526 vcpu_ioctl(vcpu, KVM_GET_ONE_REG, ®); 527 } 528 static inline void vcpu_set_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t val) 529 { 530 struct kvm_one_reg reg = { .id = id, .addr = (uint64_t)&val }; 531 532 vcpu_ioctl(vcpu, KVM_SET_ONE_REG, ®); 533 } 534 535 #ifdef __KVM_HAVE_VCPU_EVENTS 536 static inline void vcpu_events_get(struct kvm_vcpu *vcpu, 537 struct kvm_vcpu_events *events) 538 { 539 vcpu_ioctl(vcpu, KVM_GET_VCPU_EVENTS, events); 540 } 541 static inline void vcpu_events_set(struct kvm_vcpu *vcpu, 542 struct kvm_vcpu_events *events) 543 { 544 vcpu_ioctl(vcpu, KVM_SET_VCPU_EVENTS, events); 545 } 546 #endif 547 #ifdef __x86_64__ 548 static inline void vcpu_nested_state_get(struct kvm_vcpu *vcpu, 549 struct kvm_nested_state *state) 550 { 551 vcpu_ioctl(vcpu, KVM_GET_NESTED_STATE, state); 552 } 553 static inline int __vcpu_nested_state_set(struct kvm_vcpu *vcpu, 554 struct kvm_nested_state *state) 555 { 556 return __vcpu_ioctl(vcpu, KVM_SET_NESTED_STATE, state); 557 } 558 559 static inline void vcpu_nested_state_set(struct kvm_vcpu *vcpu, 560 struct kvm_nested_state *state) 561 { 562 vcpu_ioctl(vcpu, KVM_SET_NESTED_STATE, state); 563 } 564 #endif 565 static inline int vcpu_get_stats_fd(struct kvm_vcpu *vcpu) 566 { 567 int fd = __vcpu_ioctl(vcpu, KVM_GET_STATS_FD, NULL); 568 569 TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_GET_STATS_FD, fd)); 570 return fd; 571 } 572 573 int __kvm_has_device_attr(int dev_fd, uint32_t group, uint64_t attr); 574 575 static inline void kvm_has_device_attr(int dev_fd, uint32_t group, uint64_t attr) 576 { 577 int ret = __kvm_has_device_attr(dev_fd, group, attr); 578 579 TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno); 580 } 581 582 int __kvm_device_attr_get(int dev_fd, uint32_t group, uint64_t attr, void *val); 583 584 static inline void kvm_device_attr_get(int dev_fd, uint32_t group, 585 uint64_t attr, void *val) 586 { 587 int ret = __kvm_device_attr_get(dev_fd, group, attr, val); 588 589 TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_GET_DEVICE_ATTR, ret)); 590 } 591 592 int __kvm_device_attr_set(int dev_fd, uint32_t group, uint64_t attr, void *val); 593 594 static inline void kvm_device_attr_set(int dev_fd, uint32_t group, 595 uint64_t attr, void *val) 596 { 597 int ret = __kvm_device_attr_set(dev_fd, group, attr, val); 598 599 TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_SET_DEVICE_ATTR, ret)); 600 } 601 602 static inline int __vcpu_has_device_attr(struct kvm_vcpu *vcpu, uint32_t group, 603 uint64_t attr) 604 { 605 return __kvm_has_device_attr(vcpu->fd, group, attr); 606 } 607 608 static inline void vcpu_has_device_attr(struct kvm_vcpu *vcpu, uint32_t group, 609 uint64_t attr) 610 { 611 kvm_has_device_attr(vcpu->fd, group, attr); 612 } 613 614 static inline int __vcpu_device_attr_get(struct kvm_vcpu *vcpu, uint32_t group, 615 uint64_t attr, void *val) 616 { 617 return __kvm_device_attr_get(vcpu->fd, group, attr, val); 618 } 619 620 static inline void vcpu_device_attr_get(struct kvm_vcpu *vcpu, uint32_t group, 621 uint64_t attr, void *val) 622 { 623 kvm_device_attr_get(vcpu->fd, group, attr, val); 624 } 625 626 static inline int __vcpu_device_attr_set(struct kvm_vcpu *vcpu, uint32_t group, 627 uint64_t attr, void *val) 628 { 629 return __kvm_device_attr_set(vcpu->fd, group, attr, val); 630 } 631 632 static inline void vcpu_device_attr_set(struct kvm_vcpu *vcpu, uint32_t group, 633 uint64_t attr, void *val) 634 { 635 kvm_device_attr_set(vcpu->fd, group, attr, val); 636 } 637 638 int __kvm_test_create_device(struct kvm_vm *vm, uint64_t type); 639 int __kvm_create_device(struct kvm_vm *vm, uint64_t type); 640 641 static inline int kvm_create_device(struct kvm_vm *vm, uint64_t type) 642 { 643 int fd = __kvm_create_device(vm, type); 644 645 TEST_ASSERT(fd >= 0, KVM_IOCTL_ERROR(KVM_CREATE_DEVICE, fd)); 646 return fd; 647 } 648 649 void *vcpu_map_dirty_ring(struct kvm_vcpu *vcpu); 650 651 /* 652 * VM VCPU Args Set 653 * 654 * Input Args: 655 * vm - Virtual Machine 656 * num - number of arguments 657 * ... - arguments, each of type uint64_t 658 * 659 * Output Args: None 660 * 661 * Return: None 662 * 663 * Sets the first @num input parameters for the function at @vcpu's entry point, 664 * per the C calling convention of the architecture, to the values given as 665 * variable args. Each of the variable args is expected to be of type uint64_t. 666 * The maximum @num can be is specific to the architecture. 667 */ 668 void vcpu_args_set(struct kvm_vcpu *vcpu, unsigned int num, ...); 669 670 void kvm_irq_line(struct kvm_vm *vm, uint32_t irq, int level); 671 int _kvm_irq_line(struct kvm_vm *vm, uint32_t irq, int level); 672 673 #define KVM_MAX_IRQ_ROUTES 4096 674 675 struct kvm_irq_routing *kvm_gsi_routing_create(void); 676 void kvm_gsi_routing_irqchip_add(struct kvm_irq_routing *routing, 677 uint32_t gsi, uint32_t pin); 678 int _kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing); 679 void kvm_gsi_routing_write(struct kvm_vm *vm, struct kvm_irq_routing *routing); 680 681 const char *exit_reason_str(unsigned int exit_reason); 682 683 vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min, 684 uint32_t memslot); 685 vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, 686 vm_paddr_t paddr_min, uint32_t memslot); 687 vm_paddr_t vm_alloc_page_table(struct kvm_vm *vm); 688 689 /* 690 * ____vm_create() does KVM_CREATE_VM and little else. __vm_create() also 691 * loads the test binary into guest memory and creates an IRQ chip (x86 only). 692 * __vm_create() does NOT create vCPUs, @nr_runnable_vcpus is used purely to 693 * calculate the amount of memory needed for per-vCPU data, e.g. stacks. 694 */ 695 struct kvm_vm *____vm_create(enum vm_guest_mode mode); 696 struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus, 697 uint64_t nr_extra_pages); 698 699 static inline struct kvm_vm *vm_create_barebones(void) 700 { 701 return ____vm_create(VM_MODE_DEFAULT); 702 } 703 704 static inline struct kvm_vm *vm_create(uint32_t nr_runnable_vcpus) 705 { 706 return __vm_create(VM_MODE_DEFAULT, nr_runnable_vcpus, 0); 707 } 708 709 struct kvm_vm *__vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus, 710 uint64_t extra_mem_pages, 711 void *guest_code, struct kvm_vcpu *vcpus[]); 712 713 static inline struct kvm_vm *vm_create_with_vcpus(uint32_t nr_vcpus, 714 void *guest_code, 715 struct kvm_vcpu *vcpus[]) 716 { 717 return __vm_create_with_vcpus(VM_MODE_DEFAULT, nr_vcpus, 0, 718 guest_code, vcpus); 719 } 720 721 /* 722 * Create a VM with a single vCPU with reasonable defaults and @extra_mem_pages 723 * additional pages of guest memory. Returns the VM and vCPU (via out param). 724 */ 725 struct kvm_vm *__vm_create_with_one_vcpu(struct kvm_vcpu **vcpu, 726 uint64_t extra_mem_pages, 727 void *guest_code); 728 729 static inline struct kvm_vm *vm_create_with_one_vcpu(struct kvm_vcpu **vcpu, 730 void *guest_code) 731 { 732 return __vm_create_with_one_vcpu(vcpu, 0, guest_code); 733 } 734 735 struct kvm_vcpu *vm_recreate_with_one_vcpu(struct kvm_vm *vm); 736 737 void kvm_pin_this_task_to_pcpu(uint32_t pcpu); 738 void kvm_print_vcpu_pinning_help(void); 739 void kvm_parse_vcpu_pinning(const char *pcpus_string, uint32_t vcpu_to_pcpu[], 740 int nr_vcpus); 741 742 unsigned long vm_compute_max_gfn(struct kvm_vm *vm); 743 unsigned int vm_calc_num_guest_pages(enum vm_guest_mode mode, size_t size); 744 unsigned int vm_num_host_pages(enum vm_guest_mode mode, unsigned int num_guest_pages); 745 unsigned int vm_num_guest_pages(enum vm_guest_mode mode, unsigned int num_host_pages); 746 static inline unsigned int 747 vm_adjust_num_guest_pages(enum vm_guest_mode mode, unsigned int num_guest_pages) 748 { 749 unsigned int n; 750 n = vm_num_guest_pages(mode, vm_num_host_pages(mode, num_guest_pages)); 751 #ifdef __s390x__ 752 /* s390 requires 1M aligned guest sizes */ 753 n = (n + 255) & ~255; 754 #endif 755 return n; 756 } 757 758 struct kvm_userspace_memory_region * 759 kvm_userspace_memory_region_find(struct kvm_vm *vm, uint64_t start, 760 uint64_t end); 761 762 #define sync_global_to_guest(vm, g) ({ \ 763 typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g)); \ 764 memcpy(_p, &(g), sizeof(g)); \ 765 }) 766 767 #define sync_global_from_guest(vm, g) ({ \ 768 typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g)); \ 769 memcpy(&(g), _p, sizeof(g)); \ 770 }) 771 772 /* 773 * Write a global value, but only in the VM's (guest's) domain. Primarily used 774 * for "globals" that hold per-VM values (VMs always duplicate code and global 775 * data into their own region of physical memory), but can be used anytime it's 776 * undesirable to change the host's copy of the global. 777 */ 778 #define write_guest_global(vm, g, val) ({ \ 779 typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g)); \ 780 typeof(g) _val = val; \ 781 \ 782 memcpy(_p, &(_val), sizeof(g)); \ 783 }) 784 785 void assert_on_unhandled_exception(struct kvm_vcpu *vcpu); 786 787 void vcpu_arch_dump(FILE *stream, struct kvm_vcpu *vcpu, 788 uint8_t indent); 789 790 static inline void vcpu_dump(FILE *stream, struct kvm_vcpu *vcpu, 791 uint8_t indent) 792 { 793 vcpu_arch_dump(stream, vcpu, indent); 794 } 795 796 /* 797 * Adds a vCPU with reasonable defaults (e.g. a stack) 798 * 799 * Input Args: 800 * vm - Virtual Machine 801 * vcpu_id - The id of the VCPU to add to the VM. 802 * guest_code - The vCPU's entry point 803 */ 804 struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, 805 void *guest_code); 806 807 static inline struct kvm_vcpu *vm_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, 808 void *guest_code) 809 { 810 return vm_arch_vcpu_add(vm, vcpu_id, guest_code); 811 } 812 813 /* Re-create a vCPU after restarting a VM, e.g. for state save/restore tests. */ 814 struct kvm_vcpu *vm_arch_vcpu_recreate(struct kvm_vm *vm, uint32_t vcpu_id); 815 816 static inline struct kvm_vcpu *vm_vcpu_recreate(struct kvm_vm *vm, 817 uint32_t vcpu_id) 818 { 819 return vm_arch_vcpu_recreate(vm, vcpu_id); 820 } 821 822 void vcpu_arch_free(struct kvm_vcpu *vcpu); 823 824 void virt_arch_pgd_alloc(struct kvm_vm *vm); 825 826 static inline void virt_pgd_alloc(struct kvm_vm *vm) 827 { 828 virt_arch_pgd_alloc(vm); 829 } 830 831 /* 832 * VM Virtual Page Map 833 * 834 * Input Args: 835 * vm - Virtual Machine 836 * vaddr - VM Virtual Address 837 * paddr - VM Physical Address 838 * memslot - Memory region slot for new virtual translation tables 839 * 840 * Output Args: None 841 * 842 * Return: None 843 * 844 * Within @vm, creates a virtual translation for the page starting 845 * at @vaddr to the page starting at @paddr. 846 */ 847 void virt_arch_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr); 848 849 static inline void virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr) 850 { 851 virt_arch_pg_map(vm, vaddr, paddr); 852 } 853 854 855 /* 856 * Address Guest Virtual to Guest Physical 857 * 858 * Input Args: 859 * vm - Virtual Machine 860 * gva - VM virtual address 861 * 862 * Output Args: None 863 * 864 * Return: 865 * Equivalent VM physical address 866 * 867 * Returns the VM physical address of the translated VM virtual 868 * address given by @gva. 869 */ 870 vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva); 871 872 static inline vm_paddr_t addr_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva) 873 { 874 return addr_arch_gva2gpa(vm, gva); 875 } 876 877 /* 878 * Virtual Translation Tables Dump 879 * 880 * Input Args: 881 * stream - Output FILE stream 882 * vm - Virtual Machine 883 * indent - Left margin indent amount 884 * 885 * Output Args: None 886 * 887 * Return: None 888 * 889 * Dumps to the FILE stream given by @stream, the contents of all the 890 * virtual translation tables for the VM given by @vm. 891 */ 892 void virt_arch_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent); 893 894 static inline void virt_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent) 895 { 896 virt_arch_dump(stream, vm, indent); 897 } 898 899 900 static inline int __vm_disable_nx_huge_pages(struct kvm_vm *vm) 901 { 902 return __vm_enable_cap(vm, KVM_CAP_VM_DISABLE_NX_HUGE_PAGES, 0); 903 } 904 905 /* 906 * Arch hook that is invoked via a constructor, i.e. before exeucting main(), 907 * to allow for arch-specific setup that is common to all tests, e.g. computing 908 * the default guest "mode". 909 */ 910 void kvm_selftest_arch_init(void); 911 912 void kvm_arch_vm_post_create(struct kvm_vm *vm); 913 914 #endif /* SELFTEST_KVM_UTIL_BASE_H */ 915