Optimize KVM/ARM for VHE systems
Subsystems (4)
PATCH v5 2/40 KVM: arm/arm64: Move vcpu_load call after kvm_vcpu_first_run_init
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
Moving the call to vcpu_load() in kvm_arch_vcpu_ioctl_run() to after we've called kvm_vcpu_first_run_init() simplifies some of the vgic and there is also no need to do vcpu_load() for things such as handling the immediate_exit flag.
--- virt/kvm/arm/arch_timer.c | 4 ---- virt/kvm/arm/arm.c | 22 ++++++++-------------- virt/kvm/arm/vgic/vgic-init.c | 11 ----------- 3 files changed, 8 insertions(+), 29 deletions(-)
virt/kvm/arm/arch_timer.c +0 -4
@@ -854,11 +854,7 @@ int kvm_timer_enable(struct kvm_vcpu *vcpu)return ret; no_vgic: -preempt_disable (); timer->enabled =1 ; -kvm_timer_vcpu_load (vcpu); -preempt_enable (); -return 0 ; }
virt/kvm/arm/arm.c +8 -14
@@ -632,27 +632,22 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)if (unlikely (!kvm_vcpu_initialized (vcpu)))return -ENOEXEC ; -vcpu_load (vcpu); - ret =kvm_vcpu_first_run_init (vcpu);if (ret) - goto out; +return ret;if (run->exit_reason ==KVM_EXIT_MMIO ) { ret =kvm_handle_mmio_return (vcpu, vcpu->run);if (ret) - goto out; -if (kvm_arm_handle_step_debug (vcpu, vcpu->run)) { - ret =0 ; - goto out; - } - +return ret; +if (kvm_arm_handle_step_debug (vcpu, vcpu->run)) +return 0 ; } -if (run->immediate_exit) { - ret = -EINTR ; - goto out; - } +if (run->immediate_exit) +return -EINTR ; + +vcpu_load (vcpu);kvm_sigset_activate (vcpu);
@@ -811,7 +806,6 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)kvm_sigset_deactivate (vcpu); -out:vcpu_put (vcpu);return ret; }
virt/kvm/arm/vgic/vgic-init.c +0 -11
@@ -302,17 +302,6 @@ int vgic_init(struct kvm *kvm) dist->initialized = true; -/* -* If we're initializing GICv2 on-demand when first running the VCPU -* then we need to load the VGIC state onto the CPU. We can detect -* this easily by checking if we are in between vcpu_load and vcpu_put -* when we just initialized the VGIC. -*/ -preempt_disable (); - vcpu =kvm_arm_get_running_vcpu (); -if (vcpu) -kvm_vgic_load (vcpu); -preempt_enable (); out:return ret; }
Signature · 1 line
2.14.2
PATCH v5 3/40 KVM: arm64: Avoid storing the vcpu pointer on the stack
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
We already have the percpu area for the host cpu state, which points to the VCPU, so there's no need to store the VCPU pointer on the stack on every context switch. We can be a little more clever and just use tpidr_el2 for the percpu offset and load the VCPU pointer from the host context.
This has the benefit of being able to retrieve the host context even when our stack is corrupted, and it has a potential performance benefit because we trade a store plus a load for an mrs and a load on a round trip to the guest.
This does require us to calculate the percpu offset without including the offset from the kernel mapping of the percpu array to the linear mapping of the array (which is what we store in tpidr_el1), because a PC-relative generated address in EL2 is already giving us the hyp alias of the linear mapping of a kernel address. We do this in __cpu_init_hyp_mode() by using kvm_ksym_ref().
The code that accesses ESR_EL2 was previously using an alternative to use the _EL1 accessor on VHE systems, but this was actually unnecessary as the _EL1 accessor aliases the ESR_EL2 register on VHE, and the _EL2 accessor does the same thing on both systems.
---
Notes:
Changes since v4:
- Clarified rationale in commit message.
- Called get_host_ctxt from get_vcpu and rename get_vcpu to get_vcpu_ptr.
Changes since v3:
- Reworked the assembly part of the patch after rebasing on v4.16-rc1 which created a conflict with the variant 2 mitigations.
- Removed Marc's reviewed-by due to the rework.
- Removed unneeded extern keyword in declaration in header file
Changes since v1:
- Use PC-relative addressing to access per-cpu variables instead of using a load from the literal pool.
- Remove stale comments as pointed out by Marc
- Reworded the commit message as suggested by Drew
arch/arm64/include/asm/kvm_asm.h | 15 +++++++++++++++ arch/arm64/include/asm/kvm_host.h | 15 +++++++++++++++ arch/arm64/kernel/asm-offsets.c | 1 + arch/arm64/kvm/hyp/entry.S | 6 +----- arch/arm64/kvm/hyp/hyp-entry.S | 28 ++++++++++------------------ arch/arm64/kvm/hyp/switch.c | 5 +---- arch/arm64/kvm/hyp/sysreg-sr.c | 5 +++++ 7 files changed, 48 insertions(+), 27 deletions(-)
arch/arm64/include/asm/kvm_asm.h +15 -0
@@ -33,6 +33,7 @@#define KVM_ARM64_DEBUG_DIRTY_SHIFT 0#define KVM_ARM64_DEBUG_DIRTY (1 << KVM_ARM64_DEBUG_DIRTY_SHIFT) +/* Translate a kernel address of @sym into its equivalent linear mapping */ #define kvm_ksym_ref (sym) \ ({ \ void *val = &sym; \
@@ -70,6 +71,20 @@ extern u32 __init_stage2_translation(void); extern void __qcom_hyp_sanitize_btac_predictors(void); +#else /* __ASSEMBLY__ */ + +.macro get_host_ctxt reg, tmp + adr_l \reg, kvm_host_cpu_state + mrs \tmp, tpidr_el2 + add \reg, \reg, \tmp +.endm + +.macro get_vcpu_ptr vcpu, ctxt + get_host_ctxt \ctxt, \vcpu + ldr \vcpu, [\ctxt, #HOST_CONTEXT_VCPU] + kern_hyp_va \vcpu +.endm + #endif #endif /* __ARM_KVM_ASM_H__ */
arch/arm64/include/asm/kvm_host.h +15 -0
@@ -358,10 +358,15 @@ int kvm_perf_teardown(void);struct kvm_vcpu *kvm_mpidr_to_vcpu (struct kvm *kvm,unsigned long mpidr); +void __kvm_set_tpidr_el2 (u64 tpidr_el2); +DECLARE_PER_CPU (kvm_cpu_context_t, kvm_host_cpu_state); +static inline void __cpu_init_hyp_mode (phys_addr_t pgd_ptr,unsigned long hyp_stack_ptr,unsigned long vector_ptr) { +u64 tpidr_el2; +/* * Call initialization code, and switch to the full blown HYP code. * If the cpucaps haven't been finalized yet, something has gone very
@@ -370,6 +375,16 @@ static inline void __cpu_init_hyp_mode(phys_addr_t pgd_ptr,*/ BUG_ON (!static_branch_likely (&arm64_const_caps_ready));__kvm_call_hyp ((void *)pgd_ptr, hyp_stack_ptr, vector_ptr); + +/* +* Calculate the raw per-cpu offset without a translation from the +* kernel's mapping to the linear mapping, and store it in tpidr_el2 +* so that we can use adr_l to access per-cpu variables in EL2. +*/ + tpidr_el2 = (u64 )this_cpu_ptr (&kvm_host_cpu_state) + - (u64 )kvm_ksym_ref (kvm_host_cpu_state); + +kvm_call_hyp (__kvm_set_tpidr_el2, tpidr_el2); }static inline void kvm_arch_hardware_unsetup (void ) {}
arch/arm64/kernel/asm-offsets.c +1 -0
@@ -138,6 +138,7 @@ int main(void)DEFINE (CPU_FP_REGS , offsetof(struct kvm_regs , fp_regs)); DEFINE(VCPU_FPEXC32_EL2, offsetof(struct kvm_vcpu, arch.ctxt.sys_regs[FPEXC32_EL2])); DEFINE(VCPU_HOST_CONTEXT, offsetof(struct kvm_vcpu, arch.host_cpu_context)); +DEFINE (HOST_CONTEXT_VCPU , offsetof(struct kvm_cpu_context , __hyp_running_vcpu));#endif #ifdef CONFIG_CPU_PM DEFINE (CPU_SUSPEND_SZ ,sizeof (struct cpu_suspend_ctx ));
arch/arm64/kvm/hyp/entry.S +1 -5
@@ -62,9 +62,6 @@ ENTRY(__guest_enter) // Store the host regs save_callee_saved_regs x1 - // Store host_ctxt and vcpu for use at exit time - stp x1, x0, [sp, #-16]! - add x18, x0, #VCPU_CONTEXT // Restore guest regs x0-x17
@@ -118,8 +115,7 @@ ENTRY(__guest_exit) // Store the guest regs x19-x29, lr save_callee_saved_regs x1 - // Restore the host_ctxt from the stack - ldr x2, [sp], #16 + get_host_ctxt x2, x3 // Now restore the host regs restore_callee_saved_regs x2
arch/arm64/kvm/hyp/hyp-entry.S +10 -18
@@ -57,13 +57,8 @@ ENDPROC(__vhe_hyp_call) el1_sync: // Guest trapped into EL2 stp x0, x1, [sp, #-16]! -alternative_if_not ARM64_HAS_VIRT_HOST_EXTN - mrs x1, esr_el2 -alternative_else - mrs x1, esr_el1 -alternative_endif - lsr x0, x1, #ESR_ELx_EC_SHIFT - + mrs x0, esr_el2 + lsr x0, x0, #ESR_ELx_EC_SHIFT cmp x0, #ESR_ELx_EC_HVC64 ccmp x0, #ESR_ELx_EC_HVC32, #4, ne b.ne el1_trap
@@ -117,10 +112,14 @@ el1_hvc_guest: eret el1_trap: + get_vcpu_ptr x1, x0 + + mrs x0, esr_el2 + lsr x0, x0, #ESR_ELx_EC_SHIFT /* * x0: ESR_EC + * x1: vcpu pointer */ - ldr x1, [sp, #16 + 8] // vcpu stored by __guest_enter /* * We trap the first access to the FP/SIMD to save the host context
@@ -138,13 +137,13 @@ alternative_else_nop_endif el1_irq: stp x0, x1, [sp, #-16]! - ldr x1, [sp, #16 + 8] + get_vcpu_ptr x1, x0 mov x0, #ARM_EXCEPTION_IRQ b __guest_exit el1_error: stp x0, x1, [sp, #-16]! - ldr x1, [sp, #16 + 8] + get_vcpu_ptr x1, x0 mov x0, #ARM_EXCEPTION_EL1_SERROR b __guest_exit
@@ -180,14 +179,7 @@ ENTRY(__hyp_do_panic) ENDPROC(__hyp_do_panic) ENTRY(__hyp_panic) - /* - * '=kvm_host_cpu_state' is a host VA from the constant pool, it may - * not be accessible by this address from EL2, hyp_panic() converts - * it with kern_hyp_va() before use. - */ - ldr x0, =kvm_host_cpu_state - mrs x1, tpidr_el2 - add x0, x0, x1 + get_host_ctxt x0, x1 b hyp_panic ENDPROC(__hyp_panic)
arch/arm64/kvm/hyp/switch.c +1 -4
@@ -469,7 +469,7 @@ static hyp_alternate_select(__hyp_call_panic, __hyp_call_panic_nvhe, __hyp_call_panic_vhe, ARM64_HAS_VIRT_HOST_EXTN); -void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *__host_ctxt) +void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *host_ctxt) {struct kvm_vcpu *vcpu =NULL ;
@@ -478,9 +478,6 @@ void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *__host_ctxt)u64 par =read_sysreg (par_el1);if (read_sysreg (vttbr_el2)) { -struct kvm_cpu_context *host_ctxt; - - host_ctxt =kern_hyp_va (__host_ctxt); vcpu = host_ctxt->__hyp_running_vcpu;__timer_disable_traps (vcpu);__deactivate_traps (vcpu);
arch/arm64/kvm/hyp/sysreg-sr.c +5 -0
@@ -189,3 +189,8 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu)if (vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY )write_sysreg (sysreg[DBGVCR32_EL2 ], dbgvcr32_el2); } + +void __hyp_text __kvm_set_tpidr_el2(u64 tpidr_el2) +{ + asm("msr tpidr_el2, %0" : :"r" (tpidr_el2)); +}
Signature · 1 line
2.14.2
PATCH v5 4/40 KVM: arm64: Rework hyp_panic for VHE and non-VHE
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
VHE actually doesn't rely on clearing the VTTBR when returning to the host kernel, and that is the current key mechanism of hyp_panic to figure out how to attempt to return to a state good enough to print a panic statement.
Therefore, we split the hyp_panic function into two functions, a VHE and a non-VHE, keeping the non-VHE version intact, but changing the VHE behavior.
The vttbr_el2 check on VHE doesn't really make that much sense, because the only situation where we can get here on VHE is when the hypervisor assembly code actually called into hyp_panic, which only happens when VBAR_EL2 has been set to the KVM exception vectors. On VHE, we can always safely disable the traps and restore the host registers at this point, so we simply do that unconditionally and call into the panic function directly.
---
Notes:
Changes since v1:
- Fixed typos in the commit message
- Still use the generic __deactivte_traps() function in the hyp panic code until we rework that logic later.
arch/arm64/kvm/hyp/switch.c | 42 +++++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 19 deletions(-)
arch/arm64/kvm/hyp/switch.c +23 -19
@@ -439,10 +439,20 @@ int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu)static const char __hyp_panic_string[] ="HYP panic:\nPS:%08llx PC:%016llx ESR:%08llx\nFAR:%016llx HPFAR:%016llx PAR:%016llx\nVCPU:%p\n" ; static void __hyp_text __hyp_call_panic_nvhe(u64 spsr, u64 elr, u64 par, -struct kvm_vcpu *vcpu) +struct kvm_cpu_context *__host_ctxt) { +struct kvm_vcpu *vcpu;unsigned long str_va; + vcpu = __host_ctxt->__hyp_running_vcpu; + +if (read_sysreg (vttbr_el2)) { +__timer_disable_traps (vcpu); +__deactivate_traps (vcpu); +__deactivate_vm (vcpu); +__sysreg_restore_host_state (__host_ctxt); + } +/* * Force the panic string to be loaded from the literal pool, * making sure it is a kernel address and not a PC-relative
@@ -456,37 +466,31 @@ static void __hyp_text __hyp_call_panic_nvhe(u64 spsr, u64 elr, u64 par, read_sysreg(hpfar_el2), par, vcpu); } -static void __hyp_text __hyp_call_panic_vhe(u64 spsr, u64 elr, u64 par, -struct kvm_vcpu *vcpu) +static void __hyp_call_panic_vhe (u64 spsr,u64 elr,u64 par, +struct kvm_cpu_context *host_ctxt) { +struct kvm_vcpu *vcpu; + vcpu = host_ctxt->__hyp_running_vcpu; + +__deactivate_traps (vcpu); +__sysreg_restore_host_state (host_ctxt); +panic (__hyp_panic_string, spsr, elr,read_sysreg_el2 (esr),read_sysreg_el2 (far),read_sysreg (hpfar_el2), par, vcpu); } -static hyp_alternate_select(__hyp_call_panic, - __hyp_call_panic_nvhe, __hyp_call_panic_vhe, - ARM64_HAS_VIRT_HOST_EXTN); - void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *host_ctxt) { -struct kvm_vcpu *vcpu =NULL ; -u64 spsr =read_sysreg_el2 (spsr);u64 elr =read_sysreg_el2 (elr);u64 par =read_sysreg (par_el1); -if (read_sysreg (vttbr_el2)) { - vcpu = host_ctxt->__hyp_running_vcpu; -__timer_disable_traps (vcpu); -__deactivate_traps (vcpu); -__deactivate_vm (vcpu); -__sysreg_restore_host_state (host_ctxt); - } - -/* Call panic for real */ -__hyp_call_panic ()(spsr, elr, par, vcpu); +if (!has_vhe ()) +__hyp_call_panic_nvhe (spsr, elr, par, host_ctxt); +else +__hyp_call_panic_vhe (spsr, elr, par, host_ctxt);unreachable (); }
Signature · 1 line
2.14.2
PATCH v5 6/40 KVM: arm/arm64: Get rid of vcpu->arch.irq_lines
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
We currently have a separate read-modify-write of the HCR_EL2 on entry to the guest for the sole purpose of setting the VF and VI bits, if set. Since this is most rarely the case (only when using userspace IRQ chip and interrupts are in flight), let's get rid of this operation and instead modify the bits in the vcpu->arch.hcr[_el2] directly when needed.
--- arch/arm/include/asm/kvm_emulate.h | 9 ++------- arch/arm/include/asm/kvm_host.h | 3 --- arch/arm/kvm/emulate.c | 2 +- arch/arm/kvm/hyp/switch.c | 2 +- arch/arm64/include/asm/kvm_emulate.h | 9 ++------- arch/arm64/include/asm/kvm_host.h | 3 --- arch/arm64/kvm/hyp/switch.c | 6 ------ arch/arm64/kvm/inject_fault.c | 2 +- virt/kvm/arm/arm.c | 11 ++++++----- virt/kvm/arm/mmu.c | 6 +++--- 10 files changed, 16 insertions(+), 37 deletions(-)
arch/arm/include/asm/kvm_emulate.h +2 -7
@@ -92,14 +92,9 @@ static inline void vcpu_reset_hcr(struct kvm_vcpu *vcpu) vcpu->arch.hcr =HCR_GUEST_MASK ; } -static inline unsigned long vcpu_get_hcr (const struct kvm_vcpu *vcpu) +static inline unsigned long *vcpu_hcr (const struct kvm_vcpu *vcpu) { -return vcpu->arch.hcr; -} - -static inline void vcpu_set_hcr (struct kvm_vcpu *vcpu,unsigned long hcr) -{ - vcpu->arch.hcr = hcr; +return (unsigned long *)&vcpu->arch.hcr; }static inline bool vcpu_mode_is_32bit (const struct kvm_vcpu *vcpu)
arch/arm/include/asm/kvm_host.h +0 -3
@@ -155,9 +155,6 @@ struct kvm_vcpu_arch {/* HYP trapping configuration */ u32 hcr; -/* Interrupt related fields */ -u32 irq_lines;/* IRQ and FIQ levels */ -/* Exception Information */ struct kvm_vcpu_fault_info fault;
arch/arm/kvm/emulate.c +1 -1
@@ -174,5 +174,5 @@ unsigned long *vcpu_spsr(struct kvm_vcpu *vcpu)*/ void kvm_inject_vabt (struct kvm_vcpu *vcpu) { -vcpu_set_hcr (vcpu,vcpu_get_hcr (vcpu) |HCR_VA ); + *vcpu_hcr (vcpu) |=HCR_VA ; }
arch/arm/kvm/hyp/switch.c +1 -1
@@ -44,7 +44,7 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu, u32 *fpexc_host)isb (); } -write_sysreg (vcpu->arch.hcr | vcpu->arch.irq_lines,HCR ); +write_sysreg (vcpu->arch.hcr,HCR );/* Trap on AArch32 cp15 c15 accesses (EL1 or EL0) */ write_sysreg (HSTR_T (15 ),HSTR );write_sysreg (HCPTR_TTA |HCPTR_TCP (10 ) |HCPTR_TCP (11 ),HCPTR );
arch/arm64/include/asm/kvm_emulate.h +2 -7
@@ -69,14 +69,9 @@ static inline void vcpu_reset_hcr(struct kvm_vcpu *vcpu) vcpu->arch.hcr_el2 |=HCR_TID3 ; } -static inline unsigned long vcpu_get_hcr (struct kvm_vcpu *vcpu) +static inline unsigned long *vcpu_hcr (struct kvm_vcpu *vcpu) { -return vcpu->arch.hcr_el2; -} - -static inline void vcpu_set_hcr (struct kvm_vcpu *vcpu,unsigned long hcr) -{ - vcpu->arch.hcr_el2 = hcr; +return (unsigned long *)&vcpu->arch.hcr_el2; }static inline void vcpu_set_vsesr (struct kvm_vcpu *vcpu,u64 vsesr)
arch/arm64/include/asm/kvm_host.h +0 -3
@@ -272,9 +272,6 @@ struct kvm_vcpu_arch {/* IO related fields */ struct kvm_decode mmio_decode; -/* Interrupt related fields */ -u64 irq_lines;/* IRQ and FIQ levels */ -/* Cache some mmu pages needed inside spinlock regions */ struct kvm_mmu_memory_cache mmu_page_cache;
arch/arm64/kvm/hyp/switch.c +0 -6
@@ -178,12 +178,6 @@ static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu) static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu) { -u64 val; - - val =read_sysreg (hcr_el2); - val |= vcpu->arch.irq_lines; -write_sysreg (val, hcr_el2); -if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_restore_state (vcpu);else
arch/arm64/kvm/inject_fault.c +1 -1
@@ -167,7 +167,7 @@ void kvm_inject_undefined(struct kvm_vcpu *vcpu)static void pend_guest_serror (struct kvm_vcpu *vcpu,u64 esr) {vcpu_set_vsesr (vcpu, esr); -vcpu_set_hcr (vcpu,vcpu_get_hcr (vcpu) |HCR_VSE ); + *vcpu_hcr (vcpu) |=HCR_VSE ; }/**
virt/kvm/arm/arm.c +6 -5
@@ -420,7 +420,8 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,*/ int kvm_arch_vcpu_runnable (struct kvm_vcpu *v) { -return ((!!v->arch.irq_lines ||kvm_vgic_vcpu_pending_irq (v)) +bool irq_lines = *vcpu_hcr (v) & (HCR_VI |HCR_VF ); +return ((irq_lines ||kvm_vgic_vcpu_pending_irq (v)) && !v->arch.power_off && !v->arch.pause); }
@@ -814,18 +815,18 @@ static int vcpu_interrupt_line(struct kvm_vcpu *vcpu, int number, bool level) {int bit_index;bool set; -unsigned long *ptr; +unsigned long *hcr;if (number ==KVM_ARM_IRQ_CPU_IRQ ) bit_index =__ffs (HCR_VI );else /* KVM_ARM_IRQ_CPU_FIQ */ bit_index =__ffs (HCR_VF ); - ptr = (unsigned long *)&vcpu->arch.irq_lines; + hcr =vcpu_hcr (vcpu);if (level) - set =test_and_set_bit (bit_index, ptr); + set =test_and_set_bit (bit_index, hcr);else - set =test_and_clear_bit (bit_index, ptr); + set =test_and_clear_bit (bit_index, hcr);/* * If we didn't change anything, no need to wake up or kick other CPUs
virt/kvm/arm/mmu.c +3 -3
@@ -2035,7 +2035,7 @@ void kvm_arch_flush_shadow_memslot(struct kvm *kvm,*/ void kvm_set_way_flush (struct kvm_vcpu *vcpu) { -unsigned long hcr =vcpu_get_hcr (vcpu); +unsigned long hcr = *vcpu_hcr (vcpu);/* * If this is the first time we do a S/W operation
@@ -2050,7 +2050,7 @@ void kvm_set_way_flush(struct kvm_vcpu *vcpu)trace_kvm_set_way_flush (*vcpu_pc (vcpu),vcpu_has_cache_enabled (vcpu));stage2_flush_vm (vcpu->kvm); -vcpu_set_hcr (vcpu, hcr |HCR_TVM ); + *vcpu_hcr (vcpu) = hcr |HCR_TVM ; } }
@@ -2068,7 +2068,7 @@ void kvm_toggle_cache(struct kvm_vcpu *vcpu, bool was_enabled)/* Caches are now on, stop trapping VM ops (until a S/W op) */ if (now_enabled) -vcpu_set_hcr (vcpu,vcpu_get_hcr (vcpu) & ~HCR_TVM ); + *vcpu_hcr (vcpu) &= ~HCR_TVM ;trace_kvm_toggle_cache (*vcpu_pc (vcpu), was_enabled, now_enabled); }
Signature · 1 line
2.14.2
PATCH v5 8/40 KVM: arm/arm64: Introduce vcpu_el1_is_32bit
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
We have numerous checks around that checks if the HCR_EL2 has the RW bit set to figure out if we're running an AArch64 or AArch32 VM. In some cases, directly checking the RW bit (given its unintuitive name), is a bit confusing, and that's not going to improve as we move logic around for the following patches that optimize KVM on AArch64 hosts with VHE.
Therefore, introduce a helper, vcpu_el1_is_32bit, and replace existing direct checks of HCR_EL2.RW with the helper.
---
Notes:
Changes since v2:
- New patch
Changes since v1:
- Reworded comments as suggested by Drew
arch/arm64/include/asm/kvm_emulate.h | 7 ++++++- arch/arm64/kvm/hyp/switch.c | 11 +++++------ arch/arm64/kvm/hyp/sysreg-sr.c | 5 +++-- arch/arm64/kvm/inject_fault.c | 6 +++--- 4 files changed, 17 insertions(+), 12 deletions(-)
arch/arm64/include/asm/kvm_emulate.h +6 -1
@@ -45,6 +45,11 @@ void kvm_inject_undef32(struct kvm_vcpu *vcpu);void kvm_inject_dabt32 (struct kvm_vcpu *vcpu,unsigned long addr);void kvm_inject_pabt32 (struct kvm_vcpu *vcpu,unsigned long addr); +static inline bool vcpu_el1_is_32bit (struct kvm_vcpu *vcpu) +{ +return !(vcpu->arch.hcr_el2 &HCR_RW ); +} +static inline void vcpu_reset_hcr (struct kvm_vcpu *vcpu) { vcpu->arch.hcr_el2 =HCR_GUEST_FLAGS ;
@@ -65,7 +70,7 @@ static inline void vcpu_reset_hcr(struct kvm_vcpu *vcpu)* For now this is conditional, since no AArch32 feature regs * are currently virtualised. */ -if (vcpu->arch.hcr_el2 &HCR_RW ) +if (!vcpu_el1_is_32bit (vcpu)) vcpu->arch.hcr_el2 |=HCR_TID3 ; }
arch/arm64/kvm/hyp/switch.c +5 -6
@@ -74,7 +74,7 @@ static hyp_alternate_select(__activate_traps_arch, static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu) { -u64 val; +u64 hcr = vcpu->arch.hcr_el2;/* * We are about to set CPTR_EL2.TFP to trap all floating point
@@ -85,17 +85,16 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu)* If FP/ASIMD is not implemented, FPEXC is UNDEFINED and any access to * it will cause an exception. */ - val = vcpu->arch.hcr_el2; - -if (!(val &HCR_RW ) &&system_supports_fpsimd ()) { +if (vcpu_el1_is_32bit (vcpu) &&system_supports_fpsimd ()) {write_sysreg (1 <<30 , fpexc32_el2);isb (); } -write_sysreg (val, hcr_el2); -if (cpus_have_const_cap (ARM64_HAS_RAS_EXTN ) && (val &HCR_VSE )) +if (cpus_have_const_cap (ARM64_HAS_RAS_EXTN ) && (hcr &HCR_VSE ))write_sysreg_s (vcpu->arch.vsesr_el2,SYS_VSESR_EL2 ); +write_sysreg (hcr, hcr_el2); +/* Trap on AArch32 cp15 c15 accesses (EL1 or EL0) */ write_sysreg (1 <<15 , hstr_el2);/*
arch/arm64/kvm/hyp/sysreg-sr.c +3 -2
@@ -19,6 +19,7 @@#include <linux/kvm_host.h> #include <asm/kvm_asm.h> +#include <asm/kvm_emulate.h> #include <asm/kvm_hyp.h> /* Yes, this does nothing, on purpose */
@@ -147,7 +148,7 @@ void __hyp_text __sysreg32_save_state(struct kvm_vcpu *vcpu) {u64 *spsr, *sysreg; -if (read_sysreg (hcr_el2) &HCR_RW ) +if (!vcpu_el1_is_32bit (vcpu))return ; spsr = vcpu->arch.ctxt.gp_regs.spsr;
@@ -172,7 +173,7 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu) {u64 *spsr, *sysreg; -if (read_sysreg (hcr_el2) &HCR_RW ) +if (!vcpu_el1_is_32bit (vcpu))return ; spsr = vcpu->arch.ctxt.gp_regs.spsr;
arch/arm64/kvm/inject_fault.c +3 -3
@@ -128,7 +128,7 @@ static void inject_undef64(struct kvm_vcpu *vcpu)*/ void kvm_inject_dabt (struct kvm_vcpu *vcpu,unsigned long addr) { -if (!(vcpu->arch.hcr_el2 &HCR_RW )) +if (vcpu_el1_is_32bit (vcpu))kvm_inject_dabt32 (vcpu, addr);else inject_abt64 (vcpu, false, addr);
@@ -144,7 +144,7 @@ void kvm_inject_dabt(struct kvm_vcpu *vcpu, unsigned long addr)*/ void kvm_inject_pabt (struct kvm_vcpu *vcpu,unsigned long addr) { -if (!(vcpu->arch.hcr_el2 &HCR_RW )) +if (vcpu_el1_is_32bit (vcpu))kvm_inject_pabt32 (vcpu, addr);else inject_abt64 (vcpu, true, addr);
@@ -158,7 +158,7 @@ void kvm_inject_pabt(struct kvm_vcpu *vcpu, unsigned long addr)*/ void kvm_inject_undefined (struct kvm_vcpu *vcpu) { -if (!(vcpu->arch.hcr_el2 &HCR_RW )) +if (vcpu_el1_is_32bit (vcpu))kvm_inject_undef32 (vcpu);else inject_undef64 (vcpu);
Signature · 1 line
2.14.2
PATCH v5 5/40 KVM: arm64: Move HCR_INT_OVERRIDE to default HCR_EL2 guest flag
In reply to Christoffer DallFrom: Shih-Wei Li <[email protected]>
We always set the IMO and FMO bits in the HCR_EL2 when running the guest, regardless if we use the vgic or not. By moving these flags to HCR_GUEST_FLAGS we can avoid one of the extra save/restore operations of HCR_EL2 in the world switch code, and we can also soon get rid of the other one.
This is safe, because even though the IMO and FMO bits control both taking the interrupts to EL2 and remapping ICC_*_EL1 to ICV_*_EL1 when executed at EL1, as long as we ensure that these bits are clear when running the EL1 host, we're OK, because we reset the HCR_EL2 to only have the HCR_RW bit set when returning to EL1 on non-VHE systems.
---
Notes:
Changes since v3:
- Slightly reworded the commit message
arch/arm64/include/asm/kvm_arm.h | 4 ++-- arch/arm64/kvm/hyp/switch.c | 3 --- 2 files changed, 2 insertions(+), 5 deletions(-)
arch/arm64/include/asm/kvm_arm.h +2 -2
@@ -83,9 +83,9 @@*/ #define HCR_GUEST_FLAGS (HCR_TSC | HCR_TSW | HCR_TWE | HCR_TWI | HCR_VM | \ HCR_TVM | HCR_BSU_IS | HCR_FB | HCR_TAC | \ - HCR_AMO | HCR_SWIO | HCR_TIDCP | HCR_RW | HCR_TLOR) + HCR_AMO | HCR_SWIO | HCR_TIDCP | HCR_RW | HCR_TLOR | \ + HCR_FMO | HCR_IMO)#define HCR_VIRT_EXCP_MASK (HCR_VSE | HCR_VI | HCR_VF) -#define HCR_INT_OVERRIDE (HCR_FMO | HCR_IMO)#define HCR_HOST_VHE_FLAGS (HCR_RW | HCR_TGE | HCR_E2H)/* TCR_EL2 Registers bits */
arch/arm64/kvm/hyp/switch.c +0 -3
@@ -174,8 +174,6 @@ static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu)__vgic_v3_save_state (vcpu); else__vgic_v2_save_state (vcpu ); - -write_sysreg (read_sysreg (hcr_el2) & ~HCR_INT_OVERRIDE , hcr_el2); } static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu)
@@ -183,7 +181,6 @@ static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu)u64 val; val =read_sysreg (hcr_el2); - val |=HCR_INT_OVERRIDE ; val |= vcpu->arch.irq_lines;write_sysreg (val, hcr_el2);
Signature · 1 line
2.14.2
PATCH v5 9/40 KVM: arm64: Move debug dirty flag calculation out of world switch
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
There is no need to figure out inside the world-switch if we should save/restore the debug registers or not, we might as well do that in the higher level debug setup code, making it easier to optimize down the line.
--- arch/arm64/kvm/debug.c | 5 +++++ arch/arm64/kvm/hyp/debug-sr.c | 6 ------ 2 files changed, 5 insertions(+), 6 deletions(-)
arch/arm64/kvm/debug.c +5 -0
@@ -193,6 +193,11 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu)if (trap_debug) vcpu->arch.mdcr_el2 |=MDCR_EL2_TDA ; +/* If KDE or MDE are set, perform a full save/restore cycle. */ +if ((vcpu_sys_reg (vcpu,MDSCR_EL1 ) &DBG_MDSCR_KDE ) || + (vcpu_sys_reg (vcpu,MDSCR_EL1 ) &DBG_MDSCR_MDE )) + vcpu->arch.debug_flags |=KVM_ARM64_DEBUG_DIRTY ; +trace_kvm_arm_set_dreg32 ("MDCR_EL2" , vcpu->arch.mdcr_el2);trace_kvm_arm_set_dreg32 ("MDSCR_EL1" ,vcpu_sys_reg (vcpu,MDSCR_EL1 )); }
arch/arm64/kvm/hyp/debug-sr.c +0 -6
@@ -166,12 +166,6 @@ void __hyp_text __debug_restore_state(struct kvm_vcpu *vcpu, void __hyp_text __debug_cond_save_host_state(struct kvm_vcpu *vcpu) { -/* If any of KDE, MDE or KVM_ARM64_DEBUG_DIRTY is set, perform -* a full save/restore cycle. */ -if ((vcpu->arch.ctxt.sys_regs[MDSCR_EL1 ] &DBG_MDSCR_KDE ) || - (vcpu->arch.ctxt.sys_regs[MDSCR_EL1 ] &DBG_MDSCR_MDE )) - vcpu->arch.debug_flags |=KVM_ARM64_DEBUG_DIRTY ; -__debug_save_state (vcpu, &vcpu->arch.host_debug_state.regs,kern_hyp_va (vcpu->arch.host_cpu_context));__debug_save_spe ()(&vcpu->arch.host_debug_state.pmscr_el1);
Signature · 1 line
2.14.2
PATCH v5 10/40 KVM: arm64: Slightly improve debug save/restore functions
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
The debug save/restore functions can be improved by using the has_vhe() static key instead of the instruction alternative. Using the static key uses the same paradigm as we're going to use elsewhere, it makes the code more readable, and it generates slightly better code (no stack setups and function calls unless necessary).
We also use a static key on the restore path, because it will be marginally faster than loading a value from memory.
Finally, we don't have to conditionally clear the debug dirty flag if it's set, we can just clear it.
---
Notes:
Changes since v1:
- Change dot to comma in comment
- Rename __debug_restore_spe to __debug_restore_spe_nvhe
arch/arm64/kvm/hyp/debug-sr.c | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-)
arch/arm64/kvm/hyp/debug-sr.c +12 -14
@@ -66,11 +66,6 @@default :write_debug (ptr[0 ], reg,0 ); \ } -static void __hyp_text __debug_save_spe_vhe(u64 *pmscr_el1) -{ -/* The vcpu can run. but it can't hide. */ -} - static void __hyp_text __debug_save_spe_nvhe(u64 *pmscr_el1) {u64 reg;
@@ -103,11 +98,7 @@ static void __hyp_text __debug_save_spe_nvhe(u64 *pmscr_el1)dsb (nsh); } -static hyp_alternate_select(__debug_save_spe, - __debug_save_spe_nvhe, __debug_save_spe_vhe, - ARM64_HAS_VIRT_HOST_EXTN); - -static void __hyp_text __debug_restore_spe(u64 pmscr_el1) +static void __hyp_text __debug_restore_spe_nvhe(u64 pmscr_el1) {if (!pmscr_el1)return ;
@@ -168,17 +159,24 @@ void __hyp_text __debug_cond_save_host_state(struct kvm_vcpu *vcpu) {__debug_save_state (vcpu, &vcpu->arch.host_debug_state.regs,kern_hyp_va (vcpu->arch.host_cpu_context)); -__debug_save_spe ()(&vcpu->arch.host_debug_state.pmscr_el1); + +/* +* Non-VHE: Disable and flush SPE data generation +* VHE: The vcpu can run, but it can't hide. +*/ +if (!has_vhe ()) +__debug_save_spe_nvhe (&vcpu->arch.host_debug_state.pmscr_el1); } void __hyp_text __debug_cond_restore_host_state(struct kvm_vcpu *vcpu) { -__debug_restore_spe (vcpu->arch.host_debug_state.pmscr_el1); +if (!has_vhe ()) +__debug_restore_spe_nvhe (vcpu->arch.host_debug_state.pmscr_el1); +__debug_restore_state (vcpu, &vcpu->arch.host_debug_state.regs,kern_hyp_va (vcpu->arch.host_cpu_context)); -if (vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY ) - vcpu->arch.debug_flags &= ~KVM_ARM64_DEBUG_DIRTY ; + vcpu->arch.debug_flags &= ~KVM_ARM64_DEBUG_DIRTY ; } u32 __hyp_text __kvm_get_mdcr_el2(void)
Signature · 1 line
2.14.2
PATCH v5 12/40 KVM: arm64: Factor out fault info population and gic workarounds
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
The current world-switch function has functionality to detect a number of cases where we need to fixup some part of the exit condition and possibly run the guest again, before having restored the host state.
This includes populating missing fault info, emulating GICv2 CPU interface accesses when mapped at unaligned addresses, and emulating the GICv3 CPU interface on systems that need it.
As we are about to have an alternative switch function for VHE systems, but VHE systems still need the same early fixup logic, factor out this logic into a separate function that can be shared by both switch functions.
No functional change.
--- arch/arm64/kvm/hyp/switch.c | 104 ++++++++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 47 deletions(-)
arch/arm64/kvm/hyp/switch.c +57 -47
@@ -291,53 +291,27 @@ static bool __hyp_text __skip_instr(struct kvm_vcpu *vcpu) } } -int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu) +/* +* Return true when we were able to fixup the guest exit and should return to +* the guest, false when we should restore the host state and return to the +* main run loop. +*/ +static bool __hyp_text fixup_guest_exit(struct kvm_vcpu *vcpu, u64 *exit_code) { -struct kvm_cpu_context *host_ctxt; -struct kvm_cpu_context *guest_ctxt; -bool fp_enabled; -u64 exit_code; - - vcpu =kern_hyp_va (vcpu); - - host_ctxt =kern_hyp_va (vcpu->arch.host_cpu_context); - host_ctxt->__hyp_running_vcpu = vcpu; - guest_ctxt = &vcpu->arch.ctxt; - -__sysreg_save_host_state (host_ctxt); - -__activate_traps (vcpu); -__activate_vm (vcpu); - -__vgic_restore_state (vcpu); -__timer_enable_traps (vcpu); - -/* -* We must restore the 32-bit state before the sysregs, thanks -* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). -*/ -__sysreg32_restore_state (vcpu); -__sysreg_restore_guest_state (guest_ctxt); -__debug_switch_to_guest (vcpu); - -/* Jump in the fire! */ -again: - exit_code =__guest_enter (vcpu, host_ctxt); -/* And we're baaack! */ - -if (ARM_EXCEPTION_CODE (exit_code) !=ARM_EXCEPTION_IRQ ) +if (ARM_EXCEPTION_CODE (*exit_code) !=ARM_EXCEPTION_IRQ ) vcpu->arch.fault.esr_el2 =read_sysreg_el2 (esr); +/* * We're using the raw exception code in order to only process * the trap if no SError is pending. We will come back to the * same PC once the SError has been injected, and replay the * trapping instruction. */ -if (exit_code ==ARM_EXCEPTION_TRAP && !__populate_fault_info (vcpu)) - goto again; +if (*exit_code ==ARM_EXCEPTION_TRAP && !__populate_fault_info (vcpu)) +return true;if (static_branch_unlikely (&vgic_v2_cpuif_trap) && - exit_code ==ARM_EXCEPTION_TRAP ) { + *exit_code ==ARM_EXCEPTION_TRAP ) {bool valid; valid = kvm_vcpu_trap_get_class(vcpu) == ESR_ELx_EC_DABT_LOW &&
@@ -351,9 +325,9 @@ int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu)if (ret ==1 ) {if (__skip_instr (vcpu)) - goto again; +return true;else - exit_code =ARM_EXCEPTION_TRAP ; + *exit_code =ARM_EXCEPTION_TRAP ; }if (ret ==-1 ) {
@@ -365,29 +339,65 @@ int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu)*/ if (!__skip_instr (vcpu)) *vcpu_cpsr (vcpu) &= ~DBG_SPSR_SS ; - exit_code =ARM_EXCEPTION_EL1_SERROR ; + *exit_code =ARM_EXCEPTION_EL1_SERROR ; } - -/* 0 falls through to be handler out of EL2 */ } }if (static_branch_unlikely (&vgic_v3_cpuif_trap) && - exit_code ==ARM_EXCEPTION_TRAP && + *exit_code ==ARM_EXCEPTION_TRAP && (kvm_vcpu_trap_get_class (vcpu) == ESR_ELx_EC_SYS64 ||kvm_vcpu_trap_get_class (vcpu) == ESR_ELx_EC_CP15_32)) {int ret =__vgic_v3_perform_cpuif_access (vcpu);if (ret ==1 ) {if (__skip_instr (vcpu)) - goto again; +return true;else - exit_code =ARM_EXCEPTION_TRAP ; + *exit_code =ARM_EXCEPTION_TRAP ; } - -/* 0 falls through to be handled out of EL2 */ } +/* Return to the host kernel and handle the exit */ +return false; +} + +int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu) +{ +struct kvm_cpu_context *host_ctxt; +struct kvm_cpu_context *guest_ctxt; +bool fp_enabled; +u64 exit_code; + + vcpu =kern_hyp_va (vcpu); + + host_ctxt =kern_hyp_va (vcpu->arch.host_cpu_context); + host_ctxt->__hyp_running_vcpu = vcpu; + guest_ctxt = &vcpu->arch.ctxt; + +__sysreg_save_host_state (host_ctxt); + +__activate_traps (vcpu); +__activate_vm (vcpu); + +__vgic_restore_state (vcpu); +__timer_enable_traps (vcpu); + +/* +* We must restore the 32-bit state before the sysregs, thanks +* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). +*/ +__sysreg32_restore_state (vcpu); +__sysreg_restore_guest_state (guest_ctxt); +__debug_switch_to_guest (vcpu); + +do { +/* Jump in the fire! */ + exit_code =__guest_enter (vcpu, host_ctxt); + +/* And we're baaack! */ + }while (fixup_guest_exit (vcpu, &exit_code)); +if (cpus_have_const_cap (ARM64_HARDEN_BP_POST_GUEST_EXIT )) {u32 midr =read_cpuid_id ();
Signature · 1 line
2.14.2
PATCH v5 11/40 KVM: arm64: Improve debug register save/restore flow
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
Instead of having multiple calls from the world switch path to the debug logic, each figuring out if the dirty bit is set and if we should save/restore the debug registers, let's just provide two hooks to the debug save/restore functionality, one for switching to the guest context, and one for switching to the host context, and we get the benefit of only having to evaluate the dirty flag once on each path, plus we give the compiler some more room to inline some of this functionality.
---
Notes:
Changes since v1:
- Remove leading underscores from local variables
arch/arm64/include/asm/kvm_hyp.h | 10 ++----- arch/arm64/kvm/hyp/debug-sr.c | 56 +++++++++++++++++++++++++++------------- arch/arm64/kvm/hyp/switch.c | 6 ++--- 3 files changed, 42 insertions(+), 30 deletions(-)
arch/arm64/include/asm/kvm_hyp.h +2 -8
@@ -138,14 +138,8 @@ void __sysreg_restore_guest_state(struct kvm_cpu_context *ctxt);void __sysreg32_save_state (struct kvm_vcpu *vcpu);void __sysreg32_restore_state (struct kvm_vcpu *vcpu); -void __debug_save_state (struct kvm_vcpu *vcpu, -struct kvm_guest_debug_arch *dbg, -struct kvm_cpu_context *ctxt); -void __debug_restore_state (struct kvm_vcpu *vcpu, -struct kvm_guest_debug_arch *dbg, -struct kvm_cpu_context *ctxt); -void __debug_cond_save_host_state (struct kvm_vcpu *vcpu); -void __debug_cond_restore_host_state (struct kvm_vcpu *vcpu); +void __debug_switch_to_guest (struct kvm_vcpu *vcpu); +void __debug_switch_to_host (struct kvm_vcpu *vcpu);void __fpsimd_save_state (struct user_fpsimd_state *fp_regs);void __fpsimd_restore_state (struct user_fpsimd_state *fp_regs);
arch/arm64/kvm/hyp/debug-sr.c +38 -18
95 lines not on this page · raw message
arch/arm64/kvm/hyp/switch.c +2 -4
@@ -305,7 +305,6 @@ int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu) guest_ctxt = &vcpu->arch.ctxt;__sysreg_save_host_state (host_ctxt); -__debug_cond_save_host_state (vcpu);__activate_traps (vcpu);__activate_vm (vcpu);
@@ -319,7 +318,7 @@ int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu)*/ __sysreg32_restore_state (vcpu);__sysreg_restore_guest_state (guest_ctxt); -__debug_restore_state (vcpu,kern_hyp_va (vcpu->arch.debug_ptr), guest_ctxt); +__debug_switch_to_guest (vcpu);/* Jump in the fire! */ again:
@@ -416,12 +415,11 @@ int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu)__fpsimd_restore_state (&host_ctxt->gp_regs.fp_regs); } -__debug_save_state (vcpu,kern_hyp_va (vcpu->arch.debug_ptr), guest_ctxt);/* * This must come after restoring the host sysregs, since a non-VHE * system may enable SPE here and make use of the TTBRs. */ -__debug_cond_restore_host_state (vcpu); +__debug_switch_to_host (vcpu);return exit_code; }
Signature · 1 line
2.14.2
PATCH v5 14/40 KVM: arm64: Remove kern_hyp_va() use in VHE switch function
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
VHE kernels run completely in EL2 and therefore don't have a notion of kernel and hyp addresses, they are all just kernel addresses. Therefore don't call kern_hyp_va() in the VHE switch function.
--- arch/arm64/kvm/hyp/switch.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
arch/arm64/kvm/hyp/switch.c +1 -3
@@ -370,9 +370,7 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)bool fp_enabled;u64 exit_code; - vcpu =kern_hyp_va (vcpu); - - host_ctxt =kern_hyp_va (vcpu->arch.host_cpu_context); + host_ctxt = vcpu->arch.host_cpu_context; host_ctxt->__hyp_running_vcpu = vcpu; guest_ctxt = &vcpu->arch.ctxt;
Signature · 1 line
2.14.2
PATCH v5 13/40 KVM: arm64: Introduce VHE-specific kvm_vcpu_run
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
So far this is mostly (see below) a copy of the legacy non-VHE switch function, but we will start reworking these functions in separate directions to work on VHE and non-VHE in the most optimal way in later patches.
The only difference after this patch between the VHE and non-VHE run functions is that we omit the branch-predictor variant-2 hardening for QC Falkor CPUs, because this workaround is specific to a series of non-VHE ARMv8.0 CPUs.
---
Notes:
Changes since v4:
- Unified has_vhe() conditional calls in kvm_arch_vcpu_ioctl_run
- Added isb() on exit path of VHE-specific kvm_vcpu_run(), because otherwise 32-bit guests can crash the system on reentry to the guest, because writes to FPEXC32_EL2 will cause a trap at EL2 which leads to a hyp panic. This can be observed on the model where writing FPEN to CPACR_EL1 on guest exit doesn't take effect prior to entering the guest again.
Changes since v3:
- Added BUG() to 32-bit ARM VHE run function
- Omitted QC Falkor BP Hardening functionality from VHE-specific function
Changes since v2:
- Reworded commit message
Changes since v1:
- Rename kvm_vcpu_run to kvm_vcpu_run_vhe and rename __kvm_vcpu_run to __kvm_vcpu_run_nvhe
- Removed stray whitespace line
arch/arm/include/asm/kvm_asm.h | 5 ++- arch/arm/kvm/hyp/switch.c | 2 +- arch/arm64/include/asm/kvm_asm.h | 4 ++- arch/arm64/include/asm/kvm_host.h | 7 +++++ arch/arm64/kvm/hyp/switch.c | 66 ++++++++++++++++++++++++++++++++++++++- virt/kvm/arm/arm.c | 12 ++++--- 6 files changed, 87 insertions(+), 9 deletions(-)
arch/arm/include/asm/kvm_asm.h +4 -1
@@ -70,7 +70,10 @@ extern void __kvm_tlb_flush_local_vmid(struct kvm_vcpu *vcpu);extern void __kvm_timer_set_cntvoff (u32 cntvoff_low,u32 cntvoff_high); -extern int __kvm_vcpu_run (struct kvm_vcpu *vcpu); +/* no VHE on 32-bit :( */ +static inline int kvm_vcpu_run_vhe (struct kvm_vcpu *vcpu) {BUG ();return 0 ; } + +extern int __kvm_vcpu_run_nvhe (struct kvm_vcpu *vcpu);extern void __init_stage2_translation (void );
arch/arm/kvm/hyp/switch.c +1 -1
@@ -154,7 +154,7 @@ static bool __hyp_text __populate_fault_info(struct kvm_vcpu *vcpu)return true; } -int __hyp_text __kvm_vcpu_run(struct kvm_vcpu *vcpu) +int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu) {struct kvm_cpu_context *host_ctxt;struct kvm_cpu_context *guest_ctxt;
arch/arm64/include/asm/kvm_asm.h +3 -1
@@ -58,7 +58,9 @@ extern void __kvm_tlb_flush_local_vmid(struct kvm_vcpu *vcpu);extern void __kvm_timer_set_cntvoff (u32 cntvoff_low,u32 cntvoff_high); -extern int __kvm_vcpu_run (struct kvm_vcpu *vcpu); +extern int kvm_vcpu_run_vhe (struct kvm_vcpu *vcpu); + +extern int __kvm_vcpu_run_nvhe (struct kvm_vcpu *vcpu);extern u64 __vgic_v3_get_ich_vtr_el2 (void );extern u64 __vgic_v3_read_vmcr (void );
arch/arm64/include/asm/kvm_host.h +7 -0
@@ -428,6 +428,13 @@ static inline void kvm_arm_vhe_guest_enter(void)static inline void kvm_arm_vhe_guest_exit (void ) {local_daif_restore (DAIF_PROCCTX_NOIRQ ); + +/* +* When we exit from the guest we change a number of CPU configuration +* parameters, such as traps. Make sure these changes take effect +* before running the host or additional guests. +*/ +isb (); }static inline bool kvm_arm_harden_branch_predictor (void )
arch/arm64/kvm/hyp/switch.c +65 -1
72 lines not on this page · raw message
virt/kvm/arm/arm.c +7 -5
@@ -733,13 +733,15 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)*/ trace_kvm_entry (*vcpu_pc (vcpu));guest_enter_irqoff (); -if (has_vhe ()) -kvm_arm_vhe_guest_enter (); - - ret =kvm_call_hyp (__kvm_vcpu_run, vcpu); -if (has_vhe ()) +if (has_vhe ()) { +kvm_arm_vhe_guest_enter (); + ret =kvm_vcpu_run_vhe (vcpu);kvm_arm_vhe_guest_exit (); + }else { + ret =kvm_call_hyp (__kvm_vcpu_run_nvhe, vcpu); + } + vcpu->mode =OUTSIDE_GUEST_MODE ; vcpu->stat.exits++;/*
Signature · 1 line
2.14.2
PATCH v5 15/40 KVM: arm64: Don't deactivate VM on VHE systems
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
There is no need to reset the VTTBR to zero when exiting the guest on VHE systems. VHE systems don't use stage 2 translations for the EL2&0 translation regime used by the host.
---
Notes:
Changes since v1:
- Changed __activate_vm to take a kvm pointer
- No longer adding inline attributes to functions
arch/arm64/kvm/hyp/switch.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
arch/arm64/kvm/hyp/switch.c +3 -5
@@ -156,9 +156,8 @@ static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu)write_sysreg (0 , pmuserenr_el0); } -static void __hyp_text __activate_vm(struct kvm_vcpu *vcpu) +static void __hyp_text __activate_vm(struct kvm *kvm) { -struct kvm *kvm =kern_hyp_va (vcpu->kvm);write_sysreg (kvm->arch.vttbr, vttbr_el2); }
@@ -377,7 +376,7 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__sysreg_save_host_state (host_ctxt);__activate_traps (vcpu); -__activate_vm (vcpu); +__activate_vm (vcpu->kvm);__vgic_restore_state (vcpu);__timer_enable_traps (vcpu);
@@ -405,7 +404,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__vgic_save_state (vcpu);__deactivate_traps (vcpu); -__deactivate_vm (vcpu);__sysreg_restore_host_state (host_ctxt);
@@ -440,7 +438,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)__sysreg_save_host_state (host_ctxt);__activate_traps (vcpu); -__activate_vm (vcpu); +__activate_vm (kern_hyp_va (vcpu->kvm));__vgic_restore_state (vcpu);__timer_enable_traps (vcpu);
Signature · 1 line
2.14.2
PATCH v5 16/40 KVM: arm64: Remove noop calls to timer save/restore from VHE switch
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
The VHE switch function calls __timer_enable_traps and __timer_disable_traps which don't do anything on VHE systems. Therefore, simply remove these calls from the VHE switch function and make the functions non-conditional as they are now only called from the non-VHE switch path.
---
Notes:
Changes since v2:
- Added comment explaining the timer enable/disable functions are for !VHE only.
arch/arm64/kvm/hyp/switch.c | 2 -- virt/kvm/arm/hyp/timer-sr.c | 44 ++++++++++++++++++++++---------------------- 2 files changed, 22 insertions(+), 24 deletions(-)
arch/arm64/kvm/hyp/switch.c +0 -2
@@ -379,7 +379,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__activate_vm (vcpu->kvm);__vgic_restore_state (vcpu); -__timer_enable_traps (vcpu);/* * We must restore the 32-bit state before the sysregs, thanks
@@ -400,7 +399,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__sysreg_save_guest_state (guest_ctxt);__sysreg32_save_state (vcpu); -__timer_disable_traps (vcpu);__vgic_save_state (vcpu);__deactivate_traps (vcpu);
virt/kvm/arm/hyp/timer-sr.c +22 -22
56 lines not on this page · raw message
Signature · 1 line
2.14.2
PATCH v5 17/40 KVM: arm64: Move userspace system registers into separate function
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
There's a semantic difference between the EL1 registers that control operation of a kernel running in EL1 and EL1 registers that only control userspace execution in EL0. Since we can defer saving/restoring the latter, move them into their own function.
The ARMv8 ARM (ARM DDI 0487C.a) Section D10.2.1 recommends that ACTLR_EL1 has no effect on the processor when running the VHE host, and we can therefore move this register into the EL1 state which is only saved/restored on vcpu_put/load for a VHE host.
We also take this chance to rename the function saving/restoring the remaining system register to make it clear this function deals with the EL1 system registers.
---
Notes:
Changes since v4:
- Clarified rationale for deferring ACTLR_EL1 in the commit message.
Changes since v3:
- Correct the comment about ACTLR_EL1 and adjust commit text.
Changes since v2:
- Save restore ACTLR_EL1 as part of the EL1 registers state instead of the user register state, as ACTLR_EL1 can't affect the host's execution on VHE systems.
Changes since v1:
- Added comment about sp_el0 to common save sysreg save/restore functions
arch/arm64/kvm/hyp/sysreg-sr.c | 48 ++++++++++++++++++++++++++++++------------ 1 file changed, 35 insertions(+), 13 deletions(-)
arch/arm64/kvm/hyp/sysreg-sr.c +35 -13
@@ -28,24 +28,33 @@ static void __hyp_text __sysreg_do_nothing(struct kvm_cpu_context *ctxt) { }/* * Non-VHE: Both host and guest must save everything. * -* VHE: Host must save tpidr*_el0, actlr_el1, mdscr_el1, sp_el0, +* VHE: Host must save tpidr*_el0, mdscr_el1, sp_el0, * and guest must save everything. */ static void __hyp_text __sysreg_save_common_state(struct kvm_cpu_context *ctxt) { - ctxt->sys_regs[ACTLR_EL1 ] =read_sysreg (actlr_el1); - ctxt->sys_regs[TPIDR_EL0 ] =read_sysreg (tpidr_el0); - ctxt->sys_regs[TPIDRRO_EL0 ] =read_sysreg (tpidrro_el0); ctxt->sys_regs[MDSCR_EL1 ] =read_sysreg (mdscr_el1); + +/* +* The host arm64 Linux uses sp_el0 to point to 'current' and it must +* therefore be saved/restored on every entry/exit to/from the guest. +*/ ctxt->gp_regs.regs.sp =read_sysreg (sp_el0); } -static void __hyp_text __sysreg_save_state(struct kvm_cpu_context *ctxt) +static void __hyp_text __sysreg_save_user_state(struct kvm_cpu_context *ctxt) +{ + ctxt->sys_regs[TPIDR_EL0 ] =read_sysreg (tpidr_el0); + ctxt->sys_regs[TPIDRRO_EL0 ] =read_sysreg (tpidrro_el0); +} + +static void __hyp_text __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) { ctxt->sys_regs[MPIDR_EL1 ] =read_sysreg (vmpidr_el2); ctxt->sys_regs[CSSELR_EL1 ] =read_sysreg (csselr_el1); ctxt->sys_regs[SCTLR_EL1 ] =read_sysreg_el1 (sctlr); + ctxt->sys_regs[ACTLR_EL1 ] =read_sysreg (actlr_el1); ctxt->sys_regs[CPACR_EL1 ] =read_sysreg_el1 (cpacr); ctxt->sys_regs[TTBR0_EL1 ] =read_sysreg_el1 (ttbr0); ctxt->sys_regs[TTBR1_EL1 ] =read_sysreg_el1 (ttbr1);
@@ -73,35 +82,46 @@ static void __hyp_text __sysreg_save_state(struct kvm_cpu_context *ctxt) } static hyp_alternate_select(__sysreg_call_save_host_state, - __sysreg_save_state, __sysreg_do_nothing, + __sysreg_save_el1_state, __sysreg_do_nothing, ARM64_HAS_VIRT_HOST_EXTN); void __hyp_text __sysreg_save_host_state(struct kvm_cpu_context *ctxt) {__sysreg_call_save_host_state ()(ctxt);__sysreg_save_common_state (ctxt); +__sysreg_save_user_state (ctxt); } void __hyp_text __sysreg_save_guest_state(struct kvm_cpu_context *ctxt) { -__sysreg_save_state (ctxt); +__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt); +__sysreg_save_user_state (ctxt); } static void __hyp_text __sysreg_restore_common_state(struct kvm_cpu_context *ctxt) { -write_sysreg (ctxt->sys_regs[ACTLR_EL1 ], actlr_el1); -write_sysreg (ctxt->sys_regs[TPIDR_EL0 ], tpidr_el0); -write_sysreg (ctxt->sys_regs[TPIDRRO_EL0 ], tpidrro_el0);write_sysreg (ctxt->sys_regs[MDSCR_EL1 ], mdscr_el1); + +/* +* The host arm64 Linux uses sp_el0 to point to 'current' and it must +* therefore be saved/restored on every entry/exit to/from the guest. +*/ write_sysreg (ctxt->gp_regs.regs.sp, sp_el0); } -static void __hyp_text __sysreg_restore_state(struct kvm_cpu_context *ctxt) +static void __hyp_text __sysreg_restore_user_state(struct kvm_cpu_context *ctxt) +{ +write_sysreg (ctxt->sys_regs[TPIDR_EL0 ], tpidr_el0); +write_sysreg (ctxt->sys_regs[TPIDRRO_EL0 ], tpidrro_el0); +} + +static void __hyp_text __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt) {write_sysreg (ctxt->sys_regs[MPIDR_EL1 ], vmpidr_el2);write_sysreg (ctxt->sys_regs[CSSELR_EL1 ], csselr_el1);write_sysreg_el1 (ctxt->sys_regs[SCTLR_EL1 ], sctlr); +write_sysreg (ctxt->sys_regs[ACTLR_EL1 ], actlr_el1);write_sysreg_el1 (ctxt->sys_regs[CPACR_EL1 ], cpacr);write_sysreg_el1 (ctxt->sys_regs[TTBR0_EL1 ], ttbr0);write_sysreg_el1 (ctxt->sys_regs[TTBR1_EL1 ], ttbr1);
@@ -129,19 +149,21 @@ static void __hyp_text __sysreg_restore_state(struct kvm_cpu_context *ctxt) } static hyp_alternate_select(__sysreg_call_restore_host_state, - __sysreg_restore_state, __sysreg_do_nothing, + __sysreg_restore_el1_state, __sysreg_do_nothing, ARM64_HAS_VIRT_HOST_EXTN); void __hyp_text __sysreg_restore_host_state(struct kvm_cpu_context *ctxt) {__sysreg_call_restore_host_state ()(ctxt);__sysreg_restore_common_state (ctxt); +__sysreg_restore_user_state (ctxt); } void __hyp_text __sysreg_restore_guest_state(struct kvm_cpu_context *ctxt) { -__sysreg_restore_state (ctxt); +__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt); +__sysreg_restore_user_state (ctxt); } void __hyp_text __sysreg32_save_state(struct kvm_vcpu *vcpu)
Signature · 1 line
2.14.2
PATCH v5 18/40 KVM: arm64: Rewrite sysreg alternatives to static keys
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
As we are about to move calls around in the sysreg save/restore logic, let's first rewrite the alternative function callers, because it is going to make the next patches much easier to read.
--- arch/arm64/kvm/hyp/sysreg-sr.c | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-)
arch/arm64/kvm/hyp/sysreg-sr.c +4 -13
@@ -22,9 +22,6 @@#include <asm/kvm_emulate.h> #include <asm/kvm_hyp.h> -/* Yes, this does nothing, on purpose */ -static void __hyp_text __sysreg_do_nothing(struct kvm_cpu_context *ctxt) { } -/* * Non-VHE: Both host and guest must save everything. *
@@ -81,13 +78,10 @@ static void __hyp_text __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) ctxt->sys_regs[DISR_EL1 ] =read_sysreg_s (SYS_VDISR_EL2 ); } -static hyp_alternate_select(__sysreg_call_save_host_state, - __sysreg_save_el1_state, __sysreg_do_nothing, - ARM64_HAS_VIRT_HOST_EXTN); - void __hyp_text __sysreg_save_host_state(struct kvm_cpu_context *ctxt) { -__sysreg_call_save_host_state ()(ctxt); +if (!has_vhe ()) +__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt);__sysreg_save_user_state (ctxt); }
@@ -148,13 +142,10 @@ static void __hyp_text __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt)write_sysreg_s (ctxt->sys_regs[DISR_EL1 ],SYS_VDISR_EL2 ); } -static hyp_alternate_select(__sysreg_call_restore_host_state, - __sysreg_restore_el1_state, __sysreg_do_nothing, - ARM64_HAS_VIRT_HOST_EXTN); - void __hyp_text __sysreg_restore_host_state(struct kvm_cpu_context *ctxt) { -__sysreg_call_restore_host_state ()(ctxt); +if (!has_vhe ()) +__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt);__sysreg_restore_user_state (ctxt); }
Signature · 1 line
2.14.2
PATCH v5 19/40 KVM: arm64: Introduce separate VHE/non-VHE sysreg save/restore functions
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
As we are about to handle system registers quite differently between VHE and non-VHE systems. In preparation for that, we need to split some of the handling functions between VHE and non-VHE functionality.
For now, we simply copy the non-VHE functions, but we do change the use of static keys for VHE and non-VHE functionality now that we have separate functions.
--- arch/arm64/include/asm/kvm_hyp.h | 12 ++++++++---- arch/arm64/kvm/hyp/switch.c | 20 ++++++++++---------- arch/arm64/kvm/hyp/sysreg-sr.c | 40 ++++++++++++++++++++++++++++++++-------- 3 files changed, 50 insertions(+), 22 deletions(-)
arch/arm64/include/asm/kvm_hyp.h +8 -4
@@ -131,10 +131,14 @@ int __vgic_v3_perform_cpuif_access(struct kvm_vcpu *vcpu);void __timer_enable_traps (struct kvm_vcpu *vcpu);void __timer_disable_traps (struct kvm_vcpu *vcpu); -void __sysreg_save_host_state (struct kvm_cpu_context *ctxt); -void __sysreg_restore_host_state (struct kvm_cpu_context *ctxt); -void __sysreg_save_guest_state (struct kvm_cpu_context *ctxt); -void __sysreg_restore_guest_state (struct kvm_cpu_context *ctxt); +void __sysreg_save_host_state_nvhe (struct kvm_cpu_context *ctxt); +void __sysreg_restore_host_state_nvhe (struct kvm_cpu_context *ctxt); +void __sysreg_save_guest_state_nvhe (struct kvm_cpu_context *ctxt); +void __sysreg_restore_guest_state_nvhe (struct kvm_cpu_context *ctxt); +void sysreg_save_host_state_vhe (struct kvm_cpu_context *ctxt); +void sysreg_restore_host_state_vhe (struct kvm_cpu_context *ctxt); +void sysreg_save_guest_state_vhe (struct kvm_cpu_context *ctxt); +void sysreg_restore_guest_state_vhe (struct kvm_cpu_context *ctxt);void __sysreg32_save_state (struct kvm_vcpu *vcpu);void __sysreg32_restore_state (struct kvm_vcpu *vcpu);
arch/arm64/kvm/hyp/switch.c +10 -10
@@ -373,7 +373,7 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu) host_ctxt->__hyp_running_vcpu = vcpu; guest_ctxt = &vcpu->arch.ctxt; -__sysreg_save_host_state (host_ctxt); +sysreg_save_host_state_vhe (host_ctxt);__activate_traps (vcpu);__activate_vm (vcpu->kvm);
@@ -385,7 +385,7 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). */ __sysreg32_restore_state (vcpu); -__sysreg_restore_guest_state (guest_ctxt); +sysreg_restore_guest_state_vhe (guest_ctxt);__debug_switch_to_guest (vcpu); do {
@@ -397,13 +397,13 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu) fp_enabled =__fpsimd_enabled (); -__sysreg_save_guest_state (guest_ctxt); +sysreg_save_guest_state_vhe (guest_ctxt);__sysreg32_save_state (vcpu);__vgic_save_state (vcpu);__deactivate_traps (vcpu); -__sysreg_restore_host_state (host_ctxt); +sysreg_restore_host_state_vhe (host_ctxt);if (fp_enabled) {__fpsimd_save_state (&guest_ctxt->gp_regs.fp_regs);
@@ -433,7 +433,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu) host_ctxt->__hyp_running_vcpu = vcpu; guest_ctxt = &vcpu->arch.ctxt; -__sysreg_save_host_state (host_ctxt); +__sysreg_save_host_state_nvhe (host_ctxt);__activate_traps (vcpu);__activate_vm (kern_hyp_va (vcpu->kvm));
@@ -446,7 +446,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). */ __sysreg32_restore_state (vcpu); -__sysreg_restore_guest_state (guest_ctxt); +__sysreg_restore_guest_state_nvhe (guest_ctxt);__debug_switch_to_guest (vcpu); do {
@@ -468,7 +468,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu) fp_enabled =__fpsimd_enabled (); -__sysreg_save_guest_state (guest_ctxt); +__sysreg_save_guest_state_nvhe (guest_ctxt);__sysreg32_save_state (vcpu);__timer_disable_traps (vcpu);__vgic_save_state (vcpu);
@@ -476,7 +476,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)__deactivate_traps (vcpu);__deactivate_vm (vcpu); -__sysreg_restore_host_state (host_ctxt); +__sysreg_restore_host_state_nvhe (host_ctxt);if (fp_enabled) {__fpsimd_save_state (&guest_ctxt->gp_regs.fp_regs);
@@ -506,7 +506,7 @@ static void __hyp_text __hyp_call_panic_nvhe(u64 spsr, u64 elr, u64 par,__timer_disable_traps (vcpu);__deactivate_traps (vcpu);__deactivate_vm (vcpu); -__sysreg_restore_host_state (__host_ctxt); +__sysreg_restore_host_state_nvhe (__host_ctxt); }/*
@@ -529,7 +529,7 @@ static void __hyp_call_panic_vhe(u64 spsr, u64 elr, u64 par, vcpu = host_ctxt->__hyp_running_vcpu;__deactivate_traps (vcpu); -__sysreg_restore_host_state (host_ctxt); +sysreg_restore_host_state_vhe (host_ctxt); panic(__hyp_panic_string, spsr, elr,
arch/arm64/kvm/hyp/sysreg-sr.c +32 -8
@@ -78,15 +78,27 @@ static void __hyp_text __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) ctxt->sys_regs[DISR_EL1 ] =read_sysreg_s (SYS_VDISR_EL2 ); } -void __hyp_text __sysreg_save_host_state(struct kvm_cpu_context *ctxt) +void __hyp_text __sysreg_save_host_state_nvhe(struct kvm_cpu_context *ctxt) +{ +__sysreg_save_el1_state (ctxt); +__sysreg_save_common_state (ctxt); +__sysreg_save_user_state (ctxt); +} + +void __hyp_text __sysreg_save_guest_state_nvhe(struct kvm_cpu_context *ctxt) +{ +__sysreg_save_el1_state (ctxt); +__sysreg_save_common_state (ctxt); +__sysreg_save_user_state (ctxt); +} + +void sysreg_save_host_state_vhe (struct kvm_cpu_context *ctxt) { -if (!has_vhe ()) -__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt);__sysreg_save_user_state (ctxt); } -void __hyp_text __sysreg_save_guest_state(struct kvm_cpu_context *ctxt) +void sysreg_save_guest_state_vhe (struct kvm_cpu_context *ctxt) {__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt);
@@ -142,15 +154,27 @@ static void __hyp_text __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt)write_sysreg_s (ctxt->sys_regs[DISR_EL1 ],SYS_VDISR_EL2 ); } -void __hyp_text __sysreg_restore_host_state(struct kvm_cpu_context *ctxt) +void __hyp_text __sysreg_restore_host_state_nvhe(struct kvm_cpu_context *ctxt) +{ +__sysreg_restore_el1_state (ctxt); +__sysreg_restore_common_state (ctxt); +__sysreg_restore_user_state (ctxt); +} + +void __hyp_text __sysreg_restore_guest_state_nvhe(struct kvm_cpu_context *ctxt) +{ +__sysreg_restore_el1_state (ctxt); +__sysreg_restore_common_state (ctxt); +__sysreg_restore_user_state (ctxt); +} + +void sysreg_restore_host_state_vhe (struct kvm_cpu_context *ctxt) { -if (!has_vhe ()) -__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt);__sysreg_restore_user_state (ctxt); } -void __hyp_text __sysreg_restore_guest_state(struct kvm_cpu_context *ctxt) +void sysreg_restore_guest_state_vhe (struct kvm_cpu_context *ctxt) {__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt);
Signature · 1 line
2.14.2
PATCH v5 20/40 KVM: arm/arm64: Remove leftover comment from kvm_vcpu_run_vhe
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
The comment only applied to SPE on non-VHE systems, so we simply remove it.
--- arch/arm64/kvm/hyp/switch.c | 4 ---- 1 file changed, 4 deletions(-)
arch/arm64/kvm/hyp/switch.c +0 -4
@@ -410,10 +410,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__fpsimd_restore_state (&host_ctxt->gp_regs.fp_regs); } -/* -* This must come after restoring the host sysregs, since a non-VHE -* system may enable SPE here and make use of the TTBRs. -*/ __debug_switch_to_host (vcpu);return exit_code;
Signature · 1 line
2.14.2
PATCH v5 21/40 KVM: arm64: Unify non-VHE host/guest sysreg save and restore functions
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
There is no need to have multiple identical functions with different names for saving host and guest state. When saving and restoring state for the host and guest, the state is the same for both contexts, and that's why we have the kvm_cpu_context structure. Delete one version and rename the other into simply save/restore.
--- arch/arm64/include/asm/kvm_hyp.h | 6 ++---- arch/arm64/kvm/hyp/switch.c | 10 +++++----- arch/arm64/kvm/hyp/sysreg-sr.c | 18 ++---------------- 3 files changed, 9 insertions(+), 25 deletions(-)
arch/arm64/include/asm/kvm_hyp.h +2 -4
@@ -131,10 +131,8 @@ int __vgic_v3_perform_cpuif_access(struct kvm_vcpu *vcpu);void __timer_enable_traps (struct kvm_vcpu *vcpu);void __timer_disable_traps (struct kvm_vcpu *vcpu); -void __sysreg_save_host_state_nvhe (struct kvm_cpu_context *ctxt); -void __sysreg_restore_host_state_nvhe (struct kvm_cpu_context *ctxt); -void __sysreg_save_guest_state_nvhe (struct kvm_cpu_context *ctxt); -void __sysreg_restore_guest_state_nvhe (struct kvm_cpu_context *ctxt); +void __sysreg_save_state_nvhe (struct kvm_cpu_context *ctxt); +void __sysreg_restore_state_nvhe (struct kvm_cpu_context *ctxt);void sysreg_save_host_state_vhe (struct kvm_cpu_context *ctxt);void sysreg_restore_host_state_vhe (struct kvm_cpu_context *ctxt);void sysreg_save_guest_state_vhe (struct kvm_cpu_context *ctxt);
arch/arm64/kvm/hyp/switch.c +5 -5
@@ -429,7 +429,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu) host_ctxt->__hyp_running_vcpu = vcpu; guest_ctxt = &vcpu->arch.ctxt; -__sysreg_save_host_state_nvhe (host_ctxt); +__sysreg_save_state_nvhe (host_ctxt);__activate_traps (vcpu);__activate_vm (kern_hyp_va (vcpu->kvm));
@@ -442,7 +442,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). */ __sysreg32_restore_state (vcpu); -__sysreg_restore_guest_state_nvhe (guest_ctxt); +__sysreg_restore_state_nvhe (guest_ctxt);__debug_switch_to_guest (vcpu); do {
@@ -464,7 +464,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu) fp_enabled =__fpsimd_enabled (); -__sysreg_save_guest_state_nvhe (guest_ctxt); +__sysreg_save_state_nvhe (guest_ctxt);__sysreg32_save_state (vcpu);__timer_disable_traps (vcpu);__vgic_save_state (vcpu);
@@ -472,7 +472,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)__deactivate_traps (vcpu);__deactivate_vm (vcpu); -__sysreg_restore_host_state_nvhe (host_ctxt); +__sysreg_restore_state_nvhe (host_ctxt);if (fp_enabled) {__fpsimd_save_state (&guest_ctxt->gp_regs.fp_regs);
@@ -502,7 +502,7 @@ static void __hyp_text __hyp_call_panic_nvhe(u64 spsr, u64 elr, u64 par,__timer_disable_traps (vcpu);__deactivate_traps (vcpu);__deactivate_vm (vcpu); -__sysreg_restore_host_state_nvhe (__host_ctxt); +__sysreg_restore_state_nvhe (__host_ctxt); }/*
arch/arm64/kvm/hyp/sysreg-sr.c +2 -16
@@ -78,14 +78,7 @@ static void __hyp_text __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) ctxt->sys_regs[DISR_EL1 ] =read_sysreg_s (SYS_VDISR_EL2 ); } -void __hyp_text __sysreg_save_host_state_nvhe(struct kvm_cpu_context *ctxt) -{ -__sysreg_save_el1_state (ctxt); -__sysreg_save_common_state (ctxt); -__sysreg_save_user_state (ctxt); -} - -void __hyp_text __sysreg_save_guest_state_nvhe(struct kvm_cpu_context *ctxt) +void __hyp_text __sysreg_save_state_nvhe(struct kvm_cpu_context *ctxt) {__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt);
@@ -154,14 +147,7 @@ static void __hyp_text __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt)write_sysreg_s (ctxt->sys_regs[DISR_EL1 ],SYS_VDISR_EL2 ); } -void __hyp_text __sysreg_restore_host_state_nvhe(struct kvm_cpu_context *ctxt) -{ -__sysreg_restore_el1_state (ctxt); -__sysreg_restore_common_state (ctxt); -__sysreg_restore_user_state (ctxt); -} - -void __hyp_text __sysreg_restore_guest_state_nvhe(struct kvm_cpu_context *ctxt) +void __hyp_text __sysreg_restore_state_nvhe(struct kvm_cpu_context *ctxt) {__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt);
Signature · 1 line
2.14.2
PATCH v5 22/40 KVM: arm64: Don't save the host ELR_EL2 and SPSR_EL2 on VHE systems
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
On non-VHE systems we need to save the ELR_EL2 and SPSR_EL2 so that we can return to the host in EL1 in the same state and location where we issued a hypercall to EL2, but on VHE ELR_EL2 and SPSR_EL2 are not useful because we never enter a guest as a result of an exception entry that would be directly handled by KVM. The kernel entry code already saves ELR_EL1/SPSR_EL1 on exception entry, which is enough. Therefore, factor out these registers into separate save/restore functions, making it easy to exclude them from the VHE world-switch path later on.
--- arch/arm64/kvm/hyp/sysreg-sr.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
arch/arm64/kvm/hyp/sysreg-sr.c +13 -0
@@ -71,6 +71,10 @@ static void __hyp_text __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) ctxt->gp_regs.sp_el1 =read_sysreg (sp_el1); ctxt->gp_regs.elr_el1 =read_sysreg_el1 (elr); ctxt->gp_regs.spsr[KVM_SPSR_EL1 ]=read_sysreg_el1 (spsr); +} + +static void __hyp_text __sysreg_save_el2_return_state(struct kvm_cpu_context *ctxt) +{ ctxt->gp_regs.regs.pc =read_sysreg_el2 (elr); ctxt->gp_regs.regs.pstate =read_sysreg_el2 (spsr);
@@ -83,6 +87,7 @@ void __hyp_text __sysreg_save_state_nvhe(struct kvm_cpu_context *ctxt)__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt);__sysreg_save_user_state (ctxt); +__sysreg_save_el2_return_state (ctxt); }void sysreg_save_host_state_vhe (struct kvm_cpu_context *ctxt)
@@ -96,6 +101,7 @@ void sysreg_save_guest_state_vhe(struct kvm_cpu_context *ctxt)__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt);__sysreg_save_user_state (ctxt); +__sysreg_save_el2_return_state (ctxt); } static void __hyp_text __sysreg_restore_common_state(struct kvm_cpu_context *ctxt)
@@ -140,6 +146,11 @@ static void __hyp_text __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt)write_sysreg (ctxt->gp_regs.sp_el1, sp_el1);write_sysreg_el1 (ctxt->gp_regs.elr_el1, elr);write_sysreg_el1 (ctxt->gp_regs.spsr[KVM_SPSR_EL1 ],spsr); +} + +static void __hyp_text +__sysreg_restore_el2_return_state (struct kvm_cpu_context *ctxt) +{write_sysreg_el2 (ctxt->gp_regs.regs.pc, elr);write_sysreg_el2 (ctxt->gp_regs.regs.pstate, spsr);
@@ -152,6 +163,7 @@ void __hyp_text __sysreg_restore_state_nvhe(struct kvm_cpu_context *ctxt)__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt);__sysreg_restore_user_state (ctxt); +__sysreg_restore_el2_return_state (ctxt); }void sysreg_restore_host_state_vhe (struct kvm_cpu_context *ctxt)
@@ -165,6 +177,7 @@ void sysreg_restore_guest_state_vhe(struct kvm_cpu_context *ctxt)__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt);__sysreg_restore_user_state (ctxt); +__sysreg_restore_el2_return_state (ctxt); } void __hyp_text __sysreg32_save_state(struct kvm_vcpu *vcpu)
Signature · 1 line
2.14.2
PATCH v5 23/40 KVM: arm64: Change 32-bit handling of VM system registers
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
We currently handle 32-bit accesses to trapped VM system registers using the 32-bit index into the coproc array on the vcpu structure, which is a union of the coproc array and the sysreg array.
Since all the 32-bit coproc indices are created to correspond to the architectural mapping between 64-bit system registers and 32-bit coprocessor registers, and because the AArch64 system registers are the double in size of the AArch32 coprocessor registers, we can always find the system register entry that we must update by dividing the 32-bit coproc index by 2.
This is going to make our lives much easier when we have to start accessing system registers that use deferred save/restore and might have to be read directly from the physical CPU.
--- arch/arm64/include/asm/kvm_host.h | 8 -------- arch/arm64/kvm/sys_regs.c | 20 +++++++++++++++----- 2 files changed, 15 insertions(+), 13 deletions(-)
arch/arm64/include/asm/kvm_host.h +0 -8
@@ -295,14 +295,6 @@ struct kvm_vcpu_arch {#define vcpu_cp14 (v,r) ((v)->arch.ctxt.copro[(r)])#define vcpu_cp15 (v,r) ((v)->arch.ctxt.copro[(r)]) -#ifdef CONFIG_CPU_BIG_ENDIAN -#define vcpu_cp15_64_high (v,r) vcpu_cp15((v),(r)) -#define vcpu_cp15_64_low (v,r) vcpu_cp15((v),(r) + 1) -#else -#define vcpu_cp15_64_high (v,r) vcpu_cp15((v),(r) + 1) -#define vcpu_cp15_64_low (v,r) vcpu_cp15((v),(r)) -#endif -struct kvm_vm_stat {ulong remote_tlb_flush; };
arch/arm64/kvm/sys_regs.c +15 -5
@@ -121,16 +121,26 @@ static bool access_vm_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r) {bool was_enabled =vcpu_has_cache_enabled (vcpu); +u64 val; +int reg = r->reg;BUG_ON (!p->is_write); -if (!p->is_aarch32) { -vcpu_sys_reg (vcpu, r->reg) = p->regval; +/* See the 32bit mapping in kvm_host.h */ +if (p->is_aarch32) + reg = r->reg /2 ; + +if (!p->is_aarch32 || !p->is_32bit) { + val = p->regval; }else { -if (!p->is_32bit) -vcpu_cp15_64_high (vcpu, r->reg) =upper_32_bits (p->regval); -vcpu_cp15_64_low (vcpu, r->reg) =lower_32_bits (p->regval); + val =vcpu_sys_reg (vcpu, reg); +if (r->reg %2 ) + val = (p->regval <<32 ) | (u64 )lower_32_bits (val); +else + val = ((u64 )upper_32_bits (val) <<32 ) | +lower_32_bits (p->regval); } +vcpu_sys_reg (vcpu, reg) = val;kvm_toggle_cache (vcpu, was_enabled);return true;
Signature · 1 line
2.14.2
PATCH v5 26/40 KVM: arm/arm64: Prepare to handle deferred save/restore of SPSR_EL1
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
SPSR_EL1 is not used by a VHE host kernel and can be deferred, but we need to rework the accesses to this register to access the latest value depending on whether or not guest system registers are loaded on the CPU or only reside in memory.
The handling of accessing the various banked SPSRs for 32-bit VMs is a bit clunky, but this will be improved in following patches which will first prepare and subsequently implement deferred save/restore of the 32-bit registers, including the 32-bit SPSRs.
---
Notes:
Changes since v4:
- Dropped unnecessary cast
Changes since v2:
- New patch (deferred register handling has been reworked)
arch/arm/include/asm/kvm_emulate.h | 12 ++++++++++- arch/arm/kvm/emulate.c | 2 +- arch/arm64/include/asm/kvm_emulate.h | 41 +++++++++++++++++++++++++++++++----- arch/arm64/kvm/inject_fault.c | 4 ++-- virt/kvm/arm/aarch32.c | 2 +- 5 files changed, 51 insertions(+), 10 deletions(-)
arch/arm/include/asm/kvm_emulate.h +11 -1
@@ -41,7 +41,17 @@ static inline unsigned long *vcpu_reg32(struct kvm_vcpu *vcpu, u8 reg_num)return vcpu_reg (vcpu, reg_num); } -unsigned long *vcpu_spsr (struct kvm_vcpu *vcpu); +unsigned long *__vcpu_spsr (struct kvm_vcpu *vcpu); + +static inline unsigned long vpcu_read_spsr (struct kvm_vcpu *vcpu) +{ +return *__vcpu_spsr (vcpu); +} + +static inline void vcpu_write_spsr (struct kvm_vcpu *vcpu,unsigned long v) +{ + *__vcpu_spsr (vcpu) = v; +}static inline unsigned long vcpu_get_reg (struct kvm_vcpu *vcpu,u8 reg_num)
arch/arm/kvm/emulate.c +1 -1
@@ -142,7 +142,7 @@ unsigned long *vcpu_reg(struct kvm_vcpu *vcpu, u8 reg_num)/* * Return the SPSR for the current mode of the virtual CPU. */ -unsigned long *vcpu_spsr (struct kvm_vcpu *vcpu) +unsigned long *__vcpu_spsr (struct kvm_vcpu *vcpu) {unsigned long mode = *vcpu_cpsr (vcpu) &MODE_MASK ;switch (mode) {
arch/arm64/include/asm/kvm_emulate.h +36 -5
55 lines not on this page · raw message
arch/arm64/kvm/inject_fault.c +2 -2
@@ -71,7 +71,7 @@ static void inject_abt64(struct kvm_vcpu *vcpu, bool is_iabt, unsigned long addr *vcpu_pc (vcpu) =get_except_vector (vcpu, except_type_sync); *vcpu_cpsr (vcpu) =PSTATE_FAULT_BITS_64 ; - *vcpu_spsr (vcpu) = cpsr; +vcpu_write_spsr (vcpu, cpsr);vcpu_write_sys_reg (vcpu, addr,FAR_EL1 );
@@ -106,7 +106,7 @@ static void inject_undef64(struct kvm_vcpu *vcpu) *vcpu_pc (vcpu) =get_except_vector (vcpu, except_type_sync); *vcpu_cpsr (vcpu) =PSTATE_FAULT_BITS_64 ; - *vcpu_spsr (vcpu) = cpsr; +vcpu_write_spsr (vcpu, cpsr);/* * Build an unknown exception, depending on the instruction
virt/kvm/arm/aarch32.c +1 -1
@@ -178,7 +178,7 @@ static void prepare_fault32(struct kvm_vcpu *vcpu, u32 mode, u32 vect_offset) *vcpu_cpsr (vcpu) = cpsr;/* Note: These now point to the banked copies */ - *vcpu_spsr (vcpu) = new_spsr_value; +vcpu_write_spsr (vcpu, new_spsr_value); *vcpu_reg32 (vcpu,14 ) = *vcpu_pc (vcpu) + return_offset;/* Branch to exception vector */
Signature · 1 line
2.14.2
PATCH v5 27/40 KVM: arm64: Prepare to handle deferred save/restore of ELR_EL1
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
ELR_EL1 is not used by a VHE host kernel and can be deferred, but we need to rework the accesses to this register to access the latest value depending on whether or not guest system registers are loaded on the CPU or only reside in memory.
---
Notes:
Changes since v2:
- New patch (deferred register handling has been reworked)
arch/arm64/include/asm/kvm_emulate.h | 18 +++++++++++++++++- arch/arm64/kvm/inject_fault.c | 4 ++-- 2 files changed, 19 insertions(+), 3 deletions(-)
arch/arm64/include/asm/kvm_emulate.h +17 -1
@@ -90,11 +90,27 @@ static inline unsigned long *vcpu_pc(const struct kvm_vcpu *vcpu)return (unsigned long *)&vcpu_gp_regs (vcpu)->regs.pc; } -static inline unsigned long *vcpu_elr_el1 (const struct kvm_vcpu *vcpu) +static inline unsigned long *__vcpu_elr_el1 (const struct kvm_vcpu *vcpu) {return (unsigned long *)&vcpu_gp_regs (vcpu)->elr_el1; } +static inline unsigned long vcpu_read_elr_el1 (const struct kvm_vcpu *vcpu) +{ +if (vcpu->arch.sysregs_loaded_on_cpu) +return read_sysreg_el1 (elr); +else +return *__vcpu_elr_el1 (vcpu); +} + +static inline void vcpu_write_elr_el1 (const struct kvm_vcpu *vcpu,unsigned long v) +{ +if (vcpu->arch.sysregs_loaded_on_cpu) +write_sysreg_el1 (v, elr); +else + *__vcpu_elr_el1 (vcpu) = v; +} +static inline unsigned long *vcpu_cpsr (const struct kvm_vcpu *vcpu) {return (unsigned long *)&vcpu_gp_regs (vcpu)->regs.pstate;
arch/arm64/kvm/inject_fault.c +2 -2
@@ -67,7 +67,7 @@ static void inject_abt64(struct kvm_vcpu *vcpu, bool is_iabt, unsigned long addrbool is_aarch32 =vcpu_mode_is_32bit (vcpu);u32 esr =0 ; - *vcpu_elr_el1 (vcpu) = *vcpu_pc (vcpu); +vcpu_write_elr_el1 (vcpu, *vcpu_pc (vcpu)); *vcpu_pc (vcpu) =get_except_vector (vcpu, except_type_sync); *vcpu_cpsr (vcpu) =PSTATE_FAULT_BITS_64 ;
@@ -102,7 +102,7 @@ static void inject_undef64(struct kvm_vcpu *vcpu)unsigned long cpsr = *vcpu_cpsr (vcpu);u32 esr = (ESR_ELx_EC_UNKNOWN << ESR_ELx_EC_SHIFT); - *vcpu_elr_el1 (vcpu) = *vcpu_pc (vcpu); +vcpu_write_elr_el1 (vcpu, *vcpu_pc (vcpu)); *vcpu_pc (vcpu) =get_except_vector (vcpu, except_type_sync); *vcpu_cpsr (vcpu) =PSTATE_FAULT_BITS_64 ;
Signature · 1 line
2.14.2
PATCH v5 24/40 KVM: arm64: Rewrite system register accessors to read/write functions
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
Currently we access the system registers array via the vcpu_sys_reg() macro. However, we are about to change the behavior to some times modify the register file directly, so let's change this to two primitives:
* Accessor macros vcpu_write_sys_reg() and vcpu_read_sys_reg()
* Direct array access macro __vcpu_sys_reg()
The accessor macros should be used in places where the code needs to access the currently loaded VCPU's state as observed by the guest. For example, when trapping on cache related registers, a write to a system register should go directly to the VCPU version of the register.
The direct array access macro can be used in places where the VCPU is known to never be running (for example userspace access) or for registers which are never context switched (for example all the PMU system registers).
This rewrites all users of vcpu_sys_regs to one of the macros described above.
No functional change.
---
Notes:
Changes since v4:
- Reordered val/reg of vcpu_write_sys_reg to make it look more like the write_sysreg macro.
- Fixed up a few scenarios of ugly text wrapping that were trying to maintain the 80 char limit; we can be a little more loose.
- Added Marc's acked-by and Drew's reviewed-by despite the changes, as I did the changes with a coccinelle script and figured it probably got things right:
@@
expression vcpu, val;
const reg;
@@
- vcpu_write_sys_reg(vcpu, reg, val)
+ vcpu_write_sys_reg(vcpu, val, reg)
Changes since v2:
- New patch (deferred register handling has been reworked)
arch/arm64/include/asm/kvm_emulate.h | 13 ++++--- arch/arm64/include/asm/kvm_host.h | 13 ++++++- arch/arm64/include/asm/kvm_mmu.h | 2 +- arch/arm64/kvm/debug.c | 28 ++++++++++----- arch/arm64/kvm/inject_fault.c | 8 ++--- arch/arm64/kvm/sys_regs.c | 69 ++++++++++++++++++------------------ arch/arm64/kvm/sys_regs.h | 4 +-- arch/arm64/kvm/sys_regs_generic_v8.c | 4 +-- virt/kvm/arm/pmu.c | 36 +++++++++---------- 9 files changed, 101 insertions(+), 76 deletions(-)
arch/arm64/include/asm/kvm_emulate.h +8 -5
@@ -290,15 +290,18 @@ static inline int kvm_vcpu_sys_get_rt(struct kvm_vcpu *vcpu)static inline unsigned long kvm_vcpu_get_mpidr_aff (struct kvm_vcpu *vcpu) { -return vcpu_sys_reg (vcpu,MPIDR_EL1 ) &MPIDR_HWID_BITMASK ; +return vcpu_read_sys_reg (vcpu,MPIDR_EL1 ) &MPIDR_HWID_BITMASK ; }static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) { -if (vcpu_mode_is_32bit (vcpu)) +if (vcpu_mode_is_32bit (vcpu)) { *vcpu_cpsr (vcpu) |=COMPAT_PSR_E_BIT ; -else -vcpu_sys_reg (vcpu,SCTLR_EL1 ) |= (1 <<25 ); + }else { +u64 sctlr =vcpu_read_sys_reg (vcpu,SCTLR_EL1 ); + sctlr |= (1 <<25 ); +vcpu_write_sys_reg (vcpu,SCTLR_EL1 , sctlr); + } }static inline bool kvm_vcpu_is_be (struct kvm_vcpu *vcpu)
@@ -306,7 +309,7 @@ static inline bool kvm_vcpu_is_be(struct kvm_vcpu *vcpu)if (vcpu_mode_is_32bit (vcpu))return !!(*vcpu_cpsr (vcpu) &COMPAT_PSR_E_BIT ); -return !!(vcpu_sys_reg (vcpu,SCTLR_EL1 ) & (1 <<25 )); +return !!(vcpu_read_sys_reg (vcpu,SCTLR_EL1 ) & (1 <<25 )); } static inline unsigned long vcpu_data_guest_to_host(struct kvm_vcpu *vcpu,
arch/arm64/include/asm/kvm_host.h +12 -1
@@ -287,7 +287,18 @@ struct kvm_vcpu_arch { };#define vcpu_gp_regs (v) (&(v)->arch.ctxt.gp_regs) -#define vcpu_sys_reg (v,r) ((v)->arch.ctxt.sys_regs[(r)]) + +/* +* Only use __vcpu_sys_reg if you know you want the memory backed version of a +* register, and not the one most recently accessed by a running VCPU. For +* example, for userspace access or for system registers that are never context +* switched, but only emulated. +*/ +#define __vcpu_sys_reg (v,r) ((v)->arch.ctxt.sys_regs[(r)]) + +#define vcpu_read_sys_reg (v,r) __vcpu_sys_reg(v,r) +#define vcpu_write_sys_reg (v,n,r) do { __vcpu_sys_reg(v,r) = n; } while (0) +/* * CP14 and CP15 live in the same array, as they are backed by the * same system registers.
arch/arm64/include/asm/kvm_mmu.h +1 -1
@@ -249,7 +249,7 @@ struct kvm;static inline bool vcpu_has_cache_enabled (struct kvm_vcpu *vcpu) { -return (vcpu_sys_reg (vcpu,SCTLR_EL1 ) &0b101 ) ==0b101 ; +return (vcpu_read_sys_reg (vcpu,SCTLR_EL1 ) &0b101 ) ==0b101 ; }static inline void __clean_dcache_guest_page (kvm_pfn_t pfn,unsigned long size)
arch/arm64/kvm/debug.c +19 -9
@@ -46,7 +46,9 @@ static DEFINE_PER_CPU(u32, mdcr_el2);*/ static void save_guest_debug_regs (struct kvm_vcpu *vcpu) { - vcpu->arch.guest_debug_preserved.mdscr_el1 =vcpu_sys_reg (vcpu,MDSCR_EL1 ); +u64 val =vcpu_read_sys_reg (vcpu,MDSCR_EL1 ); + + vcpu->arch.guest_debug_preserved.mdscr_el1 = val;trace_kvm_arm_set_dreg32 ("Saved MDSCR_EL1" , vcpu->arch.guest_debug_preserved.mdscr_el1);
@@ -54,10 +56,12 @@ static void save_guest_debug_regs(struct kvm_vcpu *vcpu)static void restore_guest_debug_regs (struct kvm_vcpu *vcpu) { -vcpu_sys_reg (vcpu,MDSCR_EL1 ) = vcpu->arch.guest_debug_preserved.mdscr_el1; +u64 val = vcpu->arch.guest_debug_preserved.mdscr_el1; + +vcpu_write_sys_reg (vcpu, val,MDSCR_EL1 );trace_kvm_arm_set_dreg32 ("Restored MDSCR_EL1" , -vcpu_sys_reg (vcpu,MDSCR_EL1 )); +vcpu_read_sys_reg (vcpu,MDSCR_EL1 )); }/**
@@ -108,6 +112,7 @@ void kvm_arm_reset_debug_ptr(struct kvm_vcpu *vcpu)void kvm_arm_setup_debug (struct kvm_vcpu *vcpu) {bool trap_debug = !(vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY ); +unsigned long mdscr;trace_kvm_arm_setup_debug (vcpu, vcpu->guest_debug);
@@ -152,9 +157,13 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu)*/ if (vcpu->guest_debug &KVM_GUESTDBG_SINGLESTEP ) { *vcpu_cpsr (vcpu) |=DBG_SPSR_SS ; -vcpu_sys_reg (vcpu,MDSCR_EL1 ) |=DBG_MDSCR_SS ; + mdscr =vcpu_read_sys_reg (vcpu,MDSCR_EL1 ); + mdscr |=DBG_MDSCR_SS ; +vcpu_write_sys_reg (vcpu, mdscr,MDSCR_EL1 ); }else { -vcpu_sys_reg (vcpu,MDSCR_EL1 ) &= ~DBG_MDSCR_SS ; + mdscr =vcpu_read_sys_reg (vcpu,MDSCR_EL1 ); + mdscr &= ~DBG_MDSCR_SS ; +vcpu_write_sys_reg (vcpu, mdscr,MDSCR_EL1 ); }trace_kvm_arm_set_dreg32 ("SPSR_EL2" , *vcpu_cpsr (vcpu));
@@ -170,7 +179,9 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu)*/ if (vcpu->guest_debug &KVM_GUESTDBG_USE_HW ) {/* Enable breakpoints/watchpoints */ -vcpu_sys_reg (vcpu,MDSCR_EL1 ) |=DBG_MDSCR_MDE ; + mdscr =vcpu_read_sys_reg (vcpu,MDSCR_EL1 ); + mdscr |=DBG_MDSCR_MDE ; +vcpu_write_sys_reg (vcpu, mdscr,MDSCR_EL1 ); vcpu->arch.debug_ptr = &vcpu->arch.external_debug_state; vcpu->arch.debug_flags |=KVM_ARM64_DEBUG_DIRTY ;
@@ -194,12 +205,11 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) vcpu->arch.mdcr_el2 |=MDCR_EL2_TDA ;/* If KDE or MDE are set, perform a full save/restore cycle. */ -if ((vcpu_sys_reg (vcpu,MDSCR_EL1 ) &DBG_MDSCR_KDE ) || - (vcpu_sys_reg (vcpu,MDSCR_EL1 ) &DBG_MDSCR_MDE )) +if (vcpu_read_sys_reg (vcpu,MDSCR_EL1 ) & (DBG_MDSCR_KDE |DBG_MDSCR_MDE )) vcpu->arch.debug_flags |=KVM_ARM64_DEBUG_DIRTY ;trace_kvm_arm_set_dreg32 ("MDCR_EL2" , vcpu->arch.mdcr_el2); -trace_kvm_arm_set_dreg32 ("MDSCR_EL1" ,vcpu_sys_reg (vcpu,MDSCR_EL1 )); +trace_kvm_arm_set_dreg32 ("MDSCR_EL1" ,vcpu_read_sys_reg (vcpu,MDSCR_EL1 )); }void kvm_arm_clear_debug (struct kvm_vcpu *vcpu)
arch/arm64/kvm/inject_fault.c +4 -4
@@ -58,7 +58,7 @@ static u64 get_except_vector(struct kvm_vcpu *vcpu, enum exception_type type) exc_offset = LOWER_EL_AArch32_VECTOR; } -return vcpu_sys_reg (vcpu,VBAR_EL1 ) + exc_offset + type; +return vcpu_read_sys_reg (vcpu,VBAR_EL1 ) + exc_offset + type; }static void inject_abt64 (struct kvm_vcpu *vcpu,bool is_iabt,unsigned long addr)
@@ -73,7 +73,7 @@ static void inject_abt64(struct kvm_vcpu *vcpu, bool is_iabt, unsigned long addr *vcpu_cpsr (vcpu) =PSTATE_FAULT_BITS_64 ; *vcpu_spsr (vcpu) = cpsr; -vcpu_sys_reg (vcpu,FAR_EL1 ) = addr; +vcpu_write_sys_reg (vcpu, addr,FAR_EL1 );/* * Build an {i,d}abort, depending on the level and the
@@ -94,7 +94,7 @@ static void inject_abt64(struct kvm_vcpu *vcpu, bool is_iabt, unsigned long addrif (!is_iabt) esr |= ESR_ELx_EC_DABT_LOW << ESR_ELx_EC_SHIFT; -vcpu_sys_reg (vcpu,ESR_EL1 ) = esr | ESR_ELx_FSC_EXTABT; +vcpu_write_sys_reg (vcpu, esr | ESR_ELx_FSC_EXTABT,ESR_EL1 ); }static void inject_undef64 (struct kvm_vcpu *vcpu)
@@ -115,7 +115,7 @@ static void inject_undef64(struct kvm_vcpu *vcpu)if (kvm_vcpu_trap_il_is32bit (vcpu)) esr |= ESR_ELx_IL; -vcpu_sys_reg (vcpu,ESR_EL1 ) = esr; +vcpu_write_sys_reg (vcpu, esr,ESR_EL1 ); }/**
arch/arm64/kvm/sys_regs.c +35 -34
208 lines not on this page · raw message
arch/arm64/kvm/sys_regs.h +2 -2
@@ -89,14 +89,14 @@ static inline void reset_unknown(struct kvm_vcpu *vcpu, {BUG_ON (!r->reg);BUG_ON (r->reg >=NR_SYS_REGS ); -vcpu_sys_reg (vcpu, r->reg) =0x1de7ec7edbadc0deULL ; +__vcpu_sys_reg (vcpu, r->reg) =0x1de7ec7edbadc0deULL ; }static inline void reset_val (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r) {BUG_ON (!r->reg);BUG_ON (r->reg >=NR_SYS_REGS ); -vcpu_sys_reg (vcpu, r->reg) = r->val; +__vcpu_sys_reg (vcpu, r->reg) = r->val; } static inline int cmp_sys_reg(const struct sys_reg_desc *i1,
arch/arm64/kvm/sys_regs_generic_v8.c +2 -2
@@ -38,13 +38,13 @@ static bool access_actlr(struct kvm_vcpu *vcpu,if (p->is_write)return ignore_write (vcpu, p); - p->regval =vcpu_sys_reg (vcpu,ACTLR_EL1 ); + p->regval =vcpu_read_sys_reg (vcpu,ACTLR_EL1 );return true; }static void reset_actlr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r) { -vcpu_sys_reg (vcpu,ACTLR_EL1 ) =read_sysreg (actlr_el1); +__vcpu_sys_reg (vcpu,ACTLR_EL1 ) =read_sysreg (actlr_el1); }/*
virt/kvm/arm/pmu.c +18 -18
@@ -37,7 +37,7 @@ u64 kvm_pmu_get_counter_value(struct kvm_vcpu *vcpu, u64 select_idx) reg = (select_idx ==ARMV8_PMU_CYCLE_IDX ) ?PMCCNTR_EL0 :PMEVCNTR0_EL0 + select_idx; - counter =vcpu_sys_reg (vcpu, reg); + counter =__vcpu_sys_reg (vcpu, reg);/* The real counter value is equal to the value of counter register plus * the value perf event counts.
@@ -61,7 +61,7 @@ void kvm_pmu_set_counter_value(struct kvm_vcpu *vcpu, u64 select_idx, u64 val) reg = (select_idx ==ARMV8_PMU_CYCLE_IDX ) ?PMCCNTR_EL0 :PMEVCNTR0_EL0 + select_idx; -vcpu_sys_reg (vcpu, reg) += (s64 )val -kvm_pmu_get_counter_value (vcpu, select_idx); +__vcpu_sys_reg (vcpu, reg) += (s64 )val -kvm_pmu_get_counter_value (vcpu, select_idx); }/**
@@ -78,7 +78,7 @@ static void kvm_pmu_stop_counter(struct kvm_vcpu *vcpu, struct kvm_pmc *pmc) counter =kvm_pmu_get_counter_value (vcpu, pmc->idx); reg = (pmc->idx ==ARMV8_PMU_CYCLE_IDX ) ?PMCCNTR_EL0 :PMEVCNTR0_EL0 + pmc->idx; -vcpu_sys_reg (vcpu, reg) = counter; +__vcpu_sys_reg (vcpu, reg) = counter;perf_event_disable (pmc->perf_event);perf_event_release_kernel (pmc->perf_event); pmc->perf_event =NULL ;
@@ -125,7 +125,7 @@ void kvm_pmu_vcpu_destroy(struct kvm_vcpu *vcpu)u64 kvm_pmu_valid_counter_mask (struct kvm_vcpu *vcpu) { -u64 val =vcpu_sys_reg (vcpu,PMCR_EL0 ) >>ARMV8_PMU_PMCR_N_SHIFT ; +u64 val =__vcpu_sys_reg (vcpu,PMCR_EL0 ) >>ARMV8_PMU_PMCR_N_SHIFT ; val &=ARMV8_PMU_PMCR_N_MASK ;if (val ==0 )
@@ -147,7 +147,7 @@ void kvm_pmu_enable_counter(struct kvm_vcpu *vcpu, u64 val)struct kvm_pmu *pmu = &vcpu->arch.pmu;struct kvm_pmc *pmc; -if (!(vcpu_sys_reg (vcpu,PMCR_EL0 ) &ARMV8_PMU_PMCR_E ) || !val) +if (!(__vcpu_sys_reg (vcpu,PMCR_EL0 ) &ARMV8_PMU_PMCR_E ) || !val)return ;for (i =0 ; i <ARMV8_PMU_MAX_COUNTERS ; i++) {
@@ -193,10 +193,10 @@ static u64 kvm_pmu_overflow_status(struct kvm_vcpu *vcpu) {u64 reg =0 ; -if ((vcpu_sys_reg (vcpu,PMCR_EL0 ) &ARMV8_PMU_PMCR_E )) { - reg =vcpu_sys_reg (vcpu,PMOVSSET_EL0 ); - reg &=vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ); - reg &=vcpu_sys_reg (vcpu,PMINTENSET_EL1 ); +if ((__vcpu_sys_reg (vcpu,PMCR_EL0 ) &ARMV8_PMU_PMCR_E )) { + reg =__vcpu_sys_reg (vcpu,PMOVSSET_EL0 ); + reg &=__vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ); + reg &=__vcpu_sys_reg (vcpu,PMINTENSET_EL1 ); reg &=kvm_pmu_valid_counter_mask (vcpu); }
@@ -295,7 +295,7 @@ static void kvm_pmu_perf_overflow(struct perf_event *perf_event,struct kvm_vcpu *vcpu =kvm_pmc_to_vcpu (pmc);int idx = pmc->idx; -vcpu_sys_reg (vcpu,PMOVSSET_EL0 ) |=BIT (idx); +__vcpu_sys_reg (vcpu,PMOVSSET_EL0 ) |=BIT (idx);if (kvm_pmu_overflow_status (vcpu)) {kvm_make_request (KVM_REQ_IRQ_PENDING , vcpu);
@@ -316,19 +316,19 @@ void kvm_pmu_software_increment(struct kvm_vcpu *vcpu, u64 val)if (val ==0 )return ; - enable =vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ); + enable =__vcpu_sys_reg (vcpu,PMCNTENSET_EL0 );for (i =0 ; i <ARMV8_PMU_CYCLE_IDX ; i++) {if (!(val &BIT (i)))continue ; - type =vcpu_sys_reg (vcpu,PMEVTYPER0_EL0 + i) + type =__vcpu_sys_reg (vcpu,PMEVTYPER0_EL0 + i) &ARMV8_PMU_EVTYPE_EVENT ;if ((type ==ARMV8_PMUV3_PERFCTR_SW_INCR ) && (enable &BIT (i))) { - reg =vcpu_sys_reg (vcpu,PMEVCNTR0_EL0 + i) +1 ; + reg =__vcpu_sys_reg (vcpu,PMEVCNTR0_EL0 + i) +1 ; reg =lower_32_bits (reg); -vcpu_sys_reg (vcpu,PMEVCNTR0_EL0 + i) = reg; +__vcpu_sys_reg (vcpu,PMEVCNTR0_EL0 + i) = reg;if (!reg) -vcpu_sys_reg (vcpu,PMOVSSET_EL0 ) |=BIT (i); +__vcpu_sys_reg (vcpu,PMOVSSET_EL0 ) |=BIT (i); } } }
@@ -348,7 +348,7 @@ void kvm_pmu_handle_pmcr(struct kvm_vcpu *vcpu, u64 val) mask =kvm_pmu_valid_counter_mask (vcpu);if (val &ARMV8_PMU_PMCR_E ) {kvm_pmu_enable_counter (vcpu, -vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ) & mask); +__vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ) & mask); }else {kvm_pmu_disable_counter (vcpu, mask); }
@@ -369,8 +369,8 @@ void kvm_pmu_handle_pmcr(struct kvm_vcpu *vcpu, u64 val)static bool kvm_pmu_counter_is_enabled (struct kvm_vcpu *vcpu,u64 select_idx) { -return (vcpu_sys_reg (vcpu,PMCR_EL0 ) &ARMV8_PMU_PMCR_E ) && - (vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ) &BIT (select_idx)); +return (__vcpu_sys_reg (vcpu,PMCR_EL0 ) &ARMV8_PMU_PMCR_E ) && + (__vcpu_sys_reg (vcpu,PMCNTENSET_EL0 ) &BIT (select_idx)); }/**
Signature · 1 line
2.14.2
PATCH v5 28/40 KVM: arm64: Defer saving/restoring 64-bit sysregs to vcpu load/put on VHE
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
Some system registers do not affect the host kernel's execution and can therefore be loaded when we are about to run a VCPU and we don't have to restore the host state to the hardware before the time when we are actually about to return to userspace or schedule out the VCPU thread.
The EL1 system registers and the userspace state registers only affecting EL0 execution do not need to be saved and restored on every switch between the VM and the host, because they don't affect the host kernel's execution.
We mark all registers which are now deffered as such in the vcpu_{read,write}_sys_reg accessors in sys-regs.c to ensure the most up-to-date copy is always accessed.
Note MPIDR_EL1 (controlled via VMPIDR_EL2) is accessed from other vcpu threads, for example via the GIC emulation, and therefore must be declared as immediate, which is fine as the guest cannot modify this value.
The 32-bit sysregs can also be deferred but we do this in a separate patch as it requires a bit more infrastructure.
---
Notes:
Changes since v4:
- Added explanatory note about MPIDR_EL1 to
vcpu_read_sys_reg and vcpu_write_sys_reg.
Changes since v3:
- Changed to switch-based sysreg approach
arch/arm64/kvm/hyp/sysreg-sr.c | 39 ++++++++++++++++++++++++++------- arch/arm64/kvm/sys_regs.c | 49 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+), 8 deletions(-)
arch/arm64/kvm/hyp/sysreg-sr.c +31 -8
@@ -25,8 +25,12 @@/* * Non-VHE: Both host and guest must save everything. * -* VHE: Host must save tpidr*_el0, mdscr_el1, sp_el0, -* and guest must save everything. +* VHE: Host and guest must save mdscr_el1 and sp_el0 (and the PC and pstate, +* which are handled as part of the el2 return state) on every switch. +* tpidr_el0 and tpidrro_el0 only need to be switched when going +* to host userspace or a different VCPU. EL1 registers only need to be +* switched when potentially going to run a different VCPU. The latter two +* classes are handled as part of kvm_arch_vcpu_load and kvm_arch_vcpu_put. */ static void __hyp_text __sysreg_save_common_state(struct kvm_cpu_context *ctxt)
@@ -93,14 +97,11 @@ void __hyp_text __sysreg_save_state_nvhe(struct kvm_cpu_context *ctxt)void sysreg_save_host_state_vhe (struct kvm_cpu_context *ctxt) {__sysreg_save_common_state (ctxt); -__sysreg_save_user_state (ctxt); }void sysreg_save_guest_state_vhe (struct kvm_cpu_context *ctxt) { -__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt); -__sysreg_save_user_state (ctxt);__sysreg_save_el2_return_state (ctxt); }
@@ -169,14 +170,11 @@ void __hyp_text __sysreg_restore_state_nvhe(struct kvm_cpu_context *ctxt)void sysreg_restore_host_state_vhe (struct kvm_cpu_context *ctxt) {__sysreg_restore_common_state (ctxt); -__sysreg_restore_user_state (ctxt); }void sysreg_restore_guest_state_vhe (struct kvm_cpu_context *ctxt) { -__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt); -__sysreg_restore_user_state (ctxt);__sysreg_restore_el2_return_state (ctxt); }
@@ -240,6 +238,18 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu)*/ void kvm_vcpu_load_sysregs (struct kvm_vcpu *vcpu) { +struct kvm_cpu_context *host_ctxt = vcpu->arch.host_cpu_context; +struct kvm_cpu_context *guest_ctxt = &vcpu->arch.ctxt; + +if (!has_vhe ()) +return ; + +__sysreg_save_user_state (host_ctxt); + +__sysreg_restore_user_state (guest_ctxt); +__sysreg_restore_el1_state (guest_ctxt); + + vcpu->arch.sysregs_loaded_on_cpu = true; }/**
@@ -255,6 +265,19 @@ void kvm_vcpu_load_sysregs(struct kvm_vcpu *vcpu)*/ void kvm_vcpu_put_sysregs (struct kvm_vcpu *vcpu) { +struct kvm_cpu_context *host_ctxt = vcpu->arch.host_cpu_context; +struct kvm_cpu_context *guest_ctxt = &vcpu->arch.ctxt; + +if (!has_vhe ()) +return ; + +__sysreg_save_el1_state (guest_ctxt); +__sysreg_save_user_state (guest_ctxt); + +/* Restore host user state */ +__sysreg_restore_user_state (host_ctxt); + + vcpu->arch.sysregs_loaded_on_cpu = false; } void __hyp_text __kvm_set_tpidr_el2(u64 tpidr_el2)
arch/arm64/kvm/sys_regs.c +49 -0
65 lines not on this page · raw message
Signature · 1 line
2.14.2
PATCH v5 30/40 KVM: arm64: Defer saving/restoring 32-bit sysregs to vcpu load/put
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
When running a 32-bit VM (EL1 in AArch32), the AArch32 system registers can be deferred to vcpu load/put on VHE systems because neither the host kernel nor host userspace uses these registers.
Note that we can't save DBGVCR32_EL2 conditionally based on the state of the debug dirty flag on VHE after this change, because during vcpu_load() we haven't calculated a valid debug flag yet, and when we've restored the register during vcpu_load() we also have to save it during vcpu_put(). This means that we'll always restore/save the register for VHE on load/put, but luckily vcpu load/put are called rarely, so saving an extra register unconditionally shouldn't significantly hurt performance.
We can also not defer saving FPEXC32_32 because this register only holds a guest-valid value for 32-bit guests during the exit path when the guest has used FPSIMD registers and restored the register in the early assembly handler from taking the EL2 fault, and therefore we have to check if fpsimd is enabled for the guest in the exit path and save the register then, for both VHE and non-VHE guests.
---
Notes:
Changes since v4:
- Moved logic to directly read/write 32-bit sysregs in the vcpu_{read,write}_sys_reg when sysregs are loaded to this patch.
- Removed inline attribute from __fpsimd_save_fpexc32
Changes since v3:
- Rework the FPEXC32 save/restore logic to no longer attempt to save/restore this register lazily.
Changes since v2:
- New patch (deferred register handling has been reworked)
arch/arm64/kvm/hyp/switch.c | 17 +++++++++++------ arch/arm64/kvm/hyp/sysreg-sr.c | 15 ++++++++++----- arch/arm64/kvm/sys_regs.c | 6 ++++++ 3 files changed, 27 insertions(+), 11 deletions(-)
arch/arm64/kvm/hyp/switch.c +11 -6
@@ -47,6 +47,15 @@ bool __hyp_text __fpsimd_enabled(void)return __fpsimd_is_enabled ()(); } +/* Save the 32-bit only FPSIMD system register state */ +static void __hyp_text __fpsimd_save_fpexc32(struct kvm_vcpu *vcpu) +{ +if (!vcpu_el1_is_32bit (vcpu)) +return ; + + vcpu->arch.ctxt.sys_regs[FPEXC32_EL2 ] =read_sysreg (fpexc32_el2); +} + static void __hyp_text __activate_traps_vhe(void) {u64 val;
@@ -380,11 +389,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__vgic_restore_state (vcpu); -/* -* We must restore the 32-bit state before the sysregs, thanks -* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). -*/ -__sysreg32_restore_state (vcpu);sysreg_restore_guest_state_vhe (guest_ctxt);__debug_switch_to_guest (vcpu);
@@ -398,7 +402,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu) fp_enabled =__fpsimd_enabled ();sysreg_save_guest_state_vhe (guest_ctxt); -__sysreg32_save_state (vcpu);__vgic_save_state (vcpu);__deactivate_traps (vcpu);
@@ -408,6 +411,7 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)if (fp_enabled) {__fpsimd_save_state (&guest_ctxt->gp_regs.fp_regs);__fpsimd_restore_state (&host_ctxt->gp_regs.fp_regs); +__fpsimd_save_fpexc32 (vcpu); }__debug_switch_to_host (vcpu);
@@ -477,6 +481,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)if (fp_enabled) {__fpsimd_save_state (&guest_ctxt->gp_regs.fp_regs);__fpsimd_restore_state (&host_ctxt->gp_regs.fp_regs); +__fpsimd_save_fpexc32 (vcpu); }/*
arch/arm64/kvm/hyp/sysreg-sr.c +10 -5
@@ -196,10 +196,7 @@ void __hyp_text __sysreg32_save_state(struct kvm_vcpu *vcpu) sysreg[DACR32_EL2 ] =read_sysreg (dacr32_el2); sysreg[IFSR32_EL2 ] =read_sysreg (ifsr32_el2); -if (__fpsimd_enabled ()) - sysreg[FPEXC32_EL2 ] =read_sysreg (fpexc32_el2); - -if (vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY ) +if (has_vhe () || vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY ) sysreg[DBGVCR32_EL2 ] =read_sysreg (dbgvcr32_el2); }
@@ -221,7 +218,7 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu)write_sysreg (sysreg[DACR32_EL2 ], dacr32_el2);write_sysreg (sysreg[IFSR32_EL2 ], ifsr32_el2); -if (vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY ) +if (has_vhe () || vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY )write_sysreg (sysreg[DBGVCR32_EL2 ], dbgvcr32_el2); }
@@ -246,6 +243,13 @@ void kvm_vcpu_load_sysregs(struct kvm_vcpu *vcpu)__sysreg_save_user_state (host_ctxt); +/* +* Load guest EL1 and user state +* +* We must restore the 32-bit state before the sysregs, thanks +* to erratum #852523 (Cortex-A57) or #853709 (Cortex-A72). +*/ +__sysreg32_restore_state (vcpu);__sysreg_restore_user_state (guest_ctxt);__sysreg_restore_el1_state (guest_ctxt);
@@ -273,6 +277,7 @@ void kvm_vcpu_put_sysregs(struct kvm_vcpu *vcpu)__sysreg_save_el1_state (guest_ctxt);__sysreg_save_user_state (guest_ctxt); +__sysreg32_save_state (vcpu);/* Restore host user state */ __sysreg_restore_user_state (host_ctxt);
arch/arm64/kvm/sys_regs.c +6 -0
@@ -112,6 +112,9 @@ u64 vcpu_read_sys_reg(struct kvm_vcpu *vcpu, int reg)case AMAIR_EL1 :return read_sysreg_s (amair_EL12);case CNTKCTL_EL1 :return read_sysreg_s (cntkctl_EL12);case PAR_EL1 :return read_sysreg_s (SYS_PAR_EL1 ); +case DACR32_EL2 :return read_sysreg_s (SYS_DACR32_EL2 ); +case IFSR32_EL2 :return read_sysreg_s (SYS_IFSR32_EL2 ); +case DBGVCR32_EL2 :return read_sysreg_s (SYS_DBGVCR32_EL2 ); } immediate_read:
@@ -152,6 +155,9 @@ void vcpu_write_sys_reg(struct kvm_vcpu *vcpu, u64 val, int reg)case AMAIR_EL1 :write_sysreg_s (val, amair_EL12);return ;case CNTKCTL_EL1 :write_sysreg_s (val, cntkctl_EL12);return ;case PAR_EL1 :write_sysreg_s (val,SYS_PAR_EL1 );return ; +case DACR32_EL2 :write_sysreg_s (val,SYS_DACR32_EL2 );return ; +case IFSR32_EL2 :write_sysreg_s (val,SYS_IFSR32_EL2 );return ; +case DBGVCR32_EL2 :write_sysreg_s (val,SYS_DBGVCR32_EL2 );return ; } immediate_write:
Signature · 1 line
2.14.2
PATCH v5 32/40 KVM: arm64: Directly call VHE and non-VHE FPSIMD enabled functions
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
There is no longer a need for an alternative to choose the right function to tell us whether or not FPSIMD was enabled for the VM, because we can simply can the appropriate functions directly from within the _vhe and _nvhe run functions.
---
Notes:
Changes since v3:
- New patch since we no longer defer FPSIMD handling to load/put
arch/arm64/kvm/hyp/switch.c | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-)
arch/arm64/kvm/hyp/switch.c +3 -12
@@ -33,20 +33,11 @@ static bool __hyp_text __fpsimd_enabled_nvhe(void)return !(read_sysreg (cptr_el2) &CPTR_EL2_TFP ); } -static bool __hyp_text __fpsimd_enabled_vhe(void) +static bool fpsimd_enabled_vhe (void ) {return !!(read_sysreg (cpacr_el1) &CPACR_EL1_FPEN ); } -static hyp_alternate_select(__fpsimd_is_enabled, - __fpsimd_enabled_nvhe, __fpsimd_enabled_vhe, - ARM64_HAS_VIRT_HOST_EXTN); - -bool __hyp_text __fpsimd_enabled(void) -{ -return __fpsimd_is_enabled ()(); -} -/* Save the 32-bit only FPSIMD system register state */ static void __hyp_text __fpsimd_save_fpexc32(struct kvm_vcpu *vcpu) {
@@ -414,7 +405,7 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)/* And we're baaack! */ }while (fixup_guest_exit (vcpu, &exit_code)); - fp_enabled =__fpsimd_enabled (); + fp_enabled =fpsimd_enabled_vhe ();sysreg_save_guest_state_vhe (guest_ctxt);__vgic_save_state (vcpu);
@@ -481,7 +472,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu) } } - fp_enabled =__fpsimd_enabled (); + fp_enabled =__fpsimd_enabled_nvhe ();__sysreg_save_state_nvhe (guest_ctxt);__sysreg32_save_state (vcpu);
Signature · 1 line
2.14.2
PATCH v5 35/40 KVM: arm/arm64: Get rid of vgic_elrsr
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
There is really no need to store the vgic_elrsr on the VGIC data structures as the only need we have for the elrsr is to figure out if an LR is inactive when we save the VGIC state upon returning from the guest. We can might as well store this in a temporary local variable.
---
Notes:
Changes since v4:
- Removed endianness fix comment from commit text, as this was fixed in a separate commit already merged in mainline.
Changes since v1:
- Moved patch up the queue before we start moving code around to avoid moving potentially broken code.
include/kvm/arm_vgic.h | 2 -- virt/kvm/arm/hyp/vgic-v2-sr.c | 28 +++++++--------------------- virt/kvm/arm/hyp/vgic-v3-sr.c | 6 +++--- virt/kvm/arm/vgic/vgic-v2.c | 1 - virt/kvm/arm/vgic/vgic-v3.c | 1 - 5 files changed, 10 insertions(+), 28 deletions(-)
include/kvm/arm_vgic.h +0 -2
@@ -263,7 +263,6 @@ struct vgic_dist {struct vgic_v2_cpu_if {u32 vgic_hcr;u32 vgic_vmcr; -u64 vgic_elrsr;/* Saved only */ u32 vgic_apr;u32 vgic_lr[VGIC_V2_MAX_LRS ]; };
@@ -272,7 +271,6 @@ struct vgic_v3_cpu_if {u32 vgic_hcr;u32 vgic_vmcr;u32 vgic_sre;/* Restored only, change ignored */ -u32 vgic_elrsr;/* Saved only */ u32 vgic_ap0r[4 ];u32 vgic_ap1r[4 ];u64 vgic_lr[VGIC_V3_MAX_LRS ];
virt/kvm/arm/hyp/vgic-v2-sr.c +7 -21
@@ -23,29 +23,19 @@#include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> -static void __hyp_text save_elrsr(struct kvm_vcpu *vcpu, void __iomem *base) -{ -struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; -int nr_lr = (kern_hyp_va (&kvm_vgic_global_state))->nr_lr; -u32 elrsr0, elrsr1; - - elrsr0 =readl_relaxed (base +GICH_ELRSR0 ); -if (unlikely (nr_lr >32 )) - elrsr1 =readl_relaxed (base +GICH_ELRSR1 ); -else - elrsr1 =0 ; - - cpu_if->vgic_elrsr = ((u64 )elrsr1 <<32 ) | elrsr0; -} - static void __hyp_text save_lrs(struct kvm_vcpu *vcpu, void __iomem *base) {struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; -int i;u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; +u64 elrsr; +int i; + + elrsr =readl_relaxed (base +GICH_ELRSR0 ); +if (unlikely (used_lrs >32 )) + elrsr |= ((u64 )readl_relaxed (base +GICH_ELRSR1 )) <<32 ;for (i =0 ; i < used_lrs; i++) { -if (cpu_if->vgic_elrsr & (1UL << i)) +if (elrsr & (1UL << i)) cpu_if->vgic_lr[i] &= ~GICH_LR_STATE ;else cpu_if->vgic_lr[i] =readl_relaxed (base +GICH_LR0 + (i *4 ));
@@ -68,13 +58,9 @@ void __hyp_text __vgic_v2_save_state(struct kvm_vcpu *vcpu)if (used_lrs) { cpu_if->vgic_apr =readl_relaxed (base +GICH_APR ); - -save_elrsr (vcpu, base);save_lrs (vcpu, base); -writel_relaxed (0 , base +GICH_HCR ); }else { - cpu_if->vgic_elrsr = ~0UL ; cpu_if->vgic_apr =0 ; } }
virt/kvm/arm/hyp/vgic-v3-sr.c +3 -3
@@ -222,15 +222,16 @@ void __hyp_text __vgic_v3_save_state(struct kvm_vcpu *vcpu)if (used_lrs) {int i;u32 nr_pre_bits; +u32 elrsr; - cpu_if->vgic_elrsr =read_gicreg (ICH_ELSR_EL2 ); + elrsr =read_gicreg (ICH_ELSR_EL2 );write_gicreg (0 ,ICH_HCR_EL2 ); val =read_gicreg (ICH_VTR_EL2 ); nr_pre_bits =vtr_to_nr_pre_bits (val);for (i =0 ; i < used_lrs; i++) { -if (cpu_if->vgic_elrsr & (1 << i)) +if (elrsr & (1 << i)) cpu_if->vgic_lr[i] &= ~ICH_LR_STATE ;else cpu_if->vgic_lr[i] =__gic_v3_get_lr (i);
@@ -262,7 +263,6 @@ void __hyp_text __vgic_v3_save_state(struct kvm_vcpu *vcpu) cpu_if->its_vpe.its_vm)write_gicreg (0 ,ICH_HCR_EL2 ); - cpu_if->vgic_elrsr =0xffff ; cpu_if->vgic_ap0r[0 ] =0 ; cpu_if->vgic_ap0r[1 ] =0 ; cpu_if->vgic_ap0r[2 ] =0 ;
virt/kvm/arm/vgic/vgic-v2.c +0 -1
@@ -265,7 +265,6 @@ void vgic_v2_enable(struct kvm_vcpu *vcpu)* anyway. */ vcpu->arch.vgic_cpu.vgic_v2.vgic_vmcr =0 ; - vcpu->arch.vgic_cpu.vgic_v2.vgic_elrsr = ~0 ;/* Get the show on the road... */ vcpu->arch.vgic_cpu.vgic_v2.vgic_hcr =GICH_HCR_EN ;
virt/kvm/arm/vgic/vgic-v3.c +0 -1
@@ -267,7 +267,6 @@ void vgic_v3_enable(struct kvm_vcpu *vcpu)* anyway. */ vgic_v3->vgic_vmcr =0 ; - vgic_v3->vgic_elrsr = ~0 ;/* * If we are emulating a GICv3, we do it in an non-GICv2-compatible
Signature · 1 line
2.14.2
PATCH v5 33/40 KVM: arm64: Configure c15, PMU, and debug register traps on cpu load/put for VHE
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
We do not have to change the c15 trap setting on each switch to/from the guest on VHE systems, because this setting only affects guest EL1/EL0 (and therefore not the VHE host).
The PMU and debug trap configuration can also be done on vcpu load/put instead, because they don't affect how the VHE host kernel can access the debug registers while executing KVM kernel code.
---
Notes:
Changes since v4:
- Clarified commit message
arch/arm64/include/asm/kvm_hyp.h | 3 +++ arch/arm64/kvm/hyp/switch.c | 31 ++++++++++++++++++++++--------- arch/arm64/kvm/hyp/sysreg-sr.c | 4 ++++ 3 files changed, 29 insertions(+), 9 deletions(-)
arch/arm64/include/asm/kvm_hyp.h +3 -0
@@ -147,6 +147,9 @@ void __fpsimd_save_state(struct user_fpsimd_state *fp_regs);void __fpsimd_restore_state (struct user_fpsimd_state *fp_regs);bool __fpsimd_enabled (void ); +void activate_traps_vhe_load (struct kvm_vcpu *vcpu); +void deactivate_traps_vhe_put (void ); +u64 __guest_enter (struct kvm_vcpu *vcpu,struct kvm_cpu_context *host_ctxt);void __noreturn __hyp_do_panic (unsigned long , ...);
arch/arm64/kvm/hyp/switch.c +22 -9
@@ -102,6 +102,8 @@ static void __hyp_text __activate_traps_nvhe(struct kvm_vcpu *vcpu) {u64 val; +__activate_traps_common (vcpu); + val =CPTR_EL2_DEFAULT ; val |=CPTR_EL2_TTA |CPTR_EL2_TFP |CPTR_EL2_TZ ;write_sysreg (val, cptr_el2);
@@ -121,20 +123,12 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu)write_sysreg_s (vcpu->arch.vsesr_el2,SYS_VSESR_EL2 );__activate_traps_fpsimd32 (vcpu); -__activate_traps_common (vcpu);__activate_traps_arch ()(vcpu); } static void __hyp_text __deactivate_traps_vhe(void) {extern char vectors[];/* kernel exception vectors */ -u64 mdcr_el2 =read_sysreg (mdcr_el2); - - mdcr_el2 &=MDCR_EL2_HPMN_MASK | -MDCR_EL2_E2PB_MASK <<MDCR_EL2_E2PB_SHIFT | -MDCR_EL2_TPMS ; - -write_sysreg (mdcr_el2, mdcr_el2);write_sysreg (HCR_HOST_VHE_FLAGS , hcr_el2);write_sysreg (CPACR_EL1_DEFAULT , cpacr_el1);write_sysreg (vectors, vbar_el1);
@@ -144,6 +138,8 @@ static void __hyp_text __deactivate_traps_nvhe(void) {u64 mdcr_el2 =read_sysreg (mdcr_el2); +__deactivate_traps_common (); + mdcr_el2 &=MDCR_EL2_HPMN_MASK ; mdcr_el2 |=MDCR_EL2_E2PB_MASK <<MDCR_EL2_E2PB_SHIFT ;
@@ -167,10 +163,27 @@ static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu)if (vcpu->arch.hcr_el2 &HCR_VSE ) vcpu->arch.hcr_el2 =read_sysreg (hcr_el2); -__deactivate_traps_common ();__deactivate_traps_arch ()(); } +void activate_traps_vhe_load (struct kvm_vcpu *vcpu) +{ +__activate_traps_common (vcpu); +} + +void deactivate_traps_vhe_put (void ) +{ +u64 mdcr_el2 =read_sysreg (mdcr_el2); + + mdcr_el2 &=MDCR_EL2_HPMN_MASK | +MDCR_EL2_E2PB_MASK <<MDCR_EL2_E2PB_SHIFT | +MDCR_EL2_TPMS ; + +write_sysreg (mdcr_el2, mdcr_el2); + +__deactivate_traps_common (); +} + static void __hyp_text __activate_vm(struct kvm *kvm) {write_sysreg (kvm->arch.vttbr, vttbr_el2);
arch/arm64/kvm/hyp/sysreg-sr.c +4 -0
@@ -254,6 +254,8 @@ void kvm_vcpu_load_sysregs(struct kvm_vcpu *vcpu)__sysreg_restore_el1_state (guest_ctxt); vcpu->arch.sysregs_loaded_on_cpu = true; + +activate_traps_vhe_load (vcpu); }/**
@@ -275,6 +277,8 @@ void kvm_vcpu_put_sysregs(struct kvm_vcpu *vcpu)if (!has_vhe ())return ; +deactivate_traps_vhe_put (); +__sysreg_save_el1_state (guest_ctxt);__sysreg_save_user_state (guest_ctxt);__sysreg32_save_state (vcpu);
Signature · 1 line
2.14.2
v5 cover Optimize KVM/ARM for VHE systems
This series redesigns parts of KVM/ARM to optimize the performance on VHE systems. The general approach is to try to do as little work as possible when transitioning between the VM and the hypervisor. This has the benefit of lower latency when waiting for interrupts and delivering virtual interrupts, and reduces the overhead of emulating behavior and I/O in the host kernel.
Patches 01 through 06 are not VHE specific, but rework parts of KVM/ARM that can be generally improved. We then add infrastructure to move more logic into vcpu_load and vcpu_put, we improve handling of VFP and debug registers.
We then introduce a new world-switch function for VHE systems, which we can tweak and optimize for VHE systems. To do that, we rework a lot of the system register save/restore handling and emulation code that may need access to system registers, so that we can defer as many system register save/restore operations to vcpu_load and vcpu_put, and move this logic out of the VHE world switch function.
We then optimize the configuration of traps. On non-VHE systems, both the host and VM kernels run in EL1, but because the host kernel should have full access to the underlying hardware, but the VM kernel should not, we essentially make the host kernel more privileged than the VM kernel despite them both running at the same privilege level by enabling VE traps when entering the VM and disabling those traps when exiting the VM. On VHE systems, the host kernel runs in EL2 and has full access to the hardware (as much as allowed by secure side software), and is unaffected by the trap configuration. That means we can configure the traps for VMs running in EL1 once, and don't have to switch them on and off for every entry/exit to/from the VM.
Finally, we improve our VGIC handling by moving all save/restore logic out of the VHE world-switch, and we make it possible to truly only evaluate if the AP list is empty and not do *any* VGIC work if that is the case, and only do the minimal amount of work required in the course of the VGIC processing when we have virtual interrupts in flight.
The patches are based on v4.16-rc3 with kvmarm/next and kvmarm/master applied on top.
I've given the patches a fair amount of testing on Thunder-X, Mustang, Seattle, and TC2 (32-bit) for non-VHE testing, and tested VHE functionality on TX2 and on the foundation model.
The patches are also available in the vhe-optimize-v5 branch on my kernel.org repository [1]. The vhe-optimize-v5-base branch contains prerequisites of this series.
Patches 36, 38, and 40 are missing Acked-by or Reviewed-by tags.
[1]: git://git.kernel.org/pub/scm/linux/kernel/git/cdall/linux.git vhe-optimize-v5
Changes since v4:
- Rebased on v4.16-rc3 and other patches queued for kvmarm/next.
- Mostly cosmetic, detailed changelogs are in the individual patches.
- Patch 13 introduces an additional ISB on return from the VHE run function which we lost now when we no longer call the kvm_call_hyp() wrapper which used to take care of that for us.
Changes since v3:
- Rebased on v4.16-rc1 (fun!)
- Removed VFP optimizations because it was discovered that the deferred approach taken in v3 was buggy
(https://lists.cs.columbia.edu/pipermail/kvmarm/2018-February/029838.html)
This causes a fair amount of changes throughout and I've removed affected reviewed-by and other tags as best I could to take this into account.
- Used a switch-statement to handle deferred system registers instead of the macro approach taken in v3.
- Addressed other review coments (tried to keep track of this with logs of changes in individual patches).
- I ran Yury's IPI benchark test and other tests on TX2 and could not observe a performance regression, but rather an improvement of around 65%. I suspect the previous regression was due to the timer WFI problem solved for v4.16-rc1.
- I haven't included Tomasz' reviewed-by, because I figured too much of the series has changed since v3.
Changes since v2:
- Rebased on v4.15-rc3.
- Includes two additional patches that only does vcpu_load after kvm_vcpu_first_run_init and only for KVM_RUN.
- Addressed review comments from v2 (detailed changelogs are in the individual patches).
Thanks,
-Christoffer
Christoffer Dall (39):
KVM: arm/arm64: Avoid vcpu_load for other vcpu ioctls than KVM_RUN
KVM: arm/arm64: Move vcpu_load call after kvm_vcpu_first_run_init
KVM: arm64: Avoid storing the vcpu pointer on the stack
KVM: arm64: Rework hyp_panic for VHE and non-VHE
KVM: arm/arm64: Get rid of vcpu->arch.irq_lines
KVM: arm/arm64: Add kvm_vcpu_load_sysregs and kvm_vcpu_put_sysregs
KVM: arm/arm64: Introduce vcpu_el1_is_32bit
KVM: arm64: Move debug dirty flag calculation out of world switch
KVM: arm64: Slightly improve debug save/restore functions
KVM: arm64: Improve debug register save/restore flow
KVM: arm64: Factor out fault info population and gic workarounds
KVM: arm64: Introduce VHE-specific kvm_vcpu_run
KVM: arm64: Remove kern_hyp_va() use in VHE switch function
KVM: arm64: Don't deactivate VM on VHE systems
KVM: arm64: Remove noop calls to timer save/restore from VHE switch
KVM: arm64: Move userspace system registers into separate function
KVM: arm64: Rewrite sysreg alternatives to static keys
KVM: arm64: Introduce separate VHE/non-VHE sysreg save/restore
functions
KVM: arm/arm64: Remove leftover comment from kvm_vcpu_run_vhe
KVM: arm64: Unify non-VHE host/guest sysreg save and restore functions
KVM: arm64: Don't save the host ELR_EL2 and SPSR_EL2 on VHE systems
KVM: arm64: Change 32-bit handling of VM system registers
KVM: arm64: Rewrite system register accessors to read/write functions
KVM: arm64: Introduce framework for accessing deferred sysregs
KVM: arm/arm64: Prepare to handle deferred save/restore of SPSR_EL1
KVM: arm64: Prepare to handle deferred save/restore of ELR_EL1
KVM: arm64: Defer saving/restoring 64-bit sysregs to vcpu load/put on
VHE
KVM: arm64: Prepare to handle deferred save/restore of 32-bit
registers
KVM: arm64: Defer saving/restoring 32-bit sysregs to vcpu load/put
KVM: arm64: Move common VHE/non-VHE trap config in separate functions
KVM: arm64: Directly call VHE and non-VHE FPSIMD enabled functions
KVM: arm64: Configure c15, PMU, and debug register traps on cpu
load/put for VHE
KVM: arm64: Cleanup __activate_traps and __deactive_traps for VHE and
non-VHE
KVM: arm/arm64: Get rid of vgic_elrsr
KVM: arm/arm64: Handle VGICv2 save/restore from the main VGIC code
KVM: arm/arm64: Move arm64-only vgic-v2-sr.c file to arm64
KVM: arm/arm64: Handle VGICv3 save/restore from the main VGIC code on
VHE
KVM: arm/arm64: Move VGIC APR save/restore to vgic put/load
KVM: arm/arm64: Avoid VGICv3 save/restore on VHE with no IRQs
Shih-Wei Li (1):
KVM: arm64: Move HCR_INT_OVERRIDE to default HCR_EL2 guest flag
arch/arm/include/asm/kvm_asm.h | 5 +- arch/arm/include/asm/kvm_emulate.h | 21 +- arch/arm/include/asm/kvm_host.h | 6 +- arch/arm/include/asm/kvm_hyp.h | 4 + arch/arm/kvm/emulate.c | 4 +- arch/arm/kvm/hyp/Makefile | 1 - arch/arm/kvm/hyp/switch.c | 16 +- arch/arm64/include/asm/kvm_arm.h | 4 +- arch/arm64/include/asm/kvm_asm.h | 19 +- arch/arm64/include/asm/kvm_emulate.h | 74 ++-- arch/arm64/include/asm/kvm_host.h | 53 ++- arch/arm64/include/asm/kvm_hyp.h | 29 +- arch/arm64/include/asm/kvm_mmu.h | 2 +- arch/arm64/kernel/asm-offsets.c | 1 + arch/arm64/kvm/debug.c | 29 +- arch/arm64/kvm/guest.c | 3 - arch/arm64/kvm/hyp/Makefile | 2 +- arch/arm64/kvm/hyp/debug-sr.c | 88 ++--- arch/arm64/kvm/hyp/entry.S | 6 +- arch/arm64/kvm/hyp/hyp-entry.S | 28 +- arch/arm64/kvm/hyp/switch.c | 378 ++++++++++++--------- arch/arm64/kvm/hyp/sysreg-sr.c | 172 ++++++++-- .../arm64/kvm/hyp/vgic-v2-cpuif-proxy.c | 81 ----- arch/arm64/kvm/inject_fault.c | 24 +- arch/arm64/kvm/regmap.c | 67 +++- arch/arm64/kvm/sys_regs.c | 173 ++++++++-- arch/arm64/kvm/sys_regs.h | 4 +- arch/arm64/kvm/sys_regs_generic_v8.c | 4 +- include/kvm/arm_vgic.h | 2 - virt/kvm/arm/aarch32.c | 2 +- virt/kvm/arm/arch_timer.c | 4 - virt/kvm/arm/arm.c | 57 ++-- virt/kvm/arm/hyp/timer-sr.c | 44 +-- virt/kvm/arm/hyp/vgic-v3-sr.c | 244 +++++++------ virt/kvm/arm/mmu.c | 6 +- virt/kvm/arm/pmu.c | 36 +- virt/kvm/arm/vgic/vgic-init.c | 11 - virt/kvm/arm/vgic/vgic-v2.c | 61 +++- virt/kvm/arm/vgic/vgic-v3.c | 12 +- virt/kvm/arm/vgic/vgic.c | 33 ++ virt/kvm/arm/vgic/vgic.h | 3 + 41 files changed, 1136 insertions(+), 677 deletions(-) rename virt/kvm/arm/hyp/vgic-v2-sr.c => arch/arm64/kvm/hyp/vgic-v2-cpuif-proxy.c (51%)
Signature · 1 line
2.14.2
PATCH v5 36/40 KVM: arm/arm64: Handle VGICv2 save/restore from the main VGIC code
From: Christoffer Dall <[email protected]>
We can program the GICv2 hypervisor control interface logic directly from the core vgic code and can instead do the save/restore directly from the flush/sync functions, which can lead to a number of future optimizations.
---
Notes:
Changes since v1:
- Removed unnecessary kvm_hyp.h include
- Adapted the patch based on having gotten rid of storing the elrsr prior to this patch.
- No longer change the interrupt handling of the maintenance interrupt handler. That seems to have been a leftover from an earlier version of the timer patches where we were syncing the vgic state after having enabled interrupts, leading to the maintenance interrupt firing.
It may be possible to move the vgic sync function out to an interrupts enabled section later on, which would require re-introducing logic to disable the VGIC maintenance interrupt in the maintenance interrupt handler, but we leave this for future work as the immediate benefit is not clear.
arch/arm/kvm/hyp/switch.c | 4 --- arch/arm64/include/asm/kvm_hyp.h | 2 -- arch/arm64/kvm/hyp/switch.c | 4 --- virt/kvm/arm/hyp/vgic-v2-sr.c | 65 ---------------------------------------- virt/kvm/arm/vgic/vgic-v2.c | 63 ++++++++++++++++++++++++++++++++++++++ virt/kvm/arm/vgic/vgic.c | 19 +++++++++++- virt/kvm/arm/vgic/vgic.h | 3 ++ 7 files changed, 84 insertions(+), 76 deletions(-)
arch/arm/kvm/hyp/switch.c +0 -4
@@ -92,16 +92,12 @@ static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_save_state (vcpu); -else -__vgic_v2_save_state (vcpu); } static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_restore_state (vcpu); -else -__vgic_v2_restore_state (vcpu); } static bool __hyp_text __populate_fault_info(struct kvm_vcpu *vcpu)
arch/arm64/include/asm/kvm_hyp.h +0 -2
@@ -120,8 +120,6 @@ typeof(orig) * __hyp_text fname(void) \return val; \ } -void __vgic_v2_save_state (struct kvm_vcpu *vcpu); -void __vgic_v2_restore_state (struct kvm_vcpu *vcpu);int __vgic_v2_perform_cpuif_access (struct kvm_vcpu *vcpu);void __vgic_v3_save_state (struct kvm_vcpu *vcpu);
arch/arm64/kvm/hyp/switch.c +0 -4
@@ -196,16 +196,12 @@ static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_save_state (vcpu); -else -__vgic_v2_save_state (vcpu); } static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_restore_state (vcpu); -else -__vgic_v2_restore_state (vcpu); } static bool __hyp_text __true_value(void)
virt/kvm/arm/hyp/vgic-v2-sr.c +0 -65
71 lines not on this page · raw message
virt/kvm/arm/vgic/vgic-v2.c +63 -0
69 lines not on this page · raw message
virt/kvm/arm/vgic/vgic.c +18 -1
@@ -749,11 +749,19 @@ static void vgic_flush_lr_state(struct kvm_vcpu *vcpu)vgic_clear_lr (vcpu, count); } +static inline void vgic_save_state (struct kvm_vcpu *vcpu) +{ +if (!static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif)) +vgic_v2_save_state (vcpu); +} +/* Sync back the hardware VGIC state into our emulation after a guest's run. */ void kvm_vgic_sync_hwstate (struct kvm_vcpu *vcpu) {struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; +vgic_save_state (vcpu); +WARN_ON (vgic_v4_sync_hwstate (vcpu));/* An empty ap_list_head implies used_lrs == 0 */
@@ -765,6 +773,12 @@ void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu)vgic_prune_ap_list (vcpu); } +static inline void vgic_restore_state (struct kvm_vcpu *vcpu) +{ +if (!static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif)) +vgic_v2_restore_state (vcpu); +} +/* Flush our emulation state into the GIC hardware before entering the guest. */ void kvm_vgic_flush_hwstate (struct kvm_vcpu *vcpu) {
@@ -780,13 +794,16 @@ void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu)* this. */ if (list_empty (&vcpu->arch.vgic_cpu.ap_list_head)) -return ; + goto out;DEBUG_SPINLOCK_BUG_ON (!irqs_disabled ());spin_lock (&vcpu->arch.vgic_cpu.ap_list_lock);vgic_flush_lr_state (vcpu);spin_unlock (&vcpu->arch.vgic_cpu.ap_list_lock); + +out: +vgic_restore_state (vcpu); }void kvm_vgic_load (struct kvm_vcpu *vcpu)
virt/kvm/arm/vgic/vgic.h +3 -0
@@ -176,6 +176,9 @@ void vgic_v2_init_lrs(void);void vgic_v2_load (struct kvm_vcpu *vcpu);void vgic_v2_put (struct kvm_vcpu *vcpu); +void vgic_v2_save_state (struct kvm_vcpu *vcpu); +void vgic_v2_restore_state (struct kvm_vcpu *vcpu); +static inline void vgic_get_irq_kref (struct vgic_irq *irq) {if (irq->intid <VGIC_MIN_LPI )
Signature · 1 line
2.14.2
PATCH v5 1/40 KVM: arm/arm64: Avoid vcpu_load for other vcpu ioctls than KVM_RUN
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
Calling vcpu_load() registers preempt notifiers for this vcpu and calls kvm_arch_vcpu_load(). The latter will soon be doing a lot of heavy lifting on arm/arm64 and will try to do things such as enabling the virtual timer and setting us up to handle interrupts from the timer hardware.
Loading state onto hardware registers and enabling hardware to signal interrupts can be problematic when we're not actually about to run the VCPU, because it makes it difficult to establish the right context when handling interrupts from the timer, and it makes the register access code difficult to reason about.
Luckily, now when we call vcpu_load in each ioctl implementation, we can simply remove the call from the non-KVM_RUN vcpu ioctls, and our kvm_arch_vcpu_load() is only used for loading vcpu content to the physical CPU when we're actually going to run the vcpu.
--- arch/arm64/kvm/guest.c | 3 --- virt/kvm/arm/arm.c | 9 --------- 2 files changed, 12 deletions(-)
arch/arm64/kvm/guest.c +0 -3
@@ -363,8 +363,6 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, {int ret =0 ; -vcpu_load (vcpu); -trace_kvm_set_guest_debug (vcpu, dbg->control);if (dbg->control & ~KVM_GUESTDBG_VALID_MASK ) {
@@ -386,7 +384,6 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, } out: -vcpu_put (vcpu);return ret; }
virt/kvm/arm/arm.c +0 -9
@@ -384,14 +384,11 @@ static void vcpu_power_off(struct kvm_vcpu *vcpu)int kvm_arch_vcpu_ioctl_get_mpstate (struct kvm_vcpu *vcpu,struct kvm_mp_state *mp_state) { -vcpu_load (vcpu); -if (vcpu->arch.power_off) mp_state->mp_state =KVM_MP_STATE_STOPPED ;else mp_state->mp_state =KVM_MP_STATE_RUNNABLE ; -vcpu_put (vcpu);return 0 ; }
@@ -400,8 +397,6 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, {int ret =0 ; -vcpu_load (vcpu); -switch (mp_state->mp_state) {case KVM_MP_STATE_RUNNABLE : vcpu->arch.power_off = false;
@@ -413,7 +408,6 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, ret = -EINVAL ; } -vcpu_put (vcpu);return ret; }
@@ -1036,8 +1030,6 @@ long kvm_arch_vcpu_ioctl(struct file *filp,struct kvm_device_attr attr;long r; -vcpu_load (vcpu); -switch (ioctl) {case KVM_ARM_VCPU_INIT : {struct kvm_vcpu_init init;
@@ -1114,7 +1106,6 @@ long kvm_arch_vcpu_ioctl(struct file *filp, r = -EINVAL ; } -vcpu_put (vcpu);return r; }
Signature · 1 line
2.14.2
PATCH v5 7/40 KVM: arm/arm64: Add kvm_vcpu_load_sysregs and kvm_vcpu_put_sysregs
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
As we are about to move a bunch of save/restore logic for VHE kernels to the load and put functions, we need some infrastructure to do this.
---
Notes:
Changes since v1:
- Reworded comments as suggested by Drew
arch/arm/include/asm/kvm_host.h | 3 +++ arch/arm64/include/asm/kvm_host.h | 3 +++ arch/arm64/kvm/hyp/sysreg-sr.c | 30 ++++++++++++++++++++++++++++++ virt/kvm/arm/arm.c | 2 ++ 4 files changed, 38 insertions(+)
arch/arm/include/asm/kvm_host.h +3 -0
@@ -312,4 +312,7 @@ static inline bool kvm_arm_harden_branch_predictor(void) return false; } +static inline void kvm_vcpu_load_sysregs (struct kvm_vcpu *vcpu) {} +static inline void kvm_vcpu_put_sysregs (struct kvm_vcpu *vcpu) {} +#endif /* __ARM_KVM_HOST_H__ */
arch/arm64/include/asm/kvm_host.h +3 -0
@@ -435,4 +435,7 @@ static inline bool kvm_arm_harden_branch_predictor(void) return cpus_have_const_cap(ARM64_HARDEN_BRANCH_PREDICTOR); } +void kvm_vcpu_load_sysregs (struct kvm_vcpu *vcpu); +void kvm_vcpu_put_sysregs (struct kvm_vcpu *vcpu); +#endif /* __ARM64_KVM_HOST_H__ */
arch/arm64/kvm/hyp/sysreg-sr.c +30 -0
@@ -190,6 +190,36 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu)write_sysreg (sysreg[DBGVCR32_EL2 ], dbgvcr32_el2); } +/** +* kvm_vcpu_load_sysregs - Load guest system registers to the physical CPU +* +* @vcpu: The VCPU pointer +* +* Load system registers that do not affect the host's execution, for +* example EL1 system registers on a VHE system where the host kernel +* runs at EL2. This function is called from KVM's vcpu_load() function +* and loading system register state early avoids having to load them on +* every entry to the VM. +*/ +void kvm_vcpu_load_sysregs (struct kvm_vcpu *vcpu) +{ +} + +/** +* kvm_vcpu_put_sysregs - Restore host system registers to the physical CPU +* +* @vcpu: The VCPU pointer +* +* Save guest system registers that do not affect the host's execution, for +* example EL1 system registers on a VHE system where the host kernel +* runs at EL2. This function is called from KVM's vcpu_put() function +* and deferring saving system register state until we're no longer running the +* VCPU avoids having to save them on every exit from the VM. +*/ +void kvm_vcpu_put_sysregs (struct kvm_vcpu *vcpu) +{ +} + void __hyp_text __kvm_set_tpidr_el2(u64 tpidr_el2) { asm("msr tpidr_el2, %0" : :"r" (tpidr_el2));
virt/kvm/arm/arm.c +2 -0
@@ -362,10 +362,12 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)kvm_arm_set_running_vcpu (vcpu);kvm_vgic_load (vcpu);kvm_timer_vcpu_load (vcpu); +kvm_vcpu_load_sysregs (vcpu); }void kvm_arch_vcpu_put (struct kvm_vcpu *vcpu) { +kvm_vcpu_put_sysregs (vcpu);kvm_timer_vcpu_put (vcpu);kvm_vgic_put (vcpu);
Signature · 1 line
2.14.2
PATCH v5 37/40 KVM: arm/arm64: Move arm64-only vgic-v2-sr.c file to arm64
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
The vgic-v2-sr.c file now only contains the logic to replay unaligned accesses to the virtual CPU interface on 16K and 64K page systems, which is only relevant on 64-bit platforms. Therefore move this file to the arm64 KVM tree, remove the compile directive from the 32-bit side makefile, and remove the ifdef in the C file.
Since this file also no longer saves/restores anything, rename the file to vgic-v2-cpuif-proxy.c to more accurately describe the logic in this file.
---
Notes:
Changes since v4:
- Renamed file to vgic-v2-cpuif-proxy.c as suggested by Marc.
arch/arm/kvm/hyp/Makefile | 1 - arch/arm64/kvm/hyp/Makefile | 2 +- .../arm/hyp/vgic-v2-sr.c => arch/arm64/kvm/hyp/vgic-v2-cpuif-proxy.c | 2 -- 3 files changed, 1 insertion(+), 4 deletions(-) rename virt/kvm/arm/hyp/vgic-v2-sr.c => arch/arm64/kvm/hyp/vgic-v2-cpuif-proxy.c (98%)
arch/arm/kvm/hyp/Makefile +0 -1
@@ -7,7 +7,6 @@ ccflags-y += -fno-stack-protector -DDISABLE_BRANCH_PROFILING KVM=../../../../virt/kvm -obj-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hyp/vgic-v2-sr.o obj-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hyp/vgic-v3-sr.o obj-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hyp/timer-sr.o
arch/arm64/kvm/hyp/Makefile +1 -1
@@ -7,10 +7,10 @@ ccflags-y += -fno-stack-protector -DDISABLE_BRANCH_PROFILING KVM=../../../../virt/kvm -obj-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hyp/vgic-v2-sr.o obj-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hyp/vgic-v3-sr.o obj-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hyp/timer-sr.o +obj-$(CONFIG_KVM_ARM_HOST) += vgic-v2-cpuif-proxy.o obj-$(CONFIG_KVM_ARM_HOST) += sysreg-sr.o obj-$(CONFIG_KVM_ARM_HOST) += debug-sr.o obj-$(CONFIG_KVM_ARM_HOST) += entry.o
arch/arm64/kvm/hyp/vgic-v2-cpuif-proxy.c renamed from virt/kvm/arm/hyp/vgic-v2-sr.c +0 -2
@@ -23,7 +23,6 @@#include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> -#ifdef CONFIG_ARM64 /* * __vgic_v2_perform_cpuif_access -- perform a GICV access on behalf of the * guest.
@@ -77,4 +76,3 @@ int __hyp_text __vgic_v2_perform_cpuif_access(struct kvm_vcpu *vcpu)return 1 ; } -#endif
Signature · 1 line
2.14.2
PATCH v5 25/40 KVM: arm64: Introduce framework for accessing deferred sysregs
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
We are about to defer saving and restoring some groups of system registers to vcpu_put and vcpu_load on supported systems. This means that we need some infrastructure to access system registes which supports either accessing the memory backing of the register or directly accessing the system registers, depending on the state of the system when we access the register.
We do this by defining read/write accessor functions, which can handle both "immediate" and "deferrable" system registers. Immediate registers are always saved/restored in the world-switch path, but deferrable registers are only saved/restored in vcpu_put/vcpu_load when supported and sysregs_loaded_on_cpu will be set in that case.
Note that we don't use the deferred mechanism yet in this patch, but only introduce infrastructure. This is to improve convenience of review in the subsequent patches where it is clear which registers become deferred.
---
Notes:
Changes since v4:
- Slightly reworded commentary based on Drew's feedback
Changes since v3:
- Changed to a switch-statement based approach to improve readability.
Changes since v2:
- New patch (deferred register handling has been reworked)
arch/arm64/include/asm/kvm_host.h | 8 ++++++-- arch/arm64/kvm/sys_regs.c | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 2 deletions(-)
arch/arm64/include/asm/kvm_host.h +6 -2
@@ -284,6 +284,10 @@ struct kvm_vcpu_arch {/* Virtual SError ESR to restore when HCR_EL2.VSE is set */ u64 vsesr_el2; + +/* True when deferrable sysregs are loaded on the physical CPU, +* see kvm_vcpu_load_sysregs and kvm_vcpu_put_sysregs. */ +bool sysregs_loaded_on_cpu; };#define vcpu_gp_regs (v) (&(v)->arch.ctxt.gp_regs)
@@ -296,8 +300,8 @@ struct kvm_vcpu_arch {*/ #define __vcpu_sys_reg (v,r) ((v)->arch.ctxt.sys_regs[(r)]) -#define vcpu_read_sys_reg (v,r) __vcpu_sys_reg(v,r) -#define vcpu_write_sys_reg (v,n,r) do { __vcpu_sys_reg(v,r) = n; } while (0) +u64 vcpu_read_sys_reg (struct kvm_vcpu *vcpu,int reg); +void vcpu_write_sys_reg (struct kvm_vcpu *vcpu,u64 val,int reg);/* * CP14 and CP15 live in the same array, as they are backed by the
arch/arm64/kvm/sys_regs.c +33 -0
@@ -35,6 +35,7 @@#include <asm/kvm_coproc.h> #include <asm/kvm_emulate.h> #include <asm/kvm_host.h> +#include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> #include <asm/perf_event.h> #include <asm/sysreg.h>
@@ -76,6 +77,38 @@ static bool write_to_read_only(struct kvm_vcpu *vcpu,return false; } +u64 vcpu_read_sys_reg (struct kvm_vcpu *vcpu,int reg) +{ +if (!vcpu->arch.sysregs_loaded_on_cpu) + goto immediate_read; + +/* +* System registers listed in the switch are not saved on every +* exit from the guest but are only saved on vcpu_put. +*/ +switch (reg) { + } + +immediate_read: +return __vcpu_sys_reg (vcpu, reg); +} + +void vcpu_write_sys_reg (struct kvm_vcpu *vcpu,u64 val,int reg) +{ +if (!vcpu->arch.sysregs_loaded_on_cpu) + goto immediate_write; + +/* +* System registers listed in the switch are not restored on every +* entry to the guest but are only restored on vcpu_load. +*/ +switch (reg) { + } + +immediate_write: +__vcpu_sys_reg (vcpu, reg) = val; +} +/* 3 bits per cache level, as per CLIDR, but non-existent caches always 0 */ static u32 cache_levels;
Signature · 1 line
2.14.2
PATCH v5 29/40 KVM: arm64: Prepare to handle deferred save/restore of 32-bit registers
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
32-bit registers are not used by a 64-bit host kernel and can be deferred, but we need to rework the accesses to these register to access the latest values depending on whether or not guest system registers are loaded on the CPU or only reside in memory.
---
Notes:
Changes since v4:
- Fixed typos in commit message
- Moved change to read/write sysreg to the following patch as suggested by Drew
Changes since v3:
- Don't also try to write hardware spsr when sysregs are not loaded
- Adapted patch to use switch-based sysreg save/restore approach
- (Kept additional BUG_ON() in vcpu_read_spsr32() to keep the compiler happy)
Changes since v2:
- New patch (deferred register handling has been reworked)
arch/arm64/include/asm/kvm_emulate.h | 32 +++++------------ arch/arm64/kvm/regmap.c | 67 +++++++++++++++++++++++++++--------- 2 files changed, 59 insertions(+), 40 deletions(-)
arch/arm64/include/asm/kvm_emulate.h +9 -23
@@ -33,7 +33,8 @@#include <asm/virt.h> unsigned long *vcpu_reg32 (const struct kvm_vcpu *vcpu,u8 reg_num); -unsigned long *vcpu_spsr32 (const struct kvm_vcpu *vcpu); +unsigned long vcpu_read_spsr32 (const struct kvm_vcpu *vcpu); +void vcpu_write_spsr32 (struct kvm_vcpu *vcpu,unsigned long v);bool kvm_condition_valid32 (const struct kvm_vcpu *vcpu);void kvm_skip_instr32 (struct kvm_vcpu *vcpu,bool is_wide_instr);
@@ -162,41 +163,26 @@ static inline void vcpu_set_reg(struct kvm_vcpu *vcpu, u8 reg_num,static inline unsigned long vcpu_read_spsr (const struct kvm_vcpu *vcpu) { -unsigned long *p = (unsigned long *)&vcpu_gp_regs (vcpu)->spsr[KVM_SPSR_EL1 ]; - -if (vcpu_mode_is_32bit (vcpu)) { -unsigned long *p_32bit =vcpu_spsr32 (vcpu); - -/* KVM_SPSR_SVC aliases KVM_SPSR_EL1 */ -if (p_32bit != p) -return *p_32bit; - } +if (vcpu_mode_is_32bit (vcpu)) +return vcpu_read_spsr32 (vcpu);if (vcpu->arch.sysregs_loaded_on_cpu)return read_sysreg_el1 (spsr);else -return *p; +return vcpu_gp_regs (vcpu)->spsr[KVM_SPSR_EL1 ]; } -static inline void vcpu_write_spsr (const struct kvm_vcpu *vcpu,unsigned long v) +static inline void vcpu_write_spsr (struct kvm_vcpu *vcpu,unsigned long v) { -unsigned long *p = (unsigned long *)&vcpu_gp_regs (vcpu)->spsr[KVM_SPSR_EL1 ]; - -/* KVM_SPSR_SVC aliases KVM_SPSR_EL1 */ if (vcpu_mode_is_32bit (vcpu)) { -unsigned long *p_32bit =vcpu_spsr32 (vcpu); - -/* KVM_SPSR_SVC aliases KVM_SPSR_EL1 */ -if (p_32bit != p) { - *p_32bit = v; -return ; - } +vcpu_write_spsr32 (vcpu, v); +return ; }if (vcpu->arch.sysregs_loaded_on_cpu)write_sysreg_el1 (v, spsr);else - *p = v; +vcpu_gp_regs (vcpu)->spsr[KVM_SPSR_EL1 ] = v; }static inline bool vcpu_mode_priv (const struct kvm_vcpu *vcpu)
arch/arm64/kvm/regmap.c +50 -17
78 lines not on this page · raw message
Signature · 1 line
2.14.2
PATCH v5 31/40 KVM: arm64: Move common VHE/non-VHE trap config in separate functions
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
As we are about to be more lazy with some of the trap configuration register read/writes for VHE systems, move the logic that is currently shared between VHE and non-VHE into a separate function which can be called from either the world-switch path or from vcpu_load/vcpu_put.
---
Notes:
Changes since v4:
- Added blank newline to separate logic blocks in __activate_traps_common.
Changes since v3:
- Separate fpsimd32 trap configuration into a separate function which is still called from __activate_traps, because we no longer defer saving/restoring of VFP registers to load/put.
arch/arm64/kvm/hyp/switch.c | 77 +++++++++++++++++++++++++++------------------ 1 file changed, 46 insertions(+), 31 deletions(-)
arch/arm64/kvm/hyp/switch.c +46 -31
@@ -56,7 +56,46 @@ static void __hyp_text __fpsimd_save_fpexc32(struct kvm_vcpu *vcpu) vcpu->arch.ctxt.sys_regs[FPEXC32_EL2 ] =read_sysreg (fpexc32_el2); } -static void __hyp_text __activate_traps_vhe(void) +static void __hyp_text __activate_traps_fpsimd32(struct kvm_vcpu *vcpu) +{ +/* +* We are about to set CPTR_EL2.TFP to trap all floating point +* register accesses to EL2, however, the ARM ARM clearly states that +* traps are only taken to EL2 if the operation would not otherwise +* trap to EL1. Therefore, always make sure that for 32-bit guests, +* we set FPEXC.EN to prevent traps to EL1, when setting the TFP bit. +* If FP/ASIMD is not implemented, FPEXC is UNDEFINED and any access to +* it will cause an exception. +*/ +if (vcpu_el1_is_32bit (vcpu) &&system_supports_fpsimd ()) { +write_sysreg (1 <<30 , fpexc32_el2); +isb (); + } +} + +static void __hyp_text __activate_traps_common(struct kvm_vcpu *vcpu) +{ +/* Trap on AArch32 cp15 c15 (impdef sysregs) accesses (EL1 or EL0) */ +write_sysreg (1 <<15 , hstr_el2); + +/* +* Make sure we trap PMU access from EL0 to EL2. Also sanitize +* PMSELR_EL0 to make sure it never contains the cycle +* counter, which could make a PMXEVCNTR_EL0 access UNDEF at +* EL1 instead of being trapped to EL2. +*/ +write_sysreg (0 , pmselr_el0); +write_sysreg (ARMV8_PMU_USERENR_MASK , pmuserenr_el0); +write_sysreg (vcpu->arch.mdcr_el2, mdcr_el2); +} + +static void __hyp_text __deactivate_traps_common(void) +{ +write_sysreg (0 , hstr_el2); +write_sysreg (0 , pmuserenr_el0); +} + +static void __hyp_text __activate_traps_vhe(struct kvm_vcpu *vcpu) {u64 val;
@@ -68,7 +107,7 @@ static void __hyp_text __activate_traps_vhe(void)write_sysreg (kvm_get_hyp_vector (), vbar_el1); } -static void __hyp_text __activate_traps_nvhe(void) +static void __hyp_text __activate_traps_nvhe(struct kvm_vcpu *vcpu) {u64 val;
@@ -85,37 +124,14 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu) {u64 hcr = vcpu->arch.hcr_el2; -/* -* We are about to set CPTR_EL2.TFP to trap all floating point -* register accesses to EL2, however, the ARM ARM clearly states that -* traps are only taken to EL2 if the operation would not otherwise -* trap to EL1. Therefore, always make sure that for 32-bit guests, -* we set FPEXC.EN to prevent traps to EL1, when setting the TFP bit. -* If FP/ASIMD is not implemented, FPEXC is UNDEFINED and any access to -* it will cause an exception. -*/ -if (vcpu_el1_is_32bit (vcpu) &&system_supports_fpsimd ()) { -write_sysreg (1 <<30 , fpexc32_el2); -isb (); - } +write_sysreg (hcr, hcr_el2);if (cpus_have_const_cap (ARM64_HAS_RAS_EXTN ) && (hcr &HCR_VSE ))write_sysreg_s (vcpu->arch.vsesr_el2,SYS_VSESR_EL2 ); -write_sysreg (hcr, hcr_el2); - -/* Trap on AArch32 cp15 c15 accesses (EL1 or EL0) */ -write_sysreg (1 <<15 , hstr_el2); -/* -* Make sure we trap PMU access from EL0 to EL2. Also sanitize -* PMSELR_EL0 to make sure it never contains the cycle -* counter, which could make a PMXEVCNTR_EL0 access UNDEF at -* EL1 instead of being trapped to EL2. -*/ -write_sysreg (0 , pmselr_el0); -write_sysreg (ARMV8_PMU_USERENR_MASK , pmuserenr_el0); -write_sysreg (vcpu->arch.mdcr_el2, mdcr_el2); -__activate_traps_arch ()(); +__activate_traps_fpsimd32 (vcpu); +__activate_traps_common (vcpu); +__activate_traps_arch ()(vcpu); } static void __hyp_text __deactivate_traps_vhe(void)
@@ -160,9 +176,8 @@ static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu)if (vcpu->arch.hcr_el2 &HCR_VSE ) vcpu->arch.hcr_el2 =read_sysreg (hcr_el2); +__deactivate_traps_common ();__deactivate_traps_arch ()(); -write_sysreg (0 , hstr_el2); -write_sysreg (0 , pmuserenr_el0); } static void __hyp_text __activate_vm(struct kvm *kvm)
Signature · 1 line
2.14.2
PATCH v5 34/40 KVM: arm64: Cleanup __activate_traps and __deactive_traps for VHE and non-VHE
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
To make the code more readable and to avoid the overhead of a function call, let's get rid of a pair of the alternative function selectors and explicitly call the VHE and non-VHE functions using the has_vhe() static key based selector instead, telling the compiler to try to inline the static function if it can.
---
Notes:
Changes since v4:
- Removed inline attributes from static functions in arch/arm64/kvm/hyp/switch.c
arch/arm64/kvm/hyp/switch.c | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-)
arch/arm64/kvm/hyp/switch.c +10 -12
@@ -86,7 +86,7 @@ static void __hyp_text __deactivate_traps_common(void)write_sysreg (0 , pmuserenr_el0); } -static void __hyp_text __activate_traps_vhe(struct kvm_vcpu *vcpu) +static void activate_traps_vhe (struct kvm_vcpu *vcpu) {u64 val;
@@ -109,10 +109,6 @@ static void __hyp_text __activate_traps_nvhe(struct kvm_vcpu *vcpu)write_sysreg (val, cptr_el2); } -static hyp_alternate_select(__activate_traps_arch, - __activate_traps_nvhe, __activate_traps_vhe, - ARM64_HAS_VIRT_HOST_EXTN); - static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu) {u64 hcr = vcpu->arch.hcr_el2;
@@ -123,10 +119,13 @@ static void __hyp_text __activate_traps(struct kvm_vcpu *vcpu)write_sysreg_s (vcpu->arch.vsesr_el2,SYS_VSESR_EL2 );__activate_traps_fpsimd32 (vcpu); -__activate_traps_arch ()(vcpu); +if (has_vhe ()) +activate_traps_vhe (vcpu); +else +__activate_traps_nvhe (vcpu); } -static void __hyp_text __deactivate_traps_vhe(void) +static void deactivate_traps_vhe (void ) {extern char vectors[];/* kernel exception vectors */ write_sysreg (HCR_HOST_VHE_FLAGS , hcr_el2);
@@ -148,10 +147,6 @@ static void __hyp_text __deactivate_traps_nvhe(void)write_sysreg (CPTR_EL2_DEFAULT , cptr_el2); } -static hyp_alternate_select(__deactivate_traps_arch, - __deactivate_traps_nvhe, __deactivate_traps_vhe, - ARM64_HAS_VIRT_HOST_EXTN); - static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu) {/*
@@ -163,7 +158,10 @@ static void __hyp_text __deactivate_traps(struct kvm_vcpu *vcpu)if (vcpu->arch.hcr_el2 &HCR_VSE ) vcpu->arch.hcr_el2 =read_sysreg (hcr_el2); -__deactivate_traps_arch ()(); +if (has_vhe ()) +deactivate_traps_vhe (); +else +__deactivate_traps_nvhe (); }void activate_traps_vhe_load (struct kvm_vcpu *vcpu)
Signature · 1 line
2.14.2
PATCH v5 38/40 KVM: arm/arm64: Handle VGICv3 save/restore from the main VGIC code on VHE
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
Just like we can program the GICv2 hypervisor control interface directly from the core vgic code, we can do the same for the GICv3 hypervisor control interface on VHE systems.
We do this by simply calling the save/restore functions when we have VHE and we can then get rid of the save/restore function calls from the VHE world switch function.
One caveat is that we now write GICv3 system register state before the potential early exit path in the run loop, and because we sync back state in the early exit path, we have to ensure that we read a consistent GIC state from the sync path, even though we have never actually run the guest with the newly written GIC state. We solve this by inserting an ISB in the early exit path.
---
Notes:
Changes since v4:
- Added can_access_vgic_from_kernel() primitive to make the save/restore flow from the main vgic code slightly easier to understand.
- Also added a __hyp prefix to the non-VHE world-switch save/restore functions for GICv3 to avoid confusion with the save/restore functions in the main VGIC code.
Changes since v2:
- Added ISB in the early exit path in the run loop as explained in the commit message.
arch/arm64/kvm/hyp/switch.c | 13 ++++++------- virt/kvm/arm/arm.c | 1 + virt/kvm/arm/vgic/vgic.c | 21 +++++++++++++++++++-- 3 files changed, 26 insertions(+), 9 deletions(-)
arch/arm64/kvm/hyp/switch.c +6 -7
@@ -192,13 +192,15 @@ static void __hyp_text __deactivate_vm(struct kvm_vcpu *vcpu)write_sysreg (0 , vttbr_el2); } -static void __hyp_text __vgic_save_state(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))__vgic_v3_save_state (vcpu); } -static void __hyp_text __vgic_restore_state(struct kvm_vcpu *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))__vgic_v3_restore_state (vcpu);
@@ -400,8 +402,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)__activate_traps (vcpu);__activate_vm (vcpu->kvm); -__vgic_restore_state (vcpu); -sysreg_restore_guest_state_vhe (guest_ctxt);__debug_switch_to_guest (vcpu);
@@ -415,7 +415,6 @@ int kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu) fp_enabled =fpsimd_enabled_vhe ();sysreg_save_guest_state_vhe (guest_ctxt); -__vgic_save_state (vcpu);__deactivate_traps (vcpu);
@@ -451,7 +450,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)__activate_traps (vcpu);__activate_vm (kern_hyp_va (vcpu->kvm)); -__vgic_restore_state (vcpu); +__hyp_vgic_restore_state (vcpu);__timer_enable_traps (vcpu);/*
@@ -484,7 +483,7 @@ int __hyp_text __kvm_vcpu_run_nvhe(struct kvm_vcpu *vcpu)__sysreg_save_state_nvhe (guest_ctxt);__sysreg32_save_state (vcpu);__timer_disable_traps (vcpu); -__vgic_save_state (vcpu); +__hyp_vgic_save_state (vcpu);__deactivate_traps (vcpu);__deactivate_vm (vcpu);
virt/kvm/arm/arm.c +1 -0
@@ -717,6 +717,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)if (ret <=0 ||need_new_vmid_gen (vcpu->kvm) ||kvm_request_pending (vcpu)) { vcpu->mode =OUTSIDE_GUEST_MODE ; +isb ();/* Ensure work in x_flush_hwstate is committed */ kvm_pmu_sync_hwstate (vcpu);if (static_branch_unlikely (&userspace_irqchip_in_use))kvm_timer_sync_hwstate (vcpu);
virt/kvm/arm/vgic/vgic.c +19 -2
@@ -19,6 +19,7 @@#include <linux/list_sort.h> #include <linux/interrupt.h> #include <linux/irq.h> +#include <asm/kvm_hyp.h> #include "vgic.h"
@@ -749,10 +750,22 @@ static void vgic_flush_lr_state(struct kvm_vcpu *vcpu)vgic_clear_lr (vcpu, count); } +static inline bool can_access_vgic_from_kernel (void ) +{ +/* +* GICv2 can always be accessed from the kernel because it is +* memory-mapped, and VHE systems can access GICv3 EL2 system +* registers. +*/ +return !static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif) ||has_vhe (); +} +static inline void vgic_save_state (struct kvm_vcpu *vcpu) {if (!static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))vgic_v2_save_state (vcpu); +else +__vgic_v3_save_state (vcpu); }/* Sync back the hardware VGIC state into our emulation after a guest's run. */
@@ -760,7 +773,8 @@ void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu) {struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; -vgic_save_state (vcpu); +if (can_access_vgic_from_kernel ()) +vgic_save_state (vcpu);WARN_ON (vgic_v4_sync_hwstate (vcpu));
@@ -777,6 +791,8 @@ static inline void vgic_restore_state(struct kvm_vcpu *vcpu) {if (!static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))vgic_v2_restore_state (vcpu); +else +__vgic_v3_restore_state (vcpu); }/* Flush our emulation state into the GIC hardware before entering the guest. */
@@ -803,7 +819,8 @@ void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu)spin_unlock (&vcpu->arch.vgic_cpu.ap_list_lock); out: -vgic_restore_state (vcpu); +if (can_access_vgic_from_kernel ()) +vgic_restore_state (vcpu); }void kvm_vgic_load (struct kvm_vcpu *vcpu)
Signature · 1 line
2.14.2
PATCH v5 39/40 KVM: arm/arm64: Move VGIC APR save/restore to vgic put/load
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
The APRs can only have bits set when the guest acknowledges an interrupt in the LR and can only have a bit cleared when the guest EOIs an interrupt in the LR. Therefore, if we have no LRs with any pending/active interrupts, the APR cannot change value and there is no need to clear it on every exit from the VM (hint: it will have already been cleared when we exited the guest the last time with the LRs all EOIed).
The only case we need to take care of is when we migrate the VCPU away from a CPU or migrate a new VCPU onto a CPU, or when we return to userspace to capture the state of the VCPU for migration. To make sure this works, factor out the APR save/restore functionality into separate functions called from the VCPU (and by extension VGIC) put/load hooks.
--- arch/arm/include/asm/kvm_hyp.h | 2 + arch/arm64/include/asm/kvm_hyp.h | 2 + virt/kvm/arm/hyp/vgic-v3-sr.c | 124 +++++++++++++++++++++------------------ virt/kvm/arm/vgic/vgic-v2.c | 7 +-- virt/kvm/arm/vgic/vgic-v3.c | 5 ++ 5 files changed, 78 insertions(+), 62 deletions(-)
arch/arm/include/asm/kvm_hyp.h +2 -0
@@ -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_save_aprs (struct kvm_vcpu *vcpu); +void __vgic_v3_restore_aprs (struct kvm_vcpu *vcpu); asmlinkage void __vfp_save_state(struct vfp_hard_struct *vfp); asmlinkage void __vfp_restore_state(struct vfp_hard_struct *vfp);
arch/arm64/include/asm/kvm_hyp.h +2 -0
@@ -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_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);void __timer_enable_traps (struct kvm_vcpu *vcpu);
virt/kvm/arm/hyp/vgic-v3-sr.c +67 -57
172 lines not on this page · raw message
virt/kvm/arm/vgic/vgic-v2.c +2 -5
@@ -446,7 +446,6 @@ void vgic_v2_save_state(struct kvm_vcpu *vcpu) {struct kvm *kvm = vcpu->kvm;struct vgic_dist *vgic = &kvm->arch.vgic; -struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2;void __iomem *base = vgic->vctrl_base;u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs;
@@ -454,11 +453,8 @@ void vgic_v2_save_state(struct kvm_vcpu *vcpu)return ;if (used_lrs) { - cpu_if->vgic_apr =readl_relaxed (base +GICH_APR );save_lrs (vcpu, base);writel_relaxed (0 , base +GICH_HCR ); - }else { - cpu_if->vgic_apr =0 ; } }
@@ -476,7 +472,6 @@ void vgic_v2_restore_state(struct kvm_vcpu *vcpu)if (used_lrs) {writel_relaxed (cpu_if->vgic_hcr, base +GICH_HCR ); -writel_relaxed (cpu_if->vgic_apr, base +GICH_APR );for (i =0 ; i < used_lrs; i++) {writel_relaxed (cpu_if->vgic_lr[i], base +GICH_LR0 + (i *4 ));
@@ -490,6 +485,7 @@ void vgic_v2_load(struct kvm_vcpu *vcpu)struct vgic_dist *vgic = &vcpu->kvm->arch.vgic;writel_relaxed (cpu_if->vgic_vmcr, vgic->vctrl_base +GICH_VMCR ); +writel_relaxed (cpu_if->vgic_apr, vgic->vctrl_base +GICH_APR ); }void vgic_v2_put (struct kvm_vcpu *vcpu)
@@ -498,4 +494,5 @@ void vgic_v2_put(struct kvm_vcpu *vcpu)struct vgic_dist *vgic = &vcpu->kvm->arch.vgic; cpu_if->vgic_vmcr =readl_relaxed (vgic->vctrl_base +GICH_VMCR ); + cpu_if->vgic_apr =readl_relaxed (vgic->vctrl_base +GICH_APR ); }
virt/kvm/arm/vgic/vgic-v3.c +5 -0
@@ -16,6 +16,7 @@#include <linux/kvm.h> #include <linux/kvm_host.h> #include <kvm/arm_vgic.h> +#include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> #include <asm/kvm_asm.h>
@@ -587,6 +588,8 @@ void vgic_v3_load(struct kvm_vcpu *vcpu)*/ if (likely (cpu_if->vgic_sre))kvm_call_hyp (__vgic_v3_write_vmcr, cpu_if->vgic_vmcr); + +kvm_call_hyp (__vgic_v3_restore_aprs, vcpu); }void vgic_v3_put (struct kvm_vcpu *vcpu)
@@ -595,4 +598,6 @@ void vgic_v3_put(struct kvm_vcpu *vcpu)if (likely (cpu_if->vgic_sre)) cpu_if->vgic_vmcr =kvm_call_hyp (__vgic_v3_read_vmcr); + +kvm_call_hyp (__vgic_v3_save_aprs, vcpu); }
Signature · 1 line
2.14.2
PATCH v5 40/40 KVM: arm/arm64: Avoid VGICv3 save/restore on VHE with no IRQs
In reply to Christoffer DallFrom: Christoffer Dall <[email protected]>
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.
---
Notes:
Changes since v3:
- Removed extra blank line
arch/arm/include/asm/kvm_hyp.h | 2 + arch/arm/kvm/hyp/switch.c | 8 ++- arch/arm64/include/asm/kvm_hyp.h | 2 + arch/arm64/kvm/hyp/switch.c | 8 ++- virt/kvm/arm/hyp/vgic-v3-sr.c | 120 +++++++++++++++++++++++++-------------- virt/kvm/arm/vgic/vgic-v3.c | 6 ++ virt/kvm/arm/vgic/vgic.c | 9 ++- 7 files changed, 103 insertions(+), 52 deletions(-)
arch/arm/include/asm/kvm_hyp.h +2 -0
@@ -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
@@ -90,14 +90,18 @@ 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
@@ -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
@@ -195,15 +195,19 @@ 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
171 lines not on this page · raw message
virt/kvm/arm/vgic/vgic-v3.c +6 -0
@@ -590,6 +590,9 @@ void vgic_v3_load(struct kvm_vcpu *vcpu)kvm_call_hyp (__vgic_v3_write_vmcr, cpu_if->vgic_vmcr);kvm_call_hyp (__vgic_v3_restore_aprs, vcpu); + +if (has_vhe ()) +__vgic_v3_activate_traps (vcpu); }void vgic_v3_put (struct kvm_vcpu *vcpu)
@@ -600,4 +603,7 @@ void vgic_v3_put(struct kvm_vcpu *vcpu) cpu_if->vgic_vmcr =kvm_call_hyp (__vgic_v3_read_vmcr);kvm_call_hyp (__vgic_v3_save_aprs, vcpu); + +if (has_vhe ()) +__vgic_v3_deactivate_traps (vcpu); }
virt/kvm/arm/vgic/vgic.c +4 -5
@@ -773,15 +773,15 @@ void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu) {struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; -if (can_access_vgic_from_kernel ()) -vgic_save_state (vcpu); -WARN_ON (vgic_v4_sync_hwstate (vcpu));/* An empty ap_list_head implies used_lrs == 0 */ if (list_empty (&vcpu->arch.vgic_cpu.ap_list_head))return ; +if (can_access_vgic_from_kernel ()) +vgic_save_state (vcpu); +if (vgic_cpu->used_lrs)vgic_fold_lr_state (vcpu);vgic_prune_ap_list (vcpu);
@@ -810,7 +810,7 @@ void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu)* this. */ if (list_empty (&vcpu->arch.vgic_cpu.ap_list_head)) - goto out; +return ;DEBUG_SPINLOCK_BUG_ON (!irqs_disabled ());
@@ -818,7 +818,6 @@ void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu)vgic_flush_lr_state (vcpu);spin_unlock (&vcpu->arch.vgic_cpu.ap_list_lock); -out:if (can_access_vgic_from_kernel ())vgic_restore_state (vcpu); }
Signature · 1 line
2.14.2
Re: [PATCH v5 13/40] KVM: arm64: Introduce VHE-specific kvm_vcpu_run
In reply to Christoffer DallQuoted 39 lines · Christoffer Dall
From: Christoffer Dall <[email protected]>
So far this is mostly (see below) a copy of the legacy non-VHE switch function, but we will start reworking these functions in separate directions to work on VHE and non-VHE in the most optimal way in later patches.
The only difference after this patch between the VHE and non-VHE run functions is that we omit the branch-predictor variant-2 hardening for QC Falkor CPUs, because this workaround is specific to a series of non-VHE ARMv8.0 CPUs.
Reviewed-by Marc Zyngier <[email protected]>Signed-off-by Christoffer Dall <[email protected]>---
Notes:
Changes since v4:
- Unifiedhas_vhe()conditional calls inkvm_arch_vcpu_ioctl_run
- Addedisb()on exit path of VHE-specifickvm_vcpu_run(), because otherwise 32-bit guests can crash the system on reentry to the guest, because writes toFPEXC32_EL2will cause a trap at EL2 which leads to a hyp panic. This can be observed on the model where writing FPEN toCPACR_EL1on guest exit doesn't take effect prior to entering the guest again.Changes since v3:
- AddedBUG()to 32-bit ARM VHE run function
- Omitted QC Falkor BP Hardening functionality from VHE-specific functionChanges since v2:
- Reworded commit messageChanges since v1:
- Renamekvm_vcpu_runtokvm_vcpu_run_vheand rename__kvm_vcpu_runto__kvm_vcpu_run_nvhe
- Removed stray whitespace line
Quoted 8 lines
arch/arm/include/asm/kvm_asm.h | 5 ++- arch/arm/kvm/hyp/switch.c | 2 +- arch/arm64/include/asm/kvm_asm.h | 4 ++- arch/arm64/include/asm/kvm_host.h | 7 +++++ arch/arm64/kvm/hyp/switch.c | 66 ++++++++++++++++++++++++++++++++++++++- virt/kvm/arm/arm.c | 12 ++++--- 6 files changed, 87 insertions(+), 9 deletions(-)
Re: [PATCH v5 03/40] KVM: arm64: Avoid storing the vcpu pointer on the stack
In reply to Christoffer DallHi Christoffer,
Quoted 25 lines · Christoffer Dall
From: Christoffer Dall <[email protected]>
We already have the percpu area for the host cpu state, which points to the VCPU, so there's no need to store the VCPU pointer on the stack on every context switch. We can be a little more clever and just use
tpidr_el2for the percpu offset and load the VCPU pointer from the host context.This has the benefit of being able to retrieve the host context even when our stack is corrupted, and it has a potential performance benefit because we trade a store plus a load for an mrs and a load on a round trip to the guest.
This does require us to calculate the percpu offset without including the offset from the kernel mapping of the percpu array to the linear mapping of the array (which is what we store in
tpidr_el1), because a PC-relative generated address in EL2 is already giving us the hyp alias of the linear mapping of a kernel address. We do this in__cpu_init_hyp_mode()by usingkvm_ksym_ref().The code that accesses
ESR_EL2was previously using an alternative to use the_EL1accessor on VHE systems, but this was actually unnecessary as the_EL1accessor aliases theESR_EL2register on VHE, and the_EL2accessor does the same thing on both systems.
Quoted 4 lines
Cc Ard Biesheuvel <[email protected]>Reviewed-by Marc Zyngier <[email protected]>Reviewed-by Andrew Jones <[email protected]>Signed-off-by Christoffer Dall <[email protected]>
Cheers,
Quoted 240 lines
---
Notes:
Changes since v4:
- Clarified rationale in commit message.
- Calledget_host_ctxtfromget_vcpuand renameget_vcputoget_vcpu_ptr.Changes since v3:
- Reworked the assembly part of the patch after rebasing on v4.16-rc1 which created a conflict with the variant 2 mitigations.
- Removed Marc's reviewed-by due to the rework.
- Removed unneeded extern keyword in declaration in header fileChanges since v1:
- Use PC-relative addressing to access per-cpu variables instead of using a load from the literal pool.
- Remove stale comments as pointed out by Marc
- Reworded the commit message as suggested by Drewarch/arm64/include/asm/kvm_asm.h | 15 +++++++++++++++ arch/arm64/include/asm/kvm_host.h | 15 +++++++++++++++ arch/arm64/kernel/asm-offsets.c | 1 + arch/arm64/kvm/hyp/entry.S | 6 +----- arch/arm64/kvm/hyp/hyp-entry.S | 28 ++++++++++------------------ arch/arm64/kvm/hyp/switch.c | 5 +---- arch/arm64/kvm/hyp/sysreg-sr.c | 5 +++++ 7 files changed, 48 insertions(+), 27 deletions(-)arch/arm64/include/asm/kvm_asm.h +15
-0@@ -33,6 +33,7 @@#define KVM_ARM64_DEBUG_DIRTY_SHIFT 0#define KVM_ARM64_DEBUG_DIRTY (1 << KVM_ARM64_DEBUG_DIRTY_SHIFT) +/* Translate a kernel address of @sym into its equivalent linear mapping */ #define kvm_ksym_ref (sym) \ ({ \ void *val = &sym; \@@ -70,6 +71,20 @@ extern u32 __init_stage2_translation(void); extern void __qcom_hyp_sanitize_btac_predictors(void); +#else /* __ASSEMBLY__ */ + +.macro get_host_ctxt reg, tmp + adr_l \reg, kvm_host_cpu_state + mrs \tmp, tpidr_el2 + add \reg, \reg, \tmp +.endm + +.macro get_vcpu_ptr vcpu, ctxt + get_host_ctxt \ctxt, \vcpu + ldr \vcpu, [\ctxt, #HOST_CONTEXT_VCPU] + kern_hyp_va \vcpu +.endm + #endif #endif /* __ARM_KVM_ASM_H__ */arch/arm64/include/asm/kvm_host.h +15
-0@@ -358,10 +358,15 @@ int kvm_perf_teardown(void);struct kvm_vcpu *kvm_mpidr_to_vcpu (struct kvm *kvm,unsigned long mpidr); +void __kvm_set_tpidr_el2 (u64 tpidr_el2); +DECLARE_PER_CPU (kvm_cpu_context_t, kvm_host_cpu_state); +static inline void __cpu_init_hyp_mode (phys_addr_t pgd_ptr,unsigned long hyp_stack_ptr,unsigned long vector_ptr) { +u64 tpidr_el2; +/* * Call initialization code, and switch to the full blown HYP code. * If the cpucaps haven't been finalized yet, something has gone very @@ -370,6 +375,16 @@ static inline void __cpu_init_hyp_mode(phys_addr_t pgd_ptr,*/ BUG_ON (!static_branch_likely (&arm64_const_caps_ready));__kvm_call_hyp ((void *)pgd_ptr, hyp_stack_ptr, vector_ptr); + +/* +* Calculate the raw per-cpu offset without a translation from the +* kernel's mapping to the linear mapping, and store it in tpidr_el2 +* so that we can use adr_l to access per-cpu variables in EL2. +*/ + tpidr_el2 = (u64 )this_cpu_ptr (&kvm_host_cpu_state) + - (u64 )kvm_ksym_ref (kvm_host_cpu_state); + +kvm_call_hyp (__kvm_set_tpidr_el2, tpidr_el2); }static inline void kvm_arch_hardware_unsetup (void ) {}arch/arm64/kernel/asm-offsets.c +1
-0@@ -138,6 +138,7 @@ int main(void)DEFINE (CPU_FP_REGS , offsetof(struct kvm_regs , fp_regs)); DEFINE(VCPU_FPEXC32_EL2, offsetof(struct kvm_vcpu, arch.ctxt.sys_regs[FPEXC32_EL2])); DEFINE(VCPU_HOST_CONTEXT, offsetof(struct kvm_vcpu, arch.host_cpu_context)); +DEFINE (HOST_CONTEXT_VCPU , offsetof(struct kvm_cpu_context , __hyp_running_vcpu));#endif #ifdef CONFIG_CPU_PM DEFINE (CPU_SUSPEND_SZ ,sizeof (struct cpu_suspend_ctx ));arch/arm64/kvm/hyp/entry.S +1
-5@@ -62,9 +62,6 @@ ENTRY(__guest_enter) // Store the host regs save_callee_saved_regs x1 - // Store host_ctxt and vcpu for use at exit time - stp x1, x0, [sp, #-16]! - add x18, x0, #VCPU_CONTEXT // Restore guest regs x0-x17@@ -118,8 +115,7 @@ ENTRY(__guest_exit) // Store the guest regs x19-x29, lr save_callee_saved_regs x1 - // Restore the host_ctxt from the stack - ldr x2, [sp], #16 + get_host_ctxt x2, x3 // Now restore the host regs restore_callee_saved_regs x2arch/arm64/kvm/hyp/hyp-entry.S +10
-18@@ -57,13 +57,8 @@ ENDPROC(__vhe_hyp_call) el1_sync: // Guest trapped into EL2 stp x0, x1, [sp, #-16]! -alternative_if_not ARM64_HAS_VIRT_HOST_EXTN - mrs x1, esr_el2 -alternative_else - mrs x1, esr_el1 -alternative_endif - lsr x0, x1, #ESR_ELx_EC_SHIFT - + mrs x0, esr_el2 + lsr x0, x0, #ESR_ELx_EC_SHIFT cmp x0, #ESR_ELx_EC_HVC64 ccmp x0, #ESR_ELx_EC_HVC32, #4, ne b.ne el1_trap@@ -117,10 +112,14 @@ el1_hvc_guest: eret el1_trap: + get_vcpu_ptr x1, x0 + + mrs x0, esr_el2 + lsr x0, x0, #ESR_ELx_EC_SHIFT /* * x0: ESR_EC + * x1: vcpu pointer */ - ldr x1, [sp, #16 + 8] // vcpu stored by __guest_enter /* * We trap the first access to the FP/SIMD to save the host context@@ -138,13 +137,13 @@ alternative_else_nop_endif el1_irq: stp x0, x1, [sp, #-16]! - ldr x1, [sp, #16 + 8] + get_vcpu_ptr x1, x0 mov x0, #ARM_EXCEPTION_IRQ b __guest_exit el1_error: stp x0, x1, [sp, #-16]! - ldr x1, [sp, #16 + 8] + get_vcpu_ptr x1, x0 mov x0, #ARM_EXCEPTION_EL1_SERROR b __guest_exit@@ -180,14 +179,7 @@ ENTRY(__hyp_do_panic) ENDPROC(__hyp_do_panic) ENTRY(__hyp_panic) - /* - * '=kvm_host_cpu_state' is a host VA from the constant pool, it may - * not be accessible by this address from EL2, hyp_panic() converts - * it with kern_hyp_va() before use. - */ - ldr x0, =kvm_host_cpu_state - mrs x1, tpidr_el2 - add x0, x0, x1 + get_host_ctxt x0, x1 b hyp_panic ENDPROC(__hyp_panic)arch/arm64/kvm/hyp/switch.c +1
-4@@ -469,7 +469,7 @@ static hyp_alternate_select(__hyp_call_panic, __hyp_call_panic_nvhe, __hyp_call_panic_vhe, ARM64_HAS_VIRT_HOST_EXTN); -void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *__host_ctxt) +void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *host_ctxt) {struct kvm_vcpu *vcpu =NULL ;@@ -478,9 +478,6 @@ void __hyp_text __noreturn hyp_panic(struct kvm_cpu_context *__host_ctxt)u64 par =read_sysreg (par_el1);if (read_sysreg (vttbr_el2)) { -struct kvm_cpu_context *host_ctxt; - - host_ctxt =kern_hyp_va (__host_ctxt); vcpu = host_ctxt->__hyp_running_vcpu;__timer_disable_traps (vcpu);__deactivate_traps (vcpu);arch/arm64/kvm/hyp/sysreg-sr.c +5
-0@@ -189,3 +189,8 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu)if (vcpu->arch.debug_flags &KVM_ARM64_DEBUG_DIRTY )write_sysreg (sysreg[DBGVCR32_EL2 ], dbgvcr32_el2); } + +void __hyp_text __kvm_set_tpidr_el2(u64 tpidr_el2) +{ + asm("msr tpidr_el2, %0" : :"r" (tpidr_el2)); +}
Signature · 1 line
Julien Grall
Re: [PATCH v5 17/40] KVM: arm64: Move userspace system registers into separate function
In reply to Christoffer DallHi Christoffer,
Quoted 12 lines · Christoffer Dall
From: Christoffer Dall <[email protected]>
There's a semantic difference between the EL1 registers that control operation of a kernel running in EL1 and EL1 registers that only control userspace execution in EL0. Since we can defer saving/restoring the latter, move them into their own function.
The ARMv8 ARM (ARM DDI 0487C.a) Section D10.2.1 recommends that
ACTLR_EL1has no effect on the processor when running the VHE host, and we can therefore move this register into the EL1 state which is only saved/restored on vcpu_put/load for a VHE host.
Quoted 7 lines
We also take this chance to rename the function saving/restoring the remaining system register to make it clear this function deals with the EL1 system registers.
Reviewed-by Andrew Jones <[email protected]>Reviewed-by Marc Zyngier <[email protected]>Signed-off-by Christoffer Dall <[email protected]>
Cheers,
Quoted 141 lines
---
Notes:
Changes since v4:
- Clarified rationale for deferringACTLR_EL1in the commit message.Changes since v3:
- Correct the comment aboutACTLR_EL1and adjust commit text.Changes since v2:
- Save restoreACTLR_EL1as part of the EL1 registers state instead of the user register state, asACTLR_EL1can't affect the host's execution on VHE systems.Changes since v1:
- Added comment aboutsp_el0to common save sysreg save/restore functionsarch/arm64/kvm/hyp/sysreg-sr.c | 48 ++++++++++++++++++++++++++++++------------ 1 file changed, 35 insertions(+), 13 deletions(-)arch/arm64/kvm/hyp/sysreg-sr.c +35
-13@@ -28,24 +28,33 @@ static void __hyp_text __sysreg_do_nothing(struct kvm_cpu_context *ctxt) { }/* * Non-VHE: Both host and guest must save everything. * -* VHE: Host must save tpidr*_el0, actlr_el1, mdscr_el1, sp_el0, +* VHE: Host must save tpidr*_el0, mdscr_el1, sp_el0, * and guest must save everything. */ static void __hyp_text __sysreg_save_common_state(struct kvm_cpu_context *ctxt) { - ctxt->sys_regs[ACTLR_EL1 ] =read_sysreg (actlr_el1); - ctxt->sys_regs[TPIDR_EL0 ] =read_sysreg (tpidr_el0); - ctxt->sys_regs[TPIDRRO_EL0 ] =read_sysreg (tpidrro_el0); ctxt->sys_regs[MDSCR_EL1 ] =read_sysreg (mdscr_el1); + +/* +* The host arm64 Linux uses sp_el0 to point to 'current' and it must +* therefore be saved/restored on every entry/exit to/from the guest. +*/ ctxt->gp_regs.regs.sp =read_sysreg (sp_el0); } -static void __hyp_text __sysreg_save_state(struct kvm_cpu_context *ctxt) +static void __hyp_text __sysreg_save_user_state(struct kvm_cpu_context *ctxt) +{ + ctxt->sys_regs[TPIDR_EL0 ] =read_sysreg (tpidr_el0); + ctxt->sys_regs[TPIDRRO_EL0 ] =read_sysreg (tpidrro_el0); +} + +static void __hyp_text __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) { ctxt->sys_regs[MPIDR_EL1 ] =read_sysreg (vmpidr_el2); ctxt->sys_regs[CSSELR_EL1 ] =read_sysreg (csselr_el1); ctxt->sys_regs[SCTLR_EL1 ] =read_sysreg_el1 (sctlr); + ctxt->sys_regs[ACTLR_EL1 ] =read_sysreg (actlr_el1); ctxt->sys_regs[CPACR_EL1 ] =read_sysreg_el1 (cpacr); ctxt->sys_regs[TTBR0_EL1 ] =read_sysreg_el1 (ttbr0); ctxt->sys_regs[TTBR1_EL1 ] =read_sysreg_el1 (ttbr1);@@ -73,35 +82,46 @@ static void __hyp_text __sysreg_save_state(struct kvm_cpu_context *ctxt) } static hyp_alternate_select(__sysreg_call_save_host_state, - __sysreg_save_state, __sysreg_do_nothing, + __sysreg_save_el1_state, __sysreg_do_nothing, ARM64_HAS_VIRT_HOST_EXTN); void __hyp_text __sysreg_save_host_state(struct kvm_cpu_context *ctxt) {__sysreg_call_save_host_state ()(ctxt);__sysreg_save_common_state (ctxt); +__sysreg_save_user_state (ctxt); } void __hyp_text __sysreg_save_guest_state(struct kvm_cpu_context *ctxt) { -__sysreg_save_state (ctxt); +__sysreg_save_el1_state (ctxt);__sysreg_save_common_state (ctxt); +__sysreg_save_user_state (ctxt); } static void __hyp_text __sysreg_restore_common_state(struct kvm_cpu_context *ctxt) { -write_sysreg (ctxt->sys_regs[ACTLR_EL1 ], actlr_el1); -write_sysreg (ctxt->sys_regs[TPIDR_EL0 ], tpidr_el0); -write_sysreg (ctxt->sys_regs[TPIDRRO_EL0 ], tpidrro_el0);write_sysreg (ctxt->sys_regs[MDSCR_EL1 ], mdscr_el1); + +/* +* The host arm64 Linux uses sp_el0 to point to 'current' and it must +* therefore be saved/restored on every entry/exit to/from the guest. +*/ write_sysreg (ctxt->gp_regs.regs.sp, sp_el0); } -static void __hyp_text __sysreg_restore_state(struct kvm_cpu_context *ctxt) +static void __hyp_text __sysreg_restore_user_state(struct kvm_cpu_context *ctxt) +{ +write_sysreg (ctxt->sys_regs[TPIDR_EL0 ], tpidr_el0); +write_sysreg (ctxt->sys_regs[TPIDRRO_EL0 ], tpidrro_el0); +} + +static void __hyp_text __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt) {write_sysreg (ctxt->sys_regs[MPIDR_EL1 ], vmpidr_el2);write_sysreg (ctxt->sys_regs[CSSELR_EL1 ], csselr_el1);write_sysreg_el1 (ctxt->sys_regs[SCTLR_EL1 ], sctlr); +write_sysreg (ctxt->sys_regs[ACTLR_EL1 ], actlr_el1);write_sysreg_el1 (ctxt->sys_regs[CPACR_EL1 ], cpacr);write_sysreg_el1 (ctxt->sys_regs[TTBR0_EL1 ], ttbr0);write_sysreg_el1 (ctxt->sys_regs[TTBR1_EL1 ], ttbr1);@@ -129,19 +149,21 @@ static void __hyp_text __sysreg_restore_state(struct kvm_cpu_context *ctxt) } static hyp_alternate_select(__sysreg_call_restore_host_state, - __sysreg_restore_state, __sysreg_do_nothing, + __sysreg_restore_el1_state, __sysreg_do_nothing, ARM64_HAS_VIRT_HOST_EXTN); void __hyp_text __sysreg_restore_host_state(struct kvm_cpu_context *ctxt) {__sysreg_call_restore_host_state ()(ctxt);__sysreg_restore_common_state (ctxt); +__sysreg_restore_user_state (ctxt); } void __hyp_text __sysreg_restore_guest_state(struct kvm_cpu_context *ctxt) { -__sysreg_restore_state (ctxt); +__sysreg_restore_el1_state (ctxt);__sysreg_restore_common_state (ctxt); +__sysreg_restore_user_state (ctxt); } void __hyp_text __sysreg32_save_state(struct kvm_vcpu *vcpu)
Signature · 1 line
Julien Grall
Re: [PATCH v5 01/40] KVM: arm/arm64: Avoid vcpu_load for other vcpu ioctls than KVM_RUN
In reply to Christoffer DallQuoted 19 lines · Christoffer Dall
From: Christoffer Dall <[email protected]>
Calling
vcpu_load()registers preempt notifiers for this vcpu and callskvm_arch_vcpu_load(). The latter will soon be doing a lot of heavy lifting on arm/arm64 and will try to do things such as enabling the virtual timer and setting us up to handle interrupts from the timer hardware.Loading state onto hardware registers and enabling hardware to signal interrupts can be problematic when we're not actually about to run the VCPU, because it makes it difficult to establish the right context when handling interrupts from the timer, and it makes the register access code difficult to reason about.
Luckily, now when we call
vcpu_loadin each ioctl implementation, we can simply remove the call from the non-KVM_RUN vcpu ioctls, and ourkvm_arch_vcpu_load()is only used for loading vcpu content to the physical CPU when we're actually going to run the vcpu.
Quoted 4 lines
Reviewed-by Julien Grall <[email protected]>Reviewed-by Marc Zyngier <[email protected]>Reviewed-by Andrew Jones <[email protected]>Signed-off-by Christoffer Dall <[email protected]>
I've queued this patch for 4.16-rc5 as part of the reset fix.
Thanks,
M.
Signature · 1 line
Jazz is not dead. It just smells funny...
Re: [PATCH v5 36/40] KVM: arm/arm64: Handle VGICv2 save/restore from the main VGIC code
In reply to Christoffer DallHi Christoffer,
Quoted 8 lines · Christoffer Dall
From: Christoffer Dall <[email protected]>
We can program the GICv2 hypervisor control interface logic directly from the core vgic code and can instead do the save/restore directly from the flush/sync functions, which can lead to a number of future optimizations.
Signed-off-by Christoffer Dall <[email protected]>
Cheers,
Quoted 302 lines
---
Notes:
Changes since v1:
- Removed unnecessarykvm_hyp.hinclude
- Adapted the patch based on having gotten rid of storing the elrsr prior to this patch.
- No longer change the interrupt handling of the maintenance interrupt handler. That seems to have been a leftover from an earlier version of the timer patches where we were syncing the vgic state after having enabled interrupts, leading to the maintenance interrupt firing.It may be possible to move the vgic sync function out to an interrupts enabled section later on, which would require re-introducing logic to disable the VGIC maintenance interrupt in the maintenance interrupt handler, but we leave this for future work as the immediate benefit is not clear.
arch/arm/kvm/hyp/switch.c | 4 --- arch/arm64/include/asm/kvm_hyp.h | 2 -- arch/arm64/kvm/hyp/switch.c | 4 --- virt/kvm/arm/hyp/vgic-v2-sr.c | 65 ---------------------------------------- virt/kvm/arm/vgic/vgic-v2.c | 63 ++++++++++++++++++++++++++++++++++++++ virt/kvm/arm/vgic/vgic.c | 19 +++++++++++- virt/kvm/arm/vgic/vgic.h | 3 ++ 7 files changed, 84 insertions(+), 76 deletions(-)arch/arm/kvm/hyp/switch.c +0
-4@@ -92,16 +92,12 @@ static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_save_state (vcpu); -else -__vgic_v2_save_state (vcpu); } static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_restore_state (vcpu); -else -__vgic_v2_restore_state (vcpu); } static bool __hyp_text __populate_fault_info(struct kvm_vcpu *vcpu)arch/arm64/include/asm/kvm_hyp.h +0
-2@@ -120,8 +120,6 @@ typeof(orig) * __hyp_text fname(void) \return val; \ } -void __vgic_v2_save_state (struct kvm_vcpu *vcpu); -void __vgic_v2_restore_state (struct kvm_vcpu *vcpu);int __vgic_v2_perform_cpuif_access (struct kvm_vcpu *vcpu);void __vgic_v3_save_state (struct kvm_vcpu *vcpu);arch/arm64/kvm/hyp/switch.c +0
-4@@ -196,16 +196,12 @@ static void __hyp_text __vgic_save_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_save_state (vcpu); -else -__vgic_v2_save_state (vcpu); } static void __hyp_text __vgic_restore_state(struct kvm_vcpu *vcpu) {if (static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif))__vgic_v3_restore_state (vcpu); -else -__vgic_v2_restore_state (vcpu); } static bool __hyp_text __true_value(void)virt/kvm/arm/hyp/vgic-v2-sr.c +0
-65@@ -23,71 +23,6 @@#include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> -static void __hyp_text save_lrs(struct kvm_vcpu *vcpu, void __iomem *base) -{ -struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; -u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; -u64 elrsr; -int i; - - elrsr =readl_relaxed (base +GICH_ELRSR0 ); -if (unlikely (used_lrs >32 )) - elrsr |= ((u64 )readl_relaxed (base +GICH_ELRSR1 )) <<32 ; - -for (i =0 ; i < used_lrs; i++) { -if (elrsr & (1UL << i)) - cpu_if->vgic_lr[i] &= ~GICH_LR_STATE ; -else - cpu_if->vgic_lr[i] =readl_relaxed (base +GICH_LR0 + (i *4 )); - -writel_relaxed (0 , base +GICH_LR0 + (i *4 )); - } -} - -/* vcpu is already in the HYP VA space */ -void __hyp_text __vgic_v2_save_state(struct kvm_vcpu *vcpu) -{ -struct kvm *kvm =kern_hyp_va (vcpu->kvm); -struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; -struct vgic_dist *vgic = &kvm->arch.vgic; -void __iomem *base =kern_hyp_va (vgic->vctrl_base); -u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; - -if (!base) -return ; - -if (used_lrs) { - cpu_if->vgic_apr =readl_relaxed (base +GICH_APR ); -save_lrs (vcpu, base); -writel_relaxed (0 , base +GICH_HCR ); - }else { - cpu_if->vgic_apr =0 ; - } -} - -/* vcpu is already in the HYP VA space */ -void __hyp_text __vgic_v2_restore_state(struct kvm_vcpu *vcpu) -{ -struct kvm *kvm =kern_hyp_va (vcpu->kvm); -struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; -struct vgic_dist *vgic = &kvm->arch.vgic; -void __iomem *base =kern_hyp_va (vgic->vctrl_base); -int i; -u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; - -if (!base) -return ; - -if (used_lrs) { -writel_relaxed (cpu_if->vgic_hcr, base +GICH_HCR ); -writel_relaxed (cpu_if->vgic_apr, base +GICH_APR ); -for (i =0 ; i < used_lrs; i++) { -writel_relaxed (cpu_if->vgic_lr[i], - base +GICH_LR0 + (i *4 )); - } - } -} -#ifdef CONFIG_ARM64 /* * __vgic_v2_perform_cpuif_access -- perform a GICV access on behalf of the virt/kvm/arm/vgic/vgic-v2.c +63
-0@@ -421,6 +421,69 @@ int vgic_v2_probe(const struct gic_kvm_info *info)return ret; } +static void save_lrs (struct kvm_vcpu *vcpu,void __iomem *base) +{ +struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; +u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; +u64 elrsr; +int i; + + elrsr =readl_relaxed (base +GICH_ELRSR0 ); +if (unlikely (used_lrs >32 )) + elrsr |= ((u64 )readl_relaxed (base +GICH_ELRSR1 )) <<32 ; + +for (i =0 ; i < used_lrs; i++) { +if (elrsr & (1UL << i)) + cpu_if->vgic_lr[i] &= ~GICH_LR_STATE ; +else + cpu_if->vgic_lr[i] =readl_relaxed (base +GICH_LR0 + (i *4 )); + +writel_relaxed (0 , base +GICH_LR0 + (i *4 )); + } +} + +void vgic_v2_save_state (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct vgic_dist *vgic = &kvm->arch.vgic; +struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; +void __iomem *base = vgic->vctrl_base; +u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; + +if (!base) +return ; + +if (used_lrs) { + cpu_if->vgic_apr =readl_relaxed (base +GICH_APR ); +save_lrs (vcpu, base); +writel_relaxed (0 , base +GICH_HCR ); + }else { + cpu_if->vgic_apr =0 ; + } +} + +void vgic_v2_restore_state (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct vgic_dist *vgic = &kvm->arch.vgic; +struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2; +void __iomem *base = vgic->vctrl_base; +u64 used_lrs = vcpu->arch.vgic_cpu.used_lrs; +int i; + +if (!base) +return ; + +if (used_lrs) { +writel_relaxed (cpu_if->vgic_hcr, base +GICH_HCR ); +writel_relaxed (cpu_if->vgic_apr, base +GICH_APR ); +for (i =0 ; i < used_lrs; i++) { +writel_relaxed (cpu_if->vgic_lr[i], + base +GICH_LR0 + (i *4 )); + } + } +} +void vgic_v2_load (struct kvm_vcpu *vcpu) {struct vgic_v2_cpu_if *cpu_if = &vcpu->arch.vgic_cpu.vgic_v2;virt/kvm/arm/vgic/vgic.c +18
-1@@ -749,11 +749,19 @@ static void vgic_flush_lr_state(struct kvm_vcpu *vcpu)vgic_clear_lr (vcpu, count); } +static inline void vgic_save_state (struct kvm_vcpu *vcpu) +{ +if (!static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif)) +vgic_v2_save_state (vcpu); +} +/* Sync back the hardware VGIC state into our emulation after a guest's run. */ void kvm_vgic_sync_hwstate (struct kvm_vcpu *vcpu) {struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; +vgic_save_state (vcpu); +WARN_ON (vgic_v4_sync_hwstate (vcpu));/* An empty ap_list_head implies used_lrs == 0 */ @@ -765,6 +773,12 @@ void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu)vgic_prune_ap_list (vcpu); } +static inline void vgic_restore_state (struct kvm_vcpu *vcpu) +{ +if (!static_branch_unlikely (&kvm_vgic_global_state.gicv3_cpuif)) +vgic_v2_restore_state (vcpu); +} +/* Flush our emulation state into the GIC hardware before entering the guest. */ void kvm_vgic_flush_hwstate (struct kvm_vcpu *vcpu) {@@ -780,13 +794,16 @@ void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu)* this. */ if (list_empty (&vcpu->arch.vgic_cpu.ap_list_head)) -return ; + goto out;DEBUG_SPINLOCK_BUG_ON (!irqs_disabled ());spin_lock (&vcpu->arch.vgic_cpu.ap_list_lock);vgic_flush_lr_state (vcpu);spin_unlock (&vcpu->arch.vgic_cpu.ap_list_lock); + +out: +vgic_restore_state (vcpu); }void kvm_vgic_load (struct kvm_vcpu *vcpu)virt/kvm/arm/vgic/vgic.h +3
-0@@ -176,6 +176,9 @@ void vgic_v2_init_lrs(void);void vgic_v2_load (struct kvm_vcpu *vcpu);void vgic_v2_put (struct kvm_vcpu *vcpu); +void vgic_v2_save_state (struct kvm_vcpu *vcpu); +void vgic_v2_restore_state (struct kvm_vcpu *vcpu); +static inline void vgic_get_irq_kref (struct vgic_irq *irq) {if (irq->intid <VGIC_MIN_LPI )
Signature · 1 line
Julien Grall