AMX support for KVM
Subsystems (5)
Paolo Bonzini
maintainerv6 cover AMX support for KVM
These are the final patches that I am committing. They are the same as v5 except for some cosmetic changes in patch 7 that remove the need for the IS_ENABLED(CONFIG_X86_64) check, and a rebase on top of kvm/next.
Paolo
Guang Zeng (1):
kvm: x86: Add support for getting/setting expanded xstate buffer
Jing Liu (11):
kvm: x86: Fix xstate_required_size() to follow XSTATE alignment rule
kvm: x86: Exclude unpermitted xfeatures at KVM_GET_SUPPORTED_CPUID x86/fpu: Make XFD initialization in __fpstate_reset() a function
argument
kvm: x86: Enable dynamic xfeatures at KVM_SET_CPUID2
kvm: x86: Add emulation for IA32_XFD
x86/fpu: Prepare xfd_err in struct fpu_guest
kvm: x86: Intercept #NM for saving IA32_XFD_ERR
kvm: x86: Emulate IA32_XFD_ERR for guest
kvm: x86: Disable RDMSR interception of IA32_XFD_ERR
kvm: x86: Add XCR0 support for Intel AMX
kvm: x86: Add CPUID support for Intel AMX
Kevin Tian (2):
x86/fpu: Provide fpu_update_guest_xfd() for IA32_XFD emulation
kvm: x86: Disable interception for IA32_XFD on demand
Sean Christopherson (1):
x86/fpu: Provide fpu_enable_guest_xfd_features() for KVM
Thomas Gleixner (5):
x86/fpu: Extend fpu_xstate_prctl() with guest permissions x86/fpu: Prepare guest FPU for dynamically enabled FPU features x86/fpu: Add guest support to xfd_enable_feature() x86/fpu: Add uabi_size to guest_fpu
x86/fpu: Provide fpu_sync_guest_vmexit_xfd_state()
Wei Wang (1):
kvm: selftests: Add support for KVM_CAP_XSAVE2
Documentation/virt/kvm/api.rst | 46 +++++- arch/x86/include/asm/cpufeatures.h | 2 + arch/x86/include/asm/fpu/api.h | 11 ++ arch/x86/include/asm/fpu/types.h | 32 ++++ arch/x86/include/asm/kvm_host.h | 1 + arch/x86/include/uapi/asm/kvm.h | 16 +- arch/x86/include/uapi/asm/prctl.h | 26 ++-- arch/x86/kernel/fpu/core.c | 99 +++++++++++- arch/x86/kernel/fpu/xstate.c | 147 +++++++++++------- arch/x86/kernel/fpu/xstate.h | 19 ++- arch/x86/kernel/process.c | 2 + arch/x86/kvm/cpuid.c | 86 +++++++--- arch/x86/kvm/cpuid.h | 2 + arch/x86/kvm/vmx/vmcs.h | 5 + arch/x86/kvm/vmx/vmx.c | 68 ++++++++ arch/x86/kvm/vmx/vmx.h | 2 +- arch/x86/kvm/x86.c | 112 ++++++++++++- include/uapi/linux/kvm.h | 4 + tools/arch/x86/include/uapi/asm/kvm.h | 16 +- tools/include/uapi/linux/kvm.h | 3 + .../selftests/kvm/include/kvm_util_base.h | 2 + .../selftests/kvm/include/x86_64/processor.h | 10 ++ tools/testing/selftests/kvm/lib/kvm_util.c | 32 ++++ .../selftests/kvm/lib/x86_64/processor.c | 67 +++++++- .../testing/selftests/kvm/x86_64/evmcs_test.c | 2 +- tools/testing/selftests/kvm/x86_64/smm_test.c | 2 +- .../testing/selftests/kvm/x86_64/state_test.c | 2 +- .../kvm/x86_64/vmx_preemption_timer_test.c | 2 +- 28 files changed, 711 insertions(+), 107 deletions(-)
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 1/21 x86/fpu: Extend fpu_xstate_prctl() with guest permissions
From: Thomas Gleixner <[email protected]>
KVM requires a clear separation of host user space and guest permissions for dynamic XSTATE components.
Add a guest permissions member to struct fpu and a separate set of prctl()
arguments: ARCH_GET_XCOMP_GUEST_PERM and ARCH_REQ_XCOMP_GUEST_PERM.
The semantics are equivalent to the host user space permission control except for the following constraints:
1) Permissions have to be requested before the first vCPU is created
2) Permissions are frozen when the first vCPU is created to ensure consistency. Any attempt to expand permissions via the prctl() after that point is rejected.
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/api.h | 2 ++ arch/x86/include/asm/fpu/types.h | 9 ++++++ arch/x86/include/uapi/asm/prctl.h | 26 ++++++++------- arch/x86/kernel/fpu/core.c | 3 ++ arch/x86/kernel/fpu/xstate.c | 53 +++++++++++++++++++++++-------- arch/x86/kernel/fpu/xstate.h | 13 ++++++-- arch/x86/kernel/process.c | 2 ++ 7 files changed, 80 insertions(+), 28 deletions(-)
arch/x86/include/asm/fpu/api.h +2 -0
@@ -132,6 +132,8 @@ static inline void fpstate_free(struct fpu *fpu) { }/* fpstate-related functions which are exported to KVM */ extern void fpstate_clear_xstate_component (struct fpstate *fps,unsigned int xfeature); +extern inline u64 xstate_get_guest_group_perm (void ); +/* KVM specific functions */ extern bool fpu_alloc_guest_fpstate (struct fpu_guest *gfpu);extern void fpu_free_guest_fpstate (struct fpu_guest *gfpu);
arch/x86/include/asm/fpu/types.h +9 -0
@@ -387,6 +387,8 @@ struct fpstate {/* @regs is dynamically sized! Don't add anything after @regs! */ }__aligned(64) ; +#define FPU_GUEST_PERM_LOCKED BIT_ULL(63) +struct fpu_state_perm {/* * @__state_perm:
@@ -476,6 +478,13 @@ struct fpu {*/ struct fpu_state_perm perm; +/* +* @guest_perm: +* +* Permission related information for guest pseudo FPUs +*/ +struct fpu_state_perm guest_perm; +/* * @__fpstate: *
arch/x86/include/uapi/asm/prctl.h +14 -12
@@ -2,20 +2,22 @@#ifndef _ASM_X86_PRCTL_H#define _ASM_X86_PRCTL_H -#define ARCH_SET_GS 0x1001 -#define ARCH_SET_FS 0x1002 -#define ARCH_GET_FS 0x1003 -#define ARCH_GET_GS 0x1004 +#define ARCH_SET_GS 0x1001 +#define ARCH_SET_FS 0x1002 +#define ARCH_GET_FS 0x1003 +#define ARCH_GET_GS 0x1004 -#define ARCH_GET_CPUID 0x1011 -#define ARCH_SET_CPUID 0x1012 +#define ARCH_GET_CPUID 0x1011 +#define ARCH_SET_CPUID 0x1012 -#define ARCH_GET_XCOMP_SUPP 0x1021 -#define ARCH_GET_XCOMP_PERM 0x1022 -#define ARCH_REQ_XCOMP_PERM 0x1023 +#define ARCH_GET_XCOMP_SUPP 0x1021 +#define ARCH_GET_XCOMP_PERM 0x1022 +#define ARCH_REQ_XCOMP_PERM 0x1023 +#define ARCH_GET_XCOMP_GUEST_PERM 0x1024 +#define ARCH_REQ_XCOMP_GUEST_PERM 0x1025 -#define ARCH_MAP_VDSO_X32 0x2001 -#define ARCH_MAP_VDSO_32 0x2002 -#define ARCH_MAP_VDSO_64 0x2003 +#define ARCH_MAP_VDSO_X32 0x2001 +#define ARCH_MAP_VDSO_32 0x2002 +#define ARCH_MAP_VDSO_64 0x2003#endif /* _ASM_X86_PRCTL_H */
arch/x86/kernel/fpu/core.c +3 -0
@@ -450,6 +450,8 @@ void fpstate_reset(struct fpu *fpu) fpu->perm.__state_perm = fpu_kernel_cfg.default_features; fpu->perm.__state_size = fpu_kernel_cfg.default_size; fpu->perm.__user_state_size = fpu_user_cfg.default_size; +/* Same defaults for guests */ + fpu->guest_perm = fpu->perm; }static inline void fpu_inherit_perms (struct fpu *dst_fpu)
@@ -460,6 +462,7 @@ static inline void fpu_inherit_perms(struct fpu *dst_fpu)spin_lock_irq (¤t->sighand->siglock);/* Fork also inherits the permissions of the parent */ dst_fpu->perm = src_fpu->perm; + dst_fpu->guest_perm = src_fpu->guest_perm;spin_unlock_irq (¤t->sighand->siglock); } }
arch/x86/kernel/fpu/xstate.c +39 -14
120 lines not on this page · raw message
arch/x86/kernel/fpu/xstate.h +11 -2
@@ -20,10 +20,19 @@ static inline void xstate_init_xcomp_bv(struct xregs_state *xsave, u64 mask) xsave->header.xcomp_bv = mask |XCOMP_BV_COMPACTED_FORMAT ; } -static inline u64 xstate_get_host_group_perm (void ) +static inline u64 xstate_get_group_perm (bool guest) { +struct fpu *fpu = ¤t->group_leader->thread.fpu; +struct fpu_state_perm *perm; +/* Pairs with WRITE_ONCE() in xstate_request_perm() */ -return READ_ONCE (current->group_leader->thread.fpu.perm.__state_perm); + perm = guest ? &fpu->guest_perm : &fpu->perm; +return READ_ONCE (perm->__state_perm); +} + +static inline u64 xstate_get_host_group_perm (void ) +{ +return xstate_get_group_perm (false); }enum xstate_copy_mode {
arch/x86/kernel/process.c +2 -0
@@ -993,6 +993,8 @@ long do_arch_prctl_common(struct task_struct *task, int option,case ARCH_GET_XCOMP_SUPP :case ARCH_GET_XCOMP_PERM :case ARCH_REQ_XCOMP_PERM : +case ARCH_GET_XCOMP_GUEST_PERM : +case ARCH_REQ_XCOMP_GUEST_PERM :return fpu_xstate_prctl (task, option, arg2); }
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 2/21 x86/fpu: Prepare guest FPU for dynamically enabled FPU features
In reply to Paolo BonziniFrom: Thomas Gleixner <[email protected]>
To support dynamically enabled FPU features for guests prepare the guest pseudo FPU container to keep track of the currently enabled xfeatures and the guest permissions.
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/types.h | 13 +++++++++++++ arch/x86/kernel/fpu/core.c | 26 +++++++++++++++++++++++++- 2 files changed, 38 insertions(+), 1 deletion(-)
arch/x86/include/asm/fpu/types.h +13 -0
@@ -504,6 +504,19 @@ struct fpu {* Guest pseudo FPU container */ struct fpu_guest { +/* +* @xfeatures: xfeature bitmap of features which are +* currently enabled for the guest vCPU. +*/ +u64 xfeatures; + +/* +* @perm: xfeature bitmap of features which are +* permitted to be enabled for the guest +* vCPU. +*/ +u64 perm; +/* * @fpstate: Pointer to the allocated guest fpstate */
arch/x86/kernel/fpu/core.c +25 -1
@@ -201,6 +201,26 @@ void fpu_reset_from_exception_fixup(void)#if IS_ENABLED (CONFIG_KVM )static void __fpstate_reset (struct fpstate *fpstate); +static void fpu_init_guest_permissions (struct fpu_guest *gfpu) +{ +struct fpu_state_perm *fpuperm; +u64 perm; + +if (!IS_ENABLED (CONFIG_X86_64 )) +return ; + +spin_lock_irq (¤t->sighand->siglock); + fpuperm = ¤t->group_leader->thread.fpu.guest_perm; + perm = fpuperm->__state_perm; + +/* First fpstate allocation locks down permissions. */ +WRITE_ONCE (fpuperm->__state_perm, perm |FPU_GUEST_PERM_LOCKED ); + +spin_unlock_irq (¤t->sighand->siglock); + + gfpu->perm = perm & ~FPU_GUEST_PERM_LOCKED ; +} +bool fpu_alloc_guest_fpstate (struct fpu_guest *gfpu) {struct fpstate *fpstate;
@@ -216,7 +236,11 @@ bool fpu_alloc_guest_fpstate(struct fpu_guest *gfpu) fpstate->is_valloc = true; fpstate->is_guest = true; - gfpu->fpstate = fpstate; + gfpu->fpstate = fpstate; + gfpu->xfeatures = fpu_user_cfg.default_features; + gfpu->perm = fpu_user_cfg.default_features; +fpu_init_guest_permissions (gfpu); +return true; }EXPORT_SYMBOL_GPL (fpu_alloc_guest_fpstate);
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 3/21 kvm: x86: Fix xstate_required_size() to follow XSTATE alignment rule
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
CPUID.0xD.1.EBX enumerates the size of the XSAVE area (in compacted format) required by XSAVES. If CPUID.0xD.i.ECX[1] is set for a state component (i), this state component should be located on the next 64-bytes boundary following the preceding state component in the compacted layout.
Fix xstate_required_size() to follow the alignment rule. AMX is the first state component with 64-bytes alignment to catch this bug.
Message-Id: <[email protected]>
--- arch/x86/kvm/cpuid.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
arch/x86/kvm/cpuid.c +5 -1
@@ -42,7 +42,11 @@ static u32 xstate_required_size(u64 xstate_bv, bool compacted)if (xstate_bv &0x1 ) {u32 eax, ebx, ecx, edx, offset;cpuid_count (0xD , feature_bit, &eax, &ebx, &ecx, &edx); - offset = compacted ? ret : ebx; +/* ECX[1]: 64B alignment in compacted form */ +if (compacted) + offset = (ecx &0x2 ) ?ALIGN (ret,64 ) : ret; +else + offset = ebx; ret =max (ret, offset + eax); }
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 4/21 kvm: x86: Exclude unpermitted xfeatures at KVM_GET_SUPPORTED_CPUID
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
KVM_GET_SUPPORTED_CPUID should not include any dynamic xstates in CPUID[0xD] if they have not been requested with prctl. Otherwise a process which directly passes KVM_GET_SUPPORTED_CPUID to KVM_SET_CPUID2 would now fail even if it doesn't intend to use a dynamically enabled feature. Userspace must know that prctl is required and allocate >4K xstate buffer before setting any dynamic bit.
Message-Id: <[email protected]>
--- Documentation/virt/kvm/api.rst | 4 ++++ arch/x86/kvm/cpuid.c | 9 ++++++--- 2 files changed, 10 insertions(+), 3 deletions(-)
Documentation/virt/kvm/api.rst +4 -0
@@ -1687,6 +1687,10 @@ userspace capabilities, and with user requirements (for example, the user may wish to constrain cpuid to emulate older hardware, or for feature consistency across a cluster). +Dynamically-enabled feature bits need to be requested with +``arch_prctl()`` before calling this ioctl. Feature bits that have not +been requested are excluded from the result. + Note that certain capabilities, such as KVM_CAP_X86_DISABLE_EXITS, may expose cpuid features (e.g. MONITOR) which are not supported by kvm in its default configuration. If userspace enables such capabilities, it
arch/x86/kvm/cpuid.c +6 -3
@@ -815,11 +815,13 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) goto out; }break ; -case 0xd : - entry->eax &= supported_xcr0; +case 0xd : { +u64 guest_perm =xstate_get_guest_group_perm (); + + entry->eax &= supported_xcr0 & guest_perm; entry->ebx =xstate_required_size (supported_xcr0, false); entry->ecx = entry->ebx; - entry->edx &= supported_xcr0 >>32 ; + entry->edx &= (supported_xcr0 & guest_perm) >>32 ;if (!supported_xcr0)break ;
@@ -866,6 +868,7 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) entry->edx =0 ; }break ; + }case 0x12 :/* Intel SGX */ if (!kvm_cpu_cap_has (X86_FEATURE_SGX )) {
Signature · 1 line
2.31.1
Re: [PATCH v6 04/21] kvm: x86: Exclude unpermitted xfeatures at KVM_GET_SUPPORTED_CPUID
Quoted 40 lines · Paolo Bonzini
From: Jing Liu <[email protected]>
KVM_GET_SUPPORTED_CPUIDshould not include any dynamic xstates in CPUID[0xD] if they have not been requested with prctl. Otherwise a process which directly passesKVM_GET_SUPPORTED_CPUIDtoKVM_SET_CPUID2would now fail even if it doesn't intend to use a dynamically enabled feature. Userspace must know that prctl is required and allocate >4K xstate buffer before setting any dynamic bit.Suggested-by Paolo Bonzini <[email protected]>Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>Message-Id: <[email protected]>
Signed-off-by Paolo Bonzini <[email protected]>--- Documentation/virt/kvm/api.rst | 4 ++++ arch/x86/kvm/cpuid.c | 9 ++++++--- 2 files changed, 10 insertions(+), 3 deletions(-)Documentation/virt/kvm/api.rst +4
-0@@ -1687,6 +1687,10 @@ userspace capabilities, and with user requirements (for example, the user may wish to constrain cpuid to emulate older hardware, or for feature consistency across a cluster). +Dynamically-enabled feature bits need to be requested with +``arch_prctl()`` before calling this ioctl. Feature bits that have not +been requested are excluded from the result. + Note that certain capabilities, such as KVM_CAP_X86_DISABLE_EXITS, may expose cpuid features (e.g. MONITOR) which are not supported by kvm in its default configuration. If userspace enables such capabilities, itarch/x86/kvm/cpuid.c +0
-0
arch/x86/kvm/cpuid.c static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) · line 822
Quoted 10 lines
arch/x86/kvm/cpuid.c +4
-2@@ -815,11 +815,13 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) goto out; }break ; -case 0xd : - entry->eax &= supported_xcr0; +case 0xd : { +u64 guest_perm =xstate_get_guest_group_perm (); + + entry->eax &= supported_xcr0 & guest_perm; entry->ebx =xstate_required_size (supported_xcr0, false);
If we choose to exclude unpermitted xfeatures in the entry->eax, why do we choose to expose the size of unpermitted xfeatures in ebx and ecx?
This seems to be an inconsistency, how about:
arch/x86/kvm/cpuid.c +3 -3
@@ -888,12 +888,12 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) }break ;case 0xd : { -u64 guest_perm =xstate_get_guest_group_perm (); +u64 supported_xcr0 = supported_xcr0 &xstate_get_guest_group_perm (); - entry->eax &= supported_xcr0 & guest_perm; + entry->eax &= supported_xcr0; entry->ebx =xstate_required_size (supported_xcr0, false); entry->ecx = entry->ebx; - entry->edx &= (supported_xcr0 & guest_perm) >>32 ; + entry->edx &= supported_xcr0 >>32 ;if (!supported_xcr0)break ;
It also helps to fix the CPUID_D_1_EBX and later for (i = 2; i < 64; ++i);
Is there anything I've missed ?
Quoted 14 lines
arch/x86/kvm/cpuid.c +2
-1entry->ecx = entry->ebx; - entry->edx &= supported_xcr0 >>32 ; + entry->edx &= (supported_xcr0 & guest_perm) >>32 ;if (!supported_xcr0)break ;@@ -866,6 +868,7 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) entry->edx =0 ; }break ; + }case 0x12 :/* Intel SGX */ if (!kvm_cpu_cap_has (X86_FEATURE_SGX )) {
RE: [PATCH v6 04/21] kvm: x86: Exclude unpermitted xfeatures at KVM_GET_SUPPORTED_CPUID
Quoted 86 lines
From: Like Xu <[email protected]>
Sent: Sunday, January 23, 2022 2:22 PMQuoted 13 lines · Paolo Bonzini
From: Jing Liu <[email protected]>
KVM_GET_SUPPORTED_CPUIDshould not include any dynamic xstates in CPUID[0xD] if they have not been requested with prctl. Otherwise a process which directly passesKVM_GET_SUPPORTED_CPUIDtoKVM_SET_CPUID2would now fail even if it doesn't intend to use a dynamically enabled feature. Userspace must know that prctl is required and allocate >4K xstate buffer before setting any dynamic bit.Suggested-by Paolo Bonzini <[email protected]>Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>Review
Quoted 8 lines
Message-Id: <[email protected]>
Signed-off-by Paolo Bonzini <[email protected]>--- Documentation/virt/kvm/api.rst | 4 ++++ arch/x86/kvm/cpuid.c | 9 ++++++--- 2 files changed, 10 insertions(+), 3 deletions(-)(quoted diff) +0
-0
b/Documentation/virt/kvm/api.rstDocumentation/virt/kvm/api.rst userspace capabilities, and with user
Quoted 4 lines
index
6b683dfea8f2..f4ea5e41a4d0100644Documentation/virt/kvm/api.rst +0
-0@@ -1687,6 +1687,10 @@ userspace capabilities, and with userrequirements (for example, the
arch/x86/kvm/cpuid.c static inline int __do_cpuid_func(struct
Quoted 15 lines
Documentation/virt/kvm/api.rst +4
-0user may wish to constrain cpuid to emulate older hardware, or for feature consistency across a cluster). +Dynamically-enabled feature bits need to be requested with +``arch_prctl()`` before calling this ioctl. Feature bits that have not +been requested are excluded from the result. + Note that certain capabilities, such as KVM_CAP_X86_DISABLE_EXITS, may expose cpuid features (e.g. MONITOR) which are not supported by kvm in its default configuration. If userspace enables such capabilities, itarch/x86/kvm/cpuid.c +0
-0@@ -815,11 +815,13 @@ static inline int __do_cpuid_func(struct
kvm_cpuid_array*array, u32 function)arch/x86/kvm/cpuid.c static inline int __do_cpuid_func(struct · line 822
Quoted 10 lines
arch/x86/kvm/cpuid.c +4
-2goto out; }break ; -case 0xd : - entry->eax &= supported_xcr0; +case 0xd : { +u64 guest_perm =xstate_get_guest_group_perm (); + + entry->eax &= supported_xcr0 & guest_perm; entry->ebx =xstate_required_size (supported_xcr0, false);If we choose to exclude unpermitted xfeatures in the
entry->eax, why do we choose to expose the size of unpermitted xfeatures in ebx and ecx?This seems to be an inconsistency, how about:
arch/x86/kvm/cpuid.c +0
-0@@ -888,12 +888,12 @@ static inline int __do_cpuid_func(struct
kvm_cpuid_array
*array, u32 function)
}
break;
case0xd: {arch/x86/kvm/cpuid.c +1
-1-u64 guest_perm =xstate_get_guest_group_perm (); + u64 supported_xcr0 = supported_xcr0 &
xstate_get_guest_group_perm();arch/x86/kvm/cpuid.c +2
-2- entry->eax &= supported_xcr0 & guest_perm; + entry->eax &= supported_xcr0; entry->ebx =xstate_required_size (supported_xcr0, false); entry->ecx = entry->ebx; - entry->edx &= (supported_xcr0 & guest_perm) >>32 ; + entry->edx &= supported_xcr0 >>32 ;if (!supported_xcr0)break ;
Quoted 3 lines
It also helps to fix the
CPUID_D_1_EBXand later for (i = 2; i < 64; ++i);Is there anything I've missed ?
No, you are correct. Would you please send out a formal fix?
Quoted 16 lines
arch/x86/kvm/cpuid.c static inline int __do_cpuid_func(struct
Quoted 8 lines
arch/x86/kvm/cpuid.c +1
-1entry->ecx = entry->ebx; - entry->edx &= supported_xcr0 >>32 ; + entry->edx &= (supported_xcr0 & guest_perm) >>32 ;if (!supported_xcr0)break ;@@ -866,6 +868,7 @@ static inline int __do_cpuid_func(struct
kvm_cpuid_array*array, u32 function)Quoted 7 lines
arch/x86/kvm/cpuid.c +1
-0entry->edx =0 ; }break ; + }case 0x12 :/* Intel SGX */ if (!kvm_cpu_cap_has (X86_FEATURE_SGX )) {
Paolo Bonzini
maintainerPATCH v6 5/21 x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
vCPU threads are different from native tasks regarding to the initial XFD value. While all native tasks follow a fixed value (init_fpstate::xfd) established by the FPU core at boot, vCPU threads need to obey the reset value (i.e. ZERO) defined by the specification, to meet the expectation of the guest.
Let the caller supply an argument and adjust the host and guest related invocations accordingly.
Message-Id: <[email protected]>
--- arch/x86/kernel/fpu/core.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
arch/x86/kernel/fpu/core.c +6 -5
@@ -199,7 +199,7 @@ void fpu_reset_from_exception_fixup(void) }#if IS_ENABLED (CONFIG_KVM ) -static void __fpstate_reset (struct fpstate *fpstate); +static void __fpstate_reset (struct fpstate *fpstate,u64 xfd);static void fpu_init_guest_permissions (struct fpu_guest *gfpu) {
@@ -231,7 +231,8 @@ bool fpu_alloc_guest_fpstate(struct fpu_guest *gfpu)if (!fpstate)return false; -__fpstate_reset (fpstate); +/* Leave xfd to 0 (the reset value defined by spec) */ +__fpstate_reset (fpstate,0 );fpstate_init_user (fpstate); fpstate->is_valloc = true; fpstate->is_guest = true;
@@ -454,21 +455,21 @@ void fpstate_init_user(struct fpstate *fpstate)fpstate_init_fstate (fpstate); } -static void __fpstate_reset (struct fpstate *fpstate) +static void __fpstate_reset (struct fpstate *fpstate,u64 xfd) {/* Initialize sizes and feature masks */ fpstate->size = fpu_kernel_cfg.default_size; fpstate->user_size = fpu_user_cfg.default_size; fpstate->xfeatures = fpu_kernel_cfg.default_features; fpstate->user_xfeatures = fpu_user_cfg.default_features; - fpstate->xfd = init_fpstate.xfd; + fpstate->xfd = xfd; }void fpstate_reset (struct fpu *fpu) {/* Set the fpstate pointer to the default fpstate */ fpu->fpstate = &fpu->__fpstate; -__fpstate_reset (fpu->fpstate); +__fpstate_reset (fpu->fpstate, init_fpstate.xfd);/* Initialize the permission related info in fpu */ fpu->perm.__state_perm = fpu_kernel_cfg.default_features;
Signature · 1 line
2.31.1
Borislav Petkov
maintainerRe: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 8 lines · Paolo Bonzini
From: Jing Liu <[email protected]>
vCPU threads are different from native tasks regarding to the initial XFD value. While all native tasks follow a fixed value (
init_fpstate::xfd) established by the FPU core at boot, vCPU threads need to obey the reset value (i.e. ZERO) defined by the specification, to meet the expectation of the guest.
Quoted 4 lines
Let the caller supply an argument and adjust the host and guest related invocations accordingly.
Signed-off-by Thomas Gleixner <[email protected]>
If Jing is author, then tglx's SOB should come after Jing's to mean, tglx handled it further.
As it is now, it looks wrong.
Ditto for patches 10, 11, 12, 13.
Also, I wonder if all those Signed-off-by's do mean "handled" or Co-developed-by but I haven't tracked that particular pile so...
Quoted 4 lines
Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>Message-Id: <[email protected]>
Signed-off-by Paolo Bonzini <[email protected]>
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRE: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 15 lines
From: Borislav Petkov <[email protected]>
Sent: Saturday, January 8, 2022 3:44 AMQuoted 11 lines · Paolo Bonzini
From: Jing Liu <[email protected]>
vCPU threads are different from native tasks regarding to the initial XFD value. While all native tasks follow a fixed value (
init_fpstate::xfd) established by the FPU core at boot, vCPU threads need to obey the reset value (i.e. ZERO) defined by the specification, to meet the expectation of the guest.Let the caller supply an argument and adjust the host and guest related invocations accordingly.
Quoted 6 lines
Quoted 1 line
Signed-off-by Thomas Gleixner <[email protected]>If Jing is author, then tglx's SOB should come after Jing's to mean, tglx handled it further.
As it is now, it looks wrong.
Thanks for pointing it out! Actually this is one area which we didn't get a clear answer from 'submitting-patches.rst' and now possibly a good chance to get it clarified.
This patch was handled in an interesting way due to Jing's two absences:
Internal version: Jing was the original author
--- Jing's first absence ---
v1: Yang was the submitter:
Thomas updated it in his personal branch when reviewing v1:
From: Jing Liu <[email protected]>
--- Jing was back ---
v2-v3: Jing was the submitter:
The open here is whether Jing should change the SoB order:
or just append her name again:
The former was selected for this patch.
--- Jing's 2nd absence ---
v4-v5: Yang was the submitter.
SoB order was partially changed (for Yang's SoB) but forgot to make Jing's SoB as the first. It should be:
From: Jing Liu <[email protected]>
If the rule is that SoB order should not be changed, then it will be:
From: Jing Liu <[email protected]>
Quoted 16 lines
Ditto for patches 10, 11, 12, 13.
Also, I wonder if all those Signed-off-by's do mean "handled" or Co-developed-by but I haven't tracked that particular pile so...
Quoted 4 lines
Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>Message-Id: <[email protected]>
Signed-off-by Paolo Bonzini <[email protected]>--
Regards/Gruss,
Boris.
Borislav Petkov
maintainerRe: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 2 lines · Kevin
Thanks for pointing it out! Actually this is one area which we didn't get a clear answer from '
submitting-patches.rst'
Are you sure?
I see
"Any further SoBs (Signed-off-by:'s) following the author's SoB are from people handling and transporting the patch, but were not involved in its development. SoB chains should reflect the **real** route a patch took as it was propagated to the maintainers and ultimately to Linus, with the first SoB entry signalling primary authorship of a single author."
Now, when you read that paragraph, what do you think is the answer to your question and why?
And if that paragraph doesn't make it clear, we would have to improve it...
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePaolo Bonzini
maintainerRe: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 11 lines · Borislav Petkov
Quoted 2 lines · Kevin
Thanks for pointing it out! Actually this is one area which we didn't get a clear answer from '
submitting-patches.rst'Are you sure? I see
"Any further SoBs (Signed-off-by:'s) following the author's SoB are from people handling and transporting the patch, but were not involved in its development. SoB chains should reflect the **real** route a patch took as it was propagated to the maintainers and ultimately to Linus, with the first SoB entry signalling primary authorship of a single author."
Say a patch went A->B->C->A->D and all of {A,B,C} were involved in the development at different times. The above text says "any further SoBs are from people not involved in its development", in other words it doesn't cover the case of multiple people handling different versions of a patch submission.
The only clear thing from the text would be "do not remove/move the author's Signed-off-by", but apart from that it's wild wild west and there are contradictions everywhere.
For example:
1) checkpatch.pl wants "Co-developed-by" to be immediately followed by "Signed-off-by". Should we imply that all SoB entries preceded by Co-developed-by do not exactly reflect the route that the patch took (since there could be multiple back and forth)?
2) if the author sends the patches but has co-developers, should they be first (because they're the author) or last (because they're the one actually sending the patch out)?
Any consistent rules that I could come up with are too baroque to be practical:
1) a sequence consisting of {SoB,Co-developed-by,SoB} does not necessarily reflect a chain from the first signoff to the second signoff
2) if you are a maintainer committing a patch so that it will go to Linus, just add your SoB line.
3) if you pick up someone else's branch or posted series, and you are not in the existing SoB chain, you must add a Co-developed-by and SoB line for yourself. Do not use the document the changes in brackets: that is only done by the maintainers when they make changes and do not repost for review.
The maintainers must already have a bad case of Stockholm syndrome for not having automated this kind of routine check, but it would be even worse if we were to inflict this on the developers. In the end, IMHO the real rules that matter are:
- there should be a SoB line for the author
- the submitter must always have the last SoB line
- SoB lines shall never be removed
- maintainers should prefer merge commits when moving commits from one tree to the other
- merge commits should have a SoB line too
Everything else, including the existence of Co-developed-by lines, is an unnecessary complication.
Paolo
Borislav Petkov
maintainerRe: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 5 lines · Paolo Bonzini
Say a patch went
A->B->C->A->Dand all of {A,B,C} were involved in the development at different times. The above text says "any further SoBs are from people not involved in its development", in other words it doesn't cover the case of multiple people handling different versions of a patch submission.
Well, if I'm reading Kevin's mail correctly, it sounds like Thomas updated it (and I'm pretty sure he doesn't care about Co-developed-by) and the rest of the folks simply handled it.
In the interest of remaining practical, I'd say one doesn't have to add Co-developed-by when one is doing contextual changes or addressing minor review feedback, or, of course, simply handling the patch as part of a series.
Quoted 3 lines
The only clear thing from the text would be "do not remove/move the author's Signed-off-by", but apart from that it's wild wild west and there are contradictions everywhere.
The main point in that paragraph is that the SOB chain needs to denote how that patch went upstream and who handled it on the way. So you can't simply shorten or reorder the SOBs.
What is more, even if you cherry-pick a patch which doesn't have your SOB at the end - for example, tglx applies a patch and I cherry-pick it into a different branch - I must add my SOB because, well, I handled it.
Quoted 6 lines
For example:
1) checkpatch.pl wants "Co-developed-by" to be immediately followed by "Signed-off-by". Should we imply that all SoB entries preceded by Co-developed-by do not exactly reflect the route that the patch took (since there could be multiple back and forth)?
Co-developed-by is to express multiple-people's authorship. And that rule checkpatch enforces is already in submitting-patches:
"Since Co-developed-by: denotes authorship, every Co-developed-by:
must be immediately followed by a Signed-off-by: of the associated co-author."
Quoted 4 lines
2) if the author sends the patches but has co-developers, should they be first (because they're the author) or last (because they're the one actually sending the patch out)?
That is also explained there:
"Standard sign-off procedure applies, i.e. the ordering of
Signed-off-by: tags should reflect the chronological history of the patch insofar as possible, regardless of whether the author is attributed via From: or Co-developed-by:. Notably, the last
Signed-off-by: must always be that of the developer submitting the patch."
Quoted 5 lines
Any consistent rules that I could come up with are too baroque to be practical:
1) a sequence consisting of {SoB,Co-developed-by,SoB} does not necessarily reflect a chain from the first signoff to the second signoff
Right, if you want to attribute co-authorship too - at least I think this is what you mean - then you can do that according to the last snippet I pasted. IOW, you'd need to do:
Co-developed-by: A
SOB: A
Co-developed-by: B
SOB: B
SOB: C
etc.
Or remain practical and do only an SOB chain. But it all depends on who has co-authored what and what kind of attribution the co-authors/handlers prefer.
Quoted 2 lines
2) if you are a maintainer committing a patch so that it will go to Linus, just add your SoB line.
Ack.
Quoted 3 lines
3) if you pick up someone else's branch or posted series, and you are not in the existing SoB chain, you must add a Co-developed-by and SoB line for yourself.
Just SOB, as stated above. Because you handled the patch.
Quoted 3 lines
The maintainers must already have a bad case of Stockholm syndrome for not having automated this kind of routine check, but it would be even worse if we were to inflict this on the developers.
Well, usually, the SOB chain is pretty simple and straight-forward.
In this particular case, I'd simply add my SOB when I've handled the patch. If I've done big changes and I think I'd like to be listed as an author, I'd do Co-developed but other than that, just the SOB.
Quoted 4 lines
In the end, IMHO the real rules
that matter are:- there should be a SoB line for the author
Yap.
Quoted 1 line
- the submitter must always have the last SoB line
Yap.
Quoted 1 line
- SoB lines shall never be removed
And their order should be kept too as the path upstream is important, obviously.
Quoted 2 lines
- maintainers should prefer merge commits when moving commits from one tree to the other
It depends.
Quoted 1 line
- merge commits should have a SoB line too
Yap, we do that in the tip tree and document the reason for the merge commit.
Quoted 2 lines
Everything else, including the existence of Co-developed-by lines, is an unnecessary complication.
See above.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePaolo Bonzini
maintainerRe: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 6 lines · Borislav Petkov
"Standard sign-off procedure applies, i.e. the ordering of
Signed-off-by: tags should reflect the chronological history of the patch insofar as possible, regardless of whether the author is attributed via From: or Co-developed-by:. Notably, the last
Signed-off-by: must always be that of the developer submitting the patch."
So this means that "the author must be the first SoB" is not an absolute rule. In the case of this patch we had:
From: Jing Liu <[email protected]>
...
and the possibilities could be:
1) have two SoB lines for Jing (before and after Thomas)
2) add a Co-developed-by for Thomas as the first line
3) do exactly what the gang did ("remain practical and do only an SOB chain")
Paolo
Borislav Petkov
maintainerRe: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 8 lines · Paolo Bonzini
So this means that "the author must be the first SoB" is not an absolute rule. In the case of this patch we had:
From: Jing Liu <[email protected]>
...Signed-off-by Thomas Gleixner <[email protected]>Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>
Looking at Kevin's explanation, that should be:
Quoted 5 lines
and the possibilities could be:
1) have two SoB lines for Jing (before and after Thomas)
2) add a Co-developed-by for Thomas as the first line
If Thomas would prefer. But then it becomes:
Signed-off-by: Thomas Gleixner <[email protected]> # handler/reviewer Signed-off-by: Jing Liu <[email protected]> # v2-v3 submitter Signed-off-by: Yang Zhong <[email protected]> # v4-v5 submitter
and that means, Thomas worked on that patch *after* Yang submitted v1. Which is the exact chronological order, as Kevin writes.
Quoted 2 lines
3) do exactly what the gang did ("remain practical and do only an SOB chain")
Yes, but not change the SOB order.
Because if you do that, then it doesn't state what the exact path was the patch took and how it ended up upstream. And due to past fun stories with SCO, we want to track exactly how a patch ended up upstream. And I think this is the most important aspect of those SOB chains.
IMNSVHO.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRE: [PATCH v6 05/21] x86/fpu: Make XFD initialization in __fpstate_reset() a function argument
Quoted 42 lines
From: Borislav Petkov <[email protected]>
Sent: Tuesday, January 11, 2022 2:19 AMQuoted 8 lines · Paolo Bonzini
So this means that "the author must be the first SoB" is not an absolute rule. In the case of this patch we had:
From: Jing Liu <[email protected]>
...Signed-off-by Thomas Gleixner <[email protected]>Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>Looking at Kevin's explanation, that should be:
Signed-off-by Jing Liu <[email protected]> # authorSigned-off-by Yang Zhong <[email protected]> # v1 submitterSigned-off-by Thomas Gleixner <[email protected]> # handler/reviewerSigned-off-by Jing Liu <[email protected]> # v2-v3 submitterSigned-off-by Yang Zhong <[email protected]> # v4-v5 submitterQuoted 5 lines
and the possibilities could be:
1) have two SoB lines for Jing (before and after Thomas)
2) add a Co-developed-by for Thomas as the first line
If Thomas would prefer. But then it becomes:
Signed-off-by Jing Liu <[email protected]> # authorSigned-off-by Yang Zhong <[email protected]> # v1 submitterCo-developed-by Thomas Gleixner <[email protected]> # co-authorSigned-off-by: Thomas Gleixner <[email protected]> # handler/reviewer Signed-off-by: Jing Liu <[email protected]> # v2-v3 submitter Signed-off-by: Yang Zhong <[email protected]> # v4-v5 submitterand that means, Thomas worked on that patch *after* Yang submitted v1. Which is the exact chronological order, as Kevin writes.
Quoted 2 lines
3) do exactly what the gang did ("remain practical and do only an SOB chain")
Quoted 7 lines
Yes, but not change the SOB order.
Because if you do that, then it doesn't state what the exact path was the patch took and how it ended up upstream. And due to past fun stories with SCO, we want to track exactly how a patch ended up upstream. And I think this is the most important aspect of those SOB chains.
This is exactly what we'd like to get clarified in this very special case.
Since Thomas didn't put a Co-developed-by in the first place, I prefer to respecting his choice i.e.:
From: Jing Liu <[email protected]>
Following this rule then the SoB order in all other patches also need be fixed, e.g. both Jing's name and Yang's name will occur twice to reflect the chronological order in most patches. But I'm not sure what's the best way to handle it since Paolo already puts the entire series in his tip.
Can this series gets an exempt given all participated names already have their SoB in this special case?
If must be fixed we can certainly provide updated SoB history for every patch. The burden might be on Paolo's side and if it does happen I really want to say sorry here for not getting this open clarified earlier...
Thanks
Kevin
Paolo Bonzini
maintainerPATCH v6 6/21 x86/fpu: Add guest support to xfd_enable_feature()
In reply to Paolo BonziniFrom: Thomas Gleixner <[email protected]>
Guest support for dynamically enabled FPU features requires a few modifications to the enablement function which is currently invoked from the #NM handler:
1) Use guest permissions and sizes for the update
2) Update fpu_guest state accordingly
3) Take into account that the enabling can be triggered either from a running guest via XSETBV and MSR_IA32_XFD write emulation or from a guest restore. In the latter case the guests fpstate is not the current tasks active fpstate.
Split the function and implement the guest mechanics throughout the callchain.
Message-Id: <[email protected]>
--- arch/x86/kernel/fpu/xstate.c | 93 +++++++++++++++++++++--------------- arch/x86/kernel/fpu/xstate.h | 6 +++ 2 files changed, 60 insertions(+), 39 deletions(-)
arch/x86/kernel/fpu/xstate.c +54 -39
@@ -1499,29 +1499,6 @@ void fpstate_free(struct fpu *fpu)vfree (fpu->fpstate); } -/** -* fpu_install_fpstate - Update the active fpstate in the FPU -* -* @fpu: A struct fpu * pointer -* @newfps: A struct fpstate * pointer -* -* Returns: A null pointer if the last active fpstate is the embedded -* one or the new fpstate is already installed; -* otherwise, a pointer to the old fpstate which has to -* be freed by the caller. -*/ -static struct fpstate *fpu_install_fpstate (struct fpu *fpu, -struct fpstate *newfps) -{ -struct fpstate *oldfps = fpu->fpstate; - -if (fpu->fpstate == newfps) -return NULL ; - - fpu->fpstate = newfps; -return oldfps != &fpu->__fpstate ? oldfps :NULL ; -} -/** * fpstate_realloc - Reallocate struct fpstate for the requested new features *
@@ -1529,6 +1506,7 @@ static struct fpstate *fpu_install_fpstate(struct fpu *fpu,* of that task * @ksize: The required size for the kernel buffer * @usize: The required size for user space buffers +* @guest_fpu: Pointer to a guest FPU container. NULL for host allocations * * Note vs. vmalloc(): If the task with a vzalloc()-allocated buffer * terminates quickly, vfree()-induced IPIs may be a concern, but tasks
@@ -1537,13 +1515,13 @@ static struct fpstate *fpu_install_fpstate(struct fpu *fpu,* Returns: 0 on success, -ENOMEM on allocation error. */ static int fpstate_realloc (u64 xfeatures,unsigned int ksize, -unsigned int usize) +unsigned int usize,struct fpu_guest *guest_fpu) {struct fpu *fpu = ¤t->thread.fpu;struct fpstate *curfps, *newfps =NULL ;unsigned int fpsize; +bool in_use; - curfps = fpu->fpstate; fpsize = ksize +ALIGN (offsetof(struct fpstate , regs),64 ); newfps =vzalloc (fpsize);
@@ -1553,28 +1531,55 @@ static int fpstate_realloc(u64 xfeatures, unsigned int ksize, newfps->user_size = usize; newfps->is_valloc = true; +/* +* When a guest FPU is supplied, use @guest_fpu->fpstate +* as reference independent whether it is in use or not. +*/ + curfps = guest_fpu ? guest_fpu->fpstate : fpu->fpstate; + +/* Determine whether @curfps is the active fpstate */ + in_use = fpu->fpstate == curfps; + +if (guest_fpu) { + newfps->is_guest = true; + newfps->is_confidential = curfps->is_confidential; + newfps->in_use = curfps->in_use; + guest_fpu->xfeatures |= xfeatures; + } +fpregs_lock ();/* -* Ensure that the current state is in the registers before -* swapping fpstate as that might invalidate it due to layout -* changes. +* If @curfps is in use, ensure that the current state is in the +* registers before swapping fpstate as that might invalidate it +* due to layout changes. */ -if (test_thread_flag (TIF_NEED_FPU_LOAD )) +if (in_use &&test_thread_flag (TIF_NEED_FPU_LOAD ))fpregs_restore_userregs (); newfps->xfeatures = curfps->xfeatures | xfeatures; newfps->user_xfeatures = curfps->user_xfeatures | xfeatures; newfps->xfd = curfps->xfd & ~xfeatures; - curfps =fpu_install_fpstate (fpu, newfps); -/* Do the final updates within the locked region */ xstate_init_xcomp_bv (&newfps->regs.xsave, newfps->xfeatures); -xfd_update_state (newfps); +if (guest_fpu) { + guest_fpu->fpstate = newfps; +/* If curfps is active, update the FPU fpstate pointer */ +if (in_use) + fpu->fpstate = newfps; + }else { + fpu->fpstate = newfps; + } + +if (in_use) +xfd_update_state (fpu->fpstate);fpregs_unlock (); -vfree (curfps); +/* Only free valloc'ed state */ +if (curfps && curfps->is_valloc) +vfree (curfps); +return 0 ; }
@@ -1682,14 +1687,16 @@ static int xstate_request_perm(unsigned long idx, bool guest)return ret; } -int xfd_enable_feature (u64 xfd_err) +int __xfd_enable_feature (u64 xfd_err,struct fpu_guest *guest_fpu) {u64 xfd_event = xfd_err &XFEATURE_MASK_USER_DYNAMIC ; +struct fpu_state_perm *perm;unsigned int ksize, usize;struct fpu *fpu;if (!xfd_event) { -pr_err_once ("XFD: Invalid xfd error: %016llx\n" , xfd_err); +if (!guest_fpu) +pr_err_once ("XFD: Invalid xfd error: %016llx\n" , xfd_err);return 0 ; }
@@ -1697,14 +1704,16 @@ int xfd_enable_feature(u64 xfd_err)spin_lock_irq (¤t->sighand->siglock);/* If not permitted let it die */ -if ((xstate_get_host_group_perm () & xfd_event) != xfd_event) { +if ((xstate_get_group_perm (!!guest_fpu) & xfd_event) != xfd_event) {spin_unlock_irq (¤t->sighand->siglock);return -EPERM ; } fpu = ¤t->group_leader->thread.fpu; - ksize = fpu->perm.__state_size; - usize = fpu->perm.__user_state_size; + perm = guest_fpu ? &fpu->guest_perm : &fpu->perm; + ksize = perm->__state_size; + usize = perm->__user_state_size; +/* * The feature is permitted. State size is sufficient. Dropping * the lock is safe here even if more features are added from
@@ -1717,10 +1726,16 @@ int xfd_enable_feature(u64 xfd_err)* Try to allocate a new fpstate. If that fails there is no way * out. */ -if (fpstate_realloc (xfd_event, ksize, usize)) +if (fpstate_realloc (xfd_event, ksize, usize, guest_fpu))return -EFAULT ; return 0; } + +int xfd_enable_feature (u64 xfd_err) +{ +return __xfd_enable_feature (xfd_err,NULL ); +} +#else /* CONFIG_X86_64 */ static inline int xstate_request_perm (unsigned long idx,bool guest) {
arch/x86/kernel/fpu/xstate.h +6 -0
@@ -158,8 +158,14 @@ static inline void xfd_update_state(struct fpstate *fpstate) } } } + +extern int __xfd_enable_feature (u64 which,struct fpu_guest *guest_fpu);#else static inline void xfd_update_state (struct fpstate *fpstate) { } + +static inline int __xfd_enable_feature (u64 which,struct fpu_guest *guest_fpu) { +return -EPERM ; +}#endif /*
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 7/21 x86/fpu: Provide fpu_enable_guest_xfd_features() for KVM
In reply to Paolo BonziniFrom: Sean Christopherson <[email protected]>
Provide a wrapper for expanding the guest fpstate buffer according to requested xfeatures. KVM wants to call this wrapper to manage any dynamic xstate used by the guest.
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/api.h | 1 + arch/x86/kernel/fpu/core.c | 22 ++++++++++++++++++++++ 2 files changed, 23 insertions(+)
arch/x86/include/asm/fpu/api.h +1 -0
@@ -138,6 +138,7 @@ extern inline u64 xstate_get_guest_group_perm(void);extern bool fpu_alloc_guest_fpstate (struct fpu_guest *gfpu);extern void fpu_free_guest_fpstate (struct fpu_guest *gfpu);extern int fpu_swap_kvm_fpstate (struct fpu_guest *gfpu,bool enter_guest); +extern int fpu_enable_guest_xfd_features (struct fpu_guest *guest_fpu,u64 xfeatures);extern void fpu_copy_guest_fpstate_to_uabi (struct fpu_guest *gfpu,void *buf,unsigned int size,u32 pkru);extern int fpu_copy_uabi_to_guest_fpstate (struct fpu_guest *gfpu,const void *buf,u64 xcr0,u32 *vpkru);
arch/x86/kernel/fpu/core.c +22 -0
@@ -261,6 +261,28 @@ void fpu_free_guest_fpstate(struct fpu_guest *gfpu) }EXPORT_SYMBOL_GPL (fpu_free_guest_fpstate); +/* +* fpu_enable_guest_xfd_features - Check xfeatures against guest perm and enable +* @guest_fpu: Pointer to the guest FPU container +* @xfeatures: Features requested by guest CPUID +* +* Enable all dynamic xfeatures according to guest perm and requested CPUID. +* +* Return: 0 on success, error code otherwise +*/ +int fpu_enable_guest_xfd_features (struct fpu_guest *guest_fpu,u64 xfeatures) +{ +lockdep_assert_preemption_enabled (); + +/* Nothing to do if all requested features are already enabled. */ + xfeatures &= ~guest_fpu->xfeatures; +if (!xfeatures) +return 0 ; + +return __xfd_enable_feature (xfeatures, guest_fpu); +} +EXPORT_SYMBOL_GPL (fpu_enable_guest_xfd_features); +int fpu_swap_kvm_fpstate (struct fpu_guest *guest_fpu,bool enter_guest) {struct fpstate *guest_fps = guest_fpu->fpstate;
Signature · 1 line
2.31.1
RE: [PATCH v6 07/21] x86/fpu: Provide fpu_enable_guest_xfd_features() for KVM
Hi, Paolo,
Quoted 11 lines
From: Paolo Bonzini <[email protected]>
Sent: Saturday, January 8, 2022 2:55 AM(quoted diff) +2
-0+/* + * fpu_enable_guest_xfd_features - Check xfeatures against guest permand enable
arch/x86/kernel/fpu/core.c +4
-0+* @guest_fpu: Pointer to the guest FPU container +* @xfeatures: Features requested by guest CPUID +* +* Enable all dynamic xfeatures according to guest perm and requested CPUID.
arch/x86/kernel/fpu/core.c void fpu_free_guest_fpstate(struct fpu_guest *gfpu) · line 272
Quoted 3 lines
arch/x86/kernel/fpu/core.c +3
-0+* +* Return: 0 on success, error code otherwise +*/
Just a NIT. This function itself has nothing to do with guest CPUID which is a caller-side policy. It simply enable xfeatures per request.
Thanks
Kevin
Paolo Bonzini
maintainerPATCH v6 8/21 kvm: x86: Enable dynamic xfeatures at KVM_SET_CPUID2
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
KVM can request fpstate expansion in two approaches:
1) When intercepting guest updates to XCR0 and XFD MSR;
2) Before vcpu runs (e.g. at KVM_SET_CPUID2);
The first option doesn't waste memory for legacy guest if it doesn't support XFD. However doing so introduces more complexity and also imposes an order requirement in the restoring path, i.e. XCR0/XFD must be restored before XSTATE.
Given that the agreement is to do the static approach. This is considered a better tradeoff though it does waste 8K memory for legacy guest if its CPUID includes dynamically-enabled xfeatures.
Successful fpstate expansion requires userspace VMM to acquire guest xstate permissions before calling KVM_SET_CPUID2.
Also take the chance to adjust the indent in kvm_set_cpuid().
Message-Id: <[email protected]>
--- arch/x86/kvm/cpuid.c | 42 +++++++++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 13 deletions(-)
arch/x86/kvm/cpuid.c +29 -13
@@ -84,9 +84,12 @@ static inline struct kvm_cpuid_entry2 *cpuid_entry2_find(return NULL ; } -static int kvm_check_cpuid (struct kvm_cpuid_entry2 *entries,int nent) +static int kvm_check_cpuid (struct kvm_vcpu *vcpu, +struct kvm_cpuid_entry2 *entries, +int nent) {struct kvm_cpuid_entry2 *best; +u64 xfeatures;/* * The existing code assumes virtual address is 48-bit or 57-bit in the
@@ -100,7 +103,20 @@ static int kvm_check_cpuid(struct kvm_cpuid_entry2 *entries, int nent)return -EINVAL ; } -return 0 ; +/* +* Exposing dynamic xfeatures to the guest requires additional +* enabling in the FPU, e.g. to expand the guest XSAVE state size. +*/ + best =cpuid_entry2_find (entries, nent,0xd ,0 ); +if (!best) +return 0 ; + + xfeatures = best->eax | ((u64 )best->edx <<32 ); + xfeatures &=XFEATURE_MASK_USER_DYNAMIC ; +if (!xfeatures) +return 0 ; + +return fpu_enable_guest_xfd_features (&vcpu->arch.guest_fpu, xfeatures); }static void kvm_update_kvm_cpuid_base (struct kvm_vcpu *vcpu)
@@ -280,21 +296,21 @@ u64 kvm_vcpu_reserved_gpa_bits_raw(struct kvm_vcpu *vcpu)static int kvm_set_cpuid (struct kvm_vcpu *vcpu,struct kvm_cpuid_entry2 *e2,int nent) { -int r; +int r; - r =kvm_check_cpuid (e2, nent); -if (r) -return r; + r =kvm_check_cpuid (vcpu, e2, nent); +if (r) +return r; -kvfree (vcpu->arch.cpuid_entries); - vcpu->arch.cpuid_entries = e2; - vcpu->arch.cpuid_nent = nent; +kvfree (vcpu->arch.cpuid_entries); + vcpu->arch.cpuid_entries = e2; + vcpu->arch.cpuid_nent = nent; -kvm_update_kvm_cpuid_base (vcpu); -kvm_update_cpuid_runtime (vcpu); -kvm_vcpu_after_set_cpuid (vcpu); +kvm_update_kvm_cpuid_base (vcpu); +kvm_update_cpuid_runtime (vcpu); +kvm_vcpu_after_set_cpuid (vcpu); -return 0 ; +return 0 ; }/* when an old userspace process fills a new kernel module */
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 9/21 x86/fpu: Provide fpu_update_guest_xfd() for IA32_XFD emulation
In reply to Paolo BonziniFrom: Kevin Tian <[email protected]>
Guest XFD can be updated either in the emulation path or in the restore path.
Provide a wrapper to update guest_fpu::fpstate::xfd. If the guest fpstate is currently in-use, also update the per-cpu xfd cache and the actual MSR.
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/api.h | 6 ++++++ arch/x86/kernel/fpu/core.c | 12 ++++++++++++ 2 files changed, 18 insertions(+)
arch/x86/include/asm/fpu/api.h +6 -0
@@ -140,6 +140,12 @@ extern void fpu_free_guest_fpstate(struct fpu_guest *gfpu);extern int fpu_swap_kvm_fpstate (struct fpu_guest *gfpu,bool enter_guest);extern int fpu_enable_guest_xfd_features (struct fpu_guest *guest_fpu,u64 xfeatures); +#ifdef CONFIG_X86_64 +extern void fpu_update_guest_xfd (struct fpu_guest *guest_fpu,u64 xfd); +#else +static inline void fpu_update_guest_xfd (struct fpu_guest *guest_fpu,u64 xfd) { } +#endif +extern void fpu_copy_guest_fpstate_to_uabi (struct fpu_guest *gfpu,void *buf,unsigned int size,u32 pkru);extern int fpu_copy_uabi_to_guest_fpstate (struct fpu_guest *gfpu,const void *buf,u64 xcr0,u32 *vpkru);
arch/x86/kernel/fpu/core.c +12 -0
@@ -283,6 +283,18 @@ int fpu_enable_guest_xfd_features(struct fpu_guest *guest_fpu, u64 xfeatures) }EXPORT_SYMBOL_GPL (fpu_enable_guest_xfd_features); +#ifdef CONFIG_X86_64 +void fpu_update_guest_xfd (struct fpu_guest *guest_fpu,u64 xfd) +{ +fpregs_lock (); + guest_fpu->fpstate->xfd = xfd; +if (guest_fpu->fpstate->in_use) +xfd_update_state (guest_fpu->fpstate); +fpregs_unlock (); +} +EXPORT_SYMBOL_GPL (fpu_update_guest_xfd); +#endif /* CONFIG_X86_64 */ +int fpu_swap_kvm_fpstate (struct fpu_guest *guest_fpu,bool enter_guest) {struct fpstate *guest_fps = guest_fpu->fpstate;
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 10/21 kvm: x86: Add emulation for IA32_XFD
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
Intel's eXtended Feature Disable (XFD) feature allows the software to dynamically adjust fpstate buffer size for XSAVE features which have large state.
Because guest fpstate has been expanded for all possible dynamic xstates at KVM_SET_CPUID2, emulation of the IA32_XFD MSR is straightforward. For write just call fpu_update_guest_xfd() to update the guest fpu container once all the sanity checks are passed. For read simply return the cached value in the container.
Message-Id: <[email protected]>
--- arch/x86/kvm/x86.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
arch/x86/kvm/x86.c +27 -0
@@ -1377,6 +1377,7 @@ static const u32 msrs_to_save_all[] = {MSR_F15H_PERF_CTL3 ,MSR_F15H_PERF_CTL4 ,MSR_F15H_PERF_CTL5 ,MSR_F15H_PERF_CTR0 ,MSR_F15H_PERF_CTR1 ,MSR_F15H_PERF_CTR2 ,MSR_F15H_PERF_CTR3 ,MSR_F15H_PERF_CTR4 ,MSR_F15H_PERF_CTR5 , + MSR_IA32_XFD, };static u32 msrs_to_save[ARRAY_SIZE (msrs_to_save_all)];
@@ -3686,6 +3687,19 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)return 1 ; vcpu->arch.msr_misc_features_enables = data;break ; +#ifdef CONFIG_X86_64 +case MSR_IA32_XFD : +if (!msr_info->host_initiated && + !guest_cpuid_has (vcpu,X86_FEATURE_XFD )) +return 1 ; + +if (data & ~(XFEATURE_MASK_USER_DYNAMIC & + vcpu->arch.guest_supported_xcr0)) +return 1 ; + +fpu_update_guest_xfd (&vcpu->arch.guest_fpu, data); +break ; +#endif default :if (kvm_pmu_is_valid_msr (vcpu, msr))return kvm_pmu_set_msr (vcpu, msr_info);
@@ -4006,6 +4020,15 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)case MSR_K7_HWCR : msr_info->data = vcpu->arch.msr_hwcr;break ; +#ifdef CONFIG_X86_64 +case MSR_IA32_XFD : +if (!msr_info->host_initiated && + !guest_cpuid_has (vcpu,X86_FEATURE_XFD )) +return 1 ; + + msr_info->data = vcpu->arch.guest_fpu.fpstate->xfd; +break ; +#endif default :if (kvm_pmu_is_valid_msr (vcpu, msr_info->index))return kvm_pmu_get_msr (vcpu, msr_info);
@@ -6441,6 +6464,10 @@ static void kvm_init_msr_list(void) min(INTEL_PMC_MAX_GENERIC, x86_pmu.num_counters_gp)) continue;break ; +case MSR_IA32_XFD : +if (!kvm_cpu_cap_has (X86_FEATURE_XFD )) +continue ; +break ;default :break ; }
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 11/21 x86/fpu: Prepare xfd_err in struct fpu_guest
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
When XFD causes an instruction to generate #NM, IA32_XFD_ERR contains information about which disabled state components are being accessed. The #NM handler is expected to check this information and then enable the state components by clearing IA32_XFD for the faulting task (if having permission).
If the XFD_ERR value generated in guest is consumed/clobbered by the host before the guest itself doing so, it may lead to non-XFD-related #NM treated as XFD #NM in host (due to non-zero value in XFD_ERR), or XFD-related #NM treated as non-XFD #NM in guest (XFD_ERR cleared by the host #NM handler).
Introduce a new field in fpu_guest to save the guest xfd_err value. KVM is expected to save guest xfd_err before interrupt is enabled and restore it right before entering the guest (with interrupt disabled).
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/types.h | 5 +++++ 1 file changed, 5 insertions(+)
arch/x86/include/asm/fpu/types.h +5 -0
@@ -517,6 +517,11 @@ struct fpu_guest {*/ u64 perm; +/* +* @xfd_err: Save the guest value. +*/ +u64 xfd_err; +/* * @fpstate: Pointer to the allocated guest fpstate */
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 12/21 kvm: x86: Intercept #NM for saving IA32_XFD_ERR
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
Guest IA32_XFD_ERR is generally modified in two places:
- Set by CPU when #NM is triggered;
- Cleared by guest in its #NM handler;
Intercept #NM for the first case when a nonzero value is written to IA32_XFD. Nonzero indicates that the guest is willing to do dynamic fpstate expansion for certain xfeatures, thus KVM needs to manage and virtualize guest XFD_ERR properly. The vcpu exception bitmap is updated in XFD write emulation according to guest_fpu::xfd.
Save the current XFD_ERR value to the guest_fpu container in the #NM VM-exit handler. This must be done with interrupt disabled, otherwise the unsaved MSR value may be clobbered by host activity.
The saving operation is conducted conditionally only when guest_fpu:xfd includes a non-zero value. Doing so also avoids misread on a platform which doesn't support XFD but #NM is triggered due to L1 interception.
Queueing #NM to the guest is postponed to handle_exception_nmi(). This goes through the nested_vmx check so a virtual vmexit is queued instead when #NM is triggered in L2 but L1 wants to intercept it.
Restore the host value (always ZERO outside of the host #NM handler) before enabling interrupt.
Restore the guest value from the guest_fpu container right before entering the guest (with interrupt disabled).
Message-Id: <[email protected]>
--- arch/x86/kvm/vmx/vmcs.h | 5 +++++ arch/x86/kvm/vmx/vmx.c | 48 +++++++++++++++++++++++++++++++++++++++++ arch/x86/kvm/x86.c | 6 ++++++ 3 files changed, 59 insertions(+)
arch/x86/kvm/vmx/vmcs.h +5 -0
@@ -129,6 +129,11 @@ static inline bool is_machine_check(u32 intr_info)return is_exception_n (intr_info,MC_VECTOR ); } +static inline bool is_nm_fault (u32 intr_info) +{ +return is_exception_n (intr_info,NM_VECTOR ); +} +/* Undocumented: icebp/int1 */ static inline bool is_icebp (u32 intr_info) {
arch/x86/kvm/vmx/vmx.c +48 -0
84 lines not on this page · raw message
arch/x86/kvm/x86.c +6 -0
@@ -9952,6 +9952,9 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)if (test_thread_flag (TIF_NEED_FPU_LOAD ))switch_fpu_return (); +if (vcpu->arch.guest_fpu.xfd_err) +wrmsrl (MSR_IA32_XFD_ERR , vcpu->arch.guest_fpu.xfd_err); +if (unlikely (vcpu->arch.switch_db_regs)) {set_debugreg (0 ,7 );set_debugreg (vcpu->arch.eff_db[0 ],0 );
@@ -10015,6 +10018,9 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)static_call (kvm_x86_handle_exit_irqoff)(vcpu); +if (vcpu->arch.guest_fpu.xfd_err) +wrmsrl (MSR_IA32_XFD_ERR ,0 ); +/* * Consume any pending interrupts, including the possible source of * VM-Exit on SVM and any ticks that occur between VM-Exit and now.
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 13/21 kvm: x86: Emulate IA32_XFD_ERR for guest
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
Emulate read/write to IA32_XFD_ERR MSR.
Only the saved value in the guest_fpu container is touched in the emulation handler. Actual MSR update is handled right before entering the guest (with preemption disabled)
Message-Id: <[email protected]>
--- arch/x86/kvm/x86.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-)
arch/x86/kvm/x86.c +20 -1
@@ -1377,7 +1377,7 @@ static const u32 msrs_to_save_all[] = {MSR_F15H_PERF_CTL3 ,MSR_F15H_PERF_CTL4 ,MSR_F15H_PERF_CTL5 ,MSR_F15H_PERF_CTR0 ,MSR_F15H_PERF_CTR1 ,MSR_F15H_PERF_CTR2 ,MSR_F15H_PERF_CTR3 ,MSR_F15H_PERF_CTR4 ,MSR_F15H_PERF_CTR5 , - MSR_IA32_XFD, + MSR_IA32_XFD, MSR_IA32_XFD_ERR, };static u32 msrs_to_save[ARRAY_SIZE (msrs_to_save_all)];
@@ -3699,6 +3699,17 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)fpu_update_guest_xfd (&vcpu->arch.guest_fpu, data);break ; +case MSR_IA32_XFD_ERR : +if (!msr_info->host_initiated && + !guest_cpuid_has (vcpu,X86_FEATURE_XFD )) +return 1 ; + +if (data & ~(XFEATURE_MASK_USER_DYNAMIC & + vcpu->arch.guest_supported_xcr0)) +return 1 ; + + vcpu->arch.guest_fpu.xfd_err = data; +break ;#endif default :if (kvm_pmu_is_valid_msr (vcpu, msr))
@@ -4028,6 +4039,13 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info) msr_info->data = vcpu->arch.guest_fpu.fpstate->xfd;break ; +case MSR_IA32_XFD_ERR : +if (!msr_info->host_initiated && + !guest_cpuid_has (vcpu,X86_FEATURE_XFD )) +return 1 ; + + msr_info->data = vcpu->arch.guest_fpu.xfd_err; +break ;#endif default :if (kvm_pmu_is_valid_msr (vcpu, msr_info->index))
@@ -6465,6 +6483,7 @@ static void kvm_init_msr_list(void)continue ;break ;case MSR_IA32_XFD : +case MSR_IA32_XFD_ERR :if (!kvm_cpu_cap_has (X86_FEATURE_XFD ))continue ;break ;
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 14/21 kvm: x86: Disable RDMSR interception of IA32_XFD_ERR
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
This saves one unnecessary VM-exit in guest #NM handler, given that the MSR is already restored with the guest value before the guest is resumed.
Message-Id: <[email protected]>
--- arch/x86/kvm/vmx/vmx.c | 6 ++++++ arch/x86/kvm/vmx/vmx.h | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-)
arch/x86/kvm/vmx/vmx.c +6 -0
@@ -162,6 +162,7 @@ static u32 vmx_possible_passthrough_msrs[MAX_POSSIBLE_PASSTHROUGH_MSRS] = {MSR_FS_BASE ,MSR_GS_BASE ,MSR_KERNEL_GS_BASE , +MSR_IA32_XFD_ERR , #endifMSR_IA32_SYSENTER_CS , MSR_IA32_SYSENTER_ESP,
@@ -7288,6 +7289,11 @@ static void vmx_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu) } } +if (kvm_cpu_cap_has (X86_FEATURE_XFD )) +vmx_set_intercept_for_msr (vcpu,MSR_IA32_XFD_ERR ,MSR_TYPE_R , + !guest_cpuid_has (vcpu,X86_FEATURE_XFD )); + +set_cr4_guest_host_mask (vmx);vmx_write_encls_bitmap (vcpu,NULL );
arch/x86/kvm/vmx/vmx.h +1 -1
@@ -349,7 +349,7 @@ struct vcpu_vmx {struct lbr_desc lbr_desc;/* Save desired MSR intercept (read: pass-through) state */ -#define MAX_POSSIBLE_PASSTHROUGH_MSRS 13 +#define MAX_POSSIBLE_PASSTHROUGH_MSRS 14struct { DECLARE_BITMAP(read, MAX_POSSIBLE_PASSTHROUGH_MSRS); DECLARE_BITMAP(write, MAX_POSSIBLE_PASSTHROUGH_MSRS);
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 15/21 kvm: x86: Add XCR0 support for Intel AMX
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
Two XCR0 bits are defined for AMX to support XSAVE mechanism. Bit 17 is for tilecfg and bit 18 is for tiledata.
The value of XCR0[17:18] is always either 00b or 11b. Also, SDM recommends that only 64-bit operating systems enable Intel AMX by setting XCR0[18:17]. 32-bit host kernel never sets the tile bits in vcpu->arch.guest_supported_xcr0.
Message-Id: <[email protected]>
--- arch/x86/kvm/x86.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
arch/x86/kvm/x86.c +6 -1
@@ -211,7 +211,7 @@ static struct kvm_user_return_msrs __percpu *user_return_msrs;#define KVM_SUPPORTED_XCR0 (XFEATURE_MASK_FP | XFEATURE_MASK_SSE \ | XFEATURE_MASK_YMM | XFEATURE_MASK_BNDREGS \ | XFEATURE_MASK_BNDCSR | XFEATURE_MASK_AVX512 \ - | XFEATURE_MASK_PKRU) + | XFEATURE_MASK_PKRU | XFEATURE_MASK_XTILE)u64 __read_mostly host_efer;EXPORT_SYMBOL_GPL (host_efer);
@@ -1010,6 +1010,11 @@ static int __kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr)if ((xcr0 &XFEATURE_MASK_AVX512 ) !=XFEATURE_MASK_AVX512 )return 1 ; } + +if ((xcr0 &XFEATURE_MASK_XTILE ) && + ((xcr0 &XFEATURE_MASK_XTILE ) !=XFEATURE_MASK_XTILE )) +return 1 ; + vcpu->arch.xcr0 = xcr0;if ((xcr0 ^ old_xcr0) &XFEATURE_MASK_EXTEND )
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 16/21 kvm: x86: Add CPUID support for Intel AMX
In reply to Paolo BonziniFrom: Jing Liu <[email protected]>
Extend CPUID emulation to support XFD, AMX_TILE, AMX_INT8 and AMX_BF16. Adding those bits into kvm_cpu_caps finally activates all previous logics in this series.
Hide XFD on 32bit host kernels. Otherwise it leads to a weird situation where KVM tells userspace to migrate MSR_IA32_XFD and then rejects attempts to read/write the MSR.
Message-Id: <[email protected]>
--- arch/x86/include/asm/cpufeatures.h | 2 ++ arch/x86/kvm/cpuid.c | 27 +++++++++++++++++++++++++-- 2 files changed, 27 insertions(+), 2 deletions(-)
arch/x86/include/asm/cpufeatures.h +2 -0
@@ -299,7 +299,9 @@/* Intel-defined CPU features, CPUID level 0x00000007:1 (EAX), word 12 */ #define X86_FEATURE_AVX_VNNI (12*32+ 4)/* AVX VNNI instructions */ #define X86_FEATURE_AVX512_BF16 (12*32+ 5)/* AVX512 BFLOAT16 instructions */ +#define X86_FEATURE_AMX_BF16 (18*32+22)/* AMX bf16 Support */ #define X86_FEATURE_AMX_TILE (18*32+24)/* AMX tile Support */ +#define X86_FEATURE_AMX_INT8 (18*32+25)/* AMX int8 Support */ /* AMD-defined CPU features, CPUID level 0x80000008 (EBX), word 13 */ #define X86_FEATURE_CLZERO (13*32+ 0)/* CLZERO instruction */
arch/x86/kvm/cpuid.c +25 -2
@@ -442,9 +442,11 @@ void kvm_set_cpu_caps(void)#ifdef CONFIG_X86_64 unsigned int f_gbpages =F (GBPAGES );unsigned int f_lm =F (LM ); +unsigned int f_xfd =F (XFD );#else unsigned int f_gbpages =0 ;unsigned int f_lm =0 ; +unsigned int f_xfd =0 ;#endif memset (kvm_cpu_caps,0 ,sizeof (kvm_cpu_caps));
@@ -512,7 +514,8 @@ void kvm_set_cpu_caps(void)F (AVX512_4VNNIW ) |F (AVX512_4FMAPS ) |F (SPEC_CTRL ) |F (SPEC_CTRL_SSBD ) |F (ARCH_CAPABILITIES ) |F (INTEL_STIBP ) |F (MD_CLEAR ) |F (AVX512_VP2INTERSECT ) |F (FSRM ) | -F (SERIALIZE ) |F (TSXLDTRK ) |F (AVX512_FP16 ) +F (SERIALIZE ) |F (TSXLDTRK ) |F (AVX512_FP16 ) | +F (AMX_TILE ) |F (AMX_INT8 ) |F (AMX_BF16 ) );/* TSC_ADJUST and ARCH_CAPABILITIES are emulated in software. */
@@ -531,7 +534,7 @@ void kvm_set_cpu_caps(void) );kvm_cpu_cap_mask (CPUID_D_1_EAX , -F (XSAVEOPT ) |F (XSAVEC ) |F (XGETBV1 ) |F (XSAVES ) +F (XSAVEOPT ) |F (XSAVEC ) |F (XGETBV1 ) |F (XSAVES ) | f_xfd ); kvm_cpu_cap_init_scattered(CPUID_12_EAX,
@@ -657,6 +660,8 @@ static struct kvm_cpuid_entry2 *do_host_cpuid(struct kvm_cpuid_array *array,case 0x14 :case 0x17 :case 0x18 : +case 0x1d : +case 0x1e :case 0x1f :case 0x8000001d : entry->flags |=KVM_CPUID_FLAG_SIGNIFCANT_INDEX ;
@@ -929,6 +934,24 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) goto out; }break ; +/* Intel AMX TILE */ +case 0x1d : +if (!kvm_cpu_cap_has (X86_FEATURE_AMX_TILE )) { + entry->eax = entry->ebx = entry->ecx = entry->edx =0 ; +break ; + } + +for (i =1 , max_idx = entry->eax; i <= max_idx; ++i) { +if (!do_host_cpuid (array, function, i)) + goto out; + } +break ; +case 0x1e :/* TMUL information */ +if (!kvm_cpu_cap_has (X86_FEATURE_AMX_TILE )) { + entry->eax = entry->ebx = entry->ecx = entry->edx =0 ; +break ; + } +break ;case KVM_CPUID_SIGNATURE : {const u32 *sigptr = (const u32 *)KVM_SIGNATURE ; entry->eax =KVM_CPUID_FEATURES ;
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 17/21 x86/fpu: Add uabi_size to guest_fpu
In reply to Paolo BonziniFrom: Thomas Gleixner <[email protected]>
Userspace needs to inquire KVM about the buffer size to work with the new KVM_SET_XSAVE and KVM_GET_XSAVE2. Add the size info to guest_fpu for KVM to access.
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/types.h | 5 +++++ arch/x86/kernel/fpu/core.c | 1 + arch/x86/kernel/fpu/xstate.c | 1 + 3 files changed, 7 insertions(+)
arch/x86/include/asm/fpu/types.h +5 -0
@@ -522,6 +522,11 @@ struct fpu_guest {*/ u64 xfd_err; +/* +* @uabi_size: Size required for save/restore +*/ +unsigned int uabi_size; +/* * @fpstate: Pointer to the allocated guest fpstate */
arch/x86/kernel/fpu/core.c +1 -0
@@ -240,6 +240,7 @@ bool fpu_alloc_guest_fpstate(struct fpu_guest *gfpu) gfpu->fpstate = fpstate; gfpu->xfeatures = fpu_user_cfg.default_features; gfpu->perm = fpu_user_cfg.default_features; + gfpu->uabi_size = fpu_user_cfg.default_size;fpu_init_guest_permissions (gfpu);return true;
arch/x86/kernel/fpu/xstate.c +1 -0
@@ -1545,6 +1545,7 @@ static int fpstate_realloc(u64 xfeatures, unsigned int ksize, newfps->is_confidential = curfps->is_confidential; newfps->in_use = curfps->in_use; guest_fpu->xfeatures |= xfeatures; + guest_fpu->uabi_size = usize; }fpregs_lock ();
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 18/21 kvm: x86: Add support for getting/setting expanded xstate buffer
In reply to Paolo BonziniFrom: Guang Zeng <[email protected]>
With KVM_CAP_XSAVE, userspace uses a hardcoded 4KB buffer to get/set xstate data from/to KVM. This doesn't work when dynamic xfeatures (e.g. AMX) are exposed to the guest as they require a larger buffer size.
Introduce a new capability (KVM_CAP_XSAVE2). Userspace VMM gets the required xstate buffer size via KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2). KVM_SET_XSAVE is extended to work with both legacy and new capabilities by doing properly-sized memdup_user() based on the guest fpu container. KVM_GET_XSAVE is kept for backward-compatible reason. Instead, KVM_GET_XSAVE2 is introduced under KVM_CAP_XSAVE2 as the preferred interface for getting xstate buffer (4KB or larger size) from KVM (Link: https://lkml.org/lkml/2021/12/15/510)
Also, update the api doc with the new KVM_GET_XSAVE2 ioctl.
Message-Id: <[email protected]>
--- Documentation/virt/kvm/api.rst | 42 ++++++++++++++++++++++++++++-- arch/x86/include/uapi/asm/kvm.h | 16 +++++++++++- arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/cpuid.h | 2 ++ arch/x86/kvm/x86.c | 45 ++++++++++++++++++++++++++++++++- include/uapi/linux/kvm.h | 4 +++ 6 files changed, 106 insertions(+), 5 deletions(-)
Documentation/virt/kvm/api.rst +40 -2
@@ -1569,6 +1569,7 @@ otherwise it will return EBUSY error. struct kvm_xsave { __u32 region[1024]; + __u32 extra[0]; }; This ioctl would copy current vcpu's xsave struct to the userspace.
@@ -1577,7 +1578,7 @@ This ioctl would copy current vcpu's xsave struct to the userspace. 4.43 KVM_SET_XSAVE ------------------ -:Capability: KVM_CAP_XSAVE +:Capability: KVM_CAP_XSAVE and KVM_CAP_XSAVE2 :Architectures: x86 :Type: vcpu ioctl :Parameters: struct kvm_xsave (in)
@@ -1588,9 +1589,18 @@ This ioctl would copy current vcpu's xsave struct to the userspace. struct kvm_xsave { __u32 region[1024]; + __u32 extra[0]; }; -This ioctl would copy userspace's xsave struct to the kernel. +This ioctl would copy userspace's xsave struct to the kernel. It copies +as many bytes as are returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2), +when invoked on the vm file descriptor. The size value returned by +KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) will always be at least 4096. +Currently, it is only greater than 4096 if a dynamic feature has been +enabled with ``arch_prctl()``, but this may change in the future. + +The offsets of the state save areas in struct kvm_xsave follow the +contents of CPUID leaf 0xD on the host. 4.44 KVM_GET_XCRS
@@ -5535,6 +5545,34 @@ the trailing ``'\0'``, is indicated by ``name_size`` in the header. The Stats Data block contains an array of 64-bit values in the same order as the descriptors in Descriptors block. +4.42 KVM_GET_XSAVE2 +------------------ + +:Capability: KVM_CAP_XSAVE2 +:Architectures: x86 +:Type: vcpu ioctl +:Parameters: struct kvm_xsave (out) +:Returns: 0 on success, -1 on error + + +:: + + struct kvm_xsave { + __u32 region[1024]; + __u32 extra[0]; + }; + +This ioctl would copy current vcpu's xsave struct to the userspace. It +copies as many bytes as are returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) +when invoked on the vm file descriptor. The size value returned by +KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) will always be at least 4096. +Currently, it is only greater than 4096 if a dynamic feature has been +enabled with ``arch_prctl()``, but this may change in the future. + +The offsets of the state save areas in struct kvm_xsave follow the contents +of CPUID leaf 0xD on the host. + + 5. The kvm_run structure ========================
arch/x86/include/uapi/asm/kvm.h +15 -1
@@ -373,9 +373,23 @@ struct kvm_debugregs {__u64 reserved[9 ]; }; -/* for KVM_CAP_XSAVE */ +/* for KVM_CAP_XSAVE and KVM_CAP_XSAVE2 */ struct kvm_xsave { +/* +* KVM_GET_XSAVE2 and KVM_SET_XSAVE write and read as many bytes +* as are returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) +* respectively, when invoked on the vm file descriptor. +* +* The size value returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) +* will always be at least 4096. Currently, it is only greater +* than 4096 if a dynamic feature has been enabled with +* ``arch_prctl()``, but this may change in the future. +* +* The offsets of the state save areas in struct kvm_xsave follow +* the contents of CPUID leaf 0xD on the host. +*/ __u32 region[1024 ]; +__u32 extra[0 ]; };#define KVM_MAX_XCRS 16
arch/x86/kvm/cpuid.c +1 -1
@@ -32,7 +32,7 @@u32 kvm_cpu_caps[NR_KVM_CPU_CAPS ]__read_mostly ;EXPORT_SYMBOL_GPL (kvm_cpu_caps); -static u32 xstate_required_size (u64 xstate_bv,bool compacted) +u32 xstate_required_size (u64 xstate_bv,bool compacted) {int feature_bit =0 ;u32 ret =XSAVE_HDR_SIZE +XSAVE_HDR_OFFSET ;
arch/x86/kvm/cpuid.h +2 -0
@@ -30,6 +30,8 @@ int kvm_vcpu_ioctl_get_cpuid2(struct kvm_vcpu *vcpu,bool kvm_cpuid (struct kvm_vcpu *vcpu,u32 *eax,u32 *ebx,u32 *ecx,u32 *edx,bool exact_only); +u32 xstate_required_size (u64 xstate_bv,bool compacted); +int cpuid_query_maxphyaddr (struct kvm_vcpu *vcpu);u64 kvm_vcpu_reserved_gpa_bits_raw (struct kvm_vcpu *vcpu);
arch/x86/kvm/x86.c +44 -1
75 lines not on this page · raw message
include/uapi/linux/kvm.h +4 -0
@@ -1132,6 +1132,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_ARM_MTE 205#define KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM 206#define KVM_CAP_VM_GPA_BITS 207 +#define KVM_CAP_XSAVE2 208#ifdef KVM_CAP_IRQ_ROUTING
@@ -1622,6 +1623,9 @@ struct kvm_enc_region {#define KVM_S390_NORMAL_RESET _IO(KVMIO, 0xc3)#define KVM_S390_CLEAR_RESET _IO(KVMIO, 0xc4) +/* Available with KVM_CAP_XSAVE2 */ +#define KVM_GET_XSAVE2 _IOR(KVMIO, 0xcf, struct kvm_xsave) +struct kvm_s390_pv_sec_parm {__u64 origin;__u64 length;
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 19/21 kvm: selftests: Add support for KVM_CAP_XSAVE2
In reply to Paolo BonziniFrom: Wei Wang <[email protected]>
When KVM_CAP_XSAVE2 is supported, userspace is expected to allocate buffer for KVM_GET_XSAVE2 and KVM_SET_XSAVE using the size returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2).
Message-Id: <[email protected]>
--- tools/arch/x86/include/uapi/asm/kvm.h | 16 ++++- tools/include/uapi/linux/kvm.h | 3 + .../selftests/kvm/include/kvm_util_base.h | 2 + .../selftests/kvm/include/x86_64/processor.h | 10 +++ tools/testing/selftests/kvm/lib/kvm_util.c | 32 +++++++++ .../selftests/kvm/lib/x86_64/processor.c | 67 ++++++++++++++++++- .../testing/selftests/kvm/x86_64/evmcs_test.c | 2 +- tools/testing/selftests/kvm/x86_64/smm_test.c | 2 +- .../testing/selftests/kvm/x86_64/state_test.c | 2 +- .../kvm/x86_64/vmx_preemption_timer_test.c | 2 +- 10 files changed, 130 insertions(+), 8 deletions(-)
tools/arch/x86/include/uapi/asm/kvm.h +15 -1
@@ -373,9 +373,23 @@ struct kvm_debugregs {__u64 reserved[9 ]; }; -/* for KVM_CAP_XSAVE */ +/* for KVM_CAP_XSAVE and KVM_CAP_XSAVE2 */ struct kvm_xsave { +/* +* KVM_GET_XSAVE2 and KVM_SET_XSAVE write and read as many bytes +* as are returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) +* respectively, when invoked on the vm file descriptor. +* +* The size value returned by KVM_CHECK_EXTENSION(KVM_CAP_XSAVE2) +* will always be at least 4096. Currently, it is only greater +* than 4096 if a dynamic feature has been enabled with +* ``arch_prctl()``, but this may change in the future. +* +* The offsets of the state save areas in struct kvm_xsave follow +* the contents of CPUID leaf 0xD on the host. +*/ __u32 region[1024 ]; +__u32 extra[0 ]; };#define KVM_MAX_XCRS 16
tools/include/uapi/linux/kvm.h +3 -0
@@ -1131,6 +1131,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_EXIT_ON_EMULATION_FAILURE 204#define KVM_CAP_ARM_MTE 205#define KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM 206 +#define KVM_CAP_XSAVE2 207#ifdef KVM_CAP_IRQ_ROUTING
@@ -1551,6 +1552,8 @@ struct kvm_s390_ucas_mapping {/* Available with KVM_CAP_XSAVE */ #define KVM_GET_XSAVE _IOR(KVMIO, 0xa4, struct kvm_xsave)#define KVM_SET_XSAVE _IOW(KVMIO, 0xa5, struct kvm_xsave) +/* Available with KVM_CAP_XSAVE2 */ +#define KVM_GET_XSAVE2 _IOR(KVMIO, 0xcf, struct kvm_xsave)/* Available with KVM_CAP_XCRS */ #define KVM_GET_XCRS _IOR(KVMIO, 0xa6, struct kvm_xcrs)#define KVM_SET_XCRS _IOW(KVMIO, 0xa7, struct kvm_xcrs)
tools/testing/selftests/kvm/include/kvm_util_base.h +2 -0
@@ -103,6 +103,7 @@ extern const struct vm_guest_mode_params vm_guest_mode_params[];int open_path_or_exit (const char *path,int flags);int open_kvm_dev_path_or_exit (void );int kvm_check_cap (long cap); +int vm_check_cap (struct kvm_vm *vm,long cap);int vm_enable_cap (struct kvm_vm *vm,struct kvm_enable_cap *cap);int vcpu_enable_cap (struct kvm_vm *vm,uint32_t vcpu_id,struct kvm_enable_cap *cap);
@@ -344,6 +345,7 @@ struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,* guest_code - The vCPU's entry point */ void vm_vcpu_add_default (struct kvm_vm *vm,uint32_t vcpuid,void *guest_code); +void vm_xsave_req_perm (void );bool vm_is_unrestricted_guest (struct kvm_vm *vm);
tools/testing/selftests/kvm/include/x86_64/processor.h +10 -0
@@ -10,8 +10,10 @@#include <assert.h> #include <stdint.h> +#include <syscall.h> #include <asm/msr-index.h> +#include <asm/prctl.h> #include "../kvm_util.h"
@@ -352,6 +354,7 @@ struct kvm_x86_state;struct kvm_x86_state *vcpu_save_state (struct kvm_vm *vm,uint32_t vcpuid);void vcpu_load_state (struct kvm_vm *vm,uint32_t vcpuid,struct kvm_x86_state *state); +void kvm_x86_state_cleanup (struct kvm_x86_state *state);struct kvm_msr_list *kvm_get_msr_index_list (void );uint64_t kvm_get_feature_msr (uint64_t msr_index);
@@ -443,4 +446,11 @@ void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,/* VMX_EPT_VPID_CAP bits */ #define VMX_EPT_VPID_CAP_AD_BITS (1ULL << 21) +#define XSTATE_XTILE_CFG_BIT 17 +#define XSTATE_XTILE_DATA_BIT 18 + +#define XSTATE_XTILE_CFG_MASK (1ULL << XSTATE_XTILE_CFG_BIT) +#define XSTATE_XTILE_DATA_MASK (1ULL << XSTATE_XTILE_DATA_BIT) +#define XFEATURE_XTILE_MASK (XSTATE_XTILE_CFG_MASK | \ + XSTATE_XTILE_DATA_MASK)#endif /* SELFTEST_KVM_PROCESSOR_H */
tools/testing/selftests/kvm/lib/kvm_util.c +32 -0
@@ -85,6 +85,33 @@ int kvm_check_cap(long cap)return ret; } +/* VM Check Capability +* +* Input Args: +* vm - Virtual Machine +* cap - Capability +* +* Output Args: None +* +* Return: +* On success, the Value corresponding to the capability (KVM_CAP_*) +* specified by the value of cap. On failure a TEST_ASSERT failure +* is produced. +* +* Looks up and returns the value corresponding to the capability +* (KVM_CAP_*) given by cap. +*/ +int vm_check_cap (struct kvm_vm *vm,long cap) +{ +int ret; + + ret =ioctl (vm->fd,KVM_CHECK_EXTENSION , cap); +TEST_ASSERT (ret >=0 ,"KVM_CHECK_EXTENSION VM IOCTL failed,\n" +" rc: %i errno: %i" , ret, errno); + +return ret; +} +/* VM Enable Capability * * Input Args:
@@ -366,6 +393,11 @@ struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,struct kvm_vm *vm;int i; +/* +* Permission needs to be requested before KVM_SET_CPUID2. +*/ +vm_xsave_req_perm (); +/* Force slot0 memory size not small than DEFAULT_GUEST_PHY_PAGES */ if (slot0_mem_pages <DEFAULT_GUEST_PHY_PAGES ) slot0_mem_pages =DEFAULT_GUEST_PHY_PAGES ;
tools/testing/selftests/kvm/lib/x86_64/processor.c +64 -3
106 lines not on this page · raw message
tools/testing/selftests/kvm/x86_64/evmcs_test.c +1 -1
@@ -129,7 +129,7 @@ static void save_restore_vm(struct kvm_vm *vm)vcpu_set_hv_cpuid (vm,VCPU_ID );vcpu_enable_evmcs (vm,VCPU_ID );vcpu_load_state (vm,VCPU_ID , state); -free (state); +kvm_x86_state_cleanup (state);memset (®s2,0 ,sizeof (regs2));vcpu_regs_get (vm,VCPU_ID , ®s2);
tools/testing/selftests/kvm/x86_64/smm_test.c +1 -1
@@ -212,7 +212,7 @@ int main(int argc, char *argv[])vcpu_set_cpuid (vm,VCPU_ID ,kvm_get_supported_cpuid ());vcpu_load_state (vm,VCPU_ID , state); run =vcpu_state (vm,VCPU_ID ); -free (state); +kvm_x86_state_cleanup (state); } done:
tools/testing/selftests/kvm/x86_64/state_test.c +1 -1
@@ -218,7 +218,7 @@ int main(int argc, char *argv[])vcpu_set_cpuid (vm,VCPU_ID ,kvm_get_supported_cpuid ());vcpu_load_state (vm,VCPU_ID , state); run =vcpu_state (vm,VCPU_ID ); -free (state); +kvm_x86_state_cleanup (state);memset (®s2,0 ,sizeof (regs2));vcpu_regs_get (vm,VCPU_ID , ®s2);
tools/testing/selftests/kvm/x86_64/vmx_preemption_timer_test.c +1 -1
@@ -244,7 +244,7 @@ int main(int argc, char *argv[])vcpu_set_cpuid (vm,VCPU_ID ,kvm_get_supported_cpuid ());vcpu_load_state (vm,VCPU_ID , state); run =vcpu_state (vm,VCPU_ID ); -free (state); +kvm_x86_state_cleanup (state);memset (®s2,0 ,sizeof (regs2));vcpu_regs_get (vm,VCPU_ID , ®s2);
Signature · 1 line
2.31.1
Re: [PATCH v6 19/21] kvm: selftests: Add support for KVM_CAP_XSAVE2
Quoted 25 lines · Paolo Bonzini
From: Wei Wang <[email protected]>
When
KVM_CAP_XSAVE2is supported, userspace is expected to allocate buffer forKVM_GET_XSAVE2andKVM_SET_XSAVEusing the size returned byKVM_CHECK_EXTENSION(KVM_CAP_XSAVE2).Signed-off-by Wei Wang <[email protected]>Signed-off-by Guang Zeng <[email protected]>Signed-off-by Jing Liu <[email protected]>Signed-off-by Yang Zhong <[email protected]>Message-Id: <[email protected]>
Signed-off-by Paolo Bonzini <[email protected]>--- tools/arch/x86/include/uapi/asm/kvm.h | 16 ++++- tools/include/uapi/linux/kvm.h | 3 + .../selftests/kvm/include/kvm_util_base.h | 2 + .../selftests/kvm/include/x86_64/processor.h | 10 +++ tools/testing/selftests/kvm/lib/kvm_util.c | 32 +++++++++ .../selftests/kvm/lib/x86_64/processor.c | 67 ++++++++++++++++++- .../testing/selftests/kvm/x86_64/evmcs_test.c | 2 +- tools/testing/selftests/kvm/x86_64/smm_test.c | 2 +- .../testing/selftests/kvm/x86_64/state_test.c | 2 +- .../kvm/x86_64/vmx_preemption_timer_test.c | 2 +- 10 files changed, 130 insertions(+), 8 deletions(-)
[...]
Quoted 20 lines
tools/testing/selftests/kvm/include/kvm_util_base.h +2
-0@@ -103,6 +103,7 @@ extern const struct vm_guest_mode_params vm_guest_mode_params[];int open_path_or_exit (const char *path,int flags);int open_kvm_dev_path_or_exit (void );int kvm_check_cap (long cap); +int vm_check_cap (struct kvm_vm *vm,long cap);int vm_enable_cap (struct kvm_vm *vm,struct kvm_enable_cap *cap);int vcpu_enable_cap (struct kvm_vm *vm,uint32_t vcpu_id,struct kvm_enable_cap *cap);@@ -344,6 +345,7 @@ struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,* guest_code - The vCPU's entry point */ void vm_vcpu_add_default (struct kvm_vm *vm,uint32_t vcpuid,void *guest_code); +void vm_xsave_req_perm (void );bool vm_is_unrestricted_guest (struct kvm_vm *vm);
[...]
Quoted 39 lines
tools/testing/selftests/kvm/lib/kvm_util.c +27
-0@@ -85,6 +85,33 @@ int kvm_check_cap(long cap)return ret; } +/* VM Check Capability +* +* Input Args: +* vm - Virtual Machine +* cap - Capability +* +* Output Args: None +* +* Return: +* On success, the Value corresponding to the capability (KVM_CAP_*) +* specified by the value of cap. On failure a TEST_ASSERT failure +* is produced. +* +* Looks up and returns the value corresponding to the capability +* (KVM_CAP_*) given by cap. +*/ +int vm_check_cap (struct kvm_vm *vm,long cap) +{ +int ret; + + ret =ioctl (vm->fd,KVM_CHECK_EXTENSION , cap); +TEST_ASSERT (ret >=0 ,"KVM_CHECK_EXTENSION VM IOCTL failed,\n" +" rc: %i errno: %i" , ret, errno); + +return ret; +} +/* VM Enable Capability * * Input Args:
tools/testing/selftests/kvm/lib/kvm_util.c struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus, · line 400
Quoted 8 lines
tools/testing/selftests/kvm/lib/kvm_util.c +5
-0@@ -366,6 +393,11 @@ struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus,struct kvm_vm *vm;int i; +/* +* Permission needs to be requested before KVM_SET_CPUID2. +*/ +vm_xsave_req_perm (); +
Since
79e06c4c4950 (Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm)
on s390x I'm getting:
/usr/bin/ld: tools/testing/selftests/kvm/libkvm.a(kvm_util.o): in function `vm_create_with_vcpus':tools/testing/selftests/kvm/lib/kvm_util.c:399: undefined reference to `vm_xsave_req_perm'
collect2: error: ld returned 1 exit status
make: *** [../lib.mk:146: tools/testing/selftests/kvm/s390x/memop] Error 1
Looks like it only exists for x86.
v2 had a comment about unconditional enablement:
https://lore.kernel.org/kvm/[email protected]/
Thanks for having a look.
Quoted 50 lines
tools/testing/selftests/kvm/lib/kvm_util.c +0
-0/* Force slot0 memory size not small than DEFAULT_GUEST_PHY_PAGES */ if (slot0_mem_pages <DEFAULT_GUEST_PHY_PAGES ) slot0_mem_pages =DEFAULT_GUEST_PHY_PAGES ;tools/testing/selftests/kvm/lib/x86_64/processor.c +39
-0@@ -650,6 +650,45 @@ static void vcpu_setup(struct kvm_vm *vm, int vcpuid)vcpu_sregs_set (vm, vcpuid, &sregs); } +#define CPUID_XFD_BIT (1 << 4) +static bool is_xfd_supported (void ) +{ +int eax, ebx, ecx, edx; +const int leaf =0xd , subleaf =0x1 ; + + __asm__ __volatile__( +"cpuid" + :/* output */ "=a" (eax),"=b" (ebx), +"=c" (ecx),"=d" (edx) + :/* input */ "0" (leaf),"2" (subleaf)); + +return !!(eax &CPUID_XFD_BIT ); +} + +void vm_xsave_req_perm (void ) +{ +unsigned long bitmask; +long rc; + +if (!is_xfd_supported ()) +return ; + + rc =syscall (SYS_arch_prctl,ARCH_REQ_XCOMP_GUEST_PERM , +XSTATE_XTILE_DATA_BIT ); +/* +* The older kernel version(<5.15) can't support +* ARCH_REQ_XCOMP_GUEST_PERM and directly return. +*/ +if (rc) +return ; + + rc =syscall (SYS_arch_prctl,ARCH_GET_XCOMP_GUEST_PERM , &bitmask); +TEST_ASSERT (rc ==0 ,"prctl(ARCH_GET_XCOMP_GUEST_PERM) error: %ld" , rc); +TEST_ASSERT (bitmask &XFEATURE_XTILE_MASK , +"prctl(ARCH_REQ_XCOMP_GUEST_PERM) failure bitmask=0x%lx" , + bitmask); +} +
[...]
RE: [PATCH v6 19/21] kvm: selftests: Add support for KVM_CAP_XSAVE2
Quoted 20 lines · Janis Schoetterl-Glausch
tools/testing/selftests/kvm/lib/kvm_util.c struct kvm_vm *vm_create_with_vcpus(enum vm_guest_mode mode, uint32_t nr_vcpus, · line 400
Quoted 5 lines
tools/testing/selftests/kvm/lib/kvm_util.c +5
-0+/* +* Permission needs to be requested before KVM_SET_CPUID2. +*/ +vm_xsave_req_perm (); +Since
79e06c4c4950(Merge tag 'for-linus' ofgit://git.kernel.org/pub/scm/virt/kvm/kvm)on s390x I'm getting:
/usr/bin/ld: tools/testing/selftests/kvm/libkvm.a(kvm_util.o): in function `vm_create_with_vcpus':tools/testing/selftests/kvm/lib/kvm_util.c:399: undefined reference to `vm_xsave_req_perm'
collect2: error: ld returned 1 exit status
make: *** [../lib.mk:146:tools/testing/selftests/kvm/s390x/memop] Error 1
Quoted 7 lines
Looks like it only exists for x86.
v2 had a comment about unconditional enablement:
https://lore.kernel.org/kvm/e20f590b-b9d9-237d-3b9c-77dd82a24b40@redh
at.com/Thanks for having a look.
OK, we made it conditionally enabled at runtime, but this one requires conditionally compiled. I'll get you a patch to test soon.
Thanks,
Wei
Paolo Bonzini
maintainerPATCH v6 20/21 x86/fpu: Provide fpu_sync_guest_vmexit_xfd_state()
In reply to Paolo BonziniFrom: Thomas Gleixner <[email protected]>
KVM can disable the write emulation for the XFD MSR when the vCPU's fpstate is already correctly sized to reduce the overhead.
When write emulation is disabled the XFD MSR state after a VMEXIT is unknown and therefore not in sync with the software states in fpstate and the per CPU XFD cache.
Provide fpu_sync_guest_vmexit_xfd_state() which has to be invoked after a VMEXIT before enabling interrupts when write emulation is disabled for the XFD MSR.
It could be invoked unconditionally even when write emulation is enabled for the price of a pointless MSR read.
Message-Id: <[email protected]>
--- arch/x86/include/asm/fpu/api.h | 2 ++ arch/x86/kernel/fpu/core.c | 24 ++++++++++++++++++++++++ 2 files changed, 26 insertions(+)
arch/x86/include/asm/fpu/api.h +2 -0
@@ -142,8 +142,10 @@ extern int fpu_enable_guest_xfd_features(struct fpu_guest *guest_fpu, u64 xfeatu#ifdef CONFIG_X86_64 extern void fpu_update_guest_xfd (struct fpu_guest *guest_fpu,u64 xfd); +extern void fpu_sync_guest_vmexit_xfd_state (void );#else static inline void fpu_update_guest_xfd (struct fpu_guest *guest_fpu,u64 xfd) { } +static inline void fpu_sync_guest_vmexit_xfd_state (void ) { }#endif extern void fpu_copy_guest_fpstate_to_uabi (struct fpu_guest *gfpu,void *buf,unsigned int size,u32 pkru);
arch/x86/kernel/fpu/core.c +24 -0
@@ -294,6 +294,30 @@ void fpu_update_guest_xfd(struct fpu_guest *guest_fpu, u64 xfd) fpregs_unlock(); }EXPORT_SYMBOL_GPL (fpu_update_guest_xfd); + +/** +* fpu_sync_guest_vmexit_xfd_state - Synchronize XFD MSR and software state +* +* Must be invoked from KVM after a VMEXIT before enabling interrupts when +* XFD write emulation is disabled. This is required because the guest can +* freely modify XFD and the state at VMEXIT is not guaranteed to be the +* same as the state on VMENTER. So software state has to be udpated before +* any operation which depends on it can take place. +* +* Note: It can be invoked unconditionally even when write emulation is +* enabled for the price of a then pointless MSR read. +*/ +void fpu_sync_guest_vmexit_xfd_state (void ) +{ +struct fpstate *fps = current->thread.fpu.fpstate; + +lockdep_assert_irqs_disabled (); +if (fpu_state_size_dynamic ()) { +rdmsrl (MSR_IA32_XFD , fps->xfd); +__this_cpu_write (xfd_state, fps->xfd); + } +} +EXPORT_SYMBOL_GPL (fpu_sync_guest_vmexit_xfd_state);#endif /* CONFIG_X86_64 */ int fpu_swap_kvm_fpstate (struct fpu_guest *guest_fpu,bool enter_guest)
Signature · 1 line
2.31.1
Paolo Bonzini
maintainerPATCH v6 21/21 kvm: x86: Disable interception for IA32_XFD on demand
In reply to Paolo BonziniFrom: Kevin Tian <[email protected]>
Always intercepting IA32_XFD causes non-negligible overhead when this register is updated frequently in the guest.
Disable r/w emulation after intercepting the first WRMSR(IA32_XFD) with a non-zero value.
Disable WRMSR emulation implies that IA32_XFD becomes out-of-sync with the software states in fpstate and the per-cpu xfd cache. This leads to two additional changes accordingly:
- Call fpu_sync_guest_vmexit_xfd_state() after vm-exit to bring software states back in-sync with the MSR, before handle_exit_irqoff() is called.
- Always trap #NM once write interception is disabled for IA32_XFD. The #NM exception is rare if the guest doesn't use dynamic features. Otherwise, there is at most one exception per guest task given a dynamic feature.
p.s. We have confirmed that SDM is being revised to say that when setting IA32_XFD[18] the AMX register state is not guaranteed to be preserved. This clarification avoids adding mess for a creative guest which sets IA32_XFD[18]=1 before saving active AMX state to its own storage.
Message-Id: <[email protected]>
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/kvm/vmx/vmx.c | 24 +++++++++++++++++++----- arch/x86/kvm/vmx/vmx.h | 2 +- arch/x86/kvm/x86.c | 8 ++++++++ 4 files changed, 29 insertions(+), 6 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -647,6 +647,7 @@ struct kvm_vcpu_arch {u64 smi_count;bool tpr_access_reporting;bool xsaves_enabled; +bool xfd_no_write_intercept;u64 ia32_xss;u64 microcode_version;u64 arch_capabilities;
arch/x86/kvm/vmx/vmx.c +19 -5
@@ -162,6 +162,7 @@ static u32 vmx_possible_passthrough_msrs[MAX_POSSIBLE_PASSTHROUGH_MSRS] = {MSR_FS_BASE ,MSR_GS_BASE ,MSR_KERNEL_GS_BASE , +MSR_IA32_XFD ,MSR_IA32_XFD_ERR , #endif MSR_IA32_SYSENTER_CS,
@@ -764,10 +765,11 @@ void vmx_update_exception_bitmap(struct kvm_vcpu *vcpu) }/* -* Trap #NM if guest xfd contains a non-zero value so guest XFD_ERR -* can be saved timely. +* Disabling xfd interception indicates that dynamic xfeatures +* might be used in the guest. Always trap #NM in this case +* to save guest xfd_err timely. */ -if (vcpu->arch.guest_fpu.fpstate->xfd) +if (vcpu->arch.xfd_no_write_intercept) eb |= (1u <<NM_VECTOR );vmcs_write32 (EXCEPTION_BITMAP , eb);
@@ -1978,9 +1980,21 @@ static int vmx_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)break ;case MSR_IA32_XFD : ret =kvm_set_msr_common (vcpu, msr_info); -/* Update #NM interception according to guest xfd */ -if (!ret) +/* +* Always intercepting WRMSR could incur non-negligible +* overhead given xfd might be changed frequently in +* guest context switch. Disable write interception +* upon the first write with a non-zero value (indicating +* potential usage on dynamic xfeatures). Also update +* exception bitmap to trap #NM for proper virtualization +* of guest xfd_err. +*/ +if (!ret && data) { +vmx_disable_intercept_for_msr (vcpu,MSR_IA32_XFD , +MSR_TYPE_RW ); + vcpu->arch.xfd_no_write_intercept = true;vmx_update_exception_bitmap (vcpu); + }break ;#endif case MSR_IA32_SYSENTER_CS :
arch/x86/kvm/vmx/vmx.h +1 -1
@@ -349,7 +349,7 @@ struct vcpu_vmx {struct lbr_desc lbr_desc;/* Save desired MSR intercept (read: pass-through) state */ -#define MAX_POSSIBLE_PASSTHROUGH_MSRS 14 +#define MAX_POSSIBLE_PASSTHROUGH_MSRS 15struct { DECLARE_BITMAP(read, MAX_POSSIBLE_PASSTHROUGH_MSRS); DECLARE_BITMAP(write, MAX_POSSIBLE_PASSTHROUGH_MSRS);
arch/x86/kvm/x86.c +8 -0
@@ -10083,6 +10083,14 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) vcpu->mode =OUTSIDE_GUEST_MODE ;smp_wmb (); +/* +* Sync xfd before calling handle_exit_irqoff() which may +* rely on the fact that guest_fpu::xfd is up-to-date (e.g. +* in #NM irqoff handler). +*/ +if (vcpu->arch.xfd_no_write_intercept) +fpu_sync_guest_vmexit_xfd_state (); +static_call (kvm_x86_handle_exit_irqoff)(vcpu);if (vcpu->arch.guest_fpu.xfd_err)
Signature · 1 line
2.31.1