1*4882a593Smuzhiyun // SPDX-License-Identifier: GPL-2.0
2*4882a593Smuzhiyun /*
3*4882a593Smuzhiyun * ucall support. A ucall is a "hypercall to userspace".
4*4882a593Smuzhiyun *
5*4882a593Smuzhiyun * Copyright (C) 2018, Red Hat, Inc.
6*4882a593Smuzhiyun */
7*4882a593Smuzhiyun #include "kvm_util.h"
8*4882a593Smuzhiyun #include "../kvm_util_internal.h"
9*4882a593Smuzhiyun
10*4882a593Smuzhiyun static vm_vaddr_t *ucall_exit_mmio_addr;
11*4882a593Smuzhiyun
ucall_mmio_init(struct kvm_vm * vm,vm_paddr_t gpa)12*4882a593Smuzhiyun static bool ucall_mmio_init(struct kvm_vm *vm, vm_paddr_t gpa)
13*4882a593Smuzhiyun {
14*4882a593Smuzhiyun if (kvm_userspace_memory_region_find(vm, gpa, gpa + 1))
15*4882a593Smuzhiyun return false;
16*4882a593Smuzhiyun
17*4882a593Smuzhiyun virt_pg_map(vm, gpa, gpa, 0);
18*4882a593Smuzhiyun
19*4882a593Smuzhiyun ucall_exit_mmio_addr = (vm_vaddr_t *)gpa;
20*4882a593Smuzhiyun sync_global_to_guest(vm, ucall_exit_mmio_addr);
21*4882a593Smuzhiyun
22*4882a593Smuzhiyun return true;
23*4882a593Smuzhiyun }
24*4882a593Smuzhiyun
ucall_init(struct kvm_vm * vm,void * arg)25*4882a593Smuzhiyun void ucall_init(struct kvm_vm *vm, void *arg)
26*4882a593Smuzhiyun {
27*4882a593Smuzhiyun vm_paddr_t gpa, start, end, step, offset;
28*4882a593Smuzhiyun unsigned int bits;
29*4882a593Smuzhiyun bool ret;
30*4882a593Smuzhiyun
31*4882a593Smuzhiyun if (arg) {
32*4882a593Smuzhiyun gpa = (vm_paddr_t)arg;
33*4882a593Smuzhiyun ret = ucall_mmio_init(vm, gpa);
34*4882a593Smuzhiyun TEST_ASSERT(ret, "Can't set ucall mmio address to %lx", gpa);
35*4882a593Smuzhiyun return;
36*4882a593Smuzhiyun }
37*4882a593Smuzhiyun
38*4882a593Smuzhiyun /*
39*4882a593Smuzhiyun * Find an address within the allowed physical and virtual address
40*4882a593Smuzhiyun * spaces, that does _not_ have a KVM memory region associated with
41*4882a593Smuzhiyun * it. Identity mapping an address like this allows the guest to
42*4882a593Smuzhiyun * access it, but as KVM doesn't know what to do with it, it
43*4882a593Smuzhiyun * will assume it's something userspace handles and exit with
44*4882a593Smuzhiyun * KVM_EXIT_MMIO. Well, at least that's how it works for AArch64.
45*4882a593Smuzhiyun * Here we start with a guess that the addresses around 5/8th
46*4882a593Smuzhiyun * of the allowed space are unmapped and then work both down and
47*4882a593Smuzhiyun * up from there in 1/16th allowed space sized steps.
48*4882a593Smuzhiyun *
49*4882a593Smuzhiyun * Note, we need to use VA-bits - 1 when calculating the allowed
50*4882a593Smuzhiyun * virtual address space for an identity mapping because the upper
51*4882a593Smuzhiyun * half of the virtual address space is the two's complement of the
52*4882a593Smuzhiyun * lower and won't match physical addresses.
53*4882a593Smuzhiyun */
54*4882a593Smuzhiyun bits = vm->va_bits - 1;
55*4882a593Smuzhiyun bits = vm->pa_bits < bits ? vm->pa_bits : bits;
56*4882a593Smuzhiyun end = 1ul << bits;
57*4882a593Smuzhiyun start = end * 5 / 8;
58*4882a593Smuzhiyun step = end / 16;
59*4882a593Smuzhiyun for (offset = 0; offset < end - start; offset += step) {
60*4882a593Smuzhiyun if (ucall_mmio_init(vm, start - offset))
61*4882a593Smuzhiyun return;
62*4882a593Smuzhiyun if (ucall_mmio_init(vm, start + offset))
63*4882a593Smuzhiyun return;
64*4882a593Smuzhiyun }
65*4882a593Smuzhiyun TEST_FAIL("Can't find a ucall mmio address");
66*4882a593Smuzhiyun }
67*4882a593Smuzhiyun
ucall_uninit(struct kvm_vm * vm)68*4882a593Smuzhiyun void ucall_uninit(struct kvm_vm *vm)
69*4882a593Smuzhiyun {
70*4882a593Smuzhiyun ucall_exit_mmio_addr = 0;
71*4882a593Smuzhiyun sync_global_to_guest(vm, ucall_exit_mmio_addr);
72*4882a593Smuzhiyun }
73*4882a593Smuzhiyun
ucall(uint64_t cmd,int nargs,...)74*4882a593Smuzhiyun void ucall(uint64_t cmd, int nargs, ...)
75*4882a593Smuzhiyun {
76*4882a593Smuzhiyun struct ucall uc = {};
77*4882a593Smuzhiyun va_list va;
78*4882a593Smuzhiyun int i;
79*4882a593Smuzhiyun
80*4882a593Smuzhiyun WRITE_ONCE(uc.cmd, cmd);
81*4882a593Smuzhiyun nargs = nargs <= UCALL_MAX_ARGS ? nargs : UCALL_MAX_ARGS;
82*4882a593Smuzhiyun
83*4882a593Smuzhiyun va_start(va, nargs);
84*4882a593Smuzhiyun for (i = 0; i < nargs; ++i)
85*4882a593Smuzhiyun WRITE_ONCE(uc.args[i], va_arg(va, uint64_t));
86*4882a593Smuzhiyun va_end(va);
87*4882a593Smuzhiyun
88*4882a593Smuzhiyun WRITE_ONCE(*ucall_exit_mmio_addr, (vm_vaddr_t)&uc);
89*4882a593Smuzhiyun }
90*4882a593Smuzhiyun
get_ucall(struct kvm_vm * vm,uint32_t vcpu_id,struct ucall * uc)91*4882a593Smuzhiyun uint64_t get_ucall(struct kvm_vm *vm, uint32_t vcpu_id, struct ucall *uc)
92*4882a593Smuzhiyun {
93*4882a593Smuzhiyun struct kvm_run *run = vcpu_state(vm, vcpu_id);
94*4882a593Smuzhiyun struct ucall ucall = {};
95*4882a593Smuzhiyun
96*4882a593Smuzhiyun if (uc)
97*4882a593Smuzhiyun memset(uc, 0, sizeof(*uc));
98*4882a593Smuzhiyun
99*4882a593Smuzhiyun if (run->exit_reason == KVM_EXIT_MMIO &&
100*4882a593Smuzhiyun run->mmio.phys_addr == (uint64_t)ucall_exit_mmio_addr) {
101*4882a593Smuzhiyun vm_vaddr_t gva;
102*4882a593Smuzhiyun
103*4882a593Smuzhiyun TEST_ASSERT(run->mmio.is_write && run->mmio.len == 8,
104*4882a593Smuzhiyun "Unexpected ucall exit mmio address access");
105*4882a593Smuzhiyun memcpy(&gva, run->mmio.data, sizeof(gva));
106*4882a593Smuzhiyun memcpy(&ucall, addr_gva2hva(vm, gva), sizeof(ucall));
107*4882a593Smuzhiyun
108*4882a593Smuzhiyun vcpu_run_complete_io(vm, vcpu_id);
109*4882a593Smuzhiyun if (uc)
110*4882a593Smuzhiyun memcpy(uc, &ucall, sizeof(ucall));
111*4882a593Smuzhiyun }
112*4882a593Smuzhiyun
113*4882a593Smuzhiyun return ucall.cmd;
114*4882a593Smuzhiyun }
115