Rework hyp vector handling
Subsystems (3)
Will Deacon
maintainerv2 cover Rework hyp vector handling
Hi folks,
This is version two of the patches I previously posted here:
https://lore.kernel.org/r/[email protected]
All I've done since then is rebase and retest against -rc3.
Cheers,
Will
--->8
Will Deacon (9):
KVM: arm64: Remove redundant Spectre-v2 code from kvm_map_vector()
KVM: arm64: Tidy up kvm_map_vector()
KVM: arm64: Move kvm_get_hyp_vector() out of header file
KVM: arm64: Make BP hardening globals static instead
KVM: arm64: Move BP hardening helpers into spectre.h
KVM: arm64: Re-jig logic when patching hardened hyp vectors
KVM: arm64: Allocate hyp vectors statically
arm64: spectre: Rename ARM64_HARDEN_EL2_VECTORS to ARM64_SPECTRE_V3A
arm64: spectre: Consolidate spectre-v3a detection
Documentation/arm64/memory.rst | 2 +- arch/arm64/include/asm/cpucaps.h | 2 +- arch/arm64/include/asm/kvm_asm.h | 5 -- arch/arm64/include/asm/kvm_mmu.h | 46 ----------------- arch/arm64/include/asm/mmu.h | 29 ----------- arch/arm64/include/asm/spectre.h | 63 +++++++++++++++++++++++ arch/arm64/kernel/cpu_errata.c | 19 +++---- arch/arm64/kernel/proton-pack.c | 84 ++++++++++++------------------ arch/arm64/kvm/arm.c | 87 ++++++++++++++++++++------------ arch/arm64/kvm/hyp/Makefile | 2 +- arch/arm64/kvm/hyp/hyp-entry.S | 72 ++++++++++++++------------ arch/arm64/kvm/hyp/smccc_wa.S | 32 ------------ arch/arm64/kvm/va_layout.c | 23 +-------- 13 files changed, 204 insertions(+), 262 deletions(-) delete mode 100644 arch/arm64/kvm/hyp/smccc_wa.S
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 1/9 KVM: arm64: Remove redundant Spectre-v2 code from kvm_map_vector()
'__kvm_bp_vect_base' is only used when dealing with the hardened vectors so remove the redundant assignments in kvm_map_vectors().
--- arch/arm64/kvm/arm.c | 5 ----- 1 file changed, 5 deletions(-)
arch/arm64/kvm/arm.c +0 -5
@@ -1306,11 +1306,6 @@ static int kvm_map_vectors(void)* !SV2 + HEL2 -> allocate one vector slot and use exec mapping * SV2 + HEL2 -> use hardened vectors and use exec mapping */ -if (cpus_have_const_cap (ARM64_SPECTRE_V2 )) { - __kvm_bp_vect_base =kvm_ksym_ref (__bp_harden_hyp_vecs); - __kvm_bp_vect_base =kern_hyp_va (__kvm_bp_vect_base); - } -if (cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS )) {phys_addr_t vect_pa =__pa_symbol (__bp_harden_hyp_vecs);unsigned long size = __BP_HARDEN_HYP_VECS_SZ;
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 2/9 KVM: arm64: Tidy up kvm_map_vector()
In reply to Will DeaconThe bulk of the work in kvm_map_vector() is conditional on the ARM64_HARDEN_EL2_VECTORS capability, so return early if that is not set and make the code a bit easier to read.
--- arch/arm64/kvm/arm.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-)
arch/arm64/kvm/arm.c +14 -14
@@ -1297,6 +1297,8 @@ static unsigned long nvhe_percpu_order(void)static int kvm_map_vectors (void ) { +int slot; +/* * SV2 = ARM64_SPECTRE_V2 * HEL2 = ARM64_HARDEN_EL2_VECTORS
@@ -1306,22 +1308,20 @@ static int kvm_map_vectors(void)* !SV2 + HEL2 -> allocate one vector slot and use exec mapping * SV2 + HEL2 -> use hardened vectors and use exec mapping */ -if (cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS )) { -phys_addr_t vect_pa =__pa_symbol (__bp_harden_hyp_vecs); -unsigned long size = __BP_HARDEN_HYP_VECS_SZ; +if (!cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS )) +return 0 ; -/* -* Always allocate a spare vector slot, as we don't -* know yet which CPUs have a BP hardening slot that -* we can reuse. -*/ - __kvm_harden_el2_vector_slot =atomic_inc_return (&arm64_el2_vector_last_slot); -BUG_ON (__kvm_harden_el2_vector_slot >=BP_HARDEN_EL2_SLOTS ); -return create_hyp_exec_mappings (vect_pa, size, - &__kvm_bp_vect_base); - } +/* +* Always allocate a spare vector slot, as we don't know yet which CPUs +* have a BP hardening slot that we can reuse. +*/ + slot =atomic_inc_return (&arm64_el2_vector_last_slot); +BUG_ON (slot >=BP_HARDEN_EL2_SLOTS ); + __kvm_harden_el2_vector_slot = slot; -return 0 ; +return create_hyp_exec_mappings (__pa_symbol (__bp_harden_hyp_vecs), + __BP_HARDEN_HYP_VECS_SZ, + &__kvm_bp_vect_base); }static void cpu_init_hyp_mode (void )
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 3/9 KVM: arm64: Move kvm_get_hyp_vector() out of header file
In reply to Will Deaconkvm_get_hyp_vector() has only one caller, so move it out of kvm_mmu.h and inline it into a new function, cpu_set_hyp_vector(), for setting the vector.
--- arch/arm64/include/asm/kvm_mmu.h | 43 ----------------------------- arch/arm64/kvm/arm.c | 46 ++++++++++++++++++++++++++++++-- 2 files changed, 44 insertions(+), 45 deletions(-)
arch/arm64/include/asm/kvm_mmu.h +0 -43
@@ -208,52 +208,9 @@ static inline int kvm_write_guest_lock(struct kvm *kvm, gpa_t gpa,return ret; } -/* -* EL2 vectors can be mapped and rerouted in a number of ways, -* depending on the kernel configuration and CPU present: -* -* - If the CPU is affected by Spectre-v2, the hardening sequence is -* placed in one of the vector slots, which is executed before jumping -* to the real vectors. -* -* - If the CPU also has the ARM64_HARDEN_EL2_VECTORS cap, the slot -* containing the hardening sequence is mapped next to the idmap page, -* and executed before jumping to the real vectors. -* -* - If the CPU only has the ARM64_HARDEN_EL2_VECTORS cap, then an -* empty slot is selected, mapped next to the idmap page, and -* executed before jumping to the real vectors. -* -* Note that ARM64_HARDEN_EL2_VECTORS is somewhat incompatible with -* VHE, as we don't have hypervisor-specific mappings. If the system -* is VHE and yet selects this capability, it will be ignored. -*/ extern void *__kvm_bp_vect_base;extern int __kvm_harden_el2_vector_slot; -static inline void *kvm_get_hyp_vector (void ) -{ -struct bp_hardening_data *data =arm64_get_bp_hardening_data (); -void *vect =kern_hyp_va (kvm_ksym_ref (__kvm_hyp_vector)); -int slot =-1 ; - -if (cpus_have_const_cap (ARM64_SPECTRE_V2 ) && data->fn) { - vect =kern_hyp_va (kvm_ksym_ref (__bp_harden_hyp_vecs)); - slot = data->hyp_vectors_slot; - } - -if (this_cpu_has_cap (ARM64_HARDEN_EL2_VECTORS ) && !has_vhe ()) { - vect = __kvm_bp_vect_base; -if (slot ==-1 ) - slot = __kvm_harden_el2_vector_slot; - } - -if (slot !=-1 ) - vect += slot *SZ_2K ; - -return vect; -} -#define kvm_phys_to_vttbr (addr) phys_to_ttbr(addr) static __always_inline u64 kvm_get_vttbr(struct kvm_s2_mmu *mmu)
arch/arm64/kvm/arm.c +44 -2
57 lines not on this page · raw message
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 4/9 KVM: arm64: Make BP hardening globals static instead
In reply to Will DeaconBranch predictor hardening of the hyp vectors is partially driven by a couple of global variables ('__kvm_bp_vect_base' and '__kvm_harden_el2_vector_slot'). However, these are only used within a single compilation unit, so internalise them there instead.
--- arch/arm64/include/asm/kvm_mmu.h | 3 --- arch/arm64/kvm/arm.c | 8 ++++++++ arch/arm64/kvm/va_layout.c | 3 --- 3 files changed, 8 insertions(+), 6 deletions(-)
arch/arm64/include/asm/kvm_mmu.h +0 -3
@@ -208,9 +208,6 @@ static inline int kvm_write_guest_lock(struct kvm *kvm, gpa_t gpa,return ret; } -extern void *__kvm_bp_vect_base; -extern int __kvm_harden_el2_vector_slot; -#define kvm_phys_to_vttbr (addr) phys_to_ttbr(addr) static __always_inline u64 kvm_get_vttbr(struct kvm_s2_mmu *mmu)
arch/arm64/kvm/arm.c +8 -0
@@ -51,6 +51,14 @@ DECLARE_KVM_HYP_PER_CPU(unsigned long, kvm_hyp_vector); static DEFINE_PER_CPU(unsigned long, kvm_arm_hyp_stack_page);unsigned long kvm_arm_hyp_percpu_base[NR_CPUS ]; +/* Hypervisor VA of the indirect vector trampoline page */ +static void *__kvm_bp_vect_base; +/* +* Slot in the hyp vector page for use by the indirect vector trampoline +* when mitigation against Spectre-v2 is not required. +*/ +static int __kvm_harden_el2_vector_slot; +/* The VMID used in the VTTBR */ static atomic64_t kvm_vmid_gen =ATOMIC64_INIT (1 );static u32 kvm_next_vmid;
arch/arm64/kvm/va_layout.c +0 -3
@@ -131,9 +131,6 @@ void __init kvm_update_va_mask(struct alt_instr *alt, } } -void *__kvm_bp_vect_base; -int __kvm_harden_el2_vector_slot; -void kvm_patch_vector_branch (struct alt_instr *alt,__le32 *origptr,__le32 *updptr,int nr_inst) {
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 5/9 KVM: arm64: Move BP hardening helpers into spectre.h
In reply to Will DeaconThe BP hardening helpers are an integral part of the Spectre-v2 mitigation, so move them into asm/spectre.h and inline the arm64_get_bp_hardening_data() function at the same time.
--- arch/arm64/include/asm/mmu.h | 29 ----------------------------- arch/arm64/include/asm/spectre.h | 30 ++++++++++++++++++++++++++++++ arch/arm64/kvm/arm.c | 2 +- arch/arm64/kvm/hyp/hyp-entry.S | 1 + 4 files changed, 32 insertions(+), 30 deletions(-)
arch/arm64/include/asm/mmu.h +0 -29
@@ -12,9 +12,6 @@#define USER_ASID_FLAG (UL(1) << USER_ASID_BIT)#define TTBR_ASID_MASK (UL(0xffff) << 48) -#define BP_HARDEN_EL2_SLOTS 4 -#define __BP_HARDEN_HYP_VECS_SZ (BP_HARDEN_EL2_SLOTS * SZ_2K) -#ifndef __ASSEMBLY__#include <linux/refcount.h>
@@ -41,32 +38,6 @@ static inline bool arm64_kernel_unmapped_at_el0(void)return cpus_have_const_cap (ARM64_UNMAP_KERNEL_AT_EL0 ); } -typedef void (*bp_hardening_cb_t )(void ); - -struct bp_hardening_data { -int hyp_vectors_slot; -bp_hardening_cb_t fn; -}; - -DECLARE_PER_CPU_READ_MOSTLY(struct bp_hardening_data, bp_hardening_data); - -static inline struct bp_hardening_data *arm64_get_bp_hardening_data (void ) -{ -return this_cpu_ptr (&bp_hardening_data); -} - -static inline void arm64_apply_bp_hardening (void ) -{ -struct bp_hardening_data *d; - -if (!cpus_have_const_cap (ARM64_SPECTRE_V2 )) -return ; - - d =arm64_get_bp_hardening_data (); -if (d->fn) - d->fn (); -} -extern void arm64_memblock_init (void );extern void paging_init (void );extern void bootmem_init (void );
arch/arm64/include/asm/spectre.h +30 -0
@@ -9,7 +9,15 @@#ifndef __ASM_SPECTRE_H#define __ASM_SPECTRE_H +#define BP_HARDEN_EL2_SLOTS 4 +#define __BP_HARDEN_HYP_VECS_SZ (BP_HARDEN_EL2_SLOTS * SZ_2K) + +#ifndef __ASSEMBLY__ + +#include <linux/percpu.h> +#include <asm/cpufeature.h> +#include <asm/virt.h> /* Watch out, ordering is important here. */ enum mitigation_state {
@@ -20,6 +28,27 @@ enum mitigation_state {struct task_struct ; +typedef void (*bp_hardening_cb_t )(void ); + +struct bp_hardening_data { +int hyp_vectors_slot; +bp_hardening_cb_t fn; +}; + +DECLARE_PER_CPU_READ_MOSTLY(struct bp_hardening_data, bp_hardening_data); + +static inline void arm64_apply_bp_hardening (void ) +{ +struct bp_hardening_data *d; + +if (!cpus_have_const_cap (ARM64_SPECTRE_V2 )) +return ; + + d =this_cpu_ptr (&bp_hardening_data); +if (d->fn) + d->fn (); +} +enum mitigation_state arm64_get_spectre_v2_state (void );bool has_spectre_v2 (const struct arm64_cpu_capabilities *cap,int scope);void spectre_v2_enable_mitigation (const struct arm64_cpu_capabilities *__unused);
@@ -29,4 +58,5 @@ bool has_spectre_v4(const struct arm64_cpu_capabilities *cap, int scope);void spectre_v4_enable_mitigation (const struct arm64_cpu_capabilities *__unused);void spectre_v4_enable_task_mitigation (struct task_struct *tsk); +#endif /* __ASSEMBLY__ */ #endif /* __ASM_SPECTRE_H */
arch/arm64/kvm/arm.c +1 -1
@@ -1405,7 +1405,7 @@ static void cpu_hyp_reset(void)*/ static void cpu_set_hyp_vector (void ) { -struct bp_hardening_data *data =arm64_get_bp_hardening_data (); +struct bp_hardening_data *data =this_cpu_ptr (&bp_hardening_data);void *vect =kern_hyp_va (kvm_ksym_ref (__kvm_hyp_vector));int slot =-1 ;
arch/arm64/kvm/hyp/hyp-entry.S +1 -0
@@ -13,6 +13,7 @@ #include <asm/kvm_arm.h> #include <asm/kvm_asm.h> #include <asm/mmu.h> +#include <asm/spectre.h> .macro save_caller_saved_regs_vect /* x0 and x1 were saved in the vector entry */
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 6/9 KVM: arm64: Re-jig logic when patching hardened hyp vectors
In reply to Will DeaconThe hardened hyp vectors are not used on systems running with VHE or CPUs without the ARM64_HARDEN_EL2_VECTORS capability.
Re-jig the checking logic slightly in kvm_patch_vector_branch() so that it's a bit clearer what we're looking for. This is purely cosmetic.
--- arch/arm64/kvm/va_layout.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/arm64/kvm/va_layout.c +2 -2
@@ -139,8 +139,8 @@ void kvm_patch_vector_branch(struct alt_instr *alt,BUG_ON (nr_inst !=5 ); -if (has_vhe () || !cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS )) { -WARN_ON_ONCE (cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS )); +if (!cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS ) || +WARN_ON_ONCE (has_vhe ())) {return ; }
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 7/9 KVM: arm64: Allocate hyp vectors statically
In reply to Will DeaconThe EL2 vectors installed when a guest is running point at one of the following configurations for a given CPU:
- Straight at __kvm_hyp_vector
- A trampoline containing an SMC sequence to mitigate Spectre-v2 and then a direct branch to __kvm_hyp_vector
- A dynamically-allocated trampoline which has an indirect branch to __kvm_hyp_vector
- A dynamically-allocated trampoline containing an SMC sequence to mitigate Spectre-v2 and then an indirect branch to __kvm_hyp_vector
The indirect branches mean that VA randomization at EL2 isn't trivially bypassable using Spectre-v3a (where the vector base is readable by the guest).
Rather than populate these vectors dynamically, configure everything statically and use an enumerated type to identify the vector "slot" corresponding to one of the configurations above. This both simplifies the code, but also makes it much easier to implement at EL2 later on.
--- arch/arm64/include/asm/kvm_asm.h | 5 --- arch/arm64/include/asm/spectre.h | 36 ++++++++++++++- arch/arm64/kernel/cpu_errata.c | 2 + arch/arm64/kernel/proton-pack.c | 63 ++++++-------------------- arch/arm64/kvm/arm.c | 76 ++++++++++++-------------------- arch/arm64/kvm/hyp/Makefile | 2 +- arch/arm64/kvm/hyp/hyp-entry.S | 72 +++++++++++++++++------------- arch/arm64/kvm/hyp/smccc_wa.S | 32 -------------- arch/arm64/kvm/va_layout.c | 16 +------ 9 files changed, 120 insertions(+), 184 deletions(-) delete mode 100644 arch/arm64/kvm/hyp/smccc_wa.S
arch/arm64/include/asm/kvm_asm.h +0 -5
@@ -34,8 +34,6 @@*/ #define KVM_VECTOR_PREAMBLE (2 * AARCH64_INSN_SIZE) -#define __SMCCC_WORKAROUND_1_SMC_SZ 36 -#define KVM_HOST_SMCCC_ID (id) \ ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ ARM_SMCCC_SMC_64, \
@@ -175,7 +173,6 @@ extern unsigned long kvm_arm_hyp_percpu_base[NR_CPUS];DECLARE_KVM_NVHE_SYM (__per_cpu_start);DECLARE_KVM_NVHE_SYM (__per_cpu_end); -extern atomic_t arm64_el2_vector_last_slot;DECLARE_KVM_HYP_SYM (__bp_harden_hyp_vecs);#define __bp_harden_hyp_vecs CHOOSE_HYP_SYM(__bp_harden_hyp_vecs)
@@ -198,8 +195,6 @@ extern void __vgic_v3_init_lrs(void);extern u32 __kvm_get_mdcr_el2 (void ); -extern char __smccc_workaround_1_smc[__SMCCC_WORKAROUND_1_SMC_SZ]; -/* * Obtain the PC-relative address of a kernel symbol * s: symbol
arch/arm64/include/asm/spectre.h +34 -2
@@ -28,11 +28,41 @@ enum mitigation_state {struct task_struct ; +/* +* Note: the order of this enum corresponds to __bp_harden_hyp_vecs and +* we rely on having the direct vectors first. +*/ +enum arm64_hyp_spectre_vector { +/* +* Take exceptions directly to __kvm_hyp_vector. This must be +* 0 so that it used by default when mitigations are not needed. +*/ +HYP_VECTOR_DIRECT , + +/* +* Bounce via a slot in the hypervisor text mapping of +* __bp_harden_hyp_vecs, which contains an SMC call. +*/ +HYP_VECTOR_SPECTRE_DIRECT , + +/* +* Bounce via a slot in a special mapping of __bp_harden_hyp_vecs +* next to the idmap page. +*/ +HYP_VECTOR_INDIRECT , + +/* +* Bounce via a slot in a special mapping of __bp_harden_hyp_vecs +* next to the idmap page, which contains an SMC call. +*/ +HYP_VECTOR_SPECTRE_INDIRECT , +}; +typedef void (*bp_hardening_cb_t )(void );struct bp_hardening_data { -int hyp_vectors_slot; -bp_hardening_cb_t fn; +enum arm64_hyp_spectre_vector slot; +bp_hardening_cb_t fn; }; DECLARE_PER_CPU_READ_MOSTLY(struct bp_hardening_data, bp_hardening_data);
@@ -53,6 +83,8 @@ enum mitigation_state arm64_get_spectre_v2_state(void);bool has_spectre_v2 (const struct arm64_cpu_capabilities *cap,int scope);void spectre_v2_enable_mitigation (const struct arm64_cpu_capabilities *__unused); +void cpu_el2_vector_harden_enable (const struct arm64_cpu_capabilities *__unused); +enum mitigation_state arm64_get_spectre_v4_state (void );bool has_spectre_v4 (const struct arm64_cpu_capabilities *cap,int scope);void spectre_v4_enable_mitigation (const struct arm64_cpu_capabilities *__unused);
arch/arm64/kernel/cpu_errata.c +2 -0
@@ -459,9 +459,11 @@ const struct arm64_cpu_capabilities arm64_errata[] = { },#ifdef CONFIG_RANDOMIZE_BASE { +/* Must come after the Spectre-v2 entry */ .desc = "EL2 vector hardening", .capability =ARM64_HARDEN_EL2_VECTORS ,ERRATA_MIDR_RANGE_LIST (ca57_a72), + .cpu_enable = cpu_el2_vector_harden_enable, }, #endif {
arch/arm64/kernel/proton-pack.c +13 -50
97 lines not on this page · raw message
arch/arm64/kvm/arm.c +28 -48
108 lines not on this page · raw message
arch/arm64/kvm/hyp/Makefile +1 -1
@@ -10,4 +10,4 @@ subdir-ccflags-y := -I$(incdir) \ -DDISABLE_BRANCH_PROFILING \ $(DISABLE_STACKLEAK_PLUGIN) -obj-$(CONFIG_KVM) += vhe/ nvhe/ pgtable.o smccc_wa.o +obj-$(CONFIG_KVM) += vhe/ nvhe/ pgtable.o
arch/arm64/kvm/hyp/hyp-entry.S +41 -31
93 lines not on this page · raw message
arch/arm64/kvm/hyp/smccc_wa.S deleted +0 -32
@@ -1,32 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-only */ -/* - * Copyright (C) 2015-2018 - ARM Ltd - * Author: Marc Zyngier <[email protected]> - */ - -#include <linux/arm-smccc.h> -#include <linux/linkage.h> - -#include <asm/kvm_asm.h> -#include <asm/kvm_mmu.h> - - /* - * This is not executed directly and is instead copied into the vectors - * by install_bp_hardening_cb(). - */ - .data - .pushsection .rodata - .global __smccc_workaround_1_smc -SYM_DATA_START(__smccc_workaround_1_smc) - esb - sub sp, sp, #(8 * 4) - stp x2, x3, [sp, #(8 * 0)] - stp x0, x1, [sp, #(8 * 2)] - mov w0, #ARM_SMCCC_ARCH_WORKAROUND_1 - smc #0 - ldp x2, x3, [sp, #(8 * 0)] - ldp x0, x1, [sp, #(8 * 2)] - add sp, sp, #(8 * 4) -1: .org __smccc_workaround_1_smc + __SMCCC_WORKAROUND_1_SMC_SZ - .org 1b -SYM_DATA_END(__smccc_workaround_1_smc)
arch/arm64/kvm/va_layout.c +1 -15
@@ -137,7 +137,7 @@ void kvm_patch_vector_branch(struct alt_instr *alt,u64 addr;u32 insn; -BUG_ON (nr_inst !=5 ); +BUG_ON (nr_inst !=3 );if (!cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS ) ||WARN_ON_ONCE (has_vhe ())) {
@@ -160,15 +160,6 @@ void kvm_patch_vector_branch(struct alt_instr *alt,*/ addr +=KVM_VECTOR_PREAMBLE ; -/* stp x0, x1, [sp, #-16]! */ - insn =aarch64_insn_gen_load_store_pair (AARCH64_INSN_REG_0 , -AARCH64_INSN_REG_1 , -AARCH64_INSN_REG_SP , --16 , -AARCH64_INSN_VARIANT_64BIT , -AARCH64_INSN_LDST_STORE_PAIR_PRE_INDEX ); - *updptr++ =cpu_to_le32 (insn); -/* movz x0, #(addr & 0xffff) */ insn = aarch64_insn_gen_movewide(AARCH64_INSN_REG_0, (u16)addr,
@@ -192,9 +183,4 @@ void kvm_patch_vector_branch(struct alt_instr *alt,AARCH64_INSN_VARIANT_64BIT , AARCH64_INSN_MOVEWIDE_KEEP); *updptr++ =cpu_to_le32 (insn); - -/* br x0 */ - insn =aarch64_insn_gen_branch_reg (AARCH64_INSN_REG_0 , -AARCH64_INSN_BRANCH_NOLINK ); - *updptr++ =cpu_to_le32 (insn); }
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerRe: [PATCH v2 7/9] KVM: arm64: Allocate hyp vectors statically
Quoted 11 lines · Will Deacon
The EL2 vectors installed when a guest is running point at one of the following configurations for a given CPU:
- Straight at
__kvm_hyp_vector
- A trampoline containing an SMC sequence to mitigate Spectre-v2 and then a direct branch to__kvm_hyp_vector
- A dynamically-allocated trampoline which has an indirect branch to__kvm_hyp_vector
- A dynamically-allocated trampoline containing an SMC sequence to mitigate Spectre-v2 and then an indirect branch to__kvm_hyp_vector
Quoted 8 lines
The indirect branches mean that VA randomization at EL2 isn't trivially bypassable using Spectre-v3a (where the vector base is readable by the guest).
Rather than populate these vectors dynamically, configure everything statically and use an enumerated type to identify the vector "slot" corresponding to one of the configurations above. This both simplifies the code, but also makes it much easier to implement at EL2 later on.
This series terminally breaks VHE (the host locks up on the first guest run, CPU is nowhere to be seen again).
I have a hunch about what is happening, see below.
[...]
Quoted 109 lines
arch/arm64/kvm/arm.c +0
-4@@ -51,14 +51,6 @@ DECLARE_KVM_HYP_PER_CPU(unsigned long, kvm_hyp_vector); static DEFINE_PER_CPU(unsigned long, kvm_arm_hyp_stack_page);unsigned long kvm_arm_hyp_percpu_base[NR_CPUS ]; -/* Hypervisor VA of the indirect vector trampoline page */ -static void *__kvm_bp_vect_base; -/* -* Slot in the hyp vector page for use by the indirect vector trampoline
- * when mitigation against Spectre-v2 is not required.
- */arch/arm64/kvm/arm.c +17
-15-static int __kvm_harden_el2_vector_slot; -/* The VMID used in the VTTBR */ static atomic64_t kvm_vmid_gen =ATOMIC64_INIT (1 );static u32 kvm_next_vmid;@@ -1303,33 +1295,36 @@ static unsigned long nvhe_percpu_order(void)return size ?get_order (size) :0 ; } -static int kvm_map_vectors (void ) +/* A lookup table holding the hypervisor VA for each vector slot */ +static void *hyp_spectre_vector_selector[BP_HARDEN_EL2_SLOTS ]; + +static void kvm_init_vector_slot (void *base,enum arm64_hyp_spectre_vector slot) { -int slot; + hyp_spectre_vector_selector[slot] = base + (slot *SZ_2K ); +} + +static int kvm_init_vector_slots (void ) +{ +int err; +void *base; + + base =kern_hyp_va (kvm_ksym_ref (__kvm_hyp_vector)); +kvm_init_vector_slot (base,HYP_VECTOR_DIRECT ); + + base =kern_hyp_va (kvm_ksym_ref (__bp_harden_hyp_vecs)); +kvm_init_vector_slot (base,HYP_VECTOR_SPECTRE_DIRECT ); -/* -* SV2 = ARM64_SPECTRE_V2 -* HEL2 = ARM64_HARDEN_EL2_VECTORS -* -* !SV2 + !HEL2 -> use direct vectors -* SV2 + !HEL2 -> use hardened vectors in place -* !SV2 + HEL2 -> allocate one vector slot and use exec mapping -* SV2 + HEL2 -> use hardened vectors and use exec mapping -*/ if (!cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS ))return 0 ; -/* -* Always allocate a spare vector slot, as we don't know yet which CPUs
arch/arm64/kvm/arm.c +9
-25-* have a BP hardening slot that we can reuse. -*/ - slot =atomic_inc_return (&arm64_el2_vector_last_slot); -BUG_ON (slot >=BP_HARDEN_EL2_SLOTS ); - __kvm_harden_el2_vector_slot = slot; + err =create_hyp_exec_mappings (__pa_symbol (__bp_harden_hyp_vecs), + __BP_HARDEN_HYP_VECS_SZ, &base); +if (err) +return err; -return create_hyp_exec_mappings (__pa_symbol (__bp_harden_hyp_vecs), - __BP_HARDEN_HYP_VECS_SZ, - &__kvm_bp_vect_base); +kvm_init_vector_slot (base,HYP_VECTOR_INDIRECT ); +kvm_init_vector_slot (base,HYP_VECTOR_SPECTRE_INDIRECT ); +return 0 ; }static void cpu_init_hyp_mode (void )@@ -1406,24 +1401,9 @@ static void cpu_hyp_reset(void)static void cpu_set_hyp_vector (void ) {struct bp_hardening_data *data =this_cpu_ptr (&bp_hardening_data); -void *vect =kern_hyp_va (kvm_ksym_ref (__kvm_hyp_vector)); -int slot =-1 ; - -if (cpus_have_const_cap (ARM64_SPECTRE_V2 ) && data->fn) { - vect =kern_hyp_va (kvm_ksym_ref (__bp_harden_hyp_vecs)); - slot = data->hyp_vectors_slot; - } - -if (this_cpu_has_cap (ARM64_HARDEN_EL2_VECTORS ) && !has_vhe ()) { - vect = __kvm_bp_vect_base; -if (slot ==-1 ) - slot = __kvm_harden_el2_vector_slot; - } - -if (slot !=-1 ) - vect += slot *SZ_2K ; +void *vector = hyp_spectre_vector_selector[data->slot]; - *this_cpu_ptr_hyp_sym (kvm_hyp_vector) = (unsigned long )vect; + *this_cpu_ptr_hyp_sym (kvm_hyp_vector) = (unsigned long )vector; }static void cpu_hyp_reinit (void )
arch/arm64/kvm/arm.c static int init_hyp_mode(void) · line 1644
Quoted 5 lines
arch/arm64/kvm/arm.c +1
-1@@ -1661,9 +1641,9 @@ static int init_hyp_mode(void) goto out_err; } - err =kvm_map_vectors (); + err =kvm_init_vector_slots ();
Here, you have turned the mapping of the vectors into the full init+map. The mapping makes no sense on VHE, but the initialization does matter! init_hyp_mode() being only called on non-VHE, the HYP vectors are never initialized. Too bad.
M.
Signature · 5 lines
Jazz is not dead. It just smells funny... _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerRe: [PATCH v2 7/9] KVM: arm64: Allocate hyp vectors statically
Quoted 16 lines · Marc Zyngier
Quoted 15 lines · Will Deacon
The EL2 vectors installed when a guest is running point at one of the following configurations for a given CPU:
- Straight at
__kvm_hyp_vector
- A trampoline containing an SMC sequence to mitigate Spectre-v2 and then a direct branch to__kvm_hyp_vector
- A dynamically-allocated trampoline which has an indirect branch to__kvm_hyp_vector
- A dynamically-allocated trampoline containing an SMC sequence to mitigate Spectre-v2 and then an indirect branch to__kvm_hyp_vectorThe indirect branches mean that VA randomization at EL2 isn't trivially bypassable using Spectre-v3a (where the vector base is readable by the guest).
Quoted 7 lines
Quoted 4 lines
Rather than populate these vectors dynamically, configure everything statically and use an enumerated type to identify the vector "slot" corresponding to one of the configurations above. This both simplifies the code, but also makes it much easier to implement at EL2 later on.
This series terminally breaks VHE (the host locks up on the first guest run, CPU is nowhere to be seen again).
Whoops, sorry about that. I'll look into it.
Quoted 35 lines
I have a hunch about what is happening, see below.
[...]
Quoted 31 lines
arch/arm64/kvm/arm.c +2
-17@@ -1406,24 +1401,9 @@ static void cpu_hyp_reset(void)static void cpu_set_hyp_vector (void ) {struct bp_hardening_data *data =this_cpu_ptr (&bp_hardening_data); -void *vect =kern_hyp_va (kvm_ksym_ref (__kvm_hyp_vector)); -int slot =-1 ; - -if (cpus_have_const_cap (ARM64_SPECTRE_V2 ) && data->fn) { - vect =kern_hyp_va (kvm_ksym_ref (__bp_harden_hyp_vecs)); - slot = data->hyp_vectors_slot; - } - -if (this_cpu_has_cap (ARM64_HARDEN_EL2_VECTORS ) && !has_vhe ()) { - vect = __kvm_bp_vect_base; -if (slot ==-1 ) - slot = __kvm_harden_el2_vector_slot; - } - -if (slot !=-1 ) - vect += slot *SZ_2K ; +void *vector = hyp_spectre_vector_selector[data->slot]; - *this_cpu_ptr_hyp_sym (kvm_hyp_vector) = (unsigned long )vect; + *this_cpu_ptr_hyp_sym (kvm_hyp_vector) = (unsigned long )vector; }static void cpu_hyp_reinit (void )@@ -1661,9 +1641,9 @@ static int init_hyp_mode(void) goto out_err; }
Quoted 7 lines
arch/arm64/kvm/arm.c static int init_hyp_mode(void) · line 1644
Quoted 2 lines
arch/arm64/kvm/arm.c +1
-1- err =kvm_map_vectors (); + err =kvm_init_vector_slots ();Here, you have turned the mapping of the vectors into the full init+map. The mapping makes no sense on VHE, but the initialization does matter!
init_hyp_mode()being only called on non-VHE, the HYP vectors are never initialized. Too bad.
Yeah, that certainly smells bad. I'll hack at it now and post a v3 when it comes back to life.
Cheers,
Will
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerRe: [PATCH v2 7/9] KVM: arm64: Allocate hyp vectors statically
In reply to Will DeaconQuoted 24 lines · Will Deacon
The EL2 vectors installed when a guest is running point at one of the following configurations for a given CPU:
- Straight at
__kvm_hyp_vector
- A trampoline containing an SMC sequence to mitigate Spectre-v2 and then a direct branch to__kvm_hyp_vector
- A dynamically-allocated trampoline which has an indirect branch to__kvm_hyp_vector
- A dynamically-allocated trampoline containing an SMC sequence to mitigate Spectre-v2 and then an indirect branch to__kvm_hyp_vectorThe indirect branches mean that VA randomization at EL2 isn't trivially bypassable using Spectre-v3a (where the vector base is readable by the guest).
Rather than populate these vectors dynamically, configure everything statically and use an enumerated type to identify the vector "slot" corresponding to one of the configurations above. This both simplifies the code, but also makes it much easier to implement at EL2 later on.
Cc Marc Zyngier <[email protected]>Cc Quentin Perret <[email protected]>Signed-off-by Will Deacon <[email protected]>---
[...]
Quoted 10 lines
SYM_CODE_START(__bp_harden_hyp_vecs)arch/arm64/kvm/hyp/hyp-entry.S +2
-3- .rept BP_HARDEN_EL2_SLOTS - generate_vectors - .endr + generate_vectors indirect = 0, spectrev2 = 0 // HYP_VECTOR_DIRECT + generate_vectors indirect = 0, spectrev2 = 1 //
HYP_VECTOR_SPECTRE_DIRECT(quoted diff) +2
-0+ generate_vectors indirect = 1, spectrev2 = 0 // HYP_VECTOR_INDIRECT + generate_vectors indirect = 1, spectrev2 = 1 //
HYP_VECTOR_SPECTRE_INDIRECT
Another nit (though I'm not sure if it it's a regression or not):
Why do we generate a set of hardened vectors for HYP_VECTOR_DIRECT? The code in kvm_init_vector_slots() directly points the per-CPU VBAR to __kvm_hyp_vector, which is the right thing to do. I don't think we ever use slot 0 in __bp_harden_hyp_vecs, wasting 2kB of text.
Did I miss something?
M.
Signature · 5 lines
Jazz is not dead. It just smells funny... _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerRe: [PATCH v2 7/9] KVM: arm64: Allocate hyp vectors statically
Quoted 45 lines · Marc Zyngier
Quoted 24 lines · Will Deacon
The EL2 vectors installed when a guest is running point at one of the following configurations for a given CPU:
- Straight at
__kvm_hyp_vector
- A trampoline containing an SMC sequence to mitigate Spectre-v2 and then a direct branch to__kvm_hyp_vector
- A dynamically-allocated trampoline which has an indirect branch to__kvm_hyp_vector
- A dynamically-allocated trampoline containing an SMC sequence to mitigate Spectre-v2 and then an indirect branch to__kvm_hyp_vectorThe indirect branches mean that VA randomization at EL2 isn't trivially bypassable using Spectre-v3a (where the vector base is readable by the guest).
Rather than populate these vectors dynamically, configure everything statically and use an enumerated type to identify the vector "slot" corresponding to one of the configurations above. This both simplifies the code, but also makes it much easier to implement at EL2 later on.
Cc Marc Zyngier <[email protected]>Cc Quentin Perret <[email protected]>Signed-off-by Will Deacon <[email protected]>---
[...]
Quoted 10 lines
SYM_CODE_START(__bp_harden_hyp_vecs)arch/arm64/kvm/hyp/hyp-entry.S +2
-3- .rept BP_HARDEN_EL2_SLOTS - generate_vectors - .endr + generate_vectors indirect = 0, spectrev2 = 0 // HYP_VECTOR_DIRECT + generate_vectors indirect = 0, spectrev2 = 1 //
HYP_VECTOR_SPECTRE_DIRECT(quoted diff) +2
-0+ generate_vectors indirect = 1, spectrev2 = 0 // HYP_VECTOR_INDIRECT + generate_vectors indirect = 1, spectrev2 = 1 //
HYP_VECTOR_SPECTRE_INDIRECTAnother nit (though I'm not sure if it it's a regression or not):
Why do we generate a set of hardened vectors forHYP_VECTOR_DIRECT? The code inkvm_init_vector_slots()directly points the per-CPU VBAR to__kvm_hyp_vector, which is the right thing to do. I don't think we ever use slot 0 in__bp_harden_hyp_vecs, wasting 2kB of text.
Quoted 1 line
Did I miss something?
It's inherited from the old code, but I agree that the first slot is unused. We should be able to remove it afaict if we separate BP_HARDEN_EL2_SLOTS and __BP_HARDEN_HYP_VECS_SZ but, as ever, testing this is a massive pain. I'll add a patch on top for the next version.
Will
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 8/9 arm64: spectre: Rename ARM64_HARDEN_EL2_VECTORS to ARM64_SPECTRE_V3A
In reply to Will DeaconSince ARM64_HARDEN_EL2_VECTORS is really a mitigation for Spectre-v3a, rename it accordingly for consistency with the v2 and v4 mitigation.
--- Documentation/arm64/memory.rst | 2 +- arch/arm64/include/asm/cpucaps.h | 2 +- arch/arm64/include/asm/spectre.h | 2 +- arch/arm64/kernel/cpu_errata.c | 6 +++--- arch/arm64/kernel/proton-pack.c | 13 ++++++++++--- arch/arm64/kvm/arm.c | 8 ++++---- arch/arm64/kvm/hyp/hyp-entry.S | 3 +-- arch/arm64/kvm/va_layout.c | 4 +--- 8 files changed, 22 insertions(+), 18 deletions(-)
Documentation/arm64/memory.rst +1 -1
@@ -100,7 +100,7 @@ hypervisor maps kernel pages in EL2 at a fixed (and potentially random) offset from the linear mapping. See the kern_hyp_va macro and kvm_update_va_mask function for more details. MMIO devices such as GICv2 gets mapped next to the HYP idmap page, as do vectors when -ARM64_HARDEN_EL2_VECTORS is selected for particular CPUs. +ARM64_SPECTRE_V3A is enabled for particular CPUs. When using KVM with the Virtualization Host Extensions, no additional mappings are created, since the host kernel runs directly in EL2.
arch/arm64/include/asm/cpucaps.h +1 -1
@@ -21,7 +21,7 @@#define ARM64_HAS_VIRT_HOST_EXTN 11#define ARM64_WORKAROUND_CAVIUM_27456 12#define ARM64_HAS_32BIT_EL0 13 -#define ARM64_HARDEN_EL2_VECTORS 14 +#define ARM64_SPECTRE_V3A 14#define ARM64_HAS_CNP 15#define ARM64_HAS_NO_FPSIMD 16#define ARM64_WORKAROUND_REPEAT_TLBI 17
arch/arm64/include/asm/spectre.h +1 -1
@@ -83,7 +83,7 @@ enum mitigation_state arm64_get_spectre_v2_state(void);bool has_spectre_v2 (const struct arm64_cpu_capabilities *cap,int scope);void spectre_v2_enable_mitigation (const struct arm64_cpu_capabilities *__unused); -void cpu_el2_vector_harden_enable (const struct arm64_cpu_capabilities *__unused); +void spectre_v3a_enable_mitigation (const struct arm64_cpu_capabilities *__unused);enum mitigation_state arm64_get_spectre_v4_state (void );bool has_spectre_v4 (const struct arm64_cpu_capabilities *cap,int scope);
arch/arm64/kernel/cpu_errata.c +3 -3
@@ -460,10 +460,10 @@ const struct arm64_cpu_capabilities arm64_errata[] = {#ifdef CONFIG_RANDOMIZE_BASE {/* Must come after the Spectre-v2 entry */ - .desc = "EL2 vector hardening", - .capability =ARM64_HARDEN_EL2_VECTORS , + .desc = "Spectre-v3a", + .capability =ARM64_SPECTRE_V3A ,ERRATA_MIDR_RANGE_LIST (ca57_a72), - .cpu_enable = cpu_el2_vector_harden_enable, + .cpu_enable = spectre_v3a_enable_mitigation, }, #endif {
arch/arm64/kernel/proton-pack.c +10 -3
@@ -1,6 +1,6 @@// SPDX-License-Identifier: GPL-2.0-only /* -* Handle detection, reporting and mitigation of Spectre v1, v2 and v4, as +* Handle detection, reporting and mitigation of Spectre v1, v2, v3a and v4, as * detailed at: * * https://developer.arm.com/support/arm-security-updates/speculative-processor-vulnerability
@@ -270,11 +270,18 @@ void spectre_v2_enable_mitigation(const struct arm64_cpu_capabilities *__unused)update_mitigation_state (&spectre_v2_state, state); } -void cpu_el2_vector_harden_enable (const struct arm64_cpu_capabilities *__unused) +/* +* Spectre-v3a. +* +* Phew, there's not an awful lot to do here! We just instruct EL2 to use +* an indirect trampoline for the hyp vectors so that guests can't read +* VBAR_EL2 to defeat randomisation of the hypervisor VA layout. +*/ +void spectre_v3a_enable_mitigation (const struct arm64_cpu_capabilities *__unused) {struct bp_hardening_data *data =this_cpu_ptr (&bp_hardening_data); -if (this_cpu_has_cap (ARM64_HARDEN_EL2_VECTORS )) +if (this_cpu_has_cap (ARM64_SPECTRE_V3A )) data->slot +=HYP_VECTOR_INDIRECT ; }
arch/arm64/kvm/arm.c +4 -4
@@ -1314,7 +1314,7 @@ static int kvm_init_vector_slots(void) base =kern_hyp_va (kvm_ksym_ref (__bp_harden_hyp_vecs));kvm_init_vector_slot (base,HYP_VECTOR_SPECTRE_DIRECT ); -if (!cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS )) +if (!cpus_have_const_cap (ARM64_SPECTRE_V3A ))return 0 ; err = create_hyp_exec_mappings(__pa_symbol(__bp_harden_hyp_vecs),
@@ -1386,15 +1386,15 @@ static void cpu_hyp_reset(void)* placed in one of the vector slots, which is executed before jumping * to the real vectors. * -* - If the CPU also has the ARM64_HARDEN_EL2_VECTORS cap, the slot +* - If the CPU also has the ARM64_SPECTRE_V3A cap, the slot * containing the hardening sequence is mapped next to the idmap page, * and executed before jumping to the real vectors. * -* - If the CPU only has the ARM64_HARDEN_EL2_VECTORS cap, then an +* - If the CPU only has the ARM64_SPECTRE_V3A cap, then an * empty slot is selected, mapped next to the idmap page, and * executed before jumping to the real vectors. * -* Note that ARM64_HARDEN_EL2_VECTORS is somewhat incompatible with +* Note that ARM64_SPECTRE_V3A is somewhat incompatible with * VHE, as we don't have hypervisor-specific mappings. If the system * is VHE and yet selects this capability, it will be ignored. */
arch/arm64/kvm/hyp/hyp-entry.S +1 -2
@@ -209,8 +209,7 @@ SYM_CODE_END(__kvm_hyp_vector) .if \indirect != 0 alternative_cb kvm_patch_vector_branch /* - * For ARM64_HARDEN_EL2_VECTORS configurations, these NOPs get replaced - * with: + * For ARM64_SPECTRE_V3A configurations, these NOPs get replaced with: * * movz x0, #(addr & 0xffff) * movk x0, #((addr >> 16) & 0xffff), lsl #16
arch/arm64/kvm/va_layout.c +1 -3
@@ -139,10 +139,8 @@ void kvm_patch_vector_branch(struct alt_instr *alt,BUG_ON (nr_inst !=3 ); -if (!cpus_have_const_cap (ARM64_HARDEN_EL2_VECTORS ) || -WARN_ON_ONCE (has_vhe ())) { +if (!cpus_have_const_cap (ARM64_SPECTRE_V3A ) ||WARN_ON_ONCE (has_vhe ()))return ; - }/* * Compute HYP VA by using the same computation as kern_hyp_va()
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Will Deacon
maintainerPATCH v2 9/9 arm64: spectre: Consolidate spectre-v3a detection
In reply to Will DeaconThe spectre-v3a mitigation is split between cpu_errata.c and spectre.c, with the former handling detection of the problem and the latter handling enabling of the workaround.
Move the detection logic alongside the enabling logic, like we do for the other spectre mitigations.
--- arch/arm64/include/asm/spectre.h | 1 + arch/arm64/kernel/cpu_errata.c | 13 ++----------- arch/arm64/kernel/proton-pack.c | 12 ++++++++++++ 3 files changed, 15 insertions(+), 11 deletions(-)
arch/arm64/include/asm/spectre.h +1 -0
@@ -83,6 +83,7 @@ enum mitigation_state arm64_get_spectre_v2_state(void);bool has_spectre_v2 (const struct arm64_cpu_capabilities *cap,int scope);void spectre_v2_enable_mitigation (const struct arm64_cpu_capabilities *__unused); +bool has_spectre_v3a (const struct arm64_cpu_capabilities *cap,int scope);void spectre_v3a_enable_mitigation (const struct arm64_cpu_capabilities *__unused);enum mitigation_state arm64_get_spectre_v4_state (void );
arch/arm64/kernel/cpu_errata.c +2 -11
@@ -196,16 +196,6 @@ has_neoverse_n1_erratum_1542419(const struct arm64_cpu_capabilities *entry,return is_midr_in_range (midr, &range) && has_dic; } -#ifdef CONFIG_RANDOMIZE_BASE - -static const struct midr_range ca57_a72[] = { -MIDR_ALL_VERSIONS (MIDR_CORTEX_A57 ), -MIDR_ALL_VERSIONS (MIDR_CORTEX_A72 ), - {}, -}; - -#endif -#ifdef CONFIG_ARM64_WORKAROUND_REPEAT_TLBI static const struct arm64_cpu_capabilities arm64_repeat_tlbi_list[] = { #ifdef CONFIG_QCOM_FALKOR_ERRATUM_1009
@@ -462,7 +452,8 @@ const struct arm64_cpu_capabilities arm64_errata[] = {/* Must come after the Spectre-v2 entry */ .desc = "Spectre-v3a", .capability = ARM64_SPECTRE_V3A, - ERRATA_MIDR_RANGE_LIST(ca57_a72), + .type = ARM64_CPUCAP_LOCAL_CPU_ERRATUM, + .matches = has_spectre_v3a, .cpu_enable = spectre_v3a_enable_mitigation, },#endif
arch/arm64/kernel/proton-pack.c +12 -0
@@ -277,6 +277,18 @@ void spectre_v2_enable_mitigation(const struct arm64_cpu_capabilities *__unused)* an indirect trampoline for the hyp vectors so that guests can't read * VBAR_EL2 to defeat randomisation of the hypervisor VA layout. */ +bool has_spectre_v3a (const struct arm64_cpu_capabilities *entry,int scope) +{ +static const struct midr_range spectre_v3a_unsafe_list[] = { +MIDR_ALL_VERSIONS (MIDR_CORTEX_A57 ), +MIDR_ALL_VERSIONS (MIDR_CORTEX_A72 ), + {}, + }; + +WARN_ON (scope !=SCOPE_LOCAL_CPU ||preemptible ()); +return is_midr_in_range_list (read_cpuid_id (), spectre_v3a_unsafe_list); +} +void spectre_v3a_enable_mitigation (const struct arm64_cpu_capabilities *__unused) {struct bp_hardening_data *data =this_cpu_ptr (&bp_hardening_data);
Signature · 6 lines
2.29.2.222.g5d2a92d10f8-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm