Commit 2d0e63e0 authored by Christoffer Dall's avatar Christoffer Dall Committed by Marc Zyngier
Browse files

KVM: arm/arm64: Avoid VGICv3 save/restore on VHE with no IRQs 



We can finally get completely rid of any calls to the VGICv3
save/restore functions when the AP lists are empty on VHE systems.  This
requires carefully factoring out trap configuration from saving and
restoring state, and carefully choosing what to do on the VHE and
non-VHE path.

One of the challenges is that we cannot save/restore the VMCR lazily
because we can only write the VMCR when ICC_SRE_EL1.SRE is cleared when
emulating a GICv2-on-GICv3, since otherwise all Group-0 interrupts end
up being delivered as FIQ.

To solve this problem, and still provide fast performance in the fast
path of exiting a VM when no interrupts are pending (which also
optimized the latency for actually delivering virtual interrupts coming
from physical interrupts), we orchestrate a dance of only doing the
activate/deactivate traps in vgic load/put for VHE systems (which can
have ICC_SRE_EL1.SRE cleared when running in the host), and doing the
configuration on every round-trip on non-VHE systems.

Signed-off-by: default avatarChristoffer Dall <christoffer.dall@linaro.org>
Signed-off-by: default avatarMarc Zyngier <marc.zyngier@arm.com>
parent 923a2e30

arch/arm/include/asm/kvm_hyp.h

+2 −0
Original line number Diff line number Diff line
@@ -110,6 +110,8 @@ void __sysreg_restore_state(struct kvm_cpu_context *ctxt); 


void __vgic_v3_save_state(struct kvm_vcpu *vcpu);

void __vgic_v3_restore_state(struct kvm_vcpu *vcpu);

void __vgic_v3_activate_traps(struct kvm_vcpu *vcpu);

void __vgic_v3_deactivate_traps(struct kvm_vcpu *vcpu);

void __vgic_v3_save_aprs(struct kvm_vcpu *vcpu);

void __vgic_v3_restore_aprs(struct kvm_vcpu *vcpu);

arch/arm/kvm/hyp/switch.c

+6 −2
Original line number Diff line number Diff line
@@ -90,15 +90,19 @@ static void __hyp_text __deactivate_vm(struct kvm_vcpu *vcpu) 


static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu)

{

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif))

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif)) {

		__vgic_v3_save_state(vcpu);

		__vgic_v3_deactivate_traps(vcpu);

	}

}



static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu)

{

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif))

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif)) {

		__vgic_v3_activate_traps(vcpu);

		__vgic_v3_restore_state(vcpu);

	}

}



static bool __hyp_text __populate_fault_info(struct kvm_vcpu *vcpu)

{

arch/arm64/include/asm/kvm_hyp.h

+2 −0
Original line number Diff line number Diff line
@@ -124,6 +124,8 @@ int __vgic_v2_perform_cpuif_access(struct kvm_vcpu *vcpu); 


void __vgic_v3_save_state(struct kvm_vcpu *vcpu);

void __vgic_v3_restore_state(struct kvm_vcpu *vcpu);

void __vgic_v3_activate_traps(struct kvm_vcpu *vcpu);

void __vgic_v3_deactivate_traps(struct kvm_vcpu *vcpu);

void __vgic_v3_save_aprs(struct kvm_vcpu *vcpu);

void __vgic_v3_restore_aprs(struct kvm_vcpu *vcpu);

int __vgic_v3_perform_cpuif_access(struct kvm_vcpu *vcpu);

arch/arm64/kvm/hyp/switch.c

+6 −2
Original line number Diff line number Diff line
@@ -195,16 +195,20 @@ static void __hyp_text __deactivate_vm(struct kvm_vcpu *vcpu) 
/* Save VGICv3 state on non-VHE systems */

static void __hyp_text __hyp_vgic_save_state(struct kvm_vcpu *vcpu)

{

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif))

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif)) {

		__vgic_v3_save_state(vcpu);

		__vgic_v3_deactivate_traps(vcpu);

	}

}



/* Restore VGICv3 state on non_VEH systems */

static void __hyp_text __hyp_vgic_restore_state(struct kvm_vcpu *vcpu)

{

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif))

	if (static_branch_unlikely(&kvm_vgic_global_state.gicv3_cpuif)) {

		__vgic_v3_activate_traps(vcpu);

		__vgic_v3_restore_state(vcpu);

	}

}



static bool __hyp_text __true_value(void)

