With PPIs, their state is injected via the ICH_PPI_x_EL2 system registers. For SPIs and LPIs, there are no such registers as these would limit the number of interrupts significantly. Instead, SPI and LPI pending state can be managed from the hypervisor using the GIC VDPEND instruction. This provides a way to set an SPI or LPI for a VM as pending or non-pending, i.e., to inject interrupts into a guest. At times, it is important to detect when there is an interrupt that has been "consumed" by the guest (deactivated). For PPIs, it was possible to do this via the ICH_PPI_x_EL2 registers, but for SPIs and LPIs this needs to be done using the GIC VDRCFG instruction. This, in combination with a read of the ICC_ICSR_EL1, allows the hypervisor to query the state of any valid SPIs/LPIs for a guest. These system instructions are only executable from EL2, and therefore they must be wrapped in hypercalls for NVHE/hVHE configurations. In the case of the GIC VDRCFG, this hypercall also does the read of the ICSR to ensure that it snapshots the correct state. Not doing this could result in reading incorrect state from the ICSR as there is no guarantee that someone else didn't sneak in meanwhile. Signed-off-by: Sascha Bischoff --- arch/arm64/include/asm/kvm_asm.h | 2 ++ arch/arm64/include/asm/kvm_hyp.h | 2 ++ arch/arm64/kvm/hyp/nvhe/hyp-main.c | 18 ++++++++++++++++++ arch/arm64/kvm/hyp/vgic-v5-sr.c | 20 ++++++++++++++++++++ 4 files changed, 42 insertions(+) diff --git a/arch/arm64/include/asm/kvm_asm.h b/arch/arm64/include/asm/kvm_asm.h index 8c69f1f4de534..453fc063eb61b 100644 --- a/arch/arm64/include/asm/kvm_asm.h +++ b/arch/arm64/include/asm/kvm_asm.h @@ -81,6 +81,8 @@ enum __kvm_host_smccc_func { __KVM_HOST_SMCCC_FUNC___vgic_v3_restore_vmcr_aprs, __KVM_HOST_SMCCC_FUNC___vgic_v5_make_resident, __KVM_HOST_SMCCC_FUNC___vgic_v5_make_non_resident, + __KVM_HOST_SMCCC_FUNC___vgic_v5_vdpend, + __KVM_HOST_SMCCC_FUNC___vgic_v5_vdrcfg, __KVM_HOST_SMCCC_FUNC___vgic_v5_save_apr, __KVM_HOST_SMCCC_FUNC___vgic_v5_restore_vmcr_apr, diff --git a/arch/arm64/include/asm/kvm_hyp.h b/arch/arm64/include/asm/kvm_hyp.h index 5f9184276b04e..20aeb29a4adf1 100644 --- a/arch/arm64/include/asm/kvm_hyp.h +++ b/arch/arm64/include/asm/kvm_hyp.h @@ -97,6 +97,8 @@ void __vgic_v5_save_ppi_state(struct vgic_v5_cpu_if *cpu_if); void __vgic_v5_restore_ppi_state(struct vgic_v5_cpu_if *cpu_if); void __vgic_v5_save_state(struct vgic_v5_cpu_if *cpu_if); void __vgic_v5_restore_state(struct vgic_v5_cpu_if *cpu_if); +void __vgic_v5_vdpend(u32 intid, bool pending, u16 vm); +u64 __vgic_v5_vdrcfg(u32 intid); #ifdef __KVM_NVHE_HYPERVISOR__ void __timer_enable_traps(struct kvm_vcpu *vcpu); diff --git a/arch/arm64/kvm/hyp/nvhe/hyp-main.c b/arch/arm64/kvm/hyp/nvhe/hyp-main.c index 804a9ffdc8594..5c4dc2e71fcbe 100644 --- a/arch/arm64/kvm/hyp/nvhe/hyp-main.c +++ b/arch/arm64/kvm/hyp/nvhe/hyp-main.c @@ -699,6 +699,22 @@ static void handle___vgic_v5_restore_vmcr_apr(struct kvm_cpu_context *host_ctxt) __vgic_v5_restore_vmcr_apr(kern_hyp_va(cpu_if)); } +static void handle___vgic_v5_vdpend(struct kvm_cpu_context *host_ctxt) +{ + DECLARE_REG(u32, intid, host_ctxt, 1); + DECLARE_REG(bool, pending, host_ctxt, 2); + DECLARE_REG(u16, vm, host_ctxt, 3); + + __vgic_v5_vdpend(intid, pending, vm); +} + +static void handle___vgic_v5_vdrcfg(struct kvm_cpu_context *host_ctxt) +{ + DECLARE_REG(u32, intid, host_ctxt, 1); + + cpu_reg(host_ctxt, 1) = __vgic_v5_vdrcfg(intid); +} + typedef void (*hcall_t)(struct kvm_cpu_context *); #define HANDLE_FUNC(x) [__KVM_HOST_SMCCC_FUNC_##x] = (hcall_t)handle_##x @@ -726,6 +742,8 @@ static const hcall_t host_hcall[] = { HANDLE_FUNC(__vgic_v3_restore_vmcr_aprs), HANDLE_FUNC(__vgic_v5_make_resident), HANDLE_FUNC(__vgic_v5_make_non_resident), + HANDLE_FUNC(__vgic_v5_vdpend), + HANDLE_FUNC(__vgic_v5_vdrcfg), HANDLE_FUNC(__vgic_v5_save_apr), HANDLE_FUNC(__vgic_v5_restore_vmcr_apr), diff --git a/arch/arm64/kvm/hyp/vgic-v5-sr.c b/arch/arm64/kvm/hyp/vgic-v5-sr.c index d27fe2911df3f..05090f5a0d9b6 100644 --- a/arch/arm64/kvm/hyp/vgic-v5-sr.c +++ b/arch/arm64/kvm/hyp/vgic-v5-sr.c @@ -148,3 +148,23 @@ void __vgic_v5_restore_state(struct vgic_v5_cpu_if *cpu_if) { write_sysreg_s(cpu_if->vgic_icsr, SYS_ICC_ICSR_EL1); } + +void __vgic_v5_vdpend(u32 intid, bool pending, u16 vm) +{ + u64 value; + + value = intid & (GICV5_GIC_VDPEND_ID_MASK | GICV5_GIC_VDPEND_TYPE_MASK); + value |= FIELD_PREP(GICV5_GIC_VDPEND_PENDING_MASK, pending); + value |= FIELD_PREP(GICV5_GIC_VDPEND_VM_MASK, vm); + gic_insn(value, VDPEND); +} + +u64 __vgic_v5_vdrcfg(u32 intid) +{ + u64 value; + + value = intid & (GICV5_GIC_VDRCFG_ID_MASK | GICV5_GIC_VDRCFG_TYPE_MASK); + gic_insn(value, VDRCFG); + isb(); + return read_sysreg_s(SYS_ICC_ICSR_EL1); +} -- 2.34.1