KVM: s390: add kselftests
This is the initial implementation for KVM selftests on s390. -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.22 (GNU/Linux) iQIcBAABAgAGBQJdGfsWAAoJEBF7vIC1phx8MLAP+wWRG6ZBr4K0GJMRVWnudfbD Bk/j2s4Oi8V/B8Px5/aa5BEhCzrQVWHxdCGPSdViV3Z8V2HWY0bDOl/Ul2+yaKrx IgnQkEJZjLlN8/RZKX9F28MnST05b3EqXhzt7+vSUMcmnWFVFzErWQW9JT1LQVDE x/pVlGW/SpLEEdDR22ZEAqQQLuSid+I0RpvWSe7wRTVd0IlIN0X8q70f2yU7Lxpw oAVinmZ1fhu6WF1TMPbpL9GJtKMX5I0XqYnw8x9fFGkSWU7NNHzrvnv6ui7jwagG tRqKE6vWeCVr+0PDarDOXTM6o5PfskOHXNENAKuCCJk4oGKQM2GTYJ15t5IyTDBl qTIR6BccJ8PDudm7Mir6jyFyu89t6C/lsYGvbar4p44GouO4Z5mowUkpLmAMSJgO i+gFCeKR9cj2Zz15cjsD2CrsQI6EPa9t3O8T4hsLuSOxRU+oc2plegRZ7i7hLNnw 075RGRv/hgzC9bUjOtJ3u7Rqny8TSGgNIedg3CujOD2TLYvrCT9CmcibTFlrQpvk UBPUNSN+TIqPgvD/5fnEG809EKS0yiqu+8Ihm4b5W6zx8cP3cSoXEcaBuQXCLbQ5 XVDb4Yji0tMfxP75uCofEE/R2NMvHfkJ72zGvuXv1nSkXSPViQGkmXrWE0ie87hm qyilYkncFh3wd6usbhBW =STwX -----END PGP SIGNATURE----- Merge tag 'kvm-s390-next-5.3-1' of git://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux into HEAD KVM: s390: add kselftests This is the initial implementation for KVM selftests on s390.
This commit is contained in:
Paolo Bonzini
commit
fd4198bf17
|
|
@ -8797,6 +8797,8 @@ F: arch/s390/include/asm/gmap.h
|
|||
F: arch/s390/include/asm/kvm*
|
||||
F: arch/s390/kvm/
|
||||
F: arch/s390/mm/gmap.c
|
||||
F: tools/testing/selftests/kvm/s390x/
|
||||
F: tools/testing/selftests/kvm/*/s390x/
|
||||
|
||||
KERNEL VIRTUAL MACHINE FOR X86 (KVM/x86)
|
||||
M: Paolo Bonzini <pbonzini@redhat.com>
|
||||
|
|
|
|||
|
|
@ -10,11 +10,11 @@ UNAME_M := $(shell uname -m)
|
|||
LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/ucall.c lib/sparsebit.c
|
||||
LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c
|
||||
LIBKVM_aarch64 = lib/aarch64/processor.c
|
||||
LIBKVM_s390x = lib/s390x/processor.c
|
||||
|
||||
TEST_GEN_PROGS_x86_64 = x86_64/cr4_cpuid_sync_test
|
||||
TEST_GEN_PROGS_x86_64 += x86_64/evmcs_test
|
||||
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
|
||||
TEST_GEN_PROGS_x86_64 += x86_64/kvm_create_max_vcpus
|
||||
TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
|
||||
TEST_GEN_PROGS_x86_64 += x86_64/platform_info_test
|
||||
TEST_GEN_PROGS_x86_64 += x86_64/set_sregs_test
|
||||
|
|
@ -26,9 +26,14 @@ TEST_GEN_PROGS_x86_64 += x86_64/vmx_set_nested_state_test
|
|||
TEST_GEN_PROGS_x86_64 += x86_64/vmx_tsc_adjust_test
|
||||
TEST_GEN_PROGS_x86_64 += clear_dirty_log_test
|
||||
TEST_GEN_PROGS_x86_64 += dirty_log_test
|
||||
TEST_GEN_PROGS_x86_64 += kvm_create_max_vcpus
|
||||
|
||||
TEST_GEN_PROGS_aarch64 += clear_dirty_log_test
|
||||
TEST_GEN_PROGS_aarch64 += dirty_log_test
|
||||
TEST_GEN_PROGS_aarch64 += kvm_create_max_vcpus
|
||||
|
||||
TEST_GEN_PROGS_s390x += s390x/sync_regs_test
|
||||
TEST_GEN_PROGS_s390x += kvm_create_max_vcpus
|
||||
|
||||
TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(UNAME_M))
|
||||
LIBKVM += $(LIBKVM_$(UNAME_M))
|
||||
|
|
@ -43,7 +48,12 @@ CFLAGS += -Wall -Wstrict-prototypes -Wuninitialized -O2 -g -std=gnu99 \
|
|||
no-pie-option := $(call try-run, echo 'int main() { return 0; }' | \
|
||||
$(CC) -Werror $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -no-pie -x c - -o "$$TMP", -no-pie)
|
||||
|
||||
LDFLAGS += -pthread $(no-pie-option)
|
||||
# On s390, build the testcases KVM-enabled
|
||||
pgste-option = $(call try-run, echo 'int main() { return 0; }' | \
|
||||
$(CC) -Werror -Wl$(comma)--s390-pgste -x c - -o "$$TMP",-Wl$(comma)--s390-pgste)
|
||||
|
||||
|
||||
LDFLAGS += -pthread $(no-pie-option) $(pgste-option)
|
||||
|
||||
# After inclusion, $(OUTPUT) is defined and
|
||||
# $(TEST_GEN_PROGS) starts with $(OUTPUT)/
|
||||
|
|
|
|||
|
|
@ -41,6 +41,12 @@ enum vm_guest_mode {
|
|||
NUM_VM_MODES,
|
||||
};
|
||||
|
||||
#ifdef __aarch64__
|
||||
#define VM_MODE_DEFAULT VM_MODE_P40V48_4K
|
||||
#else
|
||||
#define VM_MODE_DEFAULT VM_MODE_P52V48_4K
|
||||
#endif
|
||||
|
||||
#define vm_guest_mode_string(m) vm_guest_mode_string[m]
|
||||
extern const char * const vm_guest_mode_string[];
|
||||
|
||||
|
|
@ -111,10 +117,12 @@ void vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid,
|
|||
struct kvm_sregs *sregs);
|
||||
int _vcpu_sregs_set(struct kvm_vm *vm, uint32_t vcpuid,
|
||||
struct kvm_sregs *sregs);
|
||||
#ifdef __KVM_HAVE_VCPU_EVENTS
|
||||
void vcpu_events_get(struct kvm_vm *vm, uint32_t vcpuid,
|
||||
struct kvm_vcpu_events *events);
|
||||
void vcpu_events_set(struct kvm_vm *vm, uint32_t vcpuid,
|
||||
struct kvm_vcpu_events *events);
|
||||
#endif
|
||||
#ifdef __x86_64__
|
||||
void vcpu_nested_state_get(struct kvm_vm *vm, uint32_t vcpuid,
|
||||
struct kvm_nested_state *state);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,22 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* s390x processor specific defines
|
||||
*/
|
||||
#ifndef SELFTEST_KVM_PROCESSOR_H
|
||||
#define SELFTEST_KVM_PROCESSOR_H
|
||||
|
||||
/* Bits in the region/segment table entry */
|
||||
#define REGION_ENTRY_ORIGIN ~0xfffUL /* region/segment table origin */
|
||||
#define REGION_ENTRY_PROTECT 0x200 /* region protection bit */
|
||||
#define REGION_ENTRY_NOEXEC 0x100 /* region no-execute bit */
|
||||
#define REGION_ENTRY_OFFSET 0xc0 /* region table offset */
|
||||
#define REGION_ENTRY_INVALID 0x20 /* invalid region table entry */
|
||||
#define REGION_ENTRY_TYPE 0x0c /* region/segment table type mask */
|
||||
#define REGION_ENTRY_LENGTH 0x03 /* region third length */
|
||||
|
||||
/* Bits in the page table entry */
|
||||
#define PAGE_INVALID 0x400 /* HW invalid bit */
|
||||
#define PAGE_PROTECT 0x200 /* HW read-only bit */
|
||||
#define PAGE_NOEXEC 0x100 /* HW no-execute bit */
|
||||
|
||||
#endif
|
||||
|
|
@ -27,7 +27,7 @@ void test_vcpu_creation(int first_vcpu_id, int num_vcpus)
|
|||
printf("Testing creating %d vCPUs, with IDs %d...%d.\n",
|
||||
num_vcpus, first_vcpu_id, first_vcpu_id + num_vcpus - 1);
|
||||
|
||||
vm = vm_create(VM_MODE_P52V48_4K, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
|
||||
vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
|
||||
|
||||
for (i = 0; i < num_vcpus; i++) {
|
||||
int vcpu_id = first_vcpu_id + i;
|
||||
|
|
@ -227,7 +227,7 @@ struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_pages,
|
|||
uint64_t extra_pg_pages = (extra_mem_pages / ptrs_per_4k_pte) * 2;
|
||||
struct kvm_vm *vm;
|
||||
|
||||
vm = vm_create(VM_MODE_P40V48_4K, DEFAULT_GUEST_PHY_PAGES + extra_pg_pages, O_RDWR);
|
||||
vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES + extra_pg_pages, O_RDWR);
|
||||
|
||||
kvm_vm_elf_load(vm, program_invocation_name, 0, 0);
|
||||
vm_vcpu_add_default(vm, vcpuid, guest_code);
|
||||
|
|
|
|||
|
|
@ -556,6 +556,7 @@ void vm_userspace_mem_region_add(struct kvm_vm *vm,
|
|||
int ret;
|
||||
struct userspace_mem_region *region;
|
||||
size_t huge_page_size = KVM_UTIL_PGS_PER_HUGEPG * vm->page_size;
|
||||
size_t alignment;
|
||||
|
||||
TEST_ASSERT((guest_paddr % vm->page_size) == 0, "Guest physical "
|
||||
"address not on a page boundary.\n"
|
||||
|
|
@ -605,9 +606,20 @@ void vm_userspace_mem_region_add(struct kvm_vm *vm,
|
|||
TEST_ASSERT(region != NULL, "Insufficient Memory");
|
||||
region->mmap_size = npages * vm->page_size;
|
||||
|
||||
/* Enough memory to align up to a huge page. */
|
||||
#ifdef __s390x__
|
||||
/* On s390x, the host address must be aligned to 1M (due to PGSTEs) */
|
||||
alignment = 0x100000;
|
||||
#else
|
||||
alignment = 1;
|
||||
#endif
|
||||
|
||||
if (src_type == VM_MEM_SRC_ANONYMOUS_THP)
|
||||
region->mmap_size += huge_page_size;
|
||||
alignment = max(huge_page_size, alignment);
|
||||
|
||||
/* Add enough memory to align up if necessary */
|
||||
if (alignment > 1)
|
||||
region->mmap_size += alignment;
|
||||
|
||||
region->mmap_start = mmap(NULL, region->mmap_size,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_PRIVATE | MAP_ANONYMOUS
|
||||
|
|
@ -617,9 +629,8 @@ void vm_userspace_mem_region_add(struct kvm_vm *vm,
|
|||
"test_malloc failed, mmap_start: %p errno: %i",
|
||||
region->mmap_start, errno);
|
||||
|
||||
/* Align THP allocation up to start of a huge page. */
|
||||
region->host_mem = align(region->mmap_start,
|
||||
src_type == VM_MEM_SRC_ANONYMOUS_THP ? huge_page_size : 1);
|
||||
/* Align host address */
|
||||
region->host_mem = align(region->mmap_start, alignment);
|
||||
|
||||
/* As needed perform madvise */
|
||||
if (src_type == VM_MEM_SRC_ANONYMOUS || src_type == VM_MEM_SRC_ANONYMOUS_THP) {
|
||||
|
|
@ -1218,6 +1229,7 @@ void vcpu_regs_set(struct kvm_vm *vm, uint32_t vcpuid, struct kvm_regs *regs)
|
|||
ret, errno);
|
||||
}
|
||||
|
||||
#ifdef __KVM_HAVE_VCPU_EVENTS
|
||||
void vcpu_events_get(struct kvm_vm *vm, uint32_t vcpuid,
|
||||
struct kvm_vcpu_events *events)
|
||||
{
|
||||
|
|
@ -1243,6 +1255,7 @@ void vcpu_events_set(struct kvm_vm *vm, uint32_t vcpuid,
|
|||
TEST_ASSERT(ret == 0, "KVM_SET_VCPU_EVENTS, failed, rc: %i errno: %i",
|
||||
ret, errno);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __x86_64__
|
||||
void vcpu_nested_state_get(struct kvm_vm *vm, uint32_t vcpuid,
|
||||
|
|
|
|||
|
|
@ -0,0 +1,278 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
/*
|
||||
* KVM selftest s390x library code - CPU-related functions (page tables...)
|
||||
*
|
||||
* Copyright (C) 2019, Red Hat, Inc.
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE /* for program_invocation_name */
|
||||
|
||||
#include "processor.h"
|
||||
#include "kvm_util.h"
|
||||
#include "../kvm_util_internal.h"
|
||||
|
||||
#define KVM_GUEST_PAGE_TABLE_MIN_PADDR 0x180000
|
||||
|
||||
#define PAGES_PER_REGION 4
|
||||
|
||||
void virt_pgd_alloc(struct kvm_vm *vm, uint32_t memslot)
|
||||
{
|
||||
vm_paddr_t paddr;
|
||||
|
||||
TEST_ASSERT(vm->page_size == 4096, "Unsupported page size: 0x%x",
|
||||
vm->page_size);
|
||||
|
||||
if (vm->pgd_created)
|
||||
return;
|
||||
|
||||
paddr = vm_phy_pages_alloc(vm, PAGES_PER_REGION,
|
||||
KVM_GUEST_PAGE_TABLE_MIN_PADDR, memslot);
|
||||
memset(addr_gpa2hva(vm, paddr), 0xff, PAGES_PER_REGION * vm->page_size);
|
||||
|
||||
vm->pgd = paddr;
|
||||
vm->pgd_created = true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate 4 pages for a region/segment table (ri < 4), or one page for
|
||||
* a page table (ri == 4). Returns a suitable region/segment table entry
|
||||
* which points to the freshly allocated pages.
|
||||
*/
|
||||
static uint64_t virt_alloc_region(struct kvm_vm *vm, int ri, uint32_t memslot)
|
||||
{
|
||||
uint64_t taddr;
|
||||
|
||||
taddr = vm_phy_pages_alloc(vm, ri < 4 ? PAGES_PER_REGION : 1,
|
||||
KVM_GUEST_PAGE_TABLE_MIN_PADDR, memslot);
|
||||
memset(addr_gpa2hva(vm, taddr), 0xff, PAGES_PER_REGION * vm->page_size);
|
||||
|
||||
return (taddr & REGION_ENTRY_ORIGIN)
|
||||
| (((4 - ri) << 2) & REGION_ENTRY_TYPE)
|
||||
| ((ri < 4 ? (PAGES_PER_REGION - 1) : 0) & REGION_ENTRY_LENGTH);
|
||||
}
|
||||
|
||||
/*
|
||||
* VM Virtual Page Map
|
||||
*
|
||||
* Input Args:
|
||||
* vm - Virtual Machine
|
||||
* gva - VM Virtual Address
|
||||
* gpa - VM Physical Address
|
||||
* memslot - Memory region slot for new virtual translation tables
|
||||
*
|
||||
* Output Args: None
|
||||
*
|
||||
* Return: None
|
||||
*
|
||||
* Within the VM given by vm, creates a virtual translation for the page
|
||||
* starting at vaddr to the page starting at paddr.
|
||||
*/
|
||||
void virt_pg_map(struct kvm_vm *vm, uint64_t gva, uint64_t gpa,
|
||||
uint32_t memslot)
|
||||
{
|
||||
int ri, idx;
|
||||
uint64_t *entry;
|
||||
|
||||
TEST_ASSERT((gva % vm->page_size) == 0,
|
||||
"Virtual address not on page boundary,\n"
|
||||
" vaddr: 0x%lx vm->page_size: 0x%x",
|
||||
gva, vm->page_size);
|
||||
TEST_ASSERT(sparsebit_is_set(vm->vpages_valid,
|
||||
(gva >> vm->page_shift)),
|
||||
"Invalid virtual address, vaddr: 0x%lx",
|
||||
gva);
|
||||
TEST_ASSERT((gpa % vm->page_size) == 0,
|
||||
"Physical address not on page boundary,\n"
|
||||
" paddr: 0x%lx vm->page_size: 0x%x",
|
||||
gva, vm->page_size);
|
||||
TEST_ASSERT((gpa >> vm->page_shift) <= vm->max_gfn,
|
||||
"Physical address beyond beyond maximum supported,\n"
|
||||
" paddr: 0x%lx vm->max_gfn: 0x%lx vm->page_size: 0x%x",
|
||||
gva, vm->max_gfn, vm->page_size);
|
||||
|
||||
/* Walk through region and segment tables */
|
||||
entry = addr_gpa2hva(vm, vm->pgd);
|
||||
for (ri = 1; ri <= 4; ri++) {
|
||||
idx = (gva >> (64 - 11 * ri)) & 0x7ffu;
|
||||
if (entry[idx] & REGION_ENTRY_INVALID)
|
||||
entry[idx] = virt_alloc_region(vm, ri, memslot);
|
||||
entry = addr_gpa2hva(vm, entry[idx] & REGION_ENTRY_ORIGIN);
|
||||
}
|
||||
|
||||
/* Fill in page table entry */
|
||||
idx = (gva >> 12) & 0x0ffu; /* page index */
|
||||
if (!(entry[idx] & PAGE_INVALID))
|
||||
fprintf(stderr,
|
||||
"WARNING: PTE for gpa=0x%"PRIx64" already set!\n", gpa);
|
||||
entry[idx] = gpa;
|
||||
}
|
||||
|
||||
/*
|
||||
* Address Guest Virtual to Guest Physical
|
||||
*
|
||||
* Input Args:
|
||||
* vm - Virtual Machine
|
||||
* gpa - VM virtual address
|
||||
*
|
||||
* Output Args: None
|
||||
*
|
||||
* Return:
|
||||
* Equivalent VM physical address
|
||||
*
|
||||
* Translates the VM virtual address given by gva to a VM physical
|
||||
* address and then locates the memory region containing the VM
|
||||
* physical address, within the VM given by vm. When found, the host
|
||||
* virtual address providing the memory to the vm physical address is
|
||||
* returned.
|
||||
* A TEST_ASSERT failure occurs if no region containing translated
|
||||
* VM virtual address exists.
|
||||
*/
|
||||
vm_paddr_t addr_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva)
|
||||
{
|
||||
int ri, idx;
|
||||
uint64_t *entry;
|
||||
|
||||
TEST_ASSERT(vm->page_size == 4096, "Unsupported page size: 0x%x",
|
||||
vm->page_size);
|
||||
|
||||
entry = addr_gpa2hva(vm, vm->pgd);
|
||||
for (ri = 1; ri <= 4; ri++) {
|
||||
idx = (gva >> (64 - 11 * ri)) & 0x7ffu;
|
||||
TEST_ASSERT(!(entry[idx] & REGION_ENTRY_INVALID),
|
||||
"No region mapping for vm virtual address 0x%lx",
|
||||
gva);
|
||||
entry = addr_gpa2hva(vm, entry[idx] & REGION_ENTRY_ORIGIN);
|
||||
}
|
||||
|
||||
idx = (gva >> 12) & 0x0ffu; /* page index */
|
||||
|
||||
TEST_ASSERT(!(entry[idx] & PAGE_INVALID),
|
||||
"No page mapping for vm virtual address 0x%lx", gva);
|
||||
|
||||
return (entry[idx] & ~0xffful) + (gva & 0xffful);
|
||||
}
|
||||
|
||||
static void virt_dump_ptes(FILE *stream, struct kvm_vm *vm, uint8_t indent,
|
||||
uint64_t ptea_start)
|
||||
{
|
||||
uint64_t *pte, ptea;
|
||||
|
||||
for (ptea = ptea_start; ptea < ptea_start + 0x100 * 8; ptea += 8) {
|
||||
pte = addr_gpa2hva(vm, ptea);
|
||||
if (*pte & PAGE_INVALID)
|
||||
continue;
|
||||
fprintf(stream, "%*spte @ 0x%lx: 0x%016lx\n",
|
||||
indent, "", ptea, *pte);
|
||||
}
|
||||
}
|
||||
|
||||
static void virt_dump_region(FILE *stream, struct kvm_vm *vm, uint8_t indent,
|
||||
uint64_t reg_tab_addr)
|
||||
{
|
||||
uint64_t addr, *entry;
|
||||
|
||||
for (addr = reg_tab_addr; addr < reg_tab_addr + 0x400 * 8; addr += 8) {
|
||||
entry = addr_gpa2hva(vm, addr);
|
||||
if (*entry & REGION_ENTRY_INVALID)
|
||||
continue;
|
||||
fprintf(stream, "%*srt%lde @ 0x%lx: 0x%016lx\n",
|
||||
indent, "", 4 - ((*entry & REGION_ENTRY_TYPE) >> 2),
|
||||
addr, *entry);
|
||||
if (*entry & REGION_ENTRY_TYPE) {
|
||||
virt_dump_region(stream, vm, indent + 2,
|
||||
*entry & REGION_ENTRY_ORIGIN);
|
||||
} else {
|
||||
virt_dump_ptes(stream, vm, indent + 2,
|
||||
*entry & REGION_ENTRY_ORIGIN);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void virt_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent)
|
||||
{
|
||||
if (!vm->pgd_created)
|
||||
return;
|
||||
|
||||
virt_dump_region(stream, vm, indent, vm->pgd);
|
||||
}
|
||||
|
||||
/*
|
||||
* Create a VM with reasonable defaults
|
||||
*
|
||||
* Input Args:
|
||||
* vcpuid - The id of the single VCPU to add to the VM.
|
||||
* extra_mem_pages - The size of extra memories to add (this will
|
||||
* decide how much extra space we will need to
|
||||
* setup the page tables using mem slot 0)
|
||||
* guest_code - The vCPU's entry point
|
||||
*
|
||||
* Output Args: None
|
||||
*
|
||||
* Return:
|
||||
* Pointer to opaque structure that describes the created VM.
|
||||
*/
|
||||
struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_pages,
|
||||
void *guest_code)
|
||||
{
|
||||
/*
|
||||
* The additional amount of pages required for the page tables is:
|
||||
* 1 * n / 256 + 4 * (n / 256) / 2048 + 4 * (n / 256) / 2048^2 + ...
|
||||
* which is definitely smaller than (n / 256) * 2.
|
||||
*/
|
||||
uint64_t extra_pg_pages = extra_mem_pages / 256 * 2;
|
||||
struct kvm_vm *vm;
|
||||
|
||||
vm = vm_create(VM_MODE_DEFAULT,
|
||||
DEFAULT_GUEST_PHY_PAGES + extra_pg_pages, O_RDWR);
|
||||
|
||||
kvm_vm_elf_load(vm, program_invocation_name, 0, 0);
|
||||
vm_vcpu_add_default(vm, vcpuid, guest_code);
|
||||
|
||||
return vm;
|
||||
}
|
||||
|
||||
/*
|
||||
* Adds a vCPU with reasonable defaults (i.e. a stack and initial PSW)
|
||||
*
|
||||
* Input Args:
|
||||
* vcpuid - The id of the VCPU to add to the VM.
|
||||
* guest_code - The vCPU's entry point
|
||||
*/
|
||||
void vm_vcpu_add_default(struct kvm_vm *vm, uint32_t vcpuid, void *guest_code)
|
||||
{
|
||||
size_t stack_size = DEFAULT_STACK_PGS * getpagesize();
|
||||
uint64_t stack_vaddr;
|
||||
struct kvm_regs regs;
|
||||
struct kvm_sregs sregs;
|
||||
struct kvm_run *run;
|
||||
|
||||
TEST_ASSERT(vm->page_size == 4096, "Unsupported page size: 0x%x",
|
||||
vm->page_size);
|
||||
|
||||
stack_vaddr = vm_vaddr_alloc(vm, stack_size,
|
||||
DEFAULT_GUEST_STACK_VADDR_MIN, 0, 0);
|
||||
|
||||
vm_vcpu_add(vm, vcpuid);
|
||||
|
||||
/* Setup guest registers */
|
||||
vcpu_regs_get(vm, vcpuid, ®s);
|
||||
regs.gprs[15] = stack_vaddr + (DEFAULT_STACK_PGS * getpagesize()) - 160;
|
||||
vcpu_regs_set(vm, vcpuid, ®s);
|
||||
|
||||
vcpu_sregs_get(vm, vcpuid, &sregs);
|
||||
sregs.crs[0] |= 0x00040000; /* Enable floating point regs */
|
||||
sregs.crs[1] = vm->pgd | 0xf; /* Primary region table */
|
||||
vcpu_sregs_set(vm, vcpuid, &sregs);
|
||||
|
||||
run = vcpu_state(vm, vcpuid);
|
||||
run->psw_mask = 0x0400000180000000ULL; /* DAT enabled + 64 bit mode */
|
||||
run->psw_addr = (uintptr_t)guest_code;
|
||||
}
|
||||
|
||||
void vcpu_dump(FILE *stream, struct kvm_vm *vm, uint32_t vcpuid, uint8_t indent)
|
||||
{
|
||||
struct vcpu *vcpu = vm->vcpu_head;
|
||||
|
||||
fprintf(stream, "%*spstate: psw: 0x%.16llx:0x%.16llx\n",
|
||||
indent, "", vcpu->state->psw_mask, vcpu->state->psw_addr);
|
||||
}
|
||||
|
|
@ -821,7 +821,7 @@ struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_pages,
|
|||
uint64_t extra_pg_pages = extra_mem_pages / 512 * 2;
|
||||
|
||||
/* Create VM */
|
||||
vm = vm_create(VM_MODE_P52V48_4K,
|
||||
vm = vm_create(VM_MODE_DEFAULT,
|
||||
DEFAULT_GUEST_PHY_PAGES + extra_pg_pages,
|
||||
O_RDWR);
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,151 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
/*
|
||||
* Test for s390x KVM_CAP_SYNC_REGS
|
||||
*
|
||||
* Based on the same test for x86:
|
||||
* Copyright (C) 2018, Google LLC.
|
||||
*
|
||||
* Adaptions for s390x:
|
||||
* Copyright (C) 2019, Red Hat, Inc.
|
||||
*
|
||||
* Test expected behavior of the KVM_CAP_SYNC_REGS functionality.
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE /* for program_invocation_short_name */
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/ioctl.h>
|
||||
|
||||
#include "test_util.h"
|
||||
#include "kvm_util.h"
|
||||
|
||||
#define VCPU_ID 5
|
||||
|
||||
static void guest_code(void)
|
||||
{
|
||||
for (;;) {
|
||||
asm volatile ("diag 0,0,0x501");
|
||||
asm volatile ("ahi 11,1");
|
||||
}
|
||||
}
|
||||
|
||||
#define REG_COMPARE(reg) \
|
||||
TEST_ASSERT(left->reg == right->reg, \
|
||||
"Register " #reg \
|
||||
" values did not match: 0x%llx, 0x%llx\n", \
|
||||
left->reg, right->reg)
|
||||
|
||||
static void compare_regs(struct kvm_regs *left, struct kvm_sync_regs *right)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
REG_COMPARE(gprs[i]);
|
||||
}
|
||||
|
||||
static void compare_sregs(struct kvm_sregs *left, struct kvm_sync_regs *right)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
REG_COMPARE(acrs[i]);
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
REG_COMPARE(crs[i]);
|
||||
}
|
||||
|
||||
#undef REG_COMPARE
|
||||
|
||||
#define TEST_SYNC_FIELDS (KVM_SYNC_GPRS|KVM_SYNC_ACRS|KVM_SYNC_CRS)
|
||||
#define INVALID_SYNC_FIELD 0x80000000
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
struct kvm_vm *vm;
|
||||
struct kvm_run *run;
|
||||
struct kvm_regs regs;
|
||||
struct kvm_sregs sregs;
|
||||
int rv, cap;
|
||||
|
||||
/* Tell stdout not to buffer its content */
|
||||
setbuf(stdout, NULL);
|
||||
|
||||
cap = kvm_check_cap(KVM_CAP_SYNC_REGS);
|
||||
if (!cap) {
|
||||
fprintf(stderr, "CAP_SYNC_REGS not supported, skipping test\n");
|
||||
exit(KSFT_SKIP);
|
||||
}
|
||||
|
||||
/* Create VM */
|
||||
vm = vm_create_default(VCPU_ID, 0, guest_code);
|
||||
|
||||
run = vcpu_state(vm, VCPU_ID);
|
||||
|
||||
/* Request and verify all valid register sets. */
|
||||
run->kvm_valid_regs = TEST_SYNC_FIELDS;
|
||||
rv = _vcpu_run(vm, VCPU_ID);
|
||||
TEST_ASSERT(rv == 0, "vcpu_run failed: %d\n", rv);
|
||||
TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
|
||||
"Unexpected exit reason: %u (%s)\n",
|
||||
run->exit_reason,
|
||||
exit_reason_str(run->exit_reason));
|
||||
TEST_ASSERT(run->s390_sieic.icptcode == 4 &&
|
||||
(run->s390_sieic.ipa >> 8) == 0x83 &&
|
||||
(run->s390_sieic.ipb >> 16) == 0x501,
|
||||
"Unexpected interception code: ic=%u, ipa=0x%x, ipb=0x%x\n",
|
||||
run->s390_sieic.icptcode, run->s390_sieic.ipa,
|
||||
run->s390_sieic.ipb);
|
||||
|
||||
vcpu_regs_get(vm, VCPU_ID, ®s);
|
||||
compare_regs(®s, &run->s.regs);
|
||||
|
||||
vcpu_sregs_get(vm, VCPU_ID, &sregs);
|
||||
compare_sregs(&sregs, &run->s.regs);
|
||||
|
||||
/* Set and verify various register values */
|
||||
run->s.regs.gprs[11] = 0xBAD1DEA;
|
||||
run->s.regs.acrs[0] = 1 << 11;
|
||||
|
||||
run->kvm_valid_regs = TEST_SYNC_FIELDS;
|
||||
run->kvm_dirty_regs = KVM_SYNC_GPRS | KVM_SYNC_ACRS;
|
||||
rv = _vcpu_run(vm, VCPU_ID);
|
||||
TEST_ASSERT(rv == 0, "vcpu_run failed: %d\n", rv);
|
||||
TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
|
||||
"Unexpected exit reason: %u (%s)\n",
|
||||
run->exit_reason,
|
||||
exit_reason_str(run->exit_reason));
|
||||
TEST_ASSERT(run->s.regs.gprs[11] == 0xBAD1DEA + 1,
|
||||
"r11 sync regs value incorrect 0x%llx.",
|
||||
run->s.regs.gprs[11]);
|
||||
TEST_ASSERT(run->s.regs.acrs[0] == 1 << 11,
|
||||
"acr0 sync regs value incorrect 0x%llx.",
|
||||
run->s.regs.acrs[0]);
|
||||
|
||||
vcpu_regs_get(vm, VCPU_ID, ®s);
|
||||
compare_regs(®s, &run->s.regs);
|
||||
|
||||
vcpu_sregs_get(vm, VCPU_ID, &sregs);
|
||||
compare_sregs(&sregs, &run->s.regs);
|
||||
|
||||
/* Clear kvm_dirty_regs bits, verify new s.regs values are
|
||||
* overwritten with existing guest values.
|
||||
*/
|
||||
run->kvm_valid_regs = TEST_SYNC_FIELDS;
|
||||
run->kvm_dirty_regs = 0;
|
||||
run->s.regs.gprs[11] = 0xDEADBEEF;
|
||||
rv = _vcpu_run(vm, VCPU_ID);
|
||||
TEST_ASSERT(rv == 0, "vcpu_run failed: %d\n", rv);
|
||||
TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
|
||||
"Unexpected exit reason: %u (%s)\n",
|
||||
run->exit_reason,
|
||||
exit_reason_str(run->exit_reason));
|
||||
TEST_ASSERT(run->s.regs.gprs[11] != 0xDEADBEEF,
|
||||
"r11 sync regs value incorrect 0x%llx.",
|
||||
run->s.regs.gprs[11]);
|
||||
|
||||
kvm_vm_free(vm);
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue