| Message ID | 20231218113305.2511480-27-peter.maydell@linaro.org |
|---|---|
| State | Superseded |
| Headers | show |
| Series | target/arm: Implement emulation of nested virtualization | expand |
On 12/18/23 22:32, Peter Maydell wrote: > + if (s->nv && s->nv2 && ri->nv2_redirect_offset) { Again, s->nv test is redundant. > + /* > + * Some registers always redirect to memory; some only do so if > + * HCR_EL2.NV1 is 0, and some only if NV1 is 1 (these come in > + * pairs which share an offset; see the table in R_CSRPQ). > + */ > + if (ri->nv2_redirect_offset & NV2_REDIR_NV1) { > + nv2_mem_redirect = s->nv1; > + } else if (ri->nv2_redirect_offset & NV2_REDIR_NO_NV1) { > + nv2_mem_redirect = !s->nv1; > + } else { > + nv2_mem_redirect = true; > + } I wondered if it would be clearer with the "both" case having both bits set. While I see that the first defined offset is 0x20, offset 0x00 is still reserved and *could* be used. At which point ri->nv2_redirect_offset would need a non-zero value for a zero offset. Maybe clearer as nv2_mem_redirect = (ri->nv2_redirect_offset & (s->nv1 ? NV2_REDIR_NV1_1 : NV2_REDIR_NV1_0)); ? This is more verbose for the (common?) case of redirect regardless of nv1, so maybe not. > + if (s->nv2_mem_be) { > + mop |= MO_BE; > + } MO_BSWAP is host dependent -- needs mop |= (s->nv2_mem_be ? MO_BE : MO_LE); r~
On Wed, 27 Dec 2023 at 23:55, Richard Henderson <richard.henderson@linaro.org> wrote: > > On 12/18/23 22:32, Peter Maydell wrote: > > + if (s->nv && s->nv2 && ri->nv2_redirect_offset) { > > Again, s->nv test is redundant. Fixed, thanks. > > + /* > > + * Some registers always redirect to memory; some only do so if > > + * HCR_EL2.NV1 is 0, and some only if NV1 is 1 (these come in > > + * pairs which share an offset; see the table in R_CSRPQ). > > + */ > > + if (ri->nv2_redirect_offset & NV2_REDIR_NV1) { > > + nv2_mem_redirect = s->nv1; > > + } else if (ri->nv2_redirect_offset & NV2_REDIR_NO_NV1) { > > + nv2_mem_redirect = !s->nv1; > > + } else { > > + nv2_mem_redirect = true; > > + } > > I wondered if it would be clearer with the "both" case having both bits set. While I see > that the first defined offset is 0x20, offset 0x00 is still reserved and *could* be used. > At which point ri->nv2_redirect_offset would need a non-zero value for a zero offset. > > Maybe clearer as > > nv2_mem_redirect = (ri->nv2_redirect_offset & > (s->nv1 ? NV2_REDIR_NV1_1 : NV2_REDIR_NV1_0)); > > ? > > This is more verbose for the (common?) case of redirect regardless of nv1, so maybe not. Yes, my motivation for the notation I used is that I wanted to make the specification of the cpreg structs in the common case simple and not too long-winded. If offset 0 does ever get allocated, we'll have to come back and revisit this. But new entries clearly seem to be being allocated at the other end of the table, so I think our chances are good... > > + if (s->nv2_mem_be) { > > + mop |= MO_BE; > > + } > > MO_BSWAP is host dependent -- needs > > mop |= (s->nv2_mem_be ? MO_BE : MO_LE); Fixed. With those two fixes, can I have a reviewed-by? This is the only patch without one, and all the fixes seem to me like very minor things not worth sending out a full v2 for. thanks -- PMM
On 1/5/24 03:23, Peter Maydell wrote: > On Wed, 27 Dec 2023 at 23:55, Richard Henderson > <richard.henderson@linaro.org> wrote: >> >> On 12/18/23 22:32, Peter Maydell wrote: >>> + if (s->nv && s->nv2 && ri->nv2_redirect_offset) { >> >> Again, s->nv test is redundant. > > Fixed, thanks. > >>> + /* >>> + * Some registers always redirect to memory; some only do so if >>> + * HCR_EL2.NV1 is 0, and some only if NV1 is 1 (these come in >>> + * pairs which share an offset; see the table in R_CSRPQ). >>> + */ >>> + if (ri->nv2_redirect_offset & NV2_REDIR_NV1) { >>> + nv2_mem_redirect = s->nv1; >>> + } else if (ri->nv2_redirect_offset & NV2_REDIR_NO_NV1) { >>> + nv2_mem_redirect = !s->nv1; >>> + } else { >>> + nv2_mem_redirect = true; >>> + } >> >> I wondered if it would be clearer with the "both" case having both bits set. While I see >> that the first defined offset is 0x20, offset 0x00 is still reserved and *could* be used. >> At which point ri->nv2_redirect_offset would need a non-zero value for a zero offset. >> >> Maybe clearer as >> >> nv2_mem_redirect = (ri->nv2_redirect_offset & >> (s->nv1 ? NV2_REDIR_NV1_1 : NV2_REDIR_NV1_0)); >> >> ? >> >> This is more verbose for the (common?) case of redirect regardless of nv1, so maybe not. > > Yes, my motivation for the notation I used is that I wanted to > make the specification of the cpreg structs in the common case > simple and not too long-winded. If offset 0 does ever get > allocated, we'll have to come back and revisit this. But > new entries clearly seem to be being allocated at the other > end of the table, so I think our chances are good... > >>> + if (s->nv2_mem_be) { >>> + mop |= MO_BE; >>> + } >> >> MO_BSWAP is host dependent -- needs >> >> mop |= (s->nv2_mem_be ? MO_BE : MO_LE); > > Fixed. > > With those two fixes, can I have a reviewed-by? This is the > only patch without one, and all the fixes seem to me like > very minor things not worth sending out a full v2 for. Reviewed-by: Richard Henderson <richard.henderson@linaro.org> r~
diff --git a/target/arm/cpregs.h b/target/arm/cpregs.h index cb795bed75b..b6fdd0f3eb4 100644 --- a/target/arm/cpregs.h +++ b/target/arm/cpregs.h @@ -826,6 +826,11 @@ typedef void CPResetFn(CPUARMState *env, const ARMCPRegInfo *opaque); #define CP_ANY 0xff +/* Flags in the high bits of nv2_redirect_offset */ +#define NV2_REDIR_NV1 0x4000 /* Only redirect when HCR_EL2.NV1 == 1 */ +#define NV2_REDIR_NO_NV1 0x8000 /* Only redirect when HCR_EL2.NV1 == 0 */ +#define NV2_REDIR_FLAG_MASK 0xc000 + /* Definition of an ARM coprocessor register */ struct ARMCPRegInfo { /* Name of register (useful mainly for debugging, need not be unique) */ @@ -867,6 +872,13 @@ struct ARMCPRegInfo { * value encodes both the trap register and bit within it. */ FGTBit fgt; + + /* + * Offset from VNCR_EL2 when FEAT_NV2 redirects access to memory; + * may include an NV2_REDIR_* flag. + */ + uint32_t nv2_redirect_offset; + /* * The opaque pointer passed to define_arm_cp_regs_with_opaque() when * this register was defined: can be used to hand data through to the diff --git a/target/arm/cpu.h b/target/arm/cpu.h index e60b4f34fe4..bc4fa95ea35 100644 --- a/target/arm/cpu.h +++ b/target/arm/cpu.h @@ -3244,6 +3244,10 @@ FIELD(TBFLAG_A64, ATA0, 31, 1) FIELD(TBFLAG_A64, NV, 32, 1) FIELD(TBFLAG_A64, NV1, 33, 1) FIELD(TBFLAG_A64, NV2, 34, 1) +/* Set if FEAT_NV2 RAM accesses use the EL2&0 translation regime */ +FIELD(TBFLAG_A64, NV2_MEM_E20, 35, 1) +/* Set if FEAT_NV2 RAM accesses are big-endian */ +FIELD(TBFLAG_A64, NV2_MEM_BE, 36, 1) /* * Helpers for using the above. Note that only the A64 accessors use diff --git a/target/arm/tcg/translate.h b/target/arm/tcg/translate.h index 9e13c4ef7b6..93be745cf33 100644 --- a/target/arm/tcg/translate.h +++ b/target/arm/tcg/translate.h @@ -150,6 +150,10 @@ typedef struct DisasContext { bool nv1; /* True if NV enabled and HCR_EL2.NV2 is set */ bool nv2; + /* True if NV2 enabled and NV2 RAM accesses use EL2&0 translation regime */ + bool nv2_mem_e20; + /* True if NV2 enabled and NV2 RAM accesses are big-endian */ + bool nv2_mem_be; /* * >= 0, a copy of PSTATE.BTYPE, which will be 0 without v8.5-BTI. * < 0, set by the current instruction. @@ -165,6 +169,8 @@ typedef struct DisasContext { int c15_cpar; /* TCG op of the current insn_start. */ TCGOp *insn_start; + /* Offset from VNCR_EL2 when FEAT_NV2 redirects this reg to memory */ + uint32_t nv2_redirect_offset; } DisasContext; typedef struct DisasCompare { diff --git a/target/arm/tcg/hflags.c b/target/arm/tcg/hflags.c index d2b352663e8..8e5d35d9227 100644 --- a/target/arm/tcg/hflags.c +++ b/target/arm/tcg/hflags.c @@ -307,6 +307,12 @@ static CPUARMTBFlags rebuild_hflags_a64(CPUARMState *env, int el, int fp_el, } if (hcr & HCR_NV2) { DP_TBFLAG_A64(flags, NV2, 1); + if (hcr & HCR_E2H) { + DP_TBFLAG_A64(flags, NV2_MEM_E20, 1); + } + if (env->cp15.sctlr_el[2] & SCTLR_EE) { + DP_TBFLAG_A64(flags, NV2_MEM_BE, 1); + } } } diff --git a/target/arm/tcg/translate-a64.c b/target/arm/tcg/translate-a64.c index 6909c9df30d..128bff4b445 100644 --- a/target/arm/tcg/translate-a64.c +++ b/target/arm/tcg/translate-a64.c @@ -2134,6 +2134,7 @@ static void handle_sys(DisasContext *s, bool isread, bool nv_trap_to_el2 = false; bool nv_redirect_reg = false; bool skip_fp_access_checks = false; + bool nv2_mem_redirect = false; TCGv_ptr tcg_ri = NULL; TCGv_i64 tcg_rt; uint32_t syndrome = syn_aa64_sysregtrap(op0, op1, op2, crn, crm, rt, isread); @@ -2166,6 +2167,21 @@ static void handle_sys(DisasContext *s, bool isread, return; } + if (s->nv && s->nv2 && ri->nv2_redirect_offset) { + /* + * Some registers always redirect to memory; some only do so if + * HCR_EL2.NV1 is 0, and some only if NV1 is 1 (these come in + * pairs which share an offset; see the table in R_CSRPQ). + */ + if (ri->nv2_redirect_offset & NV2_REDIR_NV1) { + nv2_mem_redirect = s->nv1; + } else if (ri->nv2_redirect_offset & NV2_REDIR_NO_NV1) { + nv2_mem_redirect = !s->nv1; + } else { + nv2_mem_redirect = true; + } + } + /* Check access permissions */ if (!cp_access_ok(s->current_el, ri, isread)) { /* @@ -2181,6 +2197,12 @@ static void handle_sys(DisasContext *s, bool isread, * the EL2 register's accessfn. */ nv_redirect_reg = true; + assert(!nv2_mem_redirect); + } else if (nv2_mem_redirect) { + /* + * NV2 redirect-to-memory takes precedence over trap to EL2 or + * UNDEF to EL1. + */ } else if (s->nv && arm_cpreg_traps_in_nv(ri)) { /* * This register / instruction exists and is an EL2 register, so @@ -2254,6 +2276,40 @@ static void handle_sys(DisasContext *s, bool isread, assert(!(ri->type & ARM_CP_RAISES_EXC)); } + if (nv2_mem_redirect) { + /* + * This system register is being redirected into an EL2 memory access. + * This means it is not an IO operation, doesn't change hflags, + * and need not end the TB, because it has no side effects. + * + * The access is 64-bit single copy atomic, guaranteed aligned because + * of the definition of VCNR_EL2. Its endianness depends on + * SCTLR_EL2.EE, not on the data endianness of EL1. + * It is done under either the EL2 translation regime or the EL2&0 + * translation regime, depending on HCR_EL2.E2H. It behaves as if + * PSTATE.PAN is 0. + */ + TCGv_i64 ptr = tcg_temp_new_i64(); + MemOp mop = MO_64 | MO_ALIGN | MO_ATOM_IFALIGN; + ARMMMUIdx armmemidx = s->nv2_mem_e20 ? ARMMMUIdx_E20_2 : ARMMMUIdx_E2; + int memidx = arm_to_core_mmu_idx(armmemidx); + + if (s->nv2_mem_be) { + mop |= MO_BE; + } + + tcg_gen_ld_i64(ptr, tcg_env, offsetof(CPUARMState, cp15.vncr_el2)); + tcg_gen_addi_i64(ptr, ptr, + (ri->nv2_redirect_offset & ~NV2_REDIR_FLAG_MASK)); + tcg_rt = cpu_reg(s, rt); + if (isread) { + tcg_gen_qemu_ld_i64(tcg_rt, ptr, memidx, mop); + } else { + tcg_gen_qemu_st_i64(tcg_rt, ptr, memidx, mop); + } + return; + } + /* Handle special cases first */ switch (ri->type & ARM_CP_SPECIAL_MASK) { case 0: @@ -14062,6 +14118,8 @@ static void aarch64_tr_init_disas_context(DisasContextBase *dcbase, dc->nv = EX_TBFLAG_A64(tb_flags, NV); dc->nv1 = EX_TBFLAG_A64(tb_flags, NV1); dc->nv2 = EX_TBFLAG_A64(tb_flags, NV2); + dc->nv2_mem_e20 = EX_TBFLAG_A64(tb_flags, NV2_MEM_E20); + dc->nv2_mem_be = EX_TBFLAG_A64(tb_flags, NV2_MEM_BE); dc->vec_len = 0; dc->vec_stride = 0; dc->cp_regs = arm_cpu->cp_regs;
FEAT_NV2 requires that when HCR_EL2.{NV,NV2} == 0b11 then accesses by EL1 to certain system registers are redirected to RAM. The full list of affected registers is in the table in rule R_CSRPQ in the Arm ARM. The registers may be normally accessible at EL1 (like ACTLR_EL1), or normally UNDEF at EL1 (like HCR_EL2). Some registers redirect to RAM only when HCR_EL2.NV1 is 0, and some only when HCR_EL2.NV1 is 1; others trap in both cases. Add the infrastructure for identifying which registers should be redirected and turning them into memory accesses. This code does not set the correct syndrome or arrange for the exception to be taken to the correct target EL if the access via VNCR_EL2 faults; we will do that in the next commit. Subsequent commits will mark up the relevant regdefs to set their nv2_redirect_offset, and if relevant one of the two flags which indicates that the redirect happens only for a particular value of HCR_EL2.NV1. Signed-off-by: Peter Maydell <peter.maydell@linaro.org> --- target/arm/cpregs.h | 12 +++++++ target/arm/cpu.h | 4 +++ target/arm/tcg/translate.h | 6 ++++ target/arm/tcg/hflags.c | 6 ++++ target/arm/tcg/translate-a64.c | 58 ++++++++++++++++++++++++++++++++++ 5 files changed, 86 insertions(+)