Upstream more RISC-V fork patches
cover Upstream more RISC-V fork patches
This is one of the big patches that the RISC-V fork has that we don't. After this it should be straight forward to upstream the remaining patches.
Michael Clark (3):
RISC-V: Implement modular CSR helper interface
RISC-V: Implement atomic mip/sip CSR updates
RISC-V: Implement existential predicates for CSRs
target/riscv/Makefile.objs | 2 +- target/riscv/cpu.c | 6 + target/riscv/cpu.h | 41 +- target/riscv/cpu_helper.c | 7 +- target/riscv/csr.c | 863 +++++++++++++++++++++++++++++++++++++ target/riscv/gdbstub.c | 10 +- target/riscv/op_helper.c | 613 +------------------------- 7 files changed, 933 insertions(+), 609 deletions(-) create mode 100644 target/riscv/csr.c
Signature · 1 line
2.19.1
PATCH 1/3 RISC-V: Implement modular CSR helper interface
From: Michael Clark <[email protected]>
Previous CSR code uses csr_read_helper and csr_write_helper to update CSR registers however this interface prevents atomic read/modify/write CSR operations; in addition there is no trap-free method to access to CSRs due to the monolithic CSR functions call longjmp.
The current iCSR interface is not safe to be called by target/riscv/gdbstub.c as privilege checks or missing CSRs may call longjmp to generate exceptions. It needs to indicate existence so traps can be generated in the CSR instruction helpers.
This commit moves CSR access from the monolithic switch statements in target/riscv/op_helper.c into modular read/write functions in target/riscv/csr.c using a new function pointer table for dispatch (which can later be used to allow CPUs to hook up model specific CSRs).
A read/modify/write interface is added to support atomic CSR operations and a non-trapping interface is added to allow exception-free access to CSRs by the debugger.
The CSR functions and CSR dispatch table are ordered to match The RISC-V Instruction Set Manual, Volume II:
Privileged Architecture Version 1.10, 2.2 CSR Listing.
An API is added to allow derived cpu instances to modify or implement new CSR operations.
--- target/riscv/Makefile.objs | 2 +- target/riscv/cpu.h | 35 +- target/riscv/cpu_helper.c | 4 +- target/riscv/csr.c | 846 +++++++++++++++++++++++++++++++++++++ target/riscv/gdbstub.c | 10 +- target/riscv/op_helper.c | 613 +-------------------------- 6 files changed, 904 insertions(+), 606 deletions(-) create mode 100644 target/riscv/csr.c
target/riscv/Makefile.objs +1 -1
@@ -1 +1 @@ -obj-y += translate.o op_helper.o cpu_helper.o cpu.o fpu_helper.o gdbstub.o pmp.o +obj-y += translate.o op_helper.o cpu_helper.o cpu.o csr.o fpu_helper.o gdbstub.o pmp.o
target/riscv/cpu.h +32 -3
@@ -289,9 +289,38 @@ static inline void cpu_get_tb_cpu_state(CPURISCVState *env, target_ulong *pc,#endif } -void csr_write_helper (CPURISCVState *env,target_ulong val_to_write, -target_ulong csrno); -target_ulong csr_read_helper (CPURISCVState *env,target_ulong csrno); +int riscv_csrrw (CPURISCVState *env,int csrno,target_ulong *ret_value, +target_ulong new_value,target_ulong write_mask); + +static inline void csr_write_helper (CPURISCVState *env,target_ulong val, +int csrno) +{ +riscv_csrrw (env, csrno,NULL , val,MAKE_64BIT_MASK (0 ,TARGET_LONG_BITS )); +} + +static inline target_ulong csr_read_helper (CPURISCVState *env,int csrno) +{ +target_ulong val =0 ; +riscv_csrrw (env, csrno, &val,0 ,0 ); +return val; +} + +typedef int (*riscv_csr_predicate_fn )(CPURISCVState *env,int csrno); +typedef int (*riscv_csr_read_fn )(CPURISCVState *env,int csrno, +target_ulong *ret_value); +typedef int (*riscv_csr_write_fn )(CPURISCVState *env,int csrno, +target_ulong new_value); +typedef int (*riscv_csr_op_fn )(CPURISCVState *env,int csrno, +target_ulong *ret_value,target_ulong new_value,target_ulong write_mask); + +typedef struct { +riscv_csr_read_fn read; +riscv_csr_write_fn write; +riscv_csr_op_fn op; +}riscv_csr_operations ; + +void riscv_get_csr_ops (int csrno,riscv_csr_operations *ops); +void riscv_set_csr_ops (int csrno,riscv_csr_operations *ops);#include "exec/cpu-all.h"
target/riscv/cpu_helper.c +2 -2
@@ -528,7 +528,7 @@ void riscv_cpu_do_interrupt(CPUState *cs) get_field(s, MSTATUS_SIE) : get_field(s, MSTATUS_UIE << env->priv)); s =set_field (s,MSTATUS_SPP , env->priv); s =set_field (s,MSTATUS_SIE ,0 ); -csr_write_helper (env, s,CSR_MSTATUS ); + env->mstatus = s;riscv_set_mode (env,PRV_S ); }else {/* No need to check MTVEC for misaligned - lower 2 bits cannot be set */
@@ -553,7 +553,7 @@ void riscv_cpu_do_interrupt(CPUState *cs) get_field(s, MSTATUS_MIE) : get_field(s, MSTATUS_UIE << env->priv)); s =set_field (s,MSTATUS_MPP , env->priv); s =set_field (s,MSTATUS_MIE ,0 ); -csr_write_helper (env, s,CSR_MSTATUS ); + env->mstatus = s;riscv_set_mode (env,PRV_M ); }/* TODO yield load reservation */
target/riscv/csr.c new file +846 -0
846 lines not on this page · raw message
target/riscv/gdbstub.c +8 -2
@@ -33,7 +33,10 @@ int riscv_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n) }else if (n <65 ) {return gdb_get_reg64 (mem_buf, env->fpr[n -33 ]); }else if (n <4096 +65 ) { -return gdb_get_regl (mem_buf,csr_read_helper (env, n -65 )); +target_ulong val =0 ; +if (riscv_csrrw (env, n -65 , &val,0 ,0 ) ==0 ) { +return gdb_get_regl (mem_buf, val); + } }return 0 ; }
@@ -56,7 +59,10 @@ int riscv_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n) env->fpr[n -33 ] =ldq_p (mem_buf);/* always 64-bit */ return sizeof (uint64_t ); }else if (n <4096 +65 ) { -csr_write_helper (env,ldtul_p (mem_buf), n -65 ); +target_ulong val =ldtul_p (mem_buf); +if (riscv_csrrw (env, n -65 ,NULL , val,-1 ) ==0 ) { +return sizeof (target_ulong); + } }return 0 ; }
target/riscv/op_helper.c +15 -598
652 lines not on this page · raw message
Signature · 1 line
2.19.1
PATCH 2/3 RISC-V: Implement atomic mip/sip CSR updates
In reply to Alistair FrancisFrom: Michael Clark <[email protected]>
Use the new CSR read/modify/write interface to implement atomic updates to mip/sip.
--- target/riscv/csr.c | 56 +++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 28 deletions(-)
target/riscv/csr.c +28 -28
@@ -487,25 +487,31 @@ static int write_mbadaddr(CPURISCVState *env, int csrno, target_ulong val)return 0 ; } -static int read_mip (CPURISCVState *env,int csrno,target_ulong *val) -{ - *val =atomic_read (&env->mip); -return 0 ; -} - -static int write_mip (CPURISCVState *env,int csrno,target_ulong val) +static int rmw_mip (CPURISCVState *env,int csrno,target_ulong *ret_value, +target_ulong new_value,target_ulong write_mask) {RISCVCPU *cpu =riscv_env_get_cpu (env); +target_ulong mask = write_mask & delegable_ints; +uint32_t old_mip; + +/* We can't allow the supervisor to control SEIP as this would allow the +* supervisor to clear a pending external interrupt which will result in +* lost a interrupt in the case a PLIC is attached. The SEIP bit must be +* hardware controlled when a PLIC is attached. This should be an option +* for CPUs with software-delegated Supervisor External Interrupts. */ + mask &= ~MIP_SEIP ; + +if (mask) { +qemu_mutex_lock_iothread (); + old_mip =riscv_cpu_update_mip (cpu, mask, (new_value & mask)); +qemu_mutex_unlock_iothread (); + }else { + old_mip =atomic_read (&env->mip); + } -/* -* csrs, csrc on mip.SEIP is not decomposable into separate read and -* write steps, so a different implementation is needed -*/ - -qemu_mutex_lock_iothread (); -riscv_cpu_update_mip (cpu,MIP_SSIP |MIP_STIP , - (val & (MIP_SSIP |MIP_STIP ))); -qemu_mutex_unlock_iothread (); +if (ret_value) { + *ret_value = old_mip; + }return 0 ; }
@@ -623,17 +629,11 @@ static int write_sbadaddr(CPURISCVState *env, int csrno, target_ulong val)return 0 ; } -static int read_sip (CPURISCVState *env,int csrno,target_ulong *val) -{ - *val =atomic_read (&env->mip) & env->mideleg; -return 0 ; -} - -static int write_sip (CPURISCVState *env,int csrno,target_ulong val) +static int rmw_sip (CPURISCVState *env,int csrno,target_ulong *ret_value, +target_ulong new_value,target_ulong write_mask) { -target_ulong newval = (atomic_read (&env->mip) & ~env->mideleg) - | (val & env->mideleg); -return write_mip (env,CSR_MIP , newval); +return rmw_mip (env,CSR_MSTATUS , ret_value, new_value, + write_mask & env->mideleg); }/* Supervisor Protection and Translation */
@@ -812,7 +812,7 @@ static riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { [CSR_MEPC] = { read_mepc, write_mepc }, [CSR_MCAUSE] = { read_mcause, write_mcause }, [CSR_MBADADDR] = { read_mbadaddr, write_mbadaddr }, - [CSR_MIP] = { read_mip, write_mip }, + [CSR_MIP] = { NULL, NULL, rmw_mip }, /* Supervisor Trap Setup */ [CSR_SSTATUS] = { read_sstatus, write_sstatus },
@@ -825,7 +825,7 @@ static riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { [CSR_SEPC] = { read_sepc, write_sepc }, [CSR_SCAUSE] = { read_scause, write_scause }, [CSR_SBADADDR] = { read_sbadaddr, write_sbadaddr }, - [CSR_SIP] = { read_sip, write_sip }, + [CSR_SIP] = { NULL, NULL, rmw_sip }, /* Supervisor Protection and Translation */ [CSR_SATP] = { read_satp, write_satp },
Signature · 1 line
2.19.1
PATCH 3/3 RISC-V: Implement existential predicates for CSRs
In reply to Alistair FrancisFrom: Michael Clark <[email protected]>
CSR predicate functions are added to the CSR table. mstatus.FS and counter enable checks are moved to predicate functions and two new predicates are added to check misa.S for s* CSRs and a new PMP CPU feature for pmp* CSRs.
Processors that don't implement S-mode will trap on access to s* CSRs and processors that don't implement PMP will trap on accesses to pmp* CSRs.
PMP checks are disabled in riscv_cpu_handle_mmu_fault when the PMP CPU feature is not present.
--- target/riscv/cpu.c | 6 ++ target/riscv/cpu.h | 6 +- target/riscv/cpu_helper.c | 3 +- target/riscv/csr.c | 169 +++++++++++++++++++++----------------- 4 files changed, 105 insertions(+), 79 deletions(-)
target/riscv/cpu.c +6 -0
@@ -126,6 +126,7 @@ static void rv32gcsu_priv1_09_1_cpu_init(Object *obj)set_versions (env,USER_VERSION_2_02_0 ,PRIV_VERSION_1_09_1 );set_resetvec (env,DEFAULT_RSTVEC );set_feature (env,RISCV_FEATURE_MMU ); +set_feature (env,RISCV_FEATURE_PMP ); }static void rv32gcsu_priv1_10_0_cpu_init (Object *obj)
@@ -135,6 +136,7 @@ static void rv32gcsu_priv1_10_0_cpu_init(Object *obj)set_versions (env,USER_VERSION_2_02_0 ,PRIV_VERSION_1_10_0 );set_resetvec (env,DEFAULT_RSTVEC );set_feature (env,RISCV_FEATURE_MMU ); +set_feature (env,RISCV_FEATURE_PMP ); }static void rv32imacu_nommu_cpu_init (Object *obj)
@@ -143,6 +145,7 @@ static void rv32imacu_nommu_cpu_init(Object *obj)set_misa (env,RV32 |RVI |RVM |RVA |RVC |RVU );set_versions (env,USER_VERSION_2_02_0 ,PRIV_VERSION_1_10_0 );set_resetvec (env,DEFAULT_RSTVEC ); + set_feature(env, RISCV_FEATURE_PMP); }#elif defined(TARGET_RISCV64)
@@ -154,6 +157,7 @@ static void rv64gcsu_priv1_09_1_cpu_init(Object *obj)set_versions (env,USER_VERSION_2_02_0 ,PRIV_VERSION_1_09_1 );set_resetvec (env,DEFAULT_RSTVEC );set_feature (env,RISCV_FEATURE_MMU ); +set_feature (env,RISCV_FEATURE_PMP ); }static void rv64gcsu_priv1_10_0_cpu_init (Object *obj)
@@ -163,6 +167,7 @@ static void rv64gcsu_priv1_10_0_cpu_init(Object *obj)set_versions (env,USER_VERSION_2_02_0 ,PRIV_VERSION_1_10_0 );set_resetvec (env,DEFAULT_RSTVEC );set_feature (env,RISCV_FEATURE_MMU ); +set_feature (env,RISCV_FEATURE_PMP ); }static void rv64imacu_nommu_cpu_init (Object *obj)
@@ -171,6 +176,7 @@ static void rv64imacu_nommu_cpu_init(Object *obj)set_misa (env,RV64 |RVI |RVM |RVA |RVC |RVU );set_versions (env,USER_VERSION_2_02_0 ,PRIV_VERSION_1_10_0 );set_resetvec (env,DEFAULT_RSTVEC ); + set_feature(env, RISCV_FEATURE_PMP); }#endif
target/riscv/cpu.h +4 -2
@@ -83,9 +83,10 @@/* S extension denotes that Supervisor mode exists, however it is possible to have a core that support S mode but does not have an MMU and there is currently no bit in misa to indicate whether an MMU exists or not -so a cpu features bitfield is required */ +so a cpu features bitfield is required, likewise for optional PMP support */ enum { -RISCV_FEATURE_MMU +RISCV_FEATURE_MMU , +RISCV_FEATURE_PMP };#define USER_VERSION_2_02_0 0x00020200
@@ -314,6 +315,7 @@ typedef int (*riscv_csr_op_fn)(CPURISCVState *env, int csrno, target_ulong *ret_value, target_ulong new_value, target_ulong write_mask); typedef struct { + riscv_csr_predicate_fn predicate; riscv_csr_read_fn read; riscv_csr_write_fn write; riscv_csr_op_fn op;
target/riscv/cpu_helper.c +2 -1
@@ -404,7 +404,8 @@ int riscv_cpu_handle_mmu_fault(CPUState *cs, vaddr address, int size,qemu_log_mask (CPU_LOG_MMU ,"%s address=%" VADDR_PRIx" ret %d physical " TARGET_FMT_plx" prot %d\n" , __func__, address, ret, pa, prot); -if (!pmp_hart_has_privs (env, pa,TARGET_PAGE_SIZE ,1 << rw)) { +if (riscv_feature (env,RISCV_FEATURE_PMP ) && + !pmp_hart_has_privs (env, pa,TARGET_PAGE_SIZE ,1 << rw)) { ret =TRANSLATE_FAIL ; }if (ret ==TRANSLATE_SUCCESS ) {
target/riscv/csr.c +93 -76
236 lines not on this page · raw message
Signature · 1 line
2.19.1
Quoted 8 lines · Alistair Francis
This is one of the big patches that the RISC-V fork has that we don't. After this it should be straight forward to upstream the remaining patches.
Michael Clark (3):
RISC-V: Implement modular CSR helper interface
RISC-V: Implement atomic mip/sip CSR updates
RISC-V: Implement existential predicates for CSRs
r~