Re: [PATCH 2/2] KVM: selftests: Add support for ppc64le

On 1/21/22 04:01, Fabiano Rosas wrote:

This adds the infrastructure for writing tests for the powerpc platform (Only Radix MMU for now).

This patch also enables two tests:

• a dummy sample test that creates a guest with one vcpu, issues hypercalls and reads/writes test values from memory.

• the kvm_page_table test, although at this point I'm not using it to test KVM, but mostly as a way to stress test this code.

$ make -C tools/testing/selftests TARGETS=kvm $ make -C tools/testing/selftests TARGETS=kvm run_tests

Signed-off-by: Fabiano Rosas farosas@linux.ibm.com

MAINTAINERS | 3 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 14 +- .../selftests/kvm/include/kvm_util_base.h | 7 + .../selftests/kvm/include/ppc64le/processor.h | 43 +++ tools/testing/selftests/kvm/lib/kvm_util.c | 5 + .../testing/selftests/kvm/lib/powerpc/hcall.S | 6 + .../selftests/kvm/lib/powerpc/processor.c | 343 ++++++++++++++++++ .../testing/selftests/kvm/lib/powerpc/ucall.c | 67 ++++ .../selftests/kvm/powerpc/sample_test.c | 144 ++++++++ 10 files changed, 630 insertions(+), 3 deletions(-) create mode 100644 tools/testing/selftests/kvm/include/ppc64le/processor.h create mode 100644 tools/testing/selftests/kvm/lib/powerpc/hcall.S create mode 100644 tools/testing/selftests/kvm/lib/powerpc/processor.c create mode 100644 tools/testing/selftests/kvm/lib/powerpc/ucall.c create mode 100644 tools/testing/selftests/kvm/powerpc/sample_test.c

diff --git a/MAINTAINERS b/MAINTAINERS index a76e7558b151..15c89d33d584 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -10537,6 +10537,9 @@ F: arch/powerpc/include/asm/kvm* F: arch/powerpc/include/uapi/asm/kvm* F: arch/powerpc/kernel/kvm* F: arch/powerpc/kvm/ +F: tools/testing/selftests/kvm/include/ppc64le/ +F: tools/testing/selftests/kvm/lib/powerpc/ +F: tools/testing/selftests/kvm/powerpc/ KERNEL VIRTUAL MACHINE FOR RISC-V (KVM/riscv) M: Anup Patel anup@brainfault.org diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore index 8c129961accf..45ab993e2845 100644 --- a/tools/testing/selftests/kvm/.gitignore +++ b/tools/testing/selftests/kvm/.gitignore @@ -46,6 +46,7 @@ /x86_64/xen_vmcall_test /x86_64/xss_msr_test /x86_64/vmx_pmu_msrs_test +/powerpc/sample_test /access_tracking_perf_test /demand_paging_test /dirty_log_test diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index 556da71c33b8..5ae27109e9b9 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -17,9 +17,9 @@ KSFT_KHDR_INSTALL := 1 # LINUX_TOOL_ARCH_INCLUDE is set using ARCH variable. # # x86_64 targets are named to include x86_64 as a suffix and directories -# for includes are in x86_64 sub-directory. s390x and aarch64 follow the -# same convention. "uname -m" doesn't result in the correct mapping for -# s390x and aarch64. +# for includes are in x86_64 sub-directory. s390x, aarch64 and ppc64le +# follow the same convention. "uname -m" doesn't result in the correct +# mapping for s390x, aarch64 and ppc64le. # # No change necessary for x86_64 UNAME_M := $(shell uname -m) @@ -36,12 +36,17 @@ endif ifeq ($(ARCH),riscv) UNAME_M := riscv endif +# Set UNAME_M for ppc64le compile/install to work +ifeq ($(ARCH),powerpc)

• UNAME_M := ppc64le

