Add riscv kvm accel support
Subsystems (5)
v3 cover Add riscv kvm accel support
This series adds both riscv32 and riscv64 kvm support, and implements migration based on riscv. It is based on temporarily unaccepted kvm:
https://github.com/kvm-riscv/linux
Compared to RFC v2, the migration is supported in this series. The new added migration feature also requires the following patches:
[1]
[PATCH RFC 0/2] Add log dirty support
https://www.mail-archive.com/linux-kernel at vger.kernel.org/msg2284945.html
[2]
[PATCH] target/riscv: raise exception to HS-mode at get_physical_address
https://patchew.org/QEMU/20200824084158.1769-1-jiangyifei at huawei.com/
Several steps to use this:
1. Build emulation
$ ./configure --target-list=riscv64-softmmu $ make -j$(nproc)
2. Build kernel
https://github.com/kvm-riscv/linux
3. Build QEMU VM
I cross built in riscv toolchain.
$ PKG_CONFIG_LIBDIR=<toolchain pkgconfig path> $ export PKG_CONFIG_SYSROOT_DIR=<toolchain sysroot path> $ ./configure --target-list=riscv64-softmmu --enable-kvm \ --cross-prefix=riscv64-linux-gnu- --disable-libiscsi --disable-glusterfs \ --disable-libusb --disable-usb-redir --audio-drv-list= --disable-opengl \ --disable-libxml2 $ make -j$(nproc)
4. Start emulation
$ ./qemu-system-riscv64 -M virt -m 4096M -cpu rv64,x-h=true -nographic \
-name guest=riscv-hyp,debug-threads=on \
-smp 4 \
-bios ./fw_jump.bin \
-kernel ./Image \
-drive file=./hyp.img,format=raw,id=hd0 \
-device virtio-blk-device,drive=hd0 \
-append "root=/dev/vda rw console=ttyS0 earlycon=sbi"5. Start kvm-acceled QEMU VM in emulation
$ ./qemu-system-riscv64 -M virt,accel=kvm -m 1024M -cpu host -nographic \
-name guest=riscv-guset \
-smp 2 \
-bios none \
-kernel ./Image \
-drive file=./guest.img,format=raw,id=hd0 \
-device virtio-blk-device,drive=hd0 \
-append "root=/dev/vda rw console=ttyS0 earlycon=sbi"This following link describes the details about live migration steps:
https://gitee.com/openeuler/qemu/wikis/Live%20migration?sort_id=2767831
Changes since RFC v2
1. Fix checkpatch error at target/riscv/sbi_ecall_interface.h.
2. Add riscv migration support.
Changes since RFC v1
1. Add separate SBI ecall interface header.
2. Add riscv32 kvm accel support.
Yifei Jiang (14):
linux-header: Update linux/kvm.h
target/riscv: Add target/riscv/kvm.c to place the public kvm interface target/riscv: Implement function kvm_arch_init_vcpu target/riscv: Implement kvm_arch_get_registers arget/riscv: Implement kvm_arch_put_registers target/riscv: Support start kernel directly by KVM hw/riscv: PLIC update external interrupt by KVM when kvm enabled target/riscv: Handler KVM_EXIT_RISCV_SBI exit target/riscv: Add host cpu type
target/riscv: Add sifive_plic vmstate
target/riscv: Support riscv cpu vmstate
target/riscv: Add kvm_riscv_get/put_regs_timer target/riscv: Implement virtual time adjusting with vm state changing target/riscv: Support virtual time context synchronization
configure | 1 + hw/riscv/sifive_plic.c | 55 ++- hw/riscv/virt.c | 8 + include/hw/riscv/sifive_plic.h | 1 + linux-headers/linux/kvm.h | 8 + target/riscv/cpu.c | 41 +- target/riscv/cpu.h | 10 + target/riscv/kvm.c | 599 +++++++++++++++++++++++++++++ target/riscv/kvm_riscv.h | 25 ++ target/riscv/meson.build | 1 + target/riscv/sbi_ecall_interface.h | 72 ++++ 11 files changed, 809 insertions(+), 12 deletions(-) create mode 100644 target/riscv/kvm.c create mode 100644 target/riscv/kvm_riscv.h create mode 100644 target/riscv/sbi_ecall_interface.h
Signature · 1 line
2.19.1
RFC PATCH v3 1/14 linux-header: Update linux/kvm.h
Update linux-headers/linux/kvm.h from https://github.com/kvm-riscv/linux.
Only use this header file, so here do not update all linux headers by update-linux-headers.sh until above KVM series is accepted.
--- linux-headers/linux/kvm.h | 8 ++++++++ 1 file changed, 8 insertions(+)
linux-headers/linux/kvm.h +8 -0
@@ -248,6 +248,7 @@ struct kvm_hyperv_exit {#define KVM_EXIT_IOAPIC_EOI 26#define KVM_EXIT_HYPERV 27#define KVM_EXIT_ARM_NISV 28 +#define KVM_EXIT_RISCV_SBI 28/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */
@@ -412,6 +413,13 @@ struct kvm_run {__u64 esr_iss;__u64 fault_ipa; } arm_nisv; +/* KVM_EXIT_RISCV_SBI */ +struct { +unsigned long extension_id; +unsigned long function_id; +unsigned long args[6 ]; +unsigned long ret[2 ]; + } riscv_sbi;/* Fix the size of the union. */ char padding[256 ]; };
Signature · 1 line
2.19.1
RFC PATCH v3 2/14 target/riscv: Add target/riscv/kvm.c to place the public kvm interface
In reply to Yifei JiangAdd target/riscv/kvm.c to place kvm_arch_* function needed by kvm/kvm-all.c. Meanwhile, add kvm support in configure file.
--- configure | 1 + target/riscv/kvm.c | 128 +++++++++++++++++++++++++++++++++++++++ target/riscv/meson.build | 1 + 3 files changed, 130 insertions(+) create mode 100644 target/riscv/kvm.c
configure +1 -0
@@ -269,6 +269,7 @@ supported_kvm_target() { x86_64:i386 | x86_64:x86_64 | x86_64:x32 | \ mips:mips | mipsel:mips | mips64:mips | mips64el:mips | \ ppc:ppc | ppc64:ppc | ppc:ppc64 | ppc64:ppc64 | ppc64:ppc64le | \ + riscv32:riscv32 | riscv64:riscv64 | \ s390x:s390x) return 0 ;;
target/riscv/kvm.c new file +128 -0
128 lines not on this page · raw message
target/riscv/meson.build +1 -0
@@ -23,6 +23,7 @@ riscv_ss.add(files( 'vector_helper.c', 'translate.c', )) +riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c')) riscv_softmmu_ss = ss.source_set() riscv_softmmu_ss.add(files(
Signature · 1 line
2.19.1
RFC PATCH v3 3/14 target/riscv: Implement function kvm_arch_init_vcpu
In reply to Yifei JiangGet isa info from kvm while kvm init.
--- target/riscv/kvm.c | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-)
target/riscv/kvm.c +25 -1
@@ -38,6 +38,18 @@#include "qemu/log.h" #include "hw/loader.h" +static __u64 kvm_riscv_reg_id (__u64 type,__u64 idx) +{ +__u64 id =KVM_REG_RISCV | type | idx; + +#if defined(TARGET_RISCV32 ) + id |=KVM_REG_SIZE_U32 ; +#elif defined(TARGET_RISCV64 ) + id |=KVM_REG_SIZE_U64 ; +#endif +return id; +} +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };
@@ -79,7 +91,19 @@ void kvm_arch_init_irq_routing(KVMState *s)int kvm_arch_init_vcpu (CPUState *cs) { -return 0 ; +int ret =0 ; +target_ulong isa; +RISCVCPU *cpu =RISCV_CPU (cs); +__u64 id; + + id =kvm_riscv_reg_id (KVM_REG_RISCV_CONFIG ,KVM_REG_RISCV_CONFIG_REG (isa)); + ret =kvm_get_one_reg (cs, id, &isa); +if (ret) { +return ret; + } + cpu->env.misa = isa; + +return ret; }int kvm_arch_msi_data_to_gsi (uint32_t data)
Signature · 1 line
2.19.1
RFC PATCH v3 4/14 target/riscv: Implement kvm_arch_get_registers
In reply to Yifei JiangGet GPR CSR and FP registers from kvm by KVM_GET_ONE_REG ioctl.
--- target/riscv/kvm.c | 150 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 149 insertions(+), 1 deletion(-)
target/riscv/kvm.c +149 -1
@@ -50,13 +50,161 @@ static __u64 kvm_riscv_reg_id(__u64 type, __u64 idx)return id; } +#define RISCV_CORE_REG (name) kvm_riscv_reg_id(KVM_REG_RISCV_CORE, \ + KVM_REG_RISCV_CORE_REG(name)) + +#define RISCV_CSR_REG (name) kvm_riscv_reg_id(KVM_REG_RISCV_CSR, \ + KVM_REG_RISCV_CSR_REG(name)) + +#define RISCV_FP_F_REG (idx) kvm_riscv_reg_id(KVM_REG_RISCV_FP_F, idx) + +#define RISCV_FP_D_REG (idx) kvm_riscv_reg_id(KVM_REG_RISCV_FP_D, idx) + +static int kvm_riscv_get_regs_core (CPUState *cs) +{ +int ret =0 ; +int i; +target_ulong reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + + ret =kvm_get_one_reg (cs,RISCV_CORE_REG (regs.pc), ®); +if (ret) { +return ret; + } + env->pc = reg; + +for (i =1 ; i <32 ; i++) { +__u64 id =kvm_riscv_reg_id (KVM_REG_RISCV_CORE , i); + ret =kvm_get_one_reg (cs, id, ®); +if (ret) { +return ret; + } + env->gpr[i] = reg; + } + +return ret; +} + +static int kvm_riscv_get_regs_csr (CPUState *cs) +{ +int ret =0 ; +target_ulong reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (sstatus), ®); +if (ret) { +return ret; + } + env->mstatus = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (sie), ®); +if (ret) { +return ret; + } + env->mie = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (stvec), ®); +if (ret) { +return ret; + } + env->stvec = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (sscratch), ®); +if (ret) { +return ret; + } + env->sscratch = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (sepc), ®); +if (ret) { +return ret; + } + env->sepc = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (scause), ®); +if (ret) { +return ret; + } + env->scause = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (stval), ®); +if (ret) { +return ret; + } + env->sbadaddr = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (sip), ®); +if (ret) { +return ret; + } + env->mip = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (satp), ®); +if (ret) { +return ret; + } + env->satp = reg; + +return ret; +} + +static int kvm_riscv_get_regs_fp (CPUState *cs) +{ +int ret =0 ; +int i; +CPURISCVState *env = &RISCV_CPU (cs)->env; + +if (riscv_has_ext (env,RVD )) { +uint64_t reg; +for (i =0 ; i <32 ; i++) { + ret =kvm_get_one_reg (cs,RISCV_FP_D_REG (i), ®); +if (ret) { +return ret; + } + env->fpr[i] = reg; + } +return ret; + } + +if (riscv_has_ext (env,RVF )) { +uint32_t reg; +for (i =0 ; i <32 ; i++) { + ret =kvm_get_one_reg (cs,RISCV_FP_F_REG (i), ®); +if (ret) { +return ret; + } + env->fpr[i] = reg; + } +return ret; + } + +return ret; +} +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };int kvm_arch_get_registers (CPUState *cs) { -return 0 ; +int ret =0 ; + + ret =kvm_riscv_get_regs_core (cs); +if (ret) { +return ret; + } + + ret =kvm_riscv_get_regs_csr (cs); +if (ret) { +return ret; + } + + ret =kvm_riscv_get_regs_fp (cs); +if (ret) { +return ret; + } + +return ret; }int kvm_arch_put_registers (CPUState *cs,int level)
Signature · 1 line
2.19.1
RFC PATCH v3 5/14 arget/riscv: Implement kvm_arch_put_registers
In reply to Yifei JiangPut GPR CSR and FP registers to kvm by KVM_SET_ONE_REG ioctl
--- target/riscv/kvm.c | 142 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 141 insertions(+), 1 deletion(-)
target/riscv/kvm.c +141 -1
@@ -85,6 +85,31 @@ static int kvm_riscv_get_regs_core(CPUState *cs)return ret; } +static int kvm_riscv_put_regs_core (CPUState *cs) +{ +int ret =0 ; +int i; +target_ulong reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + + reg = env->pc; + ret =kvm_set_one_reg (cs,RISCV_CORE_REG (regs.pc), ®); +if (ret) { +return ret; + } + +for (i =1 ; i <32 ; i++) { +__u64 id =kvm_riscv_reg_id (KVM_REG_RISCV_CORE , i); + reg = env->gpr[i]; + ret =kvm_set_one_reg (cs, id, ®); +if (ret) { +return ret; + } + } + +return ret; +} +static int kvm_riscv_get_regs_csr (CPUState *cs) {int ret =0 ;
@@ -148,6 +173,70 @@ static int kvm_riscv_get_regs_csr(CPUState *cs)return ret; } +static int kvm_riscv_put_regs_csr (CPUState *cs) +{ +int ret =0 ; +target_ulong reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + + reg = env->mstatus; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (sstatus), ®); +if (ret) { +return ret; + } + + reg = env->mie; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (sie), ®); +if (ret) { +return ret; + } + + reg = env->stvec; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (stvec), ®); +if (ret) { +return ret; + } + + reg = env->sscratch; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (sscratch), ®); +if (ret) { +return ret; + } + + reg = env->sepc; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (sepc), ®); +if (ret) { +return ret; + } + + reg = env->scause; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (scause), ®); +if (ret) { +return ret; + } + + reg = env->sbadaddr; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (stval), ®); +if (ret) { +return ret; + } + + reg = env->mip; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (sip), ®); +if (ret) { +return ret; + } + + reg = env->satp; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (satp), ®); +if (ret) { +return ret; + } + +return ret; +} + +static int kvm_riscv_get_regs_fp (CPUState *cs) {int ret =0 ;
@@ -181,6 +270,40 @@ static int kvm_riscv_get_regs_fp(CPUState *cs)return ret; } +static int kvm_riscv_put_regs_fp (CPUState *cs) +{ +int ret =0 ; +int i; +CPURISCVState *env = &RISCV_CPU (cs)->env; + +if (riscv_has_ext (env,RVD )) { +uint64_t reg; +for (i =0 ; i <32 ; i++) { + reg = env->fpr[i]; + ret =kvm_set_one_reg (cs,RISCV_FP_D_REG (i), ®); +if (ret) { +return ret; + } + } +return ret; + } + +if (riscv_has_ext (env,RVF )) { +uint32_t reg; +for (i =0 ; i <32 ; i++) { + reg = env->fpr[i]; + ret =kvm_set_one_reg (cs,RISCV_FP_F_REG (i), ®); +if (ret) { +return ret; + } + } +return ret; + } + +return ret; +} + +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };
@@ -209,7 +332,24 @@ int kvm_arch_get_registers(CPUState *cs)int kvm_arch_put_registers (CPUState *cs,int level) { -return 0 ; +int ret =0 ; + + ret =kvm_riscv_put_regs_core (cs); +if (ret) { +return ret; + } + + ret =kvm_riscv_put_regs_csr (cs); +if (ret) { +return ret; + } + + ret =kvm_riscv_put_regs_fp (cs); +if (ret) { +return ret; + } + +return ret; }int kvm_arch_release_virq_post (int virq)
Signature · 1 line
2.19.1
RFC PATCH v3 6/14 target/riscv: Support start kernel directly by KVM
In reply to Yifei JiangGet kernel and fdt start address in virt.c, and pass them to KVM when cpu reset. In addition, add kvm_riscv.h to place riscv specific interface.
--- hw/riscv/virt.c | 8 ++++++++ target/riscv/cpu.c | 4 ++++ target/riscv/cpu.h | 3 +++ target/riscv/kvm.c | 14 ++++++++++++++ target/riscv/kvm_riscv.h | 24 ++++++++++++++++++++++++ 5 files changed, 53 insertions(+) create mode 100644 target/riscv/kvm_riscv.h
hw/riscv/virt.c +8 -0
@@ -41,6 +41,7 @@#include "sysemu/sysemu.h" #include "hw/pci/pci.h" #include "hw/pci-host/gpex.h" +#include "sysemu/kvm.h" #if defined(TARGET_RISCV32 )# define BIOS_FILENAME "opensbi-riscv32-generic-fw_dynamic.bin"
@@ -482,6 +483,7 @@ static void virt_machine_init(MachineState *machine)uint64_t kernel_entry;int i;unsigned int smp_cpus = machine->smp.cpus; +CPUState *cs;/* Initialize SOC */ object_initialize_child(OBJECT(machine), "soc", &s->soc,
@@ -547,6 +549,12 @@ static void virt_machine_init(MachineState *machine) virt_memmap[VIRT_MROM ].size, kernel_entry, fdt_load_addr, s->fdt); +for (cs = first_cpu; cs; cs =CPU_NEXT (cs)) { +RISCVCPU *riscv_cpu =RISCV_CPU (cs); + riscv_cpu->env.kernel_addr = kernel_entry; + riscv_cpu->env.fdt_addr = fdt_load_addr; + } +/* create PLIC hart topology configuration string */ plic_hart_config_len = (strlen (VIRT_PLIC_HART_CONFIG ) +1 ) * smp_cpus; plic_hart_config =g_malloc0 (plic_hart_config_len);
target/riscv/cpu.c +4 -0
@@ -28,6 +28,7 @@#include "hw/qdev-properties.h" #include "migration/vmstate.h" #include "fpu/softfloat-helpers.h" +#include "kvm_riscv.h" /* RISC-V CPU definitions */
@@ -321,6 +322,9 @@ static void riscv_cpu_reset(DeviceState *dev) cs->exception_index =EXCP_NONE ; env->load_res =-1 ;set_default_nan_mode (1 , &env->fp_status); +#ifdef CONFIG_KVM +kvm_riscv_reset_vcpu (cpu); +#endif }static void riscv_cpu_disas_set_info (CPUState *s,disassemble_info *info)
target/riscv/cpu.h +3 -0
@@ -229,6 +229,9 @@ struct CPURISCVState {/* Fields from here on are preserved across CPU reset. */ QEMUTimer *timer;/* Internal timer */ + +hwaddr kernel_addr; +hwaddr fdt_addr; };#define RISCV_CPU_CLASS (klass) \
target/riscv/kvm.c +14 -0
@@ -37,6 +37,7 @@#include "hw/irq.h" #include "qemu/log.h" #include "hw/loader.h" +#include "kvm_riscv.h" static __u64 kvm_riscv_reg_id (__u64 type,__u64 idx) {
@@ -438,3 +439,16 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) {return 0 ; } + +void kvm_riscv_reset_vcpu (RISCVCPU *cpu) +{ +CPURISCVState *env = &cpu->env; + +if (!kvm_enabled ()) { +return ; + } + env->pc = cpu->env.kernel_addr; + env->gpr[10 ] =kvm_arch_vcpu_id (CPU (cpu));/* a0 */ + env->gpr[11 ] = cpu->env.fdt_addr;/* a1 */ +} +
target/riscv/kvm_riscv.h new file +24 -0
@@ -0,0 +1,24 @@ +/* +* QEMU KVM support -- RISC-V specific functions. +* +* Copyright (c) 2020 Huawei Technologies Co., Ltd +* +* This program is free software; you can redistribute it and/or modify it +* under the terms and conditions of the GNU General Public License, +* version 2 or later, as published by the Free Software Foundation. +* +* This program is distributed in the hope it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +* more details. +* +* You should have received a copy of the GNU General Public License along with +* this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef QEMU_KVM_RISCV_H +#define QEMU_KVM_RISCV_H + +void kvm_riscv_reset_vcpu (RISCVCPU *cpu); + +#endif
Signature · 1 line
2.19.1
RFC PATCH v3 7/14 hw/riscv: PLIC update external interrupt by KVM when kvm enabled
In reply to Yifei JiangOnly support supervisor external interrupt currently.
--- hw/riscv/sifive_plic.c | 31 ++++++++++++++++++++++--------- target/riscv/kvm.c | 19 +++++++++++++++++++ target/riscv/kvm_riscv.h | 1 + 3 files changed, 42 insertions(+), 9 deletions(-)
hw/riscv/sifive_plic.c +22 -9
@@ -30,6 +30,8 @@#include "target/riscv/cpu.h" #include "sysemu/sysemu.h" #include "hw/riscv/sifive_plic.h" +#include "sysemu/kvm.h" +#include "kvm_riscv.h" #define RISCV_DEBUG_PLIC 0
@@ -146,15 +148,26 @@ static void sifive_plic_update(SiFivePLICState *plic)continue ; }int level =sifive_plic_irqs_pending (plic, addrid); -switch (mode) { -case PLICMode_M: -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)); -break ; -default : -break ; +if (kvm_enabled ()) { +if (mode == PLICMode_M) { +continue ; + } +#ifdef CONFIG_KVM +kvm_riscv_set_irq (RISCV_CPU (cpu),IRQ_S_EXT , level); +#endif + }else { +switch (mode) { +case PLICMode_M: +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)); +break ; +default : +break ; + } } }
target/riscv/kvm.c +19 -0
@@ -452,3 +452,22 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) env->gpr[11 ] = cpu->env.fdt_addr;/* a1 */ } +void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level) +{ +int ret; +unsigned virq = level ?KVM_INTERRUPT_SET :KVM_INTERRUPT_UNSET ; + +if (irq !=IRQ_S_EXT ) { +return ; + } + +if (!kvm_enabled ()) { +return ; + } + + ret =kvm_vcpu_ioctl (CPU (cpu),KVM_INTERRUPT , &virq); +if (ret <0 ) { +perror ("Set irq failed" ); +abort (); + } +}
target/riscv/kvm_riscv.h +1 -0
@@ -20,5 +20,6 @@#define QEMU_KVM_RISCV_H void kvm_riscv_reset_vcpu (RISCVCPU *cpu); +void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level);#endif
Signature · 1 line
2.19.1
RFC PATCH v3 8/14 target/riscv: Handler KVM_EXIT_RISCV_SBI exit
In reply to Yifei JiangUse char-fe handler console sbi call, which implement early console io while apply 'earlycon=sbi' into kernel parameters.
--- target/riscv/kvm.c | 42 ++++++++++++++++- target/riscv/sbi_ecall_interface.h | 72 ++++++++++++++++++++++++++++++ 2 files changed, 113 insertions(+), 1 deletion(-) create mode 100644 target/riscv/sbi_ecall_interface.h
target/riscv/kvm.c +41 -1
@@ -38,6 +38,8 @@#include "qemu/log.h" #include "hw/loader.h" #include "kvm_riscv.h" +#include "sbi_ecall_interface.h" +#include "chardev/char-fe.h" static __u64 kvm_riscv_reg_id (__u64 type,__u64 idx) {
@@ -435,9 +437,47 @@ bool kvm_arch_stop_on_emulation_error(CPUState *cs)return true; } +static int kvm_riscv_handle_sbi (struct kvm_run *run) +{ +int ret =0 ; +unsigned char ch; +switch (run->riscv_sbi.extension_id) { +case SBI_EXT_0_1_CONSOLE_PUTCHAR : + ch = run->riscv_sbi.args[0 ]; +qemu_chr_fe_write (serial_hd (0 )->be, &ch,sizeof (ch)); +break ; +case SBI_EXT_0_1_CONSOLE_GETCHAR : + ret =qemu_chr_fe_read_all (serial_hd (0 )->be, &ch,sizeof (ch)); +if (ret ==sizeof (ch)) { + run->riscv_sbi.args[0 ] = ch; + }else { + run->riscv_sbi.args[0 ] =-1 ; + } +break ; +default : +qemu_log_mask (LOG_UNIMP , +"%s: un-handled SBI EXIT, specific reasons is %lu\n" , + __func__, run->riscv_sbi.extension_id); + ret =-1 ; +break ; + } +return ret; +} +int kvm_arch_handle_exit (CPUState *cs,struct kvm_run *run) { -return 0 ; +int ret =0 ; +switch (run->exit_reason) { +case KVM_EXIT_RISCV_SBI : + ret =kvm_riscv_handle_sbi (run); +break ; +default : +qemu_log_mask (LOG_UNIMP ,"%s: un-handled exit reason %d\n" , + __func__, run->exit_reason); + ret =-1 ; +break ; + } +return ret; }void kvm_riscv_reset_vcpu (RISCVCPU *cpu)
target/riscv/sbi_ecall_interface.h new file +72 -0
72 lines not on this page · raw message
Signature · 1 line
2.19.1
RFC PATCH v3 9/14 target/riscv: Add host cpu type
In reply to Yifei JiangCurrently, host cpu is inherited simply.
--- target/riscv/cpu.c | 6 ++++++ target/riscv/cpu.h | 1 + 2 files changed, 7 insertions(+)
target/riscv/cpu.c +6 -0
@@ -179,6 +179,10 @@ static void rv32_imafcu_nommu_cpu_init(Object *obj)#endif +static void riscv_host_cpu_init (Object *obj) +{ +} +static ObjectClass *riscv_cpu_class_by_name (const char *cpu_model) {ObjectClass *oc;
@@ -635,10 +639,12 @@ static const TypeInfo riscv_cpu_type_infos[] = { DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E31, rvxx_sifive_e_cpu_init), DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E34, rv32_imafcu_nommu_cpu_init), DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_U34, rvxx_sifive_u_cpu_init), + DEFINE_CPU(TYPE_RISCV_CPU_HOST, riscv_host_cpu_init), #elif defined(TARGET_RISCV64)DEFINE_CPU (TYPE_RISCV_CPU_BASE64 , riscv_base_cpu_init),DEFINE_CPU (TYPE_RISCV_CPU_SIFIVE_E51 , rvxx_sifive_e_cpu_init),DEFINE_CPU (TYPE_RISCV_CPU_SIFIVE_U54 , rvxx_sifive_u_cpu_init), + DEFINE_CPU(TYPE_RISCV_CPU_HOST, riscv_host_cpu_init), #endif };
target/riscv/cpu.h +1 -0
@@ -42,6 +42,7 @@#define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51")#define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34")#define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54") +#define TYPE_RISCV_CPU_HOST RISCV_CPU_TYPE_NAME("host")#define RV32 ((target_ulong)1 << (TARGET_LONG_BITS - 2))#define RV64 ((target_ulong)2 << (TARGET_LONG_BITS - 2))
Signature · 1 line
2.19.1
RFC PATCH v3 10/14 target/riscv: Add sifive_plic vmstate
In reply to Yifei JiangAdd sifive_plic vmstate for supporting sifive_plic migration. Current vmstate framework only supports one structure parameter as num field to describe variable length arrays, so introduce num_enables.
--- hw/riscv/sifive_plic.c | 24 +++++++++++++++++++++++- include/hw/riscv/sifive_plic.h | 1 + 2 files changed, 24 insertions(+), 1 deletion(-)
hw/riscv/sifive_plic.c +23 -1
@@ -32,6 +32,7 @@#include "hw/riscv/sifive_plic.h" #include "sysemu/kvm.h" #include "kvm_riscv.h" +#include "migration/vmstate.h" #define RISCV_DEBUG_PLIC 0
@@ -460,11 +461,12 @@ static void sifive_plic_realize(DeviceState *dev, Error **errp) TYPE_SIFIVE_PLIC, plic->aperture_size);parse_hart_config (plic); plic->bitfield_words = (plic->num_sources +31 ) >>5 ; + plic->num_enables = plic->bitfield_words * plic->num_addrs; plic->source_priority =g_new0 (uint32_t, plic->num_sources); plic->target_priority =g_new (uint32_t, plic->num_addrs); plic->pending =g_new0 (uint32_t, plic->bitfield_words); plic->claimed =g_new0 (uint32_t, plic->bitfield_words); - plic->enable =g_new0 (uint32_t, plic->bitfield_words * plic->num_addrs); + plic->enable =g_new0 (uint32_t, plic->num_enables);sysbus_init_mmio (SYS_BUS_DEVICE (dev), &plic->mmio);qdev_init_gpio_in (dev, sifive_plic_irq_request, plic->num_sources);
@@ -484,12 +486,32 @@ static void sifive_plic_realize(DeviceState *dev, Error **errp) msi_nonbroken = true; } +static const VMStateDescription vmstate_sifive_plic = { + .name ="riscv_sifive_plic" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_VARRAY_UINT32 (source_priority, SiFivePLICState, num_sources,0 , + vmstate_info_uint32, uint32_t), +VMSTATE_VARRAY_UINT32 (target_priority, SiFivePLICState, num_addrs,0 , + vmstate_info_uint32, uint32_t), +VMSTATE_VARRAY_UINT32 (pending, SiFivePLICState, bitfield_words,0 , + vmstate_info_uint32, uint32_t), +VMSTATE_VARRAY_UINT32 (claimed, SiFivePLICState, bitfield_words,0 , + vmstate_info_uint32, uint32_t), +VMSTATE_VARRAY_UINT32 (enable, SiFivePLICState, num_enables,0 , + vmstate_info_uint32, uint32_t), +VMSTATE_END_OF_LIST () + } +}; +static void sifive_plic_class_init (ObjectClass *klass,void *data) {DeviceClass *dc =DEVICE_CLASS (klass);device_class_set_props (dc, sifive_plic_properties); dc->realize = sifive_plic_realize; + dc->vmsd = &vmstate_sifive_plic; }static const TypeInfo sifive_plic_info = {
include/hw/riscv/sifive_plic.h +1 -0
@@ -49,6 +49,7 @@ typedef struct SiFivePLICState {MemoryRegion mmio;uint32_t num_addrs;uint32_t bitfield_words; +uint32_t num_enables;PLICAddr *addr_config;uint32_t *source_priority;uint32_t *target_priority;
Signature · 1 line
2.19.1
RFC PATCH v3 11/14 target/riscv: Support riscv cpu vmstate
In reply to Yifei JiangDescribe gpr, fpr and csr in vmstate_riscv_cpu.
--- target/riscv/cpu.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-)
target/riscv/cpu.c +18 -2
@@ -26,7 +26,7 @@#include "qapi/error.h" #include "qemu/error-report.h" #include "hw/qdev-properties.h" -#include "migration/vmstate.h" +#include "migration/cpu.h" #include "fpu/softfloat-helpers.h" #include "kvm_riscv.h"
@@ -499,7 +499,23 @@ static void riscv_cpu_init(Object *obj)#ifndef CONFIG_USER_ONLY static const VMStateDescription vmstate_riscv_cpu = { .name ="cpu" , - .unmigratable =1 , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_UINTTL_ARRAY (env.gpr,RISCVCPU ,32 ), +VMSTATE_UINT64_ARRAY (env.fpr,RISCVCPU ,32 ), +VMSTATE_UINTTL (env.pc,RISCVCPU ), +VMSTATE_UINTTL (env.mstatus,RISCVCPU ), +VMSTATE_UINTTL (env.mie,RISCVCPU ), +VMSTATE_UINTTL (env.stvec,RISCVCPU ), +VMSTATE_UINTTL (env.sscratch,RISCVCPU ), +VMSTATE_UINTTL (env.sepc,RISCVCPU ), +VMSTATE_UINTTL (env.scause,RISCVCPU ), +VMSTATE_UINTTL (env.sbadaddr,RISCVCPU ), +VMSTATE_UINTTL (env.mip,RISCVCPU ), +VMSTATE_UINTTL (env.satp,RISCVCPU ), +VMSTATE_END_OF_LIST () + } };#endif
Signature · 1 line
2.19.1
RFC PATCH v3 12/14 target/riscv: Add kvm_riscv_get/put_regs_timer
In reply to Yifei JiangAdd kvm_riscv_get/put_regs_timer to synchronize virtual time context from KVM. The frequency of virtual time is not supported by KVM_SET_ONE_REG, So it's useless to synchronize the frequency of virtual time.
To set register of RISCV_TIMER_REG(state) will occur a error from KVM on kvm_timer_state == 0. It's better to adapt in KVM, but it doesn't matter that adaping in QEMU.
--- target/riscv/cpu.h | 6 ++++ target/riscv/kvm.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)
target/riscv/cpu.h +6 -0
@@ -233,6 +233,12 @@ struct CPURISCVState {hwaddr kernel_addr;hwaddr fdt_addr; + +/* kvm timer */ +bool kvm_timer_dirty; +uint64_t kvm_timer_time; +uint64_t kvm_timer_compare; +uint64_t kvm_timer_state; };#define RISCV_CPU_CLASS (klass) \
target/riscv/kvm.c +72 -0
84 lines not on this page · raw message
Signature · 1 line
2.19.1
RFC PATCH v3 13/14 target/riscv: Implement virtual time adjusting with vm state changing
In reply to Yifei JiangWe hope that virtual time adjusts with vm state changing. When a vm is stopped, guest virtual time should stop counting and kvm_timer should be stopped. When the vm is resumed, guest virtual time should continue to count and kvm_timer should be restored.
--- target/riscv/kvm.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
target/riscv/kvm.c +14 -0
@@ -40,6 +40,7 @@#include "kvm_riscv.h" #include "sbi_ecall_interface.h" #include "chardev/char-fe.h" +#include "sysemu/runstate.h" static __u64 kvm_riscv_reg_id (__u64 type,__u64 idx) {
@@ -448,6 +449,17 @@ unsigned long kvm_arch_vcpu_id(CPUState *cpu)return cpu->cpu_index; } +static void kvm_riscv_vm_state_change (void *opaque,int running,RunState state) +{ +CPUState *cs = opaque; + +if (running) { +kvm_riscv_put_regs_timer (cs); + }else { +kvm_riscv_get_regs_timer (cs); + } +} +void kvm_arch_init_irq_routing (KVMState *s) { }
@@ -459,6 +471,8 @@ int kvm_arch_init_vcpu(CPUState *cs)RISCVCPU *cpu =RISCV_CPU (cs);__u64 id; +qemu_add_vm_change_state_handler (kvm_riscv_vm_state_change, cs); + id =kvm_riscv_reg_id (KVM_REG_RISCV_CONFIG ,KVM_REG_RISCV_CONFIG_REG (isa)); ret =kvm_get_one_reg (cs, id, &isa);if (ret) {
Signature · 1 line
2.19.1
RFC PATCH v3 14/14 target/riscv: Support virtual time context synchronization
In reply to Yifei JiangAdd virtual time context description to vmstate_riscv_cpu. After cpu being loaded, virtual time context is updated to KVM.
--- target/riscv/cpu.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
target/riscv/cpu.c +11 -0
@@ -496,11 +496,19 @@ static void riscv_cpu_init(Object *obj)cpu_set_cpustate_pointers (cpu); } +static int cpu_post_load (void *opaque,int version_id) +{ +RISCVCPU *cpu = opaque; + cpu->env.kvm_timer_dirty = true; +return 0 ; +} + #ifndef CONFIG_USER_ONLY static const VMStateDescription vmstate_riscv_cpu = { .name = "cpu", .version_id = 1, .minimum_version_id = 1, + .post_load = cpu_post_load, .fields = (VMStateField[]) { VMSTATE_UINTTL_ARRAY(env.gpr, RISCVCPU, 32), VMSTATE_UINT64_ARRAY(env.fpr, RISCVCPU, 32),
@@ -514,6 +522,9 @@ static const VMStateDescription vmstate_riscv_cpu = {VMSTATE_UINTTL (env.sbadaddr,RISCVCPU ),VMSTATE_UINTTL (env.mip,RISCVCPU ),VMSTATE_UINTTL (env.satp,RISCVCPU ), +VMSTATE_UINT64 (env.kvm_timer_time,RISCVCPU ), +VMSTATE_UINT64 (env.kvm_timer_compare,RISCVCPU ), +VMSTATE_UINT64 (env.kvm_timer_state,RISCVCPU ), VMSTATE_END_OF_LIST() } };
Signature · 1 line
2.19.1