{

virt/kvm/arm/hyp/vgic-v3-sr.c

+77 −43
Original line number Diff line number Diff line
@@ -209,15 +209,15 @@ void __hyp_text __vgic_v3_save_state(struct kvm_vcpu *vcpu) 
{

	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;

	u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs;

	u64 val;



	/*

	 * Make sure stores to the GIC via the memory mapped interface

	 * are now visible to the system register interface.

	 * are now visible to the system register interface when reading the

	 * LRs, and when reading back the VMCR on non-VHE systems.

	 */

	if (!cpu_if->vgic_sre) {

	if (used_lrs || !has_vhe()) {

		if (!cpu_if->vgic_sre)

			dsb(st);

		cpu_if->vgic_vmcr = read_gicreg(ICH_VMCR_EL2);

	}



	if (used_lrs) {
@@ -226,7 +226,7 @@ void __hyp_text __vgic_v3_save_state(struct kvm_vcpu *vcpu) 


		elrsr = read_gicreg(ICH_ELSR_EL2);



		write_gicreg(0, ICH_HCR_EL2);

		write_gicreg(cpu_if->vgic_hcr & ~ICH_HCR_EN, ICH_HCR_EL2);



		for (i = 0; i < used_lrs; i++) {

			if (elrsr & (1 << i))
@@ -236,27 +236,39 @@ void __hyp_text __vgic_v3_save_state(struct kvm_vcpu *vcpu) 


			__gic_v3_set_lr(0, i);

		}

	} else {

		if (static_branch_unlikely(&vgic_v3_cpuif_trap) ||

		    cpu_if->its_vpe.its_vm)

			write_gicreg(0, ICH_HCR_EL2);

	}

}



	val = read_gicreg(ICC_SRE_EL2);

	write_gicreg(val | ICC_SRE_EL2_ENABLE, ICC_SRE_EL2);

void __hyp_text __vgic_v3_restore_state(struct kvm_vcpu *vcpu)

{

	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;

	u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs;

	int i;



	if (used_lrs) {

		write_gicreg(cpu_if->vgic_hcr, ICH_HCR_EL2);



		for (i = 0; i < used_lrs; i++)

			__gic_v3_set_lr(cpu_if->vgic_lr[i], i);

	}



	/*

	 * Ensure that writes to the LRs, and on non-VHE systems ensure that

	 * the write to the VMCR in __vgic_v3_activate_traps(), will have

	 * reached the (re)distributors. This ensure the guest will read the

	 * correct values from the memory-mapped interface.

	 */

	if (used_lrs || !has_vhe()) {

		if (!cpu_if->vgic_sre) {

		/* Make sure ENABLE is set at EL2 before setting SRE at EL1 */

			isb();

		write_gicreg(1, ICC_SRE_EL1);

			dsb(sy);

		}

	}

}



void __hyp_text __vgic_v3_restore_state(struct kvm_vcpu *vcpu)

void __hyp_text __vgic_v3_activate_traps(struct kvm_vcpu *vcpu)

{

	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;

	u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs;

	int i;



	/*

	 * VFIQEn is RES1 if ICC_SRE_EL1.SRE is 1. This causes a
@@ -265,47 +277,69 @@ void __hyp_text __vgic_v3_restore_state(struct kvm_vcpu *vcpu) 
	 * consequences. So we must make sure that ICC_SRE_EL1 has

	 * been actually programmed with the value we want before

	 * starting to mess with the rest of the GIC, and VMCR_EL2 in

	 * particular.

	 * particular.  This logic must be called before

	 * __vgic_v3_restore_state().

	 */

	if (!cpu_if->vgic_sre) {

		write_gicreg(0, ICC_SRE_EL1);

		isb();

		write_gicreg(cpu_if->vgic_vmcr, ICH_VMCR_EL2);





		if (has_vhe()) {

			/*

			 * Ensure that the write to the VMCR will have reached

			 * the (re)distributors. This ensure the guest will

			 * read the correct values from the memory-mapped

			 * interface.

			 */

			isb();

			dsb(sy);

		}

	}



	if (used_lrs) {

		write_gicreg(cpu_if->vgic_hcr, ICH_HCR_EL2);

	/*

	 * Prevent the guest from touching the GIC system registers if

	 * SRE isn't enabled for GICv3 emulation.

	 */

	write_gicreg(read_gicreg(ICC_SRE_EL2) & ~ICC_SRE_EL2_ENABLE,

		     ICC_SRE_EL2);



		for (i = 0; i < used_lrs; i++)

			__gic_v3_set_lr(cpu_if->vgic_lr[i], i);

	} else {

	/*

	 * If we need to trap system registers, we must write

	 * ICH_HCR_EL2 anyway, even if no interrupts are being

		 * injected. Same thing if GICv4 is used, as VLPI

		 * delivery is gated by ICH_HCR_EL2.En.

	 * injected,

	 */

	if (static_branch_unlikely(&vgic_v3_cpuif_trap) ||

	    cpu_if->its_vpe.its_vm)

		write_gicreg(cpu_if->vgic_hcr, ICH_HCR_EL2);

}



	/*

	 * Ensures that the above will have reached the

	 * (re)distributors. This ensure the guest will read the

	 * correct values from the memory-mapped interface.

	 */

void __hyp_text __vgic_v3_deactivate_traps(struct kvm_vcpu *vcpu)

{

	struct vgic_v3_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v3;

	u64 val;



	if (!cpu_if->vgic_sre) {

		cpu_if->vgic_vmcr = read_gicreg(ICH_VMCR_EL2);

	}



	val = read_gicreg(ICC_SRE_EL2);

	write_gicreg(val | ICC_SRE_EL2_ENABLE, ICC_SRE_EL2);



	if (!cpu_if->vgic_sre) {

		/* Make sure ENABLE is set at EL2 before setting SRE at EL1 */

		isb();

		dsb(sy);

		write_gicreg(1, ICC_SRE_EL1);

	}



	/*

	 * Prevent the guest from touching the GIC system registers if

	 * SRE isn't enabled for GICv3 emulation.

	 * If we were trapping system registers, we enabled the VGIC even if

	 * no interrupts were being injected, and we disable it again here.

	 */

	write_gicreg(read_gicreg(ICC_SRE_EL2) & ~ICC_SRE_EL2_ENABLE,

		     ICC_SRE_EL2);

	if (static_branch_unlikely(&vgic_v3_cpuif_trap) ||

	    cpu_if->its_vpe.its_vm)

		write_gicreg(0, ICH_HCR_EL2);

}



void __hyp_text __vgic_v3_save_aprs(struct kvm_vcpu *vcpu)

CRA Git | Maintained and supported by SUSTech CRA and CCSE