+endif LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/rbtree.c lib/sparsebit.c lib/test_util.c lib/guest_modes.c lib/perf_test_util.c LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c lib/aarch64/handlers.S lib/aarch64/spinlock.c lib/aarch64/gic.c lib/aarch64/gic_v3.c lib/aarch64/vgic.c LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c lib/s390x/diag318_test_handler.c LIBKVM_riscv = lib/riscv/processor.c lib/riscv/ucall.c +LIBKVM_ppc64le = lib/powerpc/processor.c lib/powerpc/ucall.c lib/powerpc/hcall.S TEST_GEN_PROGS_x86_64 = x86_64/cr4_cpuid_sync_test TEST_GEN_PROGS_x86_64 += x86_64/get_msr_index_features @@ -133,6 +138,9 @@ TEST_GEN_PROGS_riscv += kvm_page_table_test TEST_GEN_PROGS_riscv += set_memory_region_test TEST_GEN_PROGS_riscv += kvm_binary_stats_test +TEST_GEN_PROGS_ppc64le += powerpc/sample_test +TEST_GEN_PROGS_ppc64le += kvm_page_table_test

• TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(UNAME_M)) LIBKVM += $(LIBKVM_$(UNAME_M))

diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h index 66775de26952..a930d663fe67 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -54,6 +54,7 @@ enum vm_guest_mode { VM_MODE_P36V48_16K, VM_MODE_P36V48_64K, VM_MODE_P36V47_16K,

• VM_MODE_P51V52_64K, NUM_VM_MODES, };

@@ -87,6 +88,12 @@ extern enum vm_guest_mode vm_mode_default; #define MIN_PAGE_SHIFT 12U #define ptes_per_page(page_size) ((page_size) / 8) +#elif defined(__powerpc__)

+#define VM_MODE_DEFAULT VM_MODE_P51V52_64K +#define MIN_PAGE_SHIFT 16U +#define ptes_per_page(page_size) ((page_size) / 8)

• #endif

#define MIN_PAGE_SIZE (1U << MIN_PAGE_SHIFT) diff --git a/tools/testing/selftests/kvm/include/ppc64le/processor.h b/tools/testing/selftests/kvm/include/ppc64le/processor.h new file mode 100644 index 000000000000..fbc1332b2b80 --- /dev/null +++ b/tools/testing/selftests/kvm/include/ppc64le/processor.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/*

• • powerpc processor specific defines
• */

+#ifndef SELFTEST_KVM_PROCESSOR_H +#define SELFTEST_KVM_PROCESSOR_H

+#define PPC_BIT(x) (1ULL << (63 - x))

Put the "x" in braces.

+#define MSR_SF PPC_BIT(0) +#define MSR_IR PPC_BIT(58) +#define MSR_DR PPC_BIT(59) +#define MSR_LE PPC_BIT(63)

+#define LPCR_UPRT PPC_BIT(41) +#define LPCR_EVIRT PPC_BIT(42) +#define LPCR_HR PPC_BIT(43) +#define LPCR_GTSE PPC_BIT(53)

+#define PATB_GR PPC_BIT(0)

+#define PTE_VALID PPC_BIT(0) +#define PTE_LEAF PPC_BIT(1) +#define PTE_R PPC_BIT(55) +#define PTE_C PPC_BIT(56) +#define PTE_RC (PTE_R | PTE_C) +#define PTE_READ 0x4 +#define PTE_WRITE 0x2 +#define PTE_EXEC 0x1 +#define PTE_RWX (PTE_READ|PTE_WRITE|PTE_EXEC)

+extern uint64_t hcall(uint64_t nr, ...);

+static inline uint32_t mfpvr(void) +{

• uint32_t pvr;
• asm ("mfpvr %0"

•     : "=r"(pvr));
  

• return pvr;

+}

+#endif diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index c22a17aac6b0..cc5247c2cfeb 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -205,6 +205,7 @@ const char *vm_guest_mode_string(uint32_t i) [VM_MODE_P36V48_16K] = "PA-bits:36, VA-bits:48, 16K pages", [VM_MODE_P36V48_64K] = "PA-bits:36, VA-bits:48, 64K pages", [VM_MODE_P36V47_16K] = "PA-bits:36, VA-bits:47, 16K pages",

• [VM_MODE_P51V52_64K]    = "PA-bits:51,  VA-bits:52, 64K pages",
  

  }; _Static_assert(sizeof(strings)/sizeof(char *) == NUM_VM_MODES, "Missing new mode strings?");

