RISC-V: KVM: Add Svadu/Zicfiss/Zicfilp FWFT support
Subsystems (4)
v5 cover RISC-V: KVM: Add Svadu/Zicfiss/Zicfilp FWFT support
This patchset based on the patchset "RISC-V: KVM: Add Zicfiss/Zicfilp support".
The patch includes all the function of original patchset from Quan:
adding the Svadu/Zicfiss/Zicfilp FWFT for the RISC-V KVM. And this patchset already passes the KVM unit test.
Test with the patch applied
https://lore.kernel.org/all/[email protected]/
Changed from v4:
patch 1:
1. Use NACL for csr update
2. Check ISA mapping before cleaning the ADUE bit patch 4:
1. Clear the zicfiss csr during a VCPU reset
2. Add zicfiss csr to num_csr_regs()
patch 6:
1. Cleanup SPELP after redirecting the trap
patch 7:
1. Use interrupt bit instead of number for masking/unmasking patch 8:
1. Add missing entry for the test
2. Fix the wrong comment.
Changed from v3:
- https://lore.kernel.org/kvm/[email protected]/
1. rebase to the v7.2-rc1
2. Tested with the updated Svadu patch
3. Remove the dependency as it is already merged.
Changed from v2:
- https://lore.kernel.org/kvm/[email protected]/
1. rebase with Yong-Xuan's patch set
2. Add SSP CSR context switch/set/get
3. Move the software-check exception set/unset into FWFT
4. Only delegate software-check exception when Zicfiss/Zicfilp is enabled.
5. Make KVM SBI_FWFT_PTE_AD_HW_UPDATING depends on both Svadu and Svade enabled.
Changed from Quan's v1:
- https://lore.kernel.org/kvm/[email protected]/
1. rebase to the latest master.
2. Split Svadu change as separate patch
3. Fix all build error from the original series
4. Remove the Svadu check in kvm_riscv_vcpu_config_ran_once() and in favor of the FWFT.
5. Remove the LPE/SSE setting bit in kvm_riscv_vcpu_config_ran_once() (kvm_riscv_vcpu_setup_config() in original patchset)
Inochi Amaoto (8):
RISC-V: KVM: Add support for Svadu FWFT features
KVM: riscv: selftests: add Svadu FWFT extension to get-reg-list test
RISC-V: KVM: Allow Zicfiss/Zicfilp extensions for Guest/VM
RISC-V: KVM: Add ssp context save/restore
RISC-V: KVM: Handle software-check exits for VCPU
RISC-V: KVM: Delegate SPELP bit to VS/VU mode if landing pad is
enabled.
RISC-V: KVM: Add support for control-flow integrity FWFT features
KVM: riscv: selftests: add Zicfiss/Zicfilp extension to get-reg-list
test
arch/riscv/include/asm/csr.h | 1 + arch/riscv/include/asm/kvm_host.h | 7 + arch/riscv/include/uapi/asm/kvm.h | 13 ++ arch/riscv/kvm/isa.c | 2 + arch/riscv/kvm/vcpu.c | 7 + arch/riscv/kvm/vcpu_exit.c | 11 ++ arch/riscv/kvm/vcpu_onereg.c | 68 ++++++- arch/riscv/kvm/vcpu_sbi_fwft.c | 184 ++++++++++++++++++ .../selftests/kvm/riscv/get-reg-list.c | 90 +++++++++ 9 files changed, 381 insertions(+), 2 deletions(-)
--
2.55.0
PATCH v5 1/8 RISC-V: KVM: Add support for Svadu FWFT features
Hardware updating of PTE A/D bits is controlled through ADUE bit in henvcfg Expose the feature only if both Svadu and Svade are supported for VS-mode.
Allow the VMM to enable/disable this feature by change the ISA extension state in the guest.
--- arch/riscv/include/uapi/asm/kvm.h | 1 + arch/riscv/kvm/vcpu_sbi_fwft.c | 77 +++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)
arch/riscv/include/uapi/asm/kvm.h +1 -0
@@ -240,6 +240,7 @@ struct kvm_riscv_sbi_fwft_feature {struct kvm_riscv_sbi_fwft {struct kvm_riscv_sbi_fwft_feature misaligned_deleg;struct kvm_riscv_sbi_fwft_feature pointer_masking; +struct kvm_riscv_sbi_fwft_feature pte_ad_hw_updating; };/* If you need to interpret the index values, here is the key: */
arch/riscv/kvm/vcpu_sbi_fwft.c +77 -0
101 lines not on this page · raw message
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH v5 1/8] RISC-V: KVM: Add support for Svadu FWFT features
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Calling ncsr_write() with preemption enabled causes per-CPU memory corruption when NACL is active…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Calling ncsr_write() with preemption enabled causes per-CPU memory corruption when NACL is active, and unsafe host CSR modifications. --
commit 08e867d22007707b3dd632ffff55b12837db2498
Author: Inochi Amaoto <[email protected]>
RISC-V: KVM: Add support for Svadu FWFT features
This patch adds support for the Svadu FWFT feature, controlling hardware updating of PTE A/D bits through the ADUE bit in henvcfg. It allows the guest and VMM to enable or disable this feature dynamically.
Quoted 4 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +0
-0
[ ... ]
Quoted 18 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +14
-0@@ -94,6 +95,45 @@ static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature)return false; } +static void kvm_sbi_fwft_env_flag_reset_helper (struct kvm_vcpu *vcpu, +u64 flag) +{ + vcpu->arch.cfg.henvcfg &= ~flag; +} + +static long kvm_sbi_fwft_env_flag_set_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long value,u64 flag) +{ +struct kvm_vcpu_config *cfg = &vcpu->arch.cfg; + +if (value ==0 )
arch/riscv/kvm/vcpu_sbi_fwft.c static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature) · line 121
Quoted 10 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +10
-0+ cfg->henvcfg &= ~flag; + else if (value == 1) + cfg->henvcfg |= flag; + else + return SBI_ERR_INVALID_PARAM; + + if (!one_reg_access) { +ncsr_write (CSR_HENVCFG , vcpu->arch.cfg.henvcfg); +if (IS_ENABLED (CONFIG_32BIT )) +ncsr_write (CSR_HENVCFGH , vcpu->arch.cfg.henvcfg >>32 );
[Severity: High]
Is it safe to call ncsr_write() here without preemption disabled?
KVM handles SBI ecalls with preemption enabled. The ncsr_write() macro evaluates nacl_shmem(), which relies on this_cpu_ptr(). Using this_cpu_ptr() with preemption enabled will trigger a CONFIG_DEBUG_PREEMPT warning.
Could the thread be migrated to another CPU after computing the pointer but before writing to it, resulting in per-CPU memory corruption by writing to the NACL shared memory of another physical CPU?
Additionally, when NACL is disabled, it falls back to csr_write(), which writes directly to the physical CPU's host CSRs (CSR_HENVCFG). Could this leave the host with modified hardware state if the vCPU thread migrates?
Quoted 4 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +4
-0+ } + +return SBI_SUCCESS ; +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Re: [PATCH v5 1/8] RISC-V: KVM: Add support for Svadu FWFT features
In reply to Inochi AmaotoQuoted 63 lines · Inochi Amaoto
Hardware updating of PTE A/D bits is controlled through ADUE bit in henvcfg Expose the feature only if both Svadu and Svade are supported for VS-mode.
Allow the VMM to enable/disable this feature by change the ISA extension state in the guest.
Assisted-by YuanSheng:claude-4.7-opusCo-developed-by Quan Zhou <[email protected]>Signed-off-by Quan Zhou <[email protected]>Signed-off-by Inochi Amaoto <[email protected]>--- arch/riscv/include/uapi/asm/kvm.h | 1 + arch/riscv/kvm/vcpu_sbi_fwft.c | 77 +++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)arch/riscv/include/uapi/asm/kvm.h +1
-0@@ -240,6 +240,7 @@ struct kvm_riscv_sbi_fwft_feature {struct kvm_riscv_sbi_fwft {struct kvm_riscv_sbi_fwft_feature misaligned_deleg;struct kvm_riscv_sbi_fwft_feature pointer_masking; +struct kvm_riscv_sbi_fwft_feature pte_ad_hw_updating; };/* If you need to interpret the index values, here is the key: */ arch/riscv/kvm/vcpu_sbi_fwft.c +20
-0@@ -11,6 +11,7 @@#include <linux/kvm_host.h> #include <asm/cpufeature.h> #include <asm/sbi.h> +#include <asm/kvm_nacl.h> #include <asm/kvm_vcpu_sbi.h> #include <asm/kvm_vcpu_sbi_fwft.h> @@ -94,6 +95,45 @@ static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature)return false; } +static void kvm_sbi_fwft_env_flag_reset_helper (struct kvm_vcpu *vcpu, +u64 flag) +{ + vcpu->arch.cfg.henvcfg &= ~flag; +} + +static long kvm_sbi_fwft_env_flag_set_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long value,u64 flag) +{ +struct kvm_vcpu_config *cfg = &vcpu->arch.cfg; + +if (value ==0 ) + cfg->henvcfg &= ~flag; +else if (value ==1 ) + cfg->henvcfg |= flag; +else +return SBI_ERR_INVALID_PARAM ;
arch/riscv/kvm/vcpu_sbi_fwft.c static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature) · line 126
Quoted 10 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +10
-0+ +if (!one_reg_access) { +ncsr_write (CSR_HENVCFG , vcpu->arch.cfg.henvcfg); +if (IS_ENABLED (CONFIG_32BIT )) +ncsr_write (CSR_HENVCFGH , vcpu->arch.cfg.henvcfg >>32 ); + } + +return SBI_SUCCESS ; +} +
Hi, Anup,
The sashiko bot point out calling NACL helper is not safe here as preemption is not allowed when calling this_cpu_ptr() and it is used by the NACL helper. Since I have no idea about how to fix it, is it acceptable to use csr read/write directly here as other FWFT feature?
Regards,
Inochi
The original reply from the bot is
Is it safe to call ncsr_write() here without preemption disabled?
KVM handles SBI ecalls with preemption enabled. The ncsr_write() macro evaluates nacl_shmem(), which relies on this_cpu_ptr(). Using this_cpu_ptr() with preemption enabled will trigger a CONFIG_DEBUG_PREEMPT warning.
Could the thread be migrated to another CPU after computing the pointer but before writing to it, resulting in per-CPU memory corruption by writing to the NACL shared memory of another physical CPU?
Additionally, when NACL is disabled, it falls back to csr_write(), which writes directly to the physical CPU's host CSRs (CSR_HENVCFG). Could this leave the host with modified hardware state if the vCPU thread migrates?
Quoted 67 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +47
-0+static long kvm_sbi_fwft_env_flag_get_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long *value,u64 flag) +{ + *value = (vcpu->arch.cfg.henvcfg & flag) == flag; + +return SBI_SUCCESS ; +} +static bool kvm_sbi_fwft_misaligned_delegation_supported (struct kvm_vcpu *vcpu) {return misaligned_traps_can_delegate ();@@ -137,6 +177,34 @@ static long kvm_sbi_fwft_get_misaligned_delegation(struct kvm_vcpu *vcpu,return SBI_SUCCESS ; } +static bool kvm_sbi_fwft_pte_ad_hw_updating_supported (struct kvm_vcpu *vcpu) +{ +return riscv_isa_extension_available (vcpu->arch.isa,SVADU ) && +riscv_isa_extension_available (vcpu->arch.isa,SVADE ); +} + +static void kvm_sbi_fwft_reset_pte_ad_hw_updating (struct kvm_vcpu *vcpu) +{ +if (kvm_sbi_fwft_pte_ad_hw_updating_supported (vcpu)) +kvm_sbi_fwft_env_flag_reset_helper (vcpu,ENVCFG_ADUE ); +} + +static long kvm_sbi_fwft_set_pte_ad_hw_updating (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long value) +{ +return kvm_sbi_fwft_env_flag_set_helper (vcpu, conf, one_reg_access, + value,ENVCFG_ADUE ); +} + +static long kvm_sbi_fwft_get_pte_ad_hw_updating (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long *value) +{ +return kvm_sbi_fwft_env_flag_get_helper (vcpu, conf, one_reg_access, + value,ENVCFG_ADUE ); +} +#ifndef CONFIG_32BIT static bool try_to_set_pmm (unsigned long value)@@ -246,6 +314,15 @@ static const struct kvm_sbi_fwft_feature features[] = { .set = kvm_sbi_fwft_set_misaligned_delegation, .get = kvm_sbi_fwft_get_misaligned_delegation, }, + { + .id = SBI_FWFT_PTE_AD_HW_UPDATING, + .first_reg_num = offsetof(struct kvm_riscv_sbi_fwft, pte_ad_hw_updating.enable) / + sizeof(unsigned long), + .supported = kvm_sbi_fwft_pte_ad_hw_updating_supported, + .reset = kvm_sbi_fwft_reset_pte_ad_hw_updating, + .set = kvm_sbi_fwft_set_pte_ad_hw_updating, + .get = kvm_sbi_fwft_get_pte_ad_hw_updating, + }, #ifndef CONFIG_32BIT { .id = SBI_FWFT_POINTER_MASKING_PMLEN,Signature · 1 line
2.55.0
Anup Patel
maintainerRe: [PATCH v5 1/8] RISC-V: KVM: Add support for Svadu FWFT features
Quoted 78 lines · Inochi Amaoto
Quoted 63 lines · Inochi Amaoto
Hardware updating of PTE A/D bits is controlled through ADUE bit in henvcfg Expose the feature only if both Svadu and Svade are supported for VS-mode.
Allow the VMM to enable/disable this feature by change the ISA extension state in the guest.
Assisted-by YuanSheng:claude-4.7-opusCo-developed-by Quan Zhou <[email protected]>Signed-off-by Quan Zhou <[email protected]>Signed-off-by Inochi Amaoto <[email protected]>--- arch/riscv/include/uapi/asm/kvm.h | 1 + arch/riscv/kvm/vcpu_sbi_fwft.c | 77 +++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)arch/riscv/include/uapi/asm/kvm.h +1
-0@@ -240,6 +240,7 @@ struct kvm_riscv_sbi_fwft_feature {struct kvm_riscv_sbi_fwft {struct kvm_riscv_sbi_fwft_feature misaligned_deleg;struct kvm_riscv_sbi_fwft_feature pointer_masking; +struct kvm_riscv_sbi_fwft_feature pte_ad_hw_updating; };/* If you need to interpret the index values, here is the key: */ arch/riscv/kvm/vcpu_sbi_fwft.c +20
-0@@ -11,6 +11,7 @@#include <linux/kvm_host.h> #include <asm/cpufeature.h> #include <asm/sbi.h> +#include <asm/kvm_nacl.h> #include <asm/kvm_vcpu_sbi.h> #include <asm/kvm_vcpu_sbi_fwft.h> @@ -94,6 +95,45 @@ static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature)return false; } +static void kvm_sbi_fwft_env_flag_reset_helper (struct kvm_vcpu *vcpu, +u64 flag) +{ + vcpu->arch.cfg.henvcfg &= ~flag; +} + +static long kvm_sbi_fwft_env_flag_set_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long value,u64 flag) +{ +struct kvm_vcpu_config *cfg = &vcpu->arch.cfg; + +if (value ==0 ) + cfg->henvcfg &= ~flag; +else if (value ==1 ) + cfg->henvcfg |= flag; +else +return SBI_ERR_INVALID_PARAM ;arch/riscv/kvm/vcpu_sbi_fwft.c static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature) · line 126
Quoted 10 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +10
-0+ +if (!one_reg_access) { +ncsr_write (CSR_HENVCFG , vcpu->arch.cfg.henvcfg); +if (IS_ENABLED (CONFIG_32BIT )) +ncsr_write (CSR_HENVCFGH , vcpu->arch.cfg.henvcfg >>32 ); + } + +return SBI_SUCCESS ; +} +Hi, Anup,
Quoted 5 lines
The sashiko bot point out calling NACL helper is not safe here as preemption is not allowed when calling
this_cpu_ptr()and it is used by the NACL helper. Since I have no idea about how to fix it, is it acceptable to use csr read/write directly here as other FWFT feature?
I think its okay use regular csr_read/write() over here because FWFT calls are not in hotpath so it won't have much impact on nested virtualization performance.
Regards,
Anup
Quoted 89 lines
Regards,
InochiThe original reply from the bot is
Is it safe to call
ncsr_write()here without preemption disabled?KVM handles SBI ecalls with preemption enabled. The
ncsr_write()macro evaluatesnacl_shmem(), which relies onthis_cpu_ptr(). Usingthis_cpu_ptr()with preemption enabled will trigger aCONFIG_DEBUG_PREEMPTwarning.Could the thread be migrated to another CPU after computing the pointer but before writing to it, resulting in per-CPU memory corruption by writing to the NACL shared memory of another physical CPU?
Additionally, when NACL is disabled, it falls back to
csr_write(), which writes directly to the physical CPU's host CSRs (CSR_HENVCFG). Could this leave the host with modified hardware state if the vCPU thread migrates?Quoted 67 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +47
-1+static long kvm_sbi_fwft_env_flag_get_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long *value,u64 flag) +{ + *value = (vcpu->arch.cfg.henvcfg & flag) == flag; + +return SBI_SUCCESS ; +} +static bool kvm_sbi_fwft_misaligned_delegation_supported (struct kvm_vcpu *vcpu) {return misaligned_traps_can_delegate ();@@ -137,6 +177,34 @@ static long kvm_sbi_fwft_get_misaligned_delegation(struct kvm_vcpu *vcpu,return SBI_SUCCESS ; } +static bool kvm_sbi_fwft_pte_ad_hw_updating_supported (struct kvm_vcpu *vcpu) +{ +return riscv_isa_extension_available (vcpu->arch.isa,SVADU ) && +riscv_isa_extension_available (vcpu->arch.isa,SVADE ); +} + +static void kvm_sbi_fwft_reset_pte_ad_hw_updating (struct kvm_vcpu *vcpu) +{ +if (kvm_sbi_fwft_pte_ad_hw_updating_supported (vcpu)) +kvm_sbi_fwft_env_flag_reset_helper (vcpu,ENVCFG_ADUE ); +} + +static long kvm_sbi_fwft_set_pte_ad_hw_updating (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long value) +{ +return kvm_sbi_fwft_env_flag_set_helper (vcpu, conf, one_reg_access, + value,ENVCFG_ADUE ); +} + +static long kvm_sbi_fwft_get_pte_ad_hw_updating (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long *value) +{ +return kvm_sbi_fwft_env_flag_get_helper (vcpu, conf, one_reg_access, + value,ENVCFG_ADUE ); +} +#ifndef CONFIG_32BIT static bool try_to_set_pmm (unsigned long value)@@ -246,6 +314,15 @@ static const struct kvm_sbi_fwft_feature features[] = { .set = kvm_sbi_fwft_set_misaligned_delegation, .get = kvm_sbi_fwft_get_misaligned_delegation, }, + { + .id = SBI_FWFT_PTE_AD_HW_UPDATING, + .first_reg_num = offsetof(struct kvm_riscv_sbi_fwft, pte_ad_hw_updating.enable) / + sizeof(unsigned long), + .supported = kvm_sbi_fwft_pte_ad_hw_updating_supported, + .reset = kvm_sbi_fwft_reset_pte_ad_hw_updating, + .set = kvm_sbi_fwft_set_pte_ad_hw_updating, + .get = kvm_sbi_fwft_get_pte_ad_hw_updating, + }, #ifndef CONFIG_32BIT { .id = SBI_FWFT_POINTER_MASKING_PMLEN, --2.55.0
Re: [PATCH v5 1/8] RISC-V: KVM: Add support for Svadu FWFT features
Quoted 85 lines · Anup Patel
Quoted 78 lines · Inochi Amaoto
Quoted 63 lines · Inochi Amaoto
Hardware updating of PTE A/D bits is controlled through ADUE bit in henvcfg Expose the feature only if both Svadu and Svade are supported for VS-mode.
Allow the VMM to enable/disable this feature by change the ISA extension state in the guest.
Assisted-by YuanSheng:claude-4.7-opusCo-developed-by Quan Zhou <[email protected]>Signed-off-by Quan Zhou <[email protected]>Signed-off-by Inochi Amaoto <[email protected]>--- arch/riscv/include/uapi/asm/kvm.h | 1 + arch/riscv/kvm/vcpu_sbi_fwft.c | 77 +++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+)arch/riscv/include/uapi/asm/kvm.h +1
-0@@ -240,6 +240,7 @@ struct kvm_riscv_sbi_fwft_feature {struct kvm_riscv_sbi_fwft {struct kvm_riscv_sbi_fwft_feature misaligned_deleg;struct kvm_riscv_sbi_fwft_feature pointer_masking; +struct kvm_riscv_sbi_fwft_feature pte_ad_hw_updating; };/* If you need to interpret the index values, here is the key: */ arch/riscv/kvm/vcpu_sbi_fwft.c +20
-0@@ -11,6 +11,7 @@#include <linux/kvm_host.h> #include <asm/cpufeature.h> #include <asm/sbi.h> +#include <asm/kvm_nacl.h> #include <asm/kvm_vcpu_sbi.h> #include <asm/kvm_vcpu_sbi_fwft.h> @@ -94,6 +95,45 @@ static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature)return false; } +static void kvm_sbi_fwft_env_flag_reset_helper (struct kvm_vcpu *vcpu, +u64 flag) +{ + vcpu->arch.cfg.henvcfg &= ~flag; +} + +static long kvm_sbi_fwft_env_flag_set_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long value,u64 flag) +{ +struct kvm_vcpu_config *cfg = &vcpu->arch.cfg; + +if (value ==0 ) + cfg->henvcfg &= ~flag; +else if (value ==1 ) + cfg->henvcfg |= flag; +else +return SBI_ERR_INVALID_PARAM ;arch/riscv/kvm/vcpu_sbi_fwft.c static bool kvm_fwft_is_defined_feature(enum sbi_fwft_feature_t feature) · line 126
Quoted 10 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +10
-0+ +if (!one_reg_access) { +ncsr_write (CSR_HENVCFG , vcpu->arch.cfg.henvcfg); +if (IS_ENABLED (CONFIG_32BIT )) +ncsr_write (CSR_HENVCFGH , vcpu->arch.cfg.henvcfg >>32 ); + } + +return SBI_SUCCESS ; +} +Hi, Anup,
Quoted 5 lines
The sashiko bot point out calling NACL helper is not safe here as preemption is not allowed when calling
this_cpu_ptr()and it is used by the NACL helper. Since I have no idea about how to fix it, is it acceptable to use csr read/write directly here as other FWFT feature?
Quoted 4 lines
I think its okay use regular csr_read/write() over here because FWFT calls are not in hotpath so it won't have much impact on nested virtualization performance.
Great, I will switch to the csr_read/write() in the next version. Thanks.
Regards,
Inochi
Quoted 92 lines
Regards,
AnupQuoted 89 lines
Regards,
InochiThe original reply from the bot is
Is it safe to call
ncsr_write()here without preemption disabled?KVM handles SBI ecalls with preemption enabled. The
ncsr_write()macro evaluatesnacl_shmem(), which relies onthis_cpu_ptr(). Usingthis_cpu_ptr()with preemption enabled will trigger aCONFIG_DEBUG_PREEMPTwarning.Could the thread be migrated to another CPU after computing the pointer but before writing to it, resulting in per-CPU memory corruption by writing to the NACL shared memory of another physical CPU?
Additionally, when NACL is disabled, it falls back to
csr_write(), which writes directly to the physical CPU's host CSRs (CSR_HENVCFG). Could this leave the host with modified hardware state if the vCPU thread migrates?Quoted 67 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +47
-1+static long kvm_sbi_fwft_env_flag_get_helper (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access, +unsigned long *value,u64 flag) +{ + *value = (vcpu->arch.cfg.henvcfg & flag) == flag; + +return SBI_SUCCESS ; +} +static bool kvm_sbi_fwft_misaligned_delegation_supported (struct kvm_vcpu *vcpu) {return misaligned_traps_can_delegate ();@@ -137,6 +177,34 @@ static long kvm_sbi_fwft_get_misaligned_delegation(struct kvm_vcpu *vcpu,return SBI_SUCCESS ; } +static bool kvm_sbi_fwft_pte_ad_hw_updating_supported (struct kvm_vcpu *vcpu) +{ +return riscv_isa_extension_available (vcpu->arch.isa,SVADU ) && +riscv_isa_extension_available (vcpu->arch.isa,SVADE ); +} + +static void kvm_sbi_fwft_reset_pte_ad_hw_updating (struct kvm_vcpu *vcpu) +{ +if (kvm_sbi_fwft_pte_ad_hw_updating_supported (vcpu)) +kvm_sbi_fwft_env_flag_reset_helper (vcpu,ENVCFG_ADUE ); +} + +static long kvm_sbi_fwft_set_pte_ad_hw_updating (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long value) +{ +return kvm_sbi_fwft_env_flag_set_helper (vcpu, conf, one_reg_access, + value,ENVCFG_ADUE ); +} + +static long kvm_sbi_fwft_get_pte_ad_hw_updating (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long *value) +{ +return kvm_sbi_fwft_env_flag_get_helper (vcpu, conf, one_reg_access, + value,ENVCFG_ADUE ); +} +#ifndef CONFIG_32BIT static bool try_to_set_pmm (unsigned long value)@@ -246,6 +314,15 @@ static const struct kvm_sbi_fwft_feature features[] = { .set = kvm_sbi_fwft_set_misaligned_delegation, .get = kvm_sbi_fwft_get_misaligned_delegation, }, + { + .id = SBI_FWFT_PTE_AD_HW_UPDATING, + .first_reg_num = offsetof(struct kvm_riscv_sbi_fwft, pte_ad_hw_updating.enable) / + sizeof(unsigned long), + .supported = kvm_sbi_fwft_pte_ad_hw_updating_supported, + .reset = kvm_sbi_fwft_reset_pte_ad_hw_updating, + .set = kvm_sbi_fwft_set_pte_ad_hw_updating, + .get = kvm_sbi_fwft_get_pte_ad_hw_updating, + }, #ifndef CONFIG_32BIT { .id = SBI_FWFT_POINTER_MASKING_PMLEN, --2.55.0
PATCH v5 2/8 KVM: riscv: selftests: add Svadu FWFT extension to get-reg-list test
In reply to Inochi AmaotoThe KVM RISC-V allows Svadu FWFT for Guest/VM so add this extension to get-reg-list test.
--- .../selftests/kvm/riscv/get-reg-list.c | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+)
tools/testing/selftests/kvm/riscv/get-reg-list.c +21 -0
@@ -745,6 +745,9 @@ static const char *sbi_fwft_id_to_str(__u64 reg_off)case 3 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pointer_masking.enable)" ;case 4 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pointer_masking.flags)" ;case 5 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pointer_masking.value)" ; +case 6 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.enable)" ; +case 7 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.flags)" ; +case 8 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.value)" ; }return strdup_printf ("KVM_REG_RISCV_SBI_FWFT | %lld /* UNKNOWN */" , reg_off); }
@@ -944,6 +947,13 @@ static __u64 sbi_fwft_pointer_masking_regs[] = { KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_STATE | KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pointer_masking.value), }; +static __u64 sbi_fwft_pte_ad_hw_updating_regs[] = { +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_EXT |KVM_REG_RISCV_SBI_SINGLE |KVM_RISCV_SBI_EXT_FWFT , +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (pte_ad_hw_updating.enable), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (pte_ad_hw_updating.flags), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (pte_ad_hw_updating.value), +}; +static __u64 zicbom_regs[] = {KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_CONFIG |KVM_REG_RISCV_CONFIG_REG (zicbom_block_size),KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICBOM ,
@@ -1259,6 +1269,16 @@ static struct vcpu_reg_list config_sbi_fwft_pointer_masking = { }, }; +static struct vcpu_reg_list config_sbi_fwft_pte_ad_hw_updating = { + .sublists = { +SUBLIST_BASE , +SUBLIST_ISA (svade,SVADE ), +SUBLIST_ISA (svadu,SVADU ), +SUBLIST_SBI (fwft_pte_ad_hw_updating,FWFT ), + {0 }, + }, +}; +struct vcpu_reg_list *vcpu_configs[] = { &config_sbi_base, &config_sbi_sta,
@@ -1268,6 +1288,7 @@ struct vcpu_reg_list *vcpu_configs[] = { &config_sbi_mpxy, &config_sbi_fwft_misaligned_deleg, &config_sbi_fwft_pointer_masking, + &config_sbi_fwft_pte_ad_hw_updating, &config_aia, &config_fp_f, &config_fp_d,
Signature · 1 line
2.55.0
PATCH v5 3/8 RISC-V: KVM: Allow Zicfiss/Zicfilp extensions for Guest/VM
In reply to Inochi AmaotoExtend the KVM ISA extension array to allow KVM userspace to detect and enable Zicfiss/Zicfilp extensions for Guest/VM.
--- arch/riscv/include/uapi/asm/kvm.h | 2 ++ arch/riscv/kvm/isa.c | 2 ++ 2 files changed, 4 insertions(+)
arch/riscv/include/uapi/asm/kvm.h +2 -0
@@ -199,6 +199,8 @@ enum KVM_RISCV_ISA_EXT_ID {KVM_RISCV_ISA_EXT_ZCLSD ,KVM_RISCV_ISA_EXT_ZILSD ,KVM_RISCV_ISA_EXT_ZALASR , +KVM_RISCV_ISA_EXT_ZICFILP , +KVM_RISCV_ISA_EXT_ZICFISS , KVM_RISCV_ISA_EXT_MAX, };
arch/riscv/kvm/isa.c +2 -0
@@ -65,6 +65,8 @@ static const unsigned long kvm_isa_ext_arr[] = {KVM_ISA_EXT_ARR (ZICBOP ),KVM_ISA_EXT_ARR (ZICBOZ ),KVM_ISA_EXT_ARR (ZICCRSE ), +KVM_ISA_EXT_ARR (ZICFILP ), +KVM_ISA_EXT_ARR (ZICFISS ),KVM_ISA_EXT_ARR (ZICNTR ),KVM_ISA_EXT_ARR (ZICOND ), KVM_ISA_EXT_ARR(ZICSR),
Signature · 1 line
2.55.0
PATCH v5 4/8 RISC-V: KVM: Add ssp context save/restore
In reply to Inochi AmaotoAdd ssp context save/restore for guest VCPUs and also add it to the ONE_REG interface to allow its access from user space.
--- arch/riscv/include/asm/kvm_host.h | 7 ++++ arch/riscv/include/uapi/asm/kvm.h | 8 ++++ arch/riscv/kvm/vcpu.c | 7 ++++ arch/riscv/kvm/vcpu_onereg.c | 68 ++++++++++++++++++++++++++++++- 4 files changed, 88 insertions(+), 2 deletions(-)
arch/riscv/include/asm/kvm_host.h +7 -0
@@ -163,6 +163,10 @@ struct kvm_vcpu_smstateen_csr {unsigned long sstateen0; }; +struct kvm_vcpu_zicfiss_csr { +unsigned long ssp; +}; +struct kvm_vcpu_reset_state {spinlock_t lock;unsigned long pc;
@@ -203,6 +207,9 @@ struct kvm_vcpu_arch {/* CPU Smstateen CSR context of Guest VCPU */ struct kvm_vcpu_smstateen_csr smstateen_csr; +/* CPU Zicfiss CSR context of Guest VCPU */ +struct kvm_vcpu_zicfiss_csr zicfiss_csr; +/* CPU reset state of Guest VCPU */ struct kvm_vcpu_reset_state reset_state;
arch/riscv/include/uapi/asm/kvm.h +8 -0
@@ -102,6 +102,11 @@ struct kvm_riscv_smstateen_csr {unsigned long sstateen0; }; +/* Zicfiss CSR for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ +struct kvm_riscv_zicfiss_csr { +unsigned long ssp; +}; +/* TIMER registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ struct kvm_riscv_timer {__u64 frequency;
@@ -266,12 +271,15 @@ struct kvm_riscv_sbi_fwft {#define KVM_REG_RISCV_CSR_GENERAL (0x0 << KVM_REG_RISCV_SUBTYPE_SHIFT)#define KVM_REG_RISCV_CSR_AIA (0x1 << KVM_REG_RISCV_SUBTYPE_SHIFT)#define KVM_REG_RISCV_CSR_SMSTATEEN (0x2 << KVM_REG_RISCV_SUBTYPE_SHIFT) +#define KVM_REG_RISCV_CSR_ZICFISS (0x3 << KVM_REG_RISCV_SUBTYPE_SHIFT)#define KVM_REG_RISCV_CSR_REG (name) \ (offsetof(struct kvm_riscv_csr, name) / sizeof(unsigned long))#define KVM_REG_RISCV_CSR_AIA_REG (name) \ (offsetof(struct kvm_riscv_aia_csr, name) / sizeof(unsigned long))#define KVM_REG_RISCV_CSR_SMSTATEEN_REG (name) \ (offsetof(struct kvm_riscv_smstateen_csr, name) / sizeof(unsigned long)) +#define KVM_REG_RISCV_CSR_ZICFISS_REG (name) \ + (offsetof(struct kvm_riscv_zicfiss_csr, name) / sizeof(unsigned long))/* Timer registers are mapped as type 4 */ #define KVM_REG_RISCV_TIMER (0x04 << KVM_REG_RISCV_TYPE_SHIFT)
arch/riscv/kvm/vcpu.c +7 -0
@@ -63,6 +63,7 @@ static void kvm_riscv_vcpu_context_reset(struct kvm_vcpu *vcpu,memset (cntx,0 ,sizeof (*cntx));memset (csr,0 ,sizeof (*csr));memset (&vcpu->arch.smstateen_csr,0 ,sizeof (vcpu->arch.smstateen_csr)); +memset (&vcpu->arch.zicfiss_csr,0 ,sizeof (vcpu->arch.zicfiss_csr));/* Restore datap as it's not a part of the guest context. */ cntx->vector.datap = vector_datap;
@@ -720,6 +721,7 @@ static void kvm_riscv_update_hvip(struct kvm_vcpu *vcpu) static __always_inline void kvm_riscv_vcpu_swap_in_guest_state(struct kvm_vcpu *vcpu) { +struct kvm_vcpu_zicfiss_csr *zicficsr = &vcpu->arch.zicfiss_csr;struct kvm_vcpu_smstateen_csr *smcsr = &vcpu->arch.smstateen_csr;struct kvm_vcpu_csr *csr = &vcpu->arch.guest_csr;
@@ -727,10 +729,13 @@ static __always_inline void kvm_riscv_vcpu_swap_in_guest_state(struct kvm_vcpu * vcpu->arch.host_senvcfg =csr_swap (CSR_SENVCFG , csr->senvcfg);if (riscv_has_extension_unlikely (RISCV_ISA_EXT_SMSTATEEN )) vcpu->arch.host_sstateen0 =csr_swap (CSR_SSTATEEN0 , smcsr->sstateen0); +if (riscv_has_extension_unlikely (RISCV_ISA_EXT_ZICFISS )) +csr_write (CSR_SSP , zicficsr->ssp); } static __always_inline void kvm_riscv_vcpu_swap_in_host_state(struct kvm_vcpu *vcpu) { +struct kvm_vcpu_zicfiss_csr *zicficsr = &vcpu->arch.zicfiss_csr;struct kvm_vcpu_smstateen_csr *smcsr = &vcpu->arch.smstateen_csr;struct kvm_vcpu_csr *csr = &vcpu->arch.guest_csr;
@@ -738,6 +743,8 @@ static __always_inline void kvm_riscv_vcpu_swap_in_host_state(struct kvm_vcpu *v csr->senvcfg =csr_swap (CSR_SENVCFG , vcpu->arch.host_senvcfg);if (riscv_has_extension_unlikely (RISCV_ISA_EXT_SMSTATEEN )) smcsr->sstateen0 =csr_swap (CSR_SSTATEEN0 , vcpu->arch.host_sstateen0); +if (riscv_has_extension_unlikely (RISCV_ISA_EXT_ZICFISS )) + zicficsr->ssp =csr_swap (CSR_SSP ,0 ); }/*
arch/riscv/kvm/vcpu_onereg.c +66 -2
104 lines not on this page · raw message
Signature · 1 line
2.55.0
PATCH v5 5/8 RISC-V: KVM: Handle software-check exits for VCPU
In reply to Inochi AmaotoThe extension Zicfiss/Zicfilp introduces a software-check exception to the privilege architecture. Delegate this exception to VS mode when vCPU enable Zicfiss/Zicfilp so the CFI violations in VU/VS could be reported.
--- arch/riscv/include/asm/csr.h | 1 + arch/riscv/kvm/vcpu_exit.c | 4 ++++ 2 files changed, 5 insertions(+)
arch/riscv/include/asm/csr.h +1 -0
@@ -117,6 +117,7 @@#define EXC_INST_PAGE_FAULT 12#define EXC_LOAD_PAGE_FAULT 13#define EXC_STORE_PAGE_FAULT 15 +#define EXC_SOFTWARE_CHECK 18#define EXC_INST_GUEST_PAGE_FAULT 20#define EXC_LOAD_GUEST_PAGE_FAULT 21#define EXC_VIRTUAL_INST_FAULT 22
arch/riscv/kvm/vcpu_exit.c +4 -0
@@ -243,6 +243,10 @@ int kvm_riscv_vcpu_exit(struct kvm_vcpu *vcpu, struct kvm_run *run, run->exit_reason =KVM_EXIT_DEBUG ; ret =0 ;break ; +case EXC_SOFTWARE_CHECK : +if (vcpu->arch.cfg.henvcfg & (ENVCFG_LPE |ENVCFG_SSE )) + ret =vcpu_redirect (vcpu, trap); +break ;default :break ; }
Signature · 1 line
2.55.0
PATCH v5 6/8 RISC-V: KVM: Delegate SPELP bit to VS/VU mode if landing pad is enabled.
In reply to Inochi AmaotoDelegate the newly added SPELP bit from Zicfilp extension to VS/VU mode if it enables landing pad support.
--- arch/riscv/kvm/vcpu_exit.c | 7 +++++++ 1 file changed, 7 insertions(+)
arch/riscv/kvm/vcpu_exit.c +7 -0
@@ -154,6 +154,13 @@ void kvm_riscv_vcpu_trap_redirect(struct kvm_vcpu *vcpu,/* Clear Guest SSTATUS.SIE bit */ vsstatus &= ~SR_SIE ; +/* Change Guest SSTATUS.SPELP bit */ +if (vcpu->arch.cfg.henvcfg &ENVCFG_LPE ) { + vsstatus &= ~SR_SPELP ; + vsstatus |= vcpu->arch.guest_context.sstatus &SR_SPELP ; + vcpu->arch.guest_context.sstatus &= ~SR_SPELP ; + } +/* Update Guest SSTATUS */ ncsr_write (CSR_VSSTATUS , vsstatus);
Signature · 1 line
2.55.0
PATCH v5 7/8 RISC-V: KVM: Add support for control-flow integrity FWFT features
In reply to Inochi AmaotoControl-flow integrity is controlled through a WARL field in henvcfg. Expose the feature only if the Zicfilp/Zicfiss is supported for VS-mode. Allow the VMM to block access to the feature by disabling the ISA extension in the guest.
--- arch/riscv/include/uapi/asm/kvm.h | 2 + arch/riscv/kvm/vcpu_sbi_fwft.c | 107 ++++++++++++++++++++++++++++++ 2 files changed, 109 insertions(+)
arch/riscv/include/uapi/asm/kvm.h +2 -0
@@ -248,6 +248,8 @@ struct kvm_riscv_sbi_fwft {struct kvm_riscv_sbi_fwft_feature misaligned_deleg;struct kvm_riscv_sbi_fwft_feature pointer_masking;struct kvm_riscv_sbi_fwft_feature pte_ad_hw_updating; +struct kvm_riscv_sbi_fwft_feature landing_pad; +struct kvm_riscv_sbi_fwft_feature shadow_stack; };/* If you need to interpret the index values, here is the key: */
arch/riscv/kvm/vcpu_sbi_fwft.c +107 -0
119 lines not on this page · raw message
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH v5 7/8] RISC-V: KVM: Add support for control-flow integrity FWFT features
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Evaluating `this_cpu_ptr()` in a preemptible context via the `ncsr_write()` macro causes potential…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Evaluating this_cpu_ptr() in a preemptible context via the ncsr_write() macro causes potential nested hypervisor state corruption. --
commit 3bf03d5d2c60c30185d31cbc3e653f9c3b28377b
Author: Inochi Amaoto <[email protected]>
RISC-V: KVM: Add support for control-flow integrity FWFT features
This commit adds support for exposing Control-Flow Integrity (CFI) FWFT features (Zicfilp/Zicfiss) to VS-mode. It allows the VMM to control access to these features by modifying the guest's henvcfg and hedeleg registers.
Quoted 4 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +0
-0
[ ... ]
Quoted 11 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +11
-0+static long kvm_sbi_fwft_set_cfi (struct kvm_vcpu *vcpu, +struct kvm_sbi_fwft_config *conf, +bool one_reg_access,unsigned long value, +u64 flag) +{ +struct kvm_vcpu_config *cfg = &vcpu->arch.cfg; + +if (value ==0 ) + cfg->henvcfg &= ~flag; +else if (value ==1 ) + cfg->henvcfg |= flag;
arch/riscv/kvm/vcpu_sbi_fwft.c static long kvm_sbi_fwft_get_misaligned_delegation(struct kvm_vcpu *vcpu, · line 200
Quoted 10 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +10
-0+else +return SBI_ERR_INVALID_PARAM ; + +if (cfg->henvcfg & (ENVCFG_LPE |ENVCFG_SSE )) + cfg->hedeleg |=BIT (EXC_SOFTWARE_CHECK ); +else + cfg->hedeleg &= ~BIT (EXC_SOFTWARE_CHECK ); + +if (!one_reg_access) { +ncsr_write (CSR_HEDELEG , cfg->hedeleg);
[Severity: High]
Is it safe to call ncsr_write() here with preemption enabled?
When a guest makes an SBI_EXT_FWFT_SET call, the KVM exit handler (kvm_riscv_vcpu_exit) explicitly enables preemption before processing the exit.
Looking at the ncsr_write() macro, it uses nacl_shmem() which evaluates this_cpu_ptr():
#define ncsr_write(__csr, __val)
...
nacl_csr_write(nacl_shmem(), __csr, __val);If the thread is preempted and migrated to another physical CPU between evaluating the CPU pointer and performing the write, could this write to the new CPU's view of the old CPU's memory?
This seems like it might corrupt the nested hypervisor state (like HEDELEG or HENVCFG) of another running vCPU, as well as trigger CONFIG_DEBUG_PREEMPT warnings.
Quoted 9 lines
arch/riscv/kvm/vcpu_sbi_fwft.c +9
-0+/* +* Both Bit LPE and SSE are in the lower part, so it is safe +* to only write the henvcfg +*/ +ncsr_write (CSR_HENVCFG , vcpu->arch.cfg.henvcfg); + } + +return SBI_SUCCESS ; +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
PATCH v5 8/8 KVM: riscv: selftests: add Zicfiss/Zicfilp extension to get-reg-list test
In reply to Inochi AmaotoThe KVM RISC-V allows Zicfiss/Zicfilp extensions for Guest/VM so add these extensions to get-reg-list test.
--- .../selftests/kvm/riscv/get-reg-list.c | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+)
tools/testing/selftests/kvm/riscv/get-reg-list.c +69 -0
@@ -90,6 +90,8 @@ bool filter_reg(__u64 reg)case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICBOP :case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICBOZ :case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICCRSE : +case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICFILP : +case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICFISS :case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICNTR :case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICOND :case KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICSR :
@@ -358,6 +360,8 @@ static const char *core_id_to_str(const char *prefix, __u64 id) "KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_REG(" #csr ")"#define RISCV_CSR_SMSTATEEN (csr) \ "KVM_REG_RISCV_CSR_SMSTATEEN | KVM_REG_RISCV_CSR_REG(" #csr ")" +#define RISCV_CSR_ZICFISS (csr) \ + "KVM_REG_RISCV_CSR_ZICFISS | KVM_REG_RISCV_CSR_REG(" #csr ")"static const char *general_csr_id_to_str (__u64 reg_off) {
@@ -425,6 +429,18 @@ static const char *smstateen_csr_id_to_str(__u64 reg_off)return NULL ; } +static const char *zicfiss_csr_id_to_str (__u64 reg_off) +{ +/* reg_off is the offset into struct kvm_riscv_zicfiss_csr */ +switch (reg_off) { +case KVM_REG_RISCV_CSR_ZICFISS_REG (ssp): +return RISCV_CSR_ZICFISS (ssp); + } + +TEST_FAIL ("Unknown zicfiss csr reg: 0x%llx" , reg_off); +return NULL ; +} +static const char *csr_id_to_str (const char *prefix,__u64 id) {__u64 reg_off = id & ~(REG_MASK |KVM_REG_RISCV_CSR );
@@ -441,6 +457,8 @@ static const char *csr_id_to_str(const char *prefix, __u64 id)return aia_csr_id_to_str (reg_off);case KVM_REG_RISCV_CSR_SMSTATEEN :return smstateen_csr_id_to_str (reg_off); +case KVM_REG_RISCV_CSR_ZICFISS : +return zicfiss_csr_id_to_str (reg_off); }return strdup_printf ("%lld | %lld /* UNKNOWN */" , reg_subtype, reg_off);
@@ -585,6 +603,8 @@ static const char *isa_ext_single_id_to_str(__u64 reg_off)KVM_ISA_EXT_ARR (ZICBOP ),KVM_ISA_EXT_ARR (ZICBOZ ),KVM_ISA_EXT_ARR (ZICCRSE ), +KVM_ISA_EXT_ARR (ZICFILP ), +KVM_ISA_EXT_ARR (ZICFISS ),KVM_ISA_EXT_ARR (ZICNTR ),KVM_ISA_EXT_ARR (ZICOND ), KVM_ISA_EXT_ARR(ZICSR),
@@ -748,6 +768,12 @@ static const char *sbi_fwft_id_to_str(__u64 reg_off)case 6 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.enable)" ;case 7 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.flags)" ;case 8 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.value)" ; +case 9 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(landing_pad.enable)" ; +case 10 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(landing_pad.flags)" ; +case 11 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(landing_pad.value)" ; +case 12 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(shadow_stack.enable)" ; +case 13 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(shadow_stack.flags)" ; +case 14 :return "KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(shadow_stack.value)" ; }return strdup_printf ("KVM_REG_RISCV_SBI_FWFT | %lld /* UNKNOWN */" , reg_off); }
@@ -954,6 +980,20 @@ static __u64 sbi_fwft_pte_ad_hw_updating_regs[] = { KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_STATE | KVM_REG_RISCV_SBI_FWFT | KVM_REG_RISCV_SBI_FWFT_REG(pte_ad_hw_updating.value), }; +static __u64 sbi_fwft_landing_pad_regs[] = { +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_EXT |KVM_REG_RISCV_SBI_SINGLE |KVM_RISCV_SBI_EXT_FWFT , +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (landing_pad.enable), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (landing_pad.flags), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (landing_pad.value), +}; + +static __u64 sbi_fwft_shadow_stack_regs[] = { +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_EXT |KVM_REG_RISCV_SBI_SINGLE |KVM_RISCV_SBI_EXT_FWFT , +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (shadow_stack.enable), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (shadow_stack.flags), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_SBI_STATE |KVM_REG_RISCV_SBI_FWFT |KVM_REG_RISCV_SBI_FWFT_REG (shadow_stack.value), +}; +static __u64 zicbom_regs[] = {KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_CONFIG |KVM_REG_RISCV_CONFIG_REG (zicbom_block_size),KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICBOM ,
@@ -969,6 +1009,11 @@ static __u64 zicboz_regs[] = { KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICBOZ, }; +static __u64 zicfiss_regs[] = { +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_CSR |KVM_REG_RISCV_CSR_ZICFISS |KVM_REG_RISCV_CSR_ZICFISS_REG (ssp), +KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_ISA_EXT |KVM_REG_RISCV_ISA_SINGLE |KVM_RISCV_ISA_EXT_ZICFISS , +}; +static __u64 aia_regs[] = {KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_CSR |KVM_REG_RISCV_CSR_AIA |KVM_REG_RISCV_CSR_AIA_REG (siselect),KVM_REG_RISCV |KVM_REG_SIZE_ULONG |KVM_REG_RISCV_CSR |KVM_REG_RISCV_CSR_AIA |KVM_REG_RISCV_CSR_AIA_REG (iprio1),
@@ -1220,6 +1265,8 @@ KVM_ISA_EXT_SUBLIST_CONFIG(zicbom, ZICBOM);KVM_ISA_EXT_SUBLIST_CONFIG (zicbop,ZICBOP );KVM_ISA_EXT_SUBLIST_CONFIG (zicboz,ZICBOZ );KVM_ISA_EXT_SIMPLE_CONFIG (ziccrse,ZICCRSE ); +KVM_ISA_EXT_SIMPLE_CONFIG (zicfilp,ZICFILP ); +KVM_ISA_EXT_SUBLIST_CONFIG (zicfiss,ZICFISS );KVM_ISA_EXT_SIMPLE_CONFIG (zicntr,ZICNTR );KVM_ISA_EXT_SIMPLE_CONFIG (zicond,ZICOND );KVM_ISA_EXT_SIMPLE_CONFIG (zicsr,ZICSR );
@@ -1279,6 +1326,24 @@ static struct vcpu_reg_list config_sbi_fwft_pte_ad_hw_updating = { }, }; +static struct vcpu_reg_list config_sbi_fwft_landing_pad = { + .sublists = { +SUBLIST_BASE , +SUBLIST_ISA (zicfilp,ZICFILP ), +SUBLIST_SBI (fwft_landing_pad,FWFT ), + {0 }, + }, +}; + +static struct vcpu_reg_list config_sbi_fwft_shadow_stack = { + .sublists = { +SUBLIST_BASE , +SUBLIST_ISA (zicfiss,ZICFISS ), +SUBLIST_SBI (fwft_shadow_stack,FWFT ), + {0 }, + }, +}; +struct vcpu_reg_list *vcpu_configs[] = { &config_sbi_base, &config_sbi_sta,
@@ -1289,6 +1354,8 @@ struct vcpu_reg_list *vcpu_configs[] = { &config_sbi_fwft_misaligned_deleg, &config_sbi_fwft_pointer_masking, &config_sbi_fwft_pte_ad_hw_updating, + &config_sbi_fwft_landing_pad, + &config_sbi_fwft_shadow_stack, &config_aia, &config_fp_f, &config_fp_d,
@@ -1332,6 +1399,8 @@ struct vcpu_reg_list *vcpu_configs[] = { &config_zicbop, &config_zicboz, &config_ziccrse, + &config_zicfilp, + &config_zicfiss, &config_zicntr, &config_zicond, &config_zicsr,
Signature · 1 line
2.55.0
[email protected]
AI reviewRe: [PATCH v5 8/8] KVM: riscv: selftests: add Zicfiss/Zicfilp extension to get-reg-list test
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The `RISCV_CSR_ZICFISS` macro generates an uncompilable C code string when outputting registers.…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The RISCV_CSR_ZICFISS macro generates an uncompilable C code string when outputting registers. --
commit ffbde58160b6dea5b92bb36fa48c6dca47305718
Author: Inochi Amaoto <[email protected]>
KVM: riscv: selftests: add Zicfiss/Zicfilp extension to get-reg-list test
The KVM RISC-V allows Zicfiss/Zicfilp extensions for Guest/VM so this adds these extensions to the get-reg-list test.
Quoted 4 lines
tools/testing/selftests/kvm/riscv/get-reg-list.c +0
-0
[ ... ]
tools/testing/selftests/kvm/riscv/get-reg-list.c static const char *core_id_to_str(const char *prefix, __u64 id) · line 364
Quoted 6 lines
tools/testing/selftests/kvm/riscv/get-reg-list.c +2
-0@@ -358,6 +360,8 @@ static const char *core_id_to_str(const char *prefix, __u64 id) "KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_REG(" #csr ")"#define RISCV_CSR_SMSTATEEN (csr) \ "KVM_REG_RISCV_CSR_SMSTATEEN | KVM_REG_RISCV_CSR_REG(" #csr ")" +#define RISCV_CSR_ZICFISS (csr) \ + "KVM_REG_RISCV_CSR_ZICFISS | KVM_REG_RISCV_CSR_REG(" #csr ")"
[Severity: Medium]
Does this macro generate an uncompilable C code string?
When outputting registers (such as when a test fails or when running with --print-list), this macro will print KVM_REG_RISCV_CSR_REG(ssp) instead of KVM_REG_RISCV_CSR_ZICFISS_REG(ssp).
Since ssp is in struct kvm_riscv_zicfiss_csr rather than struct kvm_riscv_csr, copying and pasting this output to update expected register lists will cause a build failure.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8