ARM Secure EL2 extension
v2 cover ARM Secure EL2 extension
The following changes since commit 193f51ddcf1d87d725f1dfd51b8a95351c910e8f:
Merge remote-tracking branch 'remotes/philmd-gitlab/tags/mips-fixes-20201109' into staging (2020-11-09 10:10:49 +0000)
are available for review.
Changes since version 1:
- Add the first patch which was accidentally dropped.
- Try to address comments from Peter and Richard.
----------------------------------------------------------------
Rémi Denis-Courmont (17):
target/arm: remove redundant tests
target/arm: add arm_is_el2_enabled() helper target/arm: use arm_is_el2_enabled() where applicable target/arm: use arm_hcr_el2_eff() where applicable target/arm: factor MDCR_EL2 common handling target/arm: declare new AA64PFR0 bit-fields target/arm: add 64-bit S-EL2 to EL exception table target/arm: return the stage 2 index for stage 1 target/arm: add MMU stage 1 for Secure EL2 target/arm: add ARMv8.4-SEL2 system registers target/arm: do S1_ptw_translate() before address space lookup target/arm: secure stage 2 translation regime target/arm: handle VMID change in secure state target/arm: set HPFAR_EL2.NS on secure stage 2 faults target/arm: add ARMv8.4-SEL2 extension
target/arm: enable Secure EL2 in max CPU target/arm: refactor vae1_tlbmask()
target/arm/cpu-param.h | 2 +- target/arm/cpu.c | 10 +- target/arm/cpu.h | 92 ++++++++-- target/arm/cpu64.c | 1 + target/arm/helper-a64.c | 8 +- target/arm/helper.c | 421 ++++++++++++++++++++++++++++++--------------- target/arm/internals.h | 54 +++++- target/arm/op_helper.c | 4 +- target/arm/tlb_helper.c | 3 + target/arm/translate-a64.c | 4 + target/arm/translate.c | 6 +- target/arm/translate.h | 1 + 12 files changed, 426 insertions(+), 180 deletions(-)
Signature · 2 lines
Rémi Denis-Courmont http://www.remlab.net/
PATCH v2 1/17 target/arm: remove redundant tests
From: Rémi Denis-Courmont <[email protected]>
In this context, the HCR value is the effective value, and thus is zero in secure mode. The tests for HCR.{F,I}MO are sufficient.
--- target/arm/cpu.c | 8 ++++---- target/arm/helper.c | 10 ++++------ 2 files changed, 8 insertions(+), 10 deletions(-)
target/arm/cpu.c +4 -4
@@ -447,14 +447,14 @@ static inline bool arm_excp_unmasked(CPUState *cs, unsigned int excp_idx,break ;case EXCP_VFIQ : -if (secure || !(hcr_el2 &HCR_FMO ) || (hcr_el2 &HCR_TGE )) { -/* VFIQs are only taken when hypervized and non-secure. */ +if (!(hcr_el2 &HCR_FMO ) || (hcr_el2 &HCR_TGE )) { +/* VFIQs are only taken when hypervized. */ return false; }return !(env->daif &PSTATE_F );case EXCP_VIRQ : -if (secure || !(hcr_el2 &HCR_IMO ) || (hcr_el2 &HCR_TGE )) { -/* VIRQs are only taken when hypervized and non-secure. */ +if (!(hcr_el2 &HCR_IMO ) || (hcr_el2 &HCR_TGE )) { +/* VIRQs are only taken when hypervized. */ return false; }return !(env->daif &PSTATE_I );
target/arm/helper.c +4 -6
@@ -2083,13 +2083,11 @@ static void csselr_write(CPUARMState *env, const ARMCPRegInfo *ri,static uint64_t isr_read (CPUARMState *env,const ARMCPRegInfo *ri) {CPUState *cs =env_cpu (env); -uint64_t hcr_el2 =arm_hcr_el2_eff (env); +bool el1 =arm_current_el (env) ==1 ; +uint64_t hcr_el2 = el1 ?arm_hcr_el2_eff (env) :0 ;uint64_t ret =0 ; -bool allow_virt = (arm_current_el (env) ==1 && - (!arm_is_secure_below_el3 (env) || - (env->cp15.scr_el3 &SCR_EEL2 ))); -if (allow_virt && (hcr_el2 &HCR_IMO )) { +if (hcr_el2 &HCR_IMO ) {if (cs->interrupt_request &CPU_INTERRUPT_VIRQ ) { ret |=CPSR_I ; }
@@ -2099,7 +2097,7 @@ static uint64_t isr_read(CPUARMState *env, const ARMCPRegInfo *ri) } } -if (allow_virt && (hcr_el2 &HCR_FMO )) { +if (hcr_el2 &HCR_FMO ) {if (cs->interrupt_request &CPU_INTERRUPT_VFIQ ) { ret |=CPSR_F ; }
Signature · 1 line
2.29.2
Re: [PATCH 01/17] target/arm: remove redundant tests
Quoted 10 lines · On 11/9/20 6:10 AM, [email protected] wrote:
From: Rémi Denis-Courmont <[email protected]>
In this context, the HCR value is the effective value, and thus is zero in secure mode. The tests for HCR.{F,I}MO are sufficient.
Signed-off-by Rémi Denis-Courmont <[email protected]>--- target/arm/cpu.c | 8 ++++---- target/arm/helper.c | 10 ++++------ 2 files changed, 8 insertions(+), 10 deletions(-)
r~
PATCH v2 2/17 target/arm: add arm_is_el2_enabled() helper
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
This checks if EL2 is enabled (meaning EL2 registers take effects) in the current security context.
--- target/arm/cpu.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
target/arm/cpu.h +16 -0
@@ -2040,6 +2040,17 @@ static inline bool arm_is_secure(CPUARMState *env) return arm_is_secure_below_el3(env); } +/* Return true if the current security state has AArch64 EL2 or AArch32 Hyp. +* This corresponds to the pseudocode EL2Enabled() +*/ +static inline bool arm_is_el2_enabled (CPUARMState *env) +{ +if (arm_feature (env,ARM_FEATURE_EL2 )) { +return !arm_is_secure_below_el3 (env); + } +return false; +} +#else static inline bool arm_is_secure_below_el3 (CPUARMState *env) {
@@ -2050,6 +2061,11 @@ static inline bool arm_is_secure(CPUARMState *env) {return false; } + +static inline bool arm_is_el2_enabled (CPUARMState *env) +{ +return false; +}#endif /**
Signature · 1 line
2.29.2
Re: [PATCH 02/17] target/arm: add arm_is_el2_enabled() helper
Quoted 9 lines · On 11/9/20 6:10 AM, [email protected] wrote:
From: Rémi Denis-Courmont <[email protected]>
This checks if EL2 is enabled (meaning EL2 registers take effects) in the current security context.
Signed-off-by Rémi Denis-Courmont <[email protected]>--- target/arm/cpu.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
r~
PATCH v2 3/17 target/arm: use arm_is_el2_enabled() where applicable
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
Do not assume that EL2 is available in non-secure context. That equivalence is broken by ARMv8.4-SEL2.
--- target/arm/cpu.h | 4 ++-- target/arm/helper-a64.c | 8 +------- target/arm/helper.c | 33 +++++++++++++-------------------- 3 files changed, 16 insertions(+), 29 deletions(-)
target/arm/cpu.h +2 -2
@@ -2101,7 +2101,7 @@ static inline bool arm_el_is_aa64(CPUARMState *env, int el)return aa64; } -if (arm_feature (env,ARM_FEATURE_EL2 ) && !arm_is_secure_below_el3 (env)) { +if (arm_is_el2_enabled (env)) { aa64 = aa64 && (env->cp15.hcr_el2 &HCR_RW ); }
@@ -3045,7 +3045,7 @@ static inline int arm_debug_target_el(CPUARMState *env)bool secure =arm_is_secure (env);bool route_to_el2 = false; -if (arm_feature (env,ARM_FEATURE_EL2 ) && !secure) { +if (arm_is_el2_enabled (env)) { route_to_el2 = env->cp15.hcr_el2 &HCR_TGE || env->cp15.mdcr_el2 &MDCR_TDE ; }
target/arm/helper-a64.c +1 -7
@@ -972,8 +972,7 @@ void HELPER(exception_return)(CPUARMState *env, uint64_t new_pc)if (new_el ==-1 ) { goto illegal_return; } -if (new_el > cur_el - || (new_el ==2 && !arm_feature (env,ARM_FEATURE_EL2 ))) { +if (new_el > cur_el || (new_el ==2 && !arm_is_el2_enabled (env))) {/* Disallow return to an EL which is unimplemented or higher * than the current one. */
@@ -985,11 +984,6 @@ void HELPER(exception_return)(CPUARMState *env, uint64_t new_pc) goto illegal_return; } -if (new_el ==2 &&arm_is_secure_below_el3 (env)) { -/* Return to the non-existent secure-EL2 */ - goto illegal_return; - } -if (new_el ==1 && (arm_hcr_el2_eff (env) &HCR_TGE )) { goto illegal_return; }
target/arm/helper.c +13 -20
@@ -1048,8 +1048,8 @@ static CPAccessResult cpacr_access(CPUARMState *env, const ARMCPRegInfo *ri, {if (arm_feature (env,ARM_FEATURE_V8 )) {/* Check if CPACR accesses are to be trapped to EL2 */ -if (arm_current_el (env) ==1 && - (env->cp15.cptr_el[2 ] &CPTR_TCPAC ) && !arm_is_secure (env)) { +if (arm_current_el (env) ==1 &&arm_is_el2_enabled (env) && + (env->cp15.cptr_el[2 ] &CPTR_TCPAC )) {return CP_ACCESS_TRAP_EL2 ;/* Check if CPACR accesses are to be trapped to EL3 */ } else if (arm_current_el(env) < 3 &&
@@ -2519,7 +2519,7 @@ static CPAccessResult gt_counter_access(CPUARMState *env, int timeridx, bool isread) {unsigned int cur_el =arm_current_el (env); -bool secure =arm_is_secure (env); +bool has_el2 =arm_is_el2_enabled (env);uint64_t hcr =arm_hcr_el2_eff (env);switch (cur_el) {
@@ -2543,8 +2543,7 @@ static CPAccessResult gt_counter_access(CPUARMState *env, int timeridx, } }else {/* If HCR_EL2.<E2H> == 0: check CNTHCTL_EL2.EL1PCEN. */ -if (arm_feature (env,ARM_FEATURE_EL2 ) && - timeridx ==GTIMER_PHYS && !secure && +if (has_el2 && timeridx ==GTIMER_PHYS && !extract32 (env->cp15.cnthctl_el2,1 ,1 )) {return CP_ACCESS_TRAP_EL2 ; }
@@ -2553,8 +2552,7 @@ static CPAccessResult gt_counter_access(CPUARMState *env, int timeridx,case 1 :/* Check CNTHCTL_EL2.EL1PCTEN, which changes location based on E2H. */ -if (arm_feature (env,ARM_FEATURE_EL2 ) && - timeridx ==GTIMER_PHYS && !secure && +if (has_el2 && timeridx ==GTIMER_PHYS && (hcr &HCR_E2H ? !extract32 (env->cp15.cnthctl_el2,10 ,1 ) : !extract32 (env->cp15.cnthctl_el2,0 ,1 ))) {
@@ -2569,7 +2567,7 @@ static CPAccessResult gt_timer_access(CPUARMState *env, int timeridx, bool isread) {unsigned int cur_el =arm_current_el (env); -bool secure =arm_is_secure (env); +bool has_el2 =arm_is_el2_enabled (env);uint64_t hcr =arm_hcr_el2_eff (env);switch (cur_el) {
@@ -2590,8 +2588,7 @@ static CPAccessResult gt_timer_access(CPUARMState *env, int timeridx,/* fall through */ case 1 : -if (arm_feature (env,ARM_FEATURE_EL2 ) && - timeridx ==GTIMER_PHYS && !secure) { +if (has_el2 && timeridx ==GTIMER_PHYS ) {if (hcr &HCR_E2H ) {/* If HCR_EL2.<E2H,TGE> == '10': check CNTHCTL_EL2.EL1PTEN. */ if (!extract32 (env->cp15.cnthctl_el2,11 ,1 )) {
@@ -4247,11 +4244,9 @@ static const ARMCPRegInfo strongarm_cp_reginfo[] = {static uint64_t midr_read (CPUARMState *env,const ARMCPRegInfo *ri) { -ARMCPU *cpu =env_archcpu (env);unsigned int cur_el =arm_current_el (env); -bool secure =arm_is_secure (env); -if (arm_feature (&cpu->env,ARM_FEATURE_EL2 ) && !secure && cur_el ==1 ) { +if (arm_is_el2_enabled (env) && cur_el ==1 ) {return env->cp15.vpidr_el2; }return raw_read (env, ri);
@@ -4278,9 +4273,8 @@ static uint64_t mpidr_read_val(CPUARMState *env)static uint64_t mpidr_read (CPUARMState *env,const ARMCPRegInfo *ri) {unsigned int cur_el =arm_current_el (env); -bool secure =arm_is_secure (env); -if (arm_feature (env,ARM_FEATURE_EL2 ) && !secure && cur_el ==1 ) { +if (arm_is_el2_enabled (env) && cur_el ==1 ) {return env->cp15.vmpidr_el2; }return mpidr_read_val (env);
@@ -5347,7 +5341,7 @@ uint64_t arm_hcr_el2_eff(CPUARMState *env) {uint64_t ret = env->cp15.hcr_el2; -if (arm_is_secure_below_el3 (env)) { +if (!arm_is_el2_enabled (env)) {/* * "This register has no effect if EL2 is not enabled in the * current Security state". This is ARMv8.4-SecEL2 speak for
@@ -6144,7 +6138,7 @@ int sve_exception_el(CPUARMState *env, int el)/* CPTR_EL2. Since TZ and TFP are positive, * they will be zero when EL2 is not present. */ -if (el <=2 && !arm_is_secure_below_el3 (env)) { +if (el <=2 &&arm_is_el2_enabled (env)) {if (env->cp15.cptr_el[2 ] &CPTR_TZ ) {return 2 ; }
@@ -8723,8 +8717,7 @@ static int bad_mode_switch(CPUARMState *env, int mode, CPSRWriteType write_type) }return 0 ;case ARM_CPU_MODE_HYP : -return !arm_feature (env,ARM_FEATURE_EL2 ) - ||arm_current_el (env) <2 ||arm_is_secure_below_el3 (env); +return !arm_is_el2_enabled (env) ||arm_current_el (env) <2 ;case ARM_CPU_MODE_MON :return arm_current_el (env) <3 ;default :
@@ -12634,7 +12627,7 @@ int fp_exception_el(CPUARMState *env, int cur_el)/* CPTR_EL2 : present in v7VE or v8 */ if (cur_el <=2 &&extract32 (env->cp15.cptr_el[2 ],10 ,1 ) - && !arm_is_secure_below_el3 (env)) { + &&arm_is_el2_enabled (env)) {/* Trap FP ops at EL2, NS-EL1 or NS-EL0 to EL2 */ return 2 ; }
Signature · 1 line
2.29.2
PATCH v2 4/17 target/arm: use arm_hcr_el2_eff() where applicable
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
This will simplify accessing HCR conditionally in secure state.
--- target/arm/helper.c | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-)
target/arm/helper.c +17 -13
@@ -4432,16 +4432,16 @@ static CPAccessResult aa64_cacheop_pou_access(CPUARMState *env,static int vae1_tlbmask (CPUARMState *env) { -/* Since we exclude secure first, we may read HCR_EL2 directly. */ -if (arm_is_secure_below_el3 (env)) { -return ARMMMUIdxBit_SE10_1 | - ARMMMUIdxBit_SE10_1_PAN | - ARMMMUIdxBit_SE10_0; - }else if ((env->cp15.hcr_el2 & (HCR_E2H |HCR_TGE )) - == (HCR_E2H |HCR_TGE )) { +uint64_t hcr =arm_hcr_el2_eff (env); + +if ((hcr & (HCR_E2H |HCR_TGE )) == (HCR_E2H |HCR_TGE )) {return ARMMMUIdxBit_E20_2 | ARMMMUIdxBit_E20_2_PAN | ARMMMUIdxBit_E20_0; + }else if (arm_is_secure_below_el3 (env)) { +return ARMMMUIdxBit_SE10_1 | + ARMMMUIdxBit_SE10_1_PAN | + ARMMMUIdxBit_SE10_0; }else {return ARMMMUIdxBit_E10_1 | ARMMMUIdxBit_E10_1_PAN |
@@ -9968,6 +9968,8 @@ static inline uint64_t regime_sctlr(CPUARMState *env, ARMMMUIdx mmu_idx)static inline bool regime_translation_disabled (CPUARMState *env,ARMMMUIdx mmu_idx) { +uint64_t hcr_el2; +if (arm_feature (env,ARM_FEATURE_M )) {switch (env->v7m.mpu_ctrl[regime_is_secure (env, mmu_idx)] & (R_V7M_MPU_CTRL_ENABLE_MASK |R_V7M_MPU_CTRL_HFNMIENA_MASK )) {
@@ -9986,19 +9988,21 @@ static inline bool regime_translation_disabled(CPUARMState *env, } } + hcr_el2 =arm_hcr_el2_eff (env); +if (mmu_idx == ARMMMUIdx_Stage2) {/* HCR.DC means HCR.VM behaves as 1 */ -return (env->cp15.hcr_el2 & (HCR_DC |HCR_VM )) ==0 ; +return (hcr_el2 & (HCR_DC |HCR_VM )) ==0 ; } -if (env->cp15.hcr_el2 &HCR_TGE ) { +if (hcr_el2 &HCR_TGE ) {/* TGE means that NS EL0/1 act as if SCTLR_EL1.M is zero */ if (!regime_is_secure (env, mmu_idx) &®ime_el (env, mmu_idx) ==1 ) {return true; } } -if ((env->cp15.hcr_el2 &HCR_DC ) &&arm_mmu_idx_is_stage1_of_2 (mmu_idx)) { +if ((hcr_el2 &HCR_DC ) &&arm_mmu_idx_is_stage1_of_2 (mmu_idx)) {/* HCR.DC means SCTLR_EL1.M behaves as 0 */ return true; }
@@ -10349,7 +10353,7 @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx, fi->s1ptw = true;return ~0 ; } -if ((env->cp15.hcr_el2 &HCR_PTW ) && (cacheattrs.attrs &0xf0 ) ==0 ) { +if ((arm_hcr_el2_eff (env) &HCR_PTW ) && (cacheattrs.attrs &0xf0 ) ==0 ) {/* * PTW set and S1 walk touched S2 Device memory: * generate Permission fault.
@@ -10782,7 +10786,7 @@ static uint8_t convert_stage2_attrs(CPUARMState *env, uint8_t s2attrs)uint8_t hihint =0 , lohint =0 ;if (hiattr !=0 ) {/* normal memory */ -if ((env->cp15.hcr_el2 &HCR_CD ) !=0 ) {/* cache disabled */ +if (arm_hcr_el2_eff (env) &HCR_CD ) {/* cache disabled */ hiattr = loattr =1 ;/* non-cacheable */ }else {if (hiattr !=1 ) {/* Write-through or write-back */
@@ -12099,7 +12103,7 @@ bool get_phys_addr(CPUARMState *env, target_ulong address, }/* Combine the S1 and S2 cache attributes. */ -if (env->cp15.hcr_el2 &HCR_DC ) { +if (arm_hcr_el2_eff (env) &HCR_DC ) {/* * HCR.DC forces the first stage attributes to * Normal Non-Shareable,
Signature · 1 line
2.29.2
PATCH v2 5/17 target/arm: factor MDCR_EL2 common handling
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
This adds a common helper to compute the effective value of MDCR_EL2. That is the actual value if EL2 is enabled in the current security context, or 0 elsewise.
--- target/arm/helper.c | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-)
target/arm/helper.c +22 -16
@@ -538,6 +538,11 @@ static CPAccessResult access_trap_aa32s_el1(CPUARMState *env,return CP_ACCESS_TRAP_UNCATEGORIZED ; } +static uint64_t arm_mdcr_el2_eff (CPUARMState *env) +{ +return arm_is_el2_enabled (env) ? env->cp15.mdcr_el2 :0 ; +} +/* Check for traps to "powerdown debug" registers, which are controlled * by MDCR.TDOSA */
@@ -545,11 +550,11 @@ static CPAccessResult access_tdosa(CPUARMState *env, const ARMCPRegInfo *ri, bool isread) {int el =arm_current_el (env); -bool mdcr_el2_tdosa = (env->cp15.mdcr_el2 &MDCR_TDOSA ) || - (env->cp15.mdcr_el2 &MDCR_TDE ) || +uint64_t mdcr_el2 =arm_mdcr_el2_eff (env); +bool mdcr_el2_tdosa = (mdcr_el2 &MDCR_TDOSA ) || (mdcr_el2 &MDCR_TDE ) || (arm_hcr_el2_eff (env) &HCR_TGE ); -if (el <2 && mdcr_el2_tdosa && !arm_is_secure_below_el3 (env)) { +if (el <2 && mdcr_el2_tdosa) {return CP_ACCESS_TRAP_EL2 ; }if (el <3 && (env->cp15.mdcr_el3 &MDCR_TDOSA )) {
@@ -565,11 +570,11 @@ static CPAccessResult access_tdra(CPUARMState *env, const ARMCPRegInfo *ri, bool isread) {int el =arm_current_el (env); -bool mdcr_el2_tdra = (env->cp15.mdcr_el2 &MDCR_TDRA ) || - (env->cp15.mdcr_el2 &MDCR_TDE ) || +uint64_t mdcr_el2 =arm_mdcr_el2_eff (env); +bool mdcr_el2_tdra = (mdcr_el2 &MDCR_TDRA ) || (mdcr_el2 &MDCR_TDE ) || (arm_hcr_el2_eff (env) &HCR_TGE ); -if (el <2 && mdcr_el2_tdra && !arm_is_secure_below_el3 (env)) { +if (el <2 && mdcr_el2_tdra) {return CP_ACCESS_TRAP_EL2 ; }if (el <3 && (env->cp15.mdcr_el3 &MDCR_TDA )) {
@@ -585,11 +590,11 @@ static CPAccessResult access_tda(CPUARMState *env, const ARMCPRegInfo *ri, bool isread) {int el =arm_current_el (env); -bool mdcr_el2_tda = (env->cp15.mdcr_el2 &MDCR_TDA ) || - (env->cp15.mdcr_el2 &MDCR_TDE ) || +uint64_t mdcr_el2 =arm_mdcr_el2_eff (env); +bool mdcr_el2_tda = (mdcr_el2 &MDCR_TDA ) || (mdcr_el2 &MDCR_TDE ) || (arm_hcr_el2_eff (env) &HCR_TGE ); -if (el <2 && mdcr_el2_tda && !arm_is_secure_below_el3 (env)) { +if (el <2 && mdcr_el2_tda) {return CP_ACCESS_TRAP_EL2 ; }if (el <3 && (env->cp15.mdcr_el3 &MDCR_TDA )) {
@@ -605,9 +610,9 @@ static CPAccessResult access_tpm(CPUARMState *env, const ARMCPRegInfo *ri, bool isread) {int el =arm_current_el (env); +uint64_t mdcr_el2 =arm_mdcr_el2_eff (env); -if (el <2 && (env->cp15.mdcr_el2 &MDCR_TPM ) - && !arm_is_secure_below_el3 (env)) { +if (el <2 && (mdcr_el2 &MDCR_TPM )) {return CP_ACCESS_TRAP_EL2 ; }if (el <3 && (env->cp15.mdcr_el3 &MDCR_TPM )) {
@@ -1347,12 +1352,12 @@ static CPAccessResult pmreg_access(CPUARMState *env, const ARMCPRegInfo *ri,* trapping to EL2 or EL3 for other accesses. */ int el =arm_current_el (env); +uint64_t mdcr_el2 =arm_mdcr_el2_eff (env);if (el ==0 && !(env->cp15.c9_pmuserenr &1 )) {return CP_ACCESS_TRAP ; } -if (el <2 && (env->cp15.mdcr_el2 &MDCR_TPM ) - && !arm_is_secure_below_el3 (env)) { +if (el <2 && (mdcr_el2 &MDCR_TPM )) {return CP_ACCESS_TRAP_EL2 ; }if (el <3 && (env->cp15.mdcr_el3 &MDCR_TPM )) {
@@ -1431,7 +1436,8 @@ static bool pmu_counter_enabled(CPUARMState *env, uint8_t counter)bool enabled, prohibited, filtered;bool secure =arm_is_secure (env);int el =arm_current_el (env); -uint8_t hpmn = env->cp15.mdcr_el2 &MDCR_HPMN ; +uint64_t mdcr_el2 =arm_mdcr_el2_eff (env); +uint8_t hpmn = mdcr_el2 &MDCR_HPMN ;if (!arm_feature (env,ARM_FEATURE_PMU )) {return false;
@@ -1441,13 +1447,13 @@ static bool pmu_counter_enabled(CPUARMState *env, uint8_t counter) (counter < hpmn || counter == 31)) { e = env->cp15.c9_pmcr & PMCRE; } else { - e = env->cp15.mdcr_el2 &MDCR_HPME ; + e = mdcr_el2 &MDCR_HPME ; } enabled = e && (env->cp15.c9_pmcnten & (1 << counter));if (!secure) {if (el ==2 && (counter < hpmn || counter ==31 )) { - prohibited = env->cp15.mdcr_el2 &MDCR_HPMD ; + prohibited = mdcr_el2 &MDCR_HPMD ; }else { prohibited = false; }
Signature · 1 line
2.29.2
PATCH v2 6/17 target/arm: declare new AA64PFR0 bit-fields
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
--- target/arm/cpu.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
target/arm/cpu.h +11 -0
@@ -1849,6 +1849,12 @@ FIELD(ID_AA64PFR0, ADVSIMD, 20, 4) FIELD(ID_AA64PFR0, GIC, 24, 4) FIELD(ID_AA64PFR0, RAS, 28, 4) FIELD(ID_AA64PFR0, SVE, 32, 4) +FIELD(ID_AA64PFR0, SEL2, 36, 4) +FIELD(ID_AA64PFR0, MPAM, 40, 4) +FIELD(ID_AA64PFR0, AMU, 44, 4) +FIELD(ID_AA64PFR0, DIT, 48, 4) +FIELD(ID_AA64PFR0, CSV2, 56, 4) +FIELD(ID_AA64PFR0, CSV3, 60, 4) FIELD(ID_AA64PFR1, BT, 0, 4)FIELD (ID_AA64PFR1 ,SBSS ,4 ,4 )
@@ -3881,6 +3887,11 @@ static inline bool isar_feature_aa64_sve(const ARMISARegisters *id)return FIELD_EX64 (id->id_aa64pfr0,ID_AA64PFR0 ,SVE ) !=0 ; } +static inline bool isar_feature_aa64_sel2 (const ARMISARegisters *id) +{ +return FIELD_EX64 (id->id_aa64pfr0,ID_AA64PFR0 ,SEL2 ) !=0 ; +} +static inline bool isar_feature_aa64_vh (const ARMISARegisters *id) {return FIELD_EX64 (id->id_aa64mmfr1,ID_AA64MMFR1 ,VH ) !=0 ;
Signature · 1 line
2.29.2
PATCH v2 7/17 target/arm: add 64-bit S-EL2 to EL exception table
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
With the ARMv8.4-SEL2 extension, EL2 is a legal exception level in secure mode, though it can only be AArch64.
This patch adds the target EL for exceptions from 64-bit S-EL2.
It also fixes the target EL to EL2 when HCR.{A,F,I}MO are set in secure mode. Those values were never used in practice as the effective value of HCR was always 0 in secure mode.
--- target/arm/helper.c | 10 +++++----- target/arm/op_helper.c | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-)
target/arm/helper.c +5 -5
@@ -9005,13 +9005,13 @@ static const int8_t target_el_table[2][2][2][2][2][4] = { {{/* 0 1 1 0 */{ 3, 3, 3, -1 },{ 3, -1, -1, 3 },}, {/* 0 1 1 1 */{ 3, 3, 3, -1 },{ 3, -1, -1, 3 },},},},}, {{{{/* 1 0 0 0 */{ 1, 1, 2, -1 },{ 1, 1, -1, 1 },}, - {/* 1 0 0 1 */{ 2, 2, 2, -1 },{ 1, 1, -1, 1 },},}, - {{/* 1 0 1 0 */{ 1, 1, 1, -1 },{ 1, 1, -1, 1 },}, - {/* 1 0 1 1 */{ 2, 2, 2, -1 },{ 1, 1, -1, 1 },},},}, + {/* 1 0 0 1 */{ 2, 2, 2, -1 },{ 2, 2, -1, 1 },},}, + {{/* 1 0 1 0 */{ 1, 1, 1, -1 },{ 1, 1, 1, 1 },}, + {/* 1 0 1 1 */{ 2, 2, 2, -1 },{ 2, 2, 2, 1 },},},}, {{{/* 1 1 0 0 */{ 3, 3, 3, -1 },{ 3, 3, -1, 3 },}, {/* 1 1 0 1 */{ 3, 3, 3, -1 },{ 3, 3, -1, 3 },},}, - {{/* 1 1 1 0 */{ 3, 3, 3, -1 },{ 3, 3, -1, 3 },}, - {/* 1 1 1 1 */{ 3, 3, 3, -1 },{ 3, 3, -1, 3 },},},},}, + {{/* 1 1 1 0 */{ 3, 3, 3, -1 },{ 3, 3, 3, 3 },}, + {/* 1 1 1 1 */{ 3, 3, 3, -1 },{ 3, 3, 3, 3 },},},},}, }; /*
target/arm/op_helper.c +2 -2
@@ -649,10 +649,10 @@ void HELPER(access_check_cp_reg)(CPUARMState *env, void *rip, uint32_t syndrome, target_el =exception_target_el (env);break ;case CP_ACCESS_TRAP_EL2 : -/* Requesting a trap to EL2 when we're in EL3 or S-EL0/1 is +/* Requesting a trap to EL2 when we're in EL3 is * a bug in the access function. */ -assert (!arm_is_secure (env) &&arm_current_el (env) !=3 ); +assert (arm_current_el (env) !=3 ); target_el =2 ;break ;case CP_ACCESS_TRAP_EL3 :
Signature · 1 line
2.29.2
PATCH v2 8/17 target/arm: return the stage 2 index for stage 1
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
This makes arm_mmu_idx_is_stage1_of_2() optionally return the stage 2 MMU index. With Secure EL2, there are more than one stage 2 regimes, so we can no longer hard-code a constant index for it.
--- target/arm/helper.c | 13 +++++++------ target/arm/internals.h | 16 +++++++++++----- 2 files changed, 18 insertions(+), 11 deletions(-)
target/arm/helper.c +7 -6
@@ -3424,7 +3424,7 @@ static uint64_t do_ats_write(CPUARMState *env, uint64_t value,bool take_exc = false;if (fi.s1ptw && current_el ==1 && !arm_is_secure (env) - &&arm_mmu_idx_is_stage1_of_2 (mmu_idx)) { + &&arm_mmu_idx_is_stage1_of_2 (mmu_idx,NULL )) {/* * Synchronous stage 2 fault on an access made as part of the * translation table walk for AT S1E0* or AT S1E1* insn
@@ -10008,7 +10008,7 @@ static inline bool regime_translation_disabled(CPUARMState *env, } } -if ((hcr_el2 &HCR_DC ) &&arm_mmu_idx_is_stage1_of_2 (mmu_idx)) { +if ((hcr_el2 &HCR_DC ) &&arm_mmu_idx_is_stage1_of_2 (mmu_idx,NULL )) {/* HCR.DC means SCTLR_EL1.M behaves as 0 */ return true; }
@@ -10340,16 +10340,17 @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx, hwaddr addr, MemTxAttrs txattrs, ARMMMUFaultInfo *fi) { - if (arm_mmu_idx_is_stage1_of_2(mmu_idx) && - !regime_translation_disabled(env, ARMMMUIdx_Stage2)) { + ARMMMUIdx s2_mmu_idx; + +if (arm_mmu_idx_is_stage1_of_2 (mmu_idx, &s2_mmu_idx) && + !regime_translation_disabled (env, s2_mmu_idx)) {target_ulong s2size;hwaddr s2pa;int s2prot;int ret;ARMCacheAttrs cacheattrs = {}; - ret =get_phys_addr_lpae (env, addr,MMU_DATA_LOAD , ARMMMUIdx_Stage2, - false, + ret =get_phys_addr_lpae (env, addr,MMU_DATA_LOAD , s2_mmu_idx, false, &s2pa, &txattrs, &s2prot, &s2size, fi, &cacheattrs);if (ret) {
target/arm/internals.h +11 -5
@@ -1146,17 +1146,23 @@ ARMMMUIdx arm_stage1_mmu_idx(CPUARMState *env);/** * arm_mmu_idx_is_stage1_of_2: -* @mmu_idx: The ARMMMUIdx to test +* @s1_mmu_idx: The ARMMMUIdx to test +* @s2_mmu_idx: Storage space for the stage 2 ARMMMUIdx * -* Return true if @mmu_idx is a NOTLB mmu_idx that is the -* first stage of a two stage regime. +* Return true if @mmu_idx is a NOTLB mmu_idx that is the first stage +* of a two stage regime. The corresponding second stage will be +* stored in @s2_mmu_idx. */ -static inline bool arm_mmu_idx_is_stage1_of_2 (ARMMMUIdx mmu_idx) +static inline bool arm_mmu_idx_is_stage1_of_2 (ARMMMUIdx s1_mmu_idx, +ARMMMUIdx *s2_mmu_idx) { -switch (mmu_idx) { +switch (s1_mmu_idx) {case ARMMMUIdx_Stage1_E0:case ARMMMUIdx_Stage1_E1:case ARMMMUIdx_Stage1_E1_PAN: +if (s2_mmu_idx !=NULL ) { + *s2_mmu_idx = ARMMMUIdx_Stage2; + }return true;default :return false;
Signature · 1 line
2.29.2
PATCH v2 9/17 target/arm: add MMU stage 1 for Secure EL2
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
This adds the MMU indices for EL2 stage 1 in secure mode.
To keep code contained, which is largelly identical between secure and non-secure modes, the MMU indices are reassigned. The new assignments provide a systematic pattern with a non-secure bit.
--- target/arm/cpu-param.h | 2 +- target/arm/cpu.h | 37 +++++++---- target/arm/helper.c | 127 ++++++++++++++++++++++++------------- target/arm/internals.h | 12 ++++ target/arm/translate-a64.c | 4 ++ 5 files changed, 124 insertions(+), 58 deletions(-)
target/arm/cpu-param.h +1 -1
@@ -29,6 +29,6 @@# define TARGET_PAGE_BITS_MIN 10#endif -#define NB_MMU_MODES 11 +#define NB_MMU_MODES 15#endif
target/arm/cpu.h +23 -14
@@ -2946,6 +2946,9 @@ bool write_cpustate_to_list(ARMCPU *cpu, bool kvm_sync);#define ARM_MMU_IDX_NOTLB 0x20/* does not have a TLB */ #define ARM_MMU_IDX_M 0x40/* M profile */ +/* Meanings of the bits for A profile mmu idx values */ +#define ARM_MMU_IDX_A_NS 0x8 +/* Meanings of the bits for M profile mmu idx values */ #define ARM_MMU_IDX_M_PRIV 0x1#define ARM_MMU_IDX_M_NEGPRI 0x2
@@ -2959,20 +2962,22 @@ typedef enum ARMMMUIdx {/* * A-profile. */ - ARMMMUIdx_E10_0 =0 |ARM_MMU_IDX_A , - ARMMMUIdx_E20_0 =1 |ARM_MMU_IDX_A , - - ARMMMUIdx_E10_1 =2 |ARM_MMU_IDX_A , - ARMMMUIdx_E10_1_PAN =3 |ARM_MMU_IDX_A , - - ARMMMUIdx_E2 =4 |ARM_MMU_IDX_A , - ARMMMUIdx_E20_2 =5 |ARM_MMU_IDX_A , - ARMMMUIdx_E20_2_PAN =6 |ARM_MMU_IDX_A , - - ARMMMUIdx_SE10_0 =7 |ARM_MMU_IDX_A , - ARMMMUIdx_SE10_1 =8 |ARM_MMU_IDX_A , - ARMMMUIdx_SE10_1_PAN =9 |ARM_MMU_IDX_A , - ARMMMUIdx_SE3 =10 |ARM_MMU_IDX_A , + ARMMMUIdx_SE10_0 =0 |ARM_MMU_IDX_A , + ARMMMUIdx_SE20_0 =1 |ARM_MMU_IDX_A , + ARMMMUIdx_SE10_1 =2 |ARM_MMU_IDX_A , + ARMMMUIdx_SE20_2 =3 |ARM_MMU_IDX_A , + ARMMMUIdx_SE10_1_PAN =4 |ARM_MMU_IDX_A , + ARMMMUIdx_SE20_2_PAN =5 |ARM_MMU_IDX_A , + ARMMMUIdx_SE2 =6 |ARM_MMU_IDX_A , + ARMMMUIdx_SE3 =7 |ARM_MMU_IDX_A , + + ARMMMUIdx_E10_0 = ARMMMUIdx_SE10_0 |ARM_MMU_IDX_A_NS , + ARMMMUIdx_E20_0 = ARMMMUIdx_SE20_0 |ARM_MMU_IDX_A_NS , + ARMMMUIdx_E10_1 = ARMMMUIdx_SE10_1 |ARM_MMU_IDX_A_NS , + ARMMMUIdx_E20_2 = ARMMMUIdx_SE20_2 |ARM_MMU_IDX_A_NS , + ARMMMUIdx_E10_1_PAN = ARMMMUIdx_SE10_1_PAN |ARM_MMU_IDX_A_NS , + ARMMMUIdx_E20_2_PAN = ARMMMUIdx_SE20_2_PAN |ARM_MMU_IDX_A_NS , + ARMMMUIdx_E2 = ARMMMUIdx_SE2 |ARM_MMU_IDX_A_NS ,/* * These are not allocated TLBs and are used only for AT system
@@ -3019,8 +3024,12 @@ typedef enum ARMMMUIdxBit {TO_CORE_BIT (E20_2 ),TO_CORE_BIT (E20_2_PAN ),TO_CORE_BIT (SE10_0 ), +TO_CORE_BIT (SE20_0 ),TO_CORE_BIT (SE10_1 ), +TO_CORE_BIT (SE20_2 ),TO_CORE_BIT (SE10_1_PAN ), +TO_CORE_BIT (SE20_2_PAN ), +TO_CORE_BIT (SE2 ),TO_CORE_BIT (SE3 ), TO_CORE_BIT(MUser),
target/arm/helper.c +84 -43
245 lines not on this page · raw message
target/arm/internals.h +12 -0
@@ -860,6 +860,9 @@ static inline bool regime_has_2_ranges(ARMMMUIdx mmu_idx)case ARMMMUIdx_SE10_0:case ARMMMUIdx_SE10_1:case ARMMMUIdx_SE10_1_PAN: +case ARMMMUIdx_SE20_0: +case ARMMMUIdx_SE20_2: +case ARMMMUIdx_SE20_2_PAN:return true;default :return false;
@@ -890,6 +893,10 @@ static inline bool regime_is_secure(CPUARMState *env, ARMMMUIdx mmu_idx)case ARMMMUIdx_SE10_0:case ARMMMUIdx_SE10_1:case ARMMMUIdx_SE10_1_PAN: +case ARMMMUIdx_SE20_0: +case ARMMMUIdx_SE20_2: +case ARMMMUIdx_SE20_2_PAN: +case ARMMMUIdx_SE2:case ARMMMUIdx_MSPrivNegPri:case ARMMMUIdx_MSUserNegPri:case ARMMMUIdx_MSPriv:
@@ -907,6 +914,7 @@ static inline bool regime_is_pan(CPUARMState *env, ARMMMUIdx mmu_idx)case ARMMMUIdx_E10_1_PAN:case ARMMMUIdx_E20_2_PAN:case ARMMMUIdx_SE10_1_PAN: +case ARMMMUIdx_SE20_2_PAN:return true;default :return false;
@@ -917,10 +925,14 @@ static inline bool regime_is_pan(CPUARMState *env, ARMMMUIdx mmu_idx)static inline uint32_t regime_el (CPUARMState *env,ARMMMUIdx mmu_idx) {switch (mmu_idx) { +case ARMMMUIdx_SE20_0: +case ARMMMUIdx_SE20_2: +case ARMMMUIdx_SE20_2_PAN:case ARMMMUIdx_E20_0:case ARMMMUIdx_E20_2:case ARMMMUIdx_E20_2_PAN:case ARMMMUIdx_Stage2: +case ARMMMUIdx_SE2:case ARMMMUIdx_E2:return 2 ;case ARMMMUIdx_SE3:
target/arm/translate-a64.c +4 -0
@@ -118,6 +118,10 @@ static int get_a64_user_mem_index(DisasContext *s)case ARMMMUIdx_SE10_1_PAN: useridx = ARMMMUIdx_SE10_0;break ; +case ARMMMUIdx_SE20_2: +case ARMMMUIdx_SE20_2_PAN: + useridx = ARMMMUIdx_SE20_0; +break ;default :g_assert_not_reached (); }
Signature · 1 line
2.29.2
Re: [PATCH 09/17] target/arm: add MMU stage 1 for Secure EL2
Quoted 8 lines · On 11/9/20 6:10 AM, [email protected] wrote:
From: Rémi Denis-Courmont <[email protected]>
This adds the MMU indices for EL2 stage 1 in secure mode.
To keep code contained, which is largelly identical between secure and non-secure modes, the MMU indices are reassigned. The new assignments provide a systematic pattern with a non-secure bit.
Quoted 8 lines
Signed-off-by Rémi Denis-Courmont <[email protected]>--- target/arm/cpu-param.h | 2 +- target/arm/cpu.h | 37 +++++++---- target/arm/helper.c | 127 ++++++++++++++++++++++++------------- target/arm/internals.h | 12 ++++ target/arm/translate-a64.c | 4 ++ 5 files changed, 124 insertions(+), 58 deletions(-)
r~
PATCH v2 10/17 target/arm: add ARMv8.4-SEL2 system registers
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
--- target/arm/cpu.h | 2 ++ target/arm/helper.c | 24 ++++++++++++++++++++++++ 2 files changed, 26 insertions(+)
target/arm/cpu.h +2 -0
@@ -323,9 +323,11 @@ typedef struct CPUARMState {uint64_t ttbr1_el[4 ]; };uint64_t vttbr_el2;/* Virtualization Translation Table Base. */ +uint64_t vsttbr_el2;/* Secure Virtualization Translation Table. */ /* MMU translation table base control. */ TCR tcr_el[4 ];TCR vtcr_el2;/* Virtualization Translation Control. */ +TCR vstcr_el2;/* Secure Virtualization Translation Control. */ uint32_t c2_data;/* MPU data cacheable bits. */ uint32_t c2_insn;/* MPU instruction cacheable bits. */ union {/* MMU domain access control register
target/arm/helper.c +24 -0
@@ -5721,6 +5721,27 @@ static const ARMCPRegInfo el2_v8_cp_reginfo[] = {REGINFO_SENTINEL }; +static CPAccessResult sel2_access (CPUARMState *env,const ARMCPRegInfo *ri, +bool isread) +{ +if (arm_current_el (env) ==3 ||arm_is_secure_below_el3 (env)) { +return CP_ACCESS_OK ; + } +return CP_ACCESS_TRAP_UNCATEGORIZED ; +} + +static const ARMCPRegInfo el2_sec_cp_reginfo[] = { + { .name ="VSTTBR_EL2" , .state =ARM_CP_STATE_AA64 , + .opc0 =3 , .opc1 =4 , .crn =2 , .crm =6 , .opc2 =0 , + .access =PL2_RW , .accessfn = sel2_access, + .fieldoffset = offsetof(CPUARMState, cp15.vsttbr_el2) }, + { .name ="VSTCR_EL2" , .state =ARM_CP_STATE_AA64 , + .opc0 =3 , .opc1 =4 , .crn =2 , .crm =6 , .opc2 =2 , + .access =PL2_RW , .accessfn = sel2_access, + .fieldoffset = offsetof(CPUARMState, cp15.vstcr_el2) }, +REGINFO_SENTINEL +}; +static CPAccessResult nsacr_access (CPUARMState *env,const ARMCPRegInfo *ri,bool isread) {
@@ -7733,6 +7754,9 @@ void register_cp_regs_for_features(ARMCPU *cpu)if (arm_feature (env,ARM_FEATURE_V8 )) {define_arm_cp_regs (cpu, el2_v8_cp_reginfo); } +if (cpu_isar_feature (aa64_sel2, cpu)) { +define_arm_cp_regs (cpu, el2_sec_cp_reginfo); + }/* RVBAR_EL2 is only implemented if EL2 is the highest EL */ if (!arm_feature (env,ARM_FEATURE_EL3 )) {ARMCPRegInfo rvbar = {
Signature · 1 line
2.29.2
Re: [PATCH 10/17] target/arm: add ARMv8.4-SEL2 system registers
Quoted 7 lines · On 11/9/20 6:10 AM, [email protected] wrote:
From: Rémi Denis-Courmont <[email protected]>
Signed-off-by Rémi Denis-Courmont <[email protected]>--- target/arm/cpu.h | 2 ++ target/arm/helper.c | 24 ++++++++++++++++++++++++ 2 files changed, 26 insertions(+)
r~
PATCH v2 11/17 target/arm: do S1_ptw_translate() before address space lookup
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
In the secure stage 2 translation regime, the VSTCR.SW and VTCR.NSW bits can invert the secure flag for pagetable walks. This patchset allows S1_ptw_translate() to change the non-secure bit.
--- target/arm/helper.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
target/arm/helper.c +6 -3
@@ -10391,7 +10391,7 @@ static bool get_level1_table_address(CPUARMState *env, ARMMMUIdx mmu_idx,/* Translate a S1 pagetable walk through S2 if needed. */ static hwaddr S1_ptw_translate (CPUARMState *env,ARMMMUIdx mmu_idx, -hwaddr addr,MemTxAttrs txattrs, +hwaddr addr,bool *is_secure,ARMMMUFaultInfo *fi) {ARMMMUIdx s2_mmu_idx;
@@ -10403,6 +10403,9 @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx,int s2prot;int ret;ARMCacheAttrs cacheattrs = {}; +MemTxAttrs txattrs = {}; + +assert (!*is_secure);/* TODO: S-EL2 */ ret = get_phys_addr_lpae(env, addr, MMU_DATA_LOAD, s2_mmu_idx, false, &s2pa, &txattrs, &s2prot, &s2size, fi,
@@ -10441,9 +10444,9 @@ static uint32_t arm_ldl_ptw(CPUState *cs, hwaddr addr, bool is_secure,AddressSpace *as;uint32_t data; + addr =S1_ptw_translate (env, mmu_idx, addr, &is_secure, fi); attrs.secure = is_secure; as =arm_addressspace (cs, attrs); - addr =S1_ptw_translate (env, mmu_idx, addr, attrs, fi);if (fi->s1ptw) {return 0 ; }
@@ -10470,9 +10473,9 @@ static uint64_t arm_ldq_ptw(CPUState *cs, hwaddr addr, bool is_secure,AddressSpace *as;uint64_t data; + addr =S1_ptw_translate (env, mmu_idx, addr, &is_secure, fi); attrs.secure = is_secure; as =arm_addressspace (cs, attrs); - addr =S1_ptw_translate (env, mmu_idx, addr, attrs, fi);if (fi->s1ptw) {return 0 ; }
Signature · 1 line
2.29.2
Re: [PATCH 11/17] target/arm: do S1_ptw_translate() before address space lookup
Quoted 10 lines · On 11/9/20 6:10 AM, [email protected] wrote:
From: Rémi Denis-Courmont <[email protected]>
In the secure stage 2 translation regime, the VSTCR.SW and VTCR.NSW bits can invert the secure flag for pagetable walks. This patchset allows
S1_ptw_translate()to change the non-secure bit.Signed-off-by Rémi Denis-Courmont <[email protected]>--- target/arm/helper.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
r~
PATCH v2 12/17 target/arm: secure stage 2 translation regime
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
--- target/arm/cpu.h | 11 ++++- target/arm/helper.c | 96 ++++++++++++++++++++++++++++++++---------- target/arm/internals.h | 24 +++++++++++ 3 files changed, 107 insertions(+), 24 deletions(-)
target/arm/cpu.h +10 -1
@@ -168,6 +168,11 @@ typedef struct {uint32_t base_mask; }TCR ; +#define VTCR_NSW (1u << 29) +#define VTCR_NSA (1u << 30) +#define VSTCR_SW VTCR_NSW +#define VSTCR_SA VTCR_NSA +/* Define a maximum sized vector register. * For 32-bit, this is a 128-bit NEON/AdvSIMD register. * For 64-bit, this is a 2048-bit SVE register.
@@ -2988,6 +2993,9 @@ typedef enum ARMMMUIdx { ARMMMUIdx_Stage1_E0 =0 |ARM_MMU_IDX_NOTLB , ARMMMUIdx_Stage1_E1 =1 |ARM_MMU_IDX_NOTLB , ARMMMUIdx_Stage1_E1_PAN =2 |ARM_MMU_IDX_NOTLB , + ARMMMUIdx_Stage1_SE0 =3 |ARM_MMU_IDX_NOTLB , + ARMMMUIdx_Stage1_SE1 =4 |ARM_MMU_IDX_NOTLB , + ARMMMUIdx_Stage1_SE1_PAN =5 |ARM_MMU_IDX_NOTLB ,/* * Not allocated a TLB: used only for second stage of an S12 page * table walk, or for descriptor loads during first stage of an S1
@@ -2995,7 +3003,8 @@ typedef enum ARMMMUIdx {* then various TLB flush insns which currently are no-ops or flush * only stage 1 MMU indexes will need to change to flush stage 2. */ - ARMMMUIdx_Stage2 = 3 | ARM_MMU_IDX_NOTLB, + ARMMMUIdx_Stage2 =6 |ARM_MMU_IDX_NOTLB , + ARMMMUIdx_Stage2_S = 7 | ARM_MMU_IDX_NOTLB,/* * M-profile.
target/arm/helper.c +73 -23
259 lines not on this page · raw message
target/arm/internals.h +24 -0
@@ -851,6 +851,9 @@ static inline bool regime_has_2_ranges(ARMMMUIdx mmu_idx)case ARMMMUIdx_Stage1_E0:case ARMMMUIdx_Stage1_E1:case ARMMMUIdx_Stage1_E1_PAN: +case ARMMMUIdx_Stage1_SE0: +case ARMMMUIdx_Stage1_SE1: +case ARMMMUIdx_Stage1_SE1_PAN:case ARMMMUIdx_E10_0:case ARMMMUIdx_E10_1:case ARMMMUIdx_E10_1_PAN:
@@ -896,7 +899,11 @@ static inline bool regime_is_secure(CPUARMState *env, ARMMMUIdx mmu_idx)case ARMMMUIdx_SE20_0:case ARMMMUIdx_SE20_2:case ARMMMUIdx_SE20_2_PAN: +case ARMMMUIdx_Stage1_SE0: +case ARMMMUIdx_Stage1_SE1: +case ARMMMUIdx_Stage1_SE1_PAN:case ARMMMUIdx_SE2: +case ARMMMUIdx_Stage2_S:case ARMMMUIdx_MSPrivNegPri:case ARMMMUIdx_MSUserNegPri:case ARMMMUIdx_MSPriv:
@@ -911,6 +918,7 @@ static inline bool regime_is_pan(CPUARMState *env, ARMMMUIdx mmu_idx) {switch (mmu_idx) {case ARMMMUIdx_Stage1_E1_PAN: +case ARMMMUIdx_Stage1_SE1_PAN:case ARMMMUIdx_E10_1_PAN:case ARMMMUIdx_E20_2_PAN:case ARMMMUIdx_SE10_1_PAN:
@@ -932,6 +940,7 @@ static inline uint32_t regime_el(CPUARMState *env, ARMMMUIdx mmu_idx)case ARMMMUIdx_E20_2:case ARMMMUIdx_E20_2_PAN:case ARMMMUIdx_Stage2: +case ARMMMUIdx_Stage2_S:case ARMMMUIdx_SE2:case ARMMMUIdx_E2:return 2 ;
@@ -944,6 +953,9 @@ static inline uint32_t regime_el(CPUARMState *env, ARMMMUIdx mmu_idx)case ARMMMUIdx_Stage1_E0:case ARMMMUIdx_Stage1_E1:case ARMMMUIdx_Stage1_E1_PAN: +case ARMMMUIdx_Stage1_SE0: +case ARMMMUIdx_Stage1_SE1: +case ARMMMUIdx_Stage1_SE1_PAN:case ARMMMUIdx_E10_0:case ARMMMUIdx_E10_1:case ARMMMUIdx_E10_1_PAN:
@@ -967,6 +979,12 @@ static inline TCR *regime_tcr(CPUARMState *env, ARMMMUIdx mmu_idx)if (mmu_idx == ARMMMUIdx_Stage2) {return &env->cp15.vtcr_el2; } +if (mmu_idx == ARMMMUIdx_Stage2_S) { +/* Note: Secure stage 2 nominally shares fields from VTCR_EL2, but +* those are not currently used by QEMU, so just return VSTCR_EL2. +*/ +return &env->cp15.vstcr_el2; + }return &env->cp15.tcr_el[regime_el (env, mmu_idx)]; }
@@ -1176,6 +1194,12 @@ static inline bool arm_mmu_idx_is_stage1_of_2(ARMMMUIdx s1_mmu_idx, *s2_mmu_idx = ARMMMUIdx_Stage2; }return true; +case ARMMMUIdx_Stage1_SE0: +case ARMMMUIdx_Stage1_SE1: +case ARMMMUIdx_Stage1_SE1_PAN: +if (s2_mmu_idx !=NULL ) + *s2_mmu_idx = ARMMMUIdx_Stage2_S; +return true;default :return false; }
Signature · 1 line
2.29.2
PATCH v2 13/17 target/arm: handle VMID change in secure state
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
The VTTBR write callback so far assumes that the underlying VM lies in non-secure state. This handles the secure state scenario.
--- target/arm/helper.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-)
target/arm/helper.c +9 -4
@@ -4018,10 +4018,15 @@ static void vttbr_write(CPUARMState *env, const ARMCPRegInfo *ri,* the combined stage 1&2 tlbs (EL10_1 and EL10_0). */ if (raw_read (env, ri) != value) { -tlb_flush_by_mmuidx (cs, - ARMMMUIdxBit_E10_1 | - ARMMMUIdxBit_E10_1_PAN | - ARMMMUIdxBit_E10_0); +uint16_t mask = ARMMMUIdxBit_E10_1 | + ARMMMUIdxBit_E10_1_PAN | + ARMMMUIdxBit_E10_0; + +if (arm_is_secure_below_el3 (env)) { + mask >>=ARM_MMU_IDX_A_NS ; + } + +tlb_flush_by_mmuidx (cs, mask);raw_write (env, ri, value); } }
Signature · 1 line
2.29.2
Re: [PATCH 13/17] target/arm: handle VMID change in secure state
Quoted 9 lines · On 11/9/20 6:10 AM, [email protected] wrote:
From: Rémi Denis-Courmont <[email protected]>
The VTTBR write callback so far assumes that the underlying VM lies in non-secure state. This handles the secure state scenario.
Signed-off-by Rémi Denis-Courmont <[email protected]>--- target/arm/helper.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-)
r~
PATCH v2 14/17 target/arm: set HPFAR_EL2.NS on secure stage 2 faults
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
--- target/arm/cpu.h | 2 ++ target/arm/helper.c | 6 ++++++ target/arm/internals.h | 2 ++ target/arm/tlb_helper.c | 3 +++ 4 files changed, 13 insertions(+)
target/arm/cpu.h +2 -0
@@ -1482,6 +1482,8 @@ static inline void xpsr_write(CPUARMState *env, uint32_t val, uint32_t mask)#define HCR_TWEDEN (1ULL << 59)#define HCR_TWEDEL MAKE_64BIT_MASK(60, 4) +#define HPFAR_NS (1ULL << 63) +#define SCR_NS (1U << 0)#define SCR_IRQ (1U << 1)#define SCR_FIQ (1U << 2)
target/arm/helper.c +6 -0
@@ -3444,6 +3444,9 @@ static uint64_t do_ats_write(CPUARMState *env, uint64_t value, target_el =3 ; }else { env->cp15.hpfar_el2 =extract64 (fi.s2addr,12 ,47 ) <<4 ; +if (fi.s1ns) { + env->cp15.hpfar_el2 |=HPFAR_NS ; + } target_el =2 ; } take_exc = true;
@@ -10446,6 +10449,7 @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx, fi->s2addr = addr; fi->stage2 = true; fi->s1ptw = true; + fi->s1ns = !*is_secure;return ~0 ; }if ((arm_hcr_el2_eff (env) &HCR_PTW ) && (cacheattrs.attrs &0xf0 ) ==0 ) {
@@ -10457,6 +10461,7 @@ static hwaddr S1_ptw_translate(CPUARMState *env, ARMMMUIdx mmu_idx, fi->s2addr = addr; fi->stage2 = true; fi->s1ptw = true; + fi->s1ns = !*is_secure;return ~0 ; } addr = s2pa;
@@ -11353,6 +11358,7 @@ do_fault:/* Tag the error as S2 for failed S1 PTW at S2 or ordinary S2. */ fi->stage2 = fi->s1ptw || (mmu_idx == ARMMMUIdx_Stage2 || mmu_idx == ARMMMUIdx_Stage2_S); + fi->s1ns = mmu_idx == ARMMMUIdx_Stage2;return true; }
target/arm/internals.h +2 -0
@@ -593,6 +593,7 @@ typedef enum ARMFaultType {* @s2addr: Address that caused a fault at stage 2 * @stage2: True if we faulted at stage 2 * @s1ptw: True if we faulted at stage 2 while doing a stage 1 page-table walk +* @s1ns: True if we faulted on a non-secure IPA while in secure state * @ea: True if we should set the EA (external abort type) bit in syndrome */ typedef struct ARMMMUFaultInfo ARMMMUFaultInfo ;
@@ -603,6 +604,7 @@ struct ARMMMUFaultInfo {int domain;bool stage2;bool s1ptw; +bool s1ns;bool ea; };
target/arm/tlb_helper.c +3 -0
@@ -63,6 +63,9 @@ static void QEMU_NORETURN arm_deliver_fault(ARMCPU *cpu, vaddr addr,if (fi->stage2) { target_el =2 ; env->cp15.hpfar_el2 =extract64 (fi->s2addr,12 ,47 ) <<4 ; +if (arm_is_secure_below_el3 (env) && fi->s1ns) { + env->cp15.hpfar_el2 |=HPFAR_NS ; + } } same_el = (arm_current_el (env) == target_el);
Signature · 1 line
2.29.2
Re: [PATCH 14/17] target/arm: set HPFAR_EL2.NS on secure stage 2 faults
target/arm/helper.c static uint64_t do_ats_write(CPUARMState *env, uint64_t value, · line 3449
Quoted 7 lines · On 11/9/20 6:10 AM, [email protected] wrote:
target/arm/helper.c +3
-0@@ -3444,6 +3444,9 @@ static uint64_t do_ats_write(CPUARMState *env, uint64_t value, target_el =3 ; }else { env->cp15.hpfar_el2 =extract64 (fi.s2addr,12 ,47 ) <<4 ; +if (fi.s1ns) { + env->cp15.hpfar_el2 |=HPFAR_NS ; + }
This should only be set for SEL2, not non-secure EL2.
target/arm/tlb_helper.c static void QEMU_NORETURN arm_deliver_fault(ARMCPU *cpu, vaddr addr, · line 68
Quoted 3 lines
target/arm/tlb_helper.c +3
-0+if (arm_is_secure_below_el3 (env) && fi->s1ns) { + env->cp15.hpfar_el2 |=HPFAR_NS ; + }
... like you did here.
r~
PATCH v2 15/17 target/arm: add ARMv8.4-SEL2 extension
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
This adds handling for the SCR_EL3.EEL2 bit.
A translation block flag is added in A32 mode to route exceptions correctly from AArch32 S-EL1 to (AArch64) S-EL2.
--- target/arm/cpu.c | 2 +- target/arm/cpu.h | 11 ++++++++--- target/arm/helper.c | 21 ++++++++++++++++++--- target/arm/translate.c | 6 ++++-- target/arm/translate.h | 1 + 5 files changed, 32 insertions(+), 9 deletions(-)
target/arm/cpu.c +1 -1
@@ -476,7 +476,7 @@ static inline bool arm_excp_unmasked(CPUState *cs, unsigned int excp_idx,* masked from Secure state. The HCR and SCR settings * don't affect the masking logic, only the interrupt routing. */ -if (target_el ==3 || !secure) { +if (target_el ==3 || !secure || (env->cp15.scr_el3 &SCR_EEL2 )) { unmasked = true; } }else {
target/arm/cpu.h +8 -3
@@ -2061,7 +2061,10 @@ static inline bool arm_is_secure(CPUARMState *env)static inline bool arm_is_el2_enabled (CPUARMState *env) {if (arm_feature (env,ARM_FEATURE_EL2 )) { -return !arm_is_secure_below_el3 (env); +if (arm_is_secure_below_el3 (env)) { +return (env->cp15.scr_el3 &SCR_EEL2 ) !=0 ; + } +return true; }return false; }
@@ -2108,7 +2111,8 @@ static inline bool arm_el_is_aa64(CPUARMState *env, int el)return aa64; } -if (arm_feature (env,ARM_FEATURE_EL3 )) { +if (arm_feature (env,ARM_FEATURE_EL3 ) && + ((env->cp15.scr_el3 &SCR_NS ) || !(env->cp15.scr_el3 &SCR_EEL2 ))) { aa64 = aa64 && (env->cp15.scr_el3 &SCR_RW ); }
@@ -3264,7 +3268,7 @@ typedef ARMCPU ArchCPU;* We put flags which are shared between 32 and 64 bit mode at the top * of the word, and flags which apply to only one mode at the bottom. * -* 31 20 18 14 9 0 +* 31 20 19 14 9 0 * +--------------+-----+-----+----------+--------------+ * | | | TBFLAG_A32 | | * | | +-----+----------+ TBFLAG_AM32 |
@@ -3313,6 +3317,7 @@ FIELD(TBFLAG_A32, HSTR_ACTIVE, 16, 1)* the same thing as the current security state of the processor! */ FIELD(TBFLAG_A32, NS, 17, 1) +FIELD (TBFLAG_A32 ,EEL2 ,18 ,1 )/* * Bit usage when in AArch32 state, for M-profile only.
target/arm/helper.c +18 -3
@@ -532,6 +532,9 @@ static CPAccessResult access_trap_aa32s_el1(CPUARMState *env,return CP_ACCESS_OK ; }if (arm_is_secure_below_el3 (env)) { +if (env->cp15.scr_el3 &SCR_EEL2 ) { +return CP_ACCESS_TRAP_EL2 ; + }return CP_ACCESS_TRAP_EL3 ; }/* This will be EL1 NS and EL2 NS, which just UNDEF */
@@ -2029,6 +2032,9 @@ static void scr_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)if (cpu_isar_feature (aa64_pauth, cpu)) { valid_mask |=SCR_API |SCR_APK ; } +if (cpu_isar_feature (aa64_sel2, cpu)) { + valid_mask |=SCR_EEL2 ; + }if (cpu_isar_feature (aa64_mte, cpu)) { valid_mask |=SCR_ATA ; }
@@ -3387,13 +3393,16 @@ static CPAccessResult ats_access(CPUARMState *env, const ARMCPRegInfo *ri, bool isread) {if (ri->opc2 &4 ) { -/* The ATS12NSO* operations must trap to EL3 if executed in +/* The ATS12NSO* operations must trap to EL3 or EL2 if executed in * Secure EL1 (which can only happen if EL3 is AArch64). * They are simply UNDEF if executed from NS EL1. * They function normally from EL2 or EL3. */ if (arm_current_el (env) ==1 ) {if (arm_is_secure_below_el3 (env)) { +if (env->cp15.scr_el3 &SCR_EEL2 ) { +return CP_ACCESS_TRAP_UNCATEGORIZED_EL2 ; + }return CP_ACCESS_TRAP_UNCATEGORIZED_EL3 ; }return CP_ACCESS_TRAP_UNCATEGORIZED ;
@@ -3656,7 +3665,7 @@ static void ats1h_write(CPUARMState *env, const ARMCPRegInfo *ri,static CPAccessResult at_s1e2_access (CPUARMState *env,const ARMCPRegInfo *ri,bool isread) { -if (arm_current_el (env) ==3 && !(env->cp15.scr_el3 &SCR_NS )) { +if (arm_current_el (env) ==3 && !(env->cp15.scr_el3 & (SCR_NS |SCR_EEL2 ))) {return CP_ACCESS_TRAP ; }return CP_ACCESS_OK ;
@@ -5755,12 +5764,15 @@ static CPAccessResult nsacr_access(CPUARMState *env, const ARMCPRegInfo *ri, bool isread) {/* The NSACR is RW at EL3, and RO for NS EL1 and NS EL2. -* At Secure EL1 it traps to EL3. +* At Secure EL1 it traps to EL3 or EL2. */ if (arm_current_el (env) ==3 ) {return CP_ACCESS_OK ; }if (arm_is_secure_below_el3 (env)) { +if (env->cp15.scr_el3 &SCR_EEL2 ) { +return CP_ACCESS_TRAP_EL2 ; + }return CP_ACCESS_TRAP_EL3 ; }/* Accesses from EL1 NS and EL2 NS are UNDEF for write but allow reads. */
@@ -12897,6 +12909,9 @@ static uint32_t rebuild_hflags_common_32(CPUARMState *env, int fp_el, flags =FIELD_DP32 (flags,TBFLAG_ANY ,BE_DATA ,1 ); } flags =FIELD_DP32 (flags,TBFLAG_A32 ,NS , !access_secure_reg (env)); +if (arm_is_secure_below_el3 (env) && (env->cp15.scr_el3 &SCR_EEL2 )) { + flags =FIELD_DP32 (flags,TBFLAG_A32 ,EEL2 ,1 ); + }return rebuild_hflags_common (env, fp_el, mmu_idx, flags); }
target/arm/translate.c +4 -2
@@ -2780,9 +2780,10 @@ static bool msr_banked_access_decode(DisasContext *s, int r, int sysm, int rn, }if (s->current_el ==1 ) {/* If we're in Secure EL1 (which implies that EL3 is AArch64) -* then accesses to Mon registers trap to EL3 +* then accesses to Mon registers trap to Secure EL2 if it exists +* otherwise EL3. */ - exc_target =3 ; + exc_target = s->sel2 ?2 :3 ; goto undef; }break ;
@@ -8800,6 +8801,7 @@ static void arm_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs) dc->sctlr_b =FIELD_EX32 (tb_flags,TBFLAG_A32 ,SCTLR_B ); dc->hstr_active =FIELD_EX32 (tb_flags,TBFLAG_A32 ,HSTR_ACTIVE ); dc->ns =FIELD_EX32 (tb_flags,TBFLAG_A32 ,NS ); + dc->sel2 =FIELD_EX32 (tb_flags,TBFLAG_A32 ,EEL2 ); dc->vfp_enabled =FIELD_EX32 (tb_flags,TBFLAG_A32 ,VFPEN );if (arm_feature (env,ARM_FEATURE_XSCALE )) { dc->c15_cpar =FIELD_EX32 (tb_flags,TBFLAG_A32 ,XSCALE_CPAR );
target/arm/translate.h +1 -0
@@ -32,6 +32,7 @@ typedef struct DisasContext {uint8_t tbid;/* TBI1|TBI0 for data */ uint8_t tcma;/* TCMA1|TCMA0 for MTE */ bool ns;/* Use non-secure CPREG bank on access */ +bool sel2;/* Secure EL2 enabled (only used in AArch32) */ int fp_excp_el;/* FP exception EL or 0 if enabled */ int sve_excp_el;/* SVE exception EL or 0 if enabled */ int sve_len;/* SVE vector length in bytes */
Signature · 1 line
2.29.2
PATCH v2 16/17 target/arm: enable Secure EL2 in max CPU
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
--- target/arm/cpu64.c | 1 + 1 file changed, 1 insertion(+)
target/arm/cpu64.c +1 -0
@@ -641,6 +641,7 @@ static void aarch64_max_initfn(Object *obj) t =FIELD_DP64 (t,ID_AA64PFR0 ,SVE ,1 ); t =FIELD_DP64 (t,ID_AA64PFR0 ,FP ,1 ); t =FIELD_DP64 (t,ID_AA64PFR0 ,ADVSIMD ,1 ); + t =FIELD_DP64 (t,ID_AA64PFR0 ,SEL2 ,1 ); cpu->isar.id_aa64pfr0 = t; t = cpu->isar.id_aa64pfr1;
Signature · 1 line
2.29.2
PATCH v2 17/17 target/arm: refactor vae1_tlbmask()
In reply to Rémi Denis-CourmontFrom: Rémi Denis-Courmont <[email protected]>
--- target/arm/helper.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-)
target/arm/helper.c +11 -14
@@ -4468,26 +4468,23 @@ static CPAccessResult aa64_cacheop_pou_access(CPUARMState *env,static int vae1_tlbmask (CPUARMState *env) {uint64_t hcr =arm_hcr_el2_eff (env); +uint16_t mask;if ((hcr & (HCR_E2H |HCR_TGE )) == (HCR_E2H |HCR_TGE )) { -uint16_t mask = ARMMMUIdxBit_E20_2 | - ARMMMUIdxBit_E20_2_PAN | - ARMMMUIdxBit_E20_0; - -if (arm_is_secure_below_el3 (env)) { - mask >>=ARM_MMU_IDX_A_NS ; - } - -return mask; - }else if (arm_is_secure_below_el3 (env)) { -return ARMMMUIdxBit_SE10_1 | - ARMMMUIdxBit_SE10_1_PAN | - ARMMMUIdxBit_SE10_0; + mask = ARMMMUIdxBit_E20_2 | + ARMMMUIdxBit_E20_2_PAN | + ARMMMUIdxBit_E20_0; }else { -return ARMMMUIdxBit_E10_1 | + mask = ARMMMUIdxBit_E10_1 | ARMMMUIdxBit_E10_1_PAN | ARMMMUIdxBit_E10_0; } + +if (arm_is_secure_below_el3 (env)) { + mask >>=ARM_MMU_IDX_A_NS ; + } + +return mask; }/* Return 56 if TBI is enabled, 64 otherwise. */
Signature · 1 line
2.29.2
Patchew URL: https://patchew.org/QEMU/[email protected]/
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Message-id: [email protected]
Subject: [PATCHv2 00/17] ARM Secure EL2 extension
Type: series
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
Updating 3c8cf5a9c21ff8782164d1def7f44bd888713384
From https://github.com/patchew-project/qemu
- [tag update] patchew/[email protected] -> patchew/[email protected] - [tag update] patchew/[email protected] -> patchew/[email protected] * [new tag] patchew/[email protected] -> patchew/[email protected]
Switched to a new branch 'test'
d67dda8 target/arm: refactor vae1_tlbmask()
c3bfa38 target/arm: enable Secure EL2 in max CPU
794bf9f target/arm: add ARMv8.4-SEL2 extension
551e1e9 target/arm: set HPFAR_EL2.NS on secure stage 2 faults 2a31d5d target/arm: handle VMID change in secure state f9b1072 target/arm: secure stage 2 translation regime cf8f578 target/arm: do S1_ptw_translate() before address space lookup ac77aef target/arm: add ARMv8.4-SEL2 system registers 8281b30 target/arm: add MMU stage 1 for Secure EL2
fb293c5 target/arm: return the stage 2 index for stage 1 d58b56e target/arm: add 64-bit S-EL2 to EL exception table e5fdf26 target/arm: declare new AA64PFR0 bit-fields d684ea4 target/arm: factor MDCR_EL2 common handling 2f79a14 target/arm: use arm_hcr_el2_eff() where applicable 840c8da target/arm: use arm_is_el2_enabled() where applicable 4cdb5a3 target/arm: add arm_is_el2_enabled() helper 0601131 target/arm: remove redundant tests
=== OUTPUT BEGIN ===
1/17 Checking commit 06011319d1cf (target/arm: remove redundant tests) 2/17 Checking commit 4cdb5a3d8a2f (target/arm: add arm_is_el2_enabled() helper)
WARNING: Block comments use a leading /* on a separate line
#21: FILE: target/arm/cpu.h:2043:
+/* Return true if the current security state has AArch64 EL2 or AArch32 Hyp.
WARNING: Block comments should align the * on each line #23: FILE: target/arm/cpu.h:2045:
+ * This corresponds to the pseudocode EL2Enabled()
+ */
total: 0 errors, 2 warnings, 28 lines checked
Patch 2/17 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
3/17 Checking commit 840c8da0faca (target/arm: use arm_is_el2_enabled() where applicable) 4/17 Checking commit 2f79a14cc521 (target/arm: use arm_hcr_el2_eff() where applicable)
WARNING: line over 80 characters
#80: FILE: target/arm/helper.c:10356:
+ if ((arm_hcr_el2_eff(env) & HCR_PTW) && (cacheattrs.attrs & 0xf0) == 0) {
total: 0 errors, 1 warnings, 79 lines checked
Patch 4/17 has style problems, please review. If any of these errors are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
5/17 Checking commit d684ea4ba83f (target/arm: factor MDCR_EL2 common handling) 6/17 Checking commit e5fdf2693a6c (target/arm: declare new AA64PFR0 bit-fields) 7/17 Checking commit d58b56ecf73f (target/arm: add 64-bit S-EL2 to EL exception table)
WARNING: Block comments use a leading /* on a separate line
#30: FILE: target/arm/helper.c:9008:
+ {/* 1 0 0 1 */{ 2, 2, 2, -1 },{ 2, 2, -1, 1 },},},
WARNING: Block comments use a leading /* on a separate line #31: FILE: target/arm/helper.c:9009:
+ {{/* 1 0 1 0 */{ 1, 1, 1, -1 },{ 1, 1, 1, 1 },},
WARNING: Block comments use a leading /* on a separate line #32: FILE: target/arm/helper.c:9010:
+ {/* 1 0 1 1 */{ 2, 2, 2, -1 },{ 2, 2, 2, 1 },},},},
WARNING: Block comments use a leading /* on a separate line #37: FILE: target/arm/helper.c:9013:
+ {{/* 1 1 1 0 */{ 3, 3, 3, -1 },{ 3, 3, 3, 3 },},
WARNING: Block comments use a leading /* on a separate line #38: FILE: target/arm/helper.c:9014:
+ {/* 1 1 1 1 */{ 3, 3, 3, -1 },{ 3, 3, 3, 3 },},},},},
WARNING: Block comments use a leading /* on a separate line #51: FILE: target/arm/op_helper.c:652:
+ /* Requesting a trap to EL2 when we're in EL3 is
total: 0 errors, 6 warnings, 30 lines checked
Patch 7/17 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
8/17 Checking commit fb293c5c257b (target/arm: return the stage 2 index for stage 1) 9/17 Checking commit 8281b3008c85 (target/arm: add MMU stage 1 for Secure EL2) 10/17 Checking commit ac77aef51d34 (target/arm: add ARMv8.4-SEL2 system registers) 11/17 Checking commit cf8f578fb8b8 (target/arm: do S1_ptw_translate() before address space lookup) 12/17 Checking commit f9b1072a2302 (target/arm: secure stage 2 translation regime)
ERROR: code indent should never use tabs
#18: FILE: target/arm/cpu.h:171:
+#define VTCR_NSW^I(1u << 29)$
ERROR: code indent should never use tabs
#19: FILE: target/arm/cpu.h:172:
+#define VTCR_NSA^I(1u << 30)$
ERROR: code indent should never use tabs
#20: FILE: target/arm/cpu.h:173:
+#define VSTCR_SW^IVTCR_NSW$
ERROR: code indent should never use tabs
#21: FILE: target/arm/cpu.h:174:
+#define VSTCR_SA^IVTCR_NSA$
WARNING: Block comments use a leading /* on a separate line #390: FILE: target/arm/internals.h:983:
+ /* Note: Secure stage 2 nominally shares fields from VTCR_EL2, but
ERROR: braces {} are necessary for all arms of this statement #405: FILE: target/arm/internals.h:1200:
+ if (s2_mmu_idx != NULL)
[...]
total: 5 errors, 1 warnings, 355 lines checked
Patch 12/17 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
13/17 Checking commit 2a31d5df0802 (target/arm: handle VMID change in secure state) 14/17 Checking commit 551e1e971371 (target/arm: set HPFAR_EL2.NS on secure stage 2 faults) 15/17 Checking commit 794bf9f61cbc (target/arm: add ARMv8.4-SEL2 extension)
WARNING: Block comments use a leading /* on a separate line
#101: FILE: target/arm/helper.c:3396:
+ /* The ATS12NSO* operations must trap to EL3 or EL2 if executed in
ERROR: spaces required around that '|' (ctx:VxV)
#119: FILE: target/arm/helper.c:3668:
+ if (arm_current_el(env) == 3 && !(env->cp15.scr_el3 & (SCR_NS|SCR_EEL2))) {
^total: 1 errors, 1 warnings, 137 lines checked
Patch 15/17 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
16/17 Checking commit c3bfa38083de (target/arm: enable Secure EL2 in max CPU) 17/17 Checking commit d67dda8443c1 (target/arm: refactor vae1_tlbmask()) === OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]