KVM: arm64: Revamp Fine Grained Trap handling
Marc Zyngier
maintainerv2 cover KVM: arm64: Revamp Fine Grained Trap handling
Mark recently mentioned that the way we handled FGTs, and particularly their RES0 behaviour was not entirely future-proof.
The main issue is that RES0 bits are extracted from the sysreg file, which is independently updated, and that the KVM-specific enablement is not necessarily done at the same time. This means that a bit that KVM considered RES0 at some point all of a sudden acquires a meaning, and that this can trigger unexpected behaviours.
One way of fixing that would be to mandate that everything gets updated synchronously. While this is something I'd really want to see, it is unlikely to happen within my lifetime.
So the next best option is to reintroduce KVM's own view of RES0 masks, so that it can continue to ignore a given feature in a safe manner. But instead of going back to what we have a while back in the form of hand-crafted masks that are likely to be wrong, this series makes use of the rather exhaustive description of traps that we know about, and then some more:
- compile the encoding_to_fgt[] array into individual positive, negative, and res0 masks
- use these masks in place of anything that is hardcoded
- fix a few bugs along the way (thanks Mark!)
- perform some validation and let users know that KVM may be missing some FGT bit definitions
But it would be foolish to stop here. We also use FGTs to implement the so called "Fine Grained UNDEF" (FGU) bits, and make sure that system registers that are not exposed to a guest do UNDEF. This means evaluating the guest configuration and setting up these FGU bits when said configuration isn't supported.
This series therefore goes one step further and, for the HFG*TR_EL2, HDFG*TR_EL2, and HAFGRTR_EL2 registers, define which bit is controlled by which feature. This is done mechanically, with very minimal human intervention, by extracting the relevant data from the ARM-released JSON files.
Oh, and one more thing: we now do the same for HCRX_EL2 and HCR_EL2. Isn't that great?
With that data, we greatly simplify the dependency between FGUs and features, as no code needs to be written. We also use the same data to set the RES0 bits for any register that requires sanitisation (the VNCR-backed registers, for example).
Overall, and while this is a lot of new LoCs, it is IMO a reduction in complexity and maintenance burden.
This series is atop of 6.14-rc4, and contains bits and pieces of FEAT_LS64 support thanks to the newly added HFGITR_EL2.PSBCSYNC bit sharing an EC with LS64.
* From v1 [1]:
- Renamed the LS64 EC to OTHER (Mark)
- Simplified the handling of the OTHER EC by folding the relevant checks (Fuad)
- Added HCRX_EL2 and HCR_EL2 conversion to the config scheme, the latter requiring some extra infrastructure
- Rebased on v6.14-rc4
[1] https://lore.kernel.org/r/[email protected]
Marc Zyngier (22):
arm64: sysreg: Add ID_AA64ISAR1_EL1.LS64 encoding for FEAT_LS64WB
arm64: sysreg: Update ID_AA64MMFR4_EL1 description
arm64: sysreg: Add layout for HCR_EL2
arm64: Add syndrome information for trapped LD64B/ST64B{,V,V0}
KVM: arm64: Handle trapping of FEAT_LS64* instructions
KVM: arm64: Restrict ACCDATA_EL1 undef to FEAT_ST64_ACCDATA being
disabled
KVM: arm64: Don't treat HCRX_EL2 as a FGT register
KVM: arm64: Plug FEAT_GCS handling
KVM: arm64: Compute FGT masks from KVM's own FGT tables
KVM: arm64: Add description of FGT bits leading to EC!=0x18
KVM: arm64: Use computed masks as sanitisers for FGT registers
KVM: arm64: Propagate FGT masks to the nVHE hypervisor
KVM: arm64: Use computed FGT masks to setup FGT registers
KVM: arm64: Remove most hand-crafted masks for FGT registers
KVM: arm64: Use KVM-specific HCRX_EL2 RES0 mask
KVM: arm64: Handle PSB CSYNC traps
KVM: arm64: Switch to table-driven FGU configuration
KVM: arm64: Validate FGT register descriptions against RES0 masks
KVM: arm64: Use FGT feature maps to drive RES0 bits
KVM: arm64: Allow kvm_has_feat() to take variable arguments
KVM: arm64: Use HCRX_EL2 feature map to drive fixed-value bits
KVM: arm64: Use HCR_EL2 feature map to drive fixed-value bits
Mark Rutland (1):
KVM: arm64: Unconditionally configure fine-grain traps
arch/arm64/include/asm/esr.h | 9 +- arch/arm64/include/asm/kvm_arm.h | 189 +++-- arch/arm64/include/asm/kvm_host.h | 33 +- arch/arm64/kvm/Makefile | 2 +- arch/arm64/kvm/arm.c | 8 + arch/arm64/kvm/config.c | 891 ++++++++++++++++++++++++ arch/arm64/kvm/emulate-nested.c | 140 +++- arch/arm64/kvm/handle_exit.c | 72 ++ arch/arm64/kvm/hyp/include/hyp/switch.h | 110 +-- arch/arm64/kvm/hyp/nvhe/switch.c | 7 + arch/arm64/kvm/nested.c | 204 +----- arch/arm64/kvm/sys_regs.c | 65 +- arch/arm64/tools/sysreg | 90 ++- 13 files changed, 1394 insertions(+), 426 deletions(-) create mode 100644 arch/arm64/kvm/config.c
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 1/23 arm64: sysreg: Add ID_AA64ISAR1_EL1.LS64 encoding for FEAT_LS64WB
The 2024 extensions are adding yet another variant of LS64 (aptly named FEAT_LS64WB) supporting LS64 accesses to write-back memory, as well as 32 byte single-copy atomic accesses using pairs of FP registers.
Add the relevant encoding to ID_AA64ISAR1_EL1.LS64.
--- arch/arm64/tools/sysreg | 1 + 1 file changed, 1 insertion(+)
arch/arm64/tools/sysreg +1 -0
@@ -1466,6 +1466,7 @@ UnsignedEnum 63:60 LS64 0b0001 LS64 0b0010 LS64_V 0b0011 LS64_ACCDATA + 0b0100 LS64WB EndEnum UnsignedEnum 59:56 XS 0b0000 NI
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 2/23 arm64: sysreg: Update ID_AA64MMFR4_EL1 description
In reply to Marc ZyngierResync the ID_AA64MMFR4_EL1 with the architectue description.
This results in:
- the new PoPS field
- the new NV2P1 value for the NV_frac field
- the new RMEGDI field
- the new SRMASK field
These fields have been generated from the reference JSON file.
--- arch/arm64/tools/sysreg | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)
arch/arm64/tools/sysreg +16 -3
@@ -1944,12 +1944,21 @@ EndEnum EndSysreg Sysreg ID_AA64MMFR4_EL1 3 0 0 7 4 -Res0 63:40 +Res0 63:48 +UnsignedEnum 47:44 SRMASK + 0b0000 NI + 0b0001 IMP +EndEnum +Res0 43:40 UnsignedEnum 39:36 E3DSE 0b0000 NI 0b0001 IMP EndEnum -Res0 35:28 +Res0 35:32 +UnsignedEnum 31:28 RMEGDI + 0b0000 NI + 0b0001 IMP +EndEnum SignedEnum 27:24 E2H0 0b0000 IMP 0b1110 NI_NV1
@@ -1958,6 +1967,7 @@ EndEnum UnsignedEnum 23:20 NV_frac 0b0000 NV_NV2 0b0001 NV2_ONLY + 0b0010 NV2P1 EndEnum UnsignedEnum 19:16 FGWTE3 0b0000 NI
@@ -1977,7 +1987,10 @@ SignedEnum 7:4 EIESB 0b0010 ToELx 0b1111 ANY EndEnum -Res0 3:0 +UnsignedEnum 3:0 PoPS + 0b0000 NI + 0b0001 IMP +EndEnum EndSysreg Sysreg SCTLR_EL1 3 0 1 0 0
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 3/23 arm64: sysreg: Add layout for HCR_EL2
In reply to Marc ZyngierAdd HCR_EL2 to the sysreg file, more or less directly generated from the JSON file.
Since the generated names significantly differ from the existing naming, express the old names in terms of the new one. One day, we'll fix this mess, but I'm not in any hurry.
--- arch/arm64/include/asm/kvm_arm.h | 125 ++++++++++++++++--------------- arch/arm64/tools/sysreg | 68 +++++++++++++++++ 2 files changed, 132 insertions(+), 61 deletions(-)
arch/arm64/include/asm/kvm_arm.h +64 -61
@@ -12,67 +12,70 @@#include <asm/sysreg.h> #include <asm/types.h> -/* Hyp Configuration Register (HCR) bits */ - -#define HCR_TID5 (UL(1) << 58) -#define HCR_DCT (UL(1) << 57) -#define HCR_ATA_SHIFT 56 -#define HCR_ATA (UL(1) << HCR_ATA_SHIFT) -#define HCR_TTLBOS (UL(1) << 55) -#define HCR_TTLBIS (UL(1) << 54) -#define HCR_ENSCXT (UL(1) << 53) -#define HCR_TOCU (UL(1) << 52) -#define HCR_AMVOFFEN (UL(1) << 51) -#define HCR_TICAB (UL(1) << 50) -#define HCR_TID4 (UL(1) << 49) -#define HCR_FIEN (UL(1) << 47) -#define HCR_FWB (UL(1) << 46) -#define HCR_NV2 (UL(1) << 45) -#define HCR_AT (UL(1) << 44) -#define HCR_NV1 (UL(1) << 43) -#define HCR_NV (UL(1) << 42) -#define HCR_API (UL(1) << 41) -#define HCR_APK (UL(1) << 40) -#define HCR_TEA (UL(1) << 37) -#define HCR_TERR (UL(1) << 36) -#define HCR_TLOR (UL(1) << 35) -#define HCR_E2H (UL(1) << 34) -#define HCR_ID (UL(1) << 33) -#define HCR_CD (UL(1) << 32) -#define HCR_RW_SHIFT 31 -#define HCR_RW (UL(1) << HCR_RW_SHIFT) -#define HCR_TRVM (UL(1) << 30) -#define HCR_HCD (UL(1) << 29) -#define HCR_TDZ (UL(1) << 28) -#define HCR_TGE (UL(1) << 27) -#define HCR_TVM (UL(1) << 26) -#define HCR_TTLB (UL(1) << 25) -#define HCR_TPU (UL(1) << 24) -#define HCR_TPC (UL(1) << 23)/* HCR_TPCP if FEAT_DPB */ -#define HCR_TSW (UL(1) << 22) -#define HCR_TACR (UL(1) << 21) -#define HCR_TIDCP (UL(1) << 20) -#define HCR_TSC (UL(1) << 19) -#define HCR_TID3 (UL(1) << 18) -#define HCR_TID2 (UL(1) << 17) -#define HCR_TID1 (UL(1) << 16) -#define HCR_TID0 (UL(1) << 15) -#define HCR_TWE (UL(1) << 14) -#define HCR_TWI (UL(1) << 13) -#define HCR_DC (UL(1) << 12) -#define HCR_BSU (3 << 10) -#define HCR_BSU_IS (UL(1) << 10) -#define HCR_FB (UL(1) << 9) -#define HCR_VSE (UL(1) << 8) -#define HCR_VI (UL(1) << 7) -#define HCR_VF (UL(1) << 6) -#define HCR_AMO (UL(1) << 5) -#define HCR_IMO (UL(1) << 4) -#define HCR_FMO (UL(1) << 3) -#define HCR_PTW (UL(1) << 2) -#define HCR_SWIO (UL(1) << 1) -#define HCR_VM (UL(1) << 0) -#define HCR_RES0 ((UL(1) << 48) | (UL(1) << 39)) +/* +* Because I'm terribly lazy and that repainting the whole of the KVM +* code with the proper names is a pain, use a helper to map the names +* inherited from AArch32 with the new fancy nomenclature. One day... +*/ +#define __HCR (x) HCR_EL2_##x + +#define HCR_TID5 __HCR(TID5) +#define HCR_DCT __HCR(DCT) +#define HCR_ATA_SHIFT __HCR(ATA_SHIFT) +#define HCR_ATA __HCR(ATA) +#define HCR_TTLBOS __HCR(TTLBOS) +#define HCR_TTLBIS __HCR(TTLBIS) +#define HCR_ENSCXT __HCR(EnSCXT) +#define HCR_TOCU __HCR(TOCU) +#define HCR_AMVOFFEN __HCR(AMVOFFEN) +#define HCR_TICAB __HCR(TICAB) +#define HCR_TID4 __HCR(TID4) +#define HCR_FIEN __HCR(FIEN) +#define HCR_FWB __HCR(FWB) +#define HCR_NV2 __HCR(NV2) +#define HCR_AT __HCR(AT) +#define HCR_NV1 __HCR(NV1) +#define HCR_NV __HCR(NV) +#define HCR_API __HCR(API) +#define HCR_APK __HCR(APK) +#define HCR_TEA __HCR(TEA) +#define HCR_TERR __HCR(TERR) +#define HCR_TLOR __HCR(TLOR) +#define HCR_E2H __HCR(E2H) +#define HCR_ID __HCR(ID) +#define HCR_CD __HCR(CD) +#define HCR_RW __HCR(RW) +#define HCR_TRVM __HCR(TRVM) +#define HCR_HCD __HCR(HCD) +#define HCR_TDZ __HCR(TDZ) +#define HCR_TGE __HCR(TGE) +#define HCR_TVM __HCR(TVM) +#define HCR_TTLB __HCR(TTLB) +#define HCR_TPU __HCR(TPU) +#define HCR_TPC __HCR(TPCP) +#define HCR_TSW __HCR(TSW) +#define HCR_TACR __HCR(TACR) +#define HCR_TIDCP __HCR(TIDCP) +#define HCR_TSC __HCR(TSC) +#define HCR_TID3 __HCR(TID3) +#define HCR_TID2 __HCR(TID2) +#define HCR_TID1 __HCR(TID1) +#define HCR_TID0 __HCR(TID0) +#define HCR_TWE __HCR(TWE) +#define HCR_TWI __HCR(TWI) +#define HCR_DC __HCR(DC) +#define HCR_BSU __HCR(BSU) +#define HCR_BSU_IS __HCR(BSU_IS) +#define HCR_FB __HCR(FB) +#define HCR_VSE __HCR(VSE) +#define HCR_VI __HCR(VI) +#define HCR_VF __HCR(VF) +#define HCR_AMO __HCR(AMO) +#define HCR_IMO __HCR(IMO) +#define HCR_FMO __HCR(FMO) +#define HCR_PTW __HCR(PTW) +#define HCR_SWIO __HCR(SWIO) +#define HCR_VM __HCR(VM)/* * The bits we set in HCR:
arch/arm64/tools/sysreg +68 -0
74 lines not on this page · raw message
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 4/23 arm64: Add syndrome information for trapped LD64B/ST64B{,V,V0}
In reply to Marc ZyngierProvide the architected EC and ISS values for all the FEAT_LS64* instructions.
--- arch/arm64/include/asm/esr.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
arch/arm64/include/asm/esr.h +7 -1
@@ -20,7 +20,8 @@#define ESR_ELx_EC_FP_ASIMD UL(0x07)#define ESR_ELx_EC_CP10_ID UL(0x08)/* EL2 only */ #define ESR_ELx_EC_PAC UL(0x09)/* EL2 and above */ -/* Unallocated EC: 0x0A - 0x0B */ +#define ESR_ELx_EC_OTHER UL(0x0A) +/* Unallocated EC: 0x0B */ #define ESR_ELx_EC_CP14_64 UL(0x0C)#define ESR_ELx_EC_BTI UL(0x0D)#define ESR_ELx_EC_ILL UL(0x0E)
@@ -174,6 +175,11 @@#define ESR_ELx_WFx_ISS_WFE (UL(1) << 0)#define ESR_ELx_xVC_IMM_MASK ((UL(1) << 16) - 1) +/* ISS definitions for LD64B/ST64B instructions */ +#define ESR_ELx_ISS_OTHER_ST64BV (0) +#define ESR_ELx_ISS_OTHER_ST64BV0 (1) +#define ESR_ELx_ISS_OTHER_LDST64B (2) +#define DISR_EL1_IDS (UL(1) << 24)/* * DISR_EL1 and ESR_ELx share the bottom 13 bits, but the RES0 bits may mean
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 5/23 KVM: arm64: Handle trapping of FEAT_LS64* instructions
In reply to Marc ZyngierWe generally don't expect FEAT_LS64* instructions to trap, unless they are trapped by a guest hypervisor.
Otherwise, this is just the guest playing tricks on us by using an instruction that isn't advertised, which we handle with a well deserved UNDEF.
--- arch/arm64/kvm/handle_exit.c | 56 ++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+)
arch/arm64/kvm/handle_exit.c +56 -0
@@ -294,6 +294,61 @@ static int handle_svc(struct kvm_vcpu *vcpu)return 1 ; } +static int handle_other (struct kvm_vcpu *vcpu) +{ +bool is_l2 =vcpu_has_nv (vcpu) && !is_hyp_ctxt (vcpu); +u64 hcrx =__vcpu_sys_reg (vcpu,HCRX_EL2 ); +u64 esr =kvm_vcpu_get_esr (vcpu); +u64 iss =ESR_ELx_ISS (esr); +struct kvm *kvm = vcpu->kvm; +bool allowed, fwd = false; + +/* +* We only trap for two reasons: +* +* - the feature is disabled, and the only outcome is to +* generate an UNDEF. +* +* - the feature is enabled, but a NV guest wants to trap the +* feature used my its L2 guest. We forward the exception in +* this case. +* +* What we don't expect is to end-up here if the guest is +* expected be be able to directly use the feature, hence the +* WARN_ON below. +*/ +switch (iss) { +case ESR_ELx_ISS_OTHER_ST64BV: + allowed =kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64_V ); +if (is_l2) + fwd = !(hcrx & HCRX_EL2_EnASR); +break ; +case ESR_ELx_ISS_OTHER_ST64BV0: + allowed =kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64_ACCDATA ); +if (is_l2) + fwd = !(hcrx & HCRX_EL2_EnAS0); +break ; +case ESR_ELx_ISS_OTHER_LDST64B: + allowed =kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64 ); +if (is_l2) + fwd = !(hcrx & HCRX_EL2_EnALS); +break ; +default : +/* Clearly, we're missing something. */ +WARN_ON_ONCE (1 ); + allowed = false; + } + +WARN_ON_ONCE (allowed && !fwd); + +if (allowed && fwd) +kvm_inject_nested_sync (vcpu, esr); +else +kvm_inject_undefined (vcpu); + +return 1 ; +} +static exit_handle_fn arm_exit_handlers[] = { [0 ... ESR_ELx_EC_MAX] = kvm_handle_unknown_ec, [ESR_ELx_EC_WFx] = kvm_handle_wfx,
@@ -303,6 +358,7 @@ static exit_handle_fn arm_exit_handlers[] = { [ESR_ELx_EC_CP14_LS] = kvm_handle_cp14_load_store, [ESR_ELx_EC_CP10_ID] = kvm_handle_cp10_id, [ESR_ELx_EC_CP14_64] = kvm_handle_cp14_64, + [ESR_ELx_EC_OTHER] = handle_other, [ESR_ELx_EC_HVC32] = handle_hvc, [ESR_ELx_EC_SMC32] = handle_smc, [ESR_ELx_EC_HVC64] = handle_hvc,
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 6/23 KVM: arm64: Restrict ACCDATA_EL1 undef to FEAT_ST64_ACCDATA being disabled
In reply to Marc ZyngierWe currently unconditionally make ACCDATA_EL1 accesses UNDEF.
As we are about to support it, restrict the UNDEF behaviour to cases where FEAT_ST64_ACCDATA is not exposed to the guest.
--- arch/arm64/kvm/sys_regs.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
arch/arm64/kvm/sys_regs.c +3 -1
@@ -4997,10 +4997,12 @@ void kvm_calculate_traps(struct kvm_vcpu *vcpu) kvm->arch.fgu[HFGxTR_GROUP] = (HFGxTR_EL2_nAMAIR2_EL1 | HFGxTR_EL2_nMAIR2_EL1 | HFGxTR_EL2_nS2POR_EL1 | - HFGxTR_EL2_nACCDATA_EL1 | HFGxTR_EL2_nSMPRI_EL1_MASK | HFGxTR_EL2_nTPIDR2_EL0_MASK); +if (!kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64_ACCDATA )) + kvm->arch.fgu[HFGxTR_GROUP] |= HFGxTR_EL2_nACCDATA_EL1; +if (!kvm_has_feat (kvm,ID_AA64ISAR0_EL1 ,TLB ,OS )) kvm->arch.fgu[HFGITR_GROUP] |= (HFGITR_EL2_TLBIRVAALE1OS| HFGITR_EL2_TLBIRVALE1OS |
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 7/23 KVM: arm64: Don't treat HCRX_EL2 as a FGT register
In reply to Marc ZyngierTreating HCRX_EL2 as yet another FGT register seems excessive, and gets in a way of further improvements. It is actually simpler to just be explicit about the masking, so just to that.
--- arch/arm64/kvm/hyp/include/hyp/switch.h | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
arch/arm64/kvm/hyp/include/hyp/switch.h +3 -6
@@ -261,12 +261,9 @@ static inline void __activate_traps_common(struct kvm_vcpu *vcpu)if (cpus_have_final_cap (ARM64_HAS_HCX )) {u64 hcrx = vcpu->arch.hcrx_el2;if (vcpu_has_nv (vcpu) && !is_hyp_ctxt (vcpu)) { -u64 clr =0 , set =0 ; - -compute_clr_set (vcpu,HCRX_EL2 , clr, set); - - hcrx |= set; - hcrx &= ~clr; +u64 val =__vcpu_sys_reg (vcpu,HCRX_EL2 ); + hcrx |= val & __HCRX_EL2_MASK; + hcrx &= ~(~val & __HCRX_EL2_nMASK); }write_sysreg_s (hcrx,SYS_HCRX_EL2 );
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 8/23 KVM: arm64: Plug FEAT_GCS handling
In reply to Marc ZyngierWe don't seem to be handling the GCS-specific exception class. Handle it by delivering an UNDEF to the guest, and populate the relevant trap bits.
--- arch/arm64/kvm/handle_exit.c | 11 +++++++++++ arch/arm64/kvm/sys_regs.c | 8 ++++++++ 2 files changed, 19 insertions(+)
arch/arm64/kvm/handle_exit.c +11 -0
@@ -294,6 +294,16 @@ static int handle_svc(struct kvm_vcpu *vcpu)return 1 ; } +static int kvm_handle_gcs (struct kvm_vcpu *vcpu) +{ +/* We don't expect GCS, so treat it with contempt */ +if (kvm_has_feat (vcpu->kvm,ID_AA64PFR1_EL1 ,GCS ,IMP )) +WARN_ON_ONCE (1 ); + +kvm_inject_undefined (vcpu); +return 1 ; +} +static int handle_other (struct kvm_vcpu *vcpu) {bool is_l2 =vcpu_has_nv (vcpu) && !is_hyp_ctxt (vcpu);
@@ -376,6 +386,7 @@ static exit_handle_fn arm_exit_handlers[] = { [ESR_ELx_EC_BRK64] = kvm_handle_guest_debug, [ESR_ELx_EC_FP_ASIMD] = kvm_handle_fpasimd, [ESR_ELx_EC_PAC] = kvm_handle_ptrauth, + [ESR_ELx_EC_GCS] = kvm_handle_gcs, };static exit_handle_fn kvm_get_exit_handler (struct kvm_vcpu *vcpu)
arch/arm64/kvm/sys_regs.c +8 -0
@@ -5056,6 +5056,14 @@ void kvm_calculate_traps(struct kvm_vcpu *vcpu) HFGITR_EL2_nBRBIALL); } +if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,GCS ,IMP )) { + kvm->arch.fgu[HFGxTR_GROUP] |= (HFGxTR_EL2_nGCS_EL0 | + HFGxTR_EL2_nGCS_EL1); + kvm->arch.fgu[HFGITR_GROUP ] |= (HFGITR_EL2_nGCSPUSHM_EL1 | + HFGITR_EL2_nGCSSTR_EL1 | + HFGITR_EL2_nGCSEPP); + } +set_bit (KVM_ARCH_FLAG_FGU_INITIALIZED , &kvm->arch.flags); out:mutex_unlock (&kvm->arch.config_lock);
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 9/23 KVM: arm64: Compute FGT masks from KVM's own FGT tables
In reply to Marc ZyngierIn the process of decoupling KVM's view of the FGT bits from the wider architectural state, use KVM's own FGT tables to build a synthitic view of what is actually known.
This allows for some checking along the way.
--- arch/arm64/include/asm/kvm_arm.h | 4 ++ arch/arm64/include/asm/kvm_host.h | 14 ++++ arch/arm64/kvm/emulate-nested.c | 102 ++++++++++++++++++++++++++++++ 3 files changed, 120 insertions(+)
arch/arm64/include/asm/kvm_arm.h +4 -0
@@ -362,6 +362,10 @@#define __HAFGRTR_EL2_MASK (GENMASK(49, 17) | GENMASK(4, 0))#define __HAFGRTR_EL2_nMASK ~(__HAFGRTR_EL2_RES0 | __HAFGRTR_EL2_MASK) +/* Because the sysreg file mixes R and W... */ +#define HFGRTR_EL2_RES0 HFGxTR_EL2_RES0 +#define HFGWTR_EL2_RES0 (HFGRTR_EL2_RES0 | __HFGRTR_ONLY_MASK) +/* Similar definitions for HCRX_EL2 */ #define __HCRX_EL2_RES0 HCRX_EL2_RES0#define __HCRX_EL2_MASK (BIT(6))
arch/arm64/include/asm/kvm_host.h +14 -0
@@ -569,6 +569,20 @@ struct kvm_sysreg_masks { } mask[NR_SYS_REGS - __SANITISED_REG_START__]; }; +struct fgt_masks { +const char *str; +u64 mask; +u64 nmask; +u64 res0; +}; + +extern struct fgt_masks hfgrtr_masks; +extern struct fgt_masks hfgwtr_masks; +extern struct fgt_masks hfgitr_masks; +extern struct fgt_masks hdfgrtr_masks; +extern struct fgt_masks hdfgwtr_masks; +extern struct fgt_masks hafgrtr_masks; +struct kvm_cpu_context {struct user_pt_regs regs;/* sp = sp_el0 */
arch/arm64/kvm/emulate-nested.c +102 -0
116 lines not on this page · raw message
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 10/23 KVM: arm64: Add description of FGT bits leading to EC!=0x18
In reply to Marc ZyngierThe current FTP tables are only concerned with the bits generating ESR_ELx.EC==0x18. However, we want an exhaustive view of what KVM really knows about.
So let's add another small table that provides that extra information.
--- arch/arm64/kvm/emulate-nested.c | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-)
arch/arm64/kvm/emulate-nested.c +26 -6
@@ -1279,16 +1279,21 @@ enum fg_filter_id { __NR_FG_FILTER_IDS__ }; -#define SR_FGF (sr, g, b, p, f) \ - { \ - .encoding = sr, \ - .end = sr, \ - .tc = { \ +#define __FGT (g, b, p, f) \ + { \ .fgt = g ## _GROUP, \ .bit = g ## _EL2_ ## b ## _SHIFT, \ .pol = p, \ .fgf = f, \ - }, \ + } + +#define FGT (g, b, p) __FGT(g, b, p, __NO_FGF__) + +#define SR_FGF (sr, g, b, p, f) \ + { \ + .encoding = sr, \ + .end = sr, \ + .tc = __FGT(g, b, p, f), \ .line = __LINE__, \ }
@@ -1989,6 +1994,14 @@ static const struct encoding_to_trap_config encoding_to_fgt[] __initconst = { SR_FGT(SYS_AMEVCNTR0_EL0(0), HAFGRTR, AMEVCNTR00_EL0, 1), }; +/* Additional FGTs that do not fire with ESR_EL2.EC==0x18 */ +static const union trap_config non_0x18_fgt[]__initconst = { +FGT (HFGITR , nGCSSTR_EL1,0 ), +FGT (HFGITR ,SVC_EL1 ,1 ), +FGT (HFGITR ,SVC_EL0 ,1 ), +FGT (HFGITR ,ERET ,1 ), +}; +static union trap_config get_trap_config (u32 sysreg) {return (union trap_config ) {
@@ -2199,6 +2212,13 @@ int __init populate_nv_trap_config(void) } } +for (int i =0 ; i <ARRAY_SIZE (non_0x18_fgt); i++) { +if (!aggregate_fgt (non_0x18_fgt[i])) { + ret = -EINVAL ; +kvm_err ("non_0x18_fgt[%d] is reserved\n" , i); + } + } + ret =check_all_fgt_masks (ret); kvm_info("nv: %ld fine grained trap handlers\n",
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 11/23 KVM: arm64: Use computed masks as sanitisers for FGT registers
In reply to Marc ZyngierNow that we have computed RES0 bits, use them to sanitise the guest view of FGT registers.
--- arch/arm64/kvm/nested.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
arch/arm64/kvm/nested.c +6 -6
@@ -1118,8 +1118,8 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu) res0 |= HFGxTR_EL2_nS2POR_EL1;if (!kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,AIE ,IMP )) res0 |= (HFGxTR_EL2_nMAIR2_EL1 | HFGxTR_EL2_nAMAIR2_EL1); -set_sysreg_masks (kvm,HFGRTR_EL2 , res0 | __HFGRTR_EL2_RES0, res1); -set_sysreg_masks (kvm,HFGWTR_EL2 , res0 | __HFGWTR_EL2_RES0, res1); +set_sysreg_masks (kvm,HFGRTR_EL2 , res0 | hfgrtr_masks.res0, res1); +set_sysreg_masks (kvm,HFGWTR_EL2 , res0 | hfgwtr_masks.res0, res1);/* HDFG[RW]TR_EL2 */ res0 = res1 =0 ;
@@ -1157,7 +1157,7 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu) HDFGRTR_EL2_nBRBDATA);if (!kvm_has_feat (kvm,ID_AA64DFR0_EL1 , PMSVer,V1P2 )) res0 |= HDFGRTR_EL2_nPMSNEVFR_EL1; -set_sysreg_masks (kvm,HDFGRTR_EL2 , res0 |HDFGRTR_EL2_RES0 , res1); +set_sysreg_masks (kvm,HDFGRTR_EL2 , res0 | hdfgrtr_masks.res0, res1);/* Reuse the bits from the read-side and add the write-specific stuff */ if (!kvm_has_feat (kvm,ID_AA64DFR0_EL1 , PMUVer,IMP ))
@@ -1166,10 +1166,10 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu) res0 |=HDFGWTR_EL2_TRCOSLAR ;if (!kvm_has_feat (kvm,ID_AA64DFR0_EL1 , TraceFilt,IMP )) res0 |=HDFGWTR_EL2_TRFCR_EL1 ; -set_sysreg_masks (kvm,HFGWTR_EL2 , res0 |HDFGWTR_EL2_RES0 , res1); +set_sysreg_masks (kvm,HFGWTR_EL2 , res0 | hdfgwtr_masks.res0, res1);/* HFGITR_EL2 */ - res0 =HFGITR_EL2_RES0 ; + res0 = hfgitr_masks.res0; res1 =HFGITR_EL2_RES1 ;if (!kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,DPB ,DPB2 )) res0 |=HFGITR_EL2_DCCVADP ;
@@ -1203,7 +1203,7 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu)set_sysreg_masks (kvm,HFGITR_EL2 , res0, res1);/* HAFGRTR_EL2 - not a lot to see here */ - res0 =HAFGRTR_EL2_RES0 ; + res0 = hafgrtr_masks.res0; res1 =HAFGRTR_EL2_RES1 ;if (!kvm_has_feat (kvm,ID_AA64PFR0_EL1 ,AMU ,V1P1 )) res0 |= ~(res0 | res1);
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 12/23 KVM: arm64: Unconditionally configure fine-grain traps
In reply to Marc ZyngierFrom: Mark Rutland <[email protected]>
... otherwise we can inherit the host configuration if this differs from the KVM configuration.
--- arch/arm64/kvm/hyp/include/hyp/switch.h | 39 ++++++++++--------------- 1 file changed, 15 insertions(+), 24 deletions(-)
arch/arm64/kvm/hyp/include/hyp/switch.h +15 -24
@@ -107,7 +107,8 @@ static inline void __activate_traps_fpsimd32(struct kvm_vcpu *vcpu)#define update_fgt_traps_cs (hctxt, vcpu, kvm, reg, clr, set) \ do { \ - u64 c = 0, s = 0; \ + u64 c = clr, s = set; \ + u64 val; \ \ ctxt_sys_reg(hctxt, reg) = read_sysreg_s(SYS_ ## reg); \ if (vcpu_has_nv(vcpu) && !is_hyp_ctxt(vcpu)) \
@@ -115,14 +116,10 @@ static inline void __activate_traps_fpsimd32(struct kvm_vcpu *vcpu) \compute_undef_clr_set (vcpu, kvm, reg, c, s); \ \ - s |= set; \ - c |= clr; \ -if (c || s) { \ - u64 val = __ ## reg ## _nMASK; \ - val |= s; \ - val &= ~c; \ - write_sysreg_s(val, SYS_ ## reg); \ - } \ + val = __ ## reg ## _nMASK; \ + val |= s; \ + val &= ~c; \ + write_sysreg_s(val, SYS_ ## reg); \ } while(0)#define update_fgt_traps (hctxt, vcpu, kvm, reg) \
@@ -175,33 +172,27 @@ static inline void __activate_traps_hfgxtr(struct kvm_vcpu *vcpu)update_fgt_traps (hctxt, vcpu, kvm,HAFGRTR_EL2 ); } -#define __deactivate_fgt (htcxt, vcpu, kvm, reg) \ +#define __deactivate_fgt (htcxt, vcpu, reg) \ do { \ - if ((vcpu_has_nv(vcpu) && !is_hyp_ctxt(vcpu)) || \ - kvm->arch.fgu[reg_to_fgt_group_id(reg)]) \ - write_sysreg_s(ctxt_sys_reg(hctxt, reg), \ - SYS_ ## reg); \ + write_sysreg_s(ctxt_sys_reg(hctxt, reg), \ + SYS_ ## reg); \ } while(0)static inline void __deactivate_traps_hfgxtr (struct kvm_vcpu *vcpu) {struct kvm_cpu_context *hctxt =host_data_ptr (host_ctxt); -struct kvm *kvm =kern_hyp_va (vcpu->kvm);if (!cpus_have_final_cap (ARM64_HAS_FGT ))return ; -__deactivate_fgt (hctxt, vcpu, kvm,HFGRTR_EL2 ); -if (cpus_have_final_cap (ARM64_WORKAROUND_AMPERE_AC03_CPU_38 )) -write_sysreg_s (ctxt_sys_reg (hctxt,HFGWTR_EL2 ),SYS_HFGWTR_EL2 ); -else -__deactivate_fgt (hctxt, vcpu, kvm,HFGWTR_EL2 ); -__deactivate_fgt (hctxt, vcpu, kvm,HFGITR_EL2 ); -__deactivate_fgt (hctxt, vcpu, kvm,HDFGRTR_EL2 ); -__deactivate_fgt (hctxt, vcpu, kvm,HDFGWTR_EL2 ); +__deactivate_fgt (hctxt, vcpu,HFGRTR_EL2 ); +__deactivate_fgt (hctxt, vcpu,HFGWTR_EL2 ); +__deactivate_fgt (hctxt, vcpu,HFGITR_EL2 ); +__deactivate_fgt (hctxt, vcpu,HDFGRTR_EL2 ); +__deactivate_fgt (hctxt, vcpu,HDFGWTR_EL2 );if (cpu_has_amu ()) -__deactivate_fgt (hctxt, vcpu, kvm,HAFGRTR_EL2 ); +__deactivate_fgt (hctxt, vcpu,HAFGRTR_EL2 ); }static inline void __activate_traps_mpam (struct kvm_vcpu *vcpu)
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 13/23 KVM: arm64: Propagate FGT masks to the nVHE hypervisor
In reply to Marc ZyngierThe nVHE hypervisor needs to have access to its own view of the FGT masks, which unfortunately results in a bit of data duplication.
--- arch/arm64/include/asm/kvm_host.h | 7 +++++++ arch/arm64/kvm/arm.c | 8 ++++++++ arch/arm64/kvm/hyp/nvhe/switch.c | 7 +++++++ 3 files changed, 22 insertions(+)
arch/arm64/include/asm/kvm_host.h +7 -0
@@ -583,6 +583,13 @@ extern struct fgt_masks hdfgrtr_masks;extern struct fgt_masks hdfgwtr_masks;extern struct fgt_masks hafgrtr_masks; +extern struct fgt_masks kvm_nvhe_sym (hfgrtr_masks ); +extern struct fgt_masks kvm_nvhe_sym (hfgwtr_masks ); +extern struct fgt_masks kvm_nvhe_sym (hfgitr_masks ); +extern struct fgt_masks kvm_nvhe_sym (hdfgrtr_masks ); +extern struct fgt_masks kvm_nvhe_sym (hdfgwtr_masks ); +extern struct fgt_masks kvm_nvhe_sym (hafgrtr_masks ); +struct kvm_cpu_context {struct user_pt_regs regs;/* sp = sp_el0 */
arch/arm64/kvm/arm.c +8 -0
@@ -2414,6 +2414,14 @@ static void kvm_hyp_init_symbols(void)kvm_nvhe_sym (__icache_flags) = __icache_flags;kvm_nvhe_sym (kvm_arm_vmid_bits) = kvm_arm_vmid_bits; +/* Propagate the FGT state to the the nVHE side */ +kvm_nvhe_sym (hfgrtr_masks) = hfgrtr_masks; +kvm_nvhe_sym (hfgwtr_masks) = hfgwtr_masks; +kvm_nvhe_sym (hfgitr_masks) = hfgitr_masks; +kvm_nvhe_sym (hdfgrtr_masks) = hdfgrtr_masks; +kvm_nvhe_sym (hdfgwtr_masks) = hdfgwtr_masks; +kvm_nvhe_sym (hafgrtr_masks) = hafgrtr_masks; +/* * Flush entire BSS since part of its data containing init symbols is read * while the MMU is off.
arch/arm64/kvm/hyp/nvhe/switch.c +7 -0
@@ -33,6 +33,13 @@ DEFINE_PER_CPU(struct kvm_host_data, kvm_host_data); DEFINE_PER_CPU(struct kvm_cpu_context, kvm_hyp_ctxt); DEFINE_PER_CPU(unsigned long, kvm_hyp_vector); +struct fgt_masks hfgrtr_masks; +struct fgt_masks hfgwtr_masks; +struct fgt_masks hfgitr_masks; +struct fgt_masks hdfgrtr_masks; +struct fgt_masks hdfgwtr_masks; +struct fgt_masks hafgrtr_masks; +extern void kvm_nvhe_prepare_backtrace (unsigned long fp,unsigned long pc);static void __activate_cptr_traps (struct kvm_vcpu *vcpu)
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 14/23 KVM: arm64: Use computed FGT masks to setup FGT registers
In reply to Marc ZyngierFlip the hyervisor FGT configuration over to the computed FGT masks.
--- arch/arm64/kvm/hyp/include/hyp/switch.h | 45 +++++++++++++++++++++---- 1 file changed, 38 insertions(+), 7 deletions(-)
arch/arm64/kvm/hyp/include/hyp/switch.h +38 -7
@@ -65,12 +65,41 @@ static inline void __activate_traps_fpsimd32(struct kvm_vcpu *vcpu) } } +#define reg_to_fgt_masks (reg) \ + ({ \ + struct fgt_masks *m; \ + switch(reg) { \ + case HFGRTR_EL2: \ + m = &hfgrtr_masks; \ + break; \ + case HFGWTR_EL2: \ + m = &hfgwtr_masks; \ + break; \ + case HFGITR_EL2: \ + m = &hfgitr_masks; \ + break; \ + case HDFGRTR_EL2: \ + m = &hdfgrtr_masks; \ + break; \ + case HDFGWTR_EL2: \ + m = &hdfgwtr_masks; \ + break; \ + case HAFGRTR_EL2: \ + m = &hafgrtr_masks; \ + break; \ + default: \ + BUILD_BUG_ON(1); \ + } \ + \ + m; \ + }) +#define compute_clr_set (vcpu, reg, clr, set) \ do { \ - u64 hfg; \ - hfg = __vcpu_sys_reg(vcpu, reg) & ~__ ## reg ## _RES0; \ - set |= hfg & __ ## reg ## _MASK; \ - clr |= ~hfg & __ ## reg ## _nMASK; \ + u64 hfg = __vcpu_sys_reg(vcpu, reg); \ + struct fgt_masks *m = reg_to_fgt_masks(reg); \ + set |= hfg & m->mask; \ + clr |= ~hfg & m->nmask; \ } while(0)#define reg_to_fgt_group_id (reg) \
@@ -101,12 +130,14 @@ static inline void __activate_traps_fpsimd32(struct kvm_vcpu *vcpu)#define compute_undef_clr_set (vcpu, kvm, reg, clr, set) \ do { \ u64 hfg = kvm->arch.fgu[reg_to_fgt_group_id(reg)]; \ - set |= hfg & __ ## reg ## _MASK; \ - clr |= hfg & __ ## reg ## _nMASK; \ + struct fgt_masks *m = reg_to_fgt_masks(reg); \ + set |= hfg & m->mask; \ + clr |= hfg & m->nmask; \ } while(0)#define update_fgt_traps_cs (hctxt, vcpu, kvm, reg, clr, set) \ do { \ + struct fgt_masks *m = reg_to_fgt_masks(reg); \ u64 c = clr, s = set; \ u64 val; \ \
@@ -116,7 +147,7 @@ static inline void __activate_traps_fpsimd32(struct kvm_vcpu *vcpu) \compute_undef_clr_set (vcpu, kvm, reg, c, s); \ \ - val = __ ## reg ## _nMASK; \ + val = m->nmask; \ val |= s; \ val &= ~c; \ write_sysreg_s(val, SYS_ ## reg); \
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 15/23 KVM: arm64: Remove most hand-crafted masks for FGT registers
In reply to Marc ZyngierThese masks are now useless, and can be removed. One notable exception is __HFGRTR_ONLY_MASK, as the sysreg file conflates the HFGRTR_EL2 and HFGWTR_EL2 bits in a most unhelpful way.
To be fixed one day...
--- arch/arm64/include/asm/kvm_arm.h | 42 +------------------------ arch/arm64/kvm/hyp/include/hyp/switch.h | 19 ----------- 2 files changed, 1 insertion(+), 60 deletions(-)
arch/arm64/include/asm/kvm_arm.h +1 -41
@@ -317,56 +317,16 @@/* * FGT register definitions -* -* RES0 and polarity masks as of DDI0487J.a, to be updated as needed. -* We're not using the generated masks as they are usually ahead of -* the published ARM ARM, which we use as a reference. -* -* Once we get to a point where the two describe the same thing, we'll -* merge the definitions. One day. -*/ -#define __HFGRTR_EL2_RES0 HFGxTR_EL2_RES0 -#define __HFGRTR_EL2_MASK GENMASK(49, 0) -#define __HFGRTR_EL2_nMASK ~(__HFGRTR_EL2_RES0 | __HFGRTR_EL2_MASK) - -/* -* The HFGWTR bits are a subset of HFGRTR bits. To ensure we don't miss any -* future additions, define __HFGWTR* macros relative to __HFGRTR* ones. */ #define __HFGRTR_ONLY_MASK (BIT(46) | BIT(42) | BIT(40) | BIT(28) | \ GENMASK(26, 25) | BIT(21) | BIT(18) | \ GENMASK(15, 14) | GENMASK(10, 9) | BIT(2)) -#define __HFGWTR_EL2_RES0 (__HFGRTR_EL2_RES0 | __HFGRTR_ONLY_MASK) -#define __HFGWTR_EL2_MASK (__HFGRTR_EL2_MASK & ~__HFGRTR_ONLY_MASK) -#define __HFGWTR_EL2_nMASK ~(__HFGWTR_EL2_RES0 | __HFGWTR_EL2_MASK) - -#define __HFGITR_EL2_RES0 HFGITR_EL2_RES0 -#define __HFGITR_EL2_MASK (BIT(62) | BIT(60) | GENMASK(54, 0)) -#define __HFGITR_EL2_nMASK ~(__HFGITR_EL2_RES0 | __HFGITR_EL2_MASK) - -#define __HDFGRTR_EL2_RES0 HDFGRTR_EL2_RES0 -#define __HDFGRTR_EL2_MASK (BIT(63) | GENMASK(58, 50) | GENMASK(48, 43) | \ - GENMASK(41, 40) | GENMASK(37, 22) | \ - GENMASK(19, 9) | GENMASK(7, 0)) -#define __HDFGRTR_EL2_nMASK ~(__HDFGRTR_EL2_RES0 | __HDFGRTR_EL2_MASK) - -#define __HDFGWTR_EL2_RES0 HDFGWTR_EL2_RES0 -#define __HDFGWTR_EL2_MASK (GENMASK(57, 52) | GENMASK(50, 48) | \ - GENMASK(46, 44) | GENMASK(42, 41) | \ - GENMASK(37, 35) | GENMASK(33, 31) | \ - GENMASK(29, 23) | GENMASK(21, 10) | \ - GENMASK(8, 7) | GENMASK(5, 0)) -#define __HDFGWTR_EL2_nMASK ~(__HDFGWTR_EL2_RES0 | __HDFGWTR_EL2_MASK) - -#define __HAFGRTR_EL2_RES0 HAFGRTR_EL2_RES0 -#define __HAFGRTR_EL2_MASK (GENMASK(49, 17) | GENMASK(4, 0)) -#define __HAFGRTR_EL2_nMASK ~(__HAFGRTR_EL2_RES0 | __HAFGRTR_EL2_MASK)/* Because the sysreg file mixes R and W... */ #define HFGRTR_EL2_RES0 HFGxTR_EL2_RES0#define HFGWTR_EL2_RES0 (HFGRTR_EL2_RES0 | __HFGRTR_ONLY_MASK) -/* Similar definitions for HCRX_EL2 */ +/* Polarity masks for HCRX_EL2 */ #define __HCRX_EL2_RES0 HCRX_EL2_RES0#define __HCRX_EL2_MASK (BIT(6))#define __HCRX_EL2_nMASK ~(__HCRX_EL2_RES0 | __HCRX_EL2_MASK)
arch/arm64/kvm/hyp/include/hyp/switch.h +0 -19
@@ -156,17 +156,6 @@ static inline void __activate_traps_fpsimd32(struct kvm_vcpu *vcpu)#define update_fgt_traps (hctxt, vcpu, kvm, reg) \ update_fgt_traps_cs(hctxt, vcpu, kvm, reg, 0, 0) -/* -* Validate the fine grain trap masks. -* Check that the masks do not overlap and that all bits are accounted for. -*/ -#define CHECK_FGT_MASKS (reg) \ - do { \ - BUILD_BUG_ON((__ ## reg ## _MASK) & (__ ## reg ## _nMASK)); \ - BUILD_BUG_ON(~((__ ## reg ## _RES0) ^ (__ ## reg ## _MASK) ^ \ - (__ ## reg ## _nMASK))); \ - } while(0) -static inline bool cpu_has_amu (void ) {u64 pfr0 =read_sysreg_s (SYS_ID_AA64PFR0_EL1 );
@@ -180,14 +169,6 @@ static inline void __activate_traps_hfgxtr(struct kvm_vcpu *vcpu)struct kvm_cpu_context *hctxt =host_data_ptr (host_ctxt);struct kvm *kvm =kern_hyp_va (vcpu->kvm); -CHECK_FGT_MASKS (HFGRTR_EL2 ); -CHECK_FGT_MASKS (HFGWTR_EL2 ); -CHECK_FGT_MASKS (HFGITR_EL2 ); -CHECK_FGT_MASKS (HDFGRTR_EL2 ); -CHECK_FGT_MASKS (HDFGWTR_EL2 ); -CHECK_FGT_MASKS (HAFGRTR_EL2 ); -CHECK_FGT_MASKS (HCRX_EL2 ); -if (!cpus_have_final_cap (ARM64_HAS_FGT ))return ;
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 16/23 KVM: arm64: Use KVM-specific HCRX_EL2 RES0 mask
In reply to Marc ZyngierWe do not have a computed table for HCRX_EL2, so statically define the bits we know about. A warning will fire if the architecture grows bits that are not handled yet.
--- arch/arm64/include/asm/kvm_arm.h | 18 ++++++++++++++---- arch/arm64/kvm/emulate-nested.c | 5 +++++ arch/arm64/kvm/nested.c | 4 ++-- 3 files changed, 21 insertions(+), 6 deletions(-)
arch/arm64/include/asm/kvm_arm.h +14 -4
@@ -326,10 +326,20 @@#define HFGRTR_EL2_RES0 HFGxTR_EL2_RES0#define HFGWTR_EL2_RES0 (HFGRTR_EL2_RES0 | __HFGRTR_ONLY_MASK) -/* Polarity masks for HCRX_EL2 */ -#define __HCRX_EL2_RES0 HCRX_EL2_RES0 -#define __HCRX_EL2_MASK (BIT(6)) -#define __HCRX_EL2_nMASK ~(__HCRX_EL2_RES0 | __HCRX_EL2_MASK) +/* +* Polarity masks for HCRX_EL2, limited to the bits that we know about +* at this point in time. It doesn't mean that we actually *handle* +* them, but that at least those that are not advertised to a guest +* will be RES0 for that guest. +*/ +#define __HCRX_EL2_MASK (BIT_ULL(6)) +#define __HCRX_EL2_nMASK (GENMASK_ULL(24, 14) | \ + GENMASK_ULL(11, 7) | \ + GENMASK_ULL(5, 0)) +#define __HCRX_EL2_RES0 ~(__HCRX_EL2_nMASK | __HCRX_EL2_MASK) +#define __HCRX_EL2_RES1 ~(__HCRX_EL2_nMASK | \ + __HCRX_EL2_MASK | \ + __HCRX_EL2_RES0)/* Hyp Prefetch Fault Address Register (HPFAR/HDFAR) */ #define HPFAR_MASK (~UL(0xf))
arch/arm64/kvm/emulate-nested.c +5 -0
@@ -2149,6 +2149,7 @@ int __init populate_nv_trap_config(void)BUILD_BUG_ON (__NR_CGT_GROUP_IDS__ >BIT (TC_CGT_BITS ));BUILD_BUG_ON (__NR_FGT_GROUP_IDS__ >BIT (TC_FGT_BITS ));BUILD_BUG_ON (__NR_FG_FILTER_IDS__ >BIT (TC_FGF_BITS )); +BUILD_BUG_ON (__HCRX_EL2_MASK & __HCRX_EL2_nMASK);for (int i =0 ; i <ARRAY_SIZE (encoding_to_cgt); i++) {const struct encoding_to_trap_config *cgt = &encoding_to_cgt[i];
@@ -2174,6 +2175,10 @@ int __init populate_nv_trap_config(void) } } +if (__HCRX_EL2_RES0 !=HCRX_EL2_RES0 ) +kvm_info ("Sanitised HCR_EL2_RES0 = %016llx, expecting %016llx\n" , + __HCRX_EL2_RES0,HCRX_EL2_RES0 ); +kvm_info ("nv: %ld coarse grained trap handlers\n" ,ARRAY_SIZE (encoding_to_cgt));
arch/arm64/kvm/nested.c +2 -2
@@ -1039,8 +1039,8 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu)set_sysreg_masks (kvm,HCR_EL2 , res0, res1);/* HCRX_EL2 */ - res0 =HCRX_EL2_RES0 ; - res1 =HCRX_EL2_RES1 ; + res0 = __HCRX_EL2_RES0; + res1 = __HCRX_EL2_RES1;if (!kvm_has_feat (kvm,ID_AA64ISAR3_EL1 ,PACM ,TRIVIAL_IMP )) res0 |= HCRX_EL2_PACMEn;if (!kvm_has_feat (kvm,ID_AA64PFR2_EL1 ,FPMR ,IMP ))
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 17/23 KVM: arm64: Handle PSB CSYNC traps
In reply to Marc ZyngierThe architecture introduces a trap for PSB CSYNC that fits in
the same EC as LS64. Let's deal with it in a similar way as
LS64.
It's not that we expect this to be useful any time soon anyway.
--- arch/arm64/include/asm/esr.h | 3 ++- arch/arm64/kvm/emulate-nested.c | 1 + arch/arm64/kvm/handle_exit.c | 5 +++++ arch/arm64/tools/sysreg | 2 +- 4 files changed, 9 insertions(+), 2 deletions(-)
arch/arm64/include/asm/esr.h +2 -1
@@ -175,10 +175,11 @@#define ESR_ELx_WFx_ISS_WFE (UL(1) << 0)#define ESR_ELx_xVC_IMM_MASK ((UL(1) << 16) - 1) -/* ISS definitions for LD64B/ST64B instructions */ +/* ISS definitions for LD64B/ST64B/PSBCSYNC instructions */ #define ESR_ELx_ISS_OTHER_ST64BV (0)#define ESR_ELx_ISS_OTHER_ST64BV0 (1)#define ESR_ELx_ISS_OTHER_LDST64B (2) +#define ESR_ELx_ISS_OTHER_PSBCSYNC (3)#define DISR_EL1_IDS (UL(1) << 24)/*
arch/arm64/kvm/emulate-nested.c +1 -0
@@ -1996,6 +1996,7 @@ static const struct encoding_to_trap_config encoding_to_fgt[] __initconst = {/* Additional FGTs that do not fire with ESR_EL2.EC==0x18 */ static const union trap_config non_0x18_fgt[]__initconst = { +FGT (HFGITR ,PSBCSYNC ,1 ),FGT (HFGITR , nGCSSTR_EL1,0 ),FGT (HFGITR ,SVC_EL1 ,1 ),FGT (HFGITR ,SVC_EL0 ,1 ),
arch/arm64/kvm/handle_exit.c +5 -0
@@ -343,6 +343,11 @@ static int handle_other(struct kvm_vcpu *vcpu)if (is_l2) fwd = !(hcrx & HCRX_EL2_EnALS);break ; +case ESR_ELx_ISS_OTHER_PSBCSYNC: + allowed =kvm_has_feat (kvm,ID_AA64DFR0_EL1 , PMSVer,V1P5 ); +if (is_l2) + fwd = (__vcpu_sys_reg (vcpu,HFGITR_EL2 ) &HFGITR_EL2_PSBCSYNC ); +break ;default :/* Clearly, we're missing something. */ WARN_ON_ONCE (1 );
arch/arm64/tools/sysreg +1 -1
@@ -2641,7 +2641,7 @@ Fields HFGxTR_EL2 EndSysreg Sysreg HFGITR_EL2 3 4 1 1 6 -Res0 63 +Field 63 PSBCSYNC Field 62 ATS1E1A Res0 61 Field 60 COSPRCTX
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 18/23 KVM: arm64: Switch to table-driven FGU configuration
In reply to Marc ZyngierDefining the FGU behaviour is extremely tedious. It relies on matching each set of bits from FGT registers with am architectural feature, and adding them to the FGU list if the corresponding feature isn't advertised to the guest.
It is however relatively easy to dump most of that information from the architecture JSON description, and use that to control the FGU bits.
Let's introduce a new set of tables descripbing the mapping between FGT bits and features. Most of the time, this is only a lookup in an idreg field, with a few more complex exceptions.
While this is obviously many more lines in a new file, this is mostly generated, and is pretty easy to maintain.
--- arch/arm64/include/asm/kvm_host.h | 2 + arch/arm64/kvm/Makefile | 2 +- arch/arm64/kvm/config.c | 589 ++++++++++++++++++++++++++++++ arch/arm64/kvm/sys_regs.c | 73 +--- 4 files changed, 596 insertions(+), 70 deletions(-) create mode 100644 arch/arm64/kvm/config.c
arch/arm64/include/asm/kvm_host.h +2 -0
@@ -1564,4 +1564,6 @@ void kvm_set_vm_id_reg(struct kvm *kvm, u32 reg, u64 val);#define kvm_has_s1poe (k) \ (kvm_has_feat((k), ID_AA64MMFR3_EL1, S1POE, IMP)) +void compute_fgu (struct kvm *kvm,enum fgt_group_id fgt); +#endif /* __ARM64_KVM_HOST_H__ */
arch/arm64/kvm/Makefile +1 -1
@@ -14,7 +14,7 @@ CFLAGS_sys_regs.o += -Wno-override-init CFLAGS_handle_exit.o += -Wno-override-init kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \ - inject_fault.o va_layout.o handle_exit.o \ + inject_fault.o va_layout.o handle_exit.o config.o \ guest.o debug.o reset.o sys_regs.o stacktrace.o \ vgic-sys-reg-v3.o fpsimd.o pkvm.o \ arch_timer.o trng.o vmid.o emulate-nested.o nested.o at.o \
arch/arm64/kvm/config.c new file +589 -0
589 lines not on this page · raw message
arch/arm64/kvm/sys_regs.c +4 -69
79 lines not on this page · raw message
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 19/23 KVM: arm64: Validate FGT register descriptions against RES0 masks
In reply to Marc ZyngierIn order to point out to the unsuspecting KVM hacker that they are missing something somewhere, validate that the known FGT bits do not intersect with the corresponding RES0 mask, as computed at boot time.
THis check is also performed at boot time, ensuring that there is no runtime overhead.
--- arch/arm64/include/asm/kvm_host.h | 1 + arch/arm64/kvm/config.c | 29 +++++++++++++++++++++++++++++ arch/arm64/kvm/sys_regs.c | 2 ++ 3 files changed, 32 insertions(+)
arch/arm64/include/asm/kvm_host.h +1 -0
@@ -1565,5 +1565,6 @@ void kvm_set_vm_id_reg(struct kvm *kvm, u32 reg, u64 val); (kvm_has_feat((k), ID_AA64MMFR3_EL1, S1POE, IMP))void compute_fgu (struct kvm *kvm,enum fgt_group_id fgt); +void check_feature_map (void );#endif /* __ARM64_KVM_HOST_H__ */
arch/arm64/kvm/config.c +29 -0
@@ -494,6 +494,35 @@ static struct reg_bits_to_feat_map hafgrtr_feat_map[] = { FEAT_AMUv1), }; +static void __init check_feat_map (struct reg_bits_to_feat_map *map, +int map_size,u64 res0,const char *str) +{ +u64 mask =0 ; + +for (int i =0 ; i < map_size; i++) + mask |= map[i].bits; + +if (mask != ~res0) +kvm_err ("Undefined %s behaviour, bits %016llx\n" , + str, mask ^ ~res0); +} + +void __init check_feature_map (void ) +{ +check_feat_map (hfgrtr_feat_map,ARRAY_SIZE (hfgrtr_feat_map), + hfgrtr_masks.res0, hfgrtr_masks.str); +check_feat_map (hfgwtr_feat_map,ARRAY_SIZE (hfgwtr_feat_map), + hfgwtr_masks.res0, hfgwtr_masks.str); +check_feat_map (hfgitr_feat_map,ARRAY_SIZE (hfgitr_feat_map), + hfgitr_masks.res0, hfgitr_masks.str); +check_feat_map (hdfgrtr_feat_map,ARRAY_SIZE (hdfgrtr_feat_map), + hdfgrtr_masks.res0, hdfgrtr_masks.str); +check_feat_map (hdfgwtr_feat_map,ARRAY_SIZE (hdfgwtr_feat_map), + hdfgwtr_masks.res0, hdfgwtr_masks.str); +check_feat_map (hafgrtr_feat_map,ARRAY_SIZE (hafgrtr_feat_map), + hafgrtr_masks.res0, hafgrtr_masks.str); +} +static bool idreg_feat_match (struct kvm *kvm,struct reg_bits_to_feat_map *map) {u64 regval = kvm->arch.id_regs[map->regidx];
arch/arm64/kvm/sys_regs.c +2 -0
@@ -5058,6 +5058,8 @@ int __init kvm_sys_reg_table_init(void) ret =populate_nv_trap_config (); +check_feature_map (); +for (i =0 ; !ret && i <ARRAY_SIZE (sys_reg_descs); i++) ret =populate_sysreg_config (sys_reg_descs + i, i);
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 20/23 KVM: arm64: Use FGT feature maps to drive RES0 bits
In reply to Marc ZyngierAnother benefit of mapping bits to features is that it becomes trivial to define which bits should be handled as RES0.
Let's apply this principle to the guest's view of the FGT registers.
--- arch/arm64/include/asm/kvm_host.h | 1 + arch/arm64/kvm/config.c | 46 +++++++++++ arch/arm64/kvm/nested.c | 129 +++--------------------------- 3 files changed, 57 insertions(+), 119 deletions(-)
arch/arm64/include/asm/kvm_host.h +1 -0
@@ -1565,6 +1565,7 @@ void kvm_set_vm_id_reg(struct kvm *kvm, u32 reg, u64 val); (kvm_has_feat((k), ID_AA64MMFR3_EL1, S1POE, IMP))void compute_fgu (struct kvm *kvm,enum fgt_group_id fgt); +void get_reg_fixed_bits (struct kvm *kvm,enum vcpu_sysreg reg,u64 *res0,u64 *res1);void check_feature_map (void );#endif /* __ARM64_KVM_HOST_H__ */
arch/arm64/kvm/config.c +46 -0
49 lines not on this page · raw message
arch/arm64/kvm/nested.c +10 -119
142 lines not on this page · raw message
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 21/23 KVM: arm64: Allow kvm_has_feat() to take variable arguments
In reply to Marc ZyngierIn order to be able to write more compact (and easier to read) code, let kvm_has_feat() and co take variable arguments. This enables constructs such as:
#define FEAT_SME ID_AA64PFR1_EL1, SME, IMP if (kvm_has_feat(kvm, FEAT_SME)) [...]
which is admitedly more readable.
--- arch/arm64/include/asm/kvm_host.h | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
arch/arm64/include/asm/kvm_host.h +6 -2
@@ -1526,12 +1526,16 @@ void kvm_set_vm_id_reg(struct kvm *kvm, u32 reg, u64 val); kvm_cmp_feat_signed(kvm, id, fld, op, limit) : \ kvm_cmp_feat_unsigned(kvm, id, fld, op, limit)) -#define kvm_has_feat (kvm, id, fld, limit) \ +#define __kvm_has_feat (kvm, id, fld, limit) \ kvm_cmp_feat(kvm, id, fld, >=, limit) -#define kvm_has_feat_enum (kvm, id, fld, val) \ +#define kvm_has_feat (kvm, ...) __kvm_has_feat(kvm, __VA_ARGS__) + +#define __kvm_has_feat_enum (kvm, id, fld, val) \ kvm_cmp_feat_unsigned(kvm, id, fld, ==, val) +#define kvm_has_feat_enum (kvm, ...) __kvm_has_feat_enum(kvm, __VA_ARGS__) +#define kvm_has_feat_range (kvm, id, fld, min, max) \ (kvm_cmp_feat(kvm, id, fld, >=, min) && \ kvm_cmp_feat(kvm, id, fld, <=, max))
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 22/23 KVM: arm64: Use HCRX_EL2 feature map to drive fixed-value bits
In reply to Marc ZyngierSimilarly to other registers, describe which HCR_EL2 bit depends on which feature, and use this to compute the RES0 status of these bits.
--- arch/arm64/kvm/config.c | 78 +++++++++++++++++++++++++++++++++++++++++ arch/arm64/kvm/nested.c | 40 +-------------------- 2 files changed, 79 insertions(+), 39 deletions(-)
arch/arm64/kvm/config.c +78 -0
@@ -77,6 +77,8 @@ struct reg_bits_to_feat_map {#define FEAT_THE ID_AA64PFR1_EL1, THE, IMP#define FEAT_SME ID_AA64PFR1_EL1, SME, IMP#define FEAT_GCS ID_AA64PFR1_EL1, GCS, IMP +#define FEAT_LS64 ID_AA64ISAR1_EL1, LS64, LS64 +#define FEAT_LS64_V ID_AA64ISAR1_EL1, LS64, LS64_V#define FEAT_LS64_ACCDATA ID_AA64ISAR1_EL1, LS64, LS64_ACCDATA#define FEAT_RAS ID_AA64PFR0_EL1, RAS, IMP#define FEAT_GICv3 ID_AA64PFR0_EL1, GIC, IMP
@@ -90,6 +92,16 @@ struct reg_bits_to_feat_map {#define FEAT_PAN2 ID_AA64MMFR1_EL1, PAN, PAN2#define FEAT_DPB2 ID_AA64ISAR1_EL1, DPB, DPB2#define FEAT_AMUv1 ID_AA64PFR0_EL1, AMU, IMP +#define FEAT_CMOW ID_AA64MMFR1_EL1, CMOW, IMP +#define FEAT_D128 ID_AA64MMFR3_EL1, D128, IMP +#define FEAT_DoubleFault2 ID_AA64PFR1_EL1, DF2, IMP +#define FEAT_FPMR ID_AA64PFR2_EL1, FPMR, IMP +#define FEAT_MOPS ID_AA64ISAR2_EL1, MOPS, IMP +#define FEAT_NMI ID_AA64PFR1_EL1, NMI, IMP +#define FEAT_SCTLR2 ID_AA64MMFR3_EL1, SCTLRX, IMP +#define FEAT_SYSREG128 ID_AA64ISAR2_EL1, SYSREG_128, IMP +#define FEAT_TCR2 ID_AA64MMFR3_EL1, TCRX, IMP +#define FEAT_XS ID_AA64ISAR1_EL1, XS, IMPstatic bool feat_rasv1p1 (struct kvm *kvm) {
@@ -110,6 +122,35 @@ static bool feat_pauth(struct kvm *kvm)return kvm_has_pauth (kvm, PAuth); } +static bool feat_pauth_lr (struct kvm *kvm) +{ +return kvm_has_pauth (kvm, PAuth_LR); +} + +static bool feat_aderr (struct kvm *kvm) +{ +return (kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,ADERR ,FEAT_ADERR ) && +kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,SDERR ,FEAT_ADERR )); +} + +static bool feat_anerr (struct kvm *kvm) +{ +return (kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,ANERR ,FEAT_ANERR ) && +kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,SNERR ,FEAT_ANERR )); +} + +static bool feat_sme_smps (struct kvm *kvm) +{ +/* +* Revists this if KVM ever supports SME -- this really should +* look at the guest's view of SMIDR_EL1. Funnily enough, this +* is not captured in the JSON file, but only as a note in the +* ARM ARM. +*/ +return (kvm_has_feat (kvm,FEAT_SME ) && + (read_sysreg_s (SYS_SMIDR_EL1 ) &SMIDR_EL1_SMPS )); +} +static struct reg_bits_to_feat_map hfgrtr_feat_map[] = { NEEDS_FEAT(HFGxTR_EL2_nAMAIR2_EL1 | HFGxTR_EL2_nMAIR2_EL1,
@@ -494,6 +535,35 @@ static struct reg_bits_to_feat_map hafgrtr_feat_map[] = { FEAT_AMUv1), }; +static struct reg_bits_to_feat_map hcrx_feat_map[] = { +NEEDS_FEAT (HCRX_EL2_PACMEn, feat_pauth_lr), +NEEDS_FEAT (HCRX_EL2_EnFPM,FEAT_FPMR ), +NEEDS_FEAT (HCRX_EL2_GCSEn,FEAT_GCS ), +NEEDS_FEAT (HCRX_EL2_EnIDCP128,FEAT_SYSREG128 ), +NEEDS_FEAT (HCRX_EL2_EnSDERR, feat_aderr), +NEEDS_FEAT (HCRX_EL2_TMEA , FEAT_DoubleFault2), +NEEDS_FEAT (HCRX_EL2_EnSNERR, feat_anerr), +NEEDS_FEAT (HCRX_EL2_D128En,FEAT_D128 ), +NEEDS_FEAT (HCRX_EL2_PTTWI ,FEAT_THE ), +NEEDS_FEAT (HCRX_EL2_SCTLR2En,FEAT_SCTLR2 ), +NEEDS_FEAT (HCRX_EL2_TCR2En,FEAT_TCR2 ), +NEEDS_FEAT (HCRX_EL2_MSCEn | +HCRX_EL2_MCE2 , +FEAT_MOPS ), +NEEDS_FEAT (HCRX_EL2_CMOW ,FEAT_CMOW ), +NEEDS_FEAT (HCRX_EL2_VFNMI | +HCRX_EL2_VINMI | +HCRX_EL2_TALLINT , +FEAT_NMI ), +NEEDS_FEAT (HCRX_EL2_SMPME , feat_sme_smps), +NEEDS_FEAT (HCRX_EL2_FGTnXS | + HCRX_EL2_FnXS, +FEAT_XS ), +NEEDS_FEAT (HCRX_EL2_EnASR,FEAT_LS64_V ), +NEEDS_FEAT (HCRX_EL2_EnALS,FEAT_LS64 ), +NEEDS_FEAT (HCRX_EL2_EnAS0,FEAT_LS64_ACCDATA ), +}; +static void __init check_feat_map (struct reg_bits_to_feat_map *map,int map_size,u64 res0,const char *str) {
@@ -521,6 +591,8 @@ void __init check_feature_map(void) hdfgwtr_masks.res0, hdfgwtr_masks.str);check_feat_map (hafgrtr_feat_map,ARRAY_SIZE (hafgrtr_feat_map), hafgrtr_masks.res0, hafgrtr_masks.str); +check_feat_map (hcrx_feat_map,ARRAY_SIZE (hcrx_feat_map), + __HCRX_EL2_RES0,"HCRX_EL2" ); }static bool idreg_feat_match (struct kvm *kvm,struct reg_bits_to_feat_map *map)
@@ -656,6 +728,12 @@ void get_reg_fixed_bits(struct kvm *kvm, enum vcpu_sysreg reg, u64 *res0, u64 *r *res0 |= hafgrtr_masks.res0; *res1 =HAFGRTR_EL2_RES1 ;break ; +case HCRX_EL2 : + *res0 =compute_res0_bits (kvm, hcrx_feat_map, +ARRAY_SIZE (hcrx_feat_map),0 ,0 ); + *res0 |= __HCRX_EL2_RES0; + *res1 = __HCRX_EL2_RES1; +break ;default :WARN_ON_ONCE (1 ); *res0 = *res1 =0 ;
arch/arm64/kvm/nested.c +1 -39
@@ -1039,45 +1039,7 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu)set_sysreg_masks (kvm,HCR_EL2 , res0, res1);/* HCRX_EL2 */ - res0 = __HCRX_EL2_RES0; - res1 = __HCRX_EL2_RES1; -if (!kvm_has_feat (kvm,ID_AA64ISAR3_EL1 ,PACM ,TRIVIAL_IMP )) - res0 |= HCRX_EL2_PACMEn; -if (!kvm_has_feat (kvm,ID_AA64PFR2_EL1 ,FPMR ,IMP )) - res0 |= HCRX_EL2_EnFPM; -if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,GCS ,IMP )) - res0 |= HCRX_EL2_GCSEn; -if (!kvm_has_feat (kvm,ID_AA64ISAR2_EL1 ,SYSREG_128 ,IMP )) - res0 |= HCRX_EL2_EnIDCP128; -if (!kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,ADERR ,DEV_ASYNC )) - res0 |= (HCRX_EL2_EnSDERR | HCRX_EL2_EnSNERR); -if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,DF2 ,IMP )) - res0 |=HCRX_EL2_TMEA ; -if (!kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,D128 ,IMP )) - res0 |= HCRX_EL2_D128En; -if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,THE ,IMP )) - res0 |=HCRX_EL2_PTTWI ; -if (!kvm_has_feat (kvm,ID_AA64MMFR3_EL1 ,SCTLRX ,IMP )) - res0 |= HCRX_EL2_SCTLR2En; -if (!kvm_has_tcr2 (kvm)) - res0 |= HCRX_EL2_TCR2En; -if (!kvm_has_feat (kvm,ID_AA64ISAR2_EL1 ,MOPS ,IMP )) - res0 |= (HCRX_EL2_MSCEn |HCRX_EL2_MCE2 ); -if (!kvm_has_feat (kvm,ID_AA64MMFR1_EL1 ,CMOW ,IMP )) - res0 |=HCRX_EL2_CMOW ; -if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,NMI ,IMP )) - res0 |= (HCRX_EL2_VFNMI |HCRX_EL2_VINMI |HCRX_EL2_TALLINT ); -if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,SME ,IMP ) || - !(read_sysreg_s (SYS_SMIDR_EL1 ) &SMIDR_EL1_SMPS )) - res0 |=HCRX_EL2_SMPME ; -if (!kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,XS ,IMP )) - res0 |= (HCRX_EL2_FGTnXS | HCRX_EL2_FnXS); -if (!kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64_V )) - res0 |= HCRX_EL2_EnASR; -if (!kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64 )) - res0 |= HCRX_EL2_EnALS; -if (!kvm_has_feat (kvm,ID_AA64ISAR1_EL1 ,LS64 ,LS64_ACCDATA )) - res0 |= HCRX_EL2_EnAS0; +get_reg_fixed_bits (kvm,HCRX_EL2 , &res0, &res1);set_sysreg_masks (kvm,HCRX_EL2 , res0, res1);/* HFG[RW]TR_EL2 */
Signature · 1 line
2.39.2
Marc Zyngier
maintainerPATCH v2 23/23 KVM: arm64: Use HCR_EL2 feature map to drive fixed-value bits
In reply to Marc ZyngierSimilarly to other registers, describe which HCR_EL2 bit depends on which feature, and use this to compute the RES0 status of these bits.
An additional complexity stems from the status of some bits such as E2H and RW, which do not had a RESx status, but still take a fixed value due to implementation choices in KVM.
--- arch/arm64/kvm/config.c | 149 ++++++++++++++++++++++++++++++++++++++++ arch/arm64/kvm/nested.c | 35 +--------- 2 files changed, 150 insertions(+), 34 deletions(-)
arch/arm64/kvm/config.c +149 -0
@@ -69,7 +69,10 @@ struct reg_bits_to_feat_map {#define FEAT_TRBE ID_AA64DFR0_EL1, TraceBuffer, IMP#define FEAT_DoubleLock ID_AA64DFR0_EL1, DoubleLock, IMP#define FEAT_TRF ID_AA64DFR0_EL1, TraceFilt, IMP +#define FEAT_AA32EL0 ID_AA64PFR0_EL1, EL0, AARCH32 +#define FEAT_AA32EL1 ID_AA64PFR0_EL1, EL1, AARCH32#define FEAT_AA64EL1 ID_AA64PFR0_EL1, EL1, IMP +#define FEAT_AA64EL3 ID_AA64PFR0_EL1, EL3, IMP#define FEAT_AIE ID_AA64MMFR3_EL1, AIE, IMP#define FEAT_S2POE ID_AA64MMFR3_EL1, S2POE, IMP#define FEAT_S1POE ID_AA64MMFR3_EL1, S1POE, IMP
@@ -92,6 +95,7 @@ struct reg_bits_to_feat_map {#define FEAT_PAN2 ID_AA64MMFR1_EL1, PAN, PAN2#define FEAT_DPB2 ID_AA64ISAR1_EL1, DPB, DPB2#define FEAT_AMUv1 ID_AA64PFR0_EL1, AMU, IMP +#define FEAT_AMUv1p1 ID_AA64PFR0_EL1, AMU, V1P1#define FEAT_CMOW ID_AA64MMFR1_EL1, CMOW, IMP#define FEAT_D128 ID_AA64MMFR3_EL1, D128, IMP#define FEAT_DoubleFault2 ID_AA64PFR1_EL1, DF2, IMP
@@ -102,6 +106,31 @@ struct reg_bits_to_feat_map {#define FEAT_SYSREG128 ID_AA64ISAR2_EL1, SYSREG_128, IMP#define FEAT_TCR2 ID_AA64MMFR3_EL1, TCRX, IMP#define FEAT_XS ID_AA64ISAR1_EL1, XS, IMP +#define FEAT_EVT ID_AA64MMFR2_EL1, EVT, IMP +#define FEAT_EVT_TTLBxS ID_AA64MMFR2_EL1, EVT, TTLBxS +#define FEAT_MTE2 ID_AA64PFR1_EL1, MTE, MTE2 +#define FEAT_RME ID_AA64PFR0_EL1, RME, IMP +#define FEAT_S2FWB ID_AA64MMFR2_EL1, FWB, IMP +#define FEAT_TME ID_AA64ISAR0_EL1, TME, IMP +#define FEAT_TWED ID_AA64MMFR1_EL1, TWED, IMP +#define FEAT_E2H0 ID_AA64MMFR4_EL1, E2H0, IMP + +static bool not_feat_aa64el3 (struct kvm *kvm) +{ +return !kvm_has_feat (kvm,FEAT_AA64EL3 ); +} + +static bool feat_nv2 (struct kvm *kvm) +{ +return ((kvm_has_feat (kvm,ID_AA64MMFR4_EL1 , NV_frac,NV2_ONLY ) && +kvm_has_feat_enum (kvm,ID_AA64MMFR2_EL1 ,NV ,NI )) || +kvm_has_feat (kvm,ID_AA64MMFR2_EL1 ,NV ,NV2 )); +} + +static bool feat_nv2_e2h0_ni (struct kvm *kvm) +{ +return feat_nv2 (kvm) && !kvm_has_feat (kvm,FEAT_E2H0 ); +}static bool feat_rasv1p1 (struct kvm *kvm) {
@@ -151,6 +180,31 @@ static bool feat_sme_smps(struct kvm *kvm) (read_sysreg_s(SYS_SMIDR_EL1) & SMIDR_EL1_SMPS)); } +static bool compute_hcr_rw (struct kvm *kvm,u64 *bits) +{ +/* This is purely academic: AArch32 and NV are mutually exclusive */ +if (bits) { +if (kvm_has_feat (kvm,FEAT_AA32EL1 )) + *bits &= ~HCR_EL2_RW ; +else + *bits |=HCR_EL2_RW ; + } + +return true; +} + +static bool compute_hcr_e2h (struct kvm *kvm,u64 *bits) +{ +if (bits) { +if (kvm_has_feat (kvm,FEAT_E2H0 )) + *bits &= ~HCR_EL2_E2H ; +else + *bits |=HCR_EL2_E2H ; + } + +return true; +} +static struct reg_bits_to_feat_map hfgrtr_feat_map[] = { NEEDS_FEAT(HFGxTR_EL2_nAMAIR2_EL1 | HFGxTR_EL2_nMAIR2_EL1,
@@ -564,6 +618,77 @@ static struct reg_bits_to_feat_map hcrx_feat_map[] = { NEEDS_FEAT(HCRX_EL2_EnAS0, FEAT_LS64_ACCDATA), }; +static struct reg_bits_to_feat_map hcr_feat_map[] = { +NEEDS_FEAT (HCR_EL2_TID0 ,FEAT_AA32EL0 ), +NEEDS_FEAT_FIXED (HCR_EL2_RW , compute_hcr_rw), +NEEDS_FEAT (HCR_EL2_HCD , not_feat_aa64el3), +NEEDS_FEAT (HCR_EL2_AMO | +HCR_EL2_BSU | +HCR_EL2_CD | +HCR_EL2_DC | +HCR_EL2_FB | +HCR_EL2_FMO | +HCR_EL2_ID | +HCR_EL2_IMO | +HCR_EL2_MIOCNCE | +HCR_EL2_PTW | +HCR_EL2_SWIO | +HCR_EL2_TACR | +HCR_EL2_TDZ | +HCR_EL2_TGE | +HCR_EL2_TID1 | +HCR_EL2_TID2 | +HCR_EL2_TID3 | +HCR_EL2_TIDCP | +HCR_EL2_TPCP | +HCR_EL2_TPU | +HCR_EL2_TRVM | +HCR_EL2_TSC | +HCR_EL2_TSW | +HCR_EL2_TTLB | +HCR_EL2_TVM | +HCR_EL2_TWE | +HCR_EL2_TWI | +HCR_EL2_VF | +HCR_EL2_VI | +HCR_EL2_VM | +HCR_EL2_VSE , +FEAT_AA64EL1 ), +NEEDS_FEAT (HCR_EL2_AMVOFFEN , FEAT_AMUv1p1), +NEEDS_FEAT (HCR_EL2_EnSCXT, feat_csv2_2_csv2_1p2), +NEEDS_FEAT (HCR_EL2_TICAB | +HCR_EL2_TID4 | +HCR_EL2_TOCU , +FEAT_EVT ), +NEEDS_FEAT (HCR_EL2_TTLBIS | +HCR_EL2_TTLBOS , + FEAT_EVT_TTLBxS), +NEEDS_FEAT (HCR_EL2_TLOR ,FEAT_LOR ), +NEEDS_FEAT (HCR_EL2_ATA | +HCR_EL2_DCT | +HCR_EL2_TID5 , +FEAT_MTE2 ), +NEEDS_FEAT (HCR_EL2_AT |/* Ignore the original FEAT_NV */ +HCR_EL2_NV2 | +HCR_EL2_NV , + feat_nv2), +NEEDS_FEAT (HCR_EL2_NV1 , feat_nv2_e2h0_ni),/* Missing from JSON */ +NEEDS_FEAT (HCR_EL2_API | +HCR_EL2_APK , + feat_pauth), +NEEDS_FEAT (HCR_EL2_TEA | +HCR_EL2_TERR , +FEAT_RAS ), +NEEDS_FEAT (HCR_EL2_FIEN , feat_rasv1p1), +NEEDS_FEAT (HCR_EL2_GPF ,FEAT_RME ), +NEEDS_FEAT (HCR_EL2_FWB ,FEAT_S2FWB ), +NEEDS_FEAT (HCR_EL2_TME ,FEAT_TME ), +NEEDS_FEAT (HCR_EL2_TWEDEL | + HCR_EL2_TWEDEn, +FEAT_TWED ), +NEEDS_FEAT_FIXED (HCR_EL2_E2H , compute_hcr_e2h), +}; +static void __init check_feat_map (struct reg_bits_to_feat_map *map,int map_size,u64 res0,const char *str) {
@@ -593,6 +718,8 @@ void __init check_feature_map(void) hafgrtr_masks.res0, hafgrtr_masks.str);check_feat_map (hcrx_feat_map,ARRAY_SIZE (hcrx_feat_map), __HCRX_EL2_RES0,"HCRX_EL2" ); +check_feat_map (hcr_feat_map,ARRAY_SIZE (hcr_feat_map), +HCR_EL2_RES0 ,"HCR_EL2" ); }static bool idreg_feat_match (struct kvm *kvm,struct reg_bits_to_feat_map *map)
@@ -651,6 +778,17 @@ static u64 compute_res0_bits(struct kvm *kvm, require, exclude | FIXED_VALUE); } +static u64 compute_fixed_bits (struct kvm *kvm, +struct reg_bits_to_feat_map *map, +int map_size, +u64 *fixed_bits, +unsigned long require, +unsigned long exclude) +{ +return __compute_fixed_bits (kvm, map, map_size, fixed_bits, + require |FIXED_VALUE , exclude); +} +void compute_fgu (struct kvm *kvm,enum fgt_group_id fgt) {u64 val =0 ;
@@ -691,6 +829,8 @@ void compute_fgu(struct kvm *kvm, enum fgt_group_id fgt)void get_reg_fixed_bits (struct kvm *kvm,enum vcpu_sysreg reg,u64 *res0,u64 *res1) { +u64 fixed =0 , mask; +switch (reg) {case HFGRTR_EL2 : *res0 = compute_res0_bits(kvm, hfgrtr_feat_map,
@@ -734,6 +874,15 @@ void get_reg_fixed_bits(struct kvm *kvm, enum vcpu_sysreg reg, u64 *res0, u64 *r *res0 |= __HCRX_EL2_RES0; *res1 = __HCRX_EL2_RES1;break ; +case HCR_EL2 : + mask =compute_fixed_bits (kvm, hcr_feat_map, +ARRAY_SIZE (hcr_feat_map), &fixed, +0 ,0 ); + *res0 =compute_res0_bits (kvm, hcr_feat_map, +ARRAY_SIZE (hcr_feat_map),0 ,0 ); + *res0 |=HCR_EL2_RES0 | (mask & ~fixed); + *res1 =HCR_EL2_RES1 | (mask & fixed); +break ;default :WARN_ON_ONCE (1 ); *res0 = *res1 =0 ;
arch/arm64/kvm/nested.c +1 -34
@@ -1002,40 +1002,7 @@ int kvm_init_nv_sysregs(struct kvm_vcpu *vcpu)set_sysreg_masks (kvm,VMPIDR_EL2 , res0, res1);/* HCR_EL2 */ - res0 =BIT (48 ); - res1 =HCR_RW ; -if (!kvm_has_feat (kvm,ID_AA64MMFR1_EL1 ,TWED ,IMP )) - res0 |=GENMASK (63 ,59 ); -if (!kvm_has_feat (kvm,ID_AA64PFR1_EL1 ,MTE ,MTE2 )) - res0 |= (HCR_TID5 |HCR_DCT |HCR_ATA ); -if (!kvm_has_feat (kvm,ID_AA64MMFR2_EL1 ,EVT , TTLBxS)) - res0 |= (HCR_TTLBIS |HCR_TTLBOS ); -if (!kvm_has_feat (kvm,ID_AA64PFR0_EL1 ,CSV2 ,CSV2_2 ) && - !kvm_has_feat (kvm,ID_AA64PFR1_EL1 , CSV2_frac, CSV2_1p2)) - res0 |=HCR_ENSCXT ; -if (!kvm_has_feat (kvm,ID_AA64MMFR2_EL1 ,EVT ,IMP )) - res0 |= (HCR_TOCU |HCR_TICAB |HCR_TID4 ); -if (!kvm_has_feat (kvm,ID_AA64PFR0_EL1 ,AMU ,V1P1 )) - res0 |=HCR_AMVOFFEN ; -if (!kvm_has_feat (kvm,ID_AA64PFR0_EL1 ,RAS ,V1P1 )) - res0 |=HCR_FIEN ; -if (!kvm_has_feat (kvm,ID_AA64MMFR2_EL1 ,FWB ,IMP )) - res0 |=HCR_FWB ; -if (!kvm_has_feat (kvm,ID_AA64MMFR2_EL1 ,NV ,NV2 )) - res0 |=HCR_NV2 ; -if (!kvm_has_feat (kvm,ID_AA64MMFR2_EL1 ,NV ,IMP )) - res0 |= (HCR_AT |HCR_NV1 |HCR_NV ); -if (!(kvm_vcpu_has_feature (kvm,KVM_ARM_VCPU_PTRAUTH_ADDRESS ) && -kvm_vcpu_has_feature (kvm,KVM_ARM_VCPU_PTRAUTH_GENERIC ))) - res0 |= (HCR_API |HCR_APK ); -if (!kvm_has_feat (kvm,ID_AA64ISAR0_EL1 ,TME ,IMP )) - res0 |=BIT (39 ); -if (!kvm_has_feat (kvm,ID_AA64PFR0_EL1 ,RAS ,IMP )) - res0 |= (HCR_TEA |HCR_TERR ); -if (!kvm_has_feat (kvm,ID_AA64MMFR1_EL1 ,LO ,IMP )) - res0 |=HCR_TLOR ; -if (!kvm_has_feat (kvm,ID_AA64MMFR4_EL1 ,E2H0 ,IMP )) - res1 |=HCR_E2H ; +get_reg_fixed_bits (kvm,HCR_EL2 , &res0, &res1);set_sysreg_masks (kvm,HCR_EL2 , res0, res1);/* HCRX_EL2 */
Signature · 1 line
2.39.2