Add RISC-V Hypervisor Extension v0.4
Subsystems (2)
v2 cover Add RISC-V Hypervisor Extension v0.4
This patch series adds the RISC-V Hypervisor extension v0.4. This is the latest draft spec of the Hypervisor extension.
The Hypervisor extension is disabled by default, so this series should result in no changes to anyone using QEMU unless they enable the extension. The extention can be enabled with the -cpu property (see below).
At the moment the spec does not include information about the mstatush register. Although this information has since been merged into the master spec. As it is only adding support for 32-bit I have added this register to this series.
Testing of this implementation has been done by using the baremetal Xvisor Hypervisor. We are able to run two Linux guests (that's all I have tried) as guests in 64-bit. In 32-bit so far I can only run baremetal guests, but I think this is a baremetal boot loader issue and not an issue in QEMU.
The RISC-V KVM implementation was also written using these patches. The KVM implementation is currently under review.
These patches result in a reproducable race when booting a SMP Linux guest inside a SMP Linux KVM host. This will need to be fixed.
At the moment this spec is in a draft state and is subject to change. As QEMU is extreamly useful in early bring up I think it makes sense for QEMU to support non-frozen extensions.
Thanks to Anup for doing the initial port of Xvisor. The port is avaliable here:
https://github.com/avpatel/xvisor-next and will run on QEMU.
Also thanks to Atish for implementing the SBI call support in Xvisor and for lots of help debugging.
To run this yourself:
1. Apply this patch series to QEMU. The latest branch can be found here:
https://github.com/alistair23/qemu/tree/mainline/alistair/riscv-hyp-ext-v0.4.next
2. Get the version of OpenSBI that supports the H extension. This can be found here:
https://github.com/riscv/opensbi/tree/hyp_ext_changes_v1
3. Build the next release of Xvisor. It is available here:
https://github.com/avpatel/xvisor-next
4. Make sure you build the Xvisor tests, see here for details:
https://github.com/avpatel/xvisor-next/tree/master/tests/riscv/virt64/linux
5. Run QEMU:
./riscv64-softmmu/qemu-system-riscv64 -nographic \
-machine virt -cpu rv64,x-h=true \
-serial mon:stdio -serial null -m 4G \
-device loader,file=vmm.bin,addr=0x80200000 \
-kernel fw_jump.elf \
-initrd vmm-disk-linux.img \
-append "vmm.console=uart@10000000 vmm.bootcmd=\"vfs mount initrd /;vfs run /boot.xscript;vfs cat /system/banner.txt\"" Once you get to the prompt you can start the geust by running:
guest kick guest0
You can then bind to the serial port using:
vserial bind guest0/uart0
Then you can start Linux using:
autoexec
This was all tested with the mainline 5.2/5.3 kernels.
There is very early work on a Xen port as well which is avaliable here:
https://github.com/alistair23/xen/tree/alistair/riscv-port
ToDo/Issues
- Get 32-bit fully working
This series is based on Palmers for-master branch:
https://github.com/palmer-dabbelt/qemu/commits/for-master
v2:
- Rebase on for-master
- Consolidate patches requested by Palmer
- Other updates based on feedback
Alistair Francis (27):
target/riscv: Don't set write permissions on dirty PTEs target/riscv: Add the Hypervisor extension target/riscv: Add the virtulisation mode target/riscv: Add the force HS exception mode target/riscv: Fix CSR perm checking for HS mode target/riscv: Add the Hypervisor CSRs to CPUState target/riscv: Print priv and virt in disas log target/riscv: Dump Hypervisor registers if enabled target/riscv: Add Hypervisor CSR access functions target/riscv: Add Hypervisor virtual CSRs accesses target/riscv: Convert mie and mstatus to pointers target/riscv: Add virtual register swapping function target/riscv: Add support for virtual interrupt setting target/ricsv: Flush the TLB on virtulisation mode changes target/riscv: Generate illegal instruction on WFI when V=1
riscv: plic: Always set sip.SEIP bit for HS target/riscv: Add hypvervisor trap support target/riscv: Add Hypervisor trap return support target/riscv: Add hfence instructions
target/riscv: Disable guest FP support based on virtual status target/riscv: Mark both sstatus and vsstatus as dirty target/riscv: Respect MPRV and SPRV for floating point ops target/riscv: Allow specifying MMU stage target/riscv: Implement second stage MMU target/riscv: Add support for the 32-bit MSTATUSH CSR target/riscv: Add the MSTATUS_MPV_ISSET helper macro target/riscv: Allow enabling the Hypervisor extension
hw/riscv/sifive_plic.c | 12 +- target/riscv/cpu.c | 61 ++- target/riscv/cpu.h | 55 +- target/riscv/cpu_bits.h | 45 +- target/riscv/cpu_helper.c | 481 ++++++++++++++++-- target/riscv/csr.c | 262 +++++++++- target/riscv/insn32.decode | 23 +- .../riscv/insn_trans/trans_privileged.inc.c | 40 ++ target/riscv/op_helper.c | 81 ++- target/riscv/translate.c | 34 ++ 10 files changed, 988 insertions(+), 106 deletions(-)
Signature · 1 line
2.23.0
PATCH v2 1/27 target/riscv: Don't set write permissions on dirty PTEs
Setting write permission on dirty PTEs results in userspace inside a Hypervisor guest (VU) becoming corrupted. This appears to be because it ends up with write permission in the second stage translation in cases where we aren't doing a store.
--- target/riscv/cpu_helper.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
target/riscv/cpu_helper.c +2 -4
@@ -344,10 +344,8 @@ restart:if ((pte &PTE_X )) { *prot |=PAGE_EXEC ; } -/* add write permission on stores or if the page is already dirty, -so that we TLB miss on later writes to update the dirty bit */ -if ((pte &PTE_W ) && - (access_type ==MMU_DATA_STORE || (pte &PTE_D ))) { +/* add write permission on stores */ +if ((pte &PTE_W ) && (access_type ==MMU_DATA_STORE )) { *prot |=PAGE_WRITE ; }return TRANSLATE_SUCCESS ;
Signature · 1 line
2.23.0
PATCH v2 2/27 target/riscv: Add the Hypervisor extension
In reply to Alistair Francis--- target/riscv/cpu.h | 1 + 1 file changed, 1 insertion(+)
target/riscv/cpu.h +1 -0
@@ -67,6 +67,7 @@#define RVC RV('C')#define RVS RV('S')#define RVU RV('U') +#define RVH RV('H')/* 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
Signature · 1 line
2.23.0
PATCH v2 3/27 target/riscv: Add the virtulisation mode
In reply to Alistair Francis--- target/riscv/cpu.h | 4 ++++ target/riscv/cpu_bits.h | 3 +++ target/riscv/cpu_helper.c | 18 ++++++++++++++++++ 3 files changed, 25 insertions(+)
target/riscv/cpu.h +4 -0
@@ -117,6 +117,8 @@ struct CPURISCVState {#ifndef CONFIG_USER_ONLY target_ulong priv; +/* This contains QEMU specific information about the virt state. */ +target_ulong virt;target_ulong resetvec;target_ulong mhartid;
@@ -248,6 +250,8 @@ int riscv_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);int riscv_cpu_gdb_write_register (CPUState *cpu,uint8_t *buf,int reg);bool riscv_cpu_exec_interrupt (CPUState *cs,int interrupt_request);bool riscv_cpu_fp_enabled (CPURISCVState *env); +bool riscv_cpu_virt_enabled (CPURISCVState *env); +void riscv_cpu_set_virt_enabled (CPURISCVState *env,bool enable);int riscv_cpu_mmu_index (CPURISCVState *env,bool ifetch);hwaddr riscv_cpu_get_phys_page_debug (CPUState *cpu,vaddr addr); void riscv_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
target/riscv/cpu_bits.h +3 -0
@@ -422,6 +422,9 @@#define PRV_H 2/* Reserved */ #define PRV_M 3 +/* Virtulisation Register Fields */ +#define VIRT_ONOFF 1 +/* RV32 satp CSR field masks */ #define SATP32_MODE 0x80000000#define SATP32_ASID 0x7fc00000
target/riscv/cpu_helper.c +18 -0
@@ -82,6 +82,24 @@ bool riscv_cpu_fp_enabled(CPURISCVState *env)return false; } +bool riscv_cpu_virt_enabled (CPURISCVState *env) +{ +if (!riscv_has_ext (env,RVH )) { +return false; + } + +return get_field (env->virt,VIRT_ONOFF ); +} + +void riscv_cpu_set_virt_enabled (CPURISCVState *env,bool enable) +{ +if (!riscv_has_ext (env,RVH )) { +return ; + } + + env->virt =set_field (env->virt,VIRT_ONOFF , enable); +} +int riscv_cpu_claim_interrupts (RISCVCPU *cpu,uint32_t interrupts) {CPURISCVState *env = &cpu->env;
Signature · 1 line
2.23.0
PATCH v2 4/27 target/riscv: Add the force HS exception mode
In reply to Alistair FrancisAdd a FORCE_HS_EXCEP mode to the RISC-V virtulisation status. This bit specifies if an exeption should be taken to HS mode no matter the current delegation status. This is used when an exeption must be taken to HS mode, such as when a second level page fault occurs.
--- target/riscv/cpu.h | 2 ++ target/riscv/cpu_bits.h | 6 ++++++ target/riscv/cpu_helper.c | 18 ++++++++++++++++++ 3 files changed, 26 insertions(+)
target/riscv/cpu.h +2 -0
@@ -252,6 +252,8 @@ bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request);bool riscv_cpu_fp_enabled (CPURISCVState *env);bool riscv_cpu_virt_enabled (CPURISCVState *env);void riscv_cpu_set_virt_enabled (CPURISCVState *env,bool enable); +bool riscv_cpu_force_hs_excep_enabled (CPURISCVState *env); +void riscv_cpu_set_force_hs_excep (CPURISCVState *env,bool enable);int riscv_cpu_mmu_index (CPURISCVState *env,bool ifetch);hwaddr riscv_cpu_get_phys_page_debug (CPUState *cpu,vaddr addr); void riscv_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
target/riscv/cpu_bits.h +6 -0
@@ -424,6 +424,12 @@/* Virtulisation Register Fields */ #define VIRT_ONOFF 1 +/* This is used to save state for when we take an exception. If this is set +* that means that we want to force a HS level exception (no matter what the +* delegation is set to). This will occur for things such as a second level +* page table fault. +*/ +#define FORCE_HS_EXCEP 2/* RV32 satp CSR field masks */ #define SATP32_MODE 0x80000000
target/riscv/cpu_helper.c +18 -0
@@ -100,6 +100,24 @@ void riscv_cpu_set_virt_enabled(CPURISCVState *env, bool enable) env->virt =set_field (env->virt,VIRT_ONOFF , enable); } +bool riscv_cpu_force_hs_excep_enabled (CPURISCVState *env) +{ +if (!riscv_has_ext (env,RVH )) { +return false; + } + +return get_field (env->virt,FORCE_HS_EXCEP ); +} + +void riscv_cpu_set_force_hs_excep (CPURISCVState *env,bool enable) +{ +if (!riscv_has_ext (env,RVH )) { +return ; + } + + env->virt =set_field (env->virt,FORCE_HS_EXCEP , enable); +} +int riscv_cpu_claim_interrupts (RISCVCPU *cpu,uint32_t interrupts) {CPURISCVState *env = &cpu->env;
Signature · 1 line
2.23.0
PATCH v2 5/27 target/riscv: Fix CSR perm checking for HS mode
In reply to Alistair FrancisUpdate the CSR permission checking to work correctly when we are in HS-mode.
--- target/riscv/csr.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
target/riscv/csr.c +14 -4
@@ -799,12 +799,22 @@ int riscv_csrrw(CPURISCVState *env, int csrno, target_ulong *ret_value,/* check privileges and return -1 if check fails */ #if !defined(CONFIG_USER_ONLY ) -int csr_priv =get_field (csrno,0x300 ); +int effective_priv = env->priv;int read_only =get_field (csrno,0xC00 ) ==3 ; -if ((!env->debugger) && (env->priv < csr_priv)) { -return -1 ; + +if (riscv_has_ext (env,RVH ) && + env->priv ==PRV_S && + !riscv_cpu_virt_enabled (env)) { +/* +* We are in S mode without virtualisation, therefore we are in HS Mode. +* Add 1 to the effective privledge level to allow us to access the +* Hypervisor CSRs. +*/ + effective_priv++; } -if (write_mask && read_only) { + +if ((write_mask && read_only) || + (!env->debugger && (effective_priv <get_field (csrno,0x300 )))) {return -1 ; }#endif
Signature · 1 line
2.23.0
PATCH v2 6/27 target/riscv: Add the Hypervisor CSRs to CPUState
In reply to Alistair FrancisAs the MIP CSR is 32-bits to allow atomic_read on 32-bit hosts the vsip is 32-bit as well.
--- target/riscv/cpu.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
target/riscv/cpu.h +17 -0
@@ -145,6 +145,23 @@ struct CPURISCVState {target_ulong mcause;target_ulong mtval;/* since: priv-1.10.0 */ +/* Hypervisor CSRs */ +target_ulong hstatus; +target_ulong hedeleg; +target_ulong hideleg; +target_ulong hgatp; + +/* Virtual CSRs */ +target_ulong vsstatus; +uint32_t vsip; +target_ulong vsie; +target_ulong vstvec; +target_ulong vsscratch; +target_ulong vsepc; +target_ulong vscause; +target_ulong vstval; +target_ulong vsatp; +target_ulong scounteren;target_ulong mcounteren;
Signature · 1 line
2.23.0
PATCH v2 7/27 target/riscv: Print priv and virt in disas log
In reply to Alistair Francis--- target/riscv/translate.c | 8 ++++++++ 1 file changed, 8 insertions(+)
target/riscv/translate.c +8 -0
@@ -810,7 +810,15 @@ static void riscv_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu)static void riscv_tr_disas_log (const DisasContextBase *dcbase,CPUState *cpu) { +#ifndef CONFIG_USER_ONLY +RISCVCPU *rvcpu =RISCV_CPU (cpu); +CPURISCVState *env = &rvcpu->env; +#endif +qemu_log ("IN: %s\n" ,lookup_symbol (dcbase->pc_first)); +#ifndef CONFIG_USER_ONLY +qemu_log ("Priv: " TARGET_FMT_ld"; Virt: " TARGET_FMT_ld"\n" , env->priv, env->virt); +#endif log_target_disas (cpu, dcbase->pc_first, dcbase->tb->size); }
Signature · 1 line
2.23.0
PATCH v2 8/27 target/riscv: Dump Hypervisor registers if enabled
In reply to Alistair FrancisDump the Hypervisor registers and the current Hypervisor state.
While we are editing this code let's also dump stvec and scause.
--- target/riscv/cpu.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
target/riscv/cpu.c +34 -0
@@ -220,17 +220,51 @@ static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)CPURISCVState *env = &cpu->env;int i; +#if !defined(CONFIG_USER_ONLY ) +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s %d\n" ,"V = " ,riscv_cpu_virt_enabled (env)); + } +#endif qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"pc " , env->pc);#ifndef CONFIG_USER_ONLY qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mhartid " , env->mhartid);qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mstatus " , env->mstatus); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"hstatus " , env->hstatus); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"bstatus " , env->vsstatus); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mip " , env->mip); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vsip " , + (target_ulong )atomic_read (&env->vsip)); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mie " , env->mie); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vsie " , env->vsie); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mideleg " , env->mideleg); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"hideleg " , env->hideleg); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"medeleg " , env->medeleg); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"hedeleg " , env->hedeleg); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mtvec " , env->mtvec); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"stvec " , env->stvec); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vstvec " , env->vstvec); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mepc " , env->mepc); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"sepc " , env->sepc); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vsepc " , env->vsepc); + }qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mcause " , env->mcause); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"scause " , env->scause); +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vscause " , env->vscause); + }#endif for (i =0 ; i <32 ; i++) {
Signature · 1 line
2.23.0
PATCH v2 9/27 target/riscv: Add Hypervisor CSR access functions
In reply to Alistair Francis--- target/riscv/csr.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+)
target/riscv/csr.c +68 -0
@@ -98,6 +98,20 @@ static int smode(CPURISCVState *env, int csrno)return -!riscv_has_ext (env,RVS ); } +static int hmode (CPURISCVState *env,int csrno) +{ +if (riscv_has_ext (env,RVS ) && +riscv_has_ext (env,RVH )) { +/* Hypervisor extension is supported */ +if ((env->priv ==PRV_S && !riscv_cpu_virt_enabled (env)) || + env->priv ==PRV_M ) { +return 0 ; + } + } + +return -1 ; +} +static int pmp (CPURISCVState *env,int csrno) {return -!riscv_feature (env,RISCV_FEATURE_PMP );
@@ -754,6 +768,55 @@ static int write_satp(CPURISCVState *env, int csrno, target_ulong val)return 0 ; } +/* Hypervisor Extensions */ +static int read_hstatus (CPURISCVState *env,int csrno,target_ulong *val) +{ + *val = env->hstatus; +return 0 ; +} + +static int write_hstatus (CPURISCVState *env,int csrno,target_ulong val) +{ + env->hstatus = val; +return 0 ; +} + +static int read_hedeleg (CPURISCVState *env,int csrno,target_ulong *val) +{ + *val = env->hedeleg; +return 0 ; +} + +static int write_hedeleg (CPURISCVState *env,int csrno,target_ulong val) +{ + env->hedeleg = val; +return 0 ; +} + +static int read_hideleg (CPURISCVState *env,int csrno,target_ulong *val) +{ + *val = env->hideleg; +return 0 ; +} + +static int write_hideleg (CPURISCVState *env,int csrno,target_ulong val) +{ + env->hideleg = val; +return 0 ; +} + +static int read_hgatp (CPURISCVState *env,int csrno,target_ulong *val) +{ + *val = env->hgatp; +return 0 ; +} + +static int write_hgatp (CPURISCVState *env,int csrno,target_ulong val) +{ + env->hgatp = val; +return 0 ; +} +/* Physical Memory Protection */ static int read_pmpcfg (CPURISCVState *env,int csrno,target_ulong *val) {
@@ -957,6 +1020,11 @@ static riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { /* Supervisor Protection and Translation */ [CSR_SATP] = { smode, read_satp, write_satp }, + [CSR_HSTATUS] = { hmode, read_hstatus, write_hstatus }, + [CSR_HEDELEG] = { hmode, read_hedeleg, write_hedeleg }, + [CSR_HIDELEG] = { hmode, read_hideleg, write_hideleg }, + [CSR_HGATP] = { hmode, read_hgatp, write_hgatp }, +/* Physical Memory Protection */ [CSR_PMPCFG0 ... CSR_PMPADDR9] = { pmp, read_pmpcfg, write_pmpcfg }, [CSR_PMPADDR0 ... CSR_PMPADDR15] = { pmp, read_pmpaddr, write_pmpaddr },
Signature · 1 line
2.23.0
PATCH v2 10/27 target/riscv: Add Hypervisor virtual CSRs accesses
In reply to Alistair Francis--- target/riscv/cpu_bits.h | 11 ++++ target/riscv/csr.c | 119 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 130 insertions(+)
target/riscv/cpu_bits.h +11 -0
@@ -191,6 +191,17 @@#define HGATP_PPN SATP64_PPN#endif +/* Virtual CSRs */ +#define CSR_VSSTATUS 0x200 +#define CSR_VSIE 0x204 +#define CSR_VSTVEC 0x205 +#define CSR_VSSCRATCH 0x240 +#define CSR_VSEPC 0x241 +#define CSR_VSCAUSE 0x242 +#define CSR_VSTVAL 0x243 +#define CSR_VSIP 0x244 +#define CSR_VSATP 0x280 +/* Physical Memory Protection */ #define CSR_PMPCFG0 0x3a0#define CSR_PMPCFG1 0x3a1
target/riscv/csr.c +119 -0
131 lines not on this page · raw message
Signature · 1 line
2.23.0
PATCH v2 11/27 target/riscv: Convert mie and mstatus to pointers
In reply to Alistair FrancisTo handle the new Hypervisor CSR register aliasing let's use pointers.
We only need to convert the MIE and MSTATUS CSRs. With the exception of MIP all of the other CSRs that swap with virtulsation changes are S-Mode only, so we can just do a lazy switch. This because more challenging for the M-Mode registers so it ends up being easier to use pointers.
As the MIP CSR is always accessed atomicly the pointer swap doesn't work so we leave that as is.
--- target/riscv/cpu.c | 16 ++++++++++++---- target/riscv/cpu.h | 12 ++++++++++-- target/riscv/cpu_helper.c | 32 ++++++++++++++++---------------- target/riscv/csr.c | 28 ++++++++++++++-------------- target/riscv/op_helper.c | 14 +++++++------- 5 files changed, 59 insertions(+), 43 deletions(-)
target/riscv/cpu.c +12 -4
@@ -228,7 +228,7 @@ static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"pc " , env->pc);#ifndef CONFIG_USER_ONLY qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mhartid " , env->mhartid); -qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mstatus " , env->mstatus); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mstatus " , *env->mstatus);if (riscv_has_ext (env,RVH )) {qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"hstatus " , env->hstatus);qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"bstatus " , env->vsstatus);
@@ -238,7 +238,7 @@ static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vsip " , (target_ulong )atomic_read (&env->vsip)); } -qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mie " , env->mie); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mie " , *env->mie);if (riscv_has_ext (env,RVH )) {qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"vsie " , env->vsie); }
@@ -308,7 +308,7 @@ static bool riscv_cpu_has_work(CPUState *cs)* Definition of the WFI instruction requires it to ignore the privilege * mode and delegation registers, but respect individual enables */ -return (env->mip & env->mie) !=0 ; +return (env->mip & *env->mie) !=0 ;#else return true;#endif
@@ -329,7 +329,7 @@ static void riscv_cpu_reset(CPUState *cs) mcc->parent_reset (cs);#ifndef CONFIG_USER_ONLY env->priv =PRV_M ; - env->mstatus &= ~(MSTATUS_MIE |MSTATUS_MPRV ); + *env->mstatus &= ~(MSTATUS_MIE |MSTATUS_MPRV ); env->mcause =0 ; env->pc = env->resetvec;#endif
@@ -458,8 +458,16 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp)static void riscv_cpu_init (Object *obj) {RISCVCPU *cpu =RISCV_CPU (obj); +#ifndef CONFIG_USER_ONLY +CPURISCVState *env = &cpu->env; +#endif cpu_set_cpustate_pointers (cpu); + +#ifndef CONFIG_USER_ONLY + env->mie = &env->mie_novirt; + env->mstatus = &env->mstatus_novirt; +#endif }static const VMStateDescription vmstate_riscv_cpu = {
target/riscv/cpu.h +10 -2
@@ -122,12 +122,12 @@ struct CPURISCVState {target_ulong resetvec;target_ulong mhartid; -target_ulong mstatus; +target_ulong *mstatus;target_ulong mip;uint32_t miclaim; -target_ulong mie; +target_ulong *mie;target_ulong mideleg;target_ulong sptbr;/* until: priv-1.9.1 */
@@ -145,6 +145,14 @@ struct CPURISCVState {target_ulong mcause;target_ulong mtval;/* since: priv-1.10.0 */ +/* The following registers are the "real" versions that the pointer +* versions point to. These should never be used unless you know what you +* are doing. To access these use the pointer versions instead. This is +* required to handle the Hypervisor register swapping. +*/ +target_ulong mie_novirt; +target_ulong mstatus_novirt; +/* Hypervisor CSRs */ target_ulong hstatus;target_ulong hedeleg;
target/riscv/cpu_helper.c +16 -16
@@ -37,9 +37,9 @@ int riscv_cpu_mmu_index(CPURISCVState *env, bool ifetch)#ifndef CONFIG_USER_ONLY static int riscv_cpu_local_irq_pending (CPURISCVState *env) { -target_ulong mstatus_mie =get_field (env->mstatus,MSTATUS_MIE ); -target_ulong mstatus_sie =get_field (env->mstatus,MSTATUS_SIE ); -target_ulong pending = env->mip & env->mie; +target_ulong mstatus_mie =get_field (*env->mstatus,MSTATUS_MIE ); +target_ulong mstatus_sie =get_field (*env->mstatus,MSTATUS_SIE ); +target_ulong pending = env->mip & *env->mie;target_ulong mie = env->priv <PRV_M || (env->priv ==PRV_M && mstatus_mie);target_ulong sie = env->priv <PRV_S || (env->priv ==PRV_S && mstatus_sie); target_ulong irqs = (pending & ~env->mideleg & -mie) |
@@ -75,7 +75,7 @@ bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request)/* Return true is floating point support is currently enabled */ bool riscv_cpu_fp_enabled (CPURISCVState *env) { -if (env->mstatus &MSTATUS_FS ) { +if (*env->mstatus &MSTATUS_FS ) {return true; }
@@ -198,8 +198,8 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical,int mode = mmu_idx;if (mode ==PRV_M && access_type !=MMU_INST_FETCH ) { -if (get_field (env->mstatus,MSTATUS_MPRV )) { - mode =get_field (env->mstatus,MSTATUS_MPP ); +if (get_field (*env->mstatus,MSTATUS_MPRV )) { + mode =get_field (*env->mstatus,MSTATUS_MPP ); } }
@@ -213,11 +213,11 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical,hwaddr base;int levels, ptidxbits, ptesize, vm, sum; -int mxr =get_field (env->mstatus,MSTATUS_MXR ); +int mxr =get_field (*env->mstatus,MSTATUS_MXR );if (env->priv_ver >=PRIV_VERSION_1_10_0 ) { base = (hwaddr )get_field (env->satp,SATP_PPN ) <<PGSHIFT ; - sum =get_field (env->mstatus,MSTATUS_SUM ); + sum =get_field (*env->mstatus,MSTATUS_SUM ); vm =get_field (env->satp,SATP_MODE );switch (vm) {case VM_1_10_SV32 :
@@ -237,8 +237,8 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical, } }else { base = (hwaddr)(env->sptbr) <<PGSHIFT ; - sum = !get_field (env->mstatus,MSTATUS_PUM ); - vm =get_field (env->mstatus,MSTATUS_VM ); + sum = !get_field (*env->mstatus,MSTATUS_PUM ); + vm =get_field (*env->mstatus,MSTATUS_VM );switch (vm) {case VM_1_09_SV32 : levels =2 ; ptidxbits =10 ; ptesize =4 ;break ;
@@ -493,8 +493,8 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, ret =get_physical_address (env, &pa, &prot, address, access_type, mmu_idx);if (mode ==PRV_M && access_type !=MMU_INST_FETCH ) { -if (get_field (env->mstatus,MSTATUS_MPRV )) { - mode =get_field (env->mstatus,MSTATUS_MPP ); +if (get_field (*env->mstatus,MSTATUS_MPRV )) { + mode =get_field (*env->mstatus,MSTATUS_MPP ); } }
@@ -607,12 +607,12 @@ void riscv_cpu_do_interrupt(CPUState *cs)if (env->priv <=PRV_S && cause <TARGET_LONG_BITS && ((deleg >> cause) &1 )) {/* handle the trap in S-mode */ -target_ulong s = env->mstatus; +target_ulong s = *env->mstatus; s =set_field (s,MSTATUS_SPIE , env->priv_ver >=PRIV_VERSION_1_10_0 ?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 ); - env->mstatus = s; + *env->mstatus = s; env->scause = cause | ((target_ulong )async << (TARGET_LONG_BITS -1 )); env->sepc = env->pc; env->sbadaddr = tval;
@@ -621,12 +621,12 @@ void riscv_cpu_do_interrupt(CPUState *cs)riscv_cpu_set_mode (env,PRV_S ); }else {/* handle the trap in M-mode */ -target_ulong s = env->mstatus; +target_ulong s = *env->mstatus; s =set_field (s,MSTATUS_MPIE , env->priv_ver >=PRIV_VERSION_1_10_0 ?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 ); - env->mstatus = s; + *env->mstatus = s; env->mcause = cause | ~(((target_ulong)-1 ) >> async); env->mepc = env->pc; env->mbadaddr = tval;
target/riscv/csr.c +14 -14
@@ -136,7 +136,7 @@ static int write_fflags(CPURISCVState *env, int csrno, target_ulong val)if (!env->debugger && !riscv_cpu_fp_enabled (env)) {return -1 ; } - env->mstatus |=MSTATUS_FS ; + *env->mstatus |=MSTATUS_FS ;#endif riscv_cpu_set_fflags (env, val & (FSR_AEXC >>FSR_AEXC_SHIFT ));return 0 ;
@@ -159,7 +159,7 @@ static int write_frm(CPURISCVState *env, int csrno, target_ulong val)if (!env->debugger && !riscv_cpu_fp_enabled (env)) {return -1 ; } - env->mstatus |=MSTATUS_FS ; + *env->mstatus |=MSTATUS_FS ;#endif env->frm = val & (FSR_RD >>FSR_RD_SHIFT );return 0 ;
@@ -183,7 +183,7 @@ static int write_fcsr(CPURISCVState *env, int csrno, target_ulong val)if (!env->debugger && !riscv_cpu_fp_enabled (env)) {return -1 ; } - env->mstatus |=MSTATUS_FS ; + *env->mstatus |=MSTATUS_FS ;#endif env->frm = (val &FSR_RD ) >>FSR_RD_SHIFT ;riscv_cpu_set_fflags (env, (val &FSR_AEXC ) >>FSR_AEXC_SHIFT );
@@ -307,7 +307,7 @@ static int read_mhartid(CPURISCVState *env, int csrno, target_ulong *val)/* Machine Trap Setup */ static int read_mstatus (CPURISCVState *env,int csrno,target_ulong *val) { - *val = env->mstatus; + *val = *env->mstatus;return 0 ; }
@@ -319,7 +319,7 @@ static int validate_vm(CPURISCVState *env, target_ulong vm)static int write_mstatus (CPURISCVState *env,int csrno,target_ulong val) { -target_ulong mstatus = env->mstatus; +target_ulong mstatus = *env->mstatus;target_ulong mask =0 ;int dirty;
@@ -359,7 +359,7 @@ static int write_mstatus(CPURISCVState *env, int csrno, target_ulong val) ((mstatus & MSTATUS_FS) == MSTATUS_FS)) | ((mstatus &MSTATUS_XS ) ==MSTATUS_XS ); mstatus =set_field (mstatus,MSTATUS_SD , dirty); - env->mstatus = mstatus; + *env->mstatus = mstatus;return 0 ; }
@@ -448,13 +448,13 @@ static int write_mideleg(CPURISCVState *env, int csrno, target_ulong val)static int read_mie (CPURISCVState *env,int csrno,target_ulong *val) { - *val = env->mie; + *val = *env->mie;return 0 ; }static int write_mie (CPURISCVState *env,int csrno,target_ulong val) { - env->mie = (env->mie & ~all_ints) | (val & all_ints); + *env->mie = (*env->mie & ~all_ints) | (val & all_ints);return 0 ; }
@@ -608,7 +608,7 @@ static int read_sstatus(CPURISCVState *env, int csrno, target_ulong *val) {target_ulong mask = ((env->priv_ver >=PRIV_VERSION_1_10_0 ) ? sstatus_v1_10_mask : sstatus_v1_9_mask); - *val = env->mstatus & mask; + *val = *env->mstatus & mask;return 0 ; }
@@ -616,19 +616,19 @@ static int write_sstatus(CPURISCVState *env, int csrno, target_ulong val) {target_ulong mask = ((env->priv_ver >=PRIV_VERSION_1_10_0 ) ? sstatus_v1_10_mask : sstatus_v1_9_mask); -target_ulong newval = (env->mstatus & ~mask) | (val & mask); +target_ulong newval = (*env->mstatus & ~mask) | (val & mask);return write_mstatus (env,CSR_MSTATUS , newval); }static int read_sie (CPURISCVState *env,int csrno,target_ulong *val) { - *val = env->mie & env->mideleg; + *val = *env->mie & env->mideleg;return 0 ; }static int write_sie (CPURISCVState *env,int csrno,target_ulong val) { -target_ulong newval = (env->mie & ~env->mideleg) | (val & env->mideleg); +target_ulong newval = (*env->mie & ~env->mideleg) | (val & env->mideleg);return write_mie (env,CSR_MIE , newval); }
@@ -731,7 +731,7 @@ static int read_satp(CPURISCVState *env, int csrno, target_ulong *val)if (!riscv_feature (env,RISCV_FEATURE_MMU )) { *val =0 ; }else if (env->priv_ver >=PRIV_VERSION_1_10_0 ) { -if (env->priv ==PRV_S &&get_field (env->mstatus,MSTATUS_TVM )) { +if (env->priv ==PRV_S &&get_field (*env->mstatus,MSTATUS_TVM )) {return -1 ; }else { *val = env->satp;
@@ -756,7 +756,7 @@ static int write_satp(CPURISCVState *env, int csrno, target_ulong val) validate_vm(env, get_field(val, SATP_MODE)) && ((val ^ env->satp) & (SATP_MODE | SATP_ASID | SATP_PPN))) { -if (env->priv ==PRV_S &&get_field (env->mstatus,MSTATUS_TVM )) { +if (env->priv ==PRV_S &&get_field (*env->mstatus,MSTATUS_TVM )) {return -1 ; }else {if ((val ^ env->satp) &SATP_ASID ) {
target/riscv/op_helper.c +7 -7
@@ -83,11 +83,11 @@ target_ulong helper_sret(CPURISCVState *env, target_ulong cpu_pc_deb) }if (env->priv_ver >=PRIV_VERSION_1_10_0 && -get_field (env->mstatus,MSTATUS_TSR )) { +get_field (*env->mstatus,MSTATUS_TSR )) {riscv_raise_exception (env,RISCV_EXCP_ILLEGAL_INST ,GETPC ()); } -target_ulong mstatus = env->mstatus; +target_ulong mstatus = *env->mstatus;target_ulong prev_priv =get_field (mstatus,MSTATUS_SPP ); mstatus = set_field(mstatus, env->priv_ver >= PRIV_VERSION_1_10_0 ?
@@ -96,7 +96,7 @@ target_ulong helper_sret(CPURISCVState *env, target_ulong cpu_pc_deb) mstatus =set_field (mstatus,MSTATUS_SPIE ,0 ); mstatus =set_field (mstatus,MSTATUS_SPP ,PRV_U );riscv_cpu_set_mode (env, prev_priv); - env->mstatus = mstatus; + *env->mstatus = mstatus;return retpc; }
@@ -112,7 +112,7 @@ target_ulong helper_mret(CPURISCVState *env, target_ulong cpu_pc_deb)riscv_raise_exception (env,RISCV_EXCP_INST_ADDR_MIS ,GETPC ()); } -target_ulong mstatus = env->mstatus; +target_ulong mstatus = *env->mstatus;target_ulong prev_priv =get_field (mstatus,MSTATUS_MPP ); mstatus = set_field(mstatus, env->priv_ver >= PRIV_VERSION_1_10_0 ?
@@ -121,7 +121,7 @@ target_ulong helper_mret(CPURISCVState *env, target_ulong cpu_pc_deb) mstatus =set_field (mstatus,MSTATUS_MPIE ,0 ); mstatus =set_field (mstatus,MSTATUS_MPP ,PRV_U );riscv_cpu_set_mode (env, prev_priv); - env->mstatus = mstatus; + *env->mstatus = mstatus;return retpc; }
@@ -132,7 +132,7 @@ void helper_wfi(CPURISCVState *env)if (env->priv ==PRV_S && env->priv_ver >=PRIV_VERSION_1_10_0 && -get_field (env->mstatus,MSTATUS_TW )) { +get_field (*env->mstatus,MSTATUS_TW )) {riscv_raise_exception (env,RISCV_EXCP_ILLEGAL_INST ,GETPC ()); }else { cs->halted =1 ;
@@ -147,7 +147,7 @@ void helper_tlb_flush(CPURISCVState *env)if (!(env->priv >=PRV_S ) || (env->priv ==PRV_S && env->priv_ver >=PRIV_VERSION_1_10_0 && -get_field (env->mstatus,MSTATUS_TVM ))) { +get_field (*env->mstatus,MSTATUS_TVM ))) {riscv_raise_exception (env,RISCV_EXCP_ILLEGAL_INST ,GETPC ()); }else {tlb_flush (cs);
Signature · 1 line
2.23.0
PATCH v2 12/27 target/riscv: Add virtual register swapping function
In reply to Alistair Francis--- target/riscv/cpu.h | 13 +++++- target/riscv/cpu_bits.h | 7 ++++ target/riscv/cpu_helper.c | 88 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 107 insertions(+), 1 deletion(-)
target/riscv/cpu.h +12 -1
@@ -125,6 +125,8 @@ struct CPURISCVState {target_ulong *mstatus;target_ulong mip; +target_ulong mip_novirt; +uint32_t miclaim;target_ulong *mie;
@@ -161,7 +163,7 @@ struct CPURISCVState {/* Virtual CSRs */ target_ulong vsstatus; -uint32_t vsip; +target_ulong vsip;target_ulong vsie;target_ulong vstvec;target_ulong vsscratch;
@@ -170,6 +172,14 @@ struct CPURISCVState {target_ulong vstval;target_ulong vsatp; +/* HS Backup CSRs */ +target_ulong stvec_hs; +target_ulong sscratch_hs; +target_ulong sepc_hs; +target_ulong scause_hs; +target_ulong stval_hs; +target_ulong satp_hs; +target_ulong scounteren;target_ulong mcounteren;
@@ -300,6 +310,7 @@ void riscv_cpu_list(void);#define cpu_mmu_index riscv_cpu_mmu_index#ifndef CONFIG_USER_ONLY +void riscv_cpu_swap_hypervisor_regs (CPURISCVState *env);int riscv_cpu_claim_interrupts (RISCVCPU *cpu,uint32_t interrupts);uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t value);#define BOOL_TO_MASK (x) (-!!(x))/* helper for riscv_cpu_update_mip value */
target/riscv/cpu_bits.h +7 -0
@@ -553,4 +553,11 @@#define SIP_STIP MIP_STIP#define SIP_SEIP MIP_SEIP +/* MIE masks */ +#define MIE_SEIE (1 << IRQ_S_EXT) +#define MIE_UEIE (1 << IRQ_U_EXT) +#define MIE_STIE (1 << IRQ_S_TIMER) +#define MIE_UTIE (1 << IRQ_U_TIMER) +#define MIE_SSIE (1 << IRQ_S_SOFT) +#define MIE_USIE (1 << IRQ_U_SOFT)#endif
target/riscv/cpu_helper.c +88 -0
94 lines not on this page · raw message
Signature · 1 line
2.23.0
PATCH v2 13/27 target/riscv: Add support for virtual interrupt setting
In reply to Alistair Francis--- target/riscv/cpu_helper.c | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-)
target/riscv/cpu_helper.c +17 -2
@@ -39,12 +39,27 @@ static int riscv_cpu_local_irq_pending(CPURISCVState *env) {target_ulong mstatus_mie =get_field (*env->mstatus,MSTATUS_MIE );target_ulong mstatus_sie =get_field (*env->mstatus,MSTATUS_SIE ); +target_ulong vsstatus_sie =get_field (env->mstatus_novirt,MSTATUS_SIE ); +target_ulong pending = env->mip & *env->mie; -target_ulong mie = env->priv <PRV_M || (env->priv ==PRV_M && mstatus_mie); -target_ulong sie = env->priv <PRV_S || (env->priv ==PRV_S && mstatus_sie); +target_ulong hspending = env->mip_novirt & env->mie_novirt; + +target_ulong mie = env->priv <PRV_M || (env->priv ==PRV_M && mstatus_mie); +target_ulong sie = env->priv <PRV_S || (env->priv ==PRV_S && mstatus_sie); +target_ulong vsie = env->priv <PRV_S || (env->priv ==PRV_S && vsstatus_sie); +target_ulong irqs = (pending & ~env->mideleg & -mie) | (pending & env->mideleg & -sie); +if (riscv_cpu_virt_enabled (env)) { +target_ulong pending_hs_irq = hspending & -vsie; + +if (pending_hs_irq) { +riscv_cpu_set_force_hs_excep (env,FORCE_HS_EXCEP ); +return ctz64 (pending_hs_irq); + } + } +if (irqs) {return ctz64 (irqs);/* since non-zero */ }else {
Signature · 1 line
2.23.0
PATCH v2 14/27 target/ricsv: Flush the TLB on virtulisation mode changes
In reply to Alistair FrancisTo ensure our TLB isn't out-of-date we flush it on all virt mode changes. Unlike priv mode this isn't saved in the mmu_idx as all guests share V=1. The easiest option is just to flush on all changes.
--- target/riscv/cpu_helper.c | 5 +++++ 1 file changed, 5 insertions(+)
target/riscv/cpu_helper.c +5 -0
@@ -200,6 +200,11 @@ void riscv_cpu_set_virt_enabled(CPURISCVState *env, bool enable)return ; } +/* Flush the TLB on all virt mode changes. */ +if (get_field (env->virt,VIRT_ONOFF ) != enable) { +tlb_flush (env_cpu (env)); + } + env->virt =set_field (env->virt,VIRT_ONOFF , enable); }
Signature · 1 line
2.23.0
PATCH v2 15/27 target/riscv: Generate illegal instruction on WFI when V=1
In reply to Alistair Francis--- target/riscv/op_helper.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
target/riscv/op_helper.c +3 -2
@@ -130,9 +130,10 @@ void helper_wfi(CPURISCVState *env) {CPUState *cs =env_cpu (env); -if (env->priv ==PRV_S && +if ((env->priv ==PRV_S && env->priv_ver >=PRIV_VERSION_1_10_0 && -get_field (*env->mstatus,MSTATUS_TW )) { +get_field (*env->mstatus,MSTATUS_TW )) || +riscv_cpu_virt_enabled (env)) {riscv_raise_exception (env,RISCV_EXCP_ILLEGAL_INST ,GETPC ()); }else { cs->halted =1 ;
Signature · 1 line
2.23.0
PATCH v2 16/27 riscv: plic: Always set sip.SEIP bit for HS
In reply to Alistair FrancisWhen the PLIC generates an interrupt ensure we always set it for the SIP CSR that corresponds to the HS (V=0) register.
--- hw/riscv/sifive_plic.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
hw/riscv/sifive_plic.c +11 -1
@@ -150,7 +150,17 @@ static void sifive_plic_update(SiFivePLICState *plic)riscv_cpu_update_mip (RISCV_CPU (cpu),MIP_MEIP ,BOOL_TO_MASK (level));break ;case PLICMode_S: -riscv_cpu_update_mip (RISCV_CPU (cpu),MIP_SEIP ,BOOL_TO_MASK (level)); +if (riscv_cpu_virt_enabled (env)) { +if (level) { +atomic_or (&env->mip_novirt,MIP_SEIP ); +g_assert (riscv_cpu_virt_enabled (env)); + }else { +atomic_and (&env->mip_novirt, ~MIP_SEIP ); +g_assert (riscv_cpu_virt_enabled (env)); + } + }else { +riscv_cpu_update_mip (RISCV_CPU (cpu),MIP_SEIP ,BOOL_TO_MASK (level)); + }break ;default :break ;
Signature · 1 line
2.23.0
PATCH v2 17/27 target/riscv: Add hypvervisor trap support
In reply to Alistair Francis--- target/riscv/cpu_bits.h | 4 +-- target/riscv/cpu_helper.c | 71 +++++++++++++++++++++++++++++++++------ target/riscv/csr.c | 4 +-- 3 files changed, 65 insertions(+), 14 deletions(-)
target/riscv/cpu_bits.h +2 -2
@@ -510,8 +510,8 @@#define RISCV_EXCP_STORE_AMO_ADDR_MIS 0x6#define RISCV_EXCP_STORE_AMO_ACCESS_FAULT 0x7#define RISCV_EXCP_U_ECALL 0x8 -#define RISCV_EXCP_S_ECALL 0x9 -#define RISCV_EXCP_H_ECALL 0xa +#define RISCV_EXCP_HS_ECALL 0x9 +#define RISCV_EXCP_VS_ECALL 0xa#define RISCV_EXCP_M_ECALL 0xb#define RISCV_EXCP_INST_PAGE_FAULT 0xc/* since: priv-1.10.0 */ #define RISCV_EXCP_LOAD_PAGE_FAULT 0xd/* since: priv-1.10.0 */
target/riscv/cpu_helper.c +61 -10
101 lines not on this page · raw message
target/riscv/csr.c +2 -2
@@ -255,8 +255,8 @@ static const target_ulong delegable_excps = (1ULL << (RISCV_EXCP_STORE_AMO_ADDR_MIS )) | (1ULL << (RISCV_EXCP_STORE_AMO_ACCESS_FAULT )) | (1ULL << (RISCV_EXCP_U_ECALL )) | - (1ULL << (RISCV_EXCP_S_ECALL )) | - (1ULL << (RISCV_EXCP_H_ECALL )) | + (1ULL << (RISCV_EXCP_VS_ECALL )) | + (1ULL << (RISCV_EXCP_HS_ECALL )) | (1ULL << (RISCV_EXCP_M_ECALL )) | (1ULL << (RISCV_EXCP_INST_PAGE_FAULT )) | (1ULL << (RISCV_EXCP_LOAD_PAGE_FAULT)) |
Signature · 1 line
2.23.0
PATCH v2 18/27 target/riscv: Add Hypervisor trap return support
In reply to Alistair Francis--- target/riscv/op_helper.c | 66 ++++++++++++++++++++++++++++++++-------- 1 file changed, 54 insertions(+), 12 deletions(-)
target/riscv/op_helper.c +54 -12
@@ -73,6 +73,8 @@ target_ulong helper_csrrc(CPURISCVState *env, target_ulong src,target_ulong helper_sret (CPURISCVState *env,target_ulong cpu_pc_deb) { +target_ulong prev_priv, prev_virt, mstatus; +if (!(env->priv >=PRV_S )) {riscv_raise_exception (env,RISCV_EXCP_ILLEGAL_INST ,GETPC ()); }
@@ -87,16 +89,46 @@ target_ulong helper_sret(CPURISCVState *env, target_ulong cpu_pc_deb)riscv_raise_exception (env,RISCV_EXCP_ILLEGAL_INST ,GETPC ()); } -target_ulong mstatus = *env->mstatus; -target_ulong prev_priv =get_field (mstatus,MSTATUS_SPP ); - mstatus =set_field (mstatus, - env->priv_ver >=PRIV_VERSION_1_10_0 ? -MSTATUS_SIE :MSTATUS_UIE << prev_priv, -get_field (mstatus,MSTATUS_SPIE )); - mstatus =set_field (mstatus,MSTATUS_SPIE ,0 ); - mstatus =set_field (mstatus,MSTATUS_SPP ,PRV_U ); + mstatus = *env->mstatus; + +if (riscv_has_ext (env,RVH ) && !riscv_cpu_virt_enabled (env)) { +/* We support Hypervisor extensions and virtulisation is disabled */ +target_ulong hstatus = env->hstatus; + + prev_priv =get_field (mstatus,MSTATUS_SPP ); + prev_virt =get_field (hstatus,HSTATUS_SPV ); + + hstatus =set_field (hstatus,HSTATUS_SPV , +get_field (hstatus,HSTATUS_SP2V )); + mstatus =set_field (mstatus,MSTATUS_SPP , +get_field (hstatus,HSTATUS_SP2P )); + hstatus =set_field (hstatus,HSTATUS_SP2V ,0 ); + hstatus =set_field (hstatus,HSTATUS_SP2P ,0 ); + mstatus =set_field (mstatus,SSTATUS_SIE , +get_field (mstatus,SSTATUS_SPIE )); + mstatus =set_field (mstatus,SSTATUS_SPIE ,1 ); + + *env->mstatus = mstatus; + env->hstatus = hstatus; + +if (prev_virt) { +riscv_cpu_swap_hypervisor_regs (env); + } + +riscv_cpu_set_virt_enabled (env, prev_virt); + }else { + prev_priv =get_field (mstatus,MSTATUS_SPP ); + + mstatus =set_field (mstatus, + env->priv_ver >=PRIV_VERSION_1_10_0 ? +MSTATUS_SIE :MSTATUS_UIE << prev_priv, +get_field (mstatus,MSTATUS_SPIE )); + mstatus =set_field (mstatus,MSTATUS_SPIE ,0 ); + mstatus =set_field (mstatus,MSTATUS_SPP ,PRV_U ); + *env->mstatus = mstatus; + } +riscv_cpu_set_mode (env, prev_priv); - *env->mstatus = mstatus;return retpc; }
@@ -114,14 +146,24 @@ target_ulong helper_mret(CPURISCVState *env, target_ulong cpu_pc_deb)target_ulong mstatus = *env->mstatus;target_ulong prev_priv =get_field (mstatus,MSTATUS_MPP ); +target_ulong prev_virt =get_field (mstatus,MSTATUS_MPV ); mstatus =set_field (mstatus, env->priv_ver >=PRIV_VERSION_1_10_0 ?MSTATUS_MIE :MSTATUS_UIE << prev_priv,get_field (mstatus,MSTATUS_MPIE )); - mstatus =set_field (mstatus,MSTATUS_MPIE ,0 ); - mstatus =set_field (mstatus,MSTATUS_MPP ,PRV_U ); -riscv_cpu_set_mode (env, prev_priv); + mstatus =set_field (mstatus,MSTATUS_MPIE ,1 ); + mstatus =set_field (mstatus,MSTATUS_MPP ,0 ); + mstatus =set_field (mstatus,MSTATUS_MPV ,0 ); *env->mstatus = mstatus; +riscv_cpu_set_mode (env, prev_priv); + +if (riscv_has_ext (env,RVH )) { +if (prev_virt) { +riscv_cpu_swap_hypervisor_regs (env); + } + +riscv_cpu_set_virt_enabled (env, prev_virt); + }return retpc; }
Signature · 1 line
2.23.0
PATCH v2 19/27 target/riscv: Add hfence instructions
In reply to Alistair Francis--- target/riscv/insn32.decode | 23 ++++++----- .../riscv/insn_trans/trans_privileged.inc.c | 40 +++++++++++++++++++ 2 files changed, 54 insertions(+), 9 deletions(-)
target/riscv/insn32.decode +14 -9
@@ -63,20 +63,25 @@ @r2_rm ....... ..... ..... ... ..... ....... %rs1 %rm %rd @r2 ....... ..... ..... ... ..... ....... %rs1 %rd +@hfence_gvma ....... ..... ..... ... ..... ....... %rs2 %rs1 +@hfence_bvma ....... ..... ..... ... ..... ....... %rs2 %rs1 + @sfence_vma ....... ..... ..... ... ..... ....... %rs2 %rs1 @sfence_vm ....... ..... ..... ... ..... ....... %rs1 # *** Privileged Instructions *** -ecall 000000000000 00000 000 00000 1110011 -ebreak 000000000001 00000 000 00000 1110011 -uret 0000000 00010 00000 000 00000 1110011 -sret 0001000 00010 00000 000 00000 1110011 -hret 0010000 00010 00000 000 00000 1110011 -mret 0011000 00010 00000 000 00000 1110011 -wfi 0001000 00101 00000 000 00000 1110011 -sfence_vma 0001001 ..... ..... 000 00000 1110011 @sfence_vma -sfence_vm 0001000 00100 ..... 000 00000 1110011 @sfence_vm +ecall 000000000000 00000 000 00000 1110011 +ebreak 000000000001 00000 000 00000 1110011 +uret 0000000 00010 00000 000 00000 1110011 +sret 0001000 00010 00000 000 00000 1110011 +hret 0010000 00010 00000 000 00000 1110011 +mret 0011000 00010 00000 000 00000 1110011 +wfi 0001000 00101 00000 000 00000 1110011 +hfence_gvma 0110001 ..... ..... 000 00000 1110011 @hfence_gvma +hfence_bvma 0010001 ..... ..... 000 00000 1110011 @hfence_bvma +sfence_vma 0001001 ..... ..... 000 00000 1110011 @sfence_vma +sfence_vm 0001000 00100 ..... 000 00000 1110011 @sfence_vm # *** RV32I Base Instruction Set *** lui .................... ..... 0110111 @u
target/riscv/insn_trans/trans_privileged.inc.c +40 -0
@@ -108,3 +108,43 @@ static bool trans_sfence_vm(DisasContext *ctx, arg_sfence_vm *a)#endif return false; } + +static bool trans_hfence_gvma (DisasContext *ctx,arg_sfence_vma *a) +{ +#ifndef CONFIG_USER_ONLY +if (ctx->priv_ver >=PRIV_VERSION_1_10_0 && +has_ext (ctx,RVH )) { +/* Hpervisor extensions exist */ +/* +* if (env->priv == PRV_M || +* (env->priv == PRV_S && +* !riscv_cpu_virt_enabled(env) && +* get_field(ctx->mstatus_fs, MSTATUS_TVM))) { +*/ +gen_helper_tlb_flush (cpu_env); +return true; +/* } */ + } +#endif +return false; +} + +static bool trans_hfence_bvma (DisasContext *ctx,arg_sfence_vma *a) +{ +#ifndef CONFIG_USER_ONLY +if (ctx->priv_ver >=PRIV_VERSION_1_10_0 && +has_ext (ctx,RVH )) { +/* Hpervisor extensions exist */ +/* +* if (env->priv == PRV_M || +* (env->priv == PRV_S && +* !riscv_cpu_virt_enabled(env) && +* get_field(ctx->mstatus_fs, MSTATUS_TVM))) { +*/ +gen_helper_tlb_flush (cpu_env); +return true; +/* } */ + } +#endif +return false; +}
Signature · 1 line
2.23.0
PATCH v2 20/27 target/riscv: Disable guest FP support based on virtual status
In reply to Alistair FrancisWhen the Hypervisor extension is in use we only enable floating point support when both status and vsstatus have enabled floating point support.
--- target/riscv/cpu_helper.c | 3 +++ 1 file changed, 3 insertions(+)
target/riscv/cpu_helper.c +3 -0
@@ -91,6 +91,9 @@ bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request)bool riscv_cpu_fp_enabled (CPURISCVState *env) {if (*env->mstatus &MSTATUS_FS ) { +if (riscv_cpu_virt_enabled (env) && !(env->vsstatus &MSTATUS_FS )) { +return false; + }return true; }
Signature · 1 line
2.23.0
PATCH v2 21/27 target/riscv: Mark both sstatus and vsstatus as dirty
In reply to Alistair FrancisMark both sstatus and vsstatus as dirty (3).
--- target/riscv/translate.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
target/riscv/translate.c +12 -0
@@ -44,6 +44,7 @@ typedef struct DisasContext {/* pc_succ_insn points to the instruction following base.pc_next */ target_ulong pc_succ_insn;target_ulong priv_ver; +bool virt_enabled;uint32_t opcode;uint32_t mstatus_fs;uint32_t misa;
@@ -398,6 +399,12 @@ static void mark_fs_dirty(DisasContext *ctx)tcg_gen_ld_tl (tmp, cpu_env, offsetof(CPURISCVState , mstatus));tcg_gen_ori_tl (tmp, tmp,MSTATUS_FS );tcg_gen_st_tl (tmp, cpu_env, offsetof(CPURISCVState , mstatus)); + +if (ctx->virt_enabled) { +tcg_gen_ld_tl (tmp, cpu_env, offsetof(CPURISCVState , vsstatus)); +tcg_gen_ori_tl (tmp, tmp,MSTATUS_FS ); +tcg_gen_st_tl (tmp, cpu_env, offsetof(CPURISCVState , vsstatus)); + } tcg_temp_free(tmp); }#else
@@ -742,6 +749,11 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs) ctx->mem_idx = ctx->base.tb->flags &TB_FLAGS_MMU_MASK ; ctx->mstatus_fs = ctx->base.tb->flags &TB_FLAGS_MSTATUS_FS ; ctx->priv_ver = env->priv_ver; +#if !defined(CONFIG_USER_ONLY ) + ctx->virt_enabled =riscv_cpu_virt_enabled (env); +#else + ctx->virt_enabled = false; +#endif ctx->misa = env->misa; ctx->frm =-1 ;/* unknown rounding mode */ ctx->ext_ifencei = cpu->cfg.ext_ifencei;
Signature · 1 line
2.23.0
PATCH v2 22/27 target/riscv: Respect MPRV and SPRV for floating point ops
In reply to Alistair Francismark_fs_dirty() is the only place in translate.c that uses the virt_enabled bool. Let's respect the contents of MSTATUS.MPRV and HSTATUS.SPRV when setting the bool as this is used for performing floating point operations when V=0.
--- target/riscv/translate.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)
target/riscv/translate.c +15 -1
@@ -750,7 +750,21 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs) ctx->mstatus_fs = ctx->base.tb->flags &TB_FLAGS_MSTATUS_FS ; ctx->priv_ver = env->priv_ver;#if !defined(CONFIG_USER_ONLY ) - ctx->virt_enabled =riscv_cpu_virt_enabled (env); +if (riscv_has_ext (env,RVH )) { + ctx->virt_enabled =riscv_cpu_virt_enabled (env); +if (env->priv_ver ==PRV_M && +get_field (*env->mstatus,MSTATUS_MPRV ) && +get_field (*env->mstatus,MSTATUS_MPV )) { + ctx->virt_enabled = true; + }else if (env->priv ==PRV_S && + !riscv_cpu_virt_enabled (env) && +get_field (env->hstatus,HSTATUS_SPRV ) && +get_field (env->hstatus,HSTATUS_SPV )) { + ctx->virt_enabled = true; + } + }else { + ctx->virt_enabled = false; + }#else ctx->virt_enabled = false;#endif
Signature · 1 line
2.23.0
PATCH v2 23/27 target/riscv: Allow specifying MMU stage
In reply to Alistair Francis--- target/riscv/cpu_helper.c | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-)
target/riscv/cpu_helper.c +30 -9
@@ -296,10 +296,19 @@ void riscv_cpu_set_mode(CPURISCVState *env, target_ulong newpriv)* * Adapted from Spike's mmu_t::translate and mmu_t::walk * +* @env: CPURISCVState +* @physical: This will be set to the calculated physical address +* @prot: The returned protection attributes +* @addr: The virtual address to be translated +* @access_type: The type of MMU access +* @mmu_idx: Indicates current privilege level +* @first_stage: Are we in first stage translation? +* Second stage is used for hypervisor guest translation */ static int get_physical_address (CPURISCVState *env,hwaddr *physical,int *prot,target_ulong addr, -int access_type,int mmu_idx) +int access_type,int mmu_idx, +bool first_stage) {/* NOTE: the env->pc value visible here will not be * correct, but the value visible to the exception handler
@@ -502,13 +511,23 @@ restart: }static void raise_mmu_exception (CPURISCVState *env,target_ulong address, -MMUAccessType access_type,bool pmp_violation) +MMUAccessType access_type,bool pmp_violation, +bool first_stage) {CPUState *cs =env_cpu (env); -int page_fault_exceptions = - (env->priv_ver >=PRIV_VERSION_1_10_0 ) && -get_field (env->satp,SATP_MODE ) !=VM_1_10_MBARE && - !pmp_violation; +int page_fault_exceptions; +if (first_stage) { + page_fault_exceptions = + (env->priv_ver >=PRIV_VERSION_1_10_0 ) && +get_field (env->satp,SATP_MODE ) !=VM_1_10_MBARE && + !pmp_violation; +riscv_cpu_set_force_hs_excep (env,0 ); + }else { + page_fault_exceptions = +get_field (env->hgatp,HGATP_MODE ) !=VM_1_10_MBARE && + !pmp_violation; +riscv_cpu_set_force_hs_excep (env,1 ); + }switch (access_type) {case MMU_INST_FETCH : cs->exception_index = page_fault_exceptions ?
@@ -535,7 +554,8 @@ hwaddr riscv_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)int prot;int mmu_idx =cpu_mmu_index (&cpu->env, false); -if (get_physical_address (&cpu->env, &phys_addr, &prot, addr,0 , mmu_idx)) { +if (get_physical_address (&cpu->env, &phys_addr, &prot, addr,0 , mmu_idx, + true)) {return -1 ; }return phys_addr;
@@ -601,7 +621,8 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,qemu_log_mask (CPU_LOG_MMU ,"%s ad %" VADDR_PRIx" rw %d mmu_idx %d\n" , __func__, address, access_type, mmu_idx); - ret =get_physical_address (env, &pa, &prot, address, access_type, mmu_idx); + ret =get_physical_address (env, &pa, &prot, address, access_type, mmu_idx, + true);if (mode ==PRV_M && access_type !=MMU_INST_FETCH ) {if (get_field (*env->mstatus,MSTATUS_MPRV )) {
@@ -638,7 +659,7 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, } else if (probe) {return false; }else { -raise_mmu_exception (env, address, access_type, pmp_violation); +raise_mmu_exception (env, address, access_type, pmp_violation, true);riscv_raise_exception (env, cs->exception_index, retaddr); }#else
Signature · 1 line
2.23.0
PATCH v2 24/27 target/riscv: Implement second stage MMU
In reply to Alistair Francis--- target/riscv/cpu_helper.c | 193 ++++++++++++++++++++++++++++++++++---- 1 file changed, 174 insertions(+), 19 deletions(-)
target/riscv/cpu_helper.c +174 -19
@@ -304,11 +304,12 @@ void riscv_cpu_set_mode(CPURISCVState *env, target_ulong newpriv)* @mmu_idx: Indicates current privilege level * @first_stage: Are we in first stage translation? * Second stage is used for hypervisor guest translation +* @two_stage: Are we going to perform two stage translation */ static int get_physical_address (CPURISCVState *env,hwaddr *physical,int *prot,target_ulong addr,int access_type,int mmu_idx, -bool first_stage) +bool first_stage,bool two_stage) {/* NOTE: the env->pc value visible here will not be * correct, but the value visible to the exception handler
@@ -316,13 +317,40 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical,MemTxResult res;MemTxAttrs attrs =MEMTXATTRS_UNSPECIFIED ;int mode = mmu_idx; +bool use_background = false; +/* +* Check if we should use the background registers for the two +* stage translation. We don't need to check if we actually need +* two stage translation as that happened before this function +* was called. Background registers will be used if the guest has +* forced a two stage translation to be on (in HS or M mode). +*/ if (mode ==PRV_M && access_type !=MMU_INST_FETCH ) {if (get_field (*env->mstatus,MSTATUS_MPRV )) { mode =get_field (*env->mstatus,MSTATUS_MPP ); + +if (riscv_has_ext (env,RVH ) && +get_field (*env->mstatus,MSTATUS_MPV )) { + use_background = true; + } + } + } + +if (mode ==PRV_S && access_type !=MMU_INST_FETCH && +riscv_has_ext (env,RVH ) && !riscv_cpu_virt_enabled (env)) { +if (get_field (env->hstatus,HSTATUS_SPRV )) { + mode =get_field (*env->mstatus,SSTATUS_SPP ); + use_background = true; } } +if (first_stage == false) { +/* We are in stage 2 translation, this is similar to stage 1. */ +/* Stage 2 is always taken as U-mode */ + mode =PRV_U ; + } +if (mode ==PRV_M || !riscv_feature (env,RISCV_FEATURE_MMU )) { *physical = addr; *prot =PAGE_READ |PAGE_WRITE |PAGE_EXEC ;
@@ -332,13 +360,30 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical, *prot =0 ;hwaddr base; -int levels, ptidxbits, ptesize, vm, sum; -int mxr =get_field (*env->mstatus,MSTATUS_MXR ); +int levels, ptidxbits, ptesize, vm, sum, mxr, widened; + +if (first_stage == true) { + mxr =get_field (*env->mstatus,MSTATUS_MXR ); + }else { + mxr =get_field (env->vsstatus,MSTATUS_MXR ); + }if (env->priv_ver >=PRIV_VERSION_1_10_0 ) { - base = (hwaddr )get_field (env->satp,SATP_PPN ) <<PGSHIFT ; +if (first_stage == true) { +if (use_background) { + base = (hwaddr )get_field (env->vsatp,SATP_PPN ) <<PGSHIFT ; + vm =get_field (env->vsatp,SATP_MODE ); + }else { + base = (hwaddr )get_field (env->satp,SATP_PPN ) <<PGSHIFT ; + vm =get_field (env->satp,SATP_MODE ); + } + widened =0 ; + }else { + base = (hwaddr )get_field (env->hgatp,HGATP_PPN ) <<PGSHIFT ; + vm =get_field (env->hgatp,HGATP_MODE ); + widened =2 ; + } sum =get_field (*env->mstatus,MSTATUS_SUM ); - vm =get_field (env->satp,SATP_MODE );switch (vm) {case VM_1_10_SV32 : levels =2 ; ptidxbits =10 ; ptesize =4 ;break ;
@@ -356,6 +401,7 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical,g_assert_not_reached (); } }else { + widened =0 ; base = (hwaddr)(env->sptbr) <<PGSHIFT ; sum = !get_field (*env->mstatus,MSTATUS_PUM ); vm =get_field (*env->mstatus,MSTATUS_VM );
@@ -376,9 +422,16 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical, }CPUState *cs =env_cpu (env); -int va_bits =PGSHIFT + levels * ptidxbits; -target_ulong mask = (1L << (TARGET_LONG_BITS - (va_bits -1 ))) -1 ; -target_ulong masked_msbs = (addr >> (va_bits -1 )) & mask; +int va_bits =PGSHIFT + levels * ptidxbits + widened; +target_ulong mask, masked_msbs; + +if (TARGET_LONG_BITS > (va_bits -1 )) { + mask = (1L << (TARGET_LONG_BITS - (va_bits -1 ))) -1 ; + }else { + mask =0 ; + } + masked_msbs = (addr >> (va_bits -1 )) & mask; +if (masked_msbs !=0 && masked_msbs != mask) {return TRANSLATE_FAIL ; }
@@ -390,11 +443,29 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical, restart: #endif for (i = 0; i < levels; i++, ptshift -= ptidxbits) { - target_ulong idx = (addr >> (PGSHIFT + ptshift)) & + target_ulong idx; + if (i == 0) { + idx = (addr >> (PGSHIFT + ptshift)) & + ((1 << (ptidxbits + widened)) - 1); + } else { + idx = (addr >> (PGSHIFT + ptshift)) & ((1 << ptidxbits) - 1); + } /* check that physical address of PTE is legal */ - hwaddr pte_addr = base + idx * ptesize; + hwaddr pte_addr; + + if (two_stage && first_stage) { + hwaddr vbase; + + /* Do the second stage translation on the base PTE address. */ + get_physical_address(env, &vbase, prot, base, access_type, + mmu_idx, false, true); + + pte_addr = vbase + idx * ptesize; + } else { + pte_addr = base + idx * ptesize; + } if (riscv_feature(env, RISCV_FEATURE_PMP) && !pmp_hart_has_privs(env, pte_addr, sizeof(target_ulong),
@@ -491,7 +562,12 @@ restart:/* for superpage mappings, make a fake leaf PTE for the TLB's benefit. */ target_ulong vpn = addr >>PGSHIFT ; - *physical = (ppn | (vpn & ((1L << ptshift) -1 ))) <<PGSHIFT ; +if (i ==0 ) { + *physical = (ppn | (vpn & ((1L << (ptshift + widened)) -1 ))) << +PGSHIFT ; + }else { + *physical = (ppn | (vpn & ((1L << ptshift) -1 ))) <<PGSHIFT ; + }/* set permissions on the TLB entry */ if ((pte &PTE_R ) || ((pte &PTE_X ) && mxr)) {
@@ -550,14 +626,23 @@ static void raise_mmu_exception(CPURISCVState *env, target_ulong address,hwaddr riscv_cpu_get_phys_page_debug (CPUState *cs,vaddr addr) {RISCVCPU *cpu =RISCV_CPU (cs); +CPURISCVState *env = &cpu->env;hwaddr phys_addr;int prot;int mmu_idx =cpu_mmu_index (&cpu->env, false); -if (get_physical_address (&cpu->env, &phys_addr, &prot, addr,0 , mmu_idx, - true)) { +if (get_physical_address (env, &phys_addr, &prot, addr,0 , mmu_idx, + true,riscv_cpu_virt_enabled (env))) {return -1 ; } + +if (riscv_cpu_virt_enabled (env)) { +if (get_physical_address (env, &phys_addr, &prot, phys_addr, +0 , mmu_idx, false, true)) { +return -1 ; + } + } +return phys_addr; }
@@ -611,18 +696,36 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,RISCVCPU *cpu =RISCV_CPU (cs);CPURISCVState *env = &cpu->env;#ifndef CONFIG_USER_ONLY +vaddr im_address;hwaddr pa =0 ;int prot;int pmp_size =0 ;bool pmp_violation = false; +bool m_mode_two_stage = false; +bool hs_mode_two_stage = false; +bool first_stage_error = true;int ret =TRANSLATE_FAIL ;int mode = mmu_idx;qemu_log_mask (CPU_LOG_MMU ,"%s ad %" VADDR_PRIx" rw %d mmu_idx %d\n" , __func__, address, access_type, mmu_idx); - ret =get_physical_address (env, &pa, &prot, address, access_type, mmu_idx, - true); +/* +* Determine if we are in M mode and MPRV is set or in HS mode and SPRV is +* set and we want to access a virtulisation address. +*/ +if (riscv_has_ext (env,RVH )) { + m_mode_two_stage = env->priv ==PRV_M && + access_type !=MMU_INST_FETCH && +get_field (*env->mstatus,MSTATUS_MPRV ) && +get_field (*env->mstatus,MSTATUS_MPV ); + + hs_mode_two_stage = env->priv ==PRV_S && + !riscv_cpu_virt_enabled (env) && + access_type !=MMU_INST_FETCH && +get_field (env->hstatus,HSTATUS_SPRV ) && +get_field (env->hstatus,HSTATUS_SPV ); + }if (mode ==PRV_M && access_type !=MMU_INST_FETCH ) {if (get_field (*env->mstatus,MSTATUS_MPRV )) {
@@ -630,9 +733,56 @@ bool riscv_cpu_tlb_fill(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 (riscv_cpu_virt_enabled (env) || m_mode_two_stage || hs_mode_two_stage) { +/* Two stage lookup */ + ret =get_physical_address (env, &pa, &prot, address, access_type, + mmu_idx, true, true); + +qemu_log_mask (CPU_LOG_MMU , +"%s 1st-stage address=%" VADDR_PRIx" ret %d physical " + TARGET_FMT_plx" prot %d\n" , + __func__, address, ret, pa, prot); + +if (ret ==TRANSLATE_FAIL ) { + goto tlb_lookup_done; + } + +/* Second stage lookup */ + im_address = pa; + + ret =get_physical_address (env, &pa, &prot, im_address, access_type, mmu_idx, + false, true); + +qemu_log_mask (CPU_LOG_MMU , +"%s 2nd-stage address=%" VADDR_PRIx" ret %d physical " + TARGET_FMT_plx" prot %d\n" , + __func__, im_address, ret, pa, prot); + +if (riscv_feature (env,RISCV_FEATURE_PMP ) && + (ret ==TRANSLATE_SUCCESS ) && + !pmp_hart_has_privs (env, pa, size,1 << access_type, mode)) { + ret =TRANSLATE_PMP_FAIL ; + } + +if (ret !=TRANSLATE_SUCCESS ) { +/* +* Guest physical address translation failed, this is a HS +* level exception +*/ + first_stage_error = false; + address = im_address | (address & (TARGET_PAGE_SIZE -1 )); + goto tlb_lookup_done; + } + }else { +/* Single stage lookup */ + ret =get_physical_address (env, &pa, &prot, address, access_type, + mmu_idx, true, false); + +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 size is unknown (0), assume that all bytes
@@ -644,6 +794,7 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, pmp_size = size; } +tlb_lookup_done:if (riscv_feature (env,RISCV_FEATURE_PMP ) && (ret ==TRANSLATE_SUCCESS ) && !pmp_hart_has_privs (env, pa, pmp_size,1 << access_type, mode)) {
@@ -652,6 +803,7 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,if (ret ==TRANSLATE_PMP_FAIL ) { pmp_violation = true; } +if (ret ==TRANSLATE_SUCCESS ) {tlb_set_page (cs, address &TARGET_PAGE_MASK , pa &TARGET_PAGE_MASK , prot, mmu_idx,TARGET_PAGE_SIZE );
@@ -659,9 +811,12 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, } else if (probe) {return false; }else { -raise_mmu_exception (env, address, access_type, pmp_violation, true); +raise_mmu_exception (env, address, access_type, pmp_violation, first_stage_error);riscv_raise_exception (env, cs->exception_index, retaddr); } + +return true; +#else switch (access_type) {case MMU_INST_FETCH :
Signature · 1 line
2.23.0
PATCH v2 25/27 target/riscv: Add support for the 32-bit MSTATUSH CSR
In reply to Alistair Francis--- target/riscv/cpu.c | 6 ++++++ target/riscv/cpu.h | 7 +++++++ target/riscv/cpu_bits.h | 3 +++ target/riscv/cpu_helper.c | 7 +++++++ target/riscv/csr.c | 25 +++++++++++++++++++++++++ target/riscv/op_helper.c | 4 ++++ 6 files changed, 52 insertions(+)
target/riscv/cpu.c +6 -0
@@ -229,6 +229,9 @@ static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)#ifndef CONFIG_USER_ONLY qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mhartid " , env->mhartid);qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mstatus " , *env->mstatus); +#ifdef TARGET_RISCV32 +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mstatush " , *env->mstatush); +#endif if (riscv_has_ext (env,RVH )) {qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"hstatus " , env->hstatus);qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"bstatus " , env->vsstatus);
@@ -467,6 +470,9 @@ static void riscv_cpu_init(Object *obj)#ifndef CONFIG_USER_ONLY env->mie = &env->mie_novirt; env->mstatus = &env->mstatus_novirt; +# ifdef TARGET_RISCV32 + env->mstatush = &env->mstatush_novirt; +# endif #endif }
target/riscv/cpu.h +7 -0
@@ -127,6 +127,10 @@ struct CPURISCVState {target_ulong mip;target_ulong mip_novirt; +#ifdef TARGET_RISCV32 +target_ulong *mstatush; +#endif +uint32_t miclaim;target_ulong *mie;
@@ -154,6 +158,9 @@ struct CPURISCVState {*/ target_ulong mie_novirt;target_ulong mstatus_novirt; +#ifdef TARGET_RISCV32 +target_ulong mstatush_novirt; +#endif /* Hypervisor CSRs */ target_ulong hstatus;
target/riscv/cpu_bits.h +3 -0
@@ -135,6 +135,9 @@#define CSR_MTVEC 0x305#define CSR_MCOUNTEREN 0x306 +/* 32-bit only */ +#define CSR_MSTATUSH 0x310 +/* Legacy Counter Setup (priv v1.9.1) */ /* Update to #define CSR_MCOUNTINHIBIT 0x320 for 1.11.0 */ #define CSR_MUCOUNTEREN 0x320
target/riscv/cpu_helper.c +7 -0
@@ -950,10 +950,17 @@ void riscv_cpu_do_interrupt(CPUState *cs)if (riscv_cpu_virt_enabled (env)) {riscv_cpu_swap_hypervisor_regs (env); } +#ifdef TARGET_RISCV32 + *env->mstatush =set_field (*env->mstatush,MSTATUS_MPV , +riscv_cpu_virt_enabled (env)); + *env->mstatush =set_field (*env->mstatush,MSTATUS_MTL , +riscv_cpu_force_hs_excep_enabled (env)); +#else *env->mstatus =set_field (*env->mstatus,MSTATUS_MPV ,riscv_cpu_virt_enabled (env)); *env->mstatus =set_field (*env->mstatus,MSTATUS_MTL ,riscv_cpu_force_hs_excep_enabled (env)); +#endif /* Trapping to M mode, virt is disabled */ riscv_cpu_set_virt_enabled (env,0 );
target/riscv/csr.c +25 -0
@@ -364,6 +364,27 @@ static int write_mstatus(CPURISCVState *env, int csrno, target_ulong val)return 0 ; } +#ifdef TARGET_RISCV32 +static int read_mstatush (CPURISCVState *env,int csrno,target_ulong *val) +{ + *val = *env->mstatush; +return 0 ; +} + +static int write_mstatush (CPURISCVState *env,int csrno,target_ulong val) +{ +if ((val ^ *env->mstatush) & (MSTATUS_MPV )) { +tlb_flush (env_cpu (env)); + } + + val &=MSTATUS_MPV |MSTATUS_MTL ; + + *env->mstatush = val; + +return 0 ; +} +#endif +static int read_misa (CPURISCVState *env,int csrno,target_ulong *val) { *val = env->misa;
@@ -1102,6 +1123,10 @@ static riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { [CSR_MTVEC] = { any, read_mtvec, write_mtvec }, [CSR_MCOUNTEREN] = { any, read_mcounteren, write_mcounteren }, +#if defined(TARGET_RISCV32) + [CSR_MSTATUSH] = { any, read_mstatush, write_mstatush }, +#endif + /* Legacy Counter Setup (priv v1.9.1) */ [CSR_MUCOUNTEREN] = { any, read_mucounteren, write_mucounteren }, [CSR_MSCOUNTEREN] = { any, read_mscounteren, write_mscounteren },
target/riscv/op_helper.c +4 -0
@@ -153,7 +153,11 @@ target_ulong helper_mret(CPURISCVState *env, target_ulong cpu_pc_deb) get_field(mstatus, MSTATUS_MPIE)); mstatus =set_field (mstatus,MSTATUS_MPIE ,1 ); mstatus =set_field (mstatus,MSTATUS_MPP ,0 ); +#ifdef TARGET_RISCV32 + *env->mstatush =set_field (*env->mstatush,MSTATUS_MPV ,0 ); +#else mstatus =set_field (mstatus,MSTATUS_MPV ,0 ); +#endif *env->mstatus = mstatus;riscv_cpu_set_mode (env, prev_priv);
Signature · 1 line
2.23.0
PATCH v2 26/27 target/riscv: Add the MSTATUS_MPV_ISSET helper macro
In reply to Alistair FrancisAdd a helper macro MSTATUS_MPV_ISSET() which will determine if the MSTATUS_MPV bit is set for both 32-bit and 64-bit RISC-V.
--- target/riscv/cpu_bits.h | 11 +++++++++++ target/riscv/cpu_helper.c | 4 ++-- target/riscv/op_helper.c | 2 +- target/riscv/translate.c | 2 +- 4 files changed, 15 insertions(+), 4 deletions(-)
target/riscv/cpu_bits.h +11 -0
@@ -365,8 +365,19 @@#define MSTATUS_TVM 0x00100000/* since: priv-1.10 */ #define MSTATUS_TW 0x20000000/* since: priv-1.10 */ #define MSTATUS_TSR 0x40000000/* since: priv-1.10 */ +#if defined(TARGET_RISCV64 )#define MSTATUS_MTL 0x4000000000ULL#define MSTATUS_MPV 0x8000000000ULL +#elif defined(TARGET_RISCV32 ) +#define MSTATUS_MTL 0x00000040 +#define MSTATUS_MPV 0x00000080 +#endif + +#ifdef TARGET_RISCV32 +# define MSTATUS_MPV_ISSET (env) get_field(*env->mstatush, MSTATUS_MPV) +#else +# define MSTATUS_MPV_ISSET (env) get_field(*env->mstatus, MSTATUS_MPV) +#endif #define MSTATUS64_UXL 0x0000000300000000ULL#define MSTATUS64_SXL 0x0000000C00000000ULL
target/riscv/cpu_helper.c +2 -2
@@ -331,7 +331,7 @@ static int get_physical_address(CPURISCVState *env, hwaddr *physical, mode =get_field (*env->mstatus,MSTATUS_MPP );if (riscv_has_ext (env,RVH ) && -get_field (*env->mstatus,MSTATUS_MPV )) { +MSTATUS_MPV_ISSET (env)) { use_background = true; } }
@@ -718,7 +718,7 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, m_mode_two_stage = env->priv ==PRV_M && access_type !=MMU_INST_FETCH &&get_field (*env->mstatus,MSTATUS_MPRV ) && -get_field (*env->mstatus,MSTATUS_MPV ); +MSTATUS_MPV_ISSET (env); hs_mode_two_stage = env->priv ==PRV_S && !riscv_cpu_virt_enabled(env) &&
target/riscv/op_helper.c +1 -1
@@ -146,7 +146,7 @@ target_ulong helper_mret(CPURISCVState *env, target_ulong cpu_pc_deb)target_ulong mstatus = *env->mstatus;target_ulong prev_priv =get_field (mstatus,MSTATUS_MPP ); -target_ulong prev_virt =get_field (mstatus,MSTATUS_MPV ); +target_ulong prev_virt =MSTATUS_MPV_ISSET (env); mstatus = set_field(mstatus, env->priv_ver >= PRIV_VERSION_1_10_0 ? MSTATUS_MIE : MSTATUS_UIE << prev_priv,
target/riscv/translate.c +1 -1
@@ -754,7 +754,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs) ctx->virt_enabled =riscv_cpu_virt_enabled (env);if (env->priv_ver ==PRV_M &&get_field (*env->mstatus,MSTATUS_MPRV ) && -get_field (*env->mstatus,MSTATUS_MPV )) { +MSTATUS_MPV_ISSET (env)) { ctx->virt_enabled = true; } else if (env->priv == PRV_S && !riscv_cpu_virt_enabled(env) &&
Signature · 1 line
2.23.0
PATCH v2 27/27 target/riscv: Allow enabling the Hypervisor extension
In reply to Alistair Francis--- target/riscv/cpu.c | 5 +++++ target/riscv/cpu.h | 1 + 2 files changed, 6 insertions(+)
target/riscv/cpu.c +5 -0
@@ -446,6 +446,9 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp)if (cpu->cfg.ext_u) { target_misa |=RVU ; } +if (cpu->cfg.ext_h) { + target_misa |=RVH ; + }set_misa (env,RVXLEN | target_misa); }
@@ -492,6 +495,8 @@ static Property riscv_cpu_properties[] = {DEFINE_PROP_BOOL ("c" ,RISCVCPU , cfg.ext_c, true),DEFINE_PROP_BOOL ("s" ,RISCVCPU , cfg.ext_s, true),DEFINE_PROP_BOOL ("u" ,RISCVCPU , cfg.ext_u, true), +/* This is experimental so mark with 'x-' */ +DEFINE_PROP_BOOL ("x-h" ,RISCVCPU , cfg.ext_h, false),DEFINE_PROP_BOOL ("Counters" ,RISCVCPU , cfg.ext_counters, true),DEFINE_PROP_BOOL ("Zifencei" ,RISCVCPU , cfg.ext_ifencei, true), DEFINE_PROP_BOOL("Zicsr", RISCVCPU, cfg.ext_icsr, true),
target/riscv/cpu.h +1 -0
@@ -258,6 +258,7 @@ typedef struct RISCVCPU {bool ext_c;bool ext_s;bool ext_u; +bool ext_h;bool ext_counters;bool ext_ifencei;bool ext_icsr;
Signature · 1 line
2.23.0