@@ -230,6 +231,7 @@ const struct vm_guest_mode_params vm_guest_mode_params[] = { [VM_MODE_P36V48_16K] = { 36, 48, 0x4000, 14 }, [VM_MODE_P36V48_64K] = { 36, 48, 0x10000, 16 }, [VM_MODE_P36V47_16K] = { 36, 47, 0x4000, 14 },

• [VM_MODE_P51V52_64K] = { 51, 52, 0x10000, 16 }, }; _Static_assert(sizeof(vm_guest_mode_params)/sizeof(struct vm_guest_mode_params) == NUM_VM_MODES, "Missing new mode params?");

@@ -331,6 +333,9 @@ struct kvm_vm *vm_create(enum vm_guest_mode mode, uint64_t phy_pages, int perm) case VM_MODE_P44V64_4K: vm->pgtable_levels = 5; break;

• case VM_MODE_P51V52_64K:

• vm->pgtable_levels = 4;
  

• break;
  

  default: TEST_FAIL("Unknown guest mode, mode: 0x%x", mode); }

diff --git a/tools/testing/selftests/kvm/lib/powerpc/hcall.S b/tools/testing/selftests/kvm/lib/powerpc/hcall.S new file mode 100644 index 000000000000..a78b88f3b207 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/powerpc/hcall.S @@ -0,0 +1,6 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +.globl hcall;

+hcall:

• sc 1
• blr

diff --git a/tools/testing/selftests/kvm/lib/powerpc/processor.c b/tools/testing/selftests/kvm/lib/powerpc/processor.c new file mode 100644 index 000000000000..2ffd5423a968 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/powerpc/processor.c @@ -0,0 +1,343 @@ +// SPDX-License-Identifier: GPL-2.0-only +/*

• • KVM selftest powerpc library code
• • Copyright (C) 2021, IBM Corp.

2022?

Otherwise looks good and works well and we have another test for instruction emilation on top of this which highlighted a bug so this is useful stuff.

Reviewed-by: Alexey Kardashevskiy aik@ozlabs.ru

• */

+#define _GNU_SOURCE +//#define DEBUG

+#include "kvm_util.h" +#include "../kvm_util_internal.h" +#include "processor.h"

+/*

• • 2^(12+PRTS) = Process table size
• • But the hardware doesn't seem to care, so 0 for now.
• */

+#define PRTS 0 +#define RTS ((0x5UL << 5) | (0x2UL << 61)) /* 2^(RTS+31) = 2^52 */ +#define RPDS 0xd +#define RPDB_MASK 0x0fffffffffffff00UL +#define RPN_MASK 0x01fffffffffff000UL

+#define MIN_FRAME_SZ 32

+static const int radix_64k_index_sizes[4] = { 5, 9, 9, 13 };

+static inline uint64_t mk_pte(uint64_t pte_val) +{

• return cpu_to_be64(PTE_VALID | pte_val);

+}

+static inline uint64_t get_pte(uint64_t pte) +{

• return be64_to_cpu(pte);

+}

+static inline uint64_t pte_rpn(uint64_t entry) +{

• return get_pte(entry) & RPN_MASK;

+}

+static inline uint64_t next_pde(uint64_t entry) +{

• return get_pte(entry) & RPDB_MASK;

+}

+static inline uint64_t ptrs_per_pgd(int level) +{

• return 1UL << radix_64k_index_sizes[level];

+}

+static inline uint64_t level_size(int level) +{

• return sizeof(vm_paddr_t) << (radix_64k_index_sizes[level] + 3);

+}

+static vm_paddr_t alloc_pgd(struct kvm_vm *vm, int level) +{

• static vm_paddr_t base;
• vm_paddr_t addr;
• uint64_t size = level_size(level);
• if (!base || (base + size) >> vm->page_shift != base >> vm->page_shift)

• addr = vm_alloc_page_table(vm);
  

• else

• addr = base;
  

• base = addr + size;
• return addr;

+}

+static vm_paddr_t pgtable_walk(struct kvm_vm *vm, vm_vaddr_t gva, uint64_t gpa,

• 	       bool alloc)
  

