tools/testing/selftests/kvm/include/kvm_util_base.h

   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, &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, &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, &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, &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 */