Allow user space to restrict and augment MSR emulation
Subsystems (5)
v6 cover Allow user space to restrict and augment MSR emulation
While tying to add support for the MSR_CORE_THREAD_COUNT MSR in KVM, I realized that we were still in a world where user space has no control over what happens with MSR emulation in KVM.
That is bad for multiple reasons. In my case, I wanted to emulate the MSR in user space, because it's a CPU specific register that does not exist on older CPUs and that really only contains informational data that is on the package level, so it's a natural fit for user space to provide it.
However, it is also bad on a platform compatibility level. Currrently, KVM has no way to expose different MSRs based on the selected target CPU type.
This patch set introduces a way for user space to indicate to KVM which MSRs should be handled in kernel space. With that, we can solve part of the platform compatibility story. Or at least we can not handle AMD specific MSRs on an Intel platform and vice versa.
In addition, it introduces a way for user space to get into the loop when an MSR access would generate a #GP fault, such as when KVM finds an MSR that is not handled by the in-kernel MSR emulation or when the guest is trying to access reserved registers.
In combination with filtering, user space trapping allows us to emulate arbitrary MSRs in user space, paving the way for target CPU specific MSR implementations from user space.
v1 -> v2:
- s/ETRAP_TO_USER_SPACE/ENOENT/g
- deflect all #GP injection events to user space, not just unknown MSRs. That was we can also deflect allowlist errors later
- fix emulator case
- new patch: KVM: x86: Introduce allow list for MSR emulation
- new patch: KVM: selftests: Add test for user space MSR handling
v2 -> v3:
- return r if r == X86EMUL_IO_NEEDED
- s/KVM_EXIT_RDMSR/KVM_EXIT_X86_RDMSR/g
- s/KVM_EXIT_WRMSR/KVM_EXIT_X86_WRMSR/g
- Use complete_userspace_io logic instead of reply field
- Simplify trapping code
- document flags for KVM_X86_ADD_MSR_ALLOWLIST
- generalize exit path, always unlock when returning
- s/KVM_CAP_ADD_MSR_ALLOWLIST/KVM_CAP_X86_MSR_ALLOWLIST/g
- Add KVM_X86_CLEAR_MSR_ALLOWLIST
- Add test to clear whitelist
- Adjust to reply-less API
- Fix asserts
- Actually trap on MSR_IA32_POWER_CTL writes
v3 -> v4:
- Mention exit reasons in re-enter mandatory section of API documentation
- Clear padding bytes
- Generalize get/set deflect functions
- Remove redundant pending_user_msr field
- lock allow check and clearing
- free bitmaps on clear
v4 -> v5:
- use srcu
v5 -> v6:
- Switch from allow list to filtering API with explicit fallback option
- Support and test passthrough MSR filtering
- Check for filter exit reason
- Add .gitignore
- send filter change notification
- change to atomic set_msr_filter ioctl with fallback flag
- use EPERM for filter blocks
- add bit for MSR user space deflection
- check for overflow of BITS_TO_LONGS (thanks Dan Carpenter!)
- s/int i;/u32 i;/
- remove overlap check
- Introduce exit reason mask to allow for future expansion and filtering
- s/emul_to_vcpu(ctxt)/vcpu/
- imported patch: KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
- new patch: KVM: x86: Add infrastructure for MSR filtering
- new patch: KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
- new patch: KVM: x86: VMX: Prevent MSR passthrough when MSR access is denied
Aaron Lewis (1):
KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
Alexander Graf (6):
KVM: x86: Deflect unknown MSR accesses to user space
KVM: x86: Add infrastructure for MSR filtering
KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
KVM: x86: VMX: Prevent MSR passthrough when MSR access is denied
KVM: x86: Introduce MSR filtering
KVM: selftests: Add test for user space MSR handling
Documentation/virt/kvm/api.rst | 176 +++++++++- arch/x86/include/asm/kvm_host.h | 18 ++ arch/x86/include/uapi/asm/kvm.h | 19 ++ arch/x86/kvm/emulate.c | 18 +- arch/x86/kvm/svm/svm.c | 122 +++++-- arch/x86/kvm/svm/svm.h | 7 + arch/x86/kvm/vmx/nested.c | 2 +- arch/x86/kvm/vmx/vmx.c | 303 ++++++++++++------ arch/x86/kvm/vmx/vmx.h | 9 +- arch/x86/kvm/x86.c | 267 ++++++++++++++- arch/x86/kvm/x86.h | 1 + include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 17 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/x86_64/user_msr_test.c | 224 +++++++++++++ 16 files changed, 1055 insertions(+), 132 deletions(-) create mode 100644 tools/testing/selftests/kvm/x86_64/user_msr_test.c
Signature · 12 lines
2.17.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
PATCH v6 1/7 KVM: x86: Deflect unknown MSR accesses to user space
MSRs are weird. Some of them are normal control registers, such as EFER. Some however are registers that really are model specific, not very interesting to virtualization workloads, and not performance critical. Others again are really just windows into package configuration.
Out of these MSRs, only the first category is necessary to implement in kernel space. Rarely accessed MSRs, MSRs that should be fine tunes against certain CPU models and MSRs that contain information on the package level are much better suited for user space to process. However, over time we have accumulated a lot of MSRs that are not the first category, but still handled by in-kernel KVM code.
This patch adds a generic interface to handle WRMSR and RDMSR from user space. With this, any future MSR that is part of the latter categories can be handled in user space.
Furthermore, it allows us to replace the existing "ignore_msrs" logic with something that applies per-VM rather than on the full system. That way you can run productive VMs in parallel to experimental ones where you don't care about proper MSR handling.
---
v1 -> v2:
- s/ETRAP_TO_USER_SPACE/ENOENT/g
- deflect all #GP injection events to user space, not just unknown MSRs. That was we can also deflect allowlist errors later
- fix emulator case
v2 -> v3:
- return r if r == X86EMUL_IO_NEEDED
- s/KVM_EXIT_RDMSR/KVM_EXIT_X86_RDMSR/g
- s/KVM_EXIT_WRMSR/KVM_EXIT_X86_WRMSR/g
- Use complete_userspace_io logic instead of reply field
- Simplify trapping code
v3 -> v4:
- Mention exit reasons in re-inter mandatory section of API documentation
- Clear padding bytes
- Generalize get/set deflect functions
- Remove redundant pending_user_msr field
v5 -> v6:
- Introduce exit reason mask to allow for future expansion and filtering
- s/emul_to_vcpu(ctxt)/vcpu/
--- Documentation/virt/kvm/api.rst | 73 +++++++++++++++++++- arch/x86/include/asm/kvm_host.h | 3 + arch/x86/kvm/emulate.c | 18 ++++- arch/x86/kvm/x86.c | 119 ++++++++++++++++++++++++++++++-- include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 12 ++++ 6 files changed, 218 insertions(+), 9 deletions(-)
Documentation/virt/kvm/api.rst +71 -2
@@ -4861,8 +4861,8 @@ to the byte array. .. note:: - For KVM_EXIT_IO, KVM_EXIT_MMIO, KVM_EXIT_OSI, KVM_EXIT_PAPR and - KVM_EXIT_EPR the corresponding + For KVM_EXIT_IO, KVM_EXIT_MMIO, KVM_EXIT_OSI, KVM_EXIT_PAPR, + KVM_EXIT_EPR, KVM_EXIT_X86_RDMSR and KVM_EXIT_X86_WRMSR the corresponding operations are complete (and guest state is consistent) only after userspace has re-entered the kernel with KVM_RUN. The kernel side will first finish
@@ -5155,6 +5155,42 @@ Note that KVM does not skip the faulting instruction as it does for KVM_EXIT_MMIO, but userspace has to emulate any change to the processing state if it decides to decode and emulate the instruction. +:: + + /* KVM_EXIT_X86_RDMSR / KVM_EXIT_X86_WRMSR */ + struct { + __u8 error; /* user -> kernel */ + __u8 pad[3]; + __u32 reason; /* kernel -> user */ + __u32 index; /* kernel -> user */ + __u64 data; /* kernel <-> user */ + } msr; + +Used on x86 systems. When the VM capability KVM_CAP_X86_USER_SPACE_MSR is +enabled, MSR accesses to registers that would invoke a #GP by KVM kernel code +will instead trigger a KVM_EXIT_X86_RDMSR exit for reads and KVM_EXIT_X86_WRMSR +exit for writes. + +The "reason" field specifies why the MSR trap occurred. User space will only +receive MSR exit traps when a particular reason was requested during through +ENABLE_CAP. Currently valid exit reasons are: + + KVM_MSR_EXIT_REASON_INVAL - access to invalid MSRs or reserved bits + +For KVM_EXIT_X86_RDMSR, the "index" field tells user space which MSR the guest +wants to read. To respond to this request with a successful read, user space +writes the respective data into the "data" field and must continue guest +execution to ensure the read data is transferred into guest register state. + +If the RDMSR request was unsuccessful, user space indicates that with a "1" in +the "error" field. This will inject a #GP into the guest when the VCPU is +executed again. + +For KVM_EXIT_X86_WRMSR, the "index" field tells user space which MSR the guest +wants to write. Once finished processing the event, user space must continue +vCPU execution. If the MSR write was unsuccessful, user space also sets the +"error" field to "1". + :: /* Fix the size of the union. */
@@ -5844,6 +5880,28 @@ controlled by the kvm module parameter halt_poll_ns. This capability allows the maximum halt time to specified on a per-VM basis, effectively overriding the module parameter for the target VM. +7.21 KVM_CAP_X86_USER_SPACE_MSR +------------------------------- + +:Architectures: x86 +:Target: VM +:Parameters: args[0] contains the mask of KVM_MSR_EXIT_REASON_* events to report +:Returns: 0 on success; -1 on error + +This capability enables trapping of #GP invoking RDMSR and WRMSR instructions +into user space. + +When a guest requests to read or write an MSR, KVM may not implement all MSRs +that are relevant to a respective system. It also does not differentiate by +CPU type. + +To allow more fine grained control over MSR handling, user space may enable +this capability. With it enabled, MSR accesses that match the mask specified in +args[0] and trigger a #GP event inside the guest by KVM will instead trigger +KVM_EXIT_X86_RDMSR and KVM_EXIT_X86_WRMSR exit notifications which user space +can then handle to implement model specific MSR handling and/or user notifications +to inform a user that an MSR was not handled. + 8. Other capabilities. ======================
@@ -6151,3 +6209,14 @@ KVM can therefore start protected VMs. This capability governs the KVM_S390_PV_COMMAND ioctl and the KVM_MP_STATE_LOAD MP_STATE. KVM_SET_MP_STATE can fail for protected guests when the state change is invalid. + +8.24 KVM_CAP_X86_USER_SPACE_MSR +---------------------------- + +:Architectures: x86 + +This capability indicates that KVM supports deflection of MSR reads and +writes to user space. It can be enabled on a VM level. If enabled, MSR +accesses that would usually trigger a #GP by KVM into the guest will +instead get bounced to user space through the KVM_EXIT_X86_RDMSR and +KVM_EXIT_X86_WRMSR exit notifications.
arch/x86/include/asm/kvm_host.h +3 -0
@@ -1002,6 +1002,9 @@ struct kvm_arch {bool guest_can_read_msr_platform_info;bool exception_payload_enabled; +/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */ +u32 user_space_msr_mask; +struct kvm_pmu_event_filter *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread; };
arch/x86/kvm/emulate.c +16 -2
@@ -3689,11 +3689,18 @@ static int em_dr_write(struct x86_emulate_ctxt *ctxt)static int em_wrmsr (struct x86_emulate_ctxt *ctxt) { +u64 msr_index =reg_read (ctxt,VCPU_REGS_RCX );u64 msr_data; +int r; msr_data = (u32 )reg_read (ctxt,VCPU_REGS_RAX ) | ((u64 )reg_read (ctxt,VCPU_REGS_RDX ) <<32 ); -if (ctxt->ops->set_msr (ctxt,reg_read (ctxt,VCPU_REGS_RCX ), msr_data)) + r = ctxt->ops->set_msr (ctxt, msr_index, msr_data); + +if (r ==X86EMUL_IO_NEEDED ) +return r; + +if (r)return emulate_gp (ctxt,0 );return X86EMUL_CONTINUE ;
@@ -3701,9 +3708,16 @@ static int em_wrmsr(struct x86_emulate_ctxt *ctxt)static int em_rdmsr (struct x86_emulate_ctxt *ctxt) { +u64 msr_index =reg_read (ctxt,VCPU_REGS_RCX );u64 msr_data; +int r; + + r = ctxt->ops->get_msr (ctxt, msr_index, &msr_data); + +if (r ==X86EMUL_IO_NEEDED ) +return r; -if (ctxt->ops->get_msr (ctxt,reg_read (ctxt,VCPU_REGS_RCX ), &msr_data)) +if (r)return emulate_gp (ctxt,0 ); *reg_write (ctxt,VCPU_REGS_RAX ) = (u32 )msr_data;
arch/x86/kvm/x86.c +115 -4
160 lines not on this page · raw message
include/trace/events/kvm.h +1 -1
@@ -17,7 +17,7 @@ERSN (NMI ),ERSN (INTERNAL_ERROR ),ERSN (OSI ),ERSN (PAPR_HCALL ), \ERSN (S390_UCONTROL ),ERSN (WATCHDOG ),ERSN (S390_TSCH ),ERSN (EPR ),\ERSN (SYSTEM_EVENT ),ERSN (S390_STSI ),ERSN (IOAPIC_EOI ), \ - ERSN(HYPERV), ERSN(ARM_NISV) + ERSN(HYPERV), ERSN(ARM_NISV), ERSN(X86_RDMSR), ERSN(X86_WRMSR) TRACE_EVENT(kvm_userspace_exit, TP_PROTO(__u32 reason, int errno),
include/uapi/linux/kvm.h +12 -0
@@ -248,6 +248,8 @@ struct kvm_hyperv_exit {#define KVM_EXIT_IOAPIC_EOI 26#define KVM_EXIT_HYPERV 27#define KVM_EXIT_ARM_NISV 28 +#define KVM_EXIT_X86_RDMSR 29 +#define KVM_EXIT_X86_WRMSR 30/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */
@@ -412,6 +414,15 @@ struct kvm_run {__u64 esr_iss;__u64 fault_ipa; } arm_nisv; +/* KVM_EXIT_X86_RDMSR / KVM_EXIT_X86_WRMSR */ +struct { +__u8 error;/* user -> kernel */ +__u8 pad[3 ]; +#define KVM_MSR_EXIT_REASON_INVAL (1 << 0) +__u32 reason;/* kernel -> user */ +__u32 index;/* kernel -> user */ +__u64 data;/* kernel <-> user */ + } msr;/* Fix the size of the union. */ char padding[256 ]; };
@@ -1031,6 +1042,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_PPC_SECURE_GUEST 181#define KVM_CAP_HALT_POLL 182#define KVM_CAP_ASYNC_PF_INT 183 +#define KVM_CAP_X86_USER_SPACE_MSR 184#ifdef KVM_CAP_IRQ_ROUTING
Signature · 12 lines
2.17.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
PATCH v6 2/7 KVM: x86: Add infrastructure for MSR filtering
In reply to Alexander GrafIn the following commits we will add pieces of MSR filtering. To ensure that code compiles even with the feature half-merged, let's add a few stubs and struct definitions before the real patches start.
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/include/uapi/asm/kvm.h | 2 ++ arch/x86/kvm/x86.c | 5 +++++ arch/x86/kvm/x86.h | 1 + 4 files changed, 9 insertions(+)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -1272,6 +1272,7 @@ struct kvm_x86_ops {int (*enable_direct_tlbflush)(struct kvm_vcpu *vcpu);void (*migrate_timers)(struct kvm_vcpu *vcpu); +void (*msr_filter_changed)(struct kvm_vcpu *vcpu); };struct kvm_x86_nested_ops {
arch/x86/include/uapi/asm/kvm.h +2 -0
@@ -192,6 +192,8 @@ struct kvm_msr_list {__u32 indices[0 ]; }; +#define KVM_MSR_ALLOW_READ (1 << 0) +#define KVM_MSR_ALLOW_WRITE (1 << 1)struct kvm_cpuid_entry {__u32 function;
arch/x86/kvm/x86.c +5 -0
@@ -1472,6 +1472,11 @@ void kvm_enable_efer_bits(u64 mask) }EXPORT_SYMBOL_GPL (kvm_enable_efer_bits); +bool kvm_msr_allowed (struct kvm_vcpu *vcpu,u32 index,u32 type) +{ +return true; +} +/* * Write @data into the MSR specified by @index. Select MSR specific fault * checks are bypassed if @host_initiated is %true.
arch/x86/kvm/x86.h +1 -0
@@ -365,5 +365,6 @@ void kvm_load_guest_xsave_state(struct kvm_vcpu *vcpu);void kvm_load_host_xsave_state (struct kvm_vcpu *vcpu);u64 kvm_spec_ctrl_valid_bits (struct kvm_vcpu *vcpu);bool kvm_vcpu_exit_request (struct kvm_vcpu *vcpu); +bool kvm_msr_allowed (struct kvm_vcpu *vcpu,u32 index,u32 type);#endif
Signature · 12 lines
2.17.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
PATCH v6 3/7 KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
In reply to Alexander GrafFrom: Aaron Lewis <[email protected]>
Prepare vmx and svm for a subsequent change that ensures the MSR permission bitmap is set to allow an MSR that userspace is tracking to force a vmx_vmexit in the guest.
--- arch/x86/kvm/svm/svm.c | 48 +++++++++++----------- arch/x86/kvm/vmx/nested.c | 2 +- arch/x86/kvm/vmx/vmx.c | 83 +++++++++++++++++++-------------------- arch/x86/kvm/vmx/vmx.h | 2 +- 4 files changed, 67 insertions(+), 68 deletions(-)
arch/x86/kvm/svm/svm.c +25 -23
@@ -564,7 +564,7 @@ static bool valid_msr_intercept(u32 index)return false; } -static bool msr_write_intercepted (struct kvm_vcpu *vcpu,unsigned msr) +static bool msr_write_intercepted (struct kvm_vcpu *vcpu,u32 msr) {u8 bit_write;unsigned long tmp;
@@ -583,9 +583,11 @@ static bool msr_write_intercepted(struct kvm_vcpu *vcpu, unsigned msr)return !!test_bit (bit_write, &tmp); } -static void set_msr_interception (u32 *msrpm,unsigned msr, -int read,int write) +static void set_msr_interception (struct kvm_vcpu *vcpu,u32 msr,int read, +int write) { +struct vcpu_svm *svm =to_svm (vcpu); +u32 *msrpm = svm->msrpm;u8 bit_read, bit_write;unsigned long tmp;u32 offset;
@@ -609,7 +611,7 @@ static void set_msr_interception(u32 *msrpm, unsigned msr, msrpm[offset] = tmp; } -static void svm_vcpu_init_msrpm (u32 *msrpm) +static void svm_vcpu_init_msrpm (struct kvm_vcpu *vcpu,u32 *msrpm) {int i;
@@ -619,7 +621,7 @@ static void svm_vcpu_init_msrpm(u32 *msrpm)if (!direct_access_msrs[i].always)continue ; -set_msr_interception (msrpm, direct_access_msrs[i].index,1 ,1 ); +set_msr_interception (vcpu, direct_access_msrs[i].index,1 ,1 ); } }
@@ -666,26 +668,26 @@ static void init_msrpm_offsets(void) } } -static void svm_enable_lbrv (struct vcpu_svm *svm) +static void svm_enable_lbrv (struct kvm_vcpu *vcpu) { -u32 *msrpm = svm->msrpm; +struct vcpu_svm *svm =to_svm (vcpu); svm->vmcb->control.virt_ext |=LBR_CTL_ENABLE_MASK ; -set_msr_interception (msrpm,MSR_IA32_LASTBRANCHFROMIP ,1 ,1 ); -set_msr_interception (msrpm,MSR_IA32_LASTBRANCHTOIP ,1 ,1 ); -set_msr_interception (msrpm,MSR_IA32_LASTINTFROMIP ,1 ,1 ); -set_msr_interception (msrpm,MSR_IA32_LASTINTTOIP ,1 ,1 ); +set_msr_interception (vcpu,MSR_IA32_LASTBRANCHFROMIP ,1 ,1 ); +set_msr_interception (vcpu,MSR_IA32_LASTBRANCHTOIP ,1 ,1 ); +set_msr_interception (vcpu,MSR_IA32_LASTINTFROMIP ,1 ,1 ); +set_msr_interception (vcpu,MSR_IA32_LASTINTTOIP ,1 ,1 ); } -static void svm_disable_lbrv (struct vcpu_svm *svm) +static void svm_disable_lbrv (struct kvm_vcpu *vcpu) { -u32 *msrpm = svm->msrpm; +struct vcpu_svm *svm =to_svm (vcpu); svm->vmcb->control.virt_ext &= ~LBR_CTL_ENABLE_MASK ; -set_msr_interception (msrpm,MSR_IA32_LASTBRANCHFROMIP ,0 ,0 ); -set_msr_interception (msrpm,MSR_IA32_LASTBRANCHTOIP ,0 ,0 ); -set_msr_interception (msrpm,MSR_IA32_LASTINTFROMIP ,0 ,0 ); -set_msr_interception (msrpm,MSR_IA32_LASTINTTOIP ,0 ,0 ); +set_msr_interception (vcpu,MSR_IA32_LASTBRANCHFROMIP ,0 ,0 ); +set_msr_interception (vcpu,MSR_IA32_LASTBRANCHTOIP ,0 ,0 ); +set_msr_interception (vcpu,MSR_IA32_LASTINTFROMIP ,0 ,0 ); +set_msr_interception (vcpu,MSR_IA32_LASTINTTOIP ,0 ,0 ); }void disable_nmi_singlestep (struct vcpu_svm *svm)
@@ -1196,10 +1198,10 @@ static int svm_create_vcpu(struct kvm_vcpu *vcpu)clear_page (svm->nested.hsave); svm->msrpm =page_address (msrpm_pages); -svm_vcpu_init_msrpm (svm->msrpm); +svm_vcpu_init_msrpm (vcpu, svm->msrpm); svm->nested.msrpm =page_address (nested_msrpm_pages); -svm_vcpu_init_msrpm (svm->nested.msrpm); +svm_vcpu_init_msrpm (vcpu, svm->nested.msrpm); svm->vmcb =page_address (page);clear_page (svm->vmcb);
@@ -2540,7 +2542,7 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr)* We update the L1 MSR bit as well since it will end up * touching the MSR anyway now. */ -set_msr_interception (svm->msrpm,MSR_IA32_SPEC_CTRL ,1 ,1 ); +set_msr_interception (vcpu,MSR_IA32_SPEC_CTRL ,1 ,1 );break ;case MSR_IA32_PRED_CMD : if (!msr->host_initiated &&
@@ -2555,7 +2557,7 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr)break ;wrmsrl (MSR_IA32_PRED_CMD ,PRED_CMD_IBPB ); -set_msr_interception (svm->msrpm,MSR_IA32_PRED_CMD ,0 ,1 ); +set_msr_interception (vcpu,MSR_IA32_PRED_CMD ,0 ,1 );break ;case MSR_AMD64_VIRT_SPEC_CTRL : if (!msr->host_initiated &&
@@ -2619,9 +2621,9 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) svm->vmcb->save.dbgctl = data;mark_dirty (svm->vmcb,VMCB_LBR );if (data & (1ULL <<0 )) -svm_enable_lbrv (svm); +svm_enable_lbrv (vcpu);else -svm_disable_lbrv (svm); +svm_disable_lbrv (vcpu);break ;case MSR_VM_HSAVE_PA : svm->nested.hsave_msr = data;
arch/x86/kvm/vmx/nested.c +1 -1
@@ -4704,7 +4704,7 @@ static int enter_vmx_operation(struct kvm_vcpu *vcpu)if (vmx_pt_mode_is_host_guest ()) { vmx->pt_desc.guest.ctl =0 ; -pt_update_intercept_for_msr (vmx); +pt_update_intercept_for_msr (vcpu); }return 0 ;
arch/x86/kvm/vmx/vmx.c +40 -43
167 lines not on this page · raw message
arch/x86/kvm/vmx/vmx.h +1 -1
@@ -350,7 +350,7 @@ bool vmx_get_nmi_mask(struct kvm_vcpu *vcpu);void vmx_set_nmi_mask (struct kvm_vcpu *vcpu,bool masked);void vmx_set_virtual_apic_mode (struct kvm_vcpu *vcpu);struct shared_msr_entry *find_msr_entry (struct vcpu_vmx *vmx,u32 msr); -void pt_update_intercept_for_msr (struct vcpu_vmx *vmx); +void pt_update_intercept_for_msr (struct kvm_vcpu *vcpu);void vmx_update_host_rsp (struct vcpu_vmx *vmx,unsigned long host_rsp);int vmx_find_msr_index (struct vmx_msrs *m,u32 msr); int vmx_handle_memory_failure(struct kvm_vcpu *vcpu, int r,
Signature · 12 lines
2.17.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
PATCH v6 4/7 KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
In reply to Alexander GrafWe will introduce the concept of MSRs that may not be handled in kernel space soon. Some MSRs are directly passed through to the guest, effectively making them handled by KVM from user space's point of view.
This patch introduces all logic required to ensure that MSRs that user space wants trapped are not marked as direct access for guests.
--- arch/x86/kvm/svm/svm.c | 78 +++++++++++++++++++++++++++++++++++++----- arch/x86/kvm/svm/svm.h | 7 ++++ 2 files changed, 77 insertions(+), 8 deletions(-)
arch/x86/kvm/svm/svm.c +70 -8
@@ -91,7 +91,7 @@ static DEFINE_PER_CPU(u64, current_tsc_ratio);static const struct svm_direct_access_msrs {u32 index;/* Index of the MSR */ bool always;/* True if intercept is always on */ -} direct_access_msrs[] = { +} direct_access_msrs[MAX_DIRECT_ACCESS_MSRS ] = { { .index =MSR_STAR , .always = true }, { .index =MSR_IA32_SYSENTER_CS , .always = true }, #ifdef CONFIG_X86_64
@@ -553,15 +553,40 @@ static int svm_cpu_init(int cpu) } -static bool valid_msr_intercept (u32 index) +static int direct_access_msr_idx (u32 msr) { -int i; +u32 i;for (i =0 ; direct_access_msrs[i].index !=MSR_INVALID ; i++) -if (direct_access_msrs[i].index == index) -return true; +if (direct_access_msrs[i].index == msr) +return i; -return false; +return -EINVAL ; +} + +static void set_shadow_msr_intercept (struct vcpu_svm *svm,u32 msr,int read, +int write) +{ +int idx =direct_access_msr_idx (msr); + +if (idx == -EINVAL ) +return ; + +/* Set the shadow bitmaps to the desired intercept states */ +if (read) +set_bit (idx, svm->shadow_msr_intercept.read); +else +clear_bit (idx, svm->shadow_msr_intercept.read); + +if (write) +set_bit (idx, svm->shadow_msr_intercept.write); +else +clear_bit (idx, svm->shadow_msr_intercept.write); +} + +static bool valid_msr_intercept (u32 index) +{ +return direct_access_msr_idx (index) != -EINVAL ; }static bool msr_write_intercepted (struct kvm_vcpu *vcpu,u32 msr)
@@ -583,8 +608,8 @@ static bool msr_write_intercepted(struct kvm_vcpu *vcpu, u32 msr)return !!test_bit (bit_write, &tmp); } -static void set_msr_interception (struct kvm_vcpu *vcpu,u32 msr,int read, -int write) +static void set_msr_interception_nosync (struct kvm_vcpu *vcpu,u32 msr, +int read,int write) {struct vcpu_svm *svm =to_svm (vcpu);u32 *msrpm = svm->msrpm;
@@ -598,6 +623,13 @@ static void set_msr_interception(struct kvm_vcpu *vcpu, u32 msr, int read,*/ WARN_ON (!valid_msr_intercept (msr)); +/* Enforce non allowed MSRs to trap */ +if (read && !kvm_msr_allowed (vcpu, msr,KVM_MSR_ALLOW_READ )) + read =0 ; + +if (write && !kvm_msr_allowed (vcpu, msr,KVM_MSR_ALLOW_WRITE )) + write =0 ; + offset =svm_msrpm_offset (msr); bit_read =2 * (msr &0x0f ); bit_write =2 * (msr &0x0f ) +1 ;
@@ -611,6 +643,15 @@ static void set_msr_interception(struct kvm_vcpu *vcpu, u32 msr, int read, msrpm[offset] = tmp; } +static void set_msr_interception (struct kvm_vcpu *vcpu,u32 msr,int read, +int write) +{ +struct vcpu_svm *svm =to_svm (vcpu); + +set_shadow_msr_intercept (svm, msr, read, write); +set_msr_interception_nosync (vcpu, msr, read, write); +} +static void svm_vcpu_init_msrpm (struct kvm_vcpu *vcpu,u32 *msrpm) {int i;
@@ -625,6 +666,25 @@ static void svm_vcpu_init_msrpm(struct kvm_vcpu *vcpu, u32 *msrpm) } } +static void svm_msr_filter_changed (struct kvm_vcpu *vcpu) +{ +struct vcpu_svm *svm =to_svm (vcpu); +u32 i; + +/* +* Set intercept permissions for all direct access MSRs again. They +* will automatically get filtered through the MSR filter, so we are +* back in sync after this. +*/ +for (i =0 ; direct_access_msrs[i].index !=MSR_INVALID ; i++) { +u32 msr = direct_access_msrs[i].index; +u32 read =test_bit (i, svm->shadow_msr_intercept.read); +u32 write =test_bit (i, svm->shadow_msr_intercept.write); + +set_msr_interception_nosync (vcpu, msr, read, write); + } +} +static void add_msr_offset (u32 offset) {int i;
@@ -4088,6 +4148,8 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { .need_emulation_on_page_fault = svm_need_emulation_on_page_fault, .apic_init_signal_blocked = svm_apic_init_signal_blocked, + + .msr_filter_changed = svm_msr_filter_changed, };static struct kvm_x86_init_ops svm_init_ops__initdata = {
arch/x86/kvm/svm/svm.h +7 -0
@@ -31,6 +31,7 @@ static const u32 host_save_user_msrs[] = {#define NR_HOST_SAVE_USER_MSRS ARRAY_SIZE(host_save_user_msrs) +#define MAX_DIRECT_ACCESS_MSRS 15#define MSRPM_OFFSETS 16extern u32 msrpm_offsets[MSRPM_OFFSETS ]__read_mostly ;extern bool npt_enabled;
@@ -161,6 +162,12 @@ struct vcpu_svm {/* which host CPU was used for running this vcpu */ unsigned int last_cpu; + +/* Save desired MSR intercept (read: pass-through) state */ +struct { + DECLARE_BITMAP(read, MAX_DIRECT_ACCESS_MSRS); + DECLARE_BITMAP(write, MAX_DIRECT_ACCESS_MSRS); + } shadow_msr_intercept; };struct svm_cpu_data {
Signature · 12 lines
2.17.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Quoted 123 lines · Alexander Graf
While tying to add support for the
MSR_CORE_THREAD_COUNTMSR in KVM, I realized that we were still in a world where user space has no control over what happens with MSR emulation in KVM.That is bad for multiple reasons. In my case, I wanted to emulate the MSR in user space, because it's a CPU specific register that does not exist on older CPUs and that really only contains informational data that is on the package level, so it's a natural fit for user space to provide it.
However, it is also bad on a platform compatibility level. Currrently, KVM has no way to expose different MSRs based on the selected target CPU type.
This patch set introduces a way for user space to indicate to KVM which MSRs should be handled in kernel space. With that, we can solve part of the platform compatibility story. Or at least we can not handle AMD specific MSRs on an Intel platform and vice versa.
In addition, it introduces a way for user space to get into the loop when an MSR access would generate a #GP fault, such as when KVM finds an MSR that is not handled by the in-kernel MSR emulation or when the guest is trying to access reserved registers.
In combination with filtering, user space trapping allows us to emulate arbitrary MSRs in user space, paving the way for target CPU specific MSR implementations from user space.
v1 -> v2:
- s/ETRAP_TO_USER_SPACE/ENOENT/g
- deflect all #GP injection events to user space, not just unknown MSRs. That was we can also deflect allowlist errors later
- fix emulator case
- new patch: KVM: x86: Introduce allow list for MSR emulation
- new patch: KVM: selftests: Add test for user space MSR handlingv2 -> v3:
- return r if r ==
X86EMUL_IO_NEEDED
- s/KVM_EXIT_RDMSR/KVM_EXIT_X86_RDMSR/g
- s/KVM_EXIT_WRMSR/KVM_EXIT_X86_WRMSR/g
- Usecomplete_userspace_iologic instead of reply field
- Simplify trapping code
- document flags forKVM_X86_ADD_MSR_ALLOWLIST
- generalize exit path, always unlock when returning
- s/KVM_CAP_ADD_MSR_ALLOWLIST/KVM_CAP_X86_MSR_ALLOWLIST/g
- AddKVM_X86_CLEAR_MSR_ALLOWLIST
- Add test to clear whitelist
- Adjust to reply-less API
- Fix asserts
- Actually trap onMSR_IA32_POWER_CTLwritesv3 -> v4:
- Mention exit reasons in re-enter mandatory section of API documentation
- Clear padding bytes
- Generalize get/set deflect functions
- Remove redundantpending_user_msrfield
- lock allow check and clearing
- free bitmaps on clearv4 -> v5:
- use srcu
v5 -> v6:
- Switch from allow list to filtering API with explicit fallback option
- Support and test passthrough MSR filtering
- Check for filter exit reason
- Add .gitignore
- send filter change notification
- change to atomicset_msr_filterioctl with fallback flag
- use EPERM for filter blocks
- add bit for MSR user space deflection
- check for overflow ofBITS_TO_LONGS(thanks Dan Carpenter!)
- s/int i;/u32 i;/
- remove overlap check
- Introduce exit reason mask to allow for future expansion and filtering
- s/emul_to_vcpu(ctxt)/vcpu/
- imported patch: KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
- new patch: KVM: x86: Add infrastructure for MSR filtering
- new patch: KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
- new patch: KVM: x86: VMX: Prevent MSR passthrough when MSR access is deniedAaron Lewis (1):
KVM: x86: Prepare MSR bitmaps for userspace tracked MSRsAlexander Graf (6):
KVM: x86: Deflect unknown MSR accesses to user space
KVM: x86: Add infrastructure for MSR filtering
KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
KVM: x86: VMX: Prevent MSR passthrough when MSR access is denied
KVM: x86: Introduce MSR filtering
KVM: selftests: Add test for user space MSR handlingDocumentation/virt/kvm/api.rst | 176 +++++++++- arch/x86/include/asm/kvm_host.h | 18 ++ arch/x86/include/uapi/asm/kvm.h | 19 ++ arch/x86/kvm/emulate.c | 18 +- arch/x86/kvm/svm/svm.c | 122 +++++-- arch/x86/kvm/svm/svm.h | 7 + arch/x86/kvm/vmx/nested.c | 2 +- arch/x86/kvm/vmx/vmx.c | 303 ++++++++++++------ arch/x86/kvm/vmx/vmx.h | 9 +- arch/x86/kvm/x86.c | 267 ++++++++++++++- arch/x86/kvm/x86.h | 1 + include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 17 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/x86_64/user_msr_test.c | 224 +++++++++++++ 16 files changed, 1055 insertions(+), 132 deletions(-) create mode 100644 tools/testing/selftests/kvm/x86_64/user_msr_test.c--
2.17.1
Quoted 10 lines
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
Hi Alex,
I'm only seeing 4 commits. Are you planning on sending the remaining 3?
Thanks,
Aaron
Quoted 136 lines · Aaron Lewis
Quoted 123 lines · Alexander Graf
While tying to add support for the
MSR_CORE_THREAD_COUNTMSR in KVM, I realized that we were still in a world where user space has no control over what happens with MSR emulation in KVM.That is bad for multiple reasons. In my case, I wanted to emulate the MSR in user space, because it's a CPU specific register that does not exist on older CPUs and that really only contains informational data that is on the package level, so it's a natural fit for user space to provide it.
However, it is also bad on a platform compatibility level. Currrently, KVM has no way to expose different MSRs based on the selected target CPU type.
This patch set introduces a way for user space to indicate to KVM which MSRs should be handled in kernel space. With that, we can solve part of the platform compatibility story. Or at least we can not handle AMD specific MSRs on an Intel platform and vice versa.
In addition, it introduces a way for user space to get into the loop when an MSR access would generate a #GP fault, such as when KVM finds an MSR that is not handled by the in-kernel MSR emulation or when the guest is trying to access reserved registers.
In combination with filtering, user space trapping allows us to emulate arbitrary MSRs in user space, paving the way for target CPU specific MSR implementations from user space.
v1 -> v2:
- s/ETRAP_TO_USER_SPACE/ENOENT/g
- deflect all #GP injection events to user space, not just unknown MSRs. That was we can also deflect allowlist errors later
- fix emulator case
- new patch: KVM: x86: Introduce allow list for MSR emulation
- new patch: KVM: selftests: Add test for user space MSR handlingv2 -> v3:
- return r if r ==
X86EMUL_IO_NEEDED
- s/KVM_EXIT_RDMSR/KVM_EXIT_X86_RDMSR/g
- s/KVM_EXIT_WRMSR/KVM_EXIT_X86_WRMSR/g
- Usecomplete_userspace_iologic instead of reply field
- Simplify trapping code
- document flags forKVM_X86_ADD_MSR_ALLOWLIST
- generalize exit path, always unlock when returning
- s/KVM_CAP_ADD_MSR_ALLOWLIST/KVM_CAP_X86_MSR_ALLOWLIST/g
- AddKVM_X86_CLEAR_MSR_ALLOWLIST
- Add test to clear whitelist
- Adjust to reply-less API
- Fix asserts
- Actually trap onMSR_IA32_POWER_CTLwritesv3 -> v4:
- Mention exit reasons in re-enter mandatory section of API documentation
- Clear padding bytes
- Generalize get/set deflect functions
- Remove redundantpending_user_msrfield
- lock allow check and clearing
- free bitmaps on clearv4 -> v5:
- use srcu
v5 -> v6:
- Switch from allow list to filtering API with explicit fallback option
- Support and test passthrough MSR filtering
- Check for filter exit reason
- Add .gitignore
- send filter change notification
- change to atomicset_msr_filterioctl with fallback flag
- use EPERM for filter blocks
- add bit for MSR user space deflection
- check for overflow ofBITS_TO_LONGS(thanks Dan Carpenter!)
- s/int i;/u32 i;/
- remove overlap check
- Introduce exit reason mask to allow for future expansion and filtering
- s/emul_to_vcpu(ctxt)/vcpu/
- imported patch: KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
- new patch: KVM: x86: Add infrastructure for MSR filtering
- new patch: KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
- new patch: KVM: x86: VMX: Prevent MSR passthrough when MSR access is deniedAaron Lewis (1):
KVM: x86: Prepare MSR bitmaps for userspace tracked MSRsAlexander Graf (6):
KVM: x86: Deflect unknown MSR accesses to user space
KVM: x86: Add infrastructure for MSR filtering
KVM: x86: SVM: Prevent MSR passthrough when MSR access is denied
KVM: x86: VMX: Prevent MSR passthrough when MSR access is denied
KVM: x86: Introduce MSR filtering
KVM: selftests: Add test for user space MSR handlingDocumentation/virt/kvm/api.rst | 176 +++++++++- arch/x86/include/asm/kvm_host.h | 18 ++ arch/x86/include/uapi/asm/kvm.h | 19 ++ arch/x86/kvm/emulate.c | 18 +- arch/x86/kvm/svm/svm.c | 122 +++++-- arch/x86/kvm/svm/svm.h | 7 + arch/x86/kvm/vmx/nested.c | 2 +- arch/x86/kvm/vmx/vmx.c | 303 ++++++++++++------ arch/x86/kvm/vmx/vmx.h | 9 +- arch/x86/kvm/x86.c | 267 ++++++++++++++- arch/x86/kvm/x86.h | 1 + include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 17 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/x86_64/user_msr_test.c | 224 +++++++++++++ 16 files changed, 1055 insertions(+), 132 deletions(-)create mode 100644
tools/testing/selftests/kvm/x86_64/user_msr_test.c--
2.17.1Quoted 10 lines
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
Quoted 3 lines
Hi Alex,
I'm only seeing 4 commits. Are you planning on sending the remaining 3?
Hmm, looks like a combination of bad email server and buggy git broke my neck here. I found a small bug in the series, so I've just sent the full set out again, hopefully completely this time :).
Alex
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879