Add riscv kvm accel support
Subsystems (4)
cover Add riscv kvm accel support
This series adds both riscv32 and riscv64 kvm support, and implements migration based on riscv.
Because of RISC-V KVM has been merged into the Linux master, so this series are changed from RFC to patch v1.
Several steps to use this:
1. Build emulation
$ ./configure --target-list=riscv64-softmmu $ make -j$(nproc)
2. Build kernel
3. Build QEMU VM
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"Changes since RFC v6
- Rebase on recent commit 8627edfb3f1fca24a96a0954148885c3241c10f8
- Sync-up headers with Linux-5.16-rc1
Changes since RFC v5
- Rebase on QEMU v6.1.0-rc1 and kvm-riscv linux v19.
- Move kvm interrupt setting to riscv_cpu_update_mip().
- Replace __u64 with uint64_t.
Changes since RFC v4
- Rebase on QEMU v6.0.0-rc2 and kvm-riscv linux v17.
- Remove time scaling support as software solution is incomplete. Because it will cause unacceptable performance degradation. and We will post a better solution.
- Revise according to Alistair's review comments.
- Remove compile time XLEN checks in kvm_riscv_reg_id
- Surround TYPE_RISCV_CPU_HOST definition by CONFIG_KVM and share it between RV32 and RV64.
- Add kvm-stub.c for reduce unnecessary compilation checks.
- Add riscv_setup_direct_kernel() to direct boot kernel for KVM.
Changes since RFC v3
- Rebase on QEMU v5.2.0-rc2 and kvm-riscv linux v15.
- Add time scaling support(New patches 13, 14 and 15).
- Fix the bug that guest vm can't reboot.
Changes since RFC v2
- Fix checkpatch error at target/riscv/sbi_ecall_interface.h.
- Add riscv migration support.
Changes since RFC v1
- Add separate SBI ecall interface header.
- Add riscv32 kvm accel support.
Yifei Jiang (12):
update-linux-headers: Add asm-riscv/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 target/riscv: Implement kvm_arch_put_registers target/riscv: Support start kernel directly by KVM target/riscv: Support setting external interrupt by KVM target/riscv: Handle KVM_EXIT_RISCV_SBI exit
target/riscv: Add host cpu type
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
hw/riscv/boot.c | 11 + hw/riscv/virt.c | 7 + include/hw/riscv/boot.h | 1 + linux-headers/asm-riscv/kvm.h | 128 ++++++ linux-headers/linux/kvm.h | 8 + meson.build | 2 + target/riscv/cpu.c | 57 +++ target/riscv/cpu.h | 10 + target/riscv/cpu_helper.c | 27 -- target/riscv/kvm-stub.c | 30 ++ target/riscv/kvm.c | 610 +++++++++++++++++++++++++++++ target/riscv/kvm_riscv.h | 25 ++ target/riscv/machine.c | 14 + target/riscv/meson.build | 1 + target/riscv/sbi_ecall_interface.h | 72 ++++ 15 files changed, 976 insertions(+), 27 deletions(-) create mode 100644 linux-headers/asm-riscv/kvm.h create mode 100644 target/riscv/kvm-stub.c 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
PATCH 1/12 update-linux-headers: Add asm-riscv/kvm.h
Add asm-riscv/kvm.h for RISC-V KVM, and update linux/kvm.h
--- linux-headers/asm-riscv/kvm.h | 128 ++++++++++++++++++++++++++++++++++ linux-headers/linux/kvm.h | 8 +++ 2 files changed, 136 insertions(+) create mode 100644 linux-headers/asm-riscv/kvm.h
linux-headers/asm-riscv/kvm.h new file +128 -0
@@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Copyright (C) 2019 Western Digital Corporation or its affiliates. +* +* Authors: +* Anup Patel <[email protected]> +*/ + +#ifndef __LINUX_KVM_RISCV_H +#define __LINUX_KVM_RISCV_H + +#ifndef __ASSEMBLY__ + +#include <linux/types.h> +#include <asm/ptrace.h> + +#define __KVM_HAVE_READONLY_MEM + +#define KVM_COALESCED_MMIO_PAGE_OFFSET 1 + +#define KVM_INTERRUPT_SET -1U +#define KVM_INTERRUPT_UNSET -2U + +/* for KVM_GET_REGS and KVM_SET_REGS */ +struct kvm_regs { +}; + +/* for KVM_GET_FPU and KVM_SET_FPU */ +struct kvm_fpu { +}; + +/* KVM Debug exit structure */ +struct kvm_debug_exit_arch { +}; + +/* for KVM_SET_GUEST_DEBUG */ +struct kvm_guest_debug_arch { +}; + +/* definition of registers in kvm_run */ +struct kvm_sync_regs { +}; + +/* for KVM_GET_SREGS and KVM_SET_SREGS */ +struct kvm_sregs { +}; + +/* CONFIG registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_config { +unsigned long isa; +}; + +/* CORE registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_core { +struct user_regs_struct regs; +unsigned long mode; +}; + +/* Possible privilege modes for kvm_riscv_core */ +#define KVM_RISCV_MODE_S 1 +#define KVM_RISCV_MODE_U 0 + +/* CSR registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_csr { +unsigned long sstatus; +unsigned long sie; +unsigned long stvec; +unsigned long sscratch; +unsigned long sepc; +unsigned long scause; +unsigned long stval; +unsigned long sip; +unsigned long satp; +unsigned long scounteren; +}; + +/* TIMER registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_timer { +__u64 frequency; +__u64 time; +__u64 compare; +__u64 state; +}; + +/* Possible states for kvm_riscv_timer */ +#define KVM_RISCV_TIMER_STATE_OFF 0 +#define KVM_RISCV_TIMER_STATE_ON 1 + +#define KVM_REG_SIZE (id) \ + (1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT)) + +/* If you need to interpret the index values, here is the key: */ +#define KVM_REG_RISCV_TYPE_MASK 0x00000000FF000000 +#define KVM_REG_RISCV_TYPE_SHIFT 24 + +/* Config registers are mapped as type 1 */ +#define KVM_REG_RISCV_CONFIG (0x01 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CONFIG_REG (name) \ + (offsetof(struct kvm_riscv_config, name) / sizeof(unsigned long)) + +/* Core registers are mapped as type 2 */ +#define KVM_REG_RISCV_CORE (0x02 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CORE_REG (name) \ + (offsetof(struct kvm_riscv_core, name) / sizeof(unsigned long)) + +/* Control and status registers are mapped as type 3 */ +#define KVM_REG_RISCV_CSR (0x03 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CSR_REG (name) \ + (offsetof(struct kvm_riscv_csr, name) / sizeof(unsigned long)) + +/* Timer registers are mapped as type 4 */ +#define KVM_REG_RISCV_TIMER (0x04 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_TIMER_REG (name) \ + (offsetof(struct kvm_riscv_timer, name) / sizeof(__u64)) + +/* F extension registers are mapped as type 5 */ +#define KVM_REG_RISCV_FP_F (0x05 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_FP_F_REG (name) \ + (offsetof(struct __riscv_f_ext_state, name) / sizeof(__u32)) + +/* D extension registers are mapped as type 6 */ +#define KVM_REG_RISCV_FP_D (0x06 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_FP_D_REG (name) \ + (offsetof(struct __riscv_d_ext_state, name) / sizeof(__u64)) + +#endif + +#endif /* __LINUX_KVM_RISCV_H */
linux-headers/linux/kvm.h +8 -0
@@ -269,6 +269,7 @@ struct kvm_xen_exit {#define KVM_EXIT_AP_RESET_HOLD 32#define KVM_EXIT_X86_BUS_LOCK 33#define KVM_EXIT_XEN 34 +#define KVM_EXIT_RISCV_SBI 35/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */
@@ -469,6 +470,13 @@ struct kvm_run { } msr;/* KVM_EXIT_XEN */ struct kvm_xen_exit xen; +/* 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
Re: [PATCH v1 01/12] update-linux-headers: Add asm-riscv/kvm.h
Quoted 5 lines · Yifei Jiang
Add
asm-riscv/kvm.hfor RISC-V KVM, and updatelinux/kvm.hSigned-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>
Alistair
Quoted 170 lines
--- linux-headers/asm-riscv/kvm.h | 128 ++++++++++++++++++++++++++++++++++ linux-headers/linux/kvm.h | 8 +++ 2 files changed, 136 insertions(+) create mode 100644 linux-headers/asm-riscv/kvm.hlinux-headers/asm-riscv/kvm.h new file +128
-0@@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Copyright (C) 2019 Western Digital Corporation or its affiliates. +* +* Authors: +* Anup Patel <[email protected]> +*/ + +#ifndef __LINUX_KVM_RISCV_H +#define __LINUX_KVM_RISCV_H + +#ifndef __ASSEMBLY__ + +#include <linux/types.h> +#include <asm/ptrace.h> + +#define __KVM_HAVE_READONLY_MEM + +#define KVM_COALESCED_MMIO_PAGE_OFFSET 1 + +#define KVM_INTERRUPT_SET -1U +#define KVM_INTERRUPT_UNSET -2U + +/* for KVM_GET_REGS and KVM_SET_REGS */ +struct kvm_regs { +}; + +/* for KVM_GET_FPU and KVM_SET_FPU */ +struct kvm_fpu { +}; + +/* KVM Debug exit structure */ +struct kvm_debug_exit_arch { +}; + +/* for KVM_SET_GUEST_DEBUG */ +struct kvm_guest_debug_arch { +}; + +/* definition of registers in kvm_run */ +struct kvm_sync_regs { +}; + +/* for KVM_GET_SREGS and KVM_SET_SREGS */ +struct kvm_sregs { +}; + +/* CONFIG registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_config { +unsigned long isa; +}; + +/* CORE registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_core { +struct user_regs_struct regs; +unsigned long mode; +}; + +/* Possible privilege modes for kvm_riscv_core */ +#define KVM_RISCV_MODE_S 1 +#define KVM_RISCV_MODE_U 0 + +/* CSR registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_csr { +unsigned long sstatus; +unsigned long sie; +unsigned long stvec; +unsigned long sscratch; +unsigned long sepc; +unsigned long scause; +unsigned long stval; +unsigned long sip; +unsigned long satp; +unsigned long scounteren; +}; + +/* TIMER registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_timer { +__u64 frequency; +__u64 time; +__u64 compare; +__u64 state; +}; + +/* Possible states for kvm_riscv_timer */ +#define KVM_RISCV_TIMER_STATE_OFF 0 +#define KVM_RISCV_TIMER_STATE_ON 1 + +#define KVM_REG_SIZE (id) \ + (1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT)) + +/* If you need to interpret the index values, here is the key: */ +#define KVM_REG_RISCV_TYPE_MASK 0x00000000FF000000 +#define KVM_REG_RISCV_TYPE_SHIFT 24 + +/* Config registers are mapped as type 1 */ +#define KVM_REG_RISCV_CONFIG (0x01 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CONFIG_REG (name) \ + (offsetof(struct kvm_riscv_config, name) / sizeof(unsigned long)) + +/* Core registers are mapped as type 2 */ +#define KVM_REG_RISCV_CORE (0x02 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CORE_REG (name) \ + (offsetof(struct kvm_riscv_core, name) / sizeof(unsigned long)) + +/* Control and status registers are mapped as type 3 */ +#define KVM_REG_RISCV_CSR (0x03 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CSR_REG (name) \ + (offsetof(struct kvm_riscv_csr, name) / sizeof(unsigned long)) + +/* Timer registers are mapped as type 4 */ +#define KVM_REG_RISCV_TIMER (0x04 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_TIMER_REG (name) \ + (offsetof(struct kvm_riscv_timer, name) / sizeof(__u64)) + +/* F extension registers are mapped as type 5 */ +#define KVM_REG_RISCV_FP_F (0x05 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_FP_F_REG (name) \ + (offsetof(struct __riscv_f_ext_state, name) / sizeof(__u32)) + +/* D extension registers are mapped as type 6 */ +#define KVM_REG_RISCV_FP_D (0x06 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_FP_D_REG (name) \ + (offsetof(struct __riscv_d_ext_state, name) / sizeof(__u64)) + +#endif + +#endif /* __LINUX_KVM_RISCV_H */ linux-headers/linux/kvm.h +8
-1@@ -269,6 +269,7 @@ struct kvm_xen_exit {#define KVM_EXIT_AP_RESET_HOLD 32#define KVM_EXIT_X86_BUS_LOCK 33#define KVM_EXIT_XEN 34 +#define KVM_EXIT_RISCV_SBI 35/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */ @@ -469,6 +470,13 @@ struct kvm_run { } msr;/* KVM_EXIT_XEN */ struct kvm_xen_exit xen; +/* 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 ]; }; --2.19.1
Re: [PATCH v1 01/12] update-linux-headers: Add asm-riscv/kvm.h
In reply to Yifei JiangQuoted 5 lines · Yifei Jiang
Add
asm-riscv/kvm.hfor RISC-V KVM, and updatelinux/kvm.hSigned-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>
Looks good to me.
Regards,
Anup
Quoted 174 lines
--- linux-headers/asm-riscv/kvm.h | 128 ++++++++++++++++++++++++++++++++++ linux-headers/linux/kvm.h | 8 +++ 2 files changed, 136 insertions(+) create mode 100644 linux-headers/asm-riscv/kvm.hlinux-headers/asm-riscv/kvm.h new file +128
-0@@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Copyright (C) 2019 Western Digital Corporation or its affiliates. +* +* Authors: +* Anup Patel <[email protected]> +*/ + +#ifndef __LINUX_KVM_RISCV_H +#define __LINUX_KVM_RISCV_H + +#ifndef __ASSEMBLY__ + +#include <linux/types.h> +#include <asm/ptrace.h> + +#define __KVM_HAVE_READONLY_MEM + +#define KVM_COALESCED_MMIO_PAGE_OFFSET 1 + +#define KVM_INTERRUPT_SET -1U +#define KVM_INTERRUPT_UNSET -2U + +/* for KVM_GET_REGS and KVM_SET_REGS */ +struct kvm_regs { +}; + +/* for KVM_GET_FPU and KVM_SET_FPU */ +struct kvm_fpu { +}; + +/* KVM Debug exit structure */ +struct kvm_debug_exit_arch { +}; + +/* for KVM_SET_GUEST_DEBUG */ +struct kvm_guest_debug_arch { +}; + +/* definition of registers in kvm_run */ +struct kvm_sync_regs { +}; + +/* for KVM_GET_SREGS and KVM_SET_SREGS */ +struct kvm_sregs { +}; + +/* CONFIG registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_config { +unsigned long isa; +}; + +/* CORE registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_core { +struct user_regs_struct regs; +unsigned long mode; +}; + +/* Possible privilege modes for kvm_riscv_core */ +#define KVM_RISCV_MODE_S 1 +#define KVM_RISCV_MODE_U 0 + +/* CSR registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_csr { +unsigned long sstatus; +unsigned long sie; +unsigned long stvec; +unsigned long sscratch; +unsigned long sepc; +unsigned long scause; +unsigned long stval; +unsigned long sip; +unsigned long satp; +unsigned long scounteren; +}; + +/* TIMER registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_timer { +__u64 frequency; +__u64 time; +__u64 compare; +__u64 state; +}; + +/* Possible states for kvm_riscv_timer */ +#define KVM_RISCV_TIMER_STATE_OFF 0 +#define KVM_RISCV_TIMER_STATE_ON 1 + +#define KVM_REG_SIZE (id) \ + (1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT)) + +/* If you need to interpret the index values, here is the key: */ +#define KVM_REG_RISCV_TYPE_MASK 0x00000000FF000000 +#define KVM_REG_RISCV_TYPE_SHIFT 24 + +/* Config registers are mapped as type 1 */ +#define KVM_REG_RISCV_CONFIG (0x01 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CONFIG_REG (name) \ + (offsetof(struct kvm_riscv_config, name) / sizeof(unsigned long)) + +/* Core registers are mapped as type 2 */ +#define KVM_REG_RISCV_CORE (0x02 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CORE_REG (name) \ + (offsetof(struct kvm_riscv_core, name) / sizeof(unsigned long)) + +/* Control and status registers are mapped as type 3 */ +#define KVM_REG_RISCV_CSR (0x03 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_CSR_REG (name) \ + (offsetof(struct kvm_riscv_csr, name) / sizeof(unsigned long)) + +/* Timer registers are mapped as type 4 */ +#define KVM_REG_RISCV_TIMER (0x04 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_TIMER_REG (name) \ + (offsetof(struct kvm_riscv_timer, name) / sizeof(__u64)) + +/* F extension registers are mapped as type 5 */ +#define KVM_REG_RISCV_FP_F (0x05 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_FP_F_REG (name) \ + (offsetof(struct __riscv_f_ext_state, name) / sizeof(__u32)) + +/* D extension registers are mapped as type 6 */ +#define KVM_REG_RISCV_FP_D (0x06 << KVM_REG_RISCV_TYPE_SHIFT) +#define KVM_REG_RISCV_FP_D_REG (name) \ + (offsetof(struct __riscv_d_ext_state, name) / sizeof(__u64)) + +#endif + +#endif /* __LINUX_KVM_RISCV_H */ linux-headers/linux/kvm.h +8
-1@@ -269,6 +269,7 @@ struct kvm_xen_exit {#define KVM_EXIT_AP_RESET_HOLD 32#define KVM_EXIT_X86_BUS_LOCK 33#define KVM_EXIT_XEN 34 +#define KVM_EXIT_RISCV_SBI 35/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */ @@ -469,6 +470,13 @@ struct kvm_run { } msr;/* KVM_EXIT_XEN */ struct kvm_xen_exit xen; +/* 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 ]; }; --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 2/12 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 meson.build file.
--- meson.build | 2 + target/riscv/kvm.c | 133 +++++++++++++++++++++++++++++++++++++++ target/riscv/meson.build | 1 + 3 files changed, 136 insertions(+) create mode 100644 target/riscv/kvm.c
meson.build +2 -0
@@ -77,6 +77,8 @@ elif cpu in ['ppc', 'ppc64'] kvm_targets = ['ppc-softmmu', 'ppc64-softmmu'] elif cpu in ['mips', 'mips64'] kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu'] +elif cpu in ['riscv'] + kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu'] else kvm_targets = [] endif
target/riscv/kvm.c new file +133 -0
133 lines not on this page · raw message
target/riscv/meson.build +1 -0
@@ -19,6 +19,7 @@ riscv_ss.add(files( 'bitmanip_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
Re: [PATCH v1 02/12] target/riscv: Add target/riscv/kvm.c to place the public kvm interface
Quoted 7 lines · Yifei Jiang
Add
target/riscv/kvm.cto place kvm_arch_* function needed bykvm/kvm-all.c. Meanwhile, add kvm support in meson.build file.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>
Looks good to me.
Regards,
Anup
Quoted 179 lines
--- meson.build | 2 + target/riscv/kvm.c | 133 +++++++++++++++++++++++++++++++++++++++ target/riscv/meson.build | 1 + 3 files changed, 136 insertions(+) create mode 100644 target/riscv/kvm.cmeson.build +2
-0@@ -77,6 +77,8 @@ elif cpu in ['ppc', 'ppc64'] kvm_targets = ['ppc-softmmu', 'ppc64-softmmu'] elif cpu in ['mips', 'mips64'] kvm_targets = ['mips-softmmu', 'mipsel-softmmu', 'mips64-softmmu', 'mips64el-softmmu'] +elif cpu in ['riscv'] + kvm_targets = ['riscv32-softmmu', 'riscv64-softmmu'] else kvm_targets = [] endiftarget/riscv/kvm.c new file +133
-0@@ -0,0 +1,133 @@ +/* +* RISC-V implementation of KVM hooks +* +* 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/>. +*/ + +#include "qemu/osdep.h" +#include <sys/ioctl.h> + +#include <linux/kvm.h> + +#include "qemu-common.h" +#include "qemu/timer.h" +#include "qemu/error-report.h" +#include "qemu/main-loop.h" +#include "sysemu/sysemu.h" +#include "sysemu/kvm.h" +#include "sysemu/kvm_int.h" +#include "cpu.h" +#include "trace.h" +#include "hw/pci/pci.h" +#include "exec/memattrs.h" +#include "exec/address-spaces.h" +#include "hw/boards.h" +#include "hw/irq.h" +#include "qemu/log.h" +#include "hw/loader.h" + +const KVMCapabilityInfo kvm_arch_required_capabilities[] = { +KVM_CAP_LAST_INFO +}; + +int kvm_arch_get_registers (CPUState *cs) +{ +return 0 ; +} + +int kvm_arch_put_registers (CPUState *cs,int level) +{ +return 0 ; +} + +int kvm_arch_release_virq_post (int virq) +{ +return 0 ; +} + +int kvm_arch_fixup_msi_route (struct kvm_irq_routing_entry *route, +uint64_t address,uint32_t data,PCIDevice *dev) +{ +return 0 ; +} + +int kvm_arch_destroy_vcpu (CPUState *cs) +{ +return 0 ; +} + +unsigned long kvm_arch_vcpu_id (CPUState *cpu) +{ +return cpu->cpu_index; +} + +void kvm_arch_init_irq_routing (KVMState *s) +{ +} + +int kvm_arch_init_vcpu (CPUState *cs) +{ +return 0 ; +} + +int kvm_arch_msi_data_to_gsi (uint32_t data) +{ +abort (); +} + +int kvm_arch_add_msi_route_post (struct kvm_irq_routing_entry *route, +int vector,PCIDevice *dev) +{ +return 0 ; +} + +int kvm_arch_init (MachineState *ms,KVMState *s) +{ +return 0 ; +} + +int kvm_arch_irqchip_create (KVMState *s) +{ +return 0 ; +} + +int kvm_arch_process_async_events (CPUState *cs) +{ +return 0 ; +} + +void kvm_arch_pre_run (CPUState *cs,struct kvm_run *run) +{ +} + +MemTxAttrs kvm_arch_post_run (CPUState *cs,struct kvm_run *run) +{ +return MEMTXATTRS_UNSPECIFIED ; +} + +bool kvm_arch_stop_on_emulation_error (CPUState *cs) +{ +return true; +} + +int kvm_arch_handle_exit (CPUState *cs,struct kvm_run *run) +{ +return 0 ; +} + +bool kvm_arch_cpu_check_are_resettable (void ) +{ +return true; +}target/riscv/meson.build +1
-1@@ -19,6 +19,7 @@ riscv_ss.add(files( 'bitmanip_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( --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 3/12 target/riscv: Implement function kvm_arch_init_vcpu
In reply to Yifei JiangGet isa info from kvm while kvm init.
--- target/riscv/kvm.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-)
target/riscv/kvm.c +31 -1
@@ -38,6 +38,23 @@#include "qemu/log.h" #include "hw/loader.h" +static uint64_t kvm_riscv_reg_id (CPURISCVState *env,uint64_t type,uint64_t idx) +{ +uint64_t id =KVM_REG_RISCV | type | idx; + +switch (riscv_cpu_mxl (env)) { +case MXL_RV32 : + id |=KVM_REG_SIZE_U32 ; +break ; +case MXL_RV64 : + id |=KVM_REG_SIZE_U64 ; +break ; +default : +g_assert_not_reached (); + } +return id; +} +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };
@@ -79,7 +96,20 @@ 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); +CPURISCVState *env = &cpu->env; +uint64_t id; + + id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG ,KVM_REG_RISCV_CONFIG_REG (isa)); + ret =kvm_get_one_reg (cs, id, &isa); +if (ret) { +return ret; + } + env->misa_mxl |= isa; + +return ret; }int kvm_arch_msi_data_to_gsi (uint32_t data)
Signature · 1 line
2.19.1
Re: [PATCH v1 03/12] target/riscv: Implement function kvm_arch_init_vcpu
target/riscv/kvm.c void kvm_arch_init_irq_routing(KVMState *s) · line 110
Quoted 6 lines · Yifei Jiang
target/riscv/kvm.c +6
-0+ id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG ,KVM_REG_RISCV_CONFIG_REG (isa)); + ret =kvm_get_one_reg (cs, id, &isa); +if (ret) { +return ret; + } + env->misa_mxl |= isa;
This doesn't look right.
I'm sure you meant
env->misa_ext = isa;
r~
RE: [PATCH v1 03/12] target/riscv: Implement function kvm_arch_init_vcpu
Quoted 24 lines
-----Original Message-----
From: Richard Henderson [mailto:richard.henderson at linaro.org]
Sent: Sunday, November 21, 2021 6:19 AM
To: Jiangyifei <[email protected]>; qemu-devel at nongnu.org; qemu-riscv at nongnu.org
Cc: bin.meng at windriver.com; limingwang (A) <[email protected]>; kvm at vger.kernel.org; libvir-list at redhat.com; anup.patel at wdc.com; wanbo (G) <[email protected]>; Alistair Francis <[email protected]>; kvm-riscv at lists.infradead.org; Wanghaibin (D) <[email protected]>; palmer at dabbelt.com; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>
Subject: Re: [PATCH v1 03/12] target/riscv: Implement functionkvm_arch_init_vcpuQuoted 1 line · Yifei Jiang
+ id = kvm_riscv_reg_id(env,
KVM_REG_RISCV_CONFIG,
KVM_REG_RISCV_CONFIG_REG(isa));target/riscv/kvm.c void kvm_arch_init_irq_routing(KVMState *s) · line 110
Quoted 5 lines
target/riscv/kvm.c +5
-0+ ret =kvm_get_one_reg (cs, id, &isa); +if (ret) { +return ret; + } + env->misa_mxl |= isa;
Quoted 7 lines
This doesn't look right.
I'm sure you meantenv->misa_ext = isa;r~
Thanks, it will be modified in the next series.
Yifei
PATCH 4/12 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
@@ -55,13 +55,161 @@ static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idxreturn id; } +#define RISCV_CORE_REG (env, name) kvm_riscv_reg_id(env, KVM_REG_RISCV_CORE, \ + KVM_REG_RISCV_CORE_REG(name)) + +#define RISCV_CSR_REG (env, name) kvm_riscv_reg_id(env, KVM_REG_RISCV_CSR, \ + KVM_REG_RISCV_CSR_REG(name)) + +#define RISCV_FP_F_REG (env, idx) kvm_riscv_reg_id(env, KVM_REG_RISCV_FP_F, idx) + +#define RISCV_FP_D_REG (env, idx) kvm_riscv_reg_id(env, 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 (env, regs.pc), ®); +if (ret) { +return ret; + } + env->pc = reg; + +for (i =1 ; i <32 ; i++) { +uint64_t id =kvm_riscv_reg_id (env,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 (env, sstatus), ®); +if (ret) { +return ret; + } + env->mstatus = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sie), ®); +if (ret) { +return ret; + } + env->mie = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, stvec), ®); +if (ret) { +return ret; + } + env->stvec = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sscratch), ®); +if (ret) { +return ret; + } + env->sscratch = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sepc), ®); +if (ret) { +return ret; + } + env->sepc = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, scause), ®); +if (ret) { +return ret; + } + env->scause = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, stval), ®); +if (ret) { +return ret; + } + env->stval = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sip), ®); +if (ret) { +return ret; + } + env->mip = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, 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 (env, 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 (env, 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
Anup Patel
maintainerRe: [PATCH v1 04/12] target/riscv: Implement kvm_arch_get_registers
Quoted 102 lines · Yifei Jiang
Get GPR CSR and FP registers from kvm by
KVM_GET_ONE_REGioctl.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- target/riscv/kvm.c | 150 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 149 insertions(+), 1 deletion(-)target/riscv/kvm.c +84
-0@@ -55,13 +55,161 @@ static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idxreturn id; } +#define RISCV_CORE_REG (env, name) kvm_riscv_reg_id(env, KVM_REG_RISCV_CORE, \ + KVM_REG_RISCV_CORE_REG(name)) + +#define RISCV_CSR_REG (env, name) kvm_riscv_reg_id(env, KVM_REG_RISCV_CSR, \ + KVM_REG_RISCV_CSR_REG(name)) + +#define RISCV_FP_F_REG (env, idx) kvm_riscv_reg_id(env, KVM_REG_RISCV_FP_F, idx) + +#define RISCV_FP_D_REG (env, idx) kvm_riscv_reg_id(env, 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 (env, regs.pc), ®); +if (ret) { +return ret; + } + env->pc = reg; + +for (i =1 ; i <32 ; i++) { +uint64_t id =kvm_riscv_reg_id (env,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 (env, sstatus), ®); +if (ret) { +return ret; + } + env->mstatus = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sie), ®); +if (ret) { +return ret; + } + env->mie = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, stvec), ®); +if (ret) { +return ret; + } + env->stvec = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sscratch), ®); +if (ret) { +return ret; + } + env->sscratch = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sepc), ®); +if (ret) { +return ret; + } + env->sepc = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, scause), ®); +if (ret) { +return ret; + } + env->scause = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, stval), ®); +if (ret) { +return ret; + } + env->stval = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sip), ®);
target/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx · line 151
Quoted 10 lines
target/riscv/kvm.c +10
-0+if (ret) { +return ret; + } + env->mip = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, satp), ®); +if (ret) { +return ret; + } + env->satp = reg;
There is a common pattern in above kvm_get_one_reg() calls so I suggest creating a macro for repeating code patterns. This can help us to have one line for each CSR and in future it is easy to add more CSRs.
Regards,
Anup
Quoted 73 lines
target/riscv/kvm.c +55
-2+ +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 (env, 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 (env, 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) --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
RE: [PATCH v1 04/12] target/riscv: Implement kvm_arch_get_registers
Quoted 139 lines
-----Original Message-----
From: kvm-riscv [mailto:kvm-riscv-bounces at lists.infradead.org] On Behalf Of Anup Patel
Sent: Friday, December 3, 2021 2:20 PM
To: Jiangyifei <[email protected]>
Cc: QEMU Developers <[email protected]>; open list:RISC-V <[email protected]>; kvm-riscv at lists.infradead.org; KVM General <[email protected]>; libvir-list at redhat.com; Anup Patel <[email protected]>; Palmer Dabbelt <[email protected]>; Alistair Francis <[email protected]>; Bin Meng <[email protected]>; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>; Wanghaibin (D) <[email protected]>; wanbo (G) <[email protected]>; limingwang (A) <[email protected]>
Subject: Re: [PATCH v1 04/12] target/riscv: Implementkvm_arch_get_registerstarget/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState
Quoted 16 lines · Yifei Jiang
Get GPR CSR and FP registers from kvm by
KVM_GET_ONE_REGioctl.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- target/riscv/kvm.c | 150 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 149 insertions(+), 1 deletion(-)target/riscv/kvm.c index renamed from target/riscv/kvm.c +0
-0
9f9692fb9e..b49c24be0a100644target/riscv/kvm.c +0
-0@@ -55,13 +55,161 @@ static uint64_t kvm_riscv_reg_id(CPURISCVState*env,
uint64_ttype,uint64_tidxtarget/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx
Quoted 4 lines
target/riscv/kvm.c +1
-0return id; } +#define RISCV_CORE_REG (env, name) kvm_riscv_reg_id(env,
KVM_REG_RISCV_CORE, \target/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx
Quoted 3 lines
target/riscv/kvm.c +3
-0+ KVM_REG_RISCV_CORE_REG(name)) + +#define RISCV_CSR_REG (env, name) kvm_riscv_reg_id(env,
KVM_REG_RISCV_CSR, \Quoted 80 lines
target/riscv/kvm.c +80
-0+ KVM_REG_RISCV_CSR_REG(name)) + +#define RISCV_FP_F_REG (env, idx) kvm_riscv_reg_id(env, +KVM_REG_RISCV_FP_F, idx) + +#define RISCV_FP_D_REG (env, idx) kvm_riscv_reg_id(env, +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 (env, regs.pc), ®); +if (ret) { +return ret; + } + env->pc = reg; + +for (i =1 ; i <32 ; i++) { +uint64_t id =kvm_riscv_reg_id (env,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 (env, sstatus), ®); +if (ret) { +return ret; + } + env->mstatus = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sie), ®); +if (ret) { +return ret; + } + env->mie = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, stvec), ®); +if (ret) { +return ret; + } + env->stvec = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sscratch), ®); +if (ret) { +return ret; + } + env->sscratch = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sepc), ®); +if (ret) { +return ret; + } + env->sepc = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, scause), ®); +if (ret) { +return ret; + } + env->scause = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, stval), ®); +if (ret) { +return ret; + } + env->stval = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, sip), ®);target/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx · line 151
Quoted 10 lines
target/riscv/kvm.c +10
-0+if (ret) { +return ret; + } + env->mip = reg; + + ret =kvm_get_one_reg (cs,RISCV_CSR_REG (env, satp), ®); +if (ret) { +return ret; + } + env->satp = reg;There is a common pattern in above
kvm_get_one_reg()calls so I suggest creating a macro for repeating code patterns. This can help us to have one line for each CSR and in future it is easy to add more CSRs.
Quoted 3 lines
Regards,
Anup
Thanks, it will be modified in the next series.
Yifei
Quoted 76 lines
Quoted 67 lines
target/riscv/kvm.c +54
-2+ +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 (env, 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 (env, 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) --2.19.1
Quoted 4 lines
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 5/12 target/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 | 141 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 140 insertions(+), 1 deletion(-)
target/riscv/kvm.c +140 -1
@@ -90,6 +90,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 (env, regs.pc), ®); +if (ret) { +return ret; + } + +for (i =1 ; i <32 ; i++) { +uint64_t id =kvm_riscv_reg_id (env,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 ;
@@ -153,6 +178,69 @@ 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 (env, sstatus), ®); +if (ret) { +return ret; + } + + reg = env->mie; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sie), ®); +if (ret) { +return ret; + } + + reg = env->stvec; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, stvec), ®); +if (ret) { +return ret; + } + + reg = env->sscratch; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sscratch), ®); +if (ret) { +return ret; + } + + reg = env->sepc; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sepc), ®); +if (ret) { +return ret; + } + + reg = env->scause; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, scause), ®); +if (ret) { +return ret; + } + + reg = env->stval; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, stval), ®); +if (ret) { +return ret; + } + + reg = env->mip; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sip), ®); +if (ret) { +return ret; + } + + reg = env->satp; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, satp), ®); +if (ret) { +return ret; + } + +return ret; +} +static int kvm_riscv_get_regs_fp (CPUState *cs) {int ret =0 ;
@@ -186,6 +274,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 (env, 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 (env, i), ®); +if (ret) { +return ret; + } + } +return ret; + } + +return ret; +} + +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };
@@ -214,7 +336,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
Anup Patel
maintainerRe: [PATCH v1 05/12] target/riscv: Implement kvm_arch_put_registers
Quoted 99 lines · Yifei Jiang
Put GPR CSR and FP registers to kvm by
KVM_SET_ONE_REGioctlSigned-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- target/riscv/kvm.c | 141 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 140 insertions(+), 1 deletion(-)target/riscv/kvm.c +74
-0@@ -90,6 +90,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 (env, regs.pc), ®); +if (ret) { +return ret; + } + +for (i =1 ; i <32 ; i++) { +uint64_t id =kvm_riscv_reg_id (env,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 ;@@ -153,6 +178,69 @@ 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 (env, sstatus), ®); +if (ret) { +return ret; + } + + reg = env->mie; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sie), ®); +if (ret) { +return ret; + } + + reg = env->stvec; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, stvec), ®); +if (ret) { +return ret; + } + + reg = env->sscratch; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sscratch), ®); +if (ret) { +return ret; + } + + reg = env->sepc; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sepc), ®); +if (ret) { +return ret; + } + + reg = env->scause; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, scause), ®); +if (ret) { +return ret; + } + + reg = env->stval; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, stval), ®); +if (ret) { +return ret; + } + + reg = env->mip;
target/riscv/kvm.c static int kvm_riscv_get_regs_csr(CPUState *cs) · line 239
Quoted 10 lines
target/riscv/kvm.c +10
-0+ ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sip), ®); +if (ret) { +return ret; + } + + reg = env->satp; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, satp), ®); +if (ret) { +return ret; + }
Same as the previous patch, there is a common pattern in above kvm_set_one_reg() calls. Please use a macro to simplify.
Regards,
Anup
Quoted 82 lines
target/riscv/kvm.c +56
-2+ +return ret; +} +static int kvm_riscv_get_regs_fp (CPUState *cs) {int ret =0 ;@@ -186,6 +274,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 (env, 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 (env, i), ®); +if (ret) { +return ret; + } + } +return ret; + } + +return ret; +} + +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };@@ -214,7 +336,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) --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
RE: [PATCH v1 05/12] target/riscv: Implement kvm_arch_put_registers
Quoted 128 lines
-----Original Message-----
From: Anup Patel [mailto:anup at brainfault.org]
Sent: Friday, December 3, 2021 2:22 PM
To: Jiangyifei <[email protected]>
Cc: QEMU Developers <[email protected]>; open list:RISC-V <[email protected]>; kvm-riscv at lists.infradead.org; KVM General <[email protected]>; libvir-list at redhat.com; Anup Patel <[email protected]>; Palmer Dabbelt <[email protected]>; Alistair Francis <[email protected]>; Bin Meng <[email protected]>; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>; Wanghaibin (D) <[email protected]>; wanbo (G) <[email protected]>; limingwang (A) <[email protected]>
Subject: Re: [PATCH v1 05/12] target/riscv: Implementkvm_arch_put_registersQuoted 97 lines · Yifei Jiang
Put GPR CSR and FP registers to kvm by
KVM_SET_ONE_REGioctlSigned-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- target/riscv/kvm.c | 141 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 140 insertions(+), 1 deletion(-)target/riscv/kvm.c index renamed from target/riscv/kvm.c +0
-0
b49c24be0a..5fe5ca4434100644target/riscv/kvm.c +72
-0@@ -90,6 +90,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 (env, regs.pc), ®); +if (ret) { +return ret; + } + +for (i =1 ; i <32 ; i++) { +uint64_t id =kvm_riscv_reg_id (env,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 ;@@ -153,6 +178,69 @@ 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 (env, sstatus), ®); +if (ret) { +return ret; + } + + reg = env->mie; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sie), ®); +if (ret) { +return ret; + } + + reg = env->stvec; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, stvec), ®); +if (ret) { +return ret; + } + + reg = env->sscratch; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sscratch), ®); +if (ret) { +return ret; + } + + reg = env->sepc; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sepc), ®); +if (ret) { +return ret; + } + + reg = env->scause; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, scause), ®); +if (ret) { +return ret; + } + + reg = env->stval; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, stval), ®); +if (ret) { +return ret; + } + + reg = env->mip;target/riscv/kvm.c static int kvm_riscv_get_regs_csr(CPUState *cs) · line 238
Quoted 10 lines
target/riscv/kvm.c +10
-0+ ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, sip), ®); +if (ret) { +return ret; + } + + reg = env->satp; + ret =kvm_set_one_reg (cs,RISCV_CSR_REG (env, satp), ®); +if (ret) { +return ret; + }Same as the previous patch, there is a common pattern in above
kvm_set_one_reg()calls. Please use a macro to simplify.
Quoted 3 lines
Regards,
Anup
Thanks, it will be modified in the next series.
Yifei
Quoted 79 lines
Quoted 79 lines
target/riscv/kvm.c +55
-2+ +return ret; +} +static int kvm_riscv_get_regs_fp (CPUState *cs) {int ret =0 ;@@ -186,6 +274,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 (env, 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 (env, i), ®); +if (ret) { +return ret; + } + } +return ret; + } + +return ret; +} + +const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO };@@ -214,7 +336,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) --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 6/12 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/boot.c | 11 +++++++++++ hw/riscv/virt.c | 7 +++++++ include/hw/riscv/boot.h | 1 + target/riscv/cpu.c | 8 ++++++++ target/riscv/cpu.h | 3 +++ target/riscv/kvm-stub.c | 25 +++++++++++++++++++++++++ target/riscv/kvm.c | 14 ++++++++++++++ target/riscv/kvm_riscv.h | 24 ++++++++++++++++++++++++ target/riscv/meson.build | 2 +- 9 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 target/riscv/kvm-stub.c create mode 100644 target/riscv/kvm_riscv.h
hw/riscv/boot.c +11 -0
@@ -317,3 +317,14 @@ void riscv_setup_rom_reset_vec(MachineState *machine, RISCVHartArrayState *hartsreturn ; } + +void riscv_setup_direct_kernel (hwaddr kernel_addr,hwaddr fdt_addr) +{ +CPUState *cs; + +for (cs = first_cpu; cs; cs =CPU_NEXT (cs)) { +RISCVCPU *riscv_cpu =RISCV_CPU (cs); + riscv_cpu->env.kernel_addr = kernel_addr; + riscv_cpu->env.fdt_addr = fdt_addr; + } +}
hw/riscv/virt.c +7 -0
@@ -941,6 +941,13 @@ static void virt_machine_init(MachineState *machine) virt_memmap[VIRT_MROM ].size, kernel_entry, fdt_load_addr, machine->fdt); +/* +* Only direct boot kernel is currently supported for KVM VM, +* So here setup kernel start address and fdt address. +* TODO:Support firmware loading and integrate to TCG start +*/ +riscv_setup_direct_kernel (kernel_entry, fdt_load_addr); +/* SiFive Test MMIO device */ sifive_test_create (memmap[VIRT_TEST ].base);
include/hw/riscv/boot.h +1 -0
@@ -58,5 +58,6 @@ void riscv_rom_copy_firmware_info(MachineState *machine, hwaddr rom_base,hwaddr rom_size, uint32_t reset_vec_size, uint64_t kernel_entry); +void riscv_setup_direct_kernel (hwaddr kernel_addr,hwaddr fdt_addr);#endif /* RISCV_BOOT_H */
target/riscv/cpu.c +8 -0
@@ -29,6 +29,8 @@#include "hw/qdev-properties.h" #include "migration/vmstate.h" #include "fpu/softfloat-helpers.h" +#include "sysemu/kvm.h" +#include "kvm_riscv.h" /* RISC-V CPU definitions */
@@ -380,6 +382,12 @@ static void riscv_cpu_reset(DeviceState *dev) cs->exception_index =RISCV_EXCP_NONE ; env->load_res =-1 ;set_default_nan_mode (1 , &env->fp_status); + +#ifndef CONFIG_USER_ONLY +if (kvm_enabled ()) { +kvm_riscv_reset_vcpu (cpu); + } +#endif }static void riscv_cpu_disas_set_info (CPUState *s,disassemble_info *info)
target/riscv/cpu.h +3 -0
@@ -255,6 +255,9 @@ struct CPURISCVState {/* Fields from here on are preserved across CPU reset. */ QEMUTimer *timer;/* Internal timer */ + +hwaddr kernel_addr; +hwaddr fdt_addr; }; OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass,
target/riscv/kvm-stub.c new file +25 -0
@@ -0,0 +1,25 @@ +/* +* QEMU KVM RISC-V specific function stubs +* +* 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/>. +*/ +#include "qemu/osdep.h" +#include "cpu.h" +#include "kvm_riscv.h" + +void kvm_riscv_reset_vcpu (RISCVCPU *cpu) +{ +abort (); +}
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 uint64_t kvm_riscv_reg_id (CPURISCVState *env,uint64_t type,uint64_t idx) {
@@ -444,6 +445,19 @@ 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 */ + env->satp =0 ; +} +bool kvm_arch_cpu_check_are_resettable (void ) {return true;
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
target/riscv/meson.build +1 -1
@@ -19,7 +19,7 @@ riscv_ss.add(files( 'bitmanip_helper.c', 'translate.c', )) -riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c')) +riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c'), if_false: files('kvm-stub.c')) riscv_softmmu_ss = ss.source_set() riscv_softmmu_ss.add(files(
Signature · 1 line
2.19.1
Anup Patel
maintainerRe: [PATCH v1 06/12] target/riscv: Support start kernel directly by KVM
Quoted 46 lines · Yifei Jiang
Get kernel and fdt start address in
virt.c, and pass them to KVM when cpu reset. In addition, addkvm_riscv.hto place riscv specific interface.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- hw/riscv/boot.c | 11 +++++++++++ hw/riscv/virt.c | 7 +++++++ include/hw/riscv/boot.h | 1 + target/riscv/cpu.c | 8 ++++++++ target/riscv/cpu.h | 3 +++ target/riscv/kvm-stub.c | 25 +++++++++++++++++++++++++ target/riscv/kvm.c | 14 ++++++++++++++ target/riscv/kvm_riscv.h | 24 ++++++++++++++++++++++++ target/riscv/meson.build | 2 +- 9 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 target/riscv/kvm-stub.c create mode 100644 target/riscv/kvm_riscv.hhw/riscv/boot.c +11
-0@@ -317,3 +317,14 @@ void riscv_setup_rom_reset_vec(MachineState *machine, RISCVHartArrayState *hartsreturn ; } + +void riscv_setup_direct_kernel (hwaddr kernel_addr,hwaddr fdt_addr) +{ +CPUState *cs; + +for (cs = first_cpu; cs; cs =CPU_NEXT (cs)) { +RISCVCPU *riscv_cpu =RISCV_CPU (cs); + riscv_cpu->env.kernel_addr = kernel_addr; + riscv_cpu->env.fdt_addr = fdt_addr; + } +}hw/riscv/virt.c +0
-0
hw/riscv/virt.c static void virt_machine_init(MachineState *machine) · line 949
Quoted 9 lines
hw/riscv/virt.c +6
-0@@ -941,6 +941,13 @@ static void virt_machine_init(MachineState *machine) virt_memmap[VIRT_MROM ].size, kernel_entry, fdt_load_addr, machine->fdt); +/* +* Only direct boot kernel is currently supported for KVM VM, +* So here setup kernel start address and fdt address. +* TODO:Support firmware loading and integrate to TCG start +*/ +riscv_setup_direct_kernel (kernel_entry, fdt_load_addr);
This should be under "if (kvm_enabled()) {".
Also, update virt machine such that the "-bios" parameter is ignored and treated like "-bios none" when KVM is enabled.
Further, virt machine should not create an ACLINT (or SiFive CLINT) instance when KVM is enabled. Event the PLIC should be created without M-mode PLIC contexts when KVM is enabled.
Regards,
Anup
Quoted 169 lines
hw/riscv/virt.c +1
-0+/* SiFive Test MMIO device */ sifive_test_create (memmap[VIRT_TEST ].base);include/hw/riscv/boot.h +1
-0@@ -58,5 +58,6 @@ void riscv_rom_copy_firmware_info(MachineState *machine, hwaddr rom_base,hwaddr rom_size, uint32_t reset_vec_size, uint64_t kernel_entry); +void riscv_setup_direct_kernel (hwaddr kernel_addr,hwaddr fdt_addr);#endif /* RISCV_BOOT_H */ target/riscv/cpu.c +8
-0@@ -29,6 +29,8 @@#include "hw/qdev-properties.h" #include "migration/vmstate.h" #include "fpu/softfloat-helpers.h" +#include "sysemu/kvm.h" +#include "kvm_riscv.h" /* RISC-V CPU definitions */ @@ -380,6 +382,12 @@ static void riscv_cpu_reset(DeviceState *dev) cs->exception_index =RISCV_EXCP_NONE ; env->load_res =-1 ;set_default_nan_mode (1 , &env->fp_status); + +#ifndef CONFIG_USER_ONLY +if (kvm_enabled ()) { +kvm_riscv_reset_vcpu (cpu); + } +#endif }static void riscv_cpu_disas_set_info (CPUState *s,disassemble_info *info)target/riscv/cpu.h +3
-0@@ -255,6 +255,9 @@ struct CPURISCVState {/* Fields from here on are preserved across CPU reset. */ QEMUTimer *timer;/* Internal timer */ + +hwaddr kernel_addr; +hwaddr fdt_addr; }; OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass,target/riscv/kvm-stub.c new file +25
-0@@ -0,0 +1,25 @@ +/* +* QEMU KVM RISC-V specific function stubs +* +* 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/>. +*/ +#include "qemu/osdep.h" +#include "cpu.h" +#include "kvm_riscv.h" + +void kvm_riscv_reset_vcpu (RISCVCPU *cpu) +{ +abort (); +}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 uint64_t kvm_riscv_reg_id (CPURISCVState *env,uint64_t type,uint64_t idx) {@@ -444,6 +445,19 @@ 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 */ + env->satp =0 ; +} +bool kvm_arch_cpu_check_are_resettable (void ) {return true;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 target/riscv/meson.build +1
-2@@ -19,7 +19,7 @@ riscv_ss.add(files( 'bitmanip_helper.c', 'translate.c', )) -riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c')) +riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c'), if_false: files('kvm-stub.c')) riscv_softmmu_ss = ss.source_set() riscv_softmmu_ss.add(files( --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
RE: [PATCH v1 06/12] target/riscv: Support start kernel directly by KVM
Quoted 75 lines
-----Original Message-----
From: kvm-riscv [mailto:kvm-riscv-bounces at lists.infradead.org] On Behalf Of Anup Patel
Sent: Friday, December 3, 2021 2:31 PM
To: Jiangyifei <[email protected]>
Cc: QEMU Developers <[email protected]>; open list:RISC-V <[email protected]>; kvm-riscv at lists.infradead.org; KVM General <[email protected]>; libvir-list at redhat.com; Anup Patel <[email protected]>; Palmer Dabbelt <[email protected]>; Alistair Francis <[email protected]>; Bin Meng <[email protected]>; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>; Wanghaibin (D) <[email protected]>; wanbo (G) <[email protected]>; limingwang (A) <[email protected]>
Subject: Re: [PATCH v1 06/12] target/riscv: Support start kernel directly by KVMhw/riscv/virt.c static void virt_machine_init(MachineState
Quoted 45 lines · Yifei Jiang
Get kernel and fdt start address in
virt.c, and pass them to KVM when cpu reset. In addition, addkvm_riscv.hto place riscv specific interface.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- hw/riscv/boot.c | 11 +++++++++++ hw/riscv/virt.c | 7 +++++++ include/hw/riscv/boot.h | 1 + target/riscv/cpu.c | 8 ++++++++ target/riscv/cpu.h | 3 +++ target/riscv/kvm-stub.c | 25 +++++++++++++++++++++++++ target/riscv/kvm.c | 14 ++++++++++++++ target/riscv/kvm_riscv.h | 24 ++++++++++++++++++++++++ target/riscv/meson.build | 2 +- 9 files changed, 94 insertions(+), 1 deletion(-) create mode 100644
target/riscv/kvm-stub.ccreate mode 100644target/riscv/kvm_riscv.hhw/riscv/boot.c index renamed from hw/riscv/boot.c +0
-0
519fa455a1..00df6d7810100644hw/riscv/boot.c +10
-0@@ -317,3 +317,14 @@ void riscv_setup_rom_reset_vec(MachineState *machine, RISCVHartArrayState *harts return; } + +void riscv_setup_direct_kernel (hwaddr kernel_addr,hwaddr fdt_addr) { +CPUState *cs; + +for (cs = first_cpu; cs; cs =CPU_NEXT (cs)) { +RISCVCPU *riscv_cpu =RISCV_CPU (cs); + riscv_cpu->env.kernel_addr = kernel_addr; + riscv_cpu->env.fdt_addr = fdt_addr; + } +}hw/riscv/virt.c index renamed from hw/riscv/virt.c +0
-0
3af074148e..e3452b25e8100644hw/riscv/virt.c +0
-0@@ -941,6 +941,13 @@ static void virt_machine_init(MachineState*machine)
hw/riscv/virt.c static void virt_machine_init(MachineState · line 941
Quoted 1 line
hw/riscv/virt.c +0
-0virt_memmap[VIRT_MROM].size,
kernel_entry,hw/riscv/virt.c static void virt_machine_init(MachineState *machine) · line 949
Quoted 8 lines
hw/riscv/virt.c +6
-0fdt_load_addr, machine->fdt); +/* +* Only direct boot kernel is currently supported for KVM VM, +* So here setup kernel start address and fdt address. +* TODO:Support firmware loading and integrate to TCG start +*/ +riscv_setup_direct_kernel (kernel_entry, fdt_load_addr);
Quoted 5 lines
This should be under "if (
kvm_enabled()) {".Also, update virt machine such that the "-bios" parameter is ignored and treated like "-bios none" when KVM is enabled.
Thanks, it will be modified in the next series.
Quoted 7 lines
Further, virt machine should not create an ACLINT (or SiFive CLINT) instance when KVM is enabled. Event the PLIC should be created without M-mode PLIC contexts when KVM is enabled.
Regards,
Anup
Yes, you are right. But in order to reuse the PLIC, it is not planned to modify the PLIC at this time.
Yifei
Quoted 184 lines
include/hw/riscv/boot.h void riscv_rom_copy_firmware_info(MachineState
Quoted 9 lines
hw/riscv/virt.c +1
-0+/* SiFive Test MMIO device */ sifive_test_create (memmap[VIRT_TEST ].base);include/hw/riscv/boot.h index renamed from include/hw/riscv/boot.h +0
-0
baff11dd8a..5834c234aa100644include/hw/riscv/boot.h +0
-0@@ -58,5 +58,6 @@ void riscv_rom_copy_firmware_info(MachineState*machine, hwaddr
rom_base,Quoted 54 lines
include/hw/riscv/boot.h +1
-0hwaddr rom_size, uint32_t reset_vec_size, uint64_t kernel_entry); +void riscv_setup_direct_kernel (hwaddr kernel_addr,hwaddr fdt_addr);#endif /* RISCV_BOOT_H */ target/riscv/cpu.c index renamed from target/riscv/cpu.c +0
-0
f812998123..1c944872a3100644target/riscv/cpu.c +8
-0@@ -29,6 +29,8 @@#include "hw/qdev-properties.h" #include "migration/vmstate.h" #include "fpu/softfloat-helpers.h" +#include "sysemu/kvm.h" +#include "kvm_riscv.h" /* RISC-V CPU definitions */ @@ -380,6 +382,12 @@ static void riscv_cpu_reset(DeviceState *dev) cs->exception_index =RISCV_EXCP_NONE ; env->load_res =-1 ;set_default_nan_mode (1 , &env->fp_status); + +#ifndef CONFIG_USER_ONLY +if (kvm_enabled ()) { +kvm_riscv_reset_vcpu (cpu); + } +#endif } static void riscv_cpu_disas_set_info(CPUState *s, disassemble_info*info) diff --git
a/target/riscv/cpu.hb/target/riscv/cpu.hindex0760c0af93..2807eb1bcb100644target/riscv/cpu.h +3
-0@@ -255,6 +255,9 @@ struct CPURISCVState {/* Fields from here on are preserved across CPU reset. */ QEMUTimer *timer;/* Internal timer */ + +hwaddr kernel_addr; +hwaddr fdt_addr; }; OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass, diff --git
a/target/riscv/kvm-stub.cb/target/riscv/kvm-stub.cnew file mode 100644 index 0000000000..39b96fe3f4target/riscv/kvm-stub.c new file +3
-0@@ -0,0 +1,25 @@ +/* +* QEMU KVM RISC-V specific function stubs +* target/riscv/kvm-stub.c line 13
Quoted 10 lines
target/riscv/kvm-stub.c new file +10
-0+* 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
Quoted 55 lines
target/riscv/kvm-stub.c new file +16
-0+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/>. +*/ +#include "qemu/osdep.h" +#include "cpu.h" +#include "kvm_riscv.h" + +void kvm_riscv_reset_vcpu (RISCVCPU *cpu) { +abort (); +}target/riscv/kvm.c index renamed from target/riscv/kvm.c +0
-0
5fe5ca4434..7f3ffcc2b4100644target/riscv/kvm.c +1
-0@@ -37,6 +37,7 @@#include "hw/irq.h" #include "qemu/log.h" #include "hw/loader.h" +#include "kvm_riscv.h" static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type,
uint64_tidx) { @@ -444,6 +445,19 @@ intkvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)return 0;}
target/riscv/kvm.c +12
-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 */ + env->satp =0 ; +} +bool kvm_arch_cpu_check_are_resettable (void ) {return true;target/riscv/kvm_riscv.h new renamed from target/riscv/kvm_riscv.h +0
-0file mode 100644 index 0000000000..f38c82bf59
target/riscv/kvm_riscv.h new file +3
-0@@ -0,0 +1,24 @@ +/* +* QEMU KVM support -- RISC-V specific functions. +* target/riscv/kvm_riscv.h line 13
Quoted 10 lines
target/riscv/kvm_riscv.h new file +10
-0+* 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
Quoted 34 lines
target/riscv/kvm_riscv.h new file +16
-0+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 target/riscv/meson.build index renamed from target/riscv/meson.build +0
-0
2faf08a941..fe41cc5805100644target/riscv/meson.build +2
-2@@ -19,7 +19,7 @@ riscv_ss.add(files( 'bitmanip_helper.c', 'translate.c', )) -riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c')) +riscv_ss.add(when: 'CONFIG_KVM', if_true: files('kvm.c'), if_false: +files('kvm-stub.c')) riscv_softmmu_ss = ss.source_set() riscv_softmmu_ss.add(files( --2.19.1
Quoted 4 lines
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 7/12 target/riscv: Support setting external interrupt by KVM
In reply to Yifei JiangExtend riscv_cpu_update_mip() to support setting external interrupt by KVM. It will call kvm_riscv_set_irq() to change the IRQ state in the KVM module When kvm is enabled and the MIP_SEIP bit is set in "mask"
In addition, bacause target/riscv/cpu_helper.c is used to TCG, so move riscv_cpu_update_mip() to target/riscv/cpu.c from target/riscv/cpu_helper.c
--- target/riscv/cpu.c | 34 ++++++++++++++++++++++++++++++++++ target/riscv/cpu_helper.c | 27 --------------------------- target/riscv/kvm-stub.c | 5 +++++ target/riscv/kvm.c | 20 ++++++++++++++++++++ target/riscv/kvm_riscv.h | 1 + 5 files changed, 60 insertions(+), 27 deletions(-)
target/riscv/cpu.c +34 -0
@@ -21,6 +21,7 @@#include "qemu/qemu-print.h" #include "qemu/ctype.h" #include "qemu/log.h" +#include "qemu/main-loop.h" #include "cpu.h" #include "internals.h" #include "exec/exec-all.h"
@@ -131,6 +132,39 @@ static void set_feature(CPURISCVState *env, int feature) env->features |= (1ULL << feature); } +#ifndef CONFIG_USER_ONLY +uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t value) +{ +CPURISCVState *env = &cpu->env; +CPUState *cs =CPU (cpu); +uint32_t old = env->mip; +bool locked = false; + +if (!qemu_mutex_iothread_locked ()) { + locked = true; +qemu_mutex_lock_iothread (); + } + + env->mip = (env->mip & ~mask) | (value & mask); + +if (kvm_enabled () && (mask &MIP_SEIP )) { +kvm_riscv_set_irq (RISCV_CPU (cpu),IRQ_S_EXT , value &MIP_SEIP ); + } + +if (env->mip) { +cpu_interrupt (cs,CPU_INTERRUPT_HARD ); + }else { +cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); + } + +if (locked) { +qemu_mutex_unlock_iothread (); + } + +return old; +} +#endif +static void set_resetvec (CPURISCVState *env,target_ulong resetvec) {#ifndef CONFIG_USER_ONLY
target/riscv/cpu_helper.c +0 -27
@@ -286,33 +286,6 @@ int riscv_cpu_claim_interrupts(RISCVCPU *cpu, uint32_t interrupts) } } -uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t value) -{ -CPURISCVState *env = &cpu->env; -CPUState *cs =CPU (cpu); -uint32_t old = env->mip; -bool locked = false; - -if (!qemu_mutex_iothread_locked ()) { - locked = true; -qemu_mutex_lock_iothread (); - } - - env->mip = (env->mip & ~mask) | (value & mask); - -if (env->mip) { -cpu_interrupt (cs,CPU_INTERRUPT_HARD ); - }else { -cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); - } - -if (locked) { -qemu_mutex_unlock_iothread (); - } - -return old; -} -void riscv_cpu_set_rdtime_fn (CPURISCVState *env,uint64_t (*fn)(uint32_t ),uint32_t arg) {
target/riscv/kvm-stub.c +5 -0
@@ -23,3 +23,8 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) {abort (); } + +void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level) +{ +abort (); +}
target/riscv/kvm.c +20 -0
@@ -458,6 +458,26 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) env->satp =0 ; } +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 (); + } +} +bool kvm_arch_cpu_check_are_resettable (void ) {return true;
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
Anup Patel
maintainerRe: [PATCH v1 07/12] target/riscv: Support setting external interrupt by KVM
Quoted 58 lines · Yifei Jiang
Extend
riscv_cpu_update_mip()to support setting external interrupt by KVM. It will callkvm_riscv_set_irq()to change the IRQ state in the KVM module When kvm is enabled and theMIP_SEIPbit is set in "mask"In addition, bacause
target/riscv/cpu_helper.cis used to TCG, so moveriscv_cpu_update_mip()totarget/riscv/cpu.cfromtarget/riscv/cpu_helper.cSigned-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- target/riscv/cpu.c | 34 ++++++++++++++++++++++++++++++++++ target/riscv/cpu_helper.c | 27 --------------------------- target/riscv/kvm-stub.c | 5 +++++ target/riscv/kvm.c | 20 ++++++++++++++++++++ target/riscv/kvm_riscv.h | 1 + 5 files changed, 60 insertions(+), 27 deletions(-)target/riscv/cpu.c +24
-0@@ -21,6 +21,7 @@#include "qemu/qemu-print.h" #include "qemu/ctype.h" #include "qemu/log.h" +#include "qemu/main-loop.h" #include "cpu.h" #include "internals.h" #include "exec/exec-all.h" @@ -131,6 +132,39 @@ static void set_feature(CPURISCVState *env, int feature) env->features |= (1ULL << feature); } +#ifndef CONFIG_USER_ONLY +uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t value) +{ +CPURISCVState *env = &cpu->env; +CPUState *cs =CPU (cpu); +uint32_t old = env->mip; +bool locked = false; + +if (!qemu_mutex_iothread_locked ()) { + locked = true; +qemu_mutex_lock_iothread (); + } + + env->mip = (env->mip & ~mask) | (value & mask); + +if (kvm_enabled () && (mask &MIP_SEIP )) { +kvm_riscv_set_irq (RISCV_CPU (cpu),IRQ_S_EXT , value &MIP_SEIP ); + } + +if (env->mip) { +cpu_interrupt (cs,CPU_INTERRUPT_HARD ); + }else { +cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD );
target/riscv/cpu.c static void set_feature(CPURISCVState *env, int feature) · line 167
Quoted 10 lines
target/riscv/cpu.c +10
-0+ } + +if (locked) { +qemu_mutex_unlock_iothread (); + } + +return old; +} +#endif +
We should not change riscv_cpu_update_mip() for injecting KVM interrupts because this function touches the user-space state of MIP csr but for KVM the SIP csr state is always in kernel-space.
Further, the KVM kernel-space ensures synchronization so we don't need to do qemu_mutex_lock/unlock_iothread() for KVM interrupts.
I would suggest to extend riscv_cpu_set_irq() for KVM interrupts. When KVM is enabled, the riscv_cpu_set_irq() should throw warning/abort for any interrupt other than S-mode external interrupts.
Regards,
Anup
Quoted 104 lines
target/riscv/cpu.c +0
-0static void set_resetvec (CPURISCVState *env,target_ulong resetvec) {#ifndef CONFIG_USER_ONLY target/riscv/cpu_helper.c +0
-27@@ -286,33 +286,6 @@ int riscv_cpu_claim_interrupts(RISCVCPU *cpu, uint32_t interrupts) } } -uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t value) -{ -CPURISCVState *env = &cpu->env; -CPUState *cs =CPU (cpu); -uint32_t old = env->mip; -bool locked = false; - -if (!qemu_mutex_iothread_locked ()) { - locked = true; -qemu_mutex_lock_iothread (); - } - - env->mip = (env->mip & ~mask) | (value & mask); - -if (env->mip) { -cpu_interrupt (cs,CPU_INTERRUPT_HARD ); - }else { -cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD ); - } - -if (locked) { -qemu_mutex_unlock_iothread (); - } - -return old; -} -void riscv_cpu_set_rdtime_fn (CPURISCVState *env,uint64_t (*fn)(uint32_t ),uint32_t arg) {target/riscv/kvm-stub.c +5
-0@@ -23,3 +23,8 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) {abort (); } + +void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level) +{ +abort (); +}target/riscv/kvm.c +20
-0@@ -458,6 +458,26 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) env->satp =0 ; } +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 (); + } +} +bool kvm_arch_cpu_check_are_resettable (void ) {return true;target/riscv/kvm_riscv.h +1
-1@@ -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 --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
RE: [PATCH v1 07/12] target/riscv: Support setting external interrupt by KVM
Quoted 97 lines
-----Original Message-----
From: kvm-riscv [mailto:kvm-riscv-bounces at lists.infradead.org] On Behalf Of Anup Patel
Sent: Friday, December 3, 2021 5:15 PM
To: Jiangyifei <[email protected]>
Cc: QEMU Developers <[email protected]>; open list:RISC-V <[email protected]>; kvm-riscv at lists.infradead.org; KVM General <[email protected]>; libvir-list at redhat.com; Anup Patel <[email protected]>; Palmer Dabbelt <[email protected]>; Alistair Francis <[email protected]>; Bin Meng <[email protected]>; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>; Wanghaibin (D) <[email protected]>; wanbo (G) <[email protected]>; limingwang (A) <[email protected]>
Subject: Re: [PATCH v1 07/12] target/riscv: Support setting external interrupt by KVMtarget/riscv/cpu.c static void set_feature(CPURISCVState *env, int
Quoted 33 lines · Yifei Jiang
Extend
riscv_cpu_update_mip()to support setting external interrupt by KVM. It will callkvm_riscv_set_irq()to change the IRQ state in the KVM module When kvm is enabled and theMIP_SEIPbit is set in "mask"In addition, bacause
target/riscv/cpu_helper.cis used to TCG, so moveriscv_cpu_update_mip()totarget/riscv/cpu.cfromtarget/riscv/cpu_helper.cSigned-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>--- target/riscv/cpu.c | 34 ++++++++++++++++++++++++++++++++++ target/riscv/cpu_helper.c | 27 --------------------------- target/riscv/kvm-stub.c | 5 +++++ target/riscv/kvm.c | 20 ++++++++++++++++++++ target/riscv/kvm_riscv.h | 1 + 5 files changed, 60 insertions(+), 27 deletions(-)target/riscv/cpu.c index renamed from target/riscv/cpu.c +0
-0
1c944872a3..a464845c99100644target/riscv/cpu.c +1
-0@@ -21,6 +21,7 @@#include "qemu/qemu-print.h" #include "qemu/ctype.h" #include "qemu/log.h" +#include "qemu/main-loop.h" #include "cpu.h" #include "internals.h" #include "exec/exec-all.h" @@ -131,6 +132,39 @@ static void set_feature(CPURISCVState *env, intfeature)
Quoted 9 lines
target/riscv/cpu.c +7
-0env->features |= (1ULL << feature); } +#ifndef CONFIG_USER_ONLY +uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t +value) { +CPURISCVState *env = &cpu->env; +CPUState *cs =CPU (cpu); +uint32_t old = env->mip; +bool locked = false;target/riscv/cpu.c static void set_feature(CPURISCVState *env, int feature)
Quoted 10 lines
target/riscv/cpu.c +10
-0+ +if (!qemu_mutex_iothread_locked ()) { + locked = true; +qemu_mutex_lock_iothread (); + } + + env->mip = (env->mip & ~mask) | (value & mask); + +if (kvm_enabled () && (mask &MIP_SEIP )) { + kvm_riscv_set_irq(RISCV_CPU(cpu), IRQ_S_EXT, value &
MIP_SEIP);Quoted 6 lines
target/riscv/cpu.c +6
-0+ } + +if (env->mip) { +cpu_interrupt (cs,CPU_INTERRUPT_HARD ); + }else { +cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD );target/riscv/cpu.c static void set_feature(CPURISCVState *env, int feature) · line 167
Quoted 10 lines
target/riscv/cpu.c +10
-0+ } + +if (locked) { +qemu_mutex_unlock_iothread (); + } + +return old; +} +#endif +We should not change
riscv_cpu_update_mip()for injecting KVM interrupts because this function touches the user-space state of MIP csr but for KVM the SIP csr state is always in kernel-space.Further, the KVM kernel-space ensures synchronization so we don't need to do qemu_mutex_lock/unlock_iothread() for KVM interrupts.
Quoted 7 lines
I would suggest to extend
riscv_cpu_set_irq()for KVM interrupts. When KVM is enabled, theriscv_cpu_set_irq()should throw warning/abort for any interrupt other than S-mode external interrupts.Regards,
Anup
Thanks, it will be modified in the next series.
Yifei
Quoted 106 lines
target/riscv/cpu_helper.c int riscv_cpu_claim_interrupts(RISCVCPU *cpu,
Quoted 6 lines
target/riscv/cpu.c +0
-0static void set_resetvec (CPURISCVState *env,target_ulong resetvec){ #ifndef
CONFIG_USER_ONLYdiff --gita/target/riscv/cpu_helper.cb/target/riscv/cpu_helper.cindex9eeed38c7e..5e36c35b15100644target/riscv/cpu_helper.c +0
-0@@ -286,33 +286,6 @@ int riscv_cpu_claim_interrupts(RISCVCPU *cpu,
uint32_tinterrupts)Quoted 21 lines
target/riscv/cpu_helper.c +0
-17} } -uint32_t riscv_cpu_update_mip (RISCVCPU *cpu,uint32_t mask,uint32_t value) -{ -CPURISCVState *env = &cpu->env; -CPUState *cs =CPU (cpu); -uint32_t old = env->mip; -bool locked = false; - -if (!qemu_mutex_iothread_locked ()) { - locked = true; -qemu_mutex_lock_iothread (); - } - - env->mip = (env->mip & ~mask) | (value & mask); - -if (env->mip) { -cpu_interrupt (cs,CPU_INTERRUPT_HARD ); - }else { -cpu_reset_interrupt (cs,CPU_INTERRUPT_HARD );target/riscv/cpu_helper.c int riscv_cpu_claim_interrupts(RISCVCPU *cpu, uint32_t interrupts)
Quoted 10 lines
target/riscv/cpu_helper.c +0
-9- } - -if (locked) { -qemu_mutex_unlock_iothread (); - } - -return old; -} - void riscv_cpu_set_rdtime_fn(CPURISCVState *env, uint64_t(*fn)(uint32_t),
Quoted 17 lines
target/riscv/cpu_helper.c +0
-0uint32_t arg) { diff --git
a/target/riscv/kvm-stub.cb/target/riscv/kvm-stub.cindex39b96fe3f4..4e8fc31a21100644target/riscv/kvm-stub.c +4
-0@@ -23,3 +23,8 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) {abort (); } + +void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level) { +abort (); +}target/riscv/kvm.c index renamed from target/riscv/kvm.c +0
-0
7f3ffcc2b4..8da2648d1a100644target/riscv/kvm.c void kvm_riscv_reset_vcpu(RISCVCPU *cpu) · line 463
Quoted 6 lines
target/riscv/kvm.c +3
-0@@ -458,6 +458,26 @@ void kvm_riscv_reset_vcpu(RISCVCPU *cpu) env->satp =0 ; } +void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level) { +int ret; + unsigned virq = level ? KVM_INTERRUPT_SET :
KVM_INTERRUPT_UNSET;Quoted 34 lines
target/riscv/kvm.c +16
-0+ +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 (); + } +} +bool kvm_arch_cpu_check_are_resettable (void ) {return true;target/riscv/kvm_riscv.h index renamed from target/riscv/kvm_riscv.h +0
-0
f38c82bf59..ed281bdce0100644target/riscv/kvm_riscv.h +1
-1@@ -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 --2.19.1
Quoted 4 lines
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 8/12 target/riscv: Handle KVM_EXIT_RISCV_SBI exit
In reply to Yifei JiangUse char-fe to handle 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 uint64_t kvm_riscv_reg_id (CPURISCVState *env,uint64_t type,uint64_t idx) {
@@ -440,9 +442,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
Re: [PATCH v1 08/12] target/riscv: Handle KVM_EXIT_RISCV_SBI exit
Hi,
Quoted 35 lines · Yifei Jiang
Use char-fe to handle console sbi call, which implement early console io while apply 'earlycon=sbi' into kernel parameters.
Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>--- 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.htarget/riscv/kvm.c +9
-0@@ -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 uint64_t kvm_riscv_reg_id (CPURISCVState *env,uint64_t type,uint64_t idx) {@@ -440,9 +442,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 ];
target/riscv/kvm.c bool kvm_arch_stop_on_emulation_error(CPUState *cs) · line 461
Quoted 10 lines
target/riscv/kvm.c +10
-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 ;
Shouldn't this code use the Semihosting Console API from "semihosting/console.h" instead?
RE: [PATCH v1 08/12] target/riscv: Handle KVM_EXIT_RISCV_SBI exit
Quoted 59 lines
-----Original Message-----
From: Philippe Mathieu-Daud? [mailto:philippe.mathieu.daude at gmail.com] On Behalf Of Philippe Mathieu-Daud?
Sent: Saturday, November 20, 2021 8:25 PM
To: Jiangyifei <[email protected]>; qemu-devel at nongnu.org; qemu-riscv at nongnu.org
Cc: bin.meng at windriver.com; limingwang (A) <[email protected]>; kvm at vger.kernel.org; libvir-list at redhat.com; anup.patel at wdc.com; wanbo (G) <[email protected]>; Alistair.Francis at wdc.com;
kvm-riscv at lists.infradead.org; Wanghaibin (D) <[email protected]>; palmer at dabbelt.com; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>; Alex Benn?e <[email protected]>
Subject: Re: [PATCH v1 08/12] target/riscv: HandleKVM_EXIT_RISCV_SBIexitHi,
Quoted 40 lines · Yifei Jiang
Use char-fe to handle console sbi call, which implement early console io while apply 'earlycon=sbi' into kernel parameters.
Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>--- 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.htarget/riscv/kvm.c index renamed from target/riscv/kvm.c +0
-0
8da2648d1a..6d419ba02e100644target/riscv/kvm.c +2
-0@@ -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 uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type,
uint64_tidx) { @@ -440,9 +442,47 @@ boolkvm_arch_stop_on_emulation_error(CPUState *cs)return true;}
target/riscv/kvm.c +11
-0+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)) {
Quoted 8 lines
target/riscv/kvm.c bool kvm_arch_stop_on_emulation_error(CPUState *cs) · line 461
Quoted 5 lines
target/riscv/kvm.c +5
-0+ run->riscv_sbi.args[0 ] = ch; + }else { + run->riscv_sbi.args[0 ] =-1 ; + } +break ;Shouldn't this code use the Semihosting Console API from "
semihosting/console.h" instead?
Thanks, I will use this API in the next series.
Yifei
PATCH 9/12 target/riscv: Add host cpu type
In reply to Yifei Jiang'host' type cpu is set isa to RV32 or RV64 simply, more isa info will obtain from KVM in kvm_arch_init_vcpu()
--- target/riscv/cpu.c | 15 +++++++++++++++ target/riscv/cpu.h | 1 + 2 files changed, 16 insertions(+)
target/riscv/cpu.c +15 -0
@@ -247,6 +247,18 @@ static void rv32_imafcu_nommu_cpu_init(Object *obj) }#endif +#if defined(CONFIG_KVM ) +static void riscv_host_cpu_init (Object *obj) +{ +CPURISCVState *env = &RISCV_CPU (obj)->env; +#if defined(TARGET_RISCV32 ) +set_misa (env,MXL_RV32 ,0 ); +#elif defined(TARGET_RISCV64 ) +set_misa (env,MXL_RV64 ,0 ); +#endif +} +#endif +static ObjectClass *riscv_cpu_class_by_name (const char *cpu_model) {ObjectClass *oc;
@@ -844,6 +856,9 @@ static const TypeInfo riscv_cpu_type_infos[] = { .class_init = riscv_cpu_class_init, }, DEFINE_CPU(TYPE_RISCV_CPU_ANY, riscv_any_cpu_init), +#if defined(CONFIG_KVM ) + DEFINE_CPU(TYPE_RISCV_CPU_HOST, riscv_host_cpu_init), +#endif #if defined(TARGET_RISCV32 )DEFINE_CPU (TYPE_RISCV_CPU_BASE32 , rv32_base_cpu_init), DEFINE_CPU(TYPE_RISCV_CPU_IBEX, rv32_ibex_cpu_init),
target/riscv/cpu.h +1 -0
@@ -45,6 +45,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")#if defined(TARGET_RISCV32 )# define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE32
Signature · 1 line
2.19.1
Re: [PATCH v1 09/12] target/riscv: Add host cpu type
Quoted 7 lines · Yifei Jiang
'host' type cpu is set isa to RV32 or RV64 simply, more isa info will obtain from KVM in
kvm_arch_init_vcpu()Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>Reviewed-by Alistair Francis <[email protected]>
Looks good to me.
Regards,
Anup
Quoted 58 lines
--- target/riscv/cpu.c | 15 +++++++++++++++ target/riscv/cpu.h | 1 + 2 files changed, 16 insertions(+)target/riscv/cpu.c +15
-0@@ -247,6 +247,18 @@ static void rv32_imafcu_nommu_cpu_init(Object *obj) }#endif +#if defined(CONFIG_KVM ) +static void riscv_host_cpu_init (Object *obj) +{ +CPURISCVState *env = &RISCV_CPU (obj)->env; +#if defined(TARGET_RISCV32 ) +set_misa (env,MXL_RV32 ,0 ); +#elif defined(TARGET_RISCV64 ) +set_misa (env,MXL_RV64 ,0 ); +#endif +} +#endif +static ObjectClass *riscv_cpu_class_by_name (const char *cpu_model) {ObjectClass *oc;@@ -844,6 +856,9 @@ static const TypeInfo riscv_cpu_type_infos[] = { .class_init = riscv_cpu_class_init, }, DEFINE_CPU(TYPE_RISCV_CPU_ANY, riscv_any_cpu_init), +#if defined(CONFIG_KVM ) + DEFINE_CPU(TYPE_RISCV_CPU_HOST, riscv_host_cpu_init), +#endif #if defined(TARGET_RISCV32 )DEFINE_CPU (TYPE_RISCV_CPU_BASE32 , rv32_base_cpu_init), DEFINE_CPU(TYPE_RISCV_CPU_IBEX, rv32_ibex_cpu_init),target/riscv/cpu.h +1
-1@@ -45,6 +45,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")#if defined(TARGET_RISCV32 )# define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE32 --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 10/12 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.
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
@@ -259,6 +259,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; }; OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass,
target/riscv/kvm.c +72 -0
84 lines not on this page · raw message
Signature · 1 line
2.19.1
Anup Patel
maintainerRe: [PATCH v1 10/12] target/riscv: Add kvm_riscv_get/put_regs_timer
Quoted 20 lines · Yifei Jiang
Add kvm_riscv_get/put_regs_timer to synchronize virtual time context from KVM.
To set register of
RISCV_TIMER_REG(state)will occur a error from KVM onkvm_timer_state== 0. It's better to adapt in KVM, but it doesn't matter that adaping in QEMU.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>--- target/riscv/cpu.h | 6 ++++ target/riscv/kvm.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)target/riscv/cpu.h +0
-0
target/riscv/cpu.h struct CPURISCVState { · line 267
Quoted 9 lines
target/riscv/cpu.h +6
-0@@ -259,6 +259,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;
We should also include kvm_timer_frequency here.
Currently, it is read-only but in-future KVM RISC-V will allow setting timer_frequency using SBI para-virt time scaling extension.
Regards,
Anup
Quoted 101 lines
target/riscv/cpu.h +0
-0}; OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass,target/riscv/kvm.c +72
-1@@ -64,6 +64,9 @@ static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx#define RISCV_CSR_REG (env, name) kvm_riscv_reg_id(env, KVM_REG_RISCV_CSR, \ KVM_REG_RISCV_CSR_REG(name)) +#define RISCV_TIMER_REG (env, name) kvm_riscv_reg_id(env, KVM_REG_RISCV_TIMER, \ + KVM_REG_RISCV_TIMER_REG(name)) +#define RISCV_FP_F_REG (env, idx) kvm_riscv_reg_id(env, KVM_REG_RISCV_FP_F, idx)#define RISCV_FP_D_REG (env, idx) kvm_riscv_reg_id(env, KVM_REG_RISCV_FP_D, idx)@@ -310,6 +313,75 @@ static int kvm_riscv_put_regs_fp(CPUState *cs)return ret; } +static void kvm_riscv_get_regs_timer (CPUState *cs) +{ +int ret; +uint64_t reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + +if (env->kvm_timer_dirty) { +return ; + } + + ret =kvm_get_one_reg (cs,RISCV_TIMER_REG (env, time), ®); +if (ret) { +abort (); + } + env->kvm_timer_time = reg; + + ret =kvm_get_one_reg (cs,RISCV_TIMER_REG (env, compare), ®); +if (ret) { +abort (); + } + env->kvm_timer_compare = reg; + + ret =kvm_get_one_reg (cs,RISCV_TIMER_REG (env, state), ®); +if (ret) { +abort (); + } + env->kvm_timer_state = reg; + + env->kvm_timer_dirty = true; +} + +static void kvm_riscv_put_regs_timer (CPUState *cs) +{ +int ret; +uint64_t reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + +if (!env->kvm_timer_dirty) { +return ; + } + + reg = env->kvm_timer_time; + ret =kvm_set_one_reg (cs,RISCV_TIMER_REG (env, time), ®); +if (ret) { +abort (); + } + + reg = env->kvm_timer_compare; + ret =kvm_set_one_reg (cs,RISCV_TIMER_REG (env, compare), ®); +if (ret) { +abort (); + } + +/* +* To set register of RISCV_TIMER_REG(state) will occur a error from KVM +* on env->kvm_timer_state == 0, It's better to adapt in KVM, but it +* doesn't matter that adaping in QEMU now. +* TODO If KVM changes, adapt here. +*/ +if (env->kvm_timer_state) { + reg = env->kvm_timer_state; + ret =kvm_set_one_reg (cs,RISCV_TIMER_REG (env, state), ®); +if (ret) { +abort (); + } + } + + env->kvm_timer_dirty = false; +}const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
RE: [PATCH v1 10/12] target/riscv: Add kvm_riscv_get/put_regs_timer
Quoted 50 lines
-----Original Message-----
From: Anup Patel [mailto:anup at brainfault.org]
Sent: Friday, December 3, 2021 5:38 PM
To: Jiangyifei <[email protected]>
Cc: QEMU Developers <[email protected]>; open list:RISC-V <[email protected]>; kvm-riscv at lists.infradead.org; KVM General <[email protected]>; libvir-list at redhat.com; Anup Patel <[email protected]>; Palmer Dabbelt <[email protected]>; Alistair Francis <[email protected]>; Bin Meng <[email protected]>; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>; Wanghaibin (D) <[email protected]>; wanbo (G) <[email protected]>; limingwang (A) <[email protected]>
Subject: Re: [PATCH v1 10/12] target/riscv: Add kvm_riscv_get/put_regs_timerQuoted 21 lines · Yifei Jiang
Add kvm_riscv_get/put_regs_timer to synchronize virtual time context from KVM.
To set register of
RISCV_TIMER_REG(state)will occur a error from KVM onkvm_timer_state== 0. It's better to adapt in KVM, but it doesn't matter that adaping in QEMU.Signed-off-by Yifei Jiang <[email protected]>Signed-off-by Mingwang Li <[email protected]>--- target/riscv/cpu.h | 6 ++++ target/riscv/kvm.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)target/riscv/cpu.h index renamed from target/riscv/cpu.h +0
-0
e7dba35acb..dea49e53f0100644target/riscv/cpu.h struct CPURISCVState { · line 267
Quoted 9 lines
target/riscv/cpu.h +6
-0@@ -259,6 +259,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;We should also include
kvm_timer_frequencyhere.
Quoted 6 lines
Currently, it is read-only but in-future KVM RISC-V will allow setting
timer_frequencyusing SBI para-virt time scaling extension.Regards,
Anup
Ok, added.
Quoted 104 lines
target/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState *env, · line 64
Quoted 9 lines
target/riscv/cpu.h +0
-0}; OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass, diff --git
a/target/riscv/kvm.cb/target/riscv/kvm.cindex6d419ba02e..e5725770f2100644target/riscv/kvm.c +0
-0@@ -64,6 +64,9 @@ static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx #define RISCV_CSR_REG(env, name)kvm_riscv_reg_id(env,
KVM_REG_RISCV_CSR, \target/riscv/kvm.c static uint64_t kvm_riscv_reg_id(CPURISCVState *env, uint64_t type, uint64_t idx
Quoted 3 lines
target/riscv/kvm.c +1
-0KVM_REG_RISCV_CSR_REG(name)) +#define RISCV_TIMER_REG (env, name) kvm_riscv_reg_id(env,
KVM_REG_RISCV_TIMER, \Quoted 7 lines
target/riscv/kvm.c +2
-0+ KVM_REG_RISCV_TIMER_REG(name)) +#define RISCV_FP_F_REG (env, idx) kvm_riscv_reg_id(env, KVM_REG_RISCV_FP_F, idx)#define
RISCV_FP_D_REG(env, idx)kvm_riscv_reg_id(env,KVM_REG_RISCV_FP_D, idx) @@ -310,6 +313,75 @@ static int
kvm_riscv_put_regs_fp(CPUState *cs)Quoted 46 lines
return ret;}
target/riscv/kvm.c +43
-0+static void kvm_riscv_get_regs_timer (CPUState *cs) { +int ret; +uint64_t reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + +if (env->kvm_timer_dirty) { +return ; + } + + ret =kvm_get_one_reg (cs,RISCV_TIMER_REG (env, time), ®); +if (ret) { +abort (); + } + env->kvm_timer_time = reg; + + ret =kvm_get_one_reg (cs,RISCV_TIMER_REG (env, compare), ®); +if (ret) { +abort (); + } + env->kvm_timer_compare = reg; + + ret =kvm_get_one_reg (cs,RISCV_TIMER_REG (env, state), ®); +if (ret) { +abort (); + } + env->kvm_timer_state = reg; + + env->kvm_timer_dirty = true; +} + +static void kvm_riscv_put_regs_timer (CPUState *cs) { +int ret; +uint64_t reg; +CPURISCVState *env = &RISCV_CPU (cs)->env; + +if (!env->kvm_timer_dirty) { +return ; + } + + reg = env->kvm_timer_time; + ret =kvm_set_one_reg (cs,RISCV_TIMER_REG (env, time), ®); +if (ret) { +abort ();target/riscv/kvm.c static int kvm_riscv_put_regs_fp(CPUState *cs)
Quoted 10 lines
target/riscv/kvm.c +10
-0+ } + + reg = env->kvm_timer_compare; + ret =kvm_set_one_reg (cs,RISCV_TIMER_REG (env, compare), ®); +if (ret) { +abort (); + } + +/* +* To set register of RISCV_TIMER_REG(state) will occur a error from KVM
Quoted 25 lines
target/riscv/kvm.c +14
-1+* on env->kvm_timer_state == 0, It's better to adapt in KVM, but it +* doesn't matter that adaping in QEMU now. +* TODO If KVM changes, adapt here. +*/ +if (env->kvm_timer_state) { + reg = env->kvm_timer_state; + ret =kvm_set_one_reg (cs,RISCV_TIMER_REG (env, state), ®); +if (ret) { +abort (); + } + } + + env->kvm_timer_dirty = false; +}const KVMCapabilityInfo kvm_arch_required_capabilities[] = {KVM_CAP_LAST_INFO --2.19.1
--
kvm-riscv mailing list
kvm-riscv at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/kvm-riscv
PATCH 11/12 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 uint64_t kvm_riscv_reg_id (CPURISCVState *env,uint64_t type,uint64_t idx) {
@@ -452,6 +453,17 @@ unsigned long kvm_arch_vcpu_id(CPUState *cpu)return cpu->cpu_index; } +static void kvm_riscv_vm_state_change (void *opaque,bool 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) { }
@@ -464,6 +476,8 @@ int kvm_arch_init_vcpu(CPUState *cs)CPURISCVState *env = &cpu->env;uint64_t id; +qemu_add_vm_change_state_handler (kvm_riscv_vm_state_change, cs); + id =kvm_riscv_reg_id (env,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
PATCH 12/12 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/machine.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
target/riscv/machine.c +14 -0
@@ -164,10 +164,20 @@ static const VMStateDescription vmstate_pointermasking = { } }; +static int cpu_post_load (void *opaque,int version_id) +{ +RISCVCPU *cpu = opaque; +CPURISCVState *env = &cpu->env; + + env->kvm_timer_dirty = true; +return 0 ; +} +const VMStateDescription vmstate_riscv_cpu = { .name ="cpu" , .version_id =3 , .minimum_version_id =3 , + .post_load = cpu_post_load, .fields = (VMStateField []) {VMSTATE_UINTTL_ARRAY (env.gpr,RISCVCPU ,32 ),VMSTATE_UINT64_ARRAY (env.fpr,RISCVCPU ,32 ),
@@ -211,6 +221,10 @@ const VMStateDescription vmstate_riscv_cpu = {VMSTATE_UINT64 (env.mtohost,RISCVCPU ),VMSTATE_UINT64 (env.timecmp,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 () }, .subsections = (const VMStateDescription * []) {
Signature · 1 line
2.19.1
Re: [PATCH v1 12/12] target/riscv: Support virtual time context synchronization
Quoted 9 lines · Yifei Jiang
const VMStateDescription vmstate_riscv_cpu = { .name = "cpu", .version_id = 3, .minimum_version_id = 3,target/riscv/machine.c +1
-0+ .post_load = cpu_post_load, .fields = (VMStateField []) {VMSTATE_UINTTL_ARRAY (env.gpr,RISCVCPU ,32 ),VMSTATE_UINT64_ARRAY (env.fpr,RISCVCPU ,32 ),
target/riscv/machine.c const VMStateDescription vmstate_riscv_cpu = { · line 229
Quoted 9 lines
target/riscv/machine.c +4
-0@@ -211,6 +221,10 @@ const VMStateDescription vmstate_riscv_cpu = {VMSTATE_UINT64 (env.mtohost,RISCVCPU ),VMSTATE_UINT64 (env.timecmp,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 () },
Can't alter VMStateDescription.fields without bumping version.
If this is really kvm-only state, consider placing it into a subsection. But I worry about kvm-only state because ideally we'd be able to migrate between tcg and kvm (if only for debugging).
r~
RE: [PATCH v1 12/12] target/riscv: Support virtual time context synchronization
Quoted 35 lines
-----Original Message-----
From: Richard Henderson [mailto:richard.henderson at linaro.org]
Sent: Sunday, November 21, 2021 6:35 AM
To: Jiangyifei <[email protected]>; qemu-devel at nongnu.org; qemu-riscv at nongnu.org
Cc: bin.meng at windriver.com; limingwang (A) <[email protected]>; kvm at vger.kernel.org; libvir-list at redhat.com; anup.patel at wdc.com; wanbo (G) <[email protected]>; Alistair.Francis at wdc.com;
kvm-riscv at lists.infradead.org; Wanghaibin (D) <[email protected]>; palmer at dabbelt.com; Fanliang (EulerOS) <[email protected]>; Wubin (H) <[email protected]>
Subject: Re: [PATCH v1 12/12] target/riscv: Support virtual time context synchronizationQuoted 8 lines · Yifei Jiang
const VMStateDescription vmstate_riscv_cpu = { .name = "cpu", .version_id = 3, .minimum_version_id = 3,target/riscv/machine.c +1
-0+ .post_load = cpu_post_load, .fields = (VMStateField []) {VMSTATE_UINTTL_ARRAY (env.gpr,RISCVCPU ,32 ), VMSTATE_UINT64_ARRAY(env.fpr, RISCVCPU, 32), @@ -211,6target/riscv/machine.c const VMStateDescription vmstate_riscv_cpu = { · line 229
Quoted 10 lines
target/riscv/machine.c +5
-0+221,10 @@ const VMStateDescription vmstate_riscv_cpu = {VMSTATE_UINT64 (env.mtohost,RISCVCPU ),VMSTATE_UINT64 (env.timecmp,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 () },
Quoted 8 lines
Can't alter VMStateDescription.fields without bumping version.
If this is really kvm-only state, consider placing it into a subsection. But I worry about kvm-only state because ideally we'd be able to migrate between tcg and kvm (if only for debugging).
r~
Thanks, I will update the version in the next series and place it into a subsection.
Yifei
Paolo Bonzini
maintainerRe: [PATCH v1 12/12] target/riscv: Support virtual time context synchronization
In reply to Richard HendersonQuoted 21 lines · Richard Henderson
Quoted 9 lines · Yifei Jiang
? const VMStateDescription
vmstate_riscv_cpu= { ????? .name = "cpu",
????? .version_id = 3,
????? .minimum_version_id = 3,
+??? .post_load =cpu_post_load,
????? .fields = (VMStateField[]) {
?????????VMSTATE_UINTTL_ARRAY(env.gpr, RISCVCPU, 32), ?????????VMSTATE_UINT64_ARRAY(env.fpr, RISCVCPU, 32),Review const VMStateDescription vmstate_riscv_cpu = { · line 228
Quoted 8 lines
(quoted diff) +4
-0@@ -211,6 +221,10 @@ const VMStateDescription vmstate_riscv_cpu = { ????????? VMSTATE_UINT64(env.mtohost, RISCVCPU), ????????? VMSTATE_UINT64(env.timecmp, 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() ????? },Can't alter VMStateDescription.fields without bumping version.
Quoted 3 lines
If this is really kvm-only state, consider placing it into a subsection.? But I worry about kvm-only state because ideally we'd be able to migrate between tcg and kvm (if only for debugging).
Where is this state stored for TCG?
Paolo
Quoted 2 lines · Yifei Jiang
This series adds both riscv32 and riscv64 kvm support, and implements migration based on riscv.
What libvirt does when detecting KVM support is issuing query-kvm monitor command and checking if both 'present' and 'enabled' bools are true. If this is what these patches end up with we should get KVM acceleration in Libvirt for free.
Michal