+{

• uint64_t index_bits, shift, base, index;
• uint64_t *ptep, ptep_gpa;
• int level;
• if (!vm->pgd_created)

• goto unmapped_gva;
  

• pr_debug("%s %#lx ", (alloc ? "mapping" : "lookup "), gva);
• base = vm->pgd;
• shift = vm->va_bits;
• for (level = 3; level >= 0; --level) {

• index_bits = radix_64k_index_sizes[level];
  

• shift -= index_bits;
  

• index = (gva >> shift) & ((1UL << index_bits) - 1);
  

• ptep_gpa = base + index * sizeof(*ptep);
  

• ptep = addr_gpa2hva(vm, ptep_gpa);
  

• if (!*ptep) {
  

• 	if (!alloc)
  

• 		goto unmapped_gva;
  

• 	if (level)
  

• 		*ptep = mk_pte(alloc_pgd(vm, level - 1) |
  

• 			       radix_64k_index_sizes[level - 1]);
  

• }
  

• if (get_pte(*ptep) & PTE_LEAF)
  

• 	break;
  

• base = next_pde(*ptep);
  

• }
• if (alloc)

• *ptep = mk_pte(PTE_LEAF | gpa | PTE_RC | PTE_RWX);
  

• else

• gpa = pte_rpn(*ptep);
  

• pr_debug("-> %#lx pte: %#lx (@%#lx)\n", gpa, get_pte(*ptep), ptep_gpa);
• return gpa | (gva & (vm->page_size - 1));

+unmapped_gva:

• TEST_FAIL("No mapping for vm virtual address, gva: %#lx", gva);
• exit(1);

+}

+void virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr) +{

• TEST_ASSERT((vaddr % vm->page_size) == 0,

•     "Virtual address not on page boundary,\n"
  

•     "  vaddr: 0x%lx vm->page_size: 0x%x", vaddr, vm->page_size);
  

• TEST_ASSERT(sparsebit_is_set(vm->vpages_valid,

• 		     (vaddr >> vm->page_shift)),
  

•     "Invalid virtual address, vaddr: 0x%lx", vaddr);
  

• TEST_ASSERT((paddr % vm->page_size) == 0,

•     "Physical address not on page boundary,\n"
  

•     "  paddr: 0x%lx vm->page_size: 0x%x", paddr, vm->page_size);
  

• TEST_ASSERT((paddr >> vm->page_shift) <= vm->max_gfn,

•     "Physical address beyond maximum supported,\n"
  

•     "  paddr: 0x%lx vm->max_gfn: 0x%lx vm->page_size: 0x%x",
  

•     paddr, vm->max_gfn, vm->page_size);
  

• TEST_ASSERT(vm->pgd_created, "Page table not created\n");
• pgtable_walk(vm, vaddr, paddr, true);

+}

+vm_paddr_t addr_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva) +{

• return pgtable_walk(vm, gva, 0, false);

+}

+void virt_pgd_alloc(struct kvm_vm *vm) +{

• struct kvm_ppc_mmuv3_cfg cfg = { 0 };
• vm_paddr_t proc_tb;
• uint64_t *proc_tb_hva;
• if (!kvm_check_cap(KVM_CAP_PPC_MMU_RADIX)) {

• print_skip("Tests only support Radix MMU");
  

• exit(KSFT_SKIP);
  

• }
• if (!kvm_check_cap(KVM_CAP_PPC_PAPR)) {

• print_skip("Tests only support Book3s");
  

• exit(KSFT_SKIP);
  

• }
• if (vm->pgd_created)

• return;
  

• /*

• * Allocate the process table in guest memory and set the
  

• * first doubleword of the pid 0 entry.
  

• */
  

• proc_tb = vm_alloc_page_table(vm);
• vm->pgd = vm_alloc_page_table(vm);
• proc_tb_hva = addr_gpa2hva(vm, proc_tb);
• *proc_tb_hva = cpu_to_be64(RTS | vm->pgd | RPDS);
• pr_debug("process table gpa: %#lx\n", proc_tb);
• pr_debug("process table hva: %p\n", proc_tb_hva);
• pr_debug("process table entry 0 dw0: %#lx\n", *proc_tb_hva);
• /* Register the process table with the HV */
• cfg.process_table = PATB_GR | proc_tb | PRTS;
• cfg.flags = KVM_PPC_MMUV3_RADIX | KVM_PPC_MMUV3_GTSE;
• pr_debug("MMU config proc table: %#llx\n", cfg.process_table);
• vm_ioctl(vm, KVM_PPC_CONFIGURE_V3_MMU, &cfg);
• vm->pgd_created = true;

+}

