mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
4.6 KiB
219 lines
4.6 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (C) 2012 - Virtual Open Systems and Columbia University |
|
* Author: Christoffer Dall <[email protected]> |
|
*/ |
|
|
|
#include <linux/kvm_host.h> |
|
#include <asm/kvm_mmio.h> |
|
#include <asm/kvm_emulate.h> |
|
#include <trace/events/kvm.h> |
|
|
|
#include "trace.h" |
|
|
|
void kvm_mmio_write_buf(void *buf, unsigned int len, unsigned long data) |
|
{ |
|
void *datap = NULL; |
|
union { |
|
u8 byte; |
|
u16 hword; |
|
u32 word; |
|
u64 dword; |
|
} tmp; |
|
|
|
switch (len) { |
|
case 1: |
|
tmp.byte = data; |
|
datap = &tmp.byte; |
|
break; |
|
case 2: |
|
tmp.hword = data; |
|
datap = &tmp.hword; |
|
break; |
|
case 4: |
|
tmp.word = data; |
|
datap = &tmp.word; |
|
break; |
|
case 8: |
|
tmp.dword = data; |
|
datap = &tmp.dword; |
|
break; |
|
} |
|
|
|
memcpy(buf, datap, len); |
|
} |
|
|
|
unsigned long kvm_mmio_read_buf(const void *buf, unsigned int len) |
|
{ |
|
unsigned long data = 0; |
|
union { |
|
u16 hword; |
|
u32 word; |
|
u64 dword; |
|
} tmp; |
|
|
|
switch (len) { |
|
case 1: |
|
data = *(u8 *)buf; |
|
break; |
|
case 2: |
|
memcpy(&tmp.hword, buf, len); |
|
data = tmp.hword; |
|
break; |
|
case 4: |
|
memcpy(&tmp.word, buf, len); |
|
data = tmp.word; |
|
break; |
|
case 8: |
|
memcpy(&tmp.dword, buf, len); |
|
data = tmp.dword; |
|
break; |
|
} |
|
|
|
return data; |
|
} |
|
|
|
/** |
|
* kvm_handle_mmio_return -- Handle MMIO loads after user space emulation |
|
* or in-kernel IO emulation |
|
* |
|
* @vcpu: The VCPU pointer |
|
* @run: The VCPU run struct containing the mmio data |
|
*/ |
|
int kvm_handle_mmio_return(struct kvm_vcpu *vcpu, struct kvm_run *run) |
|
{ |
|
unsigned long data; |
|
unsigned int len; |
|
int mask; |
|
|
|
/* Detect an already handled MMIO return */ |
|
if (unlikely(!vcpu->mmio_needed)) |
|
return 0; |
|
|
|
vcpu->mmio_needed = 0; |
|
|
|
if (!run->mmio.is_write) { |
|
len = run->mmio.len; |
|
if (len > sizeof(unsigned long)) |
|
return -EINVAL; |
|
|
|
data = kvm_mmio_read_buf(run->mmio.data, len); |
|
|
|
if (vcpu->arch.mmio_decode.sign_extend && |
|
len < sizeof(unsigned long)) { |
|
mask = 1U << ((len * 8) - 1); |
|
data = (data ^ mask) - mask; |
|
} |
|
|
|
if (!vcpu->arch.mmio_decode.sixty_four) |
|
data = data & 0xffffffff; |
|
|
|
trace_kvm_mmio(KVM_TRACE_MMIO_READ, len, run->mmio.phys_addr, |
|
&data); |
|
data = vcpu_data_host_to_guest(vcpu, data, len); |
|
vcpu_set_reg(vcpu, vcpu->arch.mmio_decode.rt, data); |
|
} |
|
|
|
/* |
|
* The MMIO instruction is emulated and should not be re-executed |
|
* in the guest. |
|
*/ |
|
kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu)); |
|
|
|
return 0; |
|
} |
|
|
|
static int decode_hsr(struct kvm_vcpu *vcpu, bool *is_write, int *len) |
|
{ |
|
unsigned long rt; |
|
int access_size; |
|
bool sign_extend; |
|
bool sixty_four; |
|
|
|
if (kvm_vcpu_dabt_iss1tw(vcpu)) { |
|
/* page table accesses IO mem: tell guest to fix its TTBR */ |
|
kvm_inject_dabt(vcpu, kvm_vcpu_get_hfar(vcpu)); |
|
return 1; |
|
} |
|
|
|
access_size = kvm_vcpu_dabt_get_as(vcpu); |
|
if (unlikely(access_size < 0)) |
|
return access_size; |
|
|
|
*is_write = kvm_vcpu_dabt_iswrite(vcpu); |
|
sign_extend = kvm_vcpu_dabt_issext(vcpu); |
|
sixty_four = kvm_vcpu_dabt_issf(vcpu); |
|
rt = kvm_vcpu_dabt_get_rd(vcpu); |
|
|
|
*len = access_size; |
|
vcpu->arch.mmio_decode.sign_extend = sign_extend; |
|
vcpu->arch.mmio_decode.rt = rt; |
|
vcpu->arch.mmio_decode.sixty_four = sixty_four; |
|
|
|
return 0; |
|
} |
|
|
|
int io_mem_abort(struct kvm_vcpu *vcpu, struct kvm_run *run, |
|
phys_addr_t fault_ipa) |
|
{ |
|
unsigned long data; |
|
unsigned long rt; |
|
int ret; |
|
bool is_write; |
|
int len; |
|
u8 data_buf[8]; |
|
|
|
/* |
|
* Prepare MMIO operation. First decode the syndrome data we get |
|
* from the CPU. Then try if some in-kernel emulation feels |
|
* responsible, otherwise let user space do its magic. |
|
*/ |
|
if (kvm_vcpu_dabt_isvalid(vcpu)) { |
|
ret = decode_hsr(vcpu, &is_write, &len); |
|
if (ret) |
|
return ret; |
|
} else { |
|
kvm_err("load/store instruction decoding not implemented\n"); |
|
return -ENOSYS; |
|
} |
|
|
|
rt = vcpu->arch.mmio_decode.rt; |
|
|
|
if (is_write) { |
|
data = vcpu_data_guest_to_host(vcpu, vcpu_get_reg(vcpu, rt), |
|
len); |
|
|
|
trace_kvm_mmio(KVM_TRACE_MMIO_WRITE, len, fault_ipa, &data); |
|
kvm_mmio_write_buf(data_buf, len, data); |
|
|
|
ret = kvm_io_bus_write(vcpu, KVM_MMIO_BUS, fault_ipa, len, |
|
data_buf); |
|
} else { |
|
trace_kvm_mmio(KVM_TRACE_MMIO_READ_UNSATISFIED, len, |
|
fault_ipa, NULL); |
|
|
|
ret = kvm_io_bus_read(vcpu, KVM_MMIO_BUS, fault_ipa, len, |
|
data_buf); |
|
} |
|
|
|
/* Now prepare kvm_run for the potential return to userland. */ |
|
run->mmio.is_write = is_write; |
|
run->mmio.phys_addr = fault_ipa; |
|
run->mmio.len = len; |
|
vcpu->mmio_needed = 1; |
|
|
|
if (!ret) { |
|
/* We handled the access successfully in the kernel. */ |
|
if (!is_write) |
|
memcpy(run->mmio.data, data_buf, len); |
|
vcpu->stat.mmio_exit_kernel++; |
|
kvm_handle_mmio_return(vcpu, run); |
|
return 1; |
|
} |
|
|
|
if (is_write) |
|
memcpy(run->mmio.data, data_buf, len); |
|
vcpu->stat.mmio_exit_user++; |
|
run->exit_reason = KVM_EXIT_MMIO; |
|
return 0; |
|
}
|
|
|