target/riscv, KVM: fixes and enhancements
v8 cover target/riscv, KVM: fixes and enhancements
Hi,
This version has a last minute change in patch 14. It's a bug fix and a design change.
The bug fix: ioctl() will always error out with -1 and return the error code in 'errno'. I was checking the ioctl() return value for EINVAL, which doesn't work.
The design change has to do with discussions between Andrew and Anup and myself in our internal Slack. RISC-V KVM is overusing the EINVAL error code in set_one_reg() and get_one_reg() APIs, making it very hard for userspace (such as QEMU, crosvm, etc) to tell what went wrong. In our case, patch 14 is making an EINVAL assumption that we're not confident about because this error code can mean almost anything.
We'll push for a KVM change in the next few days. As far as QEMU goes we're going to do what we consider the right thing: check for ENOENT instead of EINVAL in patch 14. The reason why we're doing this change right now in QEMU, instead of waiting for KVM to change first, can be better explained by Drew's comment in version 7 [1]:
" But, also as discussed internally, based on our upcoming plans to use ENOENT for missing registers, we should change this check to be for ENOENT now. While that may seem premature, I think it's OK, because until a KVM which returns ENOENT for missing registers exists and is used, QEMU command lines which disable unknown registers will be rejected. But, that will also happen even after a KVM that returns ENOENT exits if an older KVM is used. In both cases that's fine, as rejecting is the more conservative behavior for an error. Finally, if the yet-to-be-posted KVM ENOENT patch never gets merged, then we may be stuck rejecting forever anyway, since EINVAL is quite generic and probably isn't safe to use for this purpose."
Checking for ENOENT is the right approach and we'll change QEMU to implement it right off the gate for 8.1. In case KVM refuses to change we'll error out in all cases in patch 14, which is still a better solution than making guesses about EINVAL means.
Series based on top of Alistair's riscv-to-apply.next.
Patches missing review: 14
Changes from v7:
- Patch 14:
- use 'errno' to check the error code from ioctl()
- test for ENOENT instead of EINVAL
- v7 link: https://lore.kernel.org/qemu-devel/[email protected]/
[1] https://lore.kernel.org/qemu-devel/20230705-091906904fcc54a4ce96e625@orel/
Daniel Henrique Barboza (20):
target/riscv: skip features setup for KVM CPUs hw/riscv/virt.c: skip 'mmu-type' FDT if satp mode not set target/riscv/cpu.c: restrict 'mvendorid' value target/riscv/cpu.c: restrict 'mimpid' value target/riscv/cpu.c: restrict 'marchid' value
target/riscv: use KVM scratch CPUs to init KVM properties target/riscv: read marchid/mimpid in kvm_riscv_init_machine_ids() target/riscv: handle mvendorid/marchid/mimpid for KVM CPUs
linux-headers: Update to v6.4-rc1
target/riscv/kvm.c: init 'misa_ext_mask' with scratch CPU target/riscv/cpu: add misa_ext_info_arr[]
target/riscv: add KVM specific MISA properties target/riscv/kvm.c: update KVM MISA bits target/riscv/kvm.c: add multi-letter extension KVM properties target/riscv/cpu.c: add satp_mode properties earlier target/riscv/cpu.c: remove priv_ver check from riscv_isa_string_ext() target/riscv/cpu.c: create KVM mock properties target/riscv: update multi-letter extension KVM properties target/riscv/kvm.c: add kvmconfig_get_cfg_addr() helper target/riscv/kvm.c: read/write (cbom|cboz)_blocksize in KVM
hw/riscv/virt.c | 14 +- include/standard-headers/linux/const.h | 2 +- include/standard-headers/linux/virtio_blk.h | 18 +- .../standard-headers/linux/virtio_config.h | 6 + include/standard-headers/linux/virtio_net.h | 1 + linux-headers/asm-arm64/kvm.h | 33 ++ linux-headers/asm-riscv/kvm.h | 53 +- linux-headers/asm-riscv/unistd.h | 9 + linux-headers/asm-s390/unistd_32.h | 1 + linux-headers/asm-s390/unistd_64.h | 1 + linux-headers/asm-x86/kvm.h | 3 + linux-headers/linux/const.h | 2 +- linux-headers/linux/kvm.h | 12 +- linux-headers/linux/psp-sev.h | 7 + linux-headers/linux/userfaultfd.h | 17 +- target/riscv/cpu.c | 341 ++++++++++-- target/riscv/cpu.h | 7 +- target/riscv/kvm.c | 499 +++++++++++++++++- target/riscv/kvm_riscv.h | 1 + 19 files changed, 940 insertions(+), 87 deletions(-)
Signature · 1 line
2.41.0
PATCH v8 1/20 target/riscv: skip features setup for KVM CPUs
As it is today it's not possible to use '-cpu host' if the RISC-V host has RVH enabled. This is the resulting error:
$ ./qemu/build/qemu-system-riscv64 \
-machine virt,accel=kvm -m 2G -smp 1 \
-nographic -snapshot -kernel ./guest_imgs/Image \
-initrd ./guest_imgs/rootfs_kvm_riscv64.img \
-append "earlycon=sbi root=/dev/ram rw" \
-cpu host
qemu-system-riscv64: H extension requires priv spec 1.12.0This happens because we're checking for priv spec for all CPUs, and since we're not setting env->priv_ver for the 'host' CPU, it's being default to zero (i.e. PRIV_SPEC_1_10_0).
In reality env->priv_ver does not make sense when running with the KVM 'host' CPU. It's used to gate certain CSRs/extensions during translation to make them unavailable if the hart declares an older spec version. It doesn't have any other use. E.g. OpenSBI version 1.2 retrieves the spec checking if the CSR_MCOUNTEREN, CSR_MCOUNTINHIBIT and CSR_MENVCFG CSRs are available [1].
'priv_ver' is just one example. We're doing a lot of feature validation and setup during riscv_cpu_realize() that it doesn't apply to KVM CPUs. Validating the feature set for those CPUs is a KVM problem that should be handled in KVM specific code.
The new riscv_cpu_realize_tcg() helper contains all validation logic that are applicable to TCG CPUs only. riscv_cpu_realize() verifies if we're running TCG and, if it's the case, proceed with the usual TCG realize() logic.
[1] lib/sbi/sbi_hart.c, hart_detect_features()
--- target/riscv/cpu.c | 35 +++++++++++++++++++++++++---------- 1 file changed, 25 insertions(+), 10 deletions(-)
target/riscv/cpu.c +25 -10
@@ -34,6 +34,7 @@#include "migration/vmstate.h" #include "fpu/softfloat-helpers.h" #include "sysemu/kvm.h" +#include "sysemu/tcg.h" #include "kvm_riscv.h" #include "tcg/tcg.h"
@@ -1386,20 +1387,12 @@ static void riscv_cpu_validate_misa_priv(CPURISCVState *env, Error **errp) } } -static void riscv_cpu_realize (DeviceState *dev,Error **errp) +static void riscv_cpu_realize_tcg (DeviceState *dev,Error **errp) { -CPUState *cs =CPU (dev);RISCVCPU *cpu =RISCV_CPU (dev);CPURISCVState *env = &cpu->env; -RISCVCPUClass *mcc =RISCV_CPU_GET_CLASS (dev);Error *local_err =NULL ; -cpu_exec_realizefn (cs, &local_err); -if (local_err !=NULL ) { -error_propagate (errp, local_err); -return ; - } -riscv_cpu_validate_misa_mxl (cpu, &local_err);if (local_err !=NULL ) {error_propagate (errp, local_err);
@@ -1434,7 +1427,7 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp) }#ifndef CONFIG_USER_ONLY - cs->tcg_cflags |=CF_PCREL ; +CPU (dev)->tcg_cflags |=CF_PCREL ;if (cpu->cfg.ext_sstc) {riscv_timer_init (cpu);
@@ -1447,6 +1440,28 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp) } }#endif +} + +static void riscv_cpu_realize (DeviceState *dev,Error **errp) +{ +CPUState *cs =CPU (dev); +RISCVCPU *cpu =RISCV_CPU (dev); +RISCVCPUClass *mcc =RISCV_CPU_GET_CLASS (dev); +Error *local_err =NULL ; + +cpu_exec_realizefn (cs, &local_err); +if (local_err !=NULL ) { +error_propagate (errp, local_err); +return ; + } + +if (tcg_enabled ()) { +riscv_cpu_realize_tcg (dev, &local_err); +if (local_err !=NULL ) { +error_propagate (errp, local_err); +return ; + } + }riscv_cpu_finalize_features (cpu, &local_err);if (local_err !=NULL ) {
Signature · 1 line
2.41.0
PATCH v8 2/20 hw/riscv/virt.c: skip 'mmu-type' FDT if satp mode not set
In reply to Daniel Henrique BarbozaThe absence of a satp mode in riscv_host_cpu_init() is causing the following error:
$ ./qemu/build/qemu-system-riscv64 -machine virt,accel=kvm \
-m 2G -smp 1 -nographic -snapshot \
-kernel ./guest_imgs/Image \
-initrd ./guest_imgs/rootfs_kvm_riscv64.img \
-append "earlycon=sbi root=/dev/ram rw" \
-cpu host
**
ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be
reached
Bail out! ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should
not be reached
AbortedThe error is triggered from create_fdt_socket_cpus() in hw/riscv/virt.c. It's trying to get satp_mode_str for a NULL cpu->cfg.satp_mode.map.
For this KVM cpu we would need to inherit the satp supported modes from the RISC-V host. At this moment this is not possible because the KVM driver does not support it. And even when it does we can't just let this broken for every other older kernel.
Since mmu-type is not a required node, according to [1], skip the 'mmu-type' FDT node if there's no satp_mode set. We'll revisit this logic when we can get satp information from KVM.
[1] https://github.com/devicetree-org/dt-schema/blob/main/dtschema/schemas/cpu.yaml
--- hw/riscv/virt.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
hw/riscv/virt.c +7 -7
@@ -244,13 +244,13 @@ static void create_fdt_socket_cpus(RISCVVirtState *s, int socket, s->soc[socket].hartid_base + cpu);qemu_fdt_add_subnode (ms->fdt, cpu_name); - satp_mode_max =satp_mode_max_from_map ( - s->soc[socket].harts[cpu].cfg.satp_mode.map); - sv_name =g_strdup_printf ("riscv,%s" , -satp_mode_str (satp_mode_max, is_32_bit)); -qemu_fdt_setprop_string (ms->fdt, cpu_name,"mmu-type" , sv_name); -g_free (sv_name); - +if (cpu_ptr->cfg.satp_mode.supported !=0 ) { + satp_mode_max =satp_mode_max_from_map (cpu_ptr->cfg.satp_mode.map); + sv_name =g_strdup_printf ("riscv,%s" , +satp_mode_str (satp_mode_max, is_32_bit)); +qemu_fdt_setprop_string (ms->fdt, cpu_name,"mmu-type" , sv_name); +g_free (sv_name); + } name =riscv_isa_string (cpu_ptr);qemu_fdt_setprop_string (ms->fdt, cpu_name,"riscv,isa" , name);
Signature · 1 line
2.41.0
Re: [PATCH v8 02/20] hw/riscv/virt.c: skip 'mmu-type' FDT if satp mode not set
Quoted 24 lines · Daniel Henrique Barboza
The absence of a satp mode in
riscv_host_cpu_init()is causing the following error:$ ./qemu/build/qemu-system-riscv64 -machine virt,accel=kvm \ -m 2G -smp 1 -nographic -snapshot \ -kernel ./guest_imgs/Image \ -initrd ./guest_imgs/rootfs_kvm_riscv64.img \ -append "earlycon=sbi root=/dev/ram rw" \ -cpu host ** ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached Bail out! ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached AbortedThe error is triggered from
create_fdt_socket_cpus()inhw/riscv/virt.c. It's trying to getsatp_mode_strfor a NULLcpu->cfg.satp_mode.map.For this KVM cpu we would need to inherit the satp supported modes from the RISC-V host. At this moment this is not possible because the KVM driver does not support it. And even when it does we can't just let this broken for every other older kernel.
Quoted 5 lines
Since mmu-type is not a required node, according to [1], skip the 'mmu-type' FDT node if there's no
satp_modeset. We'll revisit this logic when we can get satp information from KVM.[1] https://github.com/devicetree-org/dt-schema/blob/main/dtschema/schemas/cpu.yaml
I don't think this is the correct link to reference as backup, as the generic binding sets out no requirements. I think you would want to link to the RISC-V specific cpus binding.
That said, things like FreeBSD and U-Boot appear to require mmu-type
https://lore.kernel.org/all/20230705-fondue-bagginess-66c25f1a4135@spud/
so I am wondering if we should in fact make the mmu-type a required property in the RISC-V specific binding.
Since nommu is covered by an mmu type of "riscv,none", I am kinda struggling to think of a case where it should be left out (while describing real hardware at least).
Cheers,
Conor.
Re: [PATCH v8 02/20] hw/riscv/virt.c: skip 'mmu-type' FDT if satp mode not set
Quoted 29 lines · Conor Dooley
Quoted 28 lines · Daniel Henrique Barboza
The absence of a satp mode in
riscv_host_cpu_init()is causing the following error:$ ./qemu/build/qemu-system-riscv64 -machine virt,accel=kvm \ -m 2G -smp 1 -nographic -snapshot \ -kernel ./guest_imgs/Image \ -initrd ./guest_imgs/rootfs_kvm_riscv64.img \ -append "earlycon=sbi root=/dev/ram rw" \ -cpu host ** ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached Bail out! ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached AbortedThe error is triggered from
create_fdt_socket_cpus()inhw/riscv/virt.c. It's trying to getsatp_mode_strfor a NULLcpu->cfg.satp_mode.map.For this KVM cpu we would need to inherit the satp supported modes from the RISC-V host. At this moment this is not possible because the KVM driver does not support it. And even when it does we can't just let this broken for every other older kernel.
Since mmu-type is not a required node, according to [1], skip the 'mmu-type' FDT node if there's no
satp_modeset. We'll revisit this logic when we can get satp information from KVM.
Quoted 5 lines
I don't think this is the correct link to reference as backup, as the generic binding sets out no requirements. I think you would want to link to the RISC-V specific cpus binding.
You mean this link?
https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/riscv/cpus.yaml
Quoted 5 lines
That said, things like FreeBSD and U-Boot appear to require mmu-type
https://lore.kernel.org/all/20230705-fondue-bagginess-66c25f1a4135@spud/
so I am wondering if we should in fact make the mmu-type a required property in the RISC-V specific binding.
To make it required, as far as QEMU is concerned, we'll need to assume a default value for the 'host' CPU type (e.g. sv57). In the future we can read the satp host value directly when/if KVM provides satp_mode via get_one_reg().
Thanks,
Daniel
Quoted 7 lines
Since nommu is covered by an mmu type of "riscv,none", I am kinda struggling to think of a case where it should be left out (while describing real hardware at least).
Cheers,
Conor.
Re: [PATCH v8 02/20] hw/riscv/virt.c: skip 'mmu-type' FDT if satp mode not set
Quoted 34 lines · Daniel Henrique Barboza
Quoted 31 lines · Conor Dooley
Quoted 29 lines · Daniel Henrique Barboza
The absence of a satp mode in
riscv_host_cpu_init()is causing the following error:$ ./qemu/build/qemu-system-riscv64 -machine virt,accel=kvm \ -m 2G -smp 1 -nographic -snapshot \ -kernel ./guest_imgs/Image \ -initrd ./guest_imgs/rootfs_kvm_riscv64.img \ -append "earlycon=sbi root=/dev/ram rw" \ -cpu host ** ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached Bail out! ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached AbortedThe error is triggered from
create_fdt_socket_cpus()inhw/riscv/virt.c. It's trying to getsatp_mode_strfor a NULLcpu->cfg.satp_mode.map.For this KVM cpu we would need to inherit the satp supported modes from the RISC-V host. At this moment this is not possible because the KVM driver does not support it. And even when it does we can't just let this broken for every other older kernel.
Since mmu-type is not a required node, according to [1], skip the 'mmu-type' FDT node if there's no
satp_modeset. We'll revisit this logic when we can get satp information from KVM.[1] https://github.com/devicetree-org/dt-schema/blob/main/dtschema/schemas/cpu.yaml
Quoted 7 lines
Quoted 3 lines
I don't think this is the correct link to reference as backup, as the generic binding sets out no requirements. I think you would want to link to the RISC-V specific cpus binding.
You mean this link?
https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/riscv/cpus.yaml
Yeah, that's the correct file. Should probably have linked it, sorry about that. And in case it was not clear, not suggesting that this would require a resend, since the reasoning is correct.
Quoted 9 lines
Quoted 4 lines
That said, things like FreeBSD and U-Boot appear to require mmu-type
https://lore.kernel.org/all/20230705-fondue-bagginess-66c25f1a4135@spud/
so I am wondering if we should in fact make the mmu-type a required property in the RISC-V specific binding.To make it required, as far as QEMU is concerned, we'll need to assume a default value for the 'host' CPU type (e.g. sv57). In the future we can read the satp host value directly when/if KVM provides
satp_modeviaget_one_reg().
I dunno if assuming is the right thing to do, since it could be actively wrong. Leaving it out, as you are doing here, is, IMO, nicer to those guests. Once there's an API for it, I think it could then be added and then the additional guests would be supported.
Thanks,
Conor.
Re: [PATCH v8 02/20] hw/riscv/virt.c: skip 'mmu-type' FDT if satp mode not set
Quoted 39 lines · Conor Dooley
Quoted 38 lines · Daniel Henrique Barboza
Quoted 34 lines · Conor Dooley
Quoted 24 lines · Daniel Henrique Barboza
The absence of a satp mode in
riscv_host_cpu_init()is causing the following error:$ ./qemu/build/qemu-system-riscv64 -machine virt,accel=kvm \ -m 2G -smp 1 -nographic -snapshot \ -kernel ./guest_imgs/Image \ -initrd ./guest_imgs/rootfs_kvm_riscv64.img \ -append "earlycon=sbi root=/dev/ram rw" \ -cpu host ** ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached Bail out! ERROR:../target/riscv/cpu.c:320:satp_mode_str: code should not be reached AbortedThe error is triggered from
create_fdt_socket_cpus()inhw/riscv/virt.c. It's trying to getsatp_mode_strfor a NULLcpu->cfg.satp_mode.map.For this KVM cpu we would need to inherit the satp supported modes from the RISC-V host. At this moment this is not possible because the KVM driver does not support it. And even when it does we can't just let this broken for every other older kernel.
Quoted 5 lines
Since mmu-type is not a required node, according to [1], skip the 'mmu-type' FDT node if there's no
satp_modeset. We'll revisit this logic when we can get satp information from KVM.[1] https://github.com/devicetree-org/dt-schema/blob/main/dtschema/schemas/cpu.yaml
I don't think this is the correct link to reference as backup, as the generic binding sets out no requirements. I think you would want to link to the RISC-V specific cpus binding.
Quoted 7 lines
Quoted 3 lines
You mean this link?
https://github.com/torvalds/linux/blob/master/Documentation/devicetree/bindings/riscv/cpus.yaml
Yeah, that's the correct file. Should probably have linked it, sorry about that. And in case it was not clear, not suggesting that this would require a resend, since the reasoning is correct.
I don't mind amending this in case we need another version for any other reason. Otherwise we'll hope that Alistair will be a true, real gentlemann and amend the commit msg for us :D
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
That said, things like FreeBSD and U-Boot appear to require mmu-type
https://lore.kernel.org/all/20230705-fondue-bagginess-66c25f1a4135@spud/
so I am wondering if we should in fact make the mmu-type a required property in the RISC-V specific binding.
Quoted 8 lines
Quoted 3 lines
To make it required, as far as QEMU is concerned, we'll need to assume a default value for the 'host' CPU type (e.g. sv57). In the future we can read the satp host value directly when/if KVM provides
satp_modeviaget_one_reg().I dunno if assuming is the right thing to do, since it could be actively wrong. Leaving it out, as you are doing here, is, IMO, nicer to those guests. Once there's an API for it, I think it could then be added and then the additional guests would be supported.
Makes sense. We'll revisit this piece of code when that API I sent today find its way upstream. Thanks,
Daniel
Quoted 3 lines
Thanks,
Conor.
PATCH v8 3/20 target/riscv/cpu.c: restrict 'mvendorid' value
In reply to Daniel Henrique BarbozaWe're going to change the handling of mvendorid/marchid/mimpid by the KVM driver. Since these are always present in all CPUs let's put the same validation for everyone.
It doesn't make sense to allow 'mvendorid' to be different than it is already set in named (vendor) CPUs. Generic (dynamic) CPUs can have any 'mvendorid' they want.
Change 'mvendorid' to be a class property created via 'object_class_property_add', instead of using the DEFINE_PROP_UINT32() macro. This allow us to define a custom setter for it that will verify, for named CPUs, if mvendorid is different than it is already set by the CPU. This is the error thrown for the 'veyron-v1' CPU if 'mvendorid' is set to an invalid value:
$ qemu-system-riscv64 -M virt -nographic -cpu veyron-v1,mvendorid=2
qemu-system-riscv64: can't apply global veyron-v1-riscv-cpu.mvendorid=2:
Unable to change veyron-v1-riscv-cpu mvendorid (0x61f)--- target/riscv/cpu.c | 38 +++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-)
target/riscv/cpu.c +37 -1
@@ -1812,7 +1812,6 @@ static void riscv_cpu_add_user_properties(Object *obj)static Property riscv_cpu_properties[] = {DEFINE_PROP_BOOL ("debug" ,RISCVCPU , cfg.debug, true), -DEFINE_PROP_UINT32 ("mvendorid" ,RISCVCPU , cfg.mvendorid,0 ),DEFINE_PROP_UINT64 ("marchid" ,RISCVCPU , cfg.marchid,RISCV_CPU_MARCHID ),DEFINE_PROP_UINT64 ("mimpid" ,RISCVCPU , cfg.mimpid,RISCV_CPU_MIMPID ),
@@ -1899,6 +1898,40 @@ static const struct TCGCPUOps riscv_tcg_ops = {#endif /* !CONFIG_USER_ONLY */ }; +static bool riscv_cpu_is_dynamic (Object *cpu_obj) +{ +return object_dynamic_cast (cpu_obj,TYPE_RISCV_DYNAMIC_CPU ) !=NULL ; +} + +static void cpu_set_mvendorid (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +bool dynamic_cpu =riscv_cpu_is_dynamic (obj); +RISCVCPU *cpu =RISCV_CPU (obj); +uint32_t prev_val = cpu->cfg.mvendorid; +uint32_t value; + +if (!visit_type_uint32 (v, name, &value, errp)) { +return ; + } + +if (!dynamic_cpu && prev_val != value) { +error_setg (errp,"Unable to change %s mvendorid (0x%x)" , +object_get_typename (obj), prev_val); +return ; + } + + cpu->cfg.mvendorid = value; +} + +static void cpu_get_mvendorid (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +bool value =RISCV_CPU (obj)->cfg.mvendorid; + +visit_type_bool (v, name, &value, errp); +} +static void riscv_cpu_class_init (ObjectClass *c,void *data) {RISCVCPUClass *mcc =RISCV_CPU_CLASS (c);
@@ -1930,6 +1963,9 @@ static void riscv_cpu_class_init(ObjectClass *c, void *data) cc->gdb_get_dynamic_xml = riscv_gdb_get_dynamic_xml; cc->tcg_ops = &riscv_tcg_ops; +object_class_property_add (c,"mvendorid" ,"uint32" , cpu_get_mvendorid, + cpu_set_mvendorid,NULL ,NULL ); +device_class_set_props (dc, riscv_cpu_properties); }
Signature · 1 line
2.41.0
PATCH v8 4/20 target/riscv/cpu.c: restrict 'mimpid' value
In reply to Daniel Henrique BarbozaFollowing the same logic used with 'mvendorid' let's also restrict 'mimpid' for named CPUs. Generic CPUs keep setting the value freely.
Note that we're getting rid of the default RISCV_CPU_MARCHID value. The reason is that this is not a good default since it's dynamic, changing with with every QEMU version, regardless of whether the actual implementation of the CPU changed from one QEMU version to the other. Named CPU should set it to a meaningful value instead and generic CPUs can set whatever they want.
This is the error thrown for an invalid 'mimpid' value for the veyron-v1 CPU:
$ ./qemu-system-riscv64 -M virt -nographic -cpu veyron-v1,mimpid=2
qemu-system-riscv64: can't apply global veyron-v1-riscv-cpu.mimpid=2:
Unable to change veyron-v1-riscv-cpu mimpid (0x111)--- target/riscv/cpu.c | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-)
target/riscv/cpu.c +32 -2
@@ -43,7 +43,6 @@#define RISCV_CPU_MARCHID ((QEMU_VERSION_MAJOR << 16) | \ (QEMU_VERSION_MINOR << 8) | \ (QEMU_VERSION_MICRO)) -#define RISCV_CPU_MIMPID RISCV_CPU_MARCHIDstatic const char riscv_single_letter_exts[] ="IEMAFDQCPVH" ;
@@ -1813,7 +1812,6 @@ static Property riscv_cpu_properties[] = {DEFINE_PROP_BOOL ("debug" ,RISCVCPU , cfg.debug, true),DEFINE_PROP_UINT64 ("marchid" ,RISCVCPU , cfg.marchid,RISCV_CPU_MARCHID ), -DEFINE_PROP_UINT64 ("mimpid" ,RISCVCPU , cfg.mimpid,RISCV_CPU_MIMPID ), #ifndef CONFIG_USER_ONLY DEFINE_PROP_UINT64("resetvec", RISCVCPU, env.resetvec, DEFAULT_RSTVEC),
@@ -1932,6 +1930,35 @@ static void cpu_get_mvendorid(Object *obj, Visitor *v, const char *name,visit_type_bool (v, name, &value, errp); } +static void cpu_set_mimpid (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +bool dynamic_cpu =riscv_cpu_is_dynamic (obj); +RISCVCPU *cpu =RISCV_CPU (obj); +uint64_t prev_val = cpu->cfg.mimpid; +uint64_t value; + +if (!visit_type_uint64 (v, name, &value, errp)) { +return ; + } + +if (!dynamic_cpu && prev_val != value) { +error_setg (errp,"Unable to change %s mimpid (0x%" PRIu64")" , +object_get_typename (obj), prev_val); +return ; + } + + cpu->cfg.mimpid = value; +} + +static void cpu_get_mimpid (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +bool value =RISCV_CPU (obj)->cfg.mimpid; + +visit_type_bool (v, name, &value, errp); +} +static void riscv_cpu_class_init (ObjectClass *c,void *data) {RISCVCPUClass *mcc =RISCV_CPU_CLASS (c);
@@ -1966,6 +1993,9 @@ static void riscv_cpu_class_init(ObjectClass *c, void *data)object_class_property_add (c,"mvendorid" ,"uint32" , cpu_get_mvendorid, cpu_set_mvendorid,NULL ,NULL ); +object_class_property_add (c,"mimpid" ,"uint64" , cpu_get_mimpid, + cpu_set_mimpid,NULL ,NULL ); +device_class_set_props (dc, riscv_cpu_properties); }
Signature · 1 line
2.41.0
PATCH v8 5/20 target/riscv/cpu.c: restrict 'marchid' value
In reply to Daniel Henrique Barboza'marchid' shouldn't be set to a different value as previously set for named CPUs.
For all other CPUs it shouldn't be freely set either - the spec requires that 'marchid' can't have the MSB (most significant bit) set and every other bit set to zero, i.e. 0x80000000 is an invalid 'marchid' value for 32 bit CPUs.
As with 'mimpid', setting a default value based on the current QEMU version is not a good idea because it implies that the CPU implementation changes from one QEMU version to the other. Named CPUs should set 'marchid' to a meaningful value instead, and generic CPUs can set to any valid value.
For the 'veyron-v1' CPU this is the error thrown if 'marchid' is set to a different val:
$ ./build/qemu-system-riscv64 -M virt -nographic -cpu veyron-v1,marchid=0x80000000
qemu-system-riscv64: can't apply global veyron-v1-riscv-cpu.marchid=0x80000000:
Unable to change veyron-v1-riscv-cpu marchid (0x8000000000010000)And, for generics CPUs, this is the error when trying to set to an invalid val:
$ ./build/qemu-system-riscv64 -M virt -nographic -cpu rv64,marchid=0x8000000000000000
qemu-system-riscv64: can't apply global rv64-riscv-cpu.marchid=0x8000000000000000:
Unable to set marchid with MSB (64) bit set and the remaining bits zero--- target/riscv/cpu.c | 60 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 53 insertions(+), 7 deletions(-)
target/riscv/cpu.c +53 -7
@@ -39,11 +39,6 @@#include "tcg/tcg.h" /* RISC-V CPU definitions */ - -#define RISCV_CPU_MARCHID ((QEMU_VERSION_MAJOR << 16) | \ - (QEMU_VERSION_MINOR << 8) | \ - (QEMU_VERSION_MICRO)) -static const char riscv_single_letter_exts[] ="IEMAFDQCPVH" ;struct isa_ext_data {
@@ -1811,8 +1806,6 @@ static void riscv_cpu_add_user_properties(Object *obj)static Property riscv_cpu_properties[] = {DEFINE_PROP_BOOL ("debug" ,RISCVCPU , cfg.debug, true), -DEFINE_PROP_UINT64 ("marchid" ,RISCVCPU , cfg.marchid,RISCV_CPU_MARCHID ), - #ifndef CONFIG_USER_ONLYDEFINE_PROP_UINT64 ("resetvec" ,RISCVCPU , env.resetvec,DEFAULT_RSTVEC ), #endif
@@ -1959,6 +1952,56 @@ static void cpu_get_mimpid(Object *obj, Visitor *v, const char *name,visit_type_bool (v, name, &value, errp); } +static void cpu_set_marchid (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +bool dynamic_cpu =riscv_cpu_is_dynamic (obj); +RISCVCPU *cpu =RISCV_CPU (obj); +uint64_t prev_val = cpu->cfg.marchid; +uint64_t value, invalid_val; +uint32_t mxlen =0 ; + +if (!visit_type_uint64 (v, name, &value, errp)) { +return ; + } + +if (!dynamic_cpu && prev_val != value) { +error_setg (errp,"Unable to change %s marchid (0x%" PRIu64")" , +object_get_typename (obj), prev_val); +return ; + } + +switch (riscv_cpu_mxl (&cpu->env)) { +case MXL_RV32 : + mxlen =32 ; +break ; +case MXL_RV64 : +case MXL_RV128 : + mxlen =64 ; +break ; +default : +g_assert_not_reached (); + } + + invalid_val =1LL << (mxlen -1 ); + +if (value == invalid_val) { +error_setg (errp,"Unable to set marchid with MSB (%u) bit set " +"and the remaining bits zero" , mxlen); +return ; + } + + cpu->cfg.marchid = value; +} + +static void cpu_get_marchid (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +bool value =RISCV_CPU (obj)->cfg.marchid; + +visit_type_bool (v, name, &value, errp); +} +static void riscv_cpu_class_init (ObjectClass *c,void *data) {RISCVCPUClass *mcc =RISCV_CPU_CLASS (c);
@@ -1996,6 +2039,9 @@ static void riscv_cpu_class_init(ObjectClass *c, void *data)object_class_property_add (c,"mimpid" ,"uint64" , cpu_get_mimpid, cpu_set_mimpid,NULL ,NULL ); +object_class_property_add (c,"marchid" ,"uint64" , cpu_get_marchid, + cpu_set_marchid,NULL ,NULL ); +device_class_set_props (dc, riscv_cpu_properties); }
Signature · 1 line
2.41.0
PATCH v8 6/20 target/riscv: use KVM scratch CPUs to init KVM properties
In reply to Daniel Henrique BarbozaCertain validations, such as the validations done for the machine IDs (mvendorid/marchid/mimpid), are done before starting the CPU. Non-dynamic (named) CPUs tries to match user input with a preset default. As it is today we can't prefetch a KVM default for these cases because we're only able to read/write KVM regs after the vcpu is spinning.
Our target/arm friends use a concept called "scratch CPU", which consists of creating a vcpu for doing queries and validations and so on, which is discarded shortly after use [1]. This is a suitable solution for what we need so let's implement it in target/riscv as well.
kvm_riscv_init_machine_ids() will be used to do any pre-launch setup for KVM CPUs, via riscv_cpu_add_user_properties(). The function will create a KVM scratch CPU, fetch KVM regs that work as default values for user properties, and then discard the scratch CPU afterwards.
We're starting by initializing 'mvendorid'. This concept will be used to init other KVM specific properties in the next patches as well.
[1] target/arm/kvm.c, kvm_arm_create_scratch_host_vcpu()
--- target/riscv/cpu.c | 6 +++ target/riscv/kvm.c | 85 ++++++++++++++++++++++++++++++++++++++++ target/riscv/kvm_riscv.h | 1 + 3 files changed, 92 insertions(+)
target/riscv/cpu.c +6 -0
@@ -1792,6 +1792,12 @@ static void riscv_cpu_add_user_properties(Object *obj)Property *prop;DeviceState *dev =DEVICE (obj); +#ifndef CONFIG_USER_ONLY +if (kvm_enabled ()) { +kvm_riscv_init_user_properties (obj); + } +#endif +riscv_cpu_add_misa_properties (obj);for (prop = riscv_cpu_extensions; prop && prop->name; prop++) {
target/riscv/kvm.c +85 -0
91 lines not on this page · raw message
target/riscv/kvm_riscv.h +1 -0
@@ -19,6 +19,7 @@#ifndef QEMU_KVM_RISCV_H #define QEMU_KVM_RISCV_H +void kvm_riscv_init_user_properties (Object *cpu_obj);void kvm_riscv_reset_vcpu (RISCVCPU *cpu);void kvm_riscv_set_irq (RISCVCPU *cpu,int irq,int level);
Signature · 1 line
2.41.0
PATCH v8 7/20 target/riscv: read marchid/mimpid in kvm_riscv_init_machine_ids()
In reply to Daniel Henrique BarbozaAllow 'marchid' and 'mimpid' to also be initialized in kvm_riscv_init_machine_ids().
After this change, the handling of mvendorid/marchid/mimpid for the 'host' CPU type will be equal to what we already have for TCG named CPUs, i.e. the user is not able to set these values to a different val than the one that is already preset.
--- target/riscv/kvm.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
target/riscv/kvm.c +16 -0
@@ -378,6 +378,22 @@ static void kvm_riscv_init_machine_ids(RISCVCPU *cpu, KVMScratchCPU *kvmcpu)if (ret !=0 ) {error_report ("Unable to retrieve mvendorid from host, error %d" , ret); } + + reg.id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , +KVM_REG_RISCV_CONFIG_REG (marchid)); + reg.addr = (uint64_t )&cpu->cfg.marchid; + ret =ioctl (kvmcpu->cpufd,KVM_GET_ONE_REG , ®); +if (ret !=0 ) { +error_report ("Unable to retrieve marchid from host, error %d" , ret); + } + + reg.id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , +KVM_REG_RISCV_CONFIG_REG (mimpid)); + reg.addr = (uint64_t )&cpu->cfg.mimpid; + ret =ioctl (kvmcpu->cpufd,KVM_GET_ONE_REG , ®); +if (ret !=0 ) { +error_report ("Unable to retrieve mimpid from host, error %d" , ret); + } }void kvm_riscv_init_user_properties (Object *cpu_obj)
Signature · 1 line
2.41.0
PATCH v8 8/20 target/riscv: handle mvendorid/marchid/mimpid for KVM CPUs
In reply to Daniel Henrique BarbozaAfter changing user validation for mvendorid/marchid/mimpid to guarantee that the value is validated on user input time, coupled with the work in fetching KVM default values for them by using a scratch CPU, we're certain that the values in cpu->cfg.(mvendorid|marchid|mimpid) are already good to be written back to KVM.
There's no need to write the values back for 'host' type CPUs since the values can't be changed, so let's do that just for generic CPUs.
--- target/riscv/kvm.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
target/riscv/kvm.c +31 -0
@@ -495,6 +495,33 @@ void kvm_arch_init_irq_routing(KVMState *s) { } +static int kvm_vcpu_set_machine_ids (RISCVCPU *cpu,CPUState *cs) +{ +CPURISCVState *env = &cpu->env; +uint64_t id; +int ret; + + id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , +KVM_REG_RISCV_CONFIG_REG (mvendorid)); + ret =kvm_set_one_reg (cs, id, &cpu->cfg.mvendorid); +if (ret !=0 ) { +return ret; + } + + id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , +KVM_REG_RISCV_CONFIG_REG (marchid)); + ret =kvm_set_one_reg (cs, id, &cpu->cfg.marchid); +if (ret !=0 ) { +return ret; + } + + id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , +KVM_REG_RISCV_CONFIG_REG (mimpid)); + ret =kvm_set_one_reg (cs, id, &cpu->cfg.mimpid); + +return ret; +} +int kvm_arch_init_vcpu (CPUState *cs) {int ret =0 ;
@@ -513,6 +540,10 @@ int kvm_arch_init_vcpu(CPUState *cs) } env->misa_ext = isa; +if (!object_dynamic_cast (OBJECT (cpu),TYPE_RISCV_CPU_HOST )) { + ret =kvm_vcpu_set_machine_ids (cpu, cs); + } +return ret; }
Signature · 1 line
2.41.0
PATCH v8 9/20 linux-headers: Update to v6.4-rc1
In reply to Daniel Henrique BarbozaUpdate to commit ac9a78681b92 ("Linux 6.4-rc1").
--- include/standard-headers/linux/const.h | 2 +- include/standard-headers/linux/virtio_blk.h | 18 +++---- .../standard-headers/linux/virtio_config.h | 6 +++ include/standard-headers/linux/virtio_net.h | 1 + linux-headers/asm-arm64/kvm.h | 33 ++++++++++++ linux-headers/asm-riscv/kvm.h | 53 ++++++++++++++++++- linux-headers/asm-riscv/unistd.h | 9 ++++ linux-headers/asm-s390/unistd_32.h | 1 + linux-headers/asm-s390/unistd_64.h | 1 + linux-headers/asm-x86/kvm.h | 3 ++ linux-headers/linux/const.h | 2 +- linux-headers/linux/kvm.h | 12 +++-- linux-headers/linux/psp-sev.h | 7 +++ linux-headers/linux/userfaultfd.h | 17 +++++- 14 files changed, 149 insertions(+), 16 deletions(-)
include/standard-headers/linux/const.h +1 -1
@@ -28,7 +28,7 @@#define _BITUL (x) (_UL(1) << (x))#define _BITULL (x) (_ULL(1) << (x)) -#define __ALIGN_KERNEL (x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) +#define __ALIGN_KERNEL (x, a) __ALIGN_KERNEL_MASK(x, (__typeof__(x))(a) - 1)#define __ALIGN_KERNEL_MASK (x, mask) (((x) + (mask)) & ~(mask))#define __KERNEL_DIV_ROUND_UP (n, d) (((n) + (d) - 1) / (d))
include/standard-headers/linux/virtio_blk.h +9 -9
@@ -138,11 +138,11 @@ struct virtio_blk_config {/* Zoned block device characteristics (if VIRTIO_BLK_F_ZONED) */ struct virtio_blk_zoned_characteristics { -uint32_t zone_sectors; -uint32_t max_open_zones; -uint32_t max_active_zones; -uint32_t max_append_sectors; -uint32_t write_granularity; +__virtio32 zone_sectors; +__virtio32 max_open_zones; +__virtio32 max_active_zones; +__virtio32 max_append_sectors; +__virtio32 write_granularity;uint8_t model;uint8_t unused2[3 ]; } zoned;
@@ -239,11 +239,11 @@ struct virtio_blk_outhdr {*/ struct virtio_blk_zone_descriptor {/* Zone capacity */ -uint64_t z_cap; +__virtio64 z_cap;/* The starting sector of the zone */ -uint64_t z_start; +__virtio64 z_start;/* Zone write pointer position in sectors */ -uint64_t z_wp; +__virtio64 z_wp;/* Zone type */ uint8_t z_type;/* Zone state */
@@ -252,7 +252,7 @@ struct virtio_blk_zone_descriptor { };struct virtio_blk_zone_report { -uint64_t nr_zones; +__virtio64 nr_zones;uint8_t reserved[56 ];struct virtio_blk_zone_descriptor zones[]; };
include/standard-headers/linux/virtio_config.h +6 -0
@@ -97,6 +97,12 @@*/ #define VIRTIO_F_SR_IOV 37 +/* +* This feature indicates that the driver passes extra data (besides +* identifying the virtqueue) in its device notifications. +*/ +#define VIRTIO_F_NOTIFICATION_DATA 38 +/* * This feature indicates that the driver can reset a queue individually. */
include/standard-headers/linux/virtio_net.h +1 -0
@@ -61,6 +61,7 @@#define VIRTIO_NET_F_GUEST_USO6 55/* Guest can handle USOv6 in. */ #define VIRTIO_NET_F_HOST_USO 56/* Host can handle USO in. */ #define VIRTIO_NET_F_HASH_REPORT 57/* Supports hash report */ +#define VIRTIO_NET_F_GUEST_HDRLEN 59/* Guest provides the exact hdr_len value. */ #define VIRTIO_NET_F_RSS 60/* Supports RSS RX steering */ #define VIRTIO_NET_F_RSC_EXT 61/* extended coalescing info */ #define VIRTIO_NET_F_STANDBY 62/* Act as standby for another device
linux-headers/asm-arm64/kvm.h +33 -0
@@ -198,6 +198,15 @@ struct kvm_arm_copy_mte_tags {__u64 reserved[2 ]; }; +/* +* Counter/Timer offset structure. Describe the virtual/physical offset. +* To be used with KVM_ARM_SET_COUNTER_OFFSET. +*/ +struct kvm_arm_counter_offset { +__u64 counter_offset; +__u64 reserved; +}; +#define KVM_ARM_TAGS_TO_GUEST 0#define KVM_ARM_TAGS_FROM_GUEST 1
@@ -363,6 +372,10 @@ enum { KVM_REG_ARM_VENDOR_HYP_BIT_PTP = 1, }; +/* Device Control API on vm fd */ +#define KVM_ARM_VM_SMCCC_CTRL 0 +#define KVM_ARM_VM_SMCCC_FILTER 0 +/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0#define KVM_DEV_ARM_VGIC_GRP_DIST_REGS 1
@@ -402,6 +415,8 @@ enum {#define KVM_ARM_VCPU_TIMER_CTRL 1#define KVM_ARM_VCPU_TIMER_IRQ_VTIMER 0#define KVM_ARM_VCPU_TIMER_IRQ_PTIMER 1 +#define KVM_ARM_VCPU_TIMER_IRQ_HVTIMER 2 +#define KVM_ARM_VCPU_TIMER_IRQ_HPTIMER 3#define KVM_ARM_VCPU_PVTIME_CTRL 2#define KVM_ARM_VCPU_PVTIME_IPA 0
@@ -458,6 +473,24 @@ enum {/* run->fail_entry.hardware_entry_failure_reason codes. */ #define KVM_EXIT_FAIL_ENTRY_CPU_UNSUPPORTED (1ULL << 0) +enum kvm_smccc_filter_action { +KVM_SMCCC_FILTER_HANDLE =0 , +KVM_SMCCC_FILTER_DENY , +KVM_SMCCC_FILTER_FWD_TO_USER , + +}; + +struct kvm_smccc_filter { +__u32 base; +__u32 nr_functions; +__u8 action; +__u8 pad[15 ]; +}; + +/* arm64-specific KVM_EXIT_HYPERCALL flags */ +#define KVM_HYPERCALL_EXIT_SMC (1U << 0) +#define KVM_HYPERCALL_EXIT_16BIT (1U << 1) +#endif #endif /* __ARM_KVM_H__ */
linux-headers/asm-riscv/kvm.h +52 -1
106 lines not on this page · raw message
linux-headers/asm-riscv/unistd.h +9 -0
@@ -43,3 +43,12 @@#define __NR_riscv_flush_icache (__NR_arch_specific_syscall + 15)#endif __SYSCALL (__NR_riscv_flush_icache, sys_riscv_flush_icache) + +/* +* Allows userspace to query the kernel for CPU architecture and +* microarchitecture details across a given set of CPUs. + */ +#ifndef __NR_riscv_hwprobe +#define __NR_riscv_hwprobe (__NR_arch_specific_syscall + 14) +#endif +__SYSCALL (__NR_riscv_hwprobe, sys_riscv_hwprobe)
linux-headers/asm-s390/unistd_32.h +1 -0
@@ -419,6 +419,7 @@#define __NR_landlock_create_ruleset 444#define __NR_landlock_add_rule 445#define __NR_landlock_restrict_self 446 +#define __NR_memfd_secret 447#define __NR_process_mrelease 448#define __NR_futex_waitv 449#define __NR_set_mempolicy_home_node 450
linux-headers/asm-s390/unistd_64.h +1 -0
@@ -367,6 +367,7 @@#define __NR_landlock_create_ruleset 444#define __NR_landlock_add_rule 445#define __NR_landlock_restrict_self 446 +#define __NR_memfd_secret 447#define __NR_process_mrelease 448#define __NR_futex_waitv 449#define __NR_set_mempolicy_home_node 450
linux-headers/asm-x86/kvm.h +3 -0
@@ -557,4 +557,7 @@ struct kvm_pmu_event_filter {#define KVM_VCPU_TSC_CTRL 0/* control group for the timestamp counter (TSC) */ #define KVM_VCPU_TSC_OFFSET 0/* attribute for the TSC offset */ +/* x86-specific KVM_EXIT_HYPERCALL flags. */ +#define KVM_EXIT_HYPERCALL_LONG_MODE BIT(0) +#endif /* _ASM_X86_KVM_H */
linux-headers/linux/const.h +1 -1
@@ -28,7 +28,7 @@#define _BITUL (x) (_UL(1) << (x))#define _BITULL (x) (_ULL(1) << (x)) -#define __ALIGN_KERNEL (x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) +#define __ALIGN_KERNEL (x, a) __ALIGN_KERNEL_MASK(x, (__typeof__(x))(a) - 1)#define __ALIGN_KERNEL_MASK (x, mask) (((x) + (mask)) & ~(mask))#define __KERNEL_DIV_ROUND_UP (n, d) (((n) + (d) - 1) / (d))
linux-headers/linux/kvm.h +9 -3
@@ -341,8 +341,11 @@ struct kvm_run {__u64 nr;__u64 args[6 ];__u64 ret; -__u32 longmode; -__u32 pad; + +union { +__u32 longmode; +__u64 flags; + }; } hypercall;/* KVM_EXIT_TPR_ACCESS */ struct {
@@ -1182,6 +1185,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_S390_PROTECTED_ASYNC_DISABLE 224#define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 225#define KVM_CAP_PMU_EVENT_MASKED_EVENTS 226 +#define KVM_CAP_COUNTER_OFFSET 227#ifdef KVM_CAP_IRQ_ROUTING
@@ -1449,7 +1453,7 @@ struct kvm_vfio_spapr_tce {#define KVM_CREATE_VCPU _IO(KVMIO, 0x41)#define KVM_GET_DIRTY_LOG _IOW(KVMIO, 0x42, struct kvm_dirty_log)#define KVM_SET_NR_MMU_PAGES _IO(KVMIO, 0x44) -#define KVM_GET_NR_MMU_PAGES _IO(KVMIO, 0x45) +#define KVM_GET_NR_MMU_PAGES _IO(KVMIO, 0x45)/* deprecated */ #define KVM_SET_USER_MEMORY_REGION _IOW(KVMIO, 0x46, \ struct kvm_userspace_memory_region)#define KVM_SET_TSS_ADDR _IO(KVMIO, 0x47)
@@ -1541,6 +1545,8 @@ struct kvm_s390_ucas_mapping {#define KVM_SET_PMU_EVENT_FILTER _IOW(KVMIO, 0xb2, struct kvm_pmu_event_filter)#define KVM_PPC_SVM_OFF _IO(KVMIO, 0xb3)#define KVM_ARM_MTE_COPY_TAGS _IOR(KVMIO, 0xb4, struct kvm_arm_copy_mte_tags) +/* Available with KVM_CAP_COUNTER_OFFSET */ +#define KVM_ARM_SET_COUNTER_OFFSET _IOW(KVMIO, 0xb5, struct kvm_arm_counter_offset)/* ioctl for vm fd */ #define KVM_CREATE_DEVICE _IOWR(KVMIO, 0xe0, struct kvm_create_device)
linux-headers/linux/psp-sev.h +7 -0
@@ -36,6 +36,13 @@ enum {* SEV Firmware status code */ typedef enum { + /* + * This error code is not in the SEV spec. Its purpose is to convey that + * there was an error that prevented the SEV firmware from being called. + * The SEV API error codes are 16 bits, so the -1 value will not overlap + * with possible values from the specification. + */ + SEV_RET_NO_FW_CALL = -1, SEV_RET_SUCCESS = 0, SEV_RET_INVALID_PLATFORM_STATE, SEV_RET_INVALID_GUEST_STATE,
linux-headers/linux/userfaultfd.h +16 -1
@@ -38,7 +38,8 @@ UFFD_FEATURE_MINOR_HUGETLBFS | \ UFFD_FEATURE_MINOR_SHMEM | \ UFFD_FEATURE_EXACT_ADDRESS | \ - UFFD_FEATURE_WP_HUGETLBFS_SHMEM) + UFFD_FEATURE_WP_HUGETLBFS_SHMEM | \ + UFFD_FEATURE_WP_UNPOPULATED)#define UFFD_API_IOCTLS \ ((__u64)1 << _UFFDIO_REGISTER | \ (__u64)1 << _UFFDIO_UNREGISTER | \
@@ -203,6 +204,12 @@ struct uffdio_api {* * UFFD_FEATURE_WP_HUGETLBFS_SHMEM indicates that userfaultfd * write-protection mode is supported on both shmem and hugetlbfs. +* +* UFFD_FEATURE_WP_UNPOPULATED indicates that userfaultfd +* write-protection mode will always apply to unpopulated pages +* (i.e. empty ptes). This will be the default behavior for shmem +* & hugetlbfs, so this flag only affects anonymous memory behavior +* when userfault write-protection mode is registered. */ #define UFFD_FEATURE_PAGEFAULT_FLAG_WP (1<<0)#define UFFD_FEATURE_EVENT_FORK (1<<1)
@@ -217,6 +224,7 @@ struct uffdio_api {#define UFFD_FEATURE_MINOR_SHMEM (1<<10)#define UFFD_FEATURE_EXACT_ADDRESS (1<<11)#define UFFD_FEATURE_WP_HUGETLBFS_SHMEM (1<<12) +#define UFFD_FEATURE_WP_UNPOPULATED (1<<13)__u64 features;__u64 ioctls;
@@ -297,6 +305,13 @@ struct uffdio_writeprotect {struct uffdio_continue {struct uffdio_range range;#define UFFDIO_CONTINUE_MODE_DONTWAKE ((__u64)1<<0) +/* +* UFFDIO_CONTINUE_MODE_WP will map the page write protected on +* the fly. UFFDIO_CONTINUE_MODE_WP is available only if the +* write protected ioctl is implemented for the range +* according to the uffdio_register.ioctls. +*/ +#define UFFDIO_CONTINUE_MODE_WP ((__u64)1<<1)__u64 mode;/*
Signature · 1 line
2.41.0
PATCH v8 10/20 target/riscv/kvm.c: init 'misa_ext_mask' with scratch CPU
In reply to Daniel Henrique BarbozaAt this moment we're retrieving env->misa_ext during kvm_arch_init_cpu(), leaving env->misa_ext_mask behind.
We want to set env->misa_ext_mask, and we want to set it as early as possible. The reason is that we're going to use it in the validation process of the KVM MISA properties we're going to add next. Setting it during arch_init_cpu() is too late for user validation.
Move the code to a new helper that is going to be called during init() time, via kvm_riscv_init_user_properties(), like we're already doing for the machine ID properties. Set both misa_ext and misa_ext_mask to the same value retrieved by the 'isa' config reg.
--- target/riscv/kvm.c | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-)
target/riscv/kvm.c +23 -11
@@ -396,6 +396,28 @@ static void kvm_riscv_init_machine_ids(RISCVCPU *cpu, KVMScratchCPU *kvmcpu) } } +static void kvm_riscv_init_misa_ext_mask (RISCVCPU *cpu, +KVMScratchCPU *kvmcpu) +{ +CPURISCVState *env = &cpu->env; +struct kvm_one_reg reg; +int ret; + + reg.id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , +KVM_REG_RISCV_CONFIG_REG (isa)); + reg.addr = (uint64_t )&env->misa_ext_mask; + ret =ioctl (kvmcpu->cpufd,KVM_GET_ONE_REG , ®); + +if (ret) { +error_report ("Unable to fetch ISA register from KVM, " +"error %d" , ret); +kvm_riscv_destroy_scratch_vcpu (kvmcpu); +exit (EXIT_FAILURE ); + } + + env->misa_ext = env->misa_ext_mask; +} +void kvm_riscv_init_user_properties (Object *cpu_obj) {RISCVCPU *cpu =RISCV_CPU (cpu_obj);
@@ -406,6 +428,7 @@ void kvm_riscv_init_user_properties(Object *cpu_obj) }kvm_riscv_init_machine_ids (cpu, &kvmcpu); +kvm_riscv_init_misa_ext_mask (cpu, &kvmcpu);kvm_riscv_destroy_scratch_vcpu (&kvmcpu); }
@@ -525,21 +548,10 @@ static int kvm_vcpu_set_machine_ids(RISCVCPU *cpu, CPUState *cs)int kvm_arch_init_vcpu (CPUState *cs) {int ret =0 ; -target_ulong isa;RISCVCPU *cpu =RISCV_CPU (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) { -return ret; - } - env->misa_ext = isa; -if (!object_dynamic_cast (OBJECT (cpu),TYPE_RISCV_CPU_HOST )) { ret =kvm_vcpu_set_machine_ids (cpu, cs); }
Signature · 1 line
2.41.0
PATCH v8 11/20 target/riscv/cpu: add misa_ext_info_arr[]
In reply to Daniel Henrique BarbozaNext patch will add KVM specific user properties for both MISA and multi-letter extensions. For MISA extensions we want to make use of what is already available in misa_ext_cfgs[] to avoid code repetition.
misa_ext_info_arr[] array will hold name and description for each MISA extension that misa_ext_cfgs[] is declaring. We'll then use this new array in KVM code to avoid duplicating strings. Two getters were added to allow KVM to retrieve the 'name' and 'description' for each MISA property.
There's nothing holding us back from doing the same with multi-letter extensions. For now doing just with MISA extensions is enough.
It is worth documenting that even using the __bultin_ctz() directive to populate the misa_ext_info_arr[] we are forced to assign 'name' and 'description' during runtime in riscv_cpu_add_misa_properties(). The reason is that some Gitlab runners ('clang-user' and 'tsan-build') will throw errors like this if we fetch 'name' and 'description' from the array in the MISA_CFG() macro:
../target/riscv/cpu.c:1624:5: error: initializer element is not a
compile-time constant
MISA_CFG(RVA, true),
^~~~~~~~~~~~~~~~~~~
../target/riscv/cpu.c:1619:53: note: expanded from macro 'MISA_CFG'
{.name = misa_ext_info_arr[MISA_INFO_IDX(_bit)].name, \
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~gcc and others compilers/builders were fine with that change. We can't ignore failures in the Gitlab pipeline though, so code was changed to make every runner happy.
As a side effect, misa_ext_cfg[] is no longer a 'const' array because it must be set during runtime.
--- target/riscv/cpu.c | 110 +++++++++++++++++++++++++++++++++------------ target/riscv/cpu.h | 7 ++- 2 files changed, 88 insertions(+), 29 deletions(-)
target/riscv/cpu.c +82 -28
@@ -1636,33 +1636,83 @@ static void cpu_get_misa_ext_cfg(Object *obj, Visitor *v, const char *name,visit_type_bool (v, name, &value, errp); } -static const RISCVCPUMisaExtConfig misa_ext_cfgs[] = { - {.name ="a" , .description ="Atomic instructions" , - .misa_bit =RVA , .enabled = true}, - {.name ="c" , .description ="Compressed instructions" , - .misa_bit =RVC , .enabled = true}, - {.name ="d" , .description ="Double-precision float point" , - .misa_bit =RVD , .enabled = true}, - {.name ="f" , .description ="Single-precision float point" , - .misa_bit =RVF , .enabled = true}, - {.name ="i" , .description ="Base integer instruction set" , - .misa_bit =RVI , .enabled = true}, - {.name ="e" , .description ="Base integer instruction set (embedded)" , - .misa_bit =RVE , .enabled = false}, - {.name ="m" , .description ="Integer multiplication and division" , - .misa_bit =RVM , .enabled = true}, - {.name ="s" , .description ="Supervisor-level instructions" , - .misa_bit =RVS , .enabled = true}, - {.name ="u" , .description ="User-level instructions" , - .misa_bit =RVU , .enabled = true}, - {.name ="h" , .description ="Hypervisor" , - .misa_bit =RVH , .enabled = true}, - {.name ="x-j" , .description ="Dynamic translated languages" , - .misa_bit =RVJ , .enabled = false}, - {.name ="v" , .description ="Vector operations" , - .misa_bit =RVV , .enabled = false}, - {.name ="g" , .description ="General purpose (IMAFD_Zicsr_Zifencei)" , - .misa_bit =RVG , .enabled = false}, +typedef struct misa_ext_info { +const char *name; +const char *description; +}MISAExtInfo ; + +#define MISA_INFO_IDX (_bit) \ + __builtin_ctz(_bit) + +#define MISA_EXT_INFO (_bit, _propname, _descr) \ + [MISA_INFO_IDX(_bit)] = {.name = _propname, .description = _descr} + +static const MISAExtInfo misa_ext_info_arr[] = { +MISA_EXT_INFO (RVA ,"a" ,"Atomic instructions" ), +MISA_EXT_INFO (RVC ,"c" ,"Compressed instructions" ), +MISA_EXT_INFO (RVD ,"d" ,"Double-precision float point" ), +MISA_EXT_INFO (RVF ,"f" ,"Single-precision float point" ), +MISA_EXT_INFO (RVI ,"i" ,"Base integer instruction set" ), +MISA_EXT_INFO (RVE ,"e" ,"Base integer instruction set (embedded)" ), +MISA_EXT_INFO (RVM ,"m" ,"Integer multiplication and division" ), +MISA_EXT_INFO (RVS ,"s" ,"Supervisor-level instructions" ), +MISA_EXT_INFO (RVU ,"u" ,"User-level instructions" ), +MISA_EXT_INFO (RVH ,"h" ,"Hypervisor" ), +MISA_EXT_INFO (RVJ ,"x-j" ,"Dynamic translated languages" ), +MISA_EXT_INFO (RVV ,"v" ,"Vector operations" ), +MISA_EXT_INFO (RVG ,"g" ,"General purpose (IMAFD_Zicsr_Zifencei)" ), +}; + +static int riscv_validate_misa_info_idx (uint32_t bit) +{ +int idx; + +/* +* Our lowest valid input (RVA) is 1 and +* __builtin_ctz() is UB with zero. +*/ +g_assert (bit !=0 ); + idx =MISA_INFO_IDX (bit); + +g_assert (idx <ARRAY_SIZE (misa_ext_info_arr)); +return idx; +} + +const char *riscv_get_misa_ext_name (uint32_t bit) +{ +int idx =riscv_validate_misa_info_idx (bit); +const char *val = misa_ext_info_arr[idx].name; + +g_assert (val !=NULL ); +return val; +} + +const char *riscv_get_misa_ext_description (uint32_t bit) +{ +int idx =riscv_validate_misa_info_idx (bit); +const char *val = misa_ext_info_arr[idx].description; + +g_assert (val !=NULL ); +return val; +} + +#define MISA_CFG (_bit, _enabled) \ + {.misa_bit = _bit, .enabled = _enabled} + +static RISCVCPUMisaExtConfig misa_ext_cfgs[] = { +MISA_CFG (RVA , true), +MISA_CFG (RVC , true), +MISA_CFG (RVD , true), +MISA_CFG (RVF , true), +MISA_CFG (RVI , true), +MISA_CFG (RVE , false), +MISA_CFG (RVM , true), +MISA_CFG (RVS , true), +MISA_CFG (RVU , true), +MISA_CFG (RVH , true), +MISA_CFG (RVJ , false), +MISA_CFG (RVV , false), +MISA_CFG (RVG , false), };static void riscv_cpu_add_misa_properties (Object *cpu_obj)
@@ -1670,7 +1720,11 @@ static void riscv_cpu_add_misa_properties(Object *cpu_obj)int i;for (i =0 ; i <ARRAY_SIZE (misa_ext_cfgs); i++) { -const RISCVCPUMisaExtConfig *misa_cfg = &misa_ext_cfgs[i]; +RISCVCPUMisaExtConfig *misa_cfg = &misa_ext_cfgs[i]; +int bit = misa_cfg->misa_bit; + + misa_cfg->name =riscv_get_misa_ext_name (bit); + misa_cfg->description =riscv_get_misa_ext_description (bit); object_property_add(cpu_obj, misa_cfg->name, "bool", cpu_get_misa_ext_cfg,
target/riscv/cpu.h +6 -1
@@ -41,7 +41,10 @@#define RV (x) ((target_ulong)1 << (x - 'A')) -/* Consider updating misa_ext_cfgs[] when adding new MISA bits here */ +/* +* Consider updating misa_ext_info_arr[] and misa_ext_cfgs[] +* when adding new MISA bits here. +*/ #define RVI RV('I')#define RVE RV('E')/* E and I are mutually exclusive */ #define RVM RV('M')
@@ -56,6 +59,8 @@#define RVJ RV('J')#define RVG RV('G') +const char *riscv_get_misa_ext_name (uint32_t bit); +const char *riscv_get_misa_ext_description (uint32_t bit);/* Privileged specification version */ enum {
Signature · 1 line
2.41.0
PATCH v8 12/20 target/riscv: add KVM specific MISA properties
In reply to Daniel Henrique BarbozaUsing all TCG user properties in KVM is tricky. First because KVM supports only a small subset of what TCG provides, so most of the cpu->cfg flags do nothing for KVM.
Second, and more important, we don't have a way of telling if any given value is an user input or not. For TCG this has a small impact since we just validating everything and error out if needed. But for KVM it would be good to know if a given value was set by the user or if it's a value already provided by KVM. Otherwise we don't know how to handle failed kvm_set_one_regs() when writing the configurations back.
These characteristics make it overly complicated to use the same user facing flags for both KVM and TCG. A simpler approach is to create KVM specific properties that have specialized logic, forking KVM and TCG use cases for those cases only. Fully separating KVM/TCG properties is unneeded at this point - in fact we want the user experience to be as equal as possible, regardless of the acceleration chosen.
We'll start this fork with the MISA properties, adding the MISA bits that the KVM driver currently supports. A new KVMCPUConfig type is introduced. It'll hold general information about an extension. For MISA extensions we're going to use the newly created getters of misa_ext_infos[] to populate their name and description. 'offset' holds the MISA bit (RVA, RVC, ...). We're calling it 'offset' instead of 'misa_bit' because this same KVMCPUConfig struct will be used to multi-letter extensions later on.
This new type also holds a 'user_set' flag. This flag will be set when the user set an option that's different than what is already configured in the host, requiring KVM intervention to write the regs back during kvm_arch_init_vcpu(). Similar mechanics will be implemented for multi-letter extensions as well.
There is no need to duplicate more code than necessary, so we're going to use the existing kvm_riscv_init_user_properties() to add the KVM specific properties. Any code that is adding a TCG user prop is then changed slightly to verify first if there's a KVM prop with the same name already added.
--- target/riscv/cpu.c | 5 +++ target/riscv/kvm.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+)
target/riscv/cpu.c +5 -0
@@ -1726,6 +1726,11 @@ static void riscv_cpu_add_misa_properties(Object *cpu_obj) misa_cfg->name =riscv_get_misa_ext_name (bit); misa_cfg->description =riscv_get_misa_ext_description (bit); +/* Check if KVM already created the property */ +if (object_property_find (cpu_obj, misa_cfg->name)) { +continue ; + } + object_property_add(cpu_obj, misa_cfg->name, "bool", cpu_get_misa_ext_cfg, cpu_set_misa_ext_cfg,
target/riscv/kvm.c +78 -0
98 lines not on this page · raw message
Signature · 1 line
2.41.0
PATCH v8 13/20 target/riscv/kvm.c: update KVM MISA bits
In reply to Daniel Henrique BarbozaOur design philosophy with KVM properties can be resumed in two main decisions based on KVM interface availability and what the user wants to do:
- if the user disables an extension that the host KVM module doesn't know about (i.e. it doesn't implement the kvm_get_one_reg() interface), keep booting the CPU. This will avoid users having to deal with issues with older KVM versions while disabling features they don't care;
- for any other case we're going to error out immediately. If the user wants to enable a feature that KVM doesn't know about this a problem that is worth aborting - the user must know that the feature wasn't enabled in the hart. Likewise, if KVM knows about the extension, the user wants to enable/disable it, and we fail to do it so, that's also a problem we can't shrug it off.
In the case of MISA bits we won't even try enabling bits that aren't already available in the host. The ioctl() is so likely to fail that it's not worth trying. This check is already done in the previous patch, in kvm_cpu_set_misa_ext_cfg(), thus we don't need to worry about it now.
In kvm_riscv_update_cpu_misa_ext() we'll go through every potential user option and do as follows:
- if the user didn't set the property or set to the same value of the host, do nothing;
- Disable the given extension in KVM. Error out if anything goes wrong.
--- target/riscv/kvm.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)
target/riscv/kvm.c +40 -0
@@ -162,6 +162,41 @@ static void kvm_cpu_set_misa_ext_cfg(Object *obj, Visitor *v, "enabled in the host", misa_ext_cfg->name); } +static void kvm_riscv_update_cpu_misa_ext (RISCVCPU *cpu,CPUState *cs) +{ +CPURISCVState *env = &cpu->env; +uint64_t id, reg; +int i, ret; + +for (i =0 ; i <ARRAY_SIZE (kvm_misa_ext_cfgs); i++) { +KVMCPUConfig *misa_cfg = &kvm_misa_ext_cfgs[i]; +target_ulong misa_bit = misa_cfg->offset; + +if (!misa_cfg->user_set) { +continue ; + } + +/* If we're here we're going to disable the MISA bit */ + reg =0 ; + id =kvm_riscv_reg_id (env,KVM_REG_RISCV_ISA_EXT , + misa_cfg->kvm_reg_id); + ret =kvm_set_one_reg (cs, id, ®); +if (ret !=0 ) { +/* +* We're not checking for -EINVAL because if the bit is about +* to be disabled, it means that it was already enabled by +* KVM. We determined that by fetching the 'isa' register +* during init() time. Any error at this point is worth +* aborting. +*/ +error_report ("Unable to set KVM reg %s, error %d" , + misa_cfg->name, ret); +exit (EXIT_FAILURE ); + } + env->misa_ext &= ~misa_bit; + } +} +static void kvm_riscv_add_cpu_user_properties (Object *cpu_obj) {int i;
@@ -632,8 +667,13 @@ int kvm_arch_init_vcpu(CPUState *cs)if (!object_dynamic_cast (OBJECT (cpu),TYPE_RISCV_CPU_HOST )) { ret =kvm_vcpu_set_machine_ids (cpu, cs); +if (ret !=0 ) { +return ret; + } } +kvm_riscv_update_cpu_misa_ext (cpu, cs); +return ret; }
Signature · 1 line
2.41.0
PATCH v8 14/20 target/riscv/kvm.c: add multi-letter extension KVM properties
In reply to Daniel Henrique BarbozaLet's add KVM user properties for the multi-letter extensions that KVM currently supports: zicbom, zicboz, zihintpause, zbb, ssaia, sstc, svinval and svpbmt.
As with MISA extensions, we're using the KVMCPUConfig type to hold information about the state of each extension. However, multi-letter extensions have more cases to cover than MISA extensions, so we're adding an extra 'supported' flag as well. This flag will reflect if a given extension is supported by KVM, i.e. KVM knows how to handle it. This is determined during KVM extension discovery in kvm_riscv_init_multiext_cfg(), where we test for ENOENT errors. Any other error will cause an abort.
The use of the 'user_set' is similar to what we already do with MISA
extensions: the flag set only if the user is changing the extension state.
The 'supported' flag will be used later on to make an exception for users that are disabling multi-letter extensions that are unknown to KVM.
--- target/riscv/cpu.c | 8 +++ target/riscv/kvm.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 127 insertions(+)
target/riscv/cpu.c +8 -0
@@ -1860,6 +1860,14 @@ static void riscv_cpu_add_user_properties(Object *obj)riscv_cpu_add_misa_properties (obj);for (prop = riscv_cpu_extensions; prop && prop->name; prop++) { +#ifndef CONFIG_USER_ONLY +if (kvm_enabled ()) { +/* Check if KVM created the property already */ +if (object_property_find (obj, prop->name)) { +continue ; + } + } +#endif qdev_property_add_static (dev, prop); }
target/riscv/kvm.c +119 -0
149 lines not on this page · raw message
Signature · 1 line
2.41.0
Re: [PATCH v8 14/20] target/riscv/kvm.c: add multi-letter extension KVM properties
Quoted 174 lines · Daniel Henrique Barboza
Let's add KVM user properties for the multi-letter extensions that KVM currently supports: zicbom, zicboz, zihintpause, zbb, ssaia, sstc, svinval and svpbmt.
As with MISA extensions, we're using the KVMCPUConfig type to hold information about the state of each extension. However, multi-letter extensions have more cases to cover than MISA extensions, so we're adding an extra 'supported' flag as well. This flag will reflect if a given extension is supported by KVM, i.e. KVM knows how to handle it. This is determined during KVM extension discovery in
kvm_riscv_init_multiext_cfg(), where we test for ENOENT errors. Any other error will cause an abort.The use of the '
user_set' is similar to what we already do with MISA
extensions: the flag set only if the user is changing the extension state.The 'supported' flag will be used later on to make an exception for users that are disabling multi-letter extensions that are unknown to KVM.
Signed-off-by Daniel Henrique Barboza <[email protected]>--- target/riscv/cpu.c | 8 +++ target/riscv/kvm.c | 119 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 127 insertions(+)target/riscv/cpu.c +8
-0@@ -1860,6 +1860,14 @@ static void riscv_cpu_add_user_properties(Object *obj)riscv_cpu_add_misa_properties (obj);for (prop = riscv_cpu_extensions; prop && prop->name; prop++) { +#ifndef CONFIG_USER_ONLY +if (kvm_enabled ()) { +/* Check if KVM created the property already */ +if (object_property_find (obj, prop->name)) { +continue ; + } + } +#endif qdev_property_add_static (dev, prop); }target/riscv/kvm.c +99
-0@@ -113,6 +113,7 @@ typedef struct KVMCPUConfig {target_ulong offset;int kvm_reg_id;bool user_set; +bool supported; } KVMCPUConfig;#define KVM_MISA_CFG (_bit, _reg_id) \@@ -197,6 +198,81 @@ static void kvm_riscv_update_cpu_misa_ext(RISCVCPU *cpu, CPUState *cs) } } +#define CPUCFG (_prop) offsetof(struct RISCVCPUConfig, _prop) + +#define KVM_EXT_CFG (_name, _prop, _reg_id) \ + {.name = _name, .offset = CPUCFG(_prop), \ + .kvm_reg_id = _reg_id} + +static KVMCPUConfig kvm_multi_ext_cfgs[] = { +KVM_EXT_CFG ("zicbom" , ext_icbom,KVM_RISCV_ISA_EXT_ZICBOM ), +KVM_EXT_CFG ("zicboz" , ext_icboz,KVM_RISCV_ISA_EXT_ZICBOZ ), +KVM_EXT_CFG ("zihintpause" , ext_zihintpause,KVM_RISCV_ISA_EXT_ZIHINTPAUSE ), +KVM_EXT_CFG ("zbb" , ext_zbb,KVM_RISCV_ISA_EXT_ZBB ), +KVM_EXT_CFG ("ssaia" , ext_ssaia,KVM_RISCV_ISA_EXT_SSAIA ), +KVM_EXT_CFG ("sstc" , ext_sstc,KVM_RISCV_ISA_EXT_SSTC ), +KVM_EXT_CFG ("svinval" , ext_svinval,KVM_RISCV_ISA_EXT_SVINVAL ), +KVM_EXT_CFG ("svpbmt" , ext_svpbmt,KVM_RISCV_ISA_EXT_SVPBMT ), +}; + +static void kvm_cpu_cfg_set (RISCVCPU *cpu,KVMCPUConfig *multi_ext, +uint32_t val) +{ +int cpu_cfg_offset = multi_ext->offset; +bool *ext_enabled = (void *)&cpu->cfg + cpu_cfg_offset; + + *ext_enabled = val; +} + +static uint32_t kvm_cpu_cfg_get (RISCVCPU *cpu, +KVMCPUConfig *multi_ext) +{ +int cpu_cfg_offset = multi_ext->offset; +bool *ext_enabled = (void *)&cpu->cfg + cpu_cfg_offset; + +return *ext_enabled; +} + +static void kvm_cpu_set_multi_ext_cfg (Object *obj,Visitor *v, +const char *name, +void *opaque,Error **errp) +{ +KVMCPUConfig *multi_ext_cfg = opaque; +RISCVCPU *cpu =RISCV_CPU (obj); +bool value, host_val; + +if (!visit_type_bool (v, name, &value, errp)) { +return ; + } + + host_val =kvm_cpu_cfg_get (cpu, multi_ext_cfg); + +/* +* Ignore if the user is setting the same value +* as the host. +*/ +if (value == host_val) { +return ; + } + +if (!multi_ext_cfg->supported) { +/* +* Error out if the user is trying to enable an +* extension that KVM doesn't support. Ignore +* option otherwise. +*/ +if (value) { +error_setg (errp,"KVM does not support disabling extension %s" , + multi_ext_cfg->name); + } + +return ; + } + + multi_ext_cfg->user_set = true; +kvm_cpu_cfg_set (cpu, multi_ext_cfg, value); +} +static void kvm_riscv_add_cpu_user_properties (Object *cpu_obj) {int i;@@ -215,6 +291,15 @@ static void kvm_riscv_add_cpu_user_properties(Object *cpu_obj)object_property_set_description (cpu_obj, misa_cfg->name, misa_cfg->description); } + +for (i =0 ; i <ARRAY_SIZE (kvm_multi_ext_cfgs); i++) { +KVMCPUConfig *multi_cfg = &kvm_multi_ext_cfgs[i]; + +object_property_add (cpu_obj, multi_cfg->name,"bool" , +NULL , + kvm_cpu_set_multi_ext_cfg, +NULL , multi_cfg); + } }static int kvm_riscv_get_regs_core (CPUState *cs)@@ -530,6 +615,39 @@ static void kvm_riscv_init_misa_ext_mask(RISCVCPU *cpu, env->misa_ext = env->misa_ext_mask; } +static void kvm_riscv_init_multiext_cfg (RISCVCPU *cpu,KVMScratchCPU *kvmcpu) +{ +CPURISCVState *env = &cpu->env; +uint64_t val; +int i, ret; + +for (i =0 ; i <ARRAY_SIZE (kvm_multi_ext_cfgs); i++) { +KVMCPUConfig *multi_ext_cfg = &kvm_multi_ext_cfgs[i]; +struct kvm_one_reg reg; + + reg.id =kvm_riscv_reg_id (env,KVM_REG_RISCV_ISA_EXT , + multi_ext_cfg->kvm_reg_id); + reg.addr = (uint64_t )&val; + ret =ioctl (kvmcpu->cpufd,KVM_GET_ONE_REG , ®);
target/riscv/kvm.c static void kvm_riscv_init_misa_ext_mask(RISCVCPU *cpu, · line 641
Quoted 10 lines
target/riscv/kvm.c +10
-0+if (ret !=0 ) { +if (errno ==ENOENT ) { +/* Silently default to 'false' if KVM does not support it. */ + multi_ext_cfg->supported = false; + val = false; + }else { +error_report ("Unable to read ISA_EXT KVM register %s, " +"error %d" , multi_ext_cfg->name, ret); +kvm_riscv_destroy_scratch_vcpu (kvmcpu); +exit (EXIT_FAILURE );
TL;DR - We need to change ENOENT back to EINVAL.
I realized that I wasn't thinking clearly yesterday when I suggested we should error out for everything but the still-nonexistent ENOENT, which means erroring out even for EINVAL when it means "register not present". That might be fine if we were making this ioctl due to user input, but we're making this ioctl based on what QEMU knows about potential KVM extension support, which means QEMU will no longer work on older KVM which doesn't support everything QEMU knows about, regardless of user input.
We're sort of stuck here with either assuming EINVAL is most likely going to be "register not present" and go with that, or we can't do this early probing for extensions at all, since we can't tell the difference between "invalid input" and "register not present".
But, there is a solution on the horizon! get-reg-list is coming soon[1]. So, I suggest we do the following:
1. Audit KVM to ensure using EINVAL for get-one-reg's "register not present" is currently safe, and keep our eye on KVM to make sure it remains safe until get-reg-list lands.
2. Once we have get-reg-list then use that as the authority, rather than trying to decide if a register is present or not by errno. We'll still fall back to EINVAL probing when get-reg-list isn't present in KVM, but we'll know it's safe to do so because of (1), i.e. we only fall back when we're on an already audited KVM version.
Whether or not we proceed with the EINVAL to ENOENT conversion in KVM no longer currently matters to QEMU with this plan, but we can still do it, as it seems more appropriate and may matter later.
[1] https://lore.kernel.org/all/[email protected]/
Thanks,
drew
Quoted 23 lines
target/riscv/kvm.c +10
-0+ } + }else { + multi_ext_cfg->supported = true; + } + +kvm_cpu_cfg_set (cpu, multi_ext_cfg, val); + } +} +void kvm_riscv_init_user_properties (Object *cpu_obj) {RISCVCPU *cpu =RISCV_CPU (cpu_obj);@@ -542,6 +660,7 @@ void kvm_riscv_init_user_properties(Object *cpu_obj)kvm_riscv_add_cpu_user_properties (cpu_obj);kvm_riscv_init_machine_ids (cpu, &kvmcpu);kvm_riscv_init_misa_ext_mask (cpu, &kvmcpu); +kvm_riscv_init_multiext_cfg (cpu, &kvmcpu);kvm_riscv_destroy_scratch_vcpu (&kvmcpu); }Signature · 1 line
2.41.0
Re: [PATCH v8 14/20] target/riscv/kvm.c: add multi-letter extension KVM properties
On Thu, Jul 06, 2023 at 10:45:04AM +0200, Andrew Jones wrote:
...
Quoted 3 lines
1. Audit KVM to ensure using EINVAL for get-one-reg's "register not present" is currently safe, and keep our eye on KVM to make sure it remains safe until get-reg-list lands.
I just did the audit and it looks fine. There's only one way these types of get-one-reg invocations can return EINVAL other than for "register not present" and that's for the encoded reg size not being sizeof(unsigned long). As long as we construct the register ID with the correct size then that can't happen. We currently construct it with kvm_riscv_reg_id() which does the right thing for these invocations.
Thanks,
drew
PATCH v8 15/20 target/riscv/cpu.c: add satp_mode properties earlier
In reply to Daniel Henrique Barbozariscv_cpu_add_user_properties() ended up with an excess of "#ifndef CONFIG_USER_ONLY" blocks after changes that added KVM properties handling.
KVM specific properties are required to be created earlier than their TCG counterparts, but the remaining props can be created at any order. Move riscv_add_satp_mode_properties() to the start of the function, inside the !CONFIG_USER_ONLY block already present there, to remove the last ifndef block.
--- target/riscv/cpu.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
target/riscv/cpu.c +2 -4
@@ -1852,6 +1852,8 @@ static void riscv_cpu_add_user_properties(Object *obj)DeviceState *dev =DEVICE (obj);#ifndef CONFIG_USER_ONLY +riscv_add_satp_mode_properties (obj); +if (kvm_enabled ()) {kvm_riscv_init_user_properties (obj); }
@@ -1870,10 +1872,6 @@ static void riscv_cpu_add_user_properties(Object *obj)#endif qdev_property_add_static (dev, prop); } - -#ifndef CONFIG_USER_ONLY -riscv_add_satp_mode_properties (obj); -#endif }static Property riscv_cpu_properties[] = {
Signature · 1 line
2.41.0
PATCH v8 16/20 target/riscv/cpu.c: remove priv_ver check from riscv_isa_string_ext()
In reply to Daniel Henrique Barbozariscv_isa_string_ext() is being used by riscv_isa_string(), which is then used by boards to retrieve the 'riscv,isa' string to be written in the FDT. All this happens after riscv_cpu_realize(), meaning that we're already past riscv_cpu_validate_set_extensions() and, more important, riscv_cpu_disable_priv_spec_isa_exts().
This means that all extensions that needed to be disabled due to priv_spec mismatch are already disabled. Checking this again during riscv_isa_string_ext() is unneeded. Remove it.
As a bonus, riscv_isa_string_ext() can now be used with the 'host' KVM-only CPU type since it doesn't have a env->priv_ver assigned and it would fail this check for no good reason.
--- target/riscv/cpu.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
target/riscv/cpu.c +1 -2
@@ -2124,8 +2124,7 @@ static void riscv_isa_string_ext(RISCVCPU *cpu, char **isa_str,int i;for (i =0 ; i <ARRAY_SIZE (isa_edata_arr); i++) { -if (cpu->env.priv_ver >= isa_edata_arr[i].min_version && -isa_ext_is_enabled (cpu, &isa_edata_arr[i])) { +if (isa_ext_is_enabled (cpu, &isa_edata_arr[i])) { new =g_strconcat (old,"_" , isa_edata_arr[i].name,NULL );g_free (old); old = new;
Signature · 1 line
2.41.0
PATCH v8 17/20 target/riscv/cpu.c: create KVM mock properties
In reply to Daniel Henrique BarbozaKVM-specific properties are being created inside target/riscv/kvm.c. But at this moment we're gathering all the remaining properties from TCG and adding them as is when running KVM. This creates a situation where non-KVM properties are setting flags to 'true' due to its default settings (e.g. Zawrs). Users can also freely enable them via command line.
This doesn't impact runtime per se because KVM doesn't care about these flags, but code such as riscv_isa_string_ext() take those flags into account. The result is that, for a KVM guest, setting non-KVM properties will make them appear in the riscv,isa DT.
We want to keep the same API for both TCG and KVM and at the same time, when running KVM, forbid non-KVM extensions to be enabled internally. We accomplish both by changing riscv_cpu_add_user_properties() to add a mock boolean property for every non-KVM extension in riscv_cpu_extensions[]. Then, when running KVM, users are still free to set extensions at will, but we'll error out if a non-KVM extension is enabled. Setting such extension to 'false' will be ignored.
--- target/riscv/cpu.c | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+)
target/riscv/cpu.c +36 -0
@@ -1840,6 +1840,26 @@ static Property riscv_cpu_extensions[] = { DEFINE_PROP_END_OF_LIST(), }; + +#ifndef CONFIG_USER_ONLY +static void cpu_set_cfg_unavailable (Object *obj,Visitor *v, +const char *name, +void *opaque,Error **errp) +{ +const char *propname = opaque; +bool value; + +if (!visit_type_bool (v, name, &value, errp)) { +return ; + } + +if (value) { +error_setg (errp,"extension %s is not available with KVM" , + propname); + } +} +#endif +/* * Add CPU properties with user-facing flags. *
@@ -1868,6 +1888,22 @@ static void riscv_cpu_add_user_properties(Object *obj)if (object_property_find (obj, prop->name)) {continue ; } + +/* +* Set the default to disabled for every extension +* unknown to KVM and error out if the user attempts +* to enable any of them. +* +* We're giving a pass for non-bool properties since they're +* not related to the availability of extensions and can be +* safely ignored as is. +*/ +if (prop->info == &qdev_prop_bool) { +object_property_add (obj, prop->name,"bool" , +NULL , cpu_set_cfg_unavailable, +NULL , (void *)prop->name); +continue ; + } }#endif qdev_property_add_static (dev, prop);
Signature · 1 line
2.41.0
PATCH v8 18/20 target/riscv: update multi-letter extension KVM properties
In reply to Daniel Henrique BarbozaWe're now ready to update the multi-letter extensions status for KVM.
kvm_riscv_update_cpu_cfg_isa_ext() is called called during vcpu creation time to verify which user options changes host defaults (via the 'user_set' flag) and tries to write them back to KVM.
Failure to commit a change to KVM is only ignored in case KVM doesn't know about the extension (-EINVAL error code) and the user wanted to disable the given extension. Otherwise we're going to abort the boot process.
--- target/riscv/kvm.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
target/riscv/kvm.c +27 -0
@@ -273,6 +273,32 @@ static void kvm_cpu_set_multi_ext_cfg(Object *obj, Visitor *v,kvm_cpu_cfg_set (cpu, multi_ext_cfg, value); } +static void kvm_riscv_update_cpu_cfg_isa_ext (RISCVCPU *cpu,CPUState *cs) +{ +CPURISCVState *env = &cpu->env; +uint64_t id, reg; +int i, ret; + +for (i =0 ; i <ARRAY_SIZE (kvm_multi_ext_cfgs); i++) { +KVMCPUConfig *multi_ext_cfg = &kvm_multi_ext_cfgs[i]; + +if (!multi_ext_cfg->user_set) { +continue ; + } + + id =kvm_riscv_reg_id (env,KVM_REG_RISCV_ISA_EXT , + multi_ext_cfg->kvm_reg_id); + reg =kvm_cpu_cfg_get (cpu, multi_ext_cfg); + ret =kvm_set_one_reg (cs, id, ®); +if (ret !=0 ) { +error_report ("Unable to %s extension %s in KVM, error %d" , + reg ?"enable" :"disable" , + multi_ext_cfg->name, ret); +exit (EXIT_FAILURE ); + } + } +} +static void kvm_riscv_add_cpu_user_properties (Object *cpu_obj) {int i;
@@ -792,6 +818,7 @@ int kvm_arch_init_vcpu(CPUState *cs) }kvm_riscv_update_cpu_misa_ext (cpu, cs); +kvm_riscv_update_cpu_cfg_isa_ext (cpu, cs);return ret; }
Signature · 1 line
2.41.0
PATCH v8 19/20 target/riscv/kvm.c: add kvmconfig_get_cfg_addr() helper
In reply to Daniel Henrique BarbozaThere are 2 places in which we need to get a pointer to a certain property of the cpu->cfg struct based on property offset. Next patch will add a couple more.
Create a helper to avoid repeating this code over and over.
--- target/riscv/kvm.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
target/riscv/kvm.c +7 -4
@@ -215,11 +215,15 @@ static KVMCPUConfig kvm_multi_ext_cfgs[] = { KVM_EXT_CFG("svpbmt", ext_svpbmt, KVM_RISCV_ISA_EXT_SVPBMT), }; +static void *kvmconfig_get_cfg_addr (RISCVCPU *cpu,KVMCPUConfig *kvmcfg) +{ +return (void *)&cpu->cfg + kvmcfg->offset; +} +static void kvm_cpu_cfg_set (RISCVCPU *cpu,KVMCPUConfig *multi_ext,uint32_t val) { -int cpu_cfg_offset = multi_ext->offset; -bool *ext_enabled = (void *)&cpu->cfg + cpu_cfg_offset; +bool *ext_enabled =kvmconfig_get_cfg_addr (cpu, multi_ext); *ext_enabled = val; }
@@ -227,8 +231,7 @@ static void kvm_cpu_cfg_set(RISCVCPU *cpu, KVMCPUConfig *multi_ext,static uint32_t kvm_cpu_cfg_get (RISCVCPU *cpu,KVMCPUConfig *multi_ext) { -int cpu_cfg_offset = multi_ext->offset; -bool *ext_enabled = (void *)&cpu->cfg + cpu_cfg_offset; +bool *ext_enabled =kvmconfig_get_cfg_addr (cpu, multi_ext);return *ext_enabled; }
Signature · 1 line
2.41.0
PATCH v8 20/20 target/riscv/kvm.c: read/write (cbom|cboz)_blocksize in KVM
In reply to Daniel Henrique BarbozaIf we don't set a proper cbom_blocksize|cboz_blocksize in the FDT the Linux Kernel will fail to detect the availability of the CBOM/CBOZ extensions, regardless of the contents of the 'riscv,isa' DT prop.
The FDT is being written using the cpu->cfg.cbom|z_blocksize attributes, so let's expose them as user properties like it is already done with TCG.
This will also require us to determine proper blocksize values during init() time since the FDT is already created during realize(). We'll take a ride in kvm_riscv_init_multiext_cfg() to do it. Note that we don't need to fetch both cbom and cboz blocksizes every time: check for their parent extensions (icbom and icboz) and only read the blocksizes if needed.
In contrast with cbom|z_blocksize properties from TCG, the user is not able to set any value that is different from the 'host' value when running KVM. KVM can be particularly harsh dealing with it: a ENOTSUPP can be thrown for the mere attempt of executing kvm_set_one_reg() for these 2 regs.
Hopefully we don't need to call kvm_set_one_reg() for these regs. We'll check if the user input matches the host value in kvm_cpu_set_cbomz_blksize(), the set() accessor for both blocksize properties. We'll fail fast since it's already known to not be supported.
--- target/riscv/kvm.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+)
target/riscv/kvm.c +70 -0
@@ -276,6 +276,42 @@ static void kvm_cpu_set_multi_ext_cfg(Object *obj, Visitor *v,kvm_cpu_cfg_set (cpu, multi_ext_cfg, value); } +static KVMCPUConfig kvm_cbom_blocksize = { + .name ="cbom_blocksize" , + .offset =CPUCFG (cbom_blocksize), + .kvm_reg_id =KVM_REG_RISCV_CONFIG_REG (zicbom_block_size) +}; + +static KVMCPUConfig kvm_cboz_blocksize = { + .name ="cboz_blocksize" , + .offset =CPUCFG (cboz_blocksize), + .kvm_reg_id =KVM_REG_RISCV_CONFIG_REG (zicboz_block_size) +}; + +static void kvm_cpu_set_cbomz_blksize (Object *obj,Visitor *v, +const char *name, +void *opaque,Error **errp) +{ +KVMCPUConfig *cbomz_cfg = opaque; +RISCVCPU *cpu =RISCV_CPU (obj); +uint16_t value, *host_val; + +if (!visit_type_uint16 (v, name, &value, errp)) { +return ; + } + + host_val =kvmconfig_get_cfg_addr (cpu, cbomz_cfg); + +if (value != *host_val) { +error_report ("Unable to set %s to a different value than " +"the host (%u)" , + cbomz_cfg->name, *host_val); +exit (EXIT_FAILURE ); + } + + cbomz_cfg->user_set = true; +} +static void kvm_riscv_update_cpu_cfg_isa_ext (RISCVCPU *cpu,CPUState *cs) {CPURISCVState *env = &cpu->env;
@@ -329,6 +365,14 @@ static void kvm_riscv_add_cpu_user_properties(Object *cpu_obj) kvm_cpu_set_multi_ext_cfg, NULL, multi_cfg); } + +object_property_add (cpu_obj,"cbom_blocksize" ,"uint16" , +NULL , kvm_cpu_set_cbomz_blksize, +NULL , &kvm_cbom_blocksize); + +object_property_add (cpu_obj,"cboz_blocksize" ,"uint16" , +NULL , kvm_cpu_set_cbomz_blksize, +NULL , &kvm_cboz_blocksize); }static int kvm_riscv_get_regs_core (CPUState *cs)
@@ -644,6 +688,24 @@ static void kvm_riscv_init_misa_ext_mask(RISCVCPU *cpu, env->misa_ext = env->misa_ext_mask; } +static void kvm_riscv_read_cbomz_blksize (RISCVCPU *cpu,KVMScratchCPU *kvmcpu, +KVMCPUConfig *cbomz_cfg) +{ +CPURISCVState *env = &cpu->env; +struct kvm_one_reg reg; +int ret; + + reg.id =kvm_riscv_reg_id (env,KVM_REG_RISCV_CONFIG , + cbomz_cfg->kvm_reg_id); + reg.addr = (uint64_t )kvmconfig_get_cfg_addr (cpu, cbomz_cfg); + ret =ioctl (kvmcpu->cpufd,KVM_GET_ONE_REG , ®); +if (ret !=0 ) { +error_report ("Unable to read KVM reg %s, error %d" , + cbomz_cfg->name, ret); +exit (EXIT_FAILURE ); + } +} +static void kvm_riscv_init_multiext_cfg (RISCVCPU *cpu,KVMScratchCPU *kvmcpu) {CPURISCVState *env = &cpu->env;
@@ -675,6 +737,14 @@ static void kvm_riscv_init_multiext_cfg(RISCVCPU *cpu, KVMScratchCPU *kvmcpu)kvm_cpu_cfg_set (cpu, multi_ext_cfg, val); } + +if (cpu->cfg.ext_icbom) { +kvm_riscv_read_cbomz_blksize (cpu, kvmcpu, &kvm_cbom_blocksize); + } + +if (cpu->cfg.ext_icboz) { +kvm_riscv_read_cbomz_blksize (cpu, kvmcpu, &kvm_cboz_blocksize); + } }void kvm_riscv_init_user_properties (Object *cpu_obj)
Signature · 1 line
2.41.0