+void vm_vcpu_add_default(struct kvm_vm *vm, uint32_t vcpuid, void *guest_code) +{

• struct kvm_enable_cap cap = { 0 };
• struct kvm_regs regs;
• struct kvm_sregs sregs;
• vm_vaddr_t stack_vaddr;
• size_t stack_sz;
• vm_vcpu_add(vm, vcpuid);
• cap.cap = KVM_CAP_PPC_PAPR;
• vcpu_enable_cap(vm, vcpuid, &cap);
• stack_sz = DEFAULT_STACK_PGS * vm->page_size;
• stack_vaddr = vm_vaddr_alloc(vm, stack_sz,

• 		     DEFAULT_GUEST_STACK_VADDR_MIN);
  

• regs.msr = MSR_SF | MSR_LE;
• regs.msr |= MSR_IR | MSR_DR;
• regs.pc = (unsigned long) guest_code;
• regs.pid = 0;
• regs.gpr[1] = stack_vaddr + stack_sz - MIN_FRAME_SZ;
• pr_debug("stack - low: %#lx high: %#lx size: %#lx SP: %#llx\n",

•  stack_vaddr, stack_vaddr + stack_sz, stack_sz, regs.gpr[1]);
  

• vcpu_regs_set(vm, vcpuid, &regs);
• sregs.pvr = mfpvr();
• vcpu_sregs_set(vm, vcpuid, &sregs);
• if (kvm_check_cap(KVM_CAP_ONE_REG)) {

• uint64_t lpcr = LPCR_UPRT | LPCR_HR | LPCR_GTSE;
  

• struct kvm_one_reg reg = {
  

• 	.id = KVM_REG_PPC_LPCR_64,
  

• 	.addr = (uintptr_t) &lpcr,
  

• };
  

• vcpu_ioctl(vm, vcpuid, KVM_SET_ONE_REG, &reg);
  

• }

+}

+void vcpu_args_set(struct kvm_vm *vm, uint32_t vcpuid, unsigned int num, ...) +{

• va_list ap;
• struct kvm_regs regs;
• int i;
• TEST_ASSERT(num >= 1 && num <= 8, "Unsupported number of args,\n"

•     "  num: %u\n", num);
  

• va_start(ap, num);
• vcpu_regs_get(vm, vcpuid, &regs);
• for (i = 0; i < num; i++)

• regs.gpr[i + 3] = va_arg(ap, uint64_t);
  

• vcpu_regs_set(vm, vcpuid, &regs);
• va_end(ap);

+}

+static void pte_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent,

•      uint64_t addr, int level)
  

+{

• static const char * const type[] = { "pte", "pmd", "pud", "pgd" };
• uint64_t pde, *hva;
• if (level < 0)

• return;
  

• fprintf(stream, "%*s (%#lx):\n", indent, type[level], addr);
• for (pde = addr; pde < addr + (ptrs_per_pgd(level) * sizeof(vm_paddr_t));

•     pde += sizeof(vm_paddr_t)) {
  

• hva = addr_gpa2hva(vm, pde);
  

• if (!*hva)
  

• 	continue;
  

• fprintf(stream, "%*s %#lx: %#lx\n", indent + 1, "", pde,
  

• 	get_pte(*hva));
  

• pte_dump(stream, vm, indent + 2, next_pde(*hva), level - 1);
  

• }

+}

+void virt_dump(FILE *stream, struct kvm_vm *vm, uint8_t indent) +{

• if (!vm->pgd_created)

• return;
  

• pte_dump(stream, vm, indent, vm->pgd, 3);

+}

