KVM SGX virtualization support (KVM part)
Subsystems (5)
v4 cover KVM SGX virtualization support (KVM part)
Hi Paolo, Sean,
Boris has merged x86 part patches to the tip/x86/sgx. This series is KVM part patches. Due to some code change in x86 part patches, two KVM patches need update so this is the new version. Please help to review. Thanks!
Specifically, x86 patch (x86/sgx: Add helpers to expose ECREATE and EINIT to KVM) was changed to return -EINVAL directly w/o setting trapnr when access_ok()s fail on any user pointers, so KVM patches:
KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
KVM: VMX: Add ENCLS[EINIT] handler to support SGX Launch Control (LC)
were updated to handle this case.
This seris is still based on tip/x86/sgx (which is based on 5.12-rc3), since it requires x86 patches to work. I tried to rebase them to latest kvm/queue, but found patch
KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
KVM: x86: Add capability to grant VM access to privileged SGX aattribute
have merge conflict, but the conflict is quite easy to resolve, so I didn't sent out the resolved version. Please let me know how would you like to proceed.
Thank you all guys!
Sean Christopherson (11):
KVM: x86: Export kvm_mmu_gva_to_gpa_{read,write}() for SGX (VMX)
KVM: x86: Define new #PF SGX error code bit
KVM: x86: Add support for reverse CPUID lookup of scattered features
KVM: x86: Add reverse-CPUID lookup support for scattered SGX features
KVM: VMX: Add basic handling of VM-Exit from SGX enclave
KVM: VMX: Frame in ENCLS handler for SGX virtualization
KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
KVM: VMX: Add emulation of SGX Launch Control LE hash MSRs
KVM: VMX: Add ENCLS[EINIT] handler to support SGX Launch Control (LC)
KVM: VMX: Enable SGX virtualization for SGX1, SGX2 and LC
KVM: x86: Add capability to grant VM access to privileged SGX
attribute
Documentation/virt/kvm/api.rst | 23 ++ arch/x86/include/asm/kvm_host.h | 5 + arch/x86/include/asm/vmx.h | 1 + arch/x86/include/uapi/asm/vmx.h | 1 + arch/x86/kvm/Makefile | 2 + arch/x86/kvm/cpuid.c | 89 +++++- arch/x86/kvm/cpuid.h | 50 +++- arch/x86/kvm/vmx/nested.c | 28 +- arch/x86/kvm/vmx/nested.h | 5 + arch/x86/kvm/vmx/sgx.c | 500 ++++++++++++++++++++++++++++++++ arch/x86/kvm/vmx/sgx.h | 34 +++ arch/x86/kvm/vmx/vmcs12.c | 1 + arch/x86/kvm/vmx/vmcs12.h | 4 +- arch/x86/kvm/vmx/vmx.c | 109 ++++++- arch/x86/kvm/vmx/vmx.h | 2 + arch/x86/kvm/x86.c | 23 ++ include/uapi/linux/kvm.h | 1 + 17 files changed, 855 insertions(+), 23 deletions(-) create mode 100644 arch/x86/kvm/vmx/sgx.c create mode 100644 arch/x86/kvm/vmx/sgx.h
Signature · 1 line
2.30.2
PATCH v4 1/11 KVM: x86: Export kvm_mmu_gva_to_gpa_{read,write}() for SGX (VMX)
From: Sean Christopherson <[email protected]>
Export the gva_to_gpa() helpers for use by SGX virtualization when executing ENCLS[ECREATE] and ENCLS[EINIT] on behalf of the guest. To execute ECREATE and EINIT, KVM must obtain the GPA of the target Secure Enclave Control Structure (SECS) in order to get its corresponding HVA.
Because the SECS must reside in the Enclave Page Cache (EPC), copying the SECS's data to a host-controlled buffer via existing exported helpers is not a viable option as the EPC is not readable or writable by the kernel.
SGX virtualization will also use gva_to_gpa() to obtain HVAs for non-EPC pages in order to pass user pointers directly to ECREATE and EINIT, which avoids having to copy pages worth of data into the kernel.
--- arch/x86/kvm/x86.c | 2 ++ 1 file changed, 2 insertions(+)
arch/x86/kvm/x86.c +2 -0
@@ -5959,6 +5959,7 @@ gpa_t kvm_mmu_gva_to_gpa_read(struct kvm_vcpu *vcpu, gva_t gva,u32 access = (static_call (kvm_x86_get_cpl)(vcpu) ==3 ) ?PFERR_USER_MASK :0 ;return vcpu->arch.walk_mmu->gva_to_gpa (vcpu, gva, access, exception); } +EXPORT_SYMBOL_GPL (kvm_mmu_gva_to_gpa_read);gpa_t kvm_mmu_gva_to_gpa_fetch (struct kvm_vcpu *vcpu,gva_t gva,struct x86_exception *exception)
@@ -5975,6 +5976,7 @@ gpa_t kvm_mmu_gva_to_gpa_write(struct kvm_vcpu *vcpu, gva_t gva, access |=PFERR_WRITE_MASK ;return vcpu->arch.walk_mmu->gva_to_gpa (vcpu, gva, access, exception); } +EXPORT_SYMBOL_GPL (kvm_mmu_gva_to_gpa_write);/* uses this to access any guest's mapped memory without checking CPL */ gpa_t kvm_mmu_gva_to_gpa_system(struct kvm_vcpu *vcpu, gva_t gva,
Signature · 1 line
2.30.2
PATCH v4 2/11 KVM: x86: Define new #PF SGX error code bit
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Page faults that are signaled by the SGX Enclave Page Cache Map (EPCM), as opposed to the traditional IA32/EPT page tables, set an SGX bit in the error code to indicate that the #PF was induced by SGX. KVM will need to emulate this behavior as part of its trap-and-execute scheme for virtualizing SGX Launch Control, e.g. to inject SGX-induced #PFs if EINIT faults in the host, and to support live migration.
--- arch/x86/include/asm/kvm_host.h | 2 ++ 1 file changed, 2 insertions(+)
arch/x86/include/asm/kvm_host.h +2 -0
@@ -227,6 +227,7 @@ enum x86_intercept_stage;#define PFERR_RSVD_BIT 3#define PFERR_FETCH_BIT 4#define PFERR_PK_BIT 5 +#define PFERR_SGX_BIT 15#define PFERR_GUEST_FINAL_BIT 32#define PFERR_GUEST_PAGE_BIT 33
@@ -236,6 +237,7 @@ enum x86_intercept_stage;#define PFERR_RSVD_MASK (1U << PFERR_RSVD_BIT)#define PFERR_FETCH_MASK (1U << PFERR_FETCH_BIT)#define PFERR_PK_MASK (1U << PFERR_PK_BIT) +#define PFERR_SGX_MASK (1U << PFERR_SGX_BIT)#define PFERR_GUEST_FINAL_MASK (1ULL << PFERR_GUEST_FINAL_BIT)#define PFERR_GUEST_PAGE_MASK (1ULL << PFERR_GUEST_PAGE_BIT)
Signature · 1 line
2.30.2
PATCH v4 3/11 KVM: x86: Add support for reverse CPUID lookup of scattered features
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Introduce a scheme that allows KVM's CPUID magic to support features that are scattered in the kernel's feature words. To advertise and/or query guest support for CPUID-based features, KVM requires the bit number of an X86_FEATURE_* to match the bit number in its associated CPUID entry. For scattered features, this does not hold true.
Add a framework to allow defining KVM-only words, stored in kvm_cpu_caps after the shared kernel caps, that can be used to gather the scattered feature bits by translating X86_FEATURE_* flags into their KVM-defined feature.
Note, because reverse_cpuid_check() effectively forces kvm_cpu_caps lookups to be resolved at compile time, there is no runtime cost for translating from kernel-defined to kvm-defined features.
More details here: https://lkml.kernel.org/r/X/[email protected]
--- arch/x86/kvm/cpuid.c | 32 +++++++++++++++++++++++++++----- arch/x86/kvm/cpuid.h | 39 ++++++++++++++++++++++++++++++++++----- 2 files changed, 61 insertions(+), 10 deletions(-)
arch/x86/kvm/cpuid.c +27 -5
@@ -28,7 +28,7 @@* Unlike "struct cpuinfo_x86.x86_capability", kvm_cpu_caps doesn't need to be * aligned to sizeof(unsigned long) because it's not accessed via bitops. */ -u32 kvm_cpu_caps[NCAPINTS ]__read_mostly ; +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)
@@ -53,6 +53,7 @@ static u32 xstate_required_size(u64 xstate_bv, bool compacted) }#define F feature_bit +#define SF (name) (boot_cpu_has(X86_FEATURE_##name) ? F(name) : 0)static inline struct kvm_cpuid_entry2 *cpuid_entry2_find (struct kvm_cpuid_entry2 *entries,int nent,u32 function,u32 index)
@@ -347,13 +348,13 @@ int kvm_vcpu_ioctl_get_cpuid2(struct kvm_vcpu *vcpu,return r; } -static __always_inline void kvm_cpu_cap_mask(enum cpuid_leafs leaf, u32 mask) +/* Mask kvm_cpu_caps for @leaf with the raw CPUID capabilities of this CPU. */ +static __always_inline void __kvm_cpu_cap_mask(enum cpuid_leafs leaf) {const struct cpuid_reg cpuid =x86_feature_cpuid (leaf *32 );struct kvm_cpuid_entry2 entry;reverse_cpuid_check (leaf); - kvm_cpu_caps[leaf] &= mask;cpuid_count (cpuid.function, cpuid.index, &entry.eax, &entry.ebx, &entry.ecx, &entry.edx);
@@ -361,6 +362,26 @@ static __always_inline void kvm_cpu_cap_mask(enum cpuid_leafs leaf, u32 mask) kvm_cpu_caps[leaf] &= *__cpuid_entry_get_reg (&entry, cpuid.reg); } +static __always_inline void kvm_cpu_cap_mask(enum cpuid_leafs leaf, u32 mask) +{ +/* Use the "init" variant for scattered leafs. */ +BUILD_BUG_ON (leaf >=NCAPINTS ); + + kvm_cpu_caps[leaf] &= mask; + +__kvm_cpu_cap_mask (leaf); +} + +static __always_inline void kvm_cpu_cap_init(enum cpuid_leafs leaf, u32 mask) +{ +/* Use the "mask" variant for hardwared-defined leafs. */ +BUILD_BUG_ON (leaf <NCAPINTS ); + + kvm_cpu_caps[leaf] = mask; + +__kvm_cpu_cap_mask (leaf); +} +void kvm_set_cpu_caps (void ) {unsigned int f_nx =is_efer_nx () ?F (NX ) :0 ;
@@ -371,12 +392,13 @@ void kvm_set_cpu_caps(void)unsigned int f_gbpages =0 ;unsigned int f_lm =0 ;#endif +memset (kvm_cpu_caps,0 ,sizeof (kvm_cpu_caps)); -BUILD_BUG_ON (sizeof (kvm_cpu_caps) > +BUILD_BUG_ON (sizeof (kvm_cpu_caps) - (NKVMCAPINTS *sizeof (*kvm_cpu_caps)) >sizeof (boot_cpu_data.x86_capability));memcpy (&kvm_cpu_caps, &boot_cpu_data.x86_capability, -sizeof (kvm_cpu_caps)); +sizeof (kvm_cpu_caps) - (NKVMCAPINTS *sizeof (*kvm_cpu_caps))); kvm_cpu_cap_mask(CPUID_1_ECX,/*
arch/x86/kvm/cpuid.h +34 -5
@@ -7,7 +7,20 @@#include <asm/processor.h> #include <uapi/asm/kvm_para.h> -extern u32 kvm_cpu_caps[NCAPINTS ]__read_mostly ; +/* +* Hardware-defined CPUID leafs that are scattered in the kernel, but need to +* be directly used by KVM. Note, these word values conflict with the kernel's +* "bug" caps, but KVM doesn't use those. +*/ +enum kvm_only_cpuid_leafs { +NR_KVM_CPU_CAPS =NCAPINTS , + +NKVMCAPINTS =NR_KVM_CPU_CAPS -NCAPINTS , +}; + +#define X86_KVM_FEATURE (w, f) ((w)*32 + (f)) + +extern u32 kvm_cpu_caps[NR_KVM_CPU_CAPS ]__read_mostly ;void kvm_set_cpu_caps (void );void kvm_update_cpuid_runtime (struct kvm_vcpu *vcpu);
@@ -100,6 +113,20 @@ static __always_inline void reverse_cpuid_check(unsigned int x86_leaf)BUILD_BUG_ON (reverse_cpuid[x86_leaf].function ==0 ); } +/* +* Translate feature bits that are scattered in the kernel's cpufeatures word +* into KVM feature words that align with hardware's definitions. +*/ +static __always_inline u32 __feature_translate(int x86_feature) +{ +return x86_feature; +} + +static __always_inline u32 __feature_leaf(int x86_feature) +{ +return __feature_translate (x86_feature) /32 ; +} +/* * Retrieve the bit mask from an X86_FEATURE_* definition. Features contain * the hardware defined bit number (stored in bits 4:0) and a software defined
@@ -108,6 +135,8 @@ static __always_inline void reverse_cpuid_check(unsigned int x86_leaf)*/ static __always_inline u32 __feature_bit(int x86_feature) { + x86_feature =__feature_translate (x86_feature); +reverse_cpuid_check (x86_feature /32 );return 1 << (x86_feature &31 ); }
@@ -116,7 +145,7 @@ static __always_inline u32 __feature_bit(int x86_feature) static __always_inline struct cpuid_reg x86_feature_cpuid(unsigned int x86_feature) { -unsigned int x86_leaf = x86_feature /32 ; +unsigned int x86_leaf =__feature_leaf (x86_feature);reverse_cpuid_check (x86_leaf);return reverse_cpuid[x86_leaf];
@@ -308,7 +337,7 @@ static inline bool cpuid_fault_enabled(struct kvm_vcpu *vcpu) static __always_inline void kvm_cpu_cap_clear(unsigned int x86_feature) { -unsigned int x86_leaf = x86_feature /32 ; +unsigned int x86_leaf =__feature_leaf (x86_feature);reverse_cpuid_check (x86_leaf); kvm_cpu_caps[x86_leaf] &= ~__feature_bit (x86_feature);
@@ -316,7 +345,7 @@ static __always_inline void kvm_cpu_cap_clear(unsigned int x86_feature) static __always_inline void kvm_cpu_cap_set(unsigned int x86_feature) { -unsigned int x86_leaf = x86_feature /32 ; +unsigned int x86_leaf =__feature_leaf (x86_feature);reverse_cpuid_check (x86_leaf); kvm_cpu_caps[x86_leaf] |=__feature_bit (x86_feature);
@@ -324,7 +353,7 @@ static __always_inline void kvm_cpu_cap_set(unsigned int x86_feature) static __always_inline u32 kvm_cpu_cap_get(unsigned int x86_feature) { -unsigned int x86_leaf = x86_feature /32 ; +unsigned int x86_leaf =__feature_leaf (x86_feature);reverse_cpuid_check (x86_leaf);return kvm_cpu_caps[x86_leaf] &__feature_bit (x86_feature);
Signature · 1 line
2.30.2
PATCH v4 4/11 KVM: x86: Add reverse-CPUID lookup support for scattered SGX features
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Define a new KVM-only feature word for advertising and querying SGX sub-features in CPUID.0x12.0x0.EAX. Because SGX1 and SGX2 are scattered in the kernel's feature word, they need to be translated so that the bit numbers match those of hardware.
--- arch/x86/kvm/cpuid.h | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)
arch/x86/kvm/cpuid.h +12 -1
@@ -13,13 +13,18 @@* "bug" caps, but KVM doesn't use those. */ enum kvm_only_cpuid_leafs { -NR_KVM_CPU_CAPS =NCAPINTS , +CPUID_12_EAX =NCAPINTS , +NR_KVM_CPU_CAPS ,NKVMCAPINTS =NR_KVM_CPU_CAPS -NCAPINTS , };#define X86_KVM_FEATURE (w, f) ((w)*32 + (f)) +/* Intel-defined SGX sub-features, CPUID level 0x12 (EAX). */ +#define __X86_FEATURE_SGX1 X86_KVM_FEATURE(CPUID_12_EAX, 0) +#define __X86_FEATURE_SGX2 X86_KVM_FEATURE(CPUID_12_EAX, 1) +extern u32 kvm_cpu_caps[NR_KVM_CPU_CAPS ]__read_mostly ;void kvm_set_cpu_caps (void );
@@ -93,6 +98,7 @@ static const struct cpuid_reg reverse_cpuid[] = { [CPUID_8000_0007_EBX] = {0x80000007, 0, CPUID_EBX}, [CPUID_7_EDX] = { 7, 0, CPUID_EDX}, [CPUID_7_1_EAX] = { 7, 1, CPUID_EAX}, + [CPUID_12_EAX] = {0x00000012, 0, CPUID_EAX}, };/*
@@ -119,6 +125,11 @@ static __always_inline void reverse_cpuid_check(unsigned int x86_leaf)*/ static __always_inline u32 __feature_translate(int x86_feature) { +if (x86_feature ==X86_FEATURE_SGX1 ) +return __X86_FEATURE_SGX1; +else if (x86_feature ==X86_FEATURE_SGX2 ) +return __X86_FEATURE_SGX2; +return x86_feature; }
Signature · 1 line
2.30.2
PATCH v4 5/11 KVM: VMX: Add basic handling of VM-Exit from SGX enclave
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Add support for handling VM-Exits that originate from a guest SGX enclave. In SGX, an "enclave" is a new CPL3-only execution environment, wherein the CPU and memory state is protected by hardware to make the state inaccesible to code running outside of the enclave. When exiting an enclave due to an asynchronous event (from the perspective of the enclave), e.g. exceptions, interrupts, and VM-Exits, the enclave's state is automatically saved and scrubbed (the CPU loads synthetic state), and then reloaded when re-entering the enclave. E.g. after an instruction based VM-Exit from an enclave, vmcs.GUEST_RIP will not contain the RIP of the enclave instruction that trigered VM-Exit, but will instead point to a RIP in the enclave's untrusted runtime (the guest userspace code that coordinates entry/exit to/from the enclave).
To help a VMM recognize and handle exits from enclaves, SGX adds bits to existing VMCS fields, VM_EXIT_REASON.VMX_EXIT_REASON_FROM_ENCLAVE and GUEST_INTERRUPTIBILITY_INFO.GUEST_INTR_STATE_ENCLAVE_INTR. Define the new architectural bits, and add a boolean to struct vcpu_vmx to cache VMX_EXIT_REASON_FROM_ENCLAVE. Clear the bit in exit_reason so that checks against exit_reason do not need to account for SGX, e.g. "if (exit_reason == EXIT_REASON_EXCEPTION_NMI)" continues to work.
KVM is a largely a passive observer of the new bits, e.g. KVM needs to account for the bits when propagating information to a nested VMM, but otherwise doesn't need to act differently for the majority of VM-Exits from enclaves.
The one scenario that is directly impacted is emulation, which is for all intents and purposes impossible[1] since KVM does not have access to the RIP or instruction stream that triggered the VM-Exit. The inability to emulate is a non-issue for KVM, as most instructions that might trigger VM-Exit unconditionally #UD in an enclave (before the VM-Exit check. For the few instruction that conditionally #UD, KVM either never sets the exiting control, e.g. PAUSE_EXITING[2], or sets it if and only if the feature is not exposed to the guest in order to inject a #UD, e.g. RDRAND_EXITING.
But, because it is still possible for a guest to trigger emulation, e.g. MMIO, inject a #UD if KVM ever attempts emulation after a VM-Exit from an enclave. This is architecturally accurate for instruction VM-Exits, and for MMIO it's the least bad choice, e.g. it's preferable to killing the VM. In practice, only broken or particularly stupid guests should ever encounter this behavior.
Add a WARN in skip_emulated_instruction to detect any attempt to modify the guest's RIP during an SGX enclave VM-Exit as all such flows should either be unreachable or must handle exits from enclaves before getting to skip_emulated_instruction.
[1] Impossible for all practical purposes. Not truly impossible since KVM could implement some form of para-virtualization scheme.
[2] PAUSE_LOOP_EXITING only affects CPL0 and enclaves exist only at CPL3, so we also don't need to worry about that interaction.
--- arch/x86/include/asm/vmx.h | 1 + arch/x86/include/uapi/asm/vmx.h | 1 + arch/x86/kvm/vmx/nested.c | 2 ++ arch/x86/kvm/vmx/vmx.c | 45 +++++++++++++++++++++++++++++++-- 4 files changed, 47 insertions(+), 2 deletions(-)
arch/x86/include/asm/vmx.h +1 -0
@@ -373,6 +373,7 @@ enum vmcs_field {#define GUEST_INTR_STATE_MOV_SS 0x00000002#define GUEST_INTR_STATE_SMI 0x00000004#define GUEST_INTR_STATE_NMI 0x00000008 +#define GUEST_INTR_STATE_ENCLAVE_INTR 0x00000010/* GUEST_ACTIVITY_STATE flags */ #define GUEST_ACTIVITY_ACTIVE 0
arch/x86/include/uapi/asm/vmx.h +1 -0
@@ -27,6 +27,7 @@#define VMX_EXIT_REASONS_FAILED_VMENTRY 0x80000000 +#define VMX_EXIT_REASONS_SGX_ENCLAVE_MODE 0x08000000#define EXIT_REASON_EXCEPTION_NMI 0#define EXIT_REASON_EXTERNAL_INTERRUPT 1
arch/x86/kvm/vmx/nested.c +2 -0
@@ -4105,6 +4105,8 @@ static void prepare_vmcs12(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12, {/* update exit information fields: */ vmcs12->vm_exit_reason = vm_exit_reason; +if (to_vmx (vcpu)->exit_reason.enclave_mode) + vmcs12->vm_exit_reason |=VMX_EXIT_REASONS_SGX_ENCLAVE_MODE ; vmcs12->exit_qualification = exit_qualification; vmcs12->vm_exit_intr_info = exit_intr_info;
arch/x86/kvm/vmx/vmx.c +43 -2
76 lines not on this page · raw message
Signature · 1 line
2.30.2
PATCH v4 6/11 KVM: VMX: Frame in ENCLS handler for SGX virtualization
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Introduce sgx.c and sgx.h, along with the framework for handling ENCLS VM-Exits. Add a bool, enable_sgx, that will eventually be wired up to a module param to control whether or not SGX virtualization is enabled at runtime.
--- arch/x86/kvm/Makefile | 2 ++ arch/x86/kvm/vmx/sgx.c | 50 ++++++++++++++++++++++++++++++++++++++++++ arch/x86/kvm/vmx/sgx.h | 15 +++++++++++++ arch/x86/kvm/vmx/vmx.c | 9 +++++--- 4 files changed, 73 insertions(+), 3 deletions(-) create mode 100644 arch/x86/kvm/vmx/sgx.c create mode 100644 arch/x86/kvm/vmx/sgx.h
arch/x86/kvm/Makefile +2 -0
@@ -23,6 +23,8 @@ kvm-$(CONFIG_KVM_XEN) += xen.o kvm-intel-y += vmx/vmx.o vmx/vmenter.o vmx/pmu_intel.o vmx/vmcs12.o \ vmx/evmcs.o vmx/nested.o vmx/posted_intr.o +kvm-intel-$(CONFIG_X86_SGX_KVM) += vmx/sgx.o + kvm-amd-y += svm/svm.o svm/vmenter.o svm/pmu.o svm/nested.o svm/avic.o svm/sev.o obj-$(CONFIG_KVM) += kvm.o
arch/x86/kvm/vmx/sgx.c new file +50 -0
50 lines not on this page · raw message
arch/x86/kvm/vmx/sgx.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __KVM_X86_SGX_H +#define __KVM_X86_SGX_H + +#include <linux/kvm_host.h> + +#ifdef CONFIG_X86_SGX_KVM +extern bool __read_mostly enable_sgx; + +int handle_encls (struct kvm_vcpu *vcpu); +#else +#define enable_sgx 0 +#endif + +#endif /* __KVM_X86_SGX_H */
arch/x86/kvm/vmx/vmx.c +6 -3
@@ -57,6 +57,7 @@#include "mmu.h" #include "nested.h" #include "pmu.h" +#include "sgx.h" #include "trace.h" #include "vmcs.h" #include "vmcs12.h"
@@ -5673,16 +5674,18 @@ static int handle_vmx_instruction(struct kvm_vcpu *vcpu)return 1 ; } +#ifndef CONFIG_X86_SGX_KVM static int handle_encls (struct kvm_vcpu *vcpu) {/* -* SGX virtualization is not yet supported. There is no software -* enable bit for SGX, so we have to trap ENCLS and inject a #UD -* to prevent the guest from executing ENCLS. +* SGX virtualization is disabled. There is no software enable bit for +* SGX, so KVM intercepts all ENCLS leafs and injects a #UD to prevent +* the guest from executing ENCLS (when SGX is supported by hardware). */ kvm_queue_exception (vcpu,UD_VECTOR );return 1 ; } +#endif /* CONFIG_X86_SGX_KVM */ static int handle_bus_lock_vmexit (struct kvm_vcpu *vcpu) {
Signature · 1 line
2.30.2
Sean Christopherson
maintainerRe: [PATCH v4 06/11] KVM: VMX: Frame in ENCLS handler for SGX virtualization
arch/x86/kvm/vmx/sgx.c line 37
Quoted 3 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c new file +3
-0+int handle_encls (struct kvm_vcpu *vcpu) +{ +u32 leaf = (u32 )vcpu->arch.regs[VCPU_REGS_RAX ];
Please use kvm_rax_read(), I've been trying to discourage direct access to the array. Which is ironic because I'm 100% certain I'm to blame for this. :-)
Quoted 13 lines
arch/x86/kvm/vmx/sgx.c new file +13
-0+ +if (!encls_leaf_enabled_in_guest (vcpu, leaf)) { +kvm_queue_exception (vcpu,UD_VECTOR ); + }else if (!sgx_enabled_in_guest_bios (vcpu)) { +kvm_inject_gp (vcpu,0 ); + }else { +WARN (1 ,"KVM: unexpected exit on ENCLS[%u]" , leaf); + vcpu->run->exit_reason =KVM_EXIT_UNKNOWN ; + vcpu->run->hw.hardware_exit_reason =EXIT_REASON_ENCLS ; +return 0 ; + } +return 1 ; +}
Re: [PATCH v4 06/11] KVM: VMX: Frame in ENCLS handler for SGX virtualization
Quoted 7 lines · On Wed, 7 Apr 2021 22:16:59 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 37
Quoted 3 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c new file +3
-0+int handle_encls (struct kvm_vcpu *vcpu) +{ +u32 leaf = (u32 )vcpu->arch.regs[VCPU_REGS_RAX ];Please use
kvm_rax_read(), I've been trying to discourage direct access to the array. Which is ironic because I'm 100% certain I'm to blame for this. :-)
Sure. But I think still, we should convert it to (u32) explicitly, so:
u32 leaf = (u32)kvm_rax_read(vcpu);
?
Quoted 14 lines
Quoted 14 lines
arch/x86/kvm/vmx/sgx.c new file +13
-0+ +if (!encls_leaf_enabled_in_guest (vcpu, leaf)) { +kvm_queue_exception (vcpu,UD_VECTOR ); + }else if (!sgx_enabled_in_guest_bios (vcpu)) { +kvm_inject_gp (vcpu,0 ); + }else { +WARN (1 ,"KVM: unexpected exit on ENCLS[%u]" , leaf); + vcpu->run->exit_reason =KVM_EXIT_UNKNOWN ; + vcpu->run->hw.hardware_exit_reason =EXIT_REASON_ENCLS ; +return 0 ; + } +return 1 ; +}
Sean Christopherson
maintainerRe: [PATCH v4 06/11] KVM: VMX: Frame in ENCLS handler for SGX virtualization
Quoted 9 lines · Kai Huang
Quoted 7 lines · On Wed, 7 Apr 2021 22:16:59 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 37
Quoted 3 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c new file +3
-0+int handle_encls (struct kvm_vcpu *vcpu) +{ +u32 leaf = (u32 )vcpu->arch.regs[VCPU_REGS_RAX ];Please use
kvm_rax_read(), I've been trying to discourage direct access to the array. Which is ironic because I'm 100% certain I'm to blame for this. :-)
Quoted 5 lines
Sure. But I think still, we should convert it to (u32) explicitly, so:
u32 leaf = (u32)kvm_rax_read(vcpu);?
Ya, agreed, it helps document that it's deliberate.
Re: [PATCH v4 06/11] KVM: VMX: Frame in ENCLS handler for SGX virtualization
Quoted 10 lines · On Wed, 7 Apr 2021 22:35:32 +0000 Sean Christopherson wrote:
Quoted 9 lines · Kai Huang
Quoted 7 lines · On Wed, 7 Apr 2021 22:16:59 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 37
Quoted 3 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c new file +3
-0+int handle_encls (struct kvm_vcpu *vcpu) +{ +u32 leaf = (u32 )vcpu->arch.regs[VCPU_REGS_RAX ];Please use
kvm_rax_read(), I've been trying to discourage direct access to the array. Which is ironic because I'm 100% certain I'm to blame for this. :-)
Quoted 7 lines
Quoted 5 lines
Sure. But I think still, we should convert it to (u32) explicitly, so:
u32 leaf = (u32)kvm_rax_read(vcpu);?
Ya, agreed, it helps document that it's deliberate.
Do you have any other comments regarding to other patches? If no I can send another version rather quickly :)
Sean Christopherson
maintainerRe: [PATCH v4 06/11] KVM: VMX: Frame in ENCLS handler for SGX virtualization
Quoted 13 lines · Kai Huang
Quoted 12 lines · On Wed, 7 Apr 2021 22:35:32 +0000 Sean Christopherson wrote:
Quoted 11 lines · Kai Huang
Quoted 7 lines · On Wed, 7 Apr 2021 22:16:59 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 37
Quoted 3 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c new file +3
-0+int handle_encls (struct kvm_vcpu *vcpu) +{ +u32 leaf = (u32 )vcpu->arch.regs[VCPU_REGS_RAX ];Please use
kvm_rax_read(), I've been trying to discourage direct access to the array. Which is ironic because I'm 100% certain I'm to blame for this. :-)Sure. But I think still, we should convert it to (u32) explicitly, so:
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
u32 leaf = (u32)kvm_rax_read(vcpu);?
Ya, agreed, it helps document that it's deliberate.
Do you have any other comments regarding to other patches? If no I can send another version rather quickly :)
Nope, nothing at this time. Though I'd give folks a few days to review before sending the next version, I don't think any of my feedback will affect other reviews.
Re: [PATCH v4 06/11] KVM: VMX: Frame in ENCLS handler for SGX virtualization
Quoted 18 lines · On Wed, 7 Apr 2021 22:47:07 +0000 Sean Christopherson wrote:
Quoted 17 lines · Kai Huang
Quoted 16 lines · On Wed, 7 Apr 2021 22:35:32 +0000 Sean Christopherson wrote:
Quoted 14 lines · Kai Huang
Quoted 7 lines · On Wed, 7 Apr 2021 22:16:59 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 37
Quoted 3 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c new file +3
-0+int handle_encls (struct kvm_vcpu *vcpu) +{ +u32 leaf = (u32 )vcpu->arch.regs[VCPU_REGS_RAX ];Please use
kvm_rax_read(), I've been trying to discourage direct access to the array. Which is ironic because I'm 100% certain I'm to blame for this. :-)Sure. But I think still, we should convert it to (u32) explicitly, so:
u32 leaf = (u32)kvm_rax_read(vcpu);?
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Ya, agreed, it helps document that it's deliberate.
Do you have any other comments regarding to other patches? If no I can send another version rather quickly :)
Nope, nothing at this time. Though I'd give folks a few days to review before sending the next version, I don't think any of my feedback will affect other reviews.
My thinking too, but OK I'll wait for other people's review, plus I'd like to hear about on how to proceed given the current series has some merge conflicts with latest kvm/queue, although they are quite straightforward to resolve.
PATCH v4 7/11 KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Add an ECREATE handler that will be used to intercept ECREATE for the purpose of enforcing and enclave's MISCSELECT, ATTRIBUTES and XFRM, i.e. to allow userspace to restrict SGX features via CPUID. ECREATE will be intercepted when any of the aforementioned masks diverges from hardware in order to enforce the desired CPUID model, i.e. inject #GP if the guest attempts to set a bit that hasn't been enumerated as allowed-1 in CPUID.
Note, access to the PROVISIONKEY is not yet supported.
--- arch/x86/include/asm/kvm_host.h | 3 + arch/x86/kvm/vmx/sgx.c | 274 ++++++++++++++++++++++++++++++++ 2 files changed, 277 insertions(+)
arch/x86/include/asm/kvm_host.h +3 -0
@@ -1038,6 +1038,9 @@ struct kvm_arch {bool bus_lock_detection_enabled; +/* Guest can access the SGX PROVISIONKEY. */ +bool sgx_provisioning_allowed; +struct kvm_pmu_event_filter __rcu *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread;
arch/x86/kvm/vmx/sgx.c +274 -0
286 lines not on this page · raw message
Signature · 1 line
2.30.2
Sean Christopherson
maintainerRe: [PATCH v4 07/11] KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
arch/x86/kvm/vmx/sgx.c line 266
Quoted 7 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c +7
-0+/* +* Copy contents into kernel memory to prevent TOCTOU attack. E.g. the +* guest could do ECREATE w/ SECS.SGX_ATTR_PROVISIONKEY=0, and +* simultaneously set SGX_ATTR_PROVISIONKEY to bypass the check to +* enforce restriction of access to the PROVISIONKEY. +*/ + contents = (struct sgx_secs *)__get_free_page (GFP_KERNEL );
This should use GFP_KERNEL_ACCOUNT.
Re: [PATCH v4 07/11] KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
Quoted 10 lines · On Wed, 7 Apr 2021 21:52:50 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 266
Quoted 7 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c +7
-0+/* +* Copy contents into kernel memory to prevent TOCTOU attack. E.g. the +* guest could do ECREATE w/ SECS.SGX_ATTR_PROVISIONKEY=0, and +* simultaneously set SGX_ATTR_PROVISIONKEY to bypass the check to +* enforce restriction of access to the PROVISIONKEY. +*/ + contents = (struct sgx_secs *)__get_free_page (GFP_KERNEL );This should use
GFP_KERNEL_ACCOUNT.
May I ask why? The page is only a temporary allocation, it will be freed before this function returns. I guess a 4K page is OK?
Sean Christopherson
maintainerRe: [PATCH v4 07/11] KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
Quoted 12 lines · Kai Huang
Quoted 10 lines · On Wed, 7 Apr 2021 21:52:50 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 266
Quoted 7 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c +7
-0+/* +* Copy contents into kernel memory to prevent TOCTOU attack. E.g. the +* guest could do ECREATE w/ SECS.SGX_ATTR_PROVISIONKEY=0, and +* simultaneously set SGX_ATTR_PROVISIONKEY to bypass the check to +* enforce restriction of access to the PROVISIONKEY. +*/ + contents = (struct sgx_secs *)__get_free_page (GFP_KERNEL );This should use
GFP_KERNEL_ACCOUNT.
Quoted 2 lines
May I ask why? The page is only a temporary allocation, it will be freed before this function returns. I guess a 4K page is OK?
A hard limit should not be violated, even temporarily. This is also per vCPU, e.g. a 256 vCPU VM could go 1mb over the limit.
Re: [PATCH v4 07/11] KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
Quoted 13 lines · On Wed, 7 Apr 2021 22:04:55 +0000 Sean Christopherson wrote:
Quoted 12 lines · Kai Huang
Quoted 10 lines · On Wed, 7 Apr 2021 21:52:50 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 266
Quoted 7 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c +7
-0+/* +* Copy contents into kernel memory to prevent TOCTOU attack. E.g. the +* guest could do ECREATE w/ SECS.SGX_ATTR_PROVISIONKEY=0, and +* simultaneously set SGX_ATTR_PROVISIONKEY to bypass the check to +* enforce restriction of access to the PROVISIONKEY. +*/ + contents = (struct sgx_secs *)__get_free_page (GFP_KERNEL );This should use
GFP_KERNEL_ACCOUNT.
Quoted 5 lines
Quoted 2 lines
May I ask why? The page is only a temporary allocation, it will be freed before this function returns. I guess a 4K page is OK?
A hard limit should not be violated, even temporarily. This is also per vCPU, e.g. a 256 vCPU VM could go 1mb over the limit.
OK. Will change in next version.
Sean Christopherson
maintainerRe: [PATCH v4 07/11] KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
In reply to Kai Huangarch/x86/kvm/vmx/sgx.c line 195
Quoted 7 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c +7
-0+/* +* sgx_virt_ecreate() returns: +* 1) 0: ECREATE was successful +* 2) -EFAULT: ECREATE was run but faulted, and trapnr was set to the +* exception number. +* 3) -EINVAL: access_ok() on @secs_hva fails. It's a kernel bug and +* sgx_virt_ecreate() aleady gave a warning.
Eh, I don't love "kernel bug", all we know is that access_ok() failed. It's also not all that helpful since it doesn't guide the debugger to any particular code that would prevent access_ok() from failing.
What if this comment simply states the rules/expectations and lets the debugger figure out what's wrong? E.g.
* 3) -EINVAL: access_ok() on @secs_hva failed. This should never
* happen as KVM checks host addresses at memslot creation.
* sgx_virt_create() has already warned in this case.
Same goes for sgx_virt_einit() in the next patch.
Quoted 9 lines
arch/x86/kvm/vmx/sgx.c +9
-0+*/ + ret =sgx_virt_ecreate (pageinfo, (void __user *)secs_hva, &trapnr); +if (!ret) +return kvm_skip_emulated_instruction (vcpu); +if (ret == -EFAULT ) +return sgx_inject_fault (vcpu, secs_gva, trapnr); + +return ret; +}
Re: [PATCH v4 07/11] KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
Quoted 13 lines · On Wed, 7 Apr 2021 22:10:36 +0000 Sean Christopherson wrote:
arch/x86/kvm/vmx/sgx.c line 195
Quoted 7 lines · Kai Huang
arch/x86/kvm/vmx/sgx.c +7
-0+/* +* sgx_virt_ecreate() returns: +* 1) 0: ECREATE was successful +* 2) -EFAULT: ECREATE was run but faulted, and trapnr was set to the +* exception number. +* 3) -EINVAL: access_ok() on @secs_hva fails. It's a kernel bug and +* sgx_virt_ecreate() aleady gave a warning. Eh, I don't love "kernel bug", all we know is that
access_ok()failed. It's also not all that helpful since it doesn't guide the debugger to any particular code that would preventaccess_ok()from failing.
Quoted 8 lines
What if this comment simply states the rules/expectations and lets the debugger figure out what's wrong? E.g.
* 3)
-EINVAL:access_ok()on @secs_hva failed. This should never
* happen as KVM checks host addresses at memslot creation.
*sgx_virt_create()has already warned in this case.Same goes for
sgx_virt_einit()in the next patch.
Sure. Will update in next version.
Quoted 10 lines
Quoted 10 lines
arch/x86/kvm/vmx/sgx.c +9
-0+*/ + ret =sgx_virt_ecreate (pageinfo, (void __user *)secs_hva, &trapnr); +if (!ret) +return kvm_skip_emulated_instruction (vcpu); +if (ret == -EFAULT ) +return sgx_inject_fault (vcpu, secs_gva, trapnr); + +return ret; +}
PATCH v4 8/11 KVM: VMX: Add emulation of SGX Launch Control LE hash MSRs
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Emulate the four Launch Enclave public key hash MSRs (LE hash MSRs) that exist on CPUs that support SGX Launch Control (LC). SGX LC modifies the behavior of ENCLS[EINIT] to use the LE hash MSRs when verifying the key used to sign an enclave. On CPUs without LC support, the LE hash is hardwired into the CPU to an Intel controlled key (the Intel key is also the reset value of the LE hash MSRs). Track the guest's desired hash so that a future patch can stuff the hash into the hardware MSRs when executing EINIT on behalf of the guest, when those MSRs are writable in host.
Note, KVM allows writes to the LE hash MSRs if IA32_FEATURE_CONTROL is unlocked. This is technically not architectural behavior, but it's roughly equivalent to the arch behavior of the MSRs being writable prior to activating SGX[1]. Emulating SGX activation is feasible, but adds no tangible benefits and would just create extra work for KVM and guest firmware.
[1] SGX related bits in IA32_FEATURE_CONTROL cannot be set until SGX is activated, e.g. by firmware. SGX activation is triggered by setting bit 0 in MSR 0x7a. Until SGX is activated, the LE hash MSRs are writable, e.g. to allow firmware to lock down the LE root key with a non-Intel value.
--- arch/x86/kvm/vmx/sgx.c | 35 +++++++++++++++++++++++++++++++++++ arch/x86/kvm/vmx/sgx.h | 6 ++++++ arch/x86/kvm/vmx/vmx.c | 20 ++++++++++++++++++++ arch/x86/kvm/vmx/vmx.h | 2 ++ 4 files changed, 63 insertions(+)
arch/x86/kvm/vmx/sgx.c +35 -0
@@ -11,6 +11,9 @@bool __read_mostly enable_sgx; +/* Initial value of guest's virtual SGX_LEPUBKEYHASHn MSRs */ +static u64 sgx_pubkey_hash[4 ]__ro_after_init ; +/* * ENCLS's memory operands use a fixed segment (DS) and a fixed * address size based on the mode. Related prefixes are ignored.
@@ -322,3 +325,35 @@ int handle_encls(struct kvm_vcpu *vcpu) }return 1 ; } + +void setup_default_sgx_lepubkeyhash (void ) +{ +/* +* Use Intel's default value for Skylake hardware if Launch Control is +* not supported, i.e. Intel's hash is hardcoded into silicon, or if +* Launch Control is supported and enabled, i.e. mimic the reset value +* and let the guest write the MSRs at will. If Launch Control is +* supported but disabled, then use the current MSR values as the hash +* MSRs exist but are read-only (locked and not writable). +*/ +if (!enable_sgx ||boot_cpu_has (X86_FEATURE_SGX_LC ) || +rdmsrl_safe (MSR_IA32_SGXLEPUBKEYHASH0 , &sgx_pubkey_hash[0 ])) { + sgx_pubkey_hash[0 ] =0xa6053e051270b7acULL ; + sgx_pubkey_hash[1 ] =0x6cfbe8ba8b3b413dULL ; + sgx_pubkey_hash[2 ] =0xc4916d99f2b3735dULL ; + sgx_pubkey_hash[3 ] =0xd4f8c05909f9bb3bULL ; + }else { +/* MSR_IA32_SGXLEPUBKEYHASH0 is read above */ +rdmsrl (MSR_IA32_SGXLEPUBKEYHASH1 , sgx_pubkey_hash[1 ]); +rdmsrl (MSR_IA32_SGXLEPUBKEYHASH2 , sgx_pubkey_hash[2 ]); +rdmsrl (MSR_IA32_SGXLEPUBKEYHASH3 , sgx_pubkey_hash[3 ]); + } +} + +void vcpu_setup_sgx_lepubkeyhash (struct kvm_vcpu *vcpu) +{ +struct vcpu_vmx *vmx =to_vmx (vcpu); + +memcpy (vmx->msr_ia32_sgxlepubkeyhash, sgx_pubkey_hash, +sizeof (sgx_pubkey_hash)); +}
arch/x86/kvm/vmx/sgx.h +6 -0
@@ -8,8 +8,14 @@extern bool __read_mostly enable_sgx;int handle_encls (struct kvm_vcpu *vcpu); + +void setup_default_sgx_lepubkeyhash (void ); +void vcpu_setup_sgx_lepubkeyhash (struct kvm_vcpu *vcpu);#else #define enable_sgx 0 + +static inline void setup_default_sgx_lepubkeyhash (void ) { } +static inline void vcpu_setup_sgx_lepubkeyhash (struct kvm_vcpu *vcpu) { }#endif #endif /* __KVM_X86_SGX_H */
arch/x86/kvm/vmx/vmx.c +20 -0
@@ -1904,6 +1904,13 @@ static int vmx_get_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)case MSR_IA32_FEAT_CTL : msr_info->data = vmx->msr_ia32_feature_control;break ; + case MSR_IA32_SGXLEPUBKEYHASH0 ... MSR_IA32_SGXLEPUBKEYHASH3: +if (!msr_info->host_initiated && + !guest_cpuid_has (vcpu,X86_FEATURE_SGX_LC )) +return 1 ; + msr_info->data =to_vmx (vcpu)->msr_ia32_sgxlepubkeyhash + [msr_info->index -MSR_IA32_SGXLEPUBKEYHASH0 ]; +break ; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC:if (!nested_vmx_allowed (vcpu))return 1 ;
@@ -2198,6 +2205,15 @@ static int vmx_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info)if (msr_info->host_initiated && data ==0 )vmx_leave_nested (vcpu);break ; + case MSR_IA32_SGXLEPUBKEYHASH0 ... MSR_IA32_SGXLEPUBKEYHASH3: +if (!msr_info->host_initiated && + (!guest_cpuid_has (vcpu,X86_FEATURE_SGX_LC ) || + ((vmx->msr_ia32_feature_control &FEAT_CTL_LOCKED ) && + !(vmx->msr_ia32_feature_control &FEAT_CTL_SGX_LC_ENABLED )))) +return 1 ; + vmx->msr_ia32_sgxlepubkeyhash + [msr_index -MSR_IA32_SGXLEPUBKEYHASH0 ] = data; +break ; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC:if (!msr_info->host_initiated)return 1 ;/* they are read-only */
@@ -7020,6 +7036,8 @@ static int vmx_create_vcpu(struct kvm_vcpu *vcpu)else memset (&vmx->nested.msrs,0 ,sizeof (vmx->nested.msrs)); +vcpu_setup_sgx_lepubkeyhash (vcpu); + vmx->nested.posted_intr_nv =-1 ; vmx->nested.current_vmptr =-1ull ;
@@ -7953,6 +7971,8 @@ static __init int hardware_setup(void)if (!enable_ept || !cpu_has_vmx_intel_pt ()) pt_mode =PT_MODE_SYSTEM ; +setup_default_sgx_lepubkeyhash (); +if (nested) {nested_vmx_setup_ctls_msrs (&vmcs_config.nested, vmx_capability.ept);
arch/x86/kvm/vmx/vmx.h +2 -0
@@ -325,6 +325,8 @@ struct vcpu_vmx {*/ u64 msr_ia32_feature_control;u64 msr_ia32_feature_control_valid_bits; +/* SGX Launch Control public key hash */ +u64 msr_ia32_sgxlepubkeyhash[4 ];u64 ept_pointer;struct pt_desc pt_desc;
Signature · 1 line
2.30.2
PATCH v4 9/11 KVM: VMX: Add ENCLS[EINIT] handler to support SGX Launch Control (LC)
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Add a VM-Exit handler to trap-and-execute EINIT when SGX LC is enabled in the host. When SGX LC is enabled, the host kernel may rewrite the hardware values at will, e.g. to launch enclaves with different signers, thus KVM needs to intercept EINIT to ensure it is executed with the correct LE hash (even if the guest sees a hardwired hash).
Switching the LE hash MSRs on VM-Enter/VM-Exit is not a viable option as writing the MSRs is prohibitively expensive, e.g. on SKL hardware each WRMSR is ~400 cycles. And because EINIT takes tens of thousands of cycles to execute, the ~1500 cycle overhead to trap-and-execute EINIT is unlikely to be noticed by the guest, let alone impact its overall SGX performance.
--- arch/x86/kvm/vmx/sgx.c | 63 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+)
arch/x86/kvm/vmx/sgx.c +63 -0
@@ -286,6 +286,67 @@ static int handle_encls_ecreate(struct kvm_vcpu *vcpu)return r; } +static int handle_encls_einit (struct kvm_vcpu *vcpu) +{ +unsigned long sig_hva, secs_hva, token_hva, rflags; +struct vcpu_vmx *vmx =to_vmx (vcpu); +gva_t sig_gva, secs_gva, token_gva; +gpa_t sig_gpa, secs_gpa, token_gpa; +int ret, trapnr; + +if (sgx_get_encls_gva (vcpu,kvm_rbx_read (vcpu),1808 ,4096 , &sig_gva) || +sgx_get_encls_gva (vcpu,kvm_rcx_read (vcpu),4096 ,4096 , &secs_gva) || +sgx_get_encls_gva (vcpu,kvm_rdx_read (vcpu),304 ,512 , &token_gva)) +return 1 ; + +/* +* Translate the SIGSTRUCT, SECS and TOKEN pointers from GVA to GPA. +* Resume the guest on failure to inject a #PF. +*/ +if (sgx_gva_to_gpa (vcpu, sig_gva, false, &sig_gpa) || +sgx_gva_to_gpa (vcpu, secs_gva, true, &secs_gpa) || +sgx_gva_to_gpa (vcpu, token_gva, false, &token_gpa)) +return 1 ; + +/* +* ...and then to HVA. The order of accesses isn't architectural, i.e. +* KVM doesn't have to fully process one address at a time. Exit to +* userspace if a GPA is invalid. Note, all structures are aligned and +* cannot split pages. +*/ +if (sgx_gpa_to_hva (vcpu, sig_gpa, &sig_hva) || +sgx_gpa_to_hva (vcpu, secs_gpa, &secs_hva) || +sgx_gpa_to_hva (vcpu, token_gpa, &token_hva)) +return 0 ; + + ret =sgx_virt_einit ((void __user *)sig_hva, (void __user *)token_hva, + (void __user *)secs_hva, + vmx->msr_ia32_sgxlepubkeyhash, &trapnr); + +if (ret == -EFAULT ) +return sgx_inject_fault (vcpu, secs_gva, trapnr); + +/* +* sgx_virt_einit() returns -EINVAL when access_ok() fails on +* @sig_hva, @token_hva or @secs_hva. It's unexpected and is kernel bug. +* Just return. +*/ +if (ret <0 ) +return ret; + + rflags =vmx_get_rflags (vcpu) & ~(X86_EFLAGS_CF |X86_EFLAGS_PF | +X86_EFLAGS_AF |X86_EFLAGS_SF | +X86_EFLAGS_OF ); +if (ret) + rflags |=X86_EFLAGS_ZF ; +else + rflags &= ~X86_EFLAGS_ZF ; +vmx_set_rflags (vcpu, rflags); + +kvm_rax_write (vcpu, ret); +return kvm_skip_emulated_instruction (vcpu); +} +static inline bool encls_leaf_enabled_in_guest (struct kvm_vcpu *vcpu,u32 leaf) {if (!enable_sgx || !guest_cpuid_has (vcpu,X86_FEATURE_SGX ))
@@ -318,6 +379,8 @@ int handle_encls(struct kvm_vcpu *vcpu) }else {if (leaf ==ECREATE )return handle_encls_ecreate (vcpu); +if (leaf ==EINIT ) +return handle_encls_einit (vcpu);WARN (1 ,"KVM: unexpected exit on ENCLS[%u]" , leaf); vcpu->run->exit_reason =KVM_EXIT_UNKNOWN ; vcpu->run->hw.hardware_exit_reason =EXIT_REASON_ENCLS ;
Signature · 1 line
2.30.2
PATCH v4 10/11 KVM: VMX: Enable SGX virtualization for SGX1, SGX2 and LC
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Enable SGX virtualization now that KVM has the VM-Exit handlers needed to trap-and-execute ENCLS to ensure correctness and/or enforce the CPU model exposed to the guest. Add a KVM module param, "sgx", to allow an admin to disable SGX virtualization independent of the kernel.
When supported in hardware and the kernel, advertise SGX1, SGX2 and SGX LC to userspace via CPUID and wire up the ENCLS_EXITING bitmap based on the guest's SGX capabilities, i.e. to allow ENCLS to be executed in an SGX-enabled guest. With the exception of the provision key, all SGX attribute bits may be exposed to the guest. Guest access to the provision key, which is controlled via securityfs, will be added in a future patch.
Note, KVM does not yet support exposing ENCLS_C leafs or ENCLV leafs.
--- arch/x86/kvm/cpuid.c | 57 +++++++++++++++++++++++++++- arch/x86/kvm/vmx/nested.c | 26 +++++++++++-- arch/x86/kvm/vmx/nested.h | 5 +++ arch/x86/kvm/vmx/sgx.c | 80 ++++++++++++++++++++++++++++++++++++++- arch/x86/kvm/vmx/sgx.h | 13 +++++++ arch/x86/kvm/vmx/vmcs12.c | 1 + arch/x86/kvm/vmx/vmcs12.h | 4 +- arch/x86/kvm/vmx/vmx.c | 35 ++++++++++++++++- 8 files changed, 212 insertions(+), 9 deletions(-)
arch/x86/kvm/cpuid.c +55 -2
@@ -18,6 +18,7 @@#include <asm/processor.h> #include <asm/user.h> #include <asm/fpu/xstate.h> +#include <asm/sgx.h> #include "cpuid.h" #include "lapic.h" #include "mmu.h"
@@ -171,6 +172,21 @@ static void kvm_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu) vcpu->arch.guest_supported_xcr0 = (best->eax | ((u64 )best->edx <<32 )) & supported_xcr0; +/* +* Bits 127:0 of the allowed SECS.ATTRIBUTES (CPUID.0x12.0x1) enumerate +* the supported XSAVE Feature Request Mask (XFRM), i.e. the enclave's +* requested XCR0 value. The enclave's XFRM must be a subset of XCRO +* at the time of EENTER, thus adjust the allowed XFRM by the guest's +* supported XCR0. Similar to XCR0 handling, FP and SSE are forced to +* '1' even on CPUs that don't support XSAVE. +*/ + best =kvm_find_cpuid_entry (vcpu,0x12 ,0x1 ); +if (best) { + best->ecx &= vcpu->arch.guest_supported_xcr0 &0xffffffff ; + best->edx &= vcpu->arch.guest_supported_xcr0 >>32 ; + best->ecx |=XFEATURE_MASK_FPSSE ; + } +kvm_update_pv_runtime (vcpu); vcpu->arch.maxphyaddr =cpuid_query_maxphyaddr (vcpu);
@@ -429,7 +445,7 @@ void kvm_set_cpu_caps(void) ); kvm_cpu_cap_mask(CPUID_7_0_EBX, - F(FSGSBASE) | F(BMI1) | F(HLE) | F(AVX2) | F(SMEP) | + F(FSGSBASE) | F(SGX) | F(BMI1) | F(HLE) | F(AVX2) | F(SMEP) | F(BMI2) | F(ERMS) | F(INVPCID) | F(RTM) | 0 /*MPX*/ | F(RDSEED) | F(ADX) | F(SMAP) | F(AVX512IFMA) | F(AVX512F) | F(AVX512PF) | F(AVX512ER) | F(AVX512CD) | F(CLFLUSHOPT) | F(CLWB) | F(AVX512DQ) |
@@ -440,7 +456,8 @@ void kvm_set_cpu_caps(void)F (AVX512VBMI ) |F (LA57 ) |F (PKU ) |0 /*OSPKE*/ |F (RDPID ) |F (AVX512_VPOPCNTDQ ) |F (UMIP ) |F (AVX512_VBMI2 ) |F (GFNI ) |F (VAES ) |F (VPCLMULQDQ ) |F (AVX512_VNNI ) |F (AVX512_BITALG ) | -F (CLDEMOTE ) |F (MOVDIRI ) |F (MOVDIR64B ) |0 /*WAITPKG*/ +F (CLDEMOTE ) |F (MOVDIRI ) |F (MOVDIR64B ) |0 /*WAITPKG*/ | +F (SGX_LC ) );/* Set LA57 based on hardware capability. */ if (cpuid_ecx (7 ) &F (LA57 ))
@@ -479,6 +496,10 @@ void kvm_set_cpu_caps(void)F (XSAVEOPT ) |F (XSAVEC ) |F (XGETBV1 ) |F (XSAVES ) ); +kvm_cpu_cap_init (CPUID_12_EAX , +SF (SGX1 ) |SF (SGX2 ) + ); + kvm_cpu_cap_mask(CPUID_8000_0001_ECX, F(LAHF_LM) | F(CMP_LEGACY) | 0 /*SVM*/ | 0 /* ExtApicSpace */ | F(CR8_LEGACY) | F(ABM) | F(SSE4A) | F(MISALIGNSSE) |
@@ -800,6 +821,38 @@ 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 )) { + entry->eax = entry->ebx = entry->ecx = entry->edx =0 ; +break ; + } + +/* +* Index 0: Sub-features, MISCSELECT (a.k.a extended features) +* and max enclave sizes. The SGX sub-features and MISCSELECT +* are restricted by kernel and KVM capabilities (like most +* feature flags), while enclave size is unrestricted. +*/ +cpuid_entry_override (entry,CPUID_12_EAX ); + entry->ebx &=SGX_MISC_EXINFO ; + + entry =do_host_cpuid (array, function,1 ); +if (!entry) + goto out; + +/* +* Index 1: SECS.ATTRIBUTES. ATTRIBUTES are restricted a la +* feature flags. Advertise all supported flags, including +* privileged attributes that require explicit opt-in from +* userspace. ATTRIBUTES.XFRM is not adjusted as userspace is +* expected to derive it from supported XCR0. +*/ + entry->eax &=SGX_ATTR_DEBUG |SGX_ATTR_MODE64BIT | +/* PROVISIONKEY | */ SGX_ATTR_EINITTOKENKEY | +SGX_ATTR_KSS ; + entry->ebx &=0 ; +break ;/* Intel PT */ case 0x14 :if (!kvm_cpu_cap_has (X86_FEATURE_INTEL_PT )) {
arch/x86/kvm/vmx/nested.c +23 -3
@@ -11,6 +11,7 @@#include "mmu.h" #include "nested.h" #include "pmu.h" +#include "sgx.h" #include "trace.h" #include "vmx.h" #include "x86.h"
@@ -2306,6 +2307,9 @@ static void prepare_vmcs02_early(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12)if (!nested_cpu_has2 (vmcs12,SECONDARY_EXEC_UNRESTRICTED_GUEST )) exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST ; +if (exec_control &SECONDARY_EXEC_ENCLS_EXITING ) +vmx_write_encls_bitmap (&vmx->vcpu, vmcs12); +secondary_exec_controls_set (vmx, exec_control); }
@@ -5707,6 +5711,20 @@ static bool nested_vmx_exit_handled_cr(struct kvm_vcpu *vcpu,return false; } +static bool nested_vmx_exit_handled_encls (struct kvm_vcpu *vcpu, +struct vmcs12 *vmcs12) +{ +u32 encls_leaf; + +if (!nested_cpu_has2 (vmcs12,SECONDARY_EXEC_ENCLS_EXITING )) +return false; + + encls_leaf =kvm_rax_read (vcpu); +if (encls_leaf >62 ) + encls_leaf =63 ; +return vmcs12->encls_exiting_bitmap &BIT_ULL (encls_leaf); +} +static bool nested_vmx_exit_handled_vmcs_access (struct kvm_vcpu *vcpu,struct vmcs12 *vmcs12,gpa_t bitmap) {
@@ -5803,9 +5821,6 @@ static bool nested_vmx_l0_wants_exit(struct kvm_vcpu *vcpu,case EXIT_REASON_VMFUNC :/* VM functions are emulated through L2->L0 vmexits. */ return true; -case EXIT_REASON_ENCLS : -/* SGX is never exposed to L1 */ -return true;default :break ; }
@@ -5929,6 +5944,8 @@ static bool nested_vmx_l1_wants_exit(struct kvm_vcpu *vcpu,case EXIT_REASON_TPAUSE :return nested_cpu_has2 (vmcs12,SECONDARY_EXEC_ENABLE_USR_WAIT_PAUSE ); +case EXIT_REASON_ENCLS : +return nested_vmx_exit_handled_encls (vcpu, vmcs12);default :return true; }
@@ -6504,6 +6521,9 @@ void nested_vmx_setup_ctls_msrs(struct nested_vmx_msrs *msrs, u32 ept_caps) msrs->secondary_ctls_high |=SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES ; +if (enable_sgx) + msrs->secondary_ctls_high |=SECONDARY_EXEC_ENCLS_EXITING ; +/* miscellaneous data */ rdmsr(MSR_IA32_VMX_MISC, msrs->misc_low,
arch/x86/kvm/vmx/nested.h +5 -0
@@ -244,6 +244,11 @@ static inline bool nested_exit_on_intr(struct kvm_vcpu *vcpu)PIN_BASED_EXT_INTR_MASK ; } +static inline bool nested_cpu_has_encls_exit (struct vmcs12 *vmcs12) +{ +return nested_cpu_has2 (vmcs12,SECONDARY_EXEC_ENCLS_EXITING ); +} +/* * if fixed0[i] == 1: val[i] must be 1 * if fixed1[i] == 0: val[i] must be 0
arch/x86/kvm/vmx/sgx.c +79 -1
93 lines not on this page · raw message
arch/x86/kvm/vmx/sgx.h +13 -0
@@ -4,6 +4,9 @@#include <linux/kvm_host.h> +#include "capabilities.h" +#include "vmx_ops.h" +#ifdef CONFIG_X86_SGX_KVM extern bool __read_mostly enable_sgx;
@@ -11,11 +14,21 @@ int handle_encls(struct kvm_vcpu *vcpu);void setup_default_sgx_lepubkeyhash (void );void vcpu_setup_sgx_lepubkeyhash (struct kvm_vcpu *vcpu); + +void vmx_write_encls_bitmap (struct kvm_vcpu *vcpu,struct vmcs12 *vmcs12);#else #define enable_sgx 0static inline void setup_default_sgx_lepubkeyhash (void ) { }static inline void vcpu_setup_sgx_lepubkeyhash (struct kvm_vcpu *vcpu) { } + +static inline void vmx_write_encls_bitmap (struct kvm_vcpu *vcpu, +struct vmcs12 *vmcs12) +{ +/* Nothing to do if hardware doesn't support SGX */ +if (cpu_has_vmx_encls_vmexit ()) +vmcs_write64 (ENCLS_EXITING_BITMAP ,-1ull ); +}#endif #endif /* __KVM_X86_SGX_H */
arch/x86/kvm/vmx/vmcs12.c +1 -0
@@ -50,6 +50,7 @@ const unsigned short vmcs_field_to_offset_table[] = {FIELD64 (VMREAD_BITMAP , vmread_bitmap),FIELD64 (VMWRITE_BITMAP , vmwrite_bitmap),FIELD64 (XSS_EXIT_BITMAP , xss_exit_bitmap), +FIELD64 (ENCLS_EXITING_BITMAP , encls_exiting_bitmap),FIELD64 (GUEST_PHYSICAL_ADDRESS , guest_physical_address),FIELD64 (VMCS_LINK_POINTER , vmcs_link_pointer), FIELD64(GUEST_IA32_DEBUGCTL, guest_ia32_debugctl),
arch/x86/kvm/vmx/vmcs12.h +3 -1
@@ -69,7 +69,8 @@ struct __packed vmcs12 {u64 vm_function_control;u64 eptp_list_address;u64 pml_address; -u64 padding64[3 ];/* room for future expansion */ +u64 encls_exiting_bitmap; +u64 padding64[2 ];/* room for future expansion */ /* * To allow migration of L1 (complete with its L2 guests) between * machines of different natural widths (32 or 64 bit), we cannot have
@@ -256,6 +257,7 @@ static inline void vmx_check_vmcs12_offsets(void)CHECK_OFFSET (vm_function_control,296 );CHECK_OFFSET (eptp_list_address,304 );CHECK_OFFSET (pml_address,312 ); +CHECK_OFFSET (encls_exiting_bitmap,320 );CHECK_OFFSET (cr0_guest_host_mask,344 );CHECK_OFFSET (cr4_guest_host_mask,352 );CHECK_OFFSET (cr0_read_shadow,360 );
arch/x86/kvm/vmx/vmx.c +33 -2
@@ -2204,6 +2204,9 @@ static int vmx_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info) vmx->msr_ia32_feature_control = data;if (msr_info->host_initiated && data ==0 )vmx_leave_nested (vcpu); + +/* SGX may be enabled/disabled by guest's firmware */ +vmx_write_encls_bitmap (vcpu,NULL );break ; case MSR_IA32_SGXLEPUBKEYHASH0 ... MSR_IA32_SGXLEPUBKEYHASH3: if (!msr_info->host_initiated &&
@@ -4366,6 +4369,15 @@ static void vmx_compute_secondary_exec_control(struct vcpu_vmx *vmx)if (!vcpu->kvm->arch.bus_lock_detection_enabled) exec_control &= ~SECONDARY_EXEC_BUS_LOCK_DETECTION ; +if (cpu_has_vmx_encls_vmexit () && nested) { +if (guest_cpuid_has (vcpu,X86_FEATURE_SGX )) + vmx->nested.msrs.secondary_ctls_high |= +SECONDARY_EXEC_ENCLS_EXITING ; +else + vmx->nested.msrs.secondary_ctls_high &= + ~SECONDARY_EXEC_ENCLS_EXITING ; + } + vmx->secondary_exec_control = exec_control; }
@@ -4465,8 +4477,7 @@ static void init_vmcs(struct vcpu_vmx *vmx)vmcs_write16 (GUEST_PML_INDEX ,PML_ENTITY_NUM -1 ); } -if (cpu_has_vmx_encls_vmexit ()) -vmcs_write64 (ENCLS_EXITING_BITMAP ,-1ull ); +vmx_write_encls_bitmap (&vmx->vcpu,NULL );if (vmx_pt_mode_is_host_guest ()) {memset (&vmx->pt_desc,0 ,sizeof (vmx->pt_desc));
@@ -7364,6 +7375,19 @@ static void vmx_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu)set_cr4_guest_host_mask (vmx); +vmx_write_encls_bitmap (vcpu,NULL ); +if (guest_cpuid_has (vcpu,X86_FEATURE_SGX )) + vmx->msr_ia32_feature_control_valid_bits |=FEAT_CTL_SGX_ENABLED ; +else + vmx->msr_ia32_feature_control_valid_bits &= ~FEAT_CTL_SGX_ENABLED ; + +if (guest_cpuid_has (vcpu,X86_FEATURE_SGX_LC )) + vmx->msr_ia32_feature_control_valid_bits |= +FEAT_CTL_SGX_LC_ENABLED ; +else + vmx->msr_ia32_feature_control_valid_bits &= + ~FEAT_CTL_SGX_LC_ENABLED ; +/* Refresh #PF interception to account for MAXPHYADDR changes. */ vmx_update_exception_bitmap (vcpu); }
@@ -7384,6 +7408,13 @@ static __init void vmx_set_cpu_caps(void)if (vmx_pt_mode_is_host_guest ())kvm_cpu_cap_check_and_set (X86_FEATURE_INTEL_PT ); +if (!enable_sgx) { +kvm_cpu_cap_clear (X86_FEATURE_SGX ); +kvm_cpu_cap_clear (X86_FEATURE_SGX_LC ); +kvm_cpu_cap_clear (X86_FEATURE_SGX1 ); +kvm_cpu_cap_clear (X86_FEATURE_SGX2 ); + } +if (vmx_umip_emulated ())kvm_cpu_cap_set (X86_FEATURE_UMIP );
Signature · 1 line
2.30.2
PATCH v4 11/11 KVM: x86: Add capability to grant VM access to privileged SGX attribute
In reply to Kai HuangFrom: Sean Christopherson <[email protected]>
Add a capability, KVM_CAP_SGX_ATTRIBUTE, that can be used by userspace to grant a VM access to a priveleged attribute, with args[0] holding a file handle to a valid SGX attribute file.
The SGX subsystem restricts access to a subset of enclave attributes to provide additional security for an uncompromised kernel, e.g. to prevent malware from using the PROVISIONKEY to ensure its nodes are running inside a geniune SGX enclave and/or to obtain a stable fingerprint.
To prevent userspace from circumventing such restrictions by running an enclave in a VM, KVM restricts guest access to privileged attributes by default.
--- Documentation/virt/kvm/api.rst | 23 +++++++++++++++++++++++ arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/x86.c | 21 +++++++++++++++++++++ include/uapi/linux/kvm.h | 1 + 4 files changed, 46 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +23 -0
@@ -6230,6 +6230,29 @@ KVM_RUN_BUS_LOCK flag is used to distinguish between them. This capability can be used to check / enable 2nd DAWR feature provided by POWER10 processor. +7.24 KVM_CAP_SGX_ATTRIBUTE +---------------------- + +:Architectures: x86 +:Target: VM +:Parameters: args[0] is a file handle of a SGX attribute file in securityfs +:Returns: 0 on success, -EINVAL if the file handle is invalid or if a requested + attribute is not supported by KVM. + +KVM_CAP_SGX_ATTRIBUTE enables a userspace VMM to grant a VM access to one or +more priveleged enclave attributes. args[0] must hold a file handle to a valid +SGX attribute file corresponding to an attribute that is supported/restricted +by KVM (currently only PROVISIONKEY). + +The SGX subsystem restricts access to a subset of enclave attributes to provide +additional security for an uncompromised kernel, e.g. use of the PROVISIONKEY +is restricted to deter malware from using the PROVISIONKEY to obtain a stable +system fingerprint. To prevent userspace from circumventing such restrictions +by running an enclave in a VM, KVM prevents access to privileged attributes by +default. + +See Documentation/x86/sgx/2.Kernel-internals.rst for more details. + 8. Other capabilities. ======================
arch/x86/kvm/cpuid.c +1 -1
@@ -849,7 +849,7 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function)* expected to derive it from supported XCR0. */ entry->eax &=SGX_ATTR_DEBUG |SGX_ATTR_MODE64BIT | -/* PROVISIONKEY | */ SGX_ATTR_EINITTOKENKEY | +SGX_ATTR_PROVISIONKEY |SGX_ATTR_EINITTOKENKEY |SGX_ATTR_KSS ; entry->ebx &=0 ;break ;
arch/x86/kvm/x86.c +21 -0
@@ -75,6 +75,7 @@#include <asm/tlbflush.h> #include <asm/intel_pt.h> #include <asm/emulate_prefix.h> +#include <asm/sgx.h> #include <clocksource/hyperv_timer.h> #define CREATE_TRACE_POINTS
@@ -3759,6 +3760,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_X86_USER_SPACE_MSR :case KVM_CAP_X86_MSR_FILTER :case KVM_CAP_ENFORCE_PV_FEATURE_CPUID : +#ifdef CONFIG_X86_SGX_KVM +case KVM_CAP_SGX_ATTRIBUTE : +#endif r =1 ;break ;#ifdef CONFIG_KVM_XEN
@@ -5345,6 +5349,23 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, kvm->arch.bus_lock_detection_enabled = true; r =0 ;break ; +#ifdef CONFIG_X86_SGX_KVM +case KVM_CAP_SGX_ATTRIBUTE : { +unsigned long allowed_attributes =0 ; + + r =sgx_set_attribute (&allowed_attributes, cap->args[0 ]); +if (r) +break ; + +/* KVM only supports the PROVISIONKEY privileged attribute. */ +if ((allowed_attributes &SGX_ATTR_PROVISIONKEY ) && + !(allowed_attributes & ~SGX_ATTR_PROVISIONKEY )) + kvm->arch.sgx_provisioning_allowed = true; +else + r = -EINVAL ; +break ; + } +#endif default : r = -EINVAL ;break ;
include/uapi/linux/kvm.h +1 -0
@@ -1078,6 +1078,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_DIRTY_LOG_RING 192#define KVM_CAP_X86_BUS_LOCK_EXIT 193#define KVM_CAP_PPC_DAWR1 194 +#define KVM_CAP_SGX_ATTRIBUTE 195#ifdef KVM_CAP_IRQ_ROUTING
Signature · 1 line
2.30.2
Quoted 19 lines · On Thu, 8 Apr 2021 08:49:24 +1200 Kai Huang wrote:
Hi Paolo, Sean,
Boris has merged x86 part patches to the tip/x86/sgx. This series is KVM part patches. Due to some code change in x86 part patches, two KVM patches need update so this is the new version. Please help to review. Thanks!
Specifically, x86 patch (x86/sgx: Add helpers to expose ECREATE and EINIT to KVM) was changed to return
-EINVALdirectly w/o setting trapnr when access_ok()s fail on any user pointers, so KVM patches:KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
KVM: VMX: Add ENCLS[EINIT] handler to support SGX Launch Control (LC)were updated to handle this case.
This seris is still based on tip/x86/sgx (which is based on 5.12-rc3), since it requires x86 patches to work. I tried to rebase them to latest kvm/queue, but found patch
Quoted 5 lines
KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
KVM: x86: Add capability to grant VM access to privileged SGX aattributehave merge conflict, but the conflict is quite easy to resolve, so I didn't sent out the resolved version. Please let me know how would you like to proceed.
Hi Paolo, Sean,
Be more specifically, the first merge conflict is in patch (KVM: VMX: Add emulation of SGX Launch Control LE hash MSRs) (sorry I made a mistake about which patch above). The new added msr_ia32_sgxlepubkeyhash[4] to struct vcpu_vmx{} conflicts with hyperv's hv_root_ept:
++<<<<<<< HEAD
+#if IS_ENABLED(CONFIG_HYPERV)
+ u64 hv_root_ept;
+#endif
++=======
+ /* SGX Launch Control public key hash */ + u64 msr_ia32_sgxlepubkeyhash[4]; + u64 ept_pointer;
++>>>>>>> ebe348a4bbc1 (KVM: VMX: Add emulation of SGX Launch Control LE hash MSRs)
The second conflict is the last patch (KVM: x86: Add capability to grant VM access to privileged SGX aattribute), due to new added KVM_CAP_VM_COPY_ENC_CONTEXT_FROM capability conflicts with KVM_CAP_SGX_ATTRIBUTE.
They are both easy to resolve.
For the next version, I think I can do:
1) grab SGX x86 part patches from tip/x86/sgx, and rebase all patches to kvm/queue (basically rebase tip/x86/sgx to kvm/queue + new KVM patches), and send out the rebased patches.
2) Still base on existing tip/x86/sgx, and let you to handle merge conflict.
Which way do you prefer? Do you have any other suggestions?
Quoted 41 lines
Thank you all guys!
Sean Christopherson (11):
KVM: x86: Export kvm_mmu_gva_to_gpa_{read,write}() for SGX (VMX)
KVM: x86: Define new #PF SGX error code bit
KVM: x86: Add support for reverse CPUID lookup of scattered features
KVM: x86: Add reverse-CPUID lookup support for scattered SGX features
KVM: VMX: Add basic handling of VM-Exit from SGX enclave
KVM: VMX: Frame in ENCLS handler for SGX virtualization
KVM: VMX: Add SGX ENCLS[ECREATE] handler to enforce CPUID restrictions
KVM: VMX: Add emulation of SGX Launch Control LE hash MSRs
KVM: VMX: Add ENCLS[EINIT] handler to support SGX Launch Control (LC)
KVM: VMX: Enable SGX virtualization for SGX1, SGX2 and LC
KVM: x86: Add capability to grant VM access to privileged SGX
attributeDocumentation/virt/kvm/api.rst | 23 ++ arch/x86/include/asm/kvm_host.h | 5 + arch/x86/include/asm/vmx.h | 1 + arch/x86/include/uapi/asm/vmx.h | 1 + arch/x86/kvm/Makefile | 2 + arch/x86/kvm/cpuid.c | 89 +++++- arch/x86/kvm/cpuid.h | 50 +++- arch/x86/kvm/vmx/nested.c | 28 +- arch/x86/kvm/vmx/nested.h | 5 + arch/x86/kvm/vmx/sgx.c | 500 ++++++++++++++++++++++++++++++++ arch/x86/kvm/vmx/sgx.h | 34 +++ arch/x86/kvm/vmx/vmcs12.c | 1 + arch/x86/kvm/vmx/vmcs12.h | 4 +- arch/x86/kvm/vmx/vmx.c | 109 ++++++- arch/x86/kvm/vmx/vmx.h | 2 + arch/x86/kvm/x86.c | 23 ++ include/uapi/linux/kvm.h | 1 + 17 files changed, 855 insertions(+), 23 deletions(-) create mode 100644 arch/x86/kvm/vmx/sgx.c create mode 100644 arch/x86/kvm/vmx/sgx.hSignature · 1 line
2.30.2