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