mirror of
https://github.com/brain-hackers/linux-brain.git
synced 2024-06-09 23:36:23 +09:00
d96ef8fa95
commit ef3e40a7ea8dbe2abd0a345032cd7d5023b9684f upstream. When using the PtrAuth feature in a guest, we need to save the host's keys before allowing the guest to program them. For that, we dump them in a per-CPU data structure (the so called host context). But both call sites that do this are in preemptible context, which may end up in disaster should the vcpu thread get preempted before reentering the guest. Instead, save the keys eagerly on each vcpu_load(). This has an increased overhead, but is at least safe. Cc: stable@vger.kernel.org Reviewed-by: Mark Rutland <mark.rutland@arm.com> Signed-off-by: Marc Zyngier <maz@kernel.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
323 lines
8.4 KiB
C
323 lines
8.4 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (C) 2012,2013 - ARM Ltd
|
|
* Author: Marc Zyngier <marc.zyngier@arm.com>
|
|
*
|
|
* Derived from arch/arm/kvm/handle_exit.c:
|
|
* Copyright (C) 2012 - Virtual Open Systems and Columbia University
|
|
* Author: Christoffer Dall <c.dall@virtualopensystems.com>
|
|
*/
|
|
|
|
#include <linux/kvm.h>
|
|
#include <linux/kvm_host.h>
|
|
|
|
#include <kvm/arm_psci.h>
|
|
|
|
#include <asm/esr.h>
|
|
#include <asm/exception.h>
|
|
#include <asm/kvm_asm.h>
|
|
#include <asm/kvm_coproc.h>
|
|
#include <asm/kvm_emulate.h>
|
|
#include <asm/kvm_mmu.h>
|
|
#include <asm/debug-monitors.h>
|
|
#include <asm/traps.h>
|
|
|
|
#define CREATE_TRACE_POINTS
|
|
#include "trace.h"
|
|
|
|
typedef int (*exit_handle_fn)(struct kvm_vcpu *, struct kvm_run *);
|
|
|
|
static void kvm_handle_guest_serror(struct kvm_vcpu *vcpu, u32 esr)
|
|
{
|
|
if (!arm64_is_ras_serror(esr) || arm64_is_fatal_ras_serror(NULL, esr))
|
|
kvm_inject_vabt(vcpu);
|
|
}
|
|
|
|
static int handle_hvc(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
int ret;
|
|
|
|
trace_kvm_hvc_arm64(*vcpu_pc(vcpu), vcpu_get_reg(vcpu, 0),
|
|
kvm_vcpu_hvc_get_imm(vcpu));
|
|
vcpu->stat.hvc_exit_stat++;
|
|
|
|
ret = kvm_hvc_call_handler(vcpu);
|
|
if (ret < 0) {
|
|
vcpu_set_reg(vcpu, 0, ~0UL);
|
|
return 1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int handle_smc(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
/*
|
|
* "If an SMC instruction executed at Non-secure EL1 is
|
|
* trapped to EL2 because HCR_EL2.TSC is 1, the exception is a
|
|
* Trap exception, not a Secure Monitor Call exception [...]"
|
|
*
|
|
* We need to advance the PC after the trap, as it would
|
|
* otherwise return to the same address...
|
|
*/
|
|
vcpu_set_reg(vcpu, 0, ~0UL);
|
|
kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu));
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Guest access to FP/ASIMD registers are routed to this handler only
|
|
* when the system doesn't support FP/ASIMD.
|
|
*/
|
|
static int handle_no_fpsimd(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
kvm_inject_undefined(vcpu);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* kvm_handle_wfx - handle a wait-for-interrupts or wait-for-event
|
|
* instruction executed by a guest
|
|
*
|
|
* @vcpu: the vcpu pointer
|
|
*
|
|
* WFE: Yield the CPU and come back to this vcpu when the scheduler
|
|
* decides to.
|
|
* WFI: Simply call kvm_vcpu_block(), which will halt execution of
|
|
* world-switches and schedule other host processes until there is an
|
|
* incoming IRQ or FIQ to the VM.
|
|
*/
|
|
static int kvm_handle_wfx(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
if (kvm_vcpu_get_hsr(vcpu) & ESR_ELx_WFx_ISS_WFE) {
|
|
trace_kvm_wfx_arm64(*vcpu_pc(vcpu), true);
|
|
vcpu->stat.wfe_exit_stat++;
|
|
kvm_vcpu_on_spin(vcpu, vcpu_mode_priv(vcpu));
|
|
} else {
|
|
trace_kvm_wfx_arm64(*vcpu_pc(vcpu), false);
|
|
vcpu->stat.wfi_exit_stat++;
|
|
kvm_vcpu_block(vcpu);
|
|
kvm_clear_request(KVM_REQ_UNHALT, vcpu);
|
|
}
|
|
|
|
kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu));
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* kvm_handle_guest_debug - handle a debug exception instruction
|
|
*
|
|
* @vcpu: the vcpu pointer
|
|
* @run: access to the kvm_run structure for results
|
|
*
|
|
* We route all debug exceptions through the same handler. If both the
|
|
* guest and host are using the same debug facilities it will be up to
|
|
* userspace to re-inject the correct exception for guest delivery.
|
|
*
|
|
* @return: 0 (while setting run->exit_reason), -1 for error
|
|
*/
|
|
static int kvm_handle_guest_debug(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
u32 hsr = kvm_vcpu_get_hsr(vcpu);
|
|
int ret = 0;
|
|
|
|
run->exit_reason = KVM_EXIT_DEBUG;
|
|
run->debug.arch.hsr = hsr;
|
|
|
|
switch (ESR_ELx_EC(hsr)) {
|
|
case ESR_ELx_EC_WATCHPT_LOW:
|
|
run->debug.arch.far = vcpu->arch.fault.far_el2;
|
|
/* fall through */
|
|
case ESR_ELx_EC_SOFTSTP_LOW:
|
|
case ESR_ELx_EC_BREAKPT_LOW:
|
|
case ESR_ELx_EC_BKPT32:
|
|
case ESR_ELx_EC_BRK64:
|
|
break;
|
|
default:
|
|
kvm_err("%s: un-handled case hsr: %#08x\n",
|
|
__func__, (unsigned int) hsr);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int kvm_handle_unknown_ec(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
u32 hsr = kvm_vcpu_get_hsr(vcpu);
|
|
|
|
kvm_pr_unimpl("Unknown exception class: hsr: %#08x -- %s\n",
|
|
hsr, esr_get_class_string(hsr));
|
|
|
|
kvm_inject_undefined(vcpu);
|
|
return 1;
|
|
}
|
|
|
|
static int handle_sve(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
/* Until SVE is supported for guests: */
|
|
kvm_inject_undefined(vcpu);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Handle the guest trying to use a ptrauth instruction, or trying to access a
|
|
* ptrauth register.
|
|
*/
|
|
void kvm_arm_vcpu_ptrauth_trap(struct kvm_vcpu *vcpu)
|
|
{
|
|
if (vcpu_has_ptrauth(vcpu))
|
|
vcpu_ptrauth_enable(vcpu);
|
|
else
|
|
kvm_inject_undefined(vcpu);
|
|
}
|
|
|
|
/*
|
|
* Guest usage of a ptrauth instruction (which the guest EL1 did not turn into
|
|
* a NOP).
|
|
*/
|
|
static int kvm_handle_ptrauth(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
kvm_arm_vcpu_ptrauth_trap(vcpu);
|
|
return 1;
|
|
}
|
|
|
|
static exit_handle_fn arm_exit_handlers[] = {
|
|
[0 ... ESR_ELx_EC_MAX] = kvm_handle_unknown_ec,
|
|
[ESR_ELx_EC_WFx] = kvm_handle_wfx,
|
|
[ESR_ELx_EC_CP15_32] = kvm_handle_cp15_32,
|
|
[ESR_ELx_EC_CP15_64] = kvm_handle_cp15_64,
|
|
[ESR_ELx_EC_CP14_MR] = kvm_handle_cp14_32,
|
|
[ESR_ELx_EC_CP14_LS] = kvm_handle_cp14_load_store,
|
|
[ESR_ELx_EC_CP14_64] = kvm_handle_cp14_64,
|
|
[ESR_ELx_EC_HVC32] = handle_hvc,
|
|
[ESR_ELx_EC_SMC32] = handle_smc,
|
|
[ESR_ELx_EC_HVC64] = handle_hvc,
|
|
[ESR_ELx_EC_SMC64] = handle_smc,
|
|
[ESR_ELx_EC_SYS64] = kvm_handle_sys_reg,
|
|
[ESR_ELx_EC_SVE] = handle_sve,
|
|
[ESR_ELx_EC_IABT_LOW] = kvm_handle_guest_abort,
|
|
[ESR_ELx_EC_DABT_LOW] = kvm_handle_guest_abort,
|
|
[ESR_ELx_EC_SOFTSTP_LOW]= kvm_handle_guest_debug,
|
|
[ESR_ELx_EC_WATCHPT_LOW]= kvm_handle_guest_debug,
|
|
[ESR_ELx_EC_BREAKPT_LOW]= kvm_handle_guest_debug,
|
|
[ESR_ELx_EC_BKPT32] = kvm_handle_guest_debug,
|
|
[ESR_ELx_EC_BRK64] = kvm_handle_guest_debug,
|
|
[ESR_ELx_EC_FP_ASIMD] = handle_no_fpsimd,
|
|
[ESR_ELx_EC_PAC] = kvm_handle_ptrauth,
|
|
};
|
|
|
|
static exit_handle_fn kvm_get_exit_handler(struct kvm_vcpu *vcpu)
|
|
{
|
|
u32 hsr = kvm_vcpu_get_hsr(vcpu);
|
|
u8 hsr_ec = ESR_ELx_EC(hsr);
|
|
|
|
return arm_exit_handlers[hsr_ec];
|
|
}
|
|
|
|
/*
|
|
* We may be single-stepping an emulated instruction. If the emulation
|
|
* has been completed in the kernel, we can return to userspace with a
|
|
* KVM_EXIT_DEBUG, otherwise userspace needs to complete its
|
|
* emulation first.
|
|
*/
|
|
static int handle_trap_exceptions(struct kvm_vcpu *vcpu, struct kvm_run *run)
|
|
{
|
|
int handled;
|
|
|
|
/*
|
|
* See ARM ARM B1.14.1: "Hyp traps on instructions
|
|
* that fail their condition code check"
|
|
*/
|
|
if (!kvm_condition_valid(vcpu)) {
|
|
kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu));
|
|
handled = 1;
|
|
} else {
|
|
exit_handle_fn exit_handler;
|
|
|
|
exit_handler = kvm_get_exit_handler(vcpu);
|
|
handled = exit_handler(vcpu, run);
|
|
}
|
|
|
|
return handled;
|
|
}
|
|
|
|
/*
|
|
* Return > 0 to return to guest, < 0 on error, 0 (and set exit_reason) on
|
|
* proper exit to userspace.
|
|
*/
|
|
int handle_exit(struct kvm_vcpu *vcpu, struct kvm_run *run,
|
|
int exception_index)
|
|
{
|
|
if (ARM_SERROR_PENDING(exception_index)) {
|
|
u8 hsr_ec = ESR_ELx_EC(kvm_vcpu_get_hsr(vcpu));
|
|
|
|
/*
|
|
* HVC/SMC already have an adjusted PC, which we need
|
|
* to correct in order to return to after having
|
|
* injected the SError.
|
|
*/
|
|
if (hsr_ec == ESR_ELx_EC_HVC32 || hsr_ec == ESR_ELx_EC_HVC64 ||
|
|
hsr_ec == ESR_ELx_EC_SMC32 || hsr_ec == ESR_ELx_EC_SMC64) {
|
|
u32 adj = kvm_vcpu_trap_il_is32bit(vcpu) ? 4 : 2;
|
|
*vcpu_pc(vcpu) -= adj;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
exception_index = ARM_EXCEPTION_CODE(exception_index);
|
|
|
|
switch (exception_index) {
|
|
case ARM_EXCEPTION_IRQ:
|
|
return 1;
|
|
case ARM_EXCEPTION_EL1_SERROR:
|
|
return 1;
|
|
case ARM_EXCEPTION_TRAP:
|
|
return handle_trap_exceptions(vcpu, run);
|
|
case ARM_EXCEPTION_HYP_GONE:
|
|
/*
|
|
* EL2 has been reset to the hyp-stub. This happens when a guest
|
|
* is pre-empted by kvm_reboot()'s shutdown call.
|
|
*/
|
|
run->exit_reason = KVM_EXIT_FAIL_ENTRY;
|
|
return 0;
|
|
case ARM_EXCEPTION_IL:
|
|
/*
|
|
* We attempted an illegal exception return. Guest state must
|
|
* have been corrupted somehow. Give up.
|
|
*/
|
|
run->exit_reason = KVM_EXIT_FAIL_ENTRY;
|
|
return -EINVAL;
|
|
default:
|
|
kvm_pr_unimpl("Unsupported exception type: %d",
|
|
exception_index);
|
|
run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* For exit types that need handling before we can be preempted */
|
|
void handle_exit_early(struct kvm_vcpu *vcpu, struct kvm_run *run,
|
|
int exception_index)
|
|
{
|
|
if (ARM_SERROR_PENDING(exception_index)) {
|
|
if (this_cpu_has_cap(ARM64_HAS_RAS_EXTN)) {
|
|
u64 disr = kvm_vcpu_get_disr(vcpu);
|
|
|
|
kvm_handle_guest_serror(vcpu, disr_to_esr(disr));
|
|
} else {
|
|
kvm_inject_vabt(vcpu);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
exception_index = ARM_EXCEPTION_CODE(exception_index);
|
|
|
|
if (exception_index == ARM_EXCEPTION_EL1_SERROR)
|
|
kvm_handle_guest_serror(vcpu, kvm_vcpu_get_hsr(vcpu));
|
|
}
|