+void vcpu_dump(FILE *stream, struct kvm_vm *vm, uint32_t vcpuid, uint8_t indent) +{

• struct kvm_regs regs;
• fprintf(stream, "%*scpuid: %u\n", indent, "", vcpuid);
• vcpu_regs_get(vm, vcpuid, &regs);
• fprintf(stream, "%*sregs:\n", indent + 2, "");
• fprintf(stream, "%*spc: %#llx\n", indent + 4, "", regs.pc);
• fprintf(stream, "%*smsr: %#llx\n", indent + 4, "", regs.msr);
• fprintf(stream, "%*ssrr0: %#llx\n", indent + 4, "", regs.srr0);
• fprintf(stream, "%*ssrr1: %#llx\n", indent + 4, "", regs.srr1);
• fprintf(stream, "\n%*sr1: %#llx\n", indent + 4, "", regs.gpr[1]);
• fprintf(stream, "%*sr2: %#llx\n", indent + 4, "", regs.gpr[2]);
• fprintf(stream, "%*sr3: %#llx\n", indent + 4, "", regs.gpr[3]);
• fprintf(stream, "%*sr4: %#llx\n", indent + 4, "", regs.gpr[4]);
• if (kvm_check_cap(KVM_CAP_ONE_REG)) {

• uint64_t lpcr;
  

• struct kvm_one_reg reg = {
  

• 	.id = KVM_REG_PPC_LPCR_64,
  

• 	.addr = (uintptr_t) &lpcr,
  

• };
  

• vcpu_ioctl(vm, vcpuid, KVM_GET_ONE_REG, &reg);
  

• fprintf(stream, "%*slpcr: %#lx\n", indent + 4, "", lpcr);
  

• }
• fprintf(stream, "%*slr: %#llx\n", indent + 4, "", regs.lr);

+}

+void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid) +{

• struct kvm_run *run;
• run = vcpu_state(vm, vcpuid);
• if (run) {

• switch (run->exit_reason) {
  

• case KVM_EXIT_PAPR_HCALL:
  

• case KVM_EXIT_MMIO:
  

• 	return;
  

• default:
  

• 	printf("reason: %s\n",
  

• 	       exit_reason_str(run->exit_reason));
  

• 	break;
  

• }
  

• }

+#ifdef DEBUG

• vm_dump(stderr, vm, 2);

+#endif

• TEST_ASSERT(false, "Unhandled exception");

+} diff --git a/tools/testing/selftests/kvm/lib/powerpc/ucall.c b/tools/testing/selftests/kvm/lib/powerpc/ucall.c new file mode 100644 index 000000000000..fc76ef796f02 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/powerpc/ucall.c @@ -0,0 +1,67 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "kvm_util.h" +#include "processor.h"

+/*

• • Using this hypercall for now because it is already defined. It is
• • used by SLOF to ask QEMU to copy memory regions, so it is close
• • enough for our purposes.
• */

+#define KVMPPC_H_LOGICAL_MEMOP 0xf001

+void ucall_init(struct kvm_vm *vm, void *arg) +{ +}

+void ucall_uninit(struct kvm_vm *vm) +{ +}

+static inline int __ucall(uint64_t args) +{

• return hcall(KVMPPC_H_LOGICAL_MEMOP, args);

+}

+/*

• • This function runs inside the guest, so avoid optimizations that
• • could add an indirect call via PLT and disable vector instructions
• • like the kernel does.
• */

+__attribute__((optimize(0), target("no-altivec,no-vsx"))) +void ucall(uint64_t cmd, int nargs, ...) +{

• struct ucall uc = {

• .cmd = cmd,
  

• };
• va_list va;
• int i;
• nargs = nargs <= UCALL_MAX_ARGS ? nargs : UCALL_MAX_ARGS;
• va_start(va, nargs);
• for (i = 0; i < nargs; ++i)

• uc.args[i] = va_arg(va, uint64_t);
  

• va_end(va);
• __ucall((uint64_t)&uc);

+}

+uint64_t get_ucall(struct kvm_vm *vm, uint32_t vcpu_id, struct ucall *uc) +{

• struct kvm_run *run = vcpu_state(vm, vcpu_id);
• struct ucall ucall = {};
• if (uc)

• memset(uc, 0, sizeof(*uc));
  

• if (run->exit_reason == KVM_EXIT_PAPR_HCALL &&

•    run->papr_hcall.nr == KVMPPC_H_LOGICAL_MEMOP) {
  

• memcpy(&ucall, addr_gva2hva(vm, run->papr_hcall.args[0]),
  

• 			    sizeof(ucall));
  

• if (uc)
  

• 	memcpy(uc, &ucall, sizeof(ucall));
  

• }
• return ucall.cmd;

+} diff --git a/tools/testing/selftests/kvm/powerpc/sample_test.c b/tools/testing/selftests/kvm/powerpc/sample_test.c new file mode 100644 index 000000000000..16f0df920d98 --- /dev/null +++ b/tools/testing/selftests/kvm/powerpc/sample_test.c @@ -0,0 +1,144 @@ +// SPDX-License-Identifier: GPL-2.0-only +#define _GNU_SOURCE /* for program_invocation_short_name */ +#include <pthread.h> +#include <stdio.h> +#include <signal.h>

