Quelle  fault.h   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2015 - ARM Ltd
 * Author: Marc Zyngier <marc.zyngier@arm.com>
 */

#ifndef __ARM64_KVM_HYP_FAULT_H__
#define __ARM64_KVM_HYP_FAULT_H__

#include <asm/kvm_asm.h>
#include <asm/kvm_emulate.h>
#include <asm/kvm_hyp.h>
#include <asm/kvm_mmu.h>

static inline bool __fault_safe_to_translate(u64 esr)
{
 u64 fsc = esr & ESR_ELx_FSC;

 if (esr_fsc_is_sea_ttw(esr) || esr_fsc_is_secc_ttw(esr))
  return false;

 return !(fsc == ESR_ELx_FSC_EXTABT && (esr & ESR_ELx_FnV));
}

static inline bool __translate_far_to_hpfar(u64 far, u64 *hpfar)
{
 int ret;
 u64 par, tmp;

 /*
  * Resolve the IPA the hard way using the guest VA.
  *
  * Stage-1 translation already validated the memory access
  * rights. As such, we can use the EL1 translation regime, and
  * don't have to distinguish between EL0 and EL1 access.
  *
  * We do need to save/restore PAR_EL1 though, as we haven't
  * saved the guest context yet, and we may return early...
 */
 par = read_sysreg_par();
 ret = system_supports_poe() ? __kvm_at(OP_AT_S1E1A, far) :
                               __kvm_at(OP_AT_S1E1R, far);
 if (!ret)
  tmp = read_sysreg_par();
 else
  tmp = SYS_PAR_EL1_F; /* back to the guest */
 write_sysreg(par, par_el1);

 if (unlikely(tmp & SYS_PAR_EL1_F))
  return false; /* Translation failed, back to guest */

 /* Convert PAR to HPFAR format */
 *hpfar = PAR_TO_HPFAR(tmp);
 return true;
}

/*
 * Checks for the conditions when HPFAR_EL2 is written, per ARM ARM R_FKLWR.
 */
static inline bool __hpfar_valid(u64 esr)
{
 /*
  * CPUs affected by ARM erratum #834220 may incorrectly report a
  * stage-2 translation fault when a stage-1 permission fault occurs.
  *
  * Re-walk the page tables to determine if a stage-1 fault actually
  * occurred.
 */
 if (cpus_have_final_cap(ARM64_WORKAROUND_834220) &&
     esr_fsc_is_translation_fault(esr))
  return false;

 if (esr_fsc_is_translation_fault(esr) || esr_fsc_is_access_flag_fault(esr))
  return true;

 if ((esr & ESR_ELx_S1PTW) && esr_fsc_is_permission_fault(esr))
  return true;

 return esr_fsc_is_addr_sz_fault(esr);
}

static inline bool __get_fault_info(u64 esr, struct kvm_vcpu_fault_info *fault)
{
 u64 hpfar;

 fault->far_el2  = read_sysreg_el2(SYS_FAR);
 fault->hpfar_el2 = 0;

 if (__hpfar_valid(esr))
  hpfar = read_sysreg(hpfar_el2);
 else if (unlikely(!__fault_safe_to_translate(esr)))
  return true;
 else if (!__translate_far_to_hpfar(fault->far_el2, &hpfar))
  return false;

 /*
  * Hijack HPFAR_EL2.NS (RES0 in Non-secure) to indicate a valid
  * HPFAR value.
 */
 fault->hpfar_el2 = hpfar | HPFAR_EL2_NS;
 return true;
}

#endif