KVM: PKS Virtualization support
v5 cover KVM: PKS Virtualization support
This patch series is based on top of kernel patchset:
https://lore.kernel.org/lkml/[email protected]/
To help patches review, one missing info in SDM is that PKSR will be cleared on Powerup/INIT/RESET, which should be listed in Table 9.1 "IA-32 and Intel 64 Processor States Following Power-up, Reset, or INIT"
---
Protection Keys for Supervisor Pages(PKS) is a feature that extends the Protection Keys architecture to support thread-specific permission restrictions on supervisor pages.
PKS works similar to an existing feature named PKU(protecting user pages). They both perform an additional check after normal paging permission checks are done. Access or Writes can be disabled via a MSR update without TLB flushes when permissions changes. If violating this addional check, #PF occurs and PFEC.PK bit will be set.
PKS introduces MSR IA32_PKRS to manage supervisor protection key rights. The MSR contains 16 pairs of ADi and WDi bits. Each pair advertises on a group of pages with the same key which is set in the leaf paging-structure entries(bits[62:59]). Currently, IA32_PKRS is not supported by XSAVES architecture.
This patchset aims to add the virtualization of PKS in KVM. It implemented PKS CPUID enumeration, vmentry/vmexit configuration, MSR exposure, nested supported etc. Currently, PKS is not yet supported for shadow paging.
Detailed information about PKS can be found in the latest Intel 64 and IA-32 Architectures Software Developer's Manual.
---
Changelogs:
v4->v5
- Make setting of MSR intercept/vmcs control bits not dependent on guest.CR4.PKS. And set them if PKS is exposed to guest. (Suggested by Sean)
- Add pkrs to standard register caching mechanism to help update vcpu->arch.pkrs on demand. Add related helper functions. (Suggested by Sean)
- Do the real pkrs update in VMCS field in vmx_vcpu_reset and vmx_sync_vmcs_host_state(). (Sean)
- Add a new mmu_role cr4_pks instead of smushing PKU and PKS together. (Sean & Paolo)
- v4: https://lore.kernel.org/lkml/[email protected]/
v3->v4
- Make the MSR intercept and load-controls setting depend on CR4.PKS value
- shadow the guest pkrs and make it usable in PKS emultion
- add the cr4_pke and cr4_pks check in pkr_mask update
- squash PATCH 2 and PATCH 5 to make the dependencies read more clear
- v3: https://lore.kernel.org/lkml/[email protected]/
v2->v3:
- No function changes since last submit
- rebase on the latest PKS kernel support:
https://lore.kernel.org/lkml/[email protected]/
- add MSR_IA32_PKRS to the vmx_possible_passthrough_msrs[]
- RFC v2: https://lore.kernel.org/lkml/[email protected]/
v1->v2:
- rebase on the latest PKS kernel support:
https://github.com/weiny2/linux-kernel/tree/pks-rfc-v3
- add a kvm-unit-tests for PKS
- add the check in kvm_init_msr_list for PKRS
- place the X86_CR4_PKS in mmu_role_bits in kvm_set_cr4
- add the support to expose VM_{ENTRY, EXIT}_LOAD_IA32_PKRS in nested VMX MSR
- RFC v1: https://lore.kernel.org/lkml/[email protected]/
---
Chenyi Qiang (7):
KVM: VMX: Introduce PKS VMCS fields
KVM: VMX: Add proper cache tracking for PKRS
KVM: X86: Expose IA32_PKRS MSR
KVM: MMU: Rename the pkru to pkr
KVM: MMU: Add support for PKS emulation
KVM: VMX: Expose PKS to guest
KVM: VMX: Enable PKS for nested VM
arch/x86/include/asm/kvm_host.h | 17 ++++--- arch/x86/include/asm/vmx.h | 6 +++ arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/kvm_cache_regs.h | 7 +++ arch/x86/kvm/mmu.h | 25 +++++---- arch/x86/kvm/mmu/mmu.c | 68 ++++++++++++++----------- arch/x86/kvm/vmx/capabilities.h | 6 +++ arch/x86/kvm/vmx/nested.c | 41 ++++++++++++++- arch/x86/kvm/vmx/vmcs.h | 1 + arch/x86/kvm/vmx/vmcs12.c | 2 + arch/x86/kvm/vmx/vmcs12.h | 4 ++ arch/x86/kvm/vmx/vmx.c | 89 ++++++++++++++++++++++++++++++--- arch/x86/kvm/vmx/vmx.h | 7 ++- arch/x86/kvm/x86.c | 6 ++- arch/x86/kvm/x86.h | 8 +++ arch/x86/mm/pkeys.c | 6 +++ include/linux/pkeys.h | 5 ++ 17 files changed, 243 insertions(+), 57 deletions(-)
Signature · 1 line
2.17.1
PATCH v5 1/7 KVM: VMX: Introduce PKS VMCS fields
PKS(Protection Keys for Supervisor Pages) is a feature that extends the Protection Key architecture to support thread-specific permission restrictions on supervisor pages.
A new PKS MSR(PKRS) is defined in kernel to support PKS, which holds a set of permissions associated with each protection domain.
Two VMCS fields {HOST,GUEST}_IA32_PKRS are introduced in {host,guest}-state area to store the respective values of PKRS.
Every VM exit saves PKRS into guest-state area.
If VM_EXIT_LOAD_IA32_PKRS = 1, VM exit loads PKRS from the host-state area.
If VM_ENTRY_LOAD_IA32_PKRS = 1, VM entry loads PKRS from the guest-state area.
--- arch/x86/include/asm/vmx.h | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/include/asm/vmx.h +6 -0
@@ -95,6 +95,7 @@#define VM_EXIT_CLEAR_BNDCFGS 0x00800000#define VM_EXIT_PT_CONCEAL_PIP 0x01000000#define VM_EXIT_CLEAR_IA32_RTIT_CTL 0x02000000 +#define VM_EXIT_LOAD_IA32_PKRS 0x20000000#define VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR 0x00036dff
@@ -108,6 +109,7 @@#define VM_ENTRY_LOAD_BNDCFGS 0x00010000#define VM_ENTRY_PT_CONCEAL_PIP 0x00020000#define VM_ENTRY_LOAD_IA32_RTIT_CTL 0x00040000 +#define VM_ENTRY_LOAD_IA32_PKRS 0x00400000#define VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR 0x000011ff
@@ -245,12 +247,16 @@ enum vmcs_field {GUEST_BNDCFGS_HIGH =0x00002813 ,GUEST_IA32_RTIT_CTL =0x00002814 ,GUEST_IA32_RTIT_CTL_HIGH =0x00002815 , +GUEST_IA32_PKRS =0x00002818 , +GUEST_IA32_PKRS_HIGH =0x00002819 ,HOST_IA32_PAT =0x00002c00 ,HOST_IA32_PAT_HIGH =0x00002c01 ,HOST_IA32_EFER =0x00002c02 ,HOST_IA32_EFER_HIGH =0x00002c03 ,HOST_IA32_PERF_GLOBAL_CTRL =0x00002c04 ,HOST_IA32_PERF_GLOBAL_CTRL_HIGH =0x00002c05 , +HOST_IA32_PKRS =0x00002c06 , +HOST_IA32_PKRS_HIGH =0x00002c07 ,PIN_BASED_VM_EXEC_CONTROL =0x00004000 ,CPU_BASED_VM_EXEC_CONTROL =0x00004002 , EXCEPTION_BITMAP = 0x00004004,
Signature · 1 line
2.17.1
PATCH v5 2/7 KVM: VMX: Add proper cache tracking for PKRS
In reply to Chenyi QiangAdd PKRS caching into the standard register caching mechanism in order to take advantage of the availability checks provided by regs_avail.
This is because vcpu->arch.pkrs will be rarely acceesed by KVM, only in the case of host userspace MSR reads and GVA->GPA translation in following patches. It is unnecessary to keep it up-to-date at all times.
--- arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/kvm_cache_regs.h | 7 +++++++ arch/x86/kvm/vmx/vmx.c | 4 ++++ arch/x86/kvm/vmx/vmx.h | 3 ++- 4 files changed, 15 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +2 -0
@@ -173,6 +173,7 @@ enum kvm_reg {VCPU_EXREG_SEGMENTS ,VCPU_EXREG_EXIT_INFO_1 ,VCPU_EXREG_EXIT_INFO_2 , + VCPU_EXREG_PKRS, }; enum {
@@ -620,6 +621,7 @@ struct kvm_vcpu_arch {unsigned long cr8;u32 host_pkru;u32 pkru; +u32 pkrs;u32 hflags;u64 efer;u64 apic_base;
arch/x86/kvm/kvm_cache_regs.h +7 -0
@@ -171,6 +171,13 @@ static inline u64 kvm_read_edx_eax(struct kvm_vcpu *vcpu) | ((u64)(kvm_rdx_read(vcpu) & -1u) << 32); } +static inline ulong kvm_read_pkrs (struct kvm_vcpu *vcpu) +{ +if (!kvm_register_is_available (vcpu,VCPU_EXREG_PKRS )) +static_call (kvm_x86_cache_reg)(vcpu,VCPU_EXREG_PKRS ); +return vcpu->arch.pkrs; +} +static inline void enter_guest_mode (struct kvm_vcpu *vcpu) { vcpu->arch.hflags |=HF_GUEST_MASK ;
arch/x86/kvm/vmx/vmx.c +4 -0
@@ -2273,6 +2273,10 @@ static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg) vcpu->arch.cr4 &= ~guest_owned_bits; vcpu->arch.cr4 |=vmcs_readl (GUEST_CR4 ) & guest_owned_bits;break ; +case VCPU_EXREG_PKRS : +if (kvm_cpu_cap_has (X86_FEATURE_PKS )) + vcpu->arch.pkrs =vmcs_read64 (GUEST_IA32_PKRS ); +break ;default :WARN_ON_ONCE (1 );break ;
arch/x86/kvm/vmx/vmx.h +2 -1
@@ -447,7 +447,8 @@ static inline void vmx_register_cache_reset(struct kvm_vcpu *vcpu) | (1 << VCPU_EXREG_CR3) | (1 <<VCPU_EXREG_CR4 ) | (1 <<VCPU_EXREG_EXIT_INFO_1 ) - | (1 << VCPU_EXREG_EXIT_INFO_2)); + | (1 <<VCPU_EXREG_EXIT_INFO_2 ) + | (1 << VCPU_EXREG_PKRS)); vcpu->arch.regs_dirty =0 ; }
Signature · 1 line
2.17.1
Sean Christopherson
maintainerRe: [PATCH v5 2/7] KVM: VMX: Add proper cache tracking for PKRS
Quoted 40 lines · Chenyi Qiang
Add PKRS caching into the standard register caching mechanism in order to take advantage of the availability checks provided by
regs_avail.This is because
vcpu->arch.pkrswill be rarely acceesed by KVM, only in the case of host userspace MSR reads andGVA->GPAtranslation in following patches. It is unnecessary to keep it up-to-date at all times.Signed-off-by Chenyi Qiang <[email protected]>--- arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/kvm_cache_regs.h | 7 +++++++ arch/x86/kvm/vmx/vmx.c | 4 ++++ arch/x86/kvm/vmx/vmx.h | 3 ++- 4 files changed, 15 insertions(+), 1 deletion(-)arch/x86/include/asm/kvm_host.h +2
-0@@ -173,6 +173,7 @@ enum kvm_reg {VCPU_EXREG_SEGMENTS ,VCPU_EXREG_EXIT_INFO_1 ,VCPU_EXREG_EXIT_INFO_2 , + VCPU_EXREG_PKRS, }; enum {@@ -620,6 +621,7 @@ struct kvm_vcpu_arch {unsigned long cr8;u32 host_pkru;u32 pkru; +u32 pkrs;u32 hflags;u64 efer;u64 apic_base;arch/x86/kvm/kvm_cache_regs.h +0
-0
arch/x86/kvm/kvm_cache_regs.h static inline u64 kvm_read_edx_eax(struct kvm_vcpu *vcpu) · line 174
Quoted 4 lines
arch/x86/kvm/kvm_cache_regs.h +1
-0@@ -171,6 +171,13 @@ static inline u64 kvm_read_edx_eax(struct kvm_vcpu *vcpu) | ((u64)(kvm_rdx_read(vcpu) & -1u) << 32); } +static inline ulong kvm_read_pkrs (struct kvm_vcpu *vcpu)
Return value should be u32 (or u64 if we decide to track PKRS as a 64-bit value).
Quoted 14 lines
arch/x86/kvm/kvm_cache_regs.h +6
-0+{ +if (!kvm_register_is_available (vcpu,VCPU_EXREG_PKRS )) +static_call (kvm_x86_cache_reg)(vcpu,VCPU_EXREG_PKRS ); +return vcpu->arch.pkrs; +} +static inline void enter_guest_mode (struct kvm_vcpu *vcpu) { vcpu->arch.hflags |=HF_GUEST_MASK ;arch/x86/kvm/vmx/vmx.c +0
-0
arch/x86/kvm/vmx/vmx.c static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg) · line 2277
Quoted 5 lines
arch/x86/kvm/vmx/vmx.c +2
-0@@ -2273,6 +2273,10 @@ static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg) vcpu->arch.cr4 &= ~guest_owned_bits; vcpu->arch.cr4 |=vmcs_readl (GUEST_CR4 ) & guest_owned_bits;break ; +case VCPU_EXREG_PKRS : +if (kvm_cpu_cap_has (X86_FEATURE_PKS ))
Peeking ahead, the next patch rejects RDMSR(MSR_IA32_PKRS) if X86_FEATURE_PKS isn't supported in KVM, i.e. this is WARN-worthy as KVM should PKRS if and only if PKS is supported. Since KVM will WARN if VMREAD fails, just omit this check and let VMREAD handle any errors. That won't detect the scenario where PKRS is supported in hardware but disabled by the kernel/KVM, but that's an acceptable risk since any buggy path is all but guaranteed to be reachable if PKRS isn't supported at all, i.e. the WARN will fire and detect any bug in the more common case.
arch/x86/kvm/vmx/vmx.c static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg) · line 2278
Quoted 1 line
arch/x86/kvm/vmx/vmx.c +1
-0+ vcpu->arch.pkrs =vmcs_read64 (GUEST_IA32_PKRS );
Hrm. I agree that it's extremely unlikely that IA32_PKRS will ever allow software to set bits 63:32, but at the same time there's no real advantage to KVM it as a u32, e.g. the extra 4 bytes per vCPU is a non-issue, and could be avoided by shuffling kvm_vcpu_arch to get a more efficient layout. On the flip side, using a 32 means code like this _looks_ buggy because it's silently dropping bits 63:32, and if the architecture ever does get updated, we'll have to modify a bunch of KVM code.
TL;DR: I vote to track PRKS as a u64 even though the kernel tracks it as a u32.
Quoted 21 lines
arch/x86/kvm/vmx/vmx.c +1
-0+break ;default :WARN_ON_ONCE (1 );break ;arch/x86/kvm/vmx/vmx.h +2
-1@@ -447,7 +447,8 @@ static inline void vmx_register_cache_reset(struct kvm_vcpu *vcpu) | (1 << VCPU_EXREG_CR3) | (1 <<VCPU_EXREG_CR4 ) | (1 <<VCPU_EXREG_EXIT_INFO_1 ) - | (1 << VCPU_EXREG_EXIT_INFO_2)); + | (1 <<VCPU_EXREG_EXIT_INFO_2 ) + | (1 << VCPU_EXREG_PKRS)); vcpu->arch.regs_dirty =0 ; }Signature · 1 line
2.17.1
Sean Christopherson
maintainerRe: [PATCH v5 2/7] KVM: VMX: Add proper cache tracking for PKRS
Quoted 11 lines · Sean Christopherson
arch/x86/kvm/vmx/vmx.c static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg) · line 2278
Quoted 1 line · Chenyi Qiang
arch/x86/kvm/vmx/vmx.c +1
-0+ vcpu->arch.pkrs =vmcs_read64 (GUEST_IA32_PKRS );Hrm. I agree that it's extremely unlikely that
IA32_PKRSwill ever allow software to set bits 63:32, but at the same time there's no real advantage to KVM it as a u32, e.g. the extra 4 bytes per vCPU is a non-issue, and could be avoided by shufflingkvm_vcpu_archto get a more efficient layout. On the flip side, using a 32 means code like this _looks_ buggy because it's silently dropping bits 63:32, and if the architecture ever does get updated, we'll have to modify a bunch of KVM code.TL;DR: I vote to track PRKS as a u64 even though the kernel tracks it as a u32.
Rats, I forgot that the MMU code for PKRU is going to be reused for PKRS. I withdraw my vote :-)
Maybe have this code WARN on bits 63:32 being set in the VMCS field? E.g. to detect if hardware ever changes and KVM fails to update this path, and to document that KVM intentionally drops those bits.
case VCPU_EXREG_PKRS: {
u64 ia32_pkrs;
ia32_pkrs = vmcs_read64(GUEST_IA32_PKRS);
WARN_ON_ONCE(ia32_pkrs >> 32);
vcpu->arch.pkrs = (u32)ia32_pkrs;
}PATCH v5 3/7 KVM: X86: Expose IA32_PKRS MSR
In reply to Chenyi QiangProtection Key for Superviosr Pages (PKS) uses IA32_PKRS MSR (PKRS) at index 0x6E1 to allow software to manage superviosr key rights, i.e. it can enforce additional permissions checks besides normal paging protections via a MSR update without TLB flushes when permissions change.
For performance consideration, PKRS intercept in KVM will be disabled when PKS is supported in guest so that PKRS can be accessed without VM exit.
PKS introduces dedicated control fields in VMCS to switch PKRS, which only does the retore part. In addition, every VM exit saves PKRS into the guest-state area in VMCS, while VM enter won't save the host value due to the expectation that the host won't change the MSR often. Update the host's value in VMCS manually if the MSR has been changed by the kernel since the last time the VMCS was run.
Introduce a function get_current_pkrs() in arch/x86/mm/pkeys.c exports the per-cpu variable pkrs_cache to avoid frequent rdmsr of PKRS.
--- arch/x86/kvm/vmx/vmcs.h | 1 + arch/x86/kvm/vmx/vmx.c | 69 +++++++++++++++++++++++++++++++++++++++-- arch/x86/kvm/vmx/vmx.h | 2 +- arch/x86/kvm/x86.c | 6 +++- arch/x86/kvm/x86.h | 6 ++++ arch/x86/mm/pkeys.c | 6 ++++ include/linux/pkeys.h | 5 +++ 7 files changed, 90 insertions(+), 5 deletions(-)
arch/x86/kvm/vmx/vmcs.h +1 -0
@@ -40,6 +40,7 @@ struct vmcs_host_state {#ifdef CONFIG_X86_64 u16 ds_sel, es_sel;#endif +u32 pkrs; };struct vmcs_controls_shadow {
arch/x86/kvm/vmx/vmx.c +66 -3
147 lines not on this page · raw message
arch/x86/kvm/vmx/vmx.h +1 -1
@@ -336,7 +336,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);
arch/x86/kvm/x86.c +5 -1
@@ -1303,7 +1303,7 @@ static const u32 msrs_to_save_all[] = {MSR_IA32_RTIT_ADDR1_A ,MSR_IA32_RTIT_ADDR1_B ,MSR_IA32_RTIT_ADDR2_A ,MSR_IA32_RTIT_ADDR2_B ,MSR_IA32_RTIT_ADDR3_A ,MSR_IA32_RTIT_ADDR3_B , -MSR_IA32_UMWAIT_CONTROL , +MSR_IA32_UMWAIT_CONTROL ,MSR_IA32_PKRS ,MSR_ARCH_PERFMON_FIXED_CTR0 ,MSR_ARCH_PERFMON_FIXED_CTR1 , MSR_ARCH_PERFMON_FIXED_CTR0 + 2, MSR_ARCH_PERFMON_FIXED_CTR0 + 3,
@@ -6219,6 +6219,10 @@ static void kvm_init_msr_list(void) intel_pt_validate_hw_cap(PT_CAP_num_address_ranges) * 2)continue ;break ; +case MSR_IA32_PKRS : +if (!kvm_cpu_cap_has (X86_FEATURE_PKS )) +continue ; +break ; case MSR_ARCH_PERFMON_PERFCTR0 ... MSR_ARCH_PERFMON_PERFCTR0 + 17:if (msrs_to_save_all[i] -MSR_ARCH_PERFMON_PERFCTR0 >=min (INTEL_PMC_MAX_GENERIC , x86_pmu.num_counters_gp))
arch/x86/kvm/x86.h +6 -0
@@ -436,6 +436,12 @@ static inline void kvm_machine_check(void)#endif } +static inline bool kvm_pkrs_valid (u64 data) +{ +/* bit[63,32] must be zero */ +return !(data >>32 ); +} +void kvm_load_guest_xsave_state (struct kvm_vcpu *vcpu);void kvm_load_host_xsave_state (struct kvm_vcpu *vcpu);int kvm_spec_ctrl_test_value (u64 value);
arch/x86/mm/pkeys.c +6 -0
@@ -452,4 +452,10 @@ void pks_abandon_protections(int pkey) }EXPORT_SYMBOL_GPL (pks_abandon_protections); +u32 get_current_pkrs (void ) +{ +return this_cpu_read (pkrs_cache); +} +EXPORT_SYMBOL_GPL (get_current_pkrs); +#endif /* CONFIG_ARCH_ENABLE_SUPERVISOR_PKEYS */
include/linux/pkeys.h +5 -0
@@ -62,6 +62,7 @@ void pks_mk_noaccess(int pkey);void pks_mk_readonly (int pkey);void pks_mk_readwrite (int pkey);void pks_abandon_protections (int pkey); +u32 get_current_pkrs (void );typedef bool (*pks_key_callback )(unsigned long address,bool write);
@@ -79,6 +80,10 @@ static inline void pks_mk_noaccess(int pkey) {}static inline void pks_mk_readonly (int pkey) {}static inline void pks_mk_readwrite (int pkey) {}static inline void pks_abandon_protections (int pkey) {} +static inline u32 get_current_pkrs (void ) +{ +return 0 ; +}#endif /* CONFIG_ARCH_ENABLE_SUPERVISOR_PKEYS */
Signature · 1 line
2.17.1
Sean Christopherson
maintainerRe: [PATCH v5 3/7] KVM: X86: Expose IA32_PKRS MSR
Quoted 1 line · Chenyi Qiang
(quoted diff) +1
-0+ u32 pkrs;
...
Review void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu) · line 1120
Quoted 5 lines
(quoted diff) +1
-0@@ -1115,6 +1117,7 @@ void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu) #endif unsigned long fs_base, gs_base; u16 fs_sel, gs_sel; + u32 host_pkrs;
As mentioned in the previosu patch, I think it makes sense to track this as a u64 so that the only place in KVM that deas with the u64<=>u32 conversion is the below
host_pkrs = get_current_pkrs();
Quoted 25 lines
(quoted diff) +14
-0int i; vmx->req_immediate_exit = false;@@ -1150,6 +1153,20 @@ void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu) */ host_state->ldt_sel = kvm_read_ldt(); + /* + * Update the host pkrs vmcs field before vcpu runs. + * The setting of VM_EXIT_LOAD_IA32_PKRS can ensure + * kvm_cpu_cap_has(X86_FEATURE_PKS) && + * guest_cpuid_has(vcpu, X86_FEATURE_PKS) + */ + if (vm_exit_controls_get(vmx) & VM_EXIT_LOAD_IA32_PKRS) { + host_pkrs = get_current_pkrs(); + if (unlikely(host_pkrs != host_state->pkrs)) { + vmcs_write64(HOST_IA32_PKRS, host_pkrs); + host_state->pkrs = host_pkrs; + } + } + #ifdef CONFIG_X86_64 savesegment(ds, host_state->ds_sel); savesegment(es, host_state->es_sel);
Review void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags) · line 1392
Quoted 5 lines
(quoted diff) +2
-0@@ -1371,6 +1388,15 @@ void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags) vmx->emulation_required = emulation_required(vcpu); } +static void vmx_set_pkrs(struct kvm_vcpu *vcpu, u64 pkrs) +{
Hrm. Ideally this would be open coded in vmx_set_msr(). Long term, the RESET/INIT paths should really treat MSR updates as "normal" host_initiated writes instead of having to manually handle every MSR.
That would be a bit gross to handle in vmx_vcpu_reset() since it would have to create a struct msr_data (because __kvm_set_msr() isn't exposed to vendor code), but since vcpu->arch.pkrs is relevant to the MMU I think it makes sense to initiate the write from common x86.
E.g. this way there's not out-of-band special code, vmx_vcpu_reset() is kept clean, and if/when SVM gains support for PKRS this particular path Just Works. And it would be an easy conversion for my pipe dream plan of handling MSRs at RESET/INIT via a list of MSRs+values.
arch/x86/kvm/x86.c +3 -0
@@ -11147,6 +11147,9 @@ void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event)kvm_set_rflags (vcpu,X86_EFLAGS_FIXED );kvm_rip_write (vcpu,0xfff0 ); +if (kvm_cpu_cap_has (X86_FEATURE_PKS )) +__kvm_set_msr (vcpu,MSR_IA32_PKRS ,0 , true); + vcpu->arch.cr3 =0 ;kvm_register_mark_dirty (vcpu,VCPU_EXREG_CR3 );
Quoted 6 lines
(quoted diff) +6
-0+ if (kvm_cpu_cap_has(X86_FEATURE_PKS)) { + vcpu->arch.pkrs = pkrs; + kvm_register_mark_available(vcpu, VCPU_EXREG_PKRS); + vmcs_write64(GUEST_IA32_PKRS, pkrs); + } +}
Re: [PATCH v5 3/7] KVM: X86: Expose IA32_PKRS MSR
Quoted 66 lines · Sean Christopherson
Quoted 1 line · Chenyi Qiang
(quoted diff) +1
-0+ u32 pkrs;...
Review void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu) · line 1120
Quoted 5 lines
(quoted diff) +1
-0@@ -1115,6 +1117,7 @@ void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu) #endif unsigned long fs_base, gs_base; u16 fs_sel, gs_sel; + u32 host_pkrs;As mentioned in the previosu patch, I think it makes sense to track this as a u64 so that the only place in KVM that deas with the u64<=>u32 conversion is the below
host_pkrs = get_current_pkrs();Quoted 25 lines
(quoted diff) +14
-0int i; vmx->req_immediate_exit = false;@@ -1150,6 +1153,20 @@ void vmx_prepare_switch_to_guest(struct kvm_vcpu *vcpu) */ host_state->ldt_sel = kvm_read_ldt(); + /* + * Update the host pkrs vmcs field before vcpu runs. + * The setting of VM_EXIT_LOAD_IA32_PKRS can ensure + * kvm_cpu_cap_has(X86_FEATURE_PKS) && + * guest_cpuid_has(vcpu, X86_FEATURE_PKS) + */ + if (vm_exit_controls_get(vmx) & VM_EXIT_LOAD_IA32_PKRS) { + host_pkrs = get_current_pkrs(); + if (unlikely(host_pkrs != host_state->pkrs)) { + vmcs_write64(HOST_IA32_PKRS, host_pkrs); + host_state->pkrs = host_pkrs; + } + } + #ifdef CONFIG_X86_64 savesegment(ds, host_state->ds_sel); savesegment(es, host_state->es_sel);Review void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags) · line 1392
Quoted 5 lines
(quoted diff) +2
-0@@ -1371,6 +1388,15 @@ void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags) vmx->emulation_required = emulation_required(vcpu); } +static void vmx_set_pkrs(struct kvm_vcpu *vcpu, u64 pkrs) +{Hrm. Ideally this would be open coded in
vmx_set_msr(). Long term, the RESET/INIT paths should really treat MSR updates as "normal"host_initiatedwrites instead of having to manually handle every MSR.That would be a bit gross to handle in
vmx_vcpu_reset()since it would have to create a structmsr_data(because__kvm_set_msr()isn't exposed to vendor code), but sincevcpu->arch.pkrsis relevant to the MMU I think it makes sense to initiate the write from common x86.E.g. this way there's not out-of-band special code,
vmx_vcpu_reset()is kept clean, and if/when SVM gains support for PKRS this particular path Just Works. And it would be an easy conversion for my pipe dream plan of handling MSRs at RESET/INIT via a list of MSRs+values.arch/x86/kvm/x86.c +0
-0
arch/x86/kvm/x86.c void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event) · line 11152
Quoted 6 lines
arch/x86/kvm/x86.c +3
-0@@ -11147,6 +11147,9 @@ void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event)kvm_set_rflags (vcpu,X86_EFLAGS_FIXED );kvm_rip_write (vcpu,0xfff0 ); +if (kvm_cpu_cap_has (X86_FEATURE_PKS )) +__kvm_set_msr (vcpu,MSR_IA32_PKRS ,0 , true); +
Got it. In addition, is it necessary to add on-INIT check? like:
if (kvm_cpu_cap_has(X86_FEATURE_PKS) && !init_event)
__kvm_set_msr(vcpu, MSR_IA32_PKRS, 0, true);
PKRS should be preserved on INIT, not cleared. The SDM doesn't make this clear either.
Quoted 9 lines
arch/x86/kvm/x86.c +0
-0vcpu->arch.cr3 =0 ;kvm_register_mark_dirty (vcpu,VCPU_EXREG_CR3 );Quoted 6 lines
(quoted diff) +6
-0+ if (kvm_cpu_cap_has(X86_FEATURE_PKS)) { + vcpu->arch.pkrs = pkrs; + kvm_register_mark_available(vcpu, VCPU_EXREG_PKRS); + vmcs_write64(GUEST_IA32_PKRS, pkrs); + } +}
Sean Christopherson
maintainerRe: [PATCH v5 3/7] KVM: X86: Expose IA32_PKRS MSR
Quoted 30 lines · Chenyi Qiang
Quoted 19 lines · Sean Christopherson
Hrm. Ideally this would be open coded in
vmx_set_msr(). Long term, the RESET/INIT paths should really treat MSR updates as "normal"host_initiatedwrites instead of having to manually handle every MSR.That would be a bit gross to handle in
vmx_vcpu_reset()since it would have to create a structmsr_data(because__kvm_set_msr()isn't exposed to vendor code), but sincevcpu->arch.pkrsis relevant to the MMU I think it makes sense to initiate the write from common x86.E.g. this way there's not out-of-band special code,
vmx_vcpu_reset()is kept clean, and if/when SVM gains support for PKRS this particular path Just Works. And it would be an easy conversion for my pipe dream plan of handling MSRs at RESET/INIT via a list of MSRs+values.arch/x86/kvm/x86.c +0
-0arch/x86/kvm/x86.c void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event) · line 11152
Quoted 6 lines
arch/x86/kvm/x86.c +3
-0@@ -11147,6 +11147,9 @@ void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event)kvm_set_rflags (vcpu,X86_EFLAGS_FIXED );kvm_rip_write (vcpu,0xfff0 ); +if (kvm_cpu_cap_has (X86_FEATURE_PKS )) +__kvm_set_msr (vcpu,MSR_IA32_PKRS ,0 , true); +Got it. In addition, is it necessary to add on-INIT check? like:
Quoted 5 lines
if (
kvm_cpu_cap_has(X86_FEATURE_PKS)&& !init_event)__kvm_set_msr(vcpu, MSR_IA32_PKRS, 0, true);PKRS should be preserved on INIT, not cleared. The SDM doesn't make this clear either.
Hmm, but your cover letter says:
To help patches review, one missing info in SDM is that PKSR will be cleared on Powerup/INIT/RESET, which should be listed in Table 9.1 "IA-32 and Intel 64 Processor States Following Power-up, Reset, or INIT"
Which honestly makes me a little happy because I thought I was making stuff up for a minute :-)
So which is it?
Re: [PATCH v5 3/7] KVM: X86: Expose IA32_PKRS MSR
Quoted 39 lines · Sean Christopherson
Quoted 30 lines · Chenyi Qiang
Quoted 19 lines · Sean Christopherson
Hrm. Ideally this would be open coded in
vmx_set_msr(). Long term, the RESET/INIT paths should really treat MSR updates as "normal"host_initiatedwrites instead of having to manually handle every MSR.That would be a bit gross to handle in
vmx_vcpu_reset()since it would have to create a structmsr_data(because__kvm_set_msr()isn't exposed to vendor code), but sincevcpu->arch.pkrsis relevant to the MMU I think it makes sense to initiate the write from common x86.E.g. this way there's not out-of-band special code,
vmx_vcpu_reset()is kept clean, and if/when SVM gains support for PKRS this particular path Just Works. And it would be an easy conversion for my pipe dream plan of handling MSRs at RESET/INIT via a list of MSRs+values.arch/x86/kvm/x86.c +0
-0arch/x86/kvm/x86.c void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event) · line 11152
Quoted 6 lines
arch/x86/kvm/x86.c +3
-0@@ -11147,6 +11147,9 @@ void kvm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event)kvm_set_rflags (vcpu,X86_EFLAGS_FIXED );kvm_rip_write (vcpu,0xfff0 ); +if (kvm_cpu_cap_has (X86_FEATURE_PKS )) +__kvm_set_msr (vcpu,MSR_IA32_PKRS ,0 , true); +Got it. In addition, is it necessary to add on-INIT check? like:
Quoted 5 lines
if (
kvm_cpu_cap_has(X86_FEATURE_PKS)&& !init_event)__kvm_set_msr(vcpu, MSR_IA32_PKRS, 0, true);PKRS should be preserved on INIT, not cleared. The SDM doesn't make this clear either.
Hmm, but your cover letter says:
Quoted 8 lines
To help patches review, one missing info in SDM is that PKSR will be cleared on Powerup/INIT/RESET, which should be listed in Table 9.1 "IA-32 and Intel 64 Processor States Following Power-up, Reset, or INIT"
Which honestly makes me a little happy because I thought I was making stuff up for a minute :-)
So which is it?
Sorry about the confusion. PKRS is preserved on INIT. I tried to correct my statement in previous ping mail but seems not so obvious.
Quoted 1 line
Sean Christopherson
maintainerRe: [PATCH v5 3/7] KVM: X86: Expose IA32_PKRS MSR
In reply to Chenyi Qiangarch/x86/kvm/vmx/vmx.c static void vmx_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu) · line 7262
Quoted 7 lines · Chenyi Qiang
arch/x86/kvm/vmx/vmx.c +3
-0@@ -7207,6 +7257,19 @@ static void vmx_vcpu_after_set_cpuid(struct kvm_vcpu *vcpu)/* Refresh #PF interception to account for MAXPHYADDR changes. */ vmx_update_exception_bitmap (vcpu); + +if (kvm_cpu_cap_has (X86_FEATURE_PKS ) && +guest_cpuid_has (vcpu,X86_FEATURE_PKS )) {
Ah, this confused me for a second. It's not wrong to clear the entry/exit controls in the "else" path, but it's surprisingly hard to follow because it reads as if the entry/exit controls are paired with the MSR behavior.
Oh, and more importantly, it's "hiding" a bug: the MSR bitmap needs to be _set_ if userspace disables X86_FEATURE_PKS in guest CPUID, e.g. if for some reason userspace exposed PKS and then yanked it away.
Oof, two bugs actually. This will fail to re-enable the entry/exit bits if userspace hides PKS and then re-enables PKS.
Heh, make that three bugs. If userspace never sets CPUID, KVM will run with the entry/exit bits set. That's arguably not a bug since functionally it's fine, but it's a bug in the sense that KVM loads an MSR when it doesn't inted to do so.
So this should be:
if (kvm_vcpu_cap_has(X86_FEATURE_PKS) {
if (guest_cpuid_has(vcpu, X86_FEATURE_PKS)) {
vmx_disable_intercept_for_msr(vcpu, MSR_IA32_PKRS, MSR_TYPE_RW);
vm_entry_controls_setbit(vmx, VM_ENTRY_LOAD_IA32_PKRS);
vm_exit_controls_setbit(vmx, VM_EXIT_LOAD_IA32_PKRS)
} else {
vmx_enable_intercept_for_msr(vcpu, MSR_IA32_PKRS, MSR_TYPE_RW);
vm_entry_controls_clearbit(vmx, VM_ENTRY_LOAD_IA32_PKRS);
vm_exit_controls_clearbit(vmx, VM_EXIT_LOAD_IA32_PKRS)
}
}and then the bits need to be masked in vmx_vmexit_ctrl() and vmx_vmentry_ctrl(), a la EFER and PERF_GLOBAL_CTRL.
Quoted 11 lines
arch/x86/kvm/vmx/vmx.c +10
-0+vmx_disable_intercept_for_msr (vcpu,MSR_IA32_PKRS ,MSR_TYPE_RW ); + }else { +/* +* Remove VM control in case guest VM doesn't support PKS to mitigate +* overhead during VM-{exit,entry}. They are present by default +* if supported. +*/ +vm_entry_controls_clearbit (vmx,VM_ENTRY_LOAD_IA32_PKRS ); +vm_exit_controls_clearbit (vmx,VM_EXIT_LOAD_IA32_PKRS ); + } }
PATCH v5 4/7 KVM: MMU: Rename the pkru to pkr
In reply to Chenyi QiangPKRU represents the PKU register utilized in the protection key rights check for user pages. Protection Keys for Superviosr Pages (PKS) extends the protection key architecture to cover supervisor pages.
Rename the *pkru* related variables and functions to *pkr* which stands for both of the PKRU and PKRS. It makes sense because PKS and PKU each have:
- a single control register (PKRU and PKRS)
- the same number of keys (16 in total)
- the same format in control registers (Access and Write disable bits)
PKS and PKU can also share the same bitmap pkr_mask cache conditions where protection key checks are neede, because they can share almost the same requirements for PK restrictions to cause a fault, except they focus on different pages (supervisor and user pages).
--- arch/x86/include/asm/kvm_host.h | 2 +- arch/x86/kvm/mmu.h | 12 ++++++------ arch/x86/kvm/mmu/mmu.c | 10 +++++----- 3 files changed, 12 insertions(+), 12 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -1
@@ -444,7 +444,7 @@ struct kvm_mmu {* with PFEC.RSVD replaced by ACC_USER_MASK from the page tables. * Each domain has 2 bits which are ANDed with AD and WD from PKRU. */ -u32 pkru_mask; +u32 pkr_mask;u64 *pae_root;u64 *pml4_root;
arch/x86/kvm/mmu.h +6 -6
@@ -200,8 +200,8 @@ static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,u32 errcode =PFERR_PRESENT_MASK ;WARN_ON (pfec & (PFERR_PK_MASK |PFERR_RSVD_MASK )); -if (unlikely (mmu->pkru_mask)) { -u32 pkru_bits, offset; +if (unlikely (mmu->pkr_mask)) { +u32 pkr_bits, offset;/* * PKRU defines 32 bits, there are 16 domains and 2
@@ -209,15 +209,15 @@ static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,* index of the protection domain, so pte_pkey * 2 is * is the index of the first bit for the domain. */ - pkru_bits = (vcpu->arch.pkru >> (pte_pkey *2 )) &3 ; + pkr_bits = (vcpu->arch.pkru >> (pte_pkey *2 )) &3 ;/* clear present bit, replace PFEC.RSVD with ACC_USER_MASK. */ offset = (pfec & ~1 ) + ((pte_access &PT_USER_MASK ) << (PFERR_RSVD_BIT -PT_USER_SHIFT )); - pkru_bits &= mmu->pkru_mask >> offset; - errcode |= -pkru_bits &PFERR_PK_MASK ; - fault |= (pkru_bits !=0 ); + pkr_bits &= mmu->pkr_mask >> offset; + errcode |= -pkr_bits &PFERR_PK_MASK ; + fault |= (pkr_bits !=0 ); }return -(u32 )fault & errcode;
arch/x86/kvm/mmu/mmu.c +5 -5
@@ -4443,13 +4443,13 @@ static void update_permission_bitmask(struct kvm_mmu *mmu, bool ept)* away both AD and WD. For all reads or if the last condition holds, WD * only will be masked away. */ -static void update_pkru_bitmask (struct kvm_mmu *mmu) +static void update_pkr_bitmask (struct kvm_mmu *mmu) {unsigned bit;bool wp;if (!is_cr4_pke (mmu)) { - mmu->pkru_mask =0 ; + mmu->pkr_mask =0 ;return ; }
@@ -4483,7 +4483,7 @@ static void update_pkru_bitmask(struct kvm_mmu *mmu)/* PKRU.WD stops write access. */ pkey_bits |= (!!check_write) <<1 ; - mmu->pkru_mask |= (pkey_bits &3 ) << pfec; + mmu->pkr_mask |= (pkey_bits &3 ) << pfec; } }
@@ -4495,7 +4495,7 @@ static void reset_guest_paging_metadata(struct kvm_vcpu *vcpu,reset_rsvds_bits_mask (vcpu, mmu);update_permission_bitmask (mmu, false); -update_pkru_bitmask (mmu); +update_pkr_bitmask (mmu); }static void paging64_init_context (struct kvm_mmu *context)
@@ -4763,7 +4763,7 @@ void kvm_init_shadow_ept_mmu(struct kvm_vcpu *vcpu, bool execonly, context->direct_map = false;update_permission_bitmask (context, true); -update_pkru_bitmask (context); +update_pkr_bitmask (context);reset_rsvds_bits_mask_ept (vcpu, context, execonly);reset_ept_shadow_zero_bits_mask (vcpu, context, execonly); }
Signature · 1 line
2.17.1
PATCH v5 5/7 KVM: MMU: Add support for PKS emulation
In reply to Chenyi QiangUp until now, pkr_mask had 0 bits for supervisor pages (the U/S bit in page tables replaces the PFEC.RSVD in page fault error code). For PKS support, fill in the bits using the same algorithm used for user mode pages, but with CR4.PKE replaced by CR4.PKS. Because of this change, CR4.PKS must also be included in the MMU role.
--- arch/x86/include/asm/kvm_host.h | 10 +++--- arch/x86/kvm/mmu.h | 15 +++++---- arch/x86/kvm/mmu/mmu.c | 58 ++++++++++++++++++++------------- 3 files changed, 50 insertions(+), 33 deletions(-)
arch/x86/include/asm/kvm_host.h +6 -4
@@ -359,6 +359,7 @@ union kvm_mmu_extended_role { unsigned int cr4_smap:1; unsigned int cr4_smep:1; unsigned int cr4_la57:1; + unsigned int cr4_pks:1; }; };
@@ -439,10 +440,11 @@ struct kvm_mmu {u8 permissions[16 ];/* -* The pkru_mask indicates if protection key checks are needed. It -* consists of 16 domains indexed by page fault error code bits [4:1], -* with PFEC.RSVD replaced by ACC_USER_MASK from the page tables. -* Each domain has 2 bits which are ANDed with AD and WD from PKRU. +* The pkr_mask indicates if protection key checks are needed. +* It consists of 16 domains indexed by page fault error code +* bits[4:1] with PFEC.RSVD replaced by ACC_USER_MASK from the +* page tables. Each domain has 2 bits which are ANDed with AD +* and WD from PKRU/PKRS. */ u32 pkr_mask;
arch/x86/kvm/mmu.h +9 -6
@@ -46,7 +46,7 @@#define KVM_MMU_CR4_ROLE_BITS (X86_CR4_PGE | X86_CR4_PSE | X86_CR4_PAE | \ X86_CR4_SMEP | X86_CR4_SMAP | X86_CR4_PKE | \ - X86_CR4_LA57) + X86_CR4_LA57 | X86_CR4_PKS)#define KVM_MMU_CR0_ROLE_BITS (X86_CR0_PG | X86_CR0_WP)
@@ -202,14 +202,17 @@ static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,WARN_ON (pfec & (PFERR_PK_MASK |PFERR_RSVD_MASK ));if (unlikely (mmu->pkr_mask)) {u32 pkr_bits, offset; +u64 pkr;/* -* PKRU defines 32 bits, there are 16 domains and 2 -* attribute bits per domain in pkru. pte_pkey is the -* index of the protection domain, so pte_pkey * 2 is -* is the index of the first bit for the domain. +* PKRU and PKRS both define 32 bits. There are 16 domains +* and 2 attribute bits per domain in them. pte_key is the +* index of the protection domain, so pte_pkey * 2 is the +* index of the first bit for the domain. The choice of +* PKRU and PKRS is determined by the accessed pages. */ - pkr_bits = (vcpu->arch.pkru >> (pte_pkey *2 )) &3 ; + pkr = pte_access &PT_USER_MASK ? vcpu->arch.pkru :kvm_read_pkrs (vcpu); + pkr_bits = (pkr >> pte_pkey *2 ) &3 ;/* clear present bit, replace PFEC.RSVD with ACC_USER_MASK. */ offset = (pfec & ~1) +
arch/x86/kvm/mmu/mmu.c +35 -23
107 lines not on this page · raw message
Signature · 1 line
2.17.1
Sean Christopherson
maintainerRe: [PATCH v5 5/7] KVM: MMU: Add support for PKS emulation
arch/x86/kvm/mmu/mmu.c static void update_permission_bitmask(struct kvm_mmu *mmu, bool ept) · line 4441
Quoted 10 lines · Chenyi Qiang
* In particular the following conditions come from the error code, the
* page tables and the machine state:arch/x86/kvm/mmu/mmu.c +4
-3-* - PK is always zero unless CR4.PKE=1 and EFER.LMA=1 +* - PK is always zero unless CR4.PKE=1/CR4.PKS=1 and EFER.LMA=1 * - PK is always zero if RSVD=1 (reserved bit set) or F=1 (instruction fetch) -* - PK is always zero if U=0 in the page tables -* - PKRU.WD is ignored if CR0.WP=0 and the access is a supervisor access. +* - PK is always zero if +* - U=0 in the page tables and CR4.PKS=0 +* - U=1 in the page tables and CR4.PKU=0
I think it makes sense to completely rewrite this "table" or drop it altogether. The "always zero" wording is nonsensical when there are multiple conditions for "always". And IMO the whole "PK is ... zero" thing is a bit awkward because it leaves the uninitiated wondering what PK=0 even means ('1' == disabled is not the most intuitive thing since most PTE bits are '1' = allowed). Ugh, and re-reading with context, that's not even what "PK" means here, this is actually referring to PFEC.PK, which is all kinds of confusing because PFEC.PK is merely a "symptom" of a #PF to due a protection key violation, not the other way 'round.
IMO this entire comment could use a good overhaul. It never explicitly documents the "access-disable" and "write-disable" behavior. More below.
Quoted 1 line
+* - (PKRU/PKRS).WD is ignored if CR0.WP=0 and the access is a supervisor access.
Hrm. The SDM contradicts itself.
Section 4.6.1 "Determination of Access Rights" says this for supervisor-mode accesses:
If CR0.WP = 0, data may be written to any supervisor-mode address with a protection key for which write access is permitted.
but section 4.6.2 "Protection Keys" says:
If WDi = 1, write accesses are not permitted if CR0.WP = 1. (If CR0.WP = 0, IA32_PKRS.WDi does not affect write accesses to supervisor-mode addresses with protection key i.)
I believe 4.6.1 is subtly wrong and should be "data access", not "write access".
If CR0.WP = 0, data may be written to any supervisor-mode address with a protection key for which data access is permitted.
^^^^
Can you follow-up with someone to get the SDM fixed? This stuff is subtle and confusing enough as it is :-)
And on a very related topic, it would be helpful to clarify user-mode vs. supervisor-mode and access vs. address.
How about this for a comment?
/*
* Protection Key Rights (PKR) is an additional mechanism by which data accesses
* with 4-level or 5-level paging (EFER.LMA=1) may be disabled based on the
* Protection Key Rights Userspace (PRKU) or Protection Key Rights Supervisor
* (PKRS) registers. The Protection Key (PK) used for an access is a 4-bit
* value specified in bits 62:59 of the leaf PTE used to translate the address. *
* PKRU and PKRS are 32-bit registers, with 16 2-bit entries consisting of an
* access-disable (AD) and write-disable (WD) bit. The PK from the leaf PTE is
* used to index the approriate PKR (see below), e.g. PK=1 would consume bits
* 3:2 (bit 3 == write-disable, bit 2 == access-disable).
*
* The PK register (PKRU vs. PKRS) indexed by the PK depends on the type of
* _address_ (not access type!). For a user-mode address, PKRU is used; for a
* supervisor-mode address, PKRS is used. An address is supervisor-mode if the
* U/S flag (bit 2) is 0 in at least one of the paging-structure entries, i.e.
* an address is user-mode if the U/S flag is 0 in _all_ entries. Again, this
* is the address type, not the the access type, e.g. a supervisor-mode _access_
* will consume PKRU if the _address_ is a user-mode address.
*
* As alluded to above, PKR checks are only performed for data accesses; code
* fetches are not subject to PKR checks. Terminal page faults (!PRESENT or
* PFEC.RSVD=1) are also not subject to PKR checks.
*
* PKR write-disable checks for superivsor-mode _accesses_ are performed if and
* only if CR0.WP=1 (though access-disable checks still apply).
*
* In summary, PKR checks are based on (a) EFER.LMA, (b) CR4.PKE or CR4.PKS,
* (c) CR4.WP, (d) the PK in the leaf PTE, (e) two bits from the corresponding
* PKR{S,U} entry, (f) the access type (derived from the other PFEC bits), and
* (g) the address type (retrieved from the paging-structure entries). *
* To avoid conditional branches in permission_fault(), the PKR bitmask caches
* the above inputs, except for (e) the PKR{S,U} entry. The FETCH, USER, and
* WRITE bits of the PFEC and the effective value of the paging-structures' U/S
* bit (slotted into the PFEC.RSVD position, bit 3) are used to index into the
* PKR bitmask (similar to the 4-bit Protection Key itself). The two bits of
* the PKR bitmask "entry" are then extracted and ANDed with the two bits of
* the PKR{S,U{} register corresponding to the address type and protection key. *
* E.g. for all values where PFEC.FETCH=1, the corresponding pkr_bitmask bits
* will be 00b, thus masking away the AD and WD bits from the PKR{S,U} register
* to suppress PKR checks on code fetches.
*/
Re: [PATCH v5 5/7] KVM: MMU: Add support for PKS emulation
Quoted 39 lines · Sean Christopherson
arch/x86/kvm/mmu/mmu.c static void update_permission_bitmask(struct kvm_mmu *mmu, bool ept) · line 4441
Quoted 10 lines · Chenyi Qiang
* In particular the following conditions come from the error code, the
* page tables and the machine state:arch/x86/kvm/mmu/mmu.c +4
-3-* - PK is always zero unless CR4.PKE=1 and EFER.LMA=1 +* - PK is always zero unless CR4.PKE=1/CR4.PKS=1 and EFER.LMA=1 * - PK is always zero if RSVD=1 (reserved bit set) or F=1 (instruction fetch) -* - PK is always zero if U=0 in the page tables -* - PKRU.WD is ignored if CR0.WP=0 and the access is a supervisor access. +* - PK is always zero if +* - U=0 in the page tables and CR4.PKS=0 +* - U=1 in the page tables and CR4.PKU=0 I think it makes sense to completely rewrite this "table" or drop it altogether. The "always zero" wording is nonsensical when there are multiple conditions for "always". And IMO the whole "PK is ... zero" thing is a bit awkward because it leaves the uninitiated wondering what PK=0 even means ('1' == disabled is not the most intuitive thing since most PTE bits are '1' = allowed). Ugh, and re-reading with context, that's not even what "PK" means here, this is actually referring to PFEC.PK, which is all kinds of confusing because PFEC.PK is merely a "symptom" of a #PF to due a protection key violation, not the other way 'round.
IMO this entire comment could use a good overhaul. It never explicitly documents the "access-disable" and "write-disable" behavior. More below.
Quoted 1 line
+* - (PKRU/PKRS).WD is ignored if CR0.WP=0 and the access is a supervisor access.
Hrm. The SDM contradicts itself.
Section 4.6.1 "Determination of Access Rights" says this for supervisor-mode accesses:
If CR0.WP = 0, data may be written to any supervisor-mode address with a protection key for which write access is permitted.
but section 4.6.2 "Protection Keys" says:
If WDi = 1, write accesses are not permitted if CR0.WP = 1. (If CR0.WP = 0, IA32_PKRS.WDi does not affect write accesses to supervisor-mode addresses with protection key i.)
Quoted 9 lines
I believe 4.6.1 is subtly wrong and should be "data access", not "write access".
If CR0.WP = 0, data may be written to any supervisor-mode address with a protection key for which data access is permitted.
^^^^Can you follow-up with someone to get the SDM fixed? This stuff is subtle and confusing enough as it is :-)
Nice catch. I'll mention it internally to fix it.
Quoted 41 lines
And on a very related topic, it would be helpful to clarify user-mode vs. supervisor-mode and access vs. address.
How about this for a comment?
/*
* Protection Key Rights (PKR) is an additional mechanism by which data accesses
* with 4-level or 5-level paging (EFER.LMA=1) may be disabled based on the
* Protection Key Rights Userspace (PRKU) or Protection Key Rights Supervisor
* (PKRS) registers. The Protection Key (PK) used for an access is a 4-bit
* value specified in bits 62:59 of the leaf PTE used to translate the address. *
* PKRU and PKRS are 32-bit registers, with 16 2-bit entries consisting of an
* access-disable (AD) and write-disable (WD) bit. The PK from the leaf PTE is
* used to index the approriate PKR (see below), e.g. PK=1 would consume bits
* 3:2 (bit 3 == write-disable, bit 2 == access-disable).
*
* The PK register (PKRU vs. PKRS) indexed by the PK depends on the type of
* _address_ (not access type!). For a user-mode address, PKRU is used; for a
* supervisor-mode address, PKRS is used. An address is supervisor-mode if the
* U/S flag (bit 2) is 0 in at least one of the paging-structure entries, i.e.
* an address is user-mode if the U/S flag is 0 in _all_ entries. Again, this
* is the address type, not the the access type, e.g. a supervisor-mode _access_
* will consume PKRU if the _address_ is a user-mode address.
*
* As alluded to above, PKR checks are only performed for data accesses; code
* fetches are not subject to PKR checks. Terminal page faults (!PRESENT or
* PFEC.RSVD=1) are also not subject to PKR checks.
*
* PKR write-disable checks for superivsor-mode _accesses_ are performed if and
* only if CR0.WP=1 (though access-disable checks still apply).
*
* In summary, PKR checks are based on (a) EFER.LMA, (b) CR4.PKE or CR4.PKS,
* (c) CR4.WP, (d) the PK in the leaf PTE, (e) two bits from the corresponding
* PKR{S,U} entry, (f) the access type (derived from the other PFEC bits), and
* (g) the address type (retrieved from the paging-structure entries). *
* To avoid conditional branches inpermission_fault(), the PKR bitmask caches
* the above inputs, except for (e) the PKR{S,U} entry. The FETCH, USER, and
* WRITE bits of the PFEC and the effective value of the paging-structures' U/S
* bit (slotted into the PFEC.RSVD position, bit 3) are used to index into the
Quoted 8 lines
* PKR bitmask (similar to the 4-bit Protection Key itself). The two bits of
* the PKR bitmask "entry" are then extracted and ANDed with the two bits of
* the PKR{S,U{} register corresponding to the address type and protection key. *
* E.g. for all values where PFEC.FETCH=1, the correspondingpkr_bitmaskbits
* will be 00b, thus masking away the AD and WD bits from the PKR{S,U} register
* to suppress PKR checks on code fetches.
*/
Very clear comment. I'll clean it up and change in next version.
Quoted 1 line
Sean Christopherson
maintainerRe: [PATCH v5 5/7] KVM: MMU: Add support for PKS emulation
In reply to Chenyi Qiangarch/x86/kvm/mmu.h static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, · line 205
Quoted 5 lines · Chenyi Qiang
arch/x86/kvm/mmu.h +1
-0@@ -202,14 +202,17 @@ static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,WARN_ON (pfec & (PFERR_PK_MASK |PFERR_RSVD_MASK ));if (unlikely (mmu->pkr_mask)) {u32 pkr_bits, offset; +u64 pkr;
Heh, MSR_IA32_PKRS strikes again. This should be a u32.
arch/x86/kvm/mmu.h static inline u8 permission_fault(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, · line 212
Quoted 11 lines
arch/x86/kvm/mmu.h +5
-4/* -* PKRU defines 32 bits, there are 16 domains and 2 -* attribute bits per domain in pkru. pte_pkey is the -* index of the protection domain, so pte_pkey * 2 is -* is the index of the first bit for the domain. +* PKRU and PKRS both define 32 bits. There are 16 domains +* and 2 attribute bits per domain in them. pte_key is the +* index of the protection domain, so pte_pkey * 2 is the +* index of the first bit for the domain. The choice of +* PKRU and PKRS is determined by the accessed pages.
Please replace "accessed pages" with something along the lines of
The use of PKRU versus PKRS is selected by the address type, as determined by the U/S bit in the paging-structure entries.
I.e. try to avoid "access" in favor of "address" to follow the SDM's wording.
PATCH v5 6/7 KVM: VMX: Expose PKS to guest
In reply to Chenyi QiangExistence of PKS is enumerated via CPUID.(EAX=7,ECX=0):ECX[31]. It is enabled by setting CR4.PKS when long mode is active. PKS is only implemented when EPT is enabled and requires the support of VM_{ENTRY,EXIT}_LOAD_IA32_PKRS VMCS controls currently.
--- arch/x86/include/asm/kvm_host.h | 3 ++- arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/vmx/capabilities.h | 6 ++++++ arch/x86/kvm/vmx/vmx.c | 15 ++++++++++++--- arch/x86/kvm/x86.h | 2 ++ 5 files changed, 23 insertions(+), 5 deletions(-)
arch/x86/include/asm/kvm_host.h +2 -1
@@ -103,7 +103,8 @@ | X86_CR4_PGE | X86_CR4_PCE | X86_CR4_OSFXSR | X86_CR4_PCIDE \ | X86_CR4_OSXSAVE | X86_CR4_SMEP | X86_CR4_FSGSBASE \ | X86_CR4_OSXMMEXCPT | X86_CR4_LA57 | X86_CR4_VMXE \ - | X86_CR4_SMAP | X86_CR4_PKE | X86_CR4_UMIP)) + | X86_CR4_SMAP | X86_CR4_PKE | X86_CR4_UMIP \ + | X86_CR4_PKS))#define CR8_RESERVED_BITS (~(unsigned long)X86_CR8_TPR)
arch/x86/kvm/cpuid.c +1 -1
@@ -458,7 +458,7 @@ void kvm_set_cpu_caps(void)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 (SGX_LC ) |F (BUS_LOCK_DETECT ) +F (SGX_LC ) |F (BUS_LOCK_DETECT ) |0 /*PKS*/ );/* Set LA57 based on hardware capability. */ if (cpuid_ecx (7 ) &F (LA57 ))
arch/x86/kvm/vmx/capabilities.h +6 -0
@@ -104,6 +104,12 @@ static inline bool cpu_has_load_perf_global_ctrl(void) (vmcs_config.vmexit_ctrl &VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL ); } +static inline bool cpu_has_load_ia32_pkrs (void ) +{ +return (vmcs_config.vmentry_ctrl &VM_ENTRY_LOAD_IA32_PKRS ) && + (vmcs_config.vmexit_ctrl &VM_EXIT_LOAD_IA32_PKRS ); +} +static inline bool cpu_has_vmx_mpx (void ) { return (vmcs_config.vmexit_ctrl & VM_EXIT_CLEAR_BNDCFGS) &&
arch/x86/kvm/vmx/vmx.c +12 -3
@@ -3218,7 +3218,7 @@ void vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4) }/* -* SMEP/SMAP/PKU is disabled if CPU is in non-paging mode in +* SMEP/SMAP/PKU/PKS is disabled if CPU is in non-paging mode in * hardware. To emulate this behavior, SMEP/SMAP/PKU needs * to be manually disabled when guest switches to non-paging * mode.
@@ -3226,10 +3226,11 @@ void vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)* If !enable_unrestricted_guest, the CPU is always running * with CR0.PG=1 and CR4 needs to be modified. * If enable_unrestricted_guest, the CPU automatically -* disables SMEP/SMAP/PKU when the guest sets CR0.PG=0. +* disables SMEP/SMAP/PKU/PKS when the guest sets CR0.PG=0. */ if (!is_paging (vcpu)) - hw_cr4 &= ~(X86_CR4_SMEP |X86_CR4_SMAP |X86_CR4_PKE ); + hw_cr4 &= ~(X86_CR4_SMEP |X86_CR4_SMAP |X86_CR4_PKE | +X86_CR4_PKS ); }vmcs_writel (CR4_READ_SHADOW , cr4);
@@ -7311,6 +7312,14 @@ static __init void vmx_set_cpu_caps(void)if (cpu_has_vmx_waitpkg ())kvm_cpu_cap_check_and_set (X86_FEATURE_WAITPKG ); + +/* +* PKS is not yet implemented for shadow paging. +* If not support VM_{ENTRY, EXIT}_LOAD_IA32_PKRS, +* don't expose the PKS as well. +*/ +if (enable_ept &&cpu_has_load_ia32_pkrs ()) +kvm_cpu_cap_check_and_set (X86_FEATURE_PKS ); }static void vmx_request_immediate_exit (struct kvm_vcpu *vcpu)
arch/x86/kvm/x86.h +2 -0
@@ -481,6 +481,8 @@ bool kvm_msr_allowed(struct kvm_vcpu *vcpu, u32 index, u32 type); __reserved_bits |=X86_CR4_VMXE ; \if (!__cpu_has (__c,X86_FEATURE_PCID )) \ __reserved_bits |=X86_CR4_PCIDE ; \ +if (!__cpu_has (__c,X86_FEATURE_PKS )) \ + __reserved_bits |=X86_CR4_PKS ; \ __reserved_bits; \ })
Signature · 1 line
2.17.1
Sean Christopherson
maintainerRe: [PATCH v5 6/7] KVM: VMX: Expose PKS to guest
Quoted 10 lines · Chenyi Qiang
arch/x86/kvm/cpuid.c +1
-1@@ -458,7 +458,7 @@ void kvm_set_cpu_caps(void)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 (SGX_LC ) |F (BUS_LOCK_DETECT ) +F (SGX_LC ) |F (BUS_LOCK_DETECT ) |0 /*PKS*/
...
Quoted 3 lines
arch/x86/kvm/cpuid.c +0
-0);/* Set LA57 based on hardware capability. */ if (cpuid_ecx (7 ) &F (LA57 ))
...
arch/x86/kvm/cpuid.c static __init void vmx_set_cpu_caps(void) · line 7322
Quoted 12 lines
arch/x86/kvm/cpuid.c +8
-0@@ -7311,6 +7312,14 @@ static __init void vmx_set_cpu_caps(void)if (cpu_has_vmx_waitpkg ())kvm_cpu_cap_check_and_set (X86_FEATURE_WAITPKG ); + +/* +* PKS is not yet implemented for shadow paging. +* If not support VM_{ENTRY, EXIT}_LOAD_IA32_PKRS, +* don't expose the PKS as well. +*/ +if (enable_ept &&cpu_has_load_ia32_pkrs ()) +kvm_cpu_cap_check_and_set (X86_FEATURE_PKS );
I would rather handle the !TDP case in cpuid.c alongside the PKU. The decision to not support Protection Keys with legacy shadow paging is an x86 decision, not a VMX decision.
And VMX's extra restriction on the VMCS support should not bleed into common x86.
Can you also opportunistically update the comment (see below) to explain _why_ OSPKE needs to be enabled in order to advertise PKU?
Thanks!
arch/x86/kvm/cpuid.c +9 -4
@@ -439,18 +439,23 @@ void kvm_set_cpu_caps(void)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 (SGX_LC ) |F (BUS_LOCK_DETECT ) +F (SGX_LC ) |F (BUS_LOCK_DETECT ) |F (PKS ) );/* Set LA57 based on hardware capability. */ if (cpuid_ecx (7 ) &F (LA57 ))kvm_cpu_cap_set (X86_FEATURE_LA57 );/* -* PKU not yet implemented for shadow paging and requires OSPKE -* to be set on the host. Clear it if that is not the case +* Protection Keys are not supported for shadow paging. PKU further +* requires OSPKE to be set on the host in order to use {RD,WR}PKRU to +* save/restore the guests PKRU. */ -if (!tdp_enabled || !boot_cpu_has (X86_FEATURE_OSPKE )) +if (!tdp_enabled) {kvm_cpu_cap_clear (X86_FEATURE_PKU ); +kvm_cpu_cap_clear (X86_FEATURE_PKS ); + }else if (!boot_cpu_has (X86_FEATURE_OSPKE )) { +kvm_cpu_cap_clear (X86_FEATURE_PKU ); + } kvm_cpu_cap_mask(CPUID_7_EDX, F(AVX512_4VNNIW) | F(AVX512_4FMAPS) | F(SPEC_CTRL) |
and then vmx.c only needs to handle clearing PKS when the VMCS controls aren't available.
PATCH v5 7/7 KVM: VMX: Enable PKS for nested VM
In reply to Chenyi QiangPKS MSR passes through guest directly. Configure the MSR to match the L0/L1 settings so that nested VM runs PKS properly.
--- arch/x86/kvm/vmx/nested.c | 41 +++++++++++++++++++++++++++++++++++++-- arch/x86/kvm/vmx/vmcs12.c | 2 ++ arch/x86/kvm/vmx/vmcs12.h | 4 ++++ arch/x86/kvm/vmx/vmx.c | 1 + arch/x86/kvm/vmx/vmx.h | 2 ++ 5 files changed, 48 insertions(+), 2 deletions(-)
arch/x86/kvm/vmx/nested.c +39 -2
@@ -251,6 +251,10 @@ static void vmx_sync_vmcs_host_state(struct vcpu_vmx *vmx, dest->ds_sel = src->ds_sel; dest->es_sel = src->es_sel;#endif +if (unlikely (src->pkrs != dest->pkrs)) { +vmcs_write64 (HOST_IA32_PKRS , src->pkrs); + dest->pkrs = src->pkrs; + } }static void vmx_switch_vmcs (struct kvm_vcpu *vcpu,struct loaded_vmcs *vmcs)
@@ -660,6 +664,12 @@ static inline bool nested_vmx_prepare_msr_bitmap(struct kvm_vcpu *vcpu,MSR_IA32_PRED_CMD , MSR_TYPE_W); +if (!msr_write_intercepted_l01 (vcpu,MSR_IA32_PKRS )) +nested_vmx_disable_intercept_for_msr ( + msr_bitmap_l1, msr_bitmap_l0, +MSR_IA32_PKRS , +MSR_TYPE_R |MSR_TYPE_W ); +kvm_vcpu_unmap (vcpu, &to_vmx (vcpu)->nested.msr_bitmap_map, false);return true;
@@ -2394,6 +2404,10 @@ static void prepare_vmcs02_rare(struct vcpu_vmx *vmx, struct vmcs12 *vmcs12)if (kvm_mpx_supported () && vmx->nested.nested_run_pending && (vmcs12->vm_entry_controls &VM_ENTRY_LOAD_BNDCFGS ))vmcs_write64 (GUEST_BNDCFGS , vmcs12->guest_bndcfgs); + +if (vmx->nested.nested_run_pending && + (vmcs12->vm_entry_controls &VM_ENTRY_LOAD_IA32_PKRS )) +vmcs_write64 (GUEST_IA32_PKRS , vmcs12->guest_ia32_pkrs); }if (nested_cpu_has_xsaves (vmcs12))
@@ -2482,6 +2496,11 @@ static int prepare_vmcs02(struct kvm_vcpu *vcpu, struct vmcs12 *vmcs12,if (kvm_mpx_supported () && (!vmx->nested.nested_run_pending || !(vmcs12->vm_entry_controls &VM_ENTRY_LOAD_BNDCFGS )))vmcs_write64 (GUEST_BNDCFGS , vmx->nested.vmcs01_guest_bndcfgs); +if (kvm_cpu_cap_has (X86_FEATURE_PKS ) && + (!vmx->nested.nested_run_pending || + !(vmcs12->vm_entry_controls &VM_ENTRY_LOAD_IA32_PKRS ))) +vmcs_write64 (GUEST_IA32_PKRS , vmx->nested.vmcs01_guest_pkrs); +vmx_set_rflags (vcpu, vmcs12->guest_rflags);/* EXCEPTION_BITMAP and CR0_GUEST_HOST_MASK should basically be the
@@ -2840,6 +2859,10 @@ static int nested_vmx_check_host_state(struct kvm_vcpu *vcpu, vmcs12->host_ia32_perf_global_ctrl)))return -EINVAL ; +if ((vmcs12->vm_exit_controls &VM_EXIT_LOAD_IA32_PKRS ) && +CC (!kvm_pkrs_valid (vmcs12->host_ia32_pkrs))) +return -EINVAL ; +#ifdef CONFIG_X86_64 ia32e = !!(vcpu->arch.efer &EFER_LMA );#else
@@ -2990,6 +3013,10 @@ static int nested_vmx_check_guest_state(struct kvm_vcpu *vcpu,if (nested_check_guest_non_reg_state (vmcs12))return -EINVAL ; +if ((vmcs12->vm_entry_controls &VM_ENTRY_LOAD_IA32_PKRS ) && +CC (!kvm_pkrs_valid (vmcs12->guest_ia32_pkrs))) +return -EINVAL ; +return 0 ; }
@@ -3325,6 +3352,9 @@ enum nvmx_vmentry_status nested_vmx_enter_non_root_mode(struct kvm_vcpu *vcpu,if (kvm_mpx_supported () && !(vmcs12->vm_entry_controls &VM_ENTRY_LOAD_BNDCFGS )) vmx->nested.vmcs01_guest_bndcfgs =vmcs_read64 (GUEST_BNDCFGS ); +if (kvm_cpu_cap_has (X86_FEATURE_PKS ) && + !(vmcs12->vm_entry_controls &VM_ENTRY_LOAD_IA32_PKRS )) + vmx->nested.vmcs01_guest_pkrs =vmcs_read64 (GUEST_IA32_PKRS );/* * Overwrite vmcs01.GUEST_CR3 with L1's CR3 if EPT is disabled *and*
@@ -3964,6 +3994,7 @@ static bool is_vmcs12_ext_field(unsigned long field)case GUEST_IDTR_BASE :case GUEST_PENDING_DBG_EXCEPTIONS :case GUEST_BNDCFGS : +case GUEST_IA32_PKRS :return true;default :break ;
@@ -4015,6 +4046,8 @@ static void sync_vmcs02_to_vmcs12_rare(struct kvm_vcpu *vcpu,vmcs_readl (GUEST_PENDING_DBG_EXCEPTIONS );if (kvm_mpx_supported ()) vmcs12->guest_bndcfgs =vmcs_read64 (GUEST_BNDCFGS ); +if (guest_cpuid_has (vcpu,X86_FEATURE_PKS )) + vmcs12->guest_ia32_pkrs =vmcs_read64 (GUEST_IA32_PKRS ); vmx->nested.need_sync_vmcs02_to_vmcs12_rare = false; }
@@ -4252,6 +4285,9 @@ static void load_vmcs12_host_state(struct kvm_vcpu *vcpu,WARN_ON_ONCE (kvm_set_msr (vcpu,MSR_CORE_PERF_GLOBAL_CTRL , vmcs12->host_ia32_perf_global_ctrl)); +if (vmcs12->vm_exit_controls &VM_EXIT_LOAD_IA32_PKRS ) +vmcs_write64 (GUEST_IA32_PKRS , vmcs12->host_ia32_pkrs); +/* Set L1 segment info according to Intel SDM 27.5.2 Loading Host Segment and Descriptor-Table Registers */ seg = (struct kvm_segment ) {
@@ -6466,7 +6502,8 @@ void nested_vmx_setup_ctls_msrs(struct nested_vmx_msrs *msrs, u32 ept_caps)VM_EXIT_HOST_ADDR_SPACE_SIZE | #endifVM_EXIT_LOAD_IA32_PAT |VM_EXIT_SAVE_IA32_PAT | -VM_EXIT_CLEAR_BNDCFGS |VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL ; +VM_EXIT_CLEAR_BNDCFGS |VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL | +VM_EXIT_LOAD_IA32_PKRS ; msrs->exit_ctls_high |=VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR | VM_EXIT_LOAD_IA32_EFER | VM_EXIT_SAVE_IA32_EFER |
@@ -6486,7 +6523,7 @@ void nested_vmx_setup_ctls_msrs(struct nested_vmx_msrs *msrs, u32 ept_caps)VM_ENTRY_IA32E_MODE | #endifVM_ENTRY_LOAD_IA32_PAT |VM_ENTRY_LOAD_BNDCFGS | -VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL ; +VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL |VM_ENTRY_LOAD_IA32_PKRS ; msrs->entry_ctls_high |= (VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR |VM_ENTRY_LOAD_IA32_EFER );
arch/x86/kvm/vmx/vmcs12.c +2 -0
@@ -63,9 +63,11 @@ const unsigned short vmcs_field_to_offset_table[] = {FIELD64 (GUEST_PDPTR2 , guest_pdptr2),FIELD64 (GUEST_PDPTR3 , guest_pdptr3),FIELD64 (GUEST_BNDCFGS , guest_bndcfgs), +FIELD64 (GUEST_IA32_PKRS , guest_ia32_pkrs),FIELD64 (HOST_IA32_PAT , host_ia32_pat),FIELD64 (HOST_IA32_EFER , host_ia32_efer),FIELD64 (HOST_IA32_PERF_GLOBAL_CTRL , host_ia32_perf_global_ctrl), +FIELD64 (HOST_IA32_PKRS , host_ia32_pkrs),FIELD (PIN_BASED_VM_EXEC_CONTROL , pin_based_vm_exec_control),FIELD (CPU_BASED_VM_EXEC_CONTROL , cpu_based_vm_exec_control), FIELD(EXCEPTION_BITMAP, exception_bitmap),
arch/x86/kvm/vmx/vmcs12.h +4 -0
@@ -185,6 +185,8 @@ struct __packed vmcs12 {u16 host_gs_selector;u16 host_tr_selector;u16 guest_pml_index; +u64 host_ia32_pkrs; +u64 guest_ia32_pkrs; };/*
@@ -359,6 +361,8 @@ static inline void vmx_check_vmcs12_offsets(void)CHECK_OFFSET (host_gs_selector,992 );CHECK_OFFSET (host_tr_selector,994 );CHECK_OFFSET (guest_pml_index,996 ); +CHECK_OFFSET (host_ia32_pkrs,998 ); +CHECK_OFFSET (guest_ia32_pkrs,1006 ); }extern const unsigned short vmcs_field_to_offset_table[];
arch/x86/kvm/vmx/vmx.c +1 -0
@@ -7112,6 +7112,7 @@ static void nested_vmx_cr_fixed1_bits_update(struct kvm_vcpu *vcpu)cr4_fixed1_update (X86_CR4_PKE , ecx,feature_bit (PKU ));cr4_fixed1_update (X86_CR4_UMIP , ecx,feature_bit (UMIP ));cr4_fixed1_update (X86_CR4_LA57 , ecx,feature_bit (LA57 )); +cr4_fixed1_update (X86_CR4_PKS , ecx,feature_bit (PKS ));#undef cr4_fixed1_update }
arch/x86/kvm/vmx/vmx.h +2 -0
@@ -203,6 +203,8 @@ struct nested_vmx {u64 vmcs01_debugctl;u64 vmcs01_guest_bndcfgs; +u64 vmcs01_guest_pkrs; +/* to migrate it to L1 if L2 writes to L1's CR8 directly */ int l1_tpr_threshold;
Signature · 1 line
2.17.1
Ping for comments.
One thing to pay attention:
The previous statement was incorrect – PKRS should be preserved on INIT, not cleared.
Quoted 103 lines · Chenyi Qiang
This patch series is based on top of kernel patchset:
https://lore.kernel.org/lkml/[email protected]/To help patches review, one missing info in SDM is that PKSR will be cleared on Powerup/INIT/RESET, which should be listed in Table 9.1 "IA-32 and Intel 64 Processor States Following Power-up, Reset, or INIT"
---
Protection Keys for Supervisor Pages(PKS) is a feature that extends the Protection Keys architecture to support thread-specific permission restrictions on supervisor pages.
PKS works similar to an existing feature named PKU(protecting user pages). They both perform an additional check after normal paging permission checks are done. Access or Writes can be disabled via a MSR update without TLB flushes when permissions changes. If violating this addional check, #PF occurs and PFEC.PK bit will be set.
PKS introduces MSR
IA32_PKRSto manage supervisor protection key rights. The MSR contains 16 pairs of ADi and WDi bits. Each pair advertises on a group of pages with the same key which is set in the leaf paging-structureentries(bits[62:59]). Currently,IA32_PKRSis not supported by XSAVES architecture.This patchset aims to add the virtualization of PKS in KVM. It implemented PKS CPUID enumeration, vmentry/vmexit configuration, MSR exposure, nested supported etc. Currently, PKS is not yet supported for shadow paging.
Detailed information about PKS can be found in the latest Intel 64 and IA-32 Architectures Software Developer's Manual.
---
Changelogs:
v4->v5
- Make setting of MSR intercept/vmcs control bits not dependent on guest.CR4.PKS. And set them if PKS is exposed to guest. (Suggested by Sean)
- Add pkrs to standard register caching mechanism to help updatevcpu->arch.pkrson demand. Add related helper functions. (Suggested by Sean)
- Do the real pkrs update in VMCS field invmx_vcpu_resetandvmx_sync_vmcs_host_state(). (Sean)
- Add a newmmu_rolecr4_pksinstead of smushing PKU and PKS together. (Sean & Paolo)
- v4: https://lore.kernel.org/lkml/[email protected]/
v3->v4
- Make the MSR intercept and load-controls setting depend on CR4.PKS value
- shadow the guest pkrs and make it usable in PKS emultion
- add thecr4_pkeandcr4_pkscheck inpkr_maskupdate
- squash PATCH 2 and PATCH 5 to make the dependencies read more clear
- v3: https://lore.kernel.org/lkml/[email protected]/
v2->v3:
- No function changes since last submit
- rebase on the latest PKS kernel support:https://lore.kernel.org/lkml/[email protected]/- add
MSR_IA32_PKRSto the vmx_possible_passthrough_msrs[]
- RFC v2: https://lore.kernel.org/lkml/[email protected]/
v1->v2:
- rebase on the latest PKS kernel support:
https://github.com/weiny2/linux-kernel/tree/pks-rfc-v3
- add a kvm-unit-tests for PKS
- add the check inkvm_init_msr_listfor PKRS
- place theX86_CR4_PKSinmmu_role_bitsinkvm_set_cr4
- add the support to expose VM_{ENTRY, EXIT}_LOAD_IA32_PKRS in nested VMX MSR
- RFC v1: https://lore.kernel.org/lkml/[email protected]/---
Chenyi Qiang (7):
KVM: VMX: Introduce PKS VMCS fields
KVM: VMX: Add proper cache tracking for PKRS
KVM: X86: ExposeIA32_PKRSMSR
KVM: MMU: Rename the pkru to pkr
KVM: MMU: Add support for PKS emulation
KVM: VMX: Expose PKS to guest
KVM: VMX: Enable PKS for nested VMarch/x86/include/asm/kvm_host.h | 17 ++++--- arch/x86/include/asm/vmx.h | 6 +++ arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/kvm_cache_regs.h | 7 +++ arch/x86/kvm/mmu.h | 25 +++++---- arch/x86/kvm/mmu/mmu.c | 68 ++++++++++++++----------- arch/x86/kvm/vmx/capabilities.h | 6 +++ arch/x86/kvm/vmx/nested.c | 41 ++++++++++++++- arch/x86/kvm/vmx/vmcs.h | 1 + arch/x86/kvm/vmx/vmcs12.c | 2 + arch/x86/kvm/vmx/vmcs12.h | 4 ++ arch/x86/kvm/vmx/vmx.c | 89 ++++++++++++++++++++++++++++++--- arch/x86/kvm/vmx/vmx.h | 7 ++- arch/x86/kvm/x86.c | 6 ++- arch/x86/kvm/x86.h | 8 +++ arch/x86/mm/pkeys.c | 6 +++ include/linux/pkeys.h | 5 ++ 17 files changed, 243 insertions(+), 57 deletions(-)
Paolo Bonzini
maintainerQuoted 25 lines · Chenyi Qiang
This patch series is based on top of kernel patchset:
https://lore.kernel.org/lkml/[email protected]/To help patches review, one missing info in SDM is that PKSR will be cleared on Powerup/INIT/RESET, which should be listed in Table 9.1 "IA-32 and Intel 64 Processor States Following Power-up, Reset, or INIT"
---
Protection Keys for Supervisor Pages(PKS) is a feature that extends the Protection Keys architecture to support thread-specific permission restrictions on supervisor pages.
PKS works similar to an existing feature named PKU(protecting user pages). They both perform an additional check after normal paging permission checks are done. Access or Writes can be disabled via a MSR update without TLB flushes when permissions changes. If violating this addional check, #PF occurs and PFEC.PK bit will be set.
PKS introduces MSR
IA32_PKRSto manage supervisor protection key rights. The MSR contains 16 pairs of ADi and WDi bits. Each pair advertises on a group of pages with the same key which is set in the leaf paging-structureentries(bits[62:59]). Currently,IA32_PKRSis not supported by XSAVES architecture.
Quoted 7 lines
This patchset aims to add the virtualization of PKS in KVM. It implemented PKS CPUID enumeration, vmentry/vmexit configuration, MSR exposure, nested supported etc. Currently, PKS is not yet supported for shadow paging.
Detailed information about PKS can be found in the latest Intel 64 and IA-32 Architectures Software Developer's Manual.
Hi Chenyi,
pkrs_cache does not yet exist in Linux 5.15. What is the state of the bare-metal support for PKS?
Thanks,
Paolo
Quoted 70 lines
---
Changelogs:
v4->v5
- Make setting of MSR intercept/vmcs control bits not dependent on guest.CR4.PKS. And set them if PKS is exposed to guest. (Suggested by Sean)
- Add pkrs to standard register caching mechanism to help updatevcpu->arch.pkrson demand. Add related helper functions. (Suggested by Sean)
- Do the real pkrs update in VMCS field invmx_vcpu_resetandvmx_sync_vmcs_host_state(). (Sean)
- Add a newmmu_rolecr4_pksinstead of smushing PKU and PKS together. (Sean & Paolo)
- v4: https://lore.kernel.org/lkml/[email protected]/
v3->v4
- Make the MSR intercept and load-controls setting depend on CR4.PKS value
- shadow the guest pkrs and make it usable in PKS emultion
- add thecr4_pkeandcr4_pkscheck inpkr_maskupdate
- squash PATCH 2 and PATCH 5 to make the dependencies read more clear
- v3: https://lore.kernel.org/lkml/[email protected]/
v2->v3:
- No function changes since last submit
- rebase on the latest PKS kernel support:https://lore.kernel.org/lkml/[email protected]/- add
MSR_IA32_PKRSto the vmx_possible_passthrough_msrs[]
- RFC v2: https://lore.kernel.org/lkml/[email protected]/
v1->v2:
- rebase on the latest PKS kernel support:
https://github.com/weiny2/linux-kernel/tree/pks-rfc-v3
- add a kvm-unit-tests for PKS
- add the check inkvm_init_msr_listfor PKRS
- place theX86_CR4_PKSinmmu_role_bitsinkvm_set_cr4
- add the support to expose VM_{ENTRY, EXIT}_LOAD_IA32_PKRS in nested VMX MSR
- RFC v1: https://lore.kernel.org/lkml/[email protected]/---
Chenyi Qiang (7):
KVM: VMX: Introduce PKS VMCS fields
KVM: VMX: Add proper cache tracking for PKRS
KVM: X86: ExposeIA32_PKRSMSR
KVM: MMU: Rename the pkru to pkr
KVM: MMU: Add support for PKS emulation
KVM: VMX: Expose PKS to guest
KVM: VMX: Enable PKS for nested VMarch/x86/include/asm/kvm_host.h | 17 ++++--- arch/x86/include/asm/vmx.h | 6 +++ arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/kvm_cache_regs.h | 7 +++ arch/x86/kvm/mmu.h | 25 +++++---- arch/x86/kvm/mmu/mmu.c | 68 ++++++++++++++----------- arch/x86/kvm/vmx/capabilities.h | 6 +++ arch/x86/kvm/vmx/nested.c | 41 ++++++++++++++- arch/x86/kvm/vmx/vmcs.h | 1 + arch/x86/kvm/vmx/vmcs12.c | 2 + arch/x86/kvm/vmx/vmcs12.h | 4 ++ arch/x86/kvm/vmx/vmx.c | 89 ++++++++++++++++++++++++++++++--- arch/x86/kvm/vmx/vmx.h | 7 ++- arch/x86/kvm/x86.c | 6 ++- arch/x86/kvm/x86.h | 8 +++ arch/x86/mm/pkeys.c | 6 +++ include/linux/pkeys.h | 5 ++ 17 files changed, 243 insertions(+), 57 deletions(-)
Quoted 35 lines · Paolo Bonzini
Quoted 26 lines · Chenyi Qiang
This patch series is based on top of kernel patchset:
https://lore.kernel.org/lkml/[email protected]/To help patches review, one missing info in SDM is that PKSR will be cleared on Powerup/INIT/RESET, which should be listed in Table 9.1 "IA-32 and Intel 64 Processor States Following Power-up, Reset, or INIT"
---
Protection Keys for Supervisor Pages(PKS) is a feature that extends the Protection Keys architecture to support thread-specific permission restrictions on supervisor pages.
PKS works similar to an existing feature named PKU(protecting user pages). They both perform an additional check after normal paging permission checks are done. Access or Writes can be disabled via a MSR update without TLB flushes when permissions changes. If violating this addional check, #PF occurs and PFEC.PK bit will be set.
PKS introduces MSR
IA32_PKRSto manage supervisor protection key rights. The MSR contains 16 pairs of ADi and WDi bits. Each pair advertises on a group of pages with the same key which is set in the leaf paging-structureentries(bits[62:59]). Currently,IA32_PKRSis not supported by XSAVES architecture.Quoted 7 lines
This patchset aims to add the virtualization of PKS in KVM. It implemented PKS CPUID enumeration, vmentry/vmexit configuration, MSR exposure, nested supported etc. Currently, PKS is not yet supported for shadow paging.
Detailed information about PKS can be found in the latest Intel 64 and IA-32 Architectures Software Developer's Manual.
Quoted 8 lines
Hi Chenyi,
pkrs_cachedoes not yet exist in Linux 5.15. What is the state of the bare-metal support for PKS?Thanks,
Paolo
Hi Paolo,
The latest version is still at
https://lore.kernel.org/lkml/[email protected]/
Ira is working on the next version but doesn't have concrete schedule.
Thanks
Chenyi
Quoted 83 lines
Quoted 82 lines
---
Changelogs:
v4->v5
- Make setting of MSR intercept/vmcs control bits not dependent on guest.CR4.PKS.
And set them if PKS is exposed to guest. (Suggested by Sean)
- Add pkrs to standard register caching mechanism to help updatevcpu->arch.pkrson demand. Add related helper functions. (Suggested by Sean)
- Do the real pkrs update in VMCS field invmx_vcpu_resetandvmx_sync_vmcs_host_state(). (Sean)
- Add a newmmu_rolecr4_pksinstead of smushing PKU and PKS together. (Sean & Paolo)
- v4:
https://lore.kernel.org/lkml/[email protected]/
v3->v4
- Make the MSR intercept and load-controls setting depend on CR4.PKS value
- shadow the guest pkrs and make it usable in PKS emultion
- add thecr4_pkeandcr4_pkscheck inpkr_maskupdate
- squash PATCH 2 and PATCH 5 to make the dependencies read more clear
- v3:
https://lore.kernel.org/lkml/[email protected]/
v2->v3:
- No function changes since last submit
- rebase on the latest PKS kernel support:https://lore.kernel.org/lkml/[email protected]/
- add
MSR_IA32_PKRSto the vmx_possible_passthrough_msrs[]
- RFC v2:
https://lore.kernel.org/lkml/[email protected]/
v1->v2:
- rebase on the latest PKS kernel support:
https://github.com/weiny2/linux-kernel/tree/pks-rfc-v3
- add a kvm-unit-tests for PKS
- add the check inkvm_init_msr_listfor PKRS
- place theX86_CR4_PKSinmmu_role_bitsinkvm_set_cr4
- add the support to expose VM_{ENTRY, EXIT}_LOAD_IA32_PKRS in nested VMX MSR
- RFC v1:
https://lore.kernel.org/lkml/[email protected]/---
Chenyi Qiang (7):
KVM: VMX: Introduce PKS VMCS fields
KVM: VMX: Add proper cache tracking for PKRS
KVM: X86: ExposeIA32_PKRSMSR
KVM: MMU: Rename the pkru to pkr
KVM: MMU: Add support for PKS emulation
KVM: VMX: Expose PKS to guest
KVM: VMX: Enable PKS for nested VM
arch/x86/include/asm/kvm_host.h| 17 ++++--- arch/x86/include/asm/vmx.h | 6 +++ arch/x86/kvm/cpuid.c | 2 +- arch/x86/kvm/kvm_cache_regs.h | 7 +++ arch/x86/kvm/mmu.h | 25 +++++---- arch/x86/kvm/mmu/mmu.c | 68 ++++++++++++++-----------arch/x86/kvm/vmx/capabilities.h| 6 +++ arch/x86/kvm/vmx/nested.c | 41 ++++++++++++++- arch/x86/kvm/vmx/vmcs.h | 1 + arch/x86/kvm/vmx/vmcs12.c | 2 + arch/x86/kvm/vmx/vmcs12.h | 4 ++ arch/x86/kvm/vmx/vmx.c | 89 ++++++++++++++++++++++++++++++--- arch/x86/kvm/vmx/vmx.h | 7 ++- arch/x86/kvm/x86.c | 6 ++- arch/x86/kvm/x86.h | 8 +++ arch/x86/mm/pkeys.c | 6 +++ include/linux/pkeys.h | 5 ++17 files changed, 243 insertions(+), 57 deletions(-)