+#define DEBUG +#include "kvm_util.h" +#include "test_util.h" +#include "processor.h"

+#define H_PUT_TERM_CHAR 0x58 +#define TEST_VAL 0x8badf00d +#define PASS_VAL 0xdeadbeef +#define FAIL_VAL 0x2badd00d

+struct kvm_vm *vm;

+/*

• • Call the hypervisor to write a character to the console. KVM does
• • not handle this hypercall so it goes out to userspace. Which in
• • this case is the vcpu_worker() below.
• */

+static inline void put_char(char c) +{

• hcall(H_PUT_TERM_CHAR, 0, 1, cpu_to_be64(c));

+}

+static void guest_code(uint64_t *ptr, uint64_t val) +{

• /*

• * Test making a hypercall and give a visual indication that
  

• * the guest code is running.
  

• */
  

• put_char('.');
• /* Make sure we can receive values */
• GUEST_ASSERT(ptr);
• GUEST_ASSERT(val == TEST_VAL);
• put_char('.');
• /* Read/write to memory */
• if (*ptr == val)

• *ptr = PASS_VAL;
  

• else

• *ptr = FAIL_VAL;
  

• put_char('.');
• /* Signal we're done */
• GUEST_DONE();

+}

+static bool guest_done(struct kvm_vm *vm) +{

• struct ucall uc;
• bool done;
• switch (get_ucall(vm, 0, &uc)) {
• case UCALL_ABORT:

• TEST_FAIL("%s at %s:%ld", (const char *)uc.args[0],
  

• 	  __FILE__, uc.args[1]);
  

• /* not reached */
  

• case UCALL_DONE:

• done = true;
  

• break;
  

• default:

• done = false;
  

• break;
  

• }
• return done;

+}

+static void *vcpu_worker(void *data) +{

• struct kvm_vm *vm = data;
• struct kvm_run *run;
• uint64_t *hva;
• static uint64_t test_buf = TEST_VAL;
• /* Pass arguments to the guest code */
• vcpu_args_set(vm, 0, 2, &test_buf, TEST_VAL);
• run = vcpu_state(vm, 0);
• while (1) {

• vcpu_run(vm, 0);
  

• if (guest_done(vm))
  

• 	break;
  

• switch (run->exit_reason) {
  

• case KVM_EXIT_PAPR_HCALL:
  

• 	if (run->papr_hcall.nr == H_PUT_TERM_CHAR) {
  

• 		char c = be64_to_cpu(run->papr_hcall.args[2]);
  

• 		pr_debug("%c", c);
  

• 	}
  

• 	break;
  

• default:
  

• 	printf("exit reason: %s\n", exit_reason_str(run->exit_reason));
  

• 	break;
  

• }
  

• }
• hva = addr_gva2hva(vm, (vm_vaddr_t)&test_buf);
• TEST_ASSERT(*hva != FAIL_VAL,

•     "Guest failed to read test value at gva %p", &test_buf);
  

• TEST_ASSERT(*hva == PASS_VAL,

•     "Guest failed to write test value to gva %p", &test_buf);
  

• pr_debug("PASS\n");
• return NULL;

+}

+void dump_vm(int sig) +{

• vm_dump(stderr, vm, 2);
• exit(1);

+}

+int main(int argc, char *argv[]) +{

• pthread_t vcpu_thread;
• signal(SIGINT, dump_vm);
• /*

• * Do not buffer stdout so we can implement put_char without
  

• * flushing.
  

• */
  

• setbuf(stdout, NULL);
• vm = vm_create_default(0, 0, guest_code);
• pthread_create(&vcpu_thread, NULL, vcpu_worker, vm);
• pthread_join(vcpu_thread, NULL);
• kvm_vm_free(vm);
• return 0;

+}