Allow user space to restrict and augment MSR emulation
Subsystems (6)
v2 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 the allow list, the user space trapping allows us to emulate arbitrary MSRs in user space, paving the way for target CPU specific MSR implementations from user space.
Alexander Graf (3):
KVM: x86: Deflect unknown MSR accesses to user space
KVM: x86: Introduce allow list for MSR emulation
KVM: selftests: Add test for user space MSR handling
Documentation/virt/kvm/api.rst | 115 +++++++++ arch/x86/include/asm/kvm_host.h | 13 + arch/x86/include/uapi/asm/kvm.h | 15 ++ arch/x86/kvm/emulate.c | 18 +- arch/x86/kvm/x86.c | 234 +++++++++++++++++- include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 15 ++ tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/x86_64/user_msr_test.c | 199 +++++++++++++++ 9 files changed, 605 insertions(+), 7 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 v2 1/3 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
--- Documentation/virt/kvm/api.rst | 62 ++++++++++++++++++ arch/x86/include/asm/kvm_host.h | 3 + arch/x86/kvm/emulate.c | 18 +++++- arch/x86/kvm/x86.c | 111 ++++++++++++++++++++++++++++++-- include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 11 ++++ 6 files changed, 200 insertions(+), 7 deletions(-)
Documentation/virt/kvm/api.rst +62 -0
@@ -5155,6 +5155,35 @@ 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_RDMSR / KVM_EXIT_WRMSR */ + struct { + __u8 reply; + __u8 error; + __u8 pad[2]; + __u32 index; + __u64 data; + } 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_RDMSR exit for reads and KVM_EXIT_WRMSR exit for +writes. + +For KVM_EXIT_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 a 1 into the "reply" field and the respective data into the "data" field. + +If the RDMSR request was unsuccessful, user space indicates that with a "1" +in the "reply" field and a "1" in the "error" field. This will inject a #GP +into the guest when the VCPU is executed again. + +For KVM_EXIT_WRMSR, the "index" field tells user space which MSR the guest +wants to write. Once finished processing the event, user space sets the "reply" +field to "1". If the MSR write was unsuccessful, user space also sets the +"error" field to "1". + :: /* Fix the size of the union. */
@@ -5844,6 +5873,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] is 1 if user space MSR handling is enabled, 0 otherwise +: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 would usually trigger +a #GP event inside the guest by KVM will instead trigger KVM_EXIT_RDMSR +and KVM_EXIT_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 +6202,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_RDMSR and +KVM_EXIT_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 */ +bool user_space_msr_enabled; +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 X86EMUL_IO_NEEDED ; + +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 X86EMUL_IO_NEEDED ; -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 +107 -4
152 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(HYPERV), ERSN(ARM_NISV), ERSN(RDMSR), ERSN(WRMSR) TRACE_EVENT(kvm_userspace_exit, TP_PROTO(__u32 reason, int errno),
include/uapi/linux/kvm.h +11 -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_RDMSR 29 +#define KVM_EXIT_WRMSR 30/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */
@@ -412,6 +414,14 @@ struct kvm_run {__u64 esr_iss;__u64 fault_ipa; } arm_nisv; +/* KVM_EXIT_RDMSR / KVM_EXIT_WRMSR */ +struct { +__u8 reply; +__u8 error; +__u8 pad[2 ]; +__u32 index; +__u64 data; + } msr;/* Fix the size of the union. */ char padding[256 ]; };
@@ -1031,6 +1041,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
Re: [PATCH v2 1/3] KVM: x86: Deflect unknown MSR accesses to user space
Quoted 95 lines · Alexander Graf
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.Signed-off-by Alexander Graf <[email protected]>---
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--- Documentation/virt/kvm/api.rst | 62 ++++++++++++++++++ arch/x86/include/asm/kvm_host.h | 3 + arch/x86/kvm/emulate.c | 18 +++++- arch/x86/kvm/x86.c | 111 ++++++++++++++++++++++++++++++-- include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 11 ++++ 6 files changed, 200 insertions(+), 7 deletions(-)Documentation/virt/kvm/api.rst +40
-0@@ -5155,6 +5155,35 @@ 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_RDMSR / KVM_EXIT_WRMSR */ + struct { + __u8 reply; + __u8 error; + __u8 pad[2]; + __u32 index; + __u64 data; + } 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_RDMSR exit for reads and KVM_EXIT_WRMSR exit for +writes. + +For KVM_EXIT_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 a 1 into the "reply" field and the respective data into the "data" field. + +If the RDMSR request was unsuccessful, user space indicates that with a "1" +in the "reply" field and a "1" in the "error" field. This will inject a #GP +into the guest when the VCPU is executed again. + +For KVM_EXIT_WRMSR, the "index" field tells user space which MSR the guest +wants to write. Once finished processing the event, user space sets the "reply" +field to "1". If the MSR write was unsuccessful, user space also sets the +"error" field to "1". + :: /* Fix the size of the union. */@@ -5844,6 +5873,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] is 1 if user space MSR handling is enabled, 0 otherwise +:Returns: 0 on success; -1 on error + +This capability enables trapping of #GP invoking RDMSR and WRMSR instructions +into user space. +
Documentation/virt/kvm/api.rst controlled by the kvm module parameter halt_poll_ns. This capability allows · line 5896
Quoted 10 lines
Documentation/virt/kvm/api.rst +10
-0+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 would usually trigger +a #GP event inside the guest by KVM will instead trigger KVM_EXIT_RDMSR +and KVM_EXIT_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.
(I'm not against the idea, just a spare thought):
#GP on WRMSR may be triggered because we violate some restrictions which can also be conditional (e.g. some other feature enablement), userspace should be aware of that if it cares enough to get the exit.
Quoted 42 lines
Documentation/virt/kvm/api.rst +12
-0+ 8. Other capabilities. ======================@@ -6151,3 +6202,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_RDMSR and +KVM_EXIT_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 */ +bool user_space_msr_enabled; +struct kvm_pmu_event_filter *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread; };arch/x86/kvm/emulate.c +1
-0@@ -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 );
arch/x86/kvm/emulate.c static int em_dr_write(struct x86_emulate_ctxt *ctxt) · line 3701
Quoted 10 lines
arch/x86/kvm/emulate.c +5
-1u64 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 X86EMUL_IO_NEEDED ;
'return r' would've been shorter :-)
Quoted 189 lines
arch/x86/kvm/emulate.c +10
-1+ +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 X86EMUL_IO_NEEDED ; -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 +107
-4@@ -1549,12 +1549,71 @@ int kvm_set_msr(struct kvm_vcpu *vcpu, u32 index, u64 data) }EXPORT_SYMBOL_GPL (kvm_set_msr); +static int kvm_get_msr_user_space (struct kvm_vcpu *vcpu,u32 index,u64 *data) +{ +if (!vcpu->kvm->arch.user_space_msr_enabled) +return 1 ; + +if (vcpu->run->exit_reason ==KVM_EXIT_RDMSR && vcpu->run->msr.reply) { + vcpu->run->msr.reply =0 ; + +if (vcpu->run->msr.error) +return 1 ; + + *data = vcpu->run->msr.data; +return 0 ; + } + + vcpu->run->exit_reason =KVM_EXIT_RDMSR ; + vcpu->run->msr.reply =0 ; + vcpu->run->msr.error =0 ; + vcpu->run->msr.index = index; + +return -ENOENT ; +} + +static int kvm_set_msr_user_space (struct kvm_vcpu *vcpu,u32 index,u64 data) +{ +if (!vcpu->kvm->arch.user_space_msr_enabled) +return 1 ; + +if (vcpu->run->exit_reason ==KVM_EXIT_WRMSR && vcpu->run->msr.reply) { + vcpu->run->msr.reply =0 ; + +if (vcpu->run->msr.error) +return 1 ; + +return 0 ; + } + + vcpu->run->exit_reason =KVM_EXIT_WRMSR ; + vcpu->run->msr.reply =0 ; + vcpu->run->msr.error =0 ; + vcpu->run->msr.index = index; + vcpu->run->msr.data = data; + +return -ENOENT ; +} +int kvm_emulate_rdmsr (struct kvm_vcpu *vcpu) {u32 ecx =kvm_rcx_read (vcpu);u64 data; +int r; + + r =kvm_get_msr (vcpu, ecx, &data); + +/* MSR read failed? See if we should ask user space */ +if (r) { + r =kvm_get_msr_user_space (vcpu, ecx, &data); +if (r == -ENOENT ) { +/* Bounce to user space */ +return 0 ; + } + } -if (kvm_get_msr (vcpu, ecx, &data)) { +/* MSR read failed? Inject a #GP */ +if (r) {trace_kvm_msr_read_ex (ecx);kvm_inject_gp (vcpu,0 );return 1 ;@@ -1572,8 +1631,21 @@ int kvm_emulate_wrmsr(struct kvm_vcpu *vcpu) {u32 ecx =kvm_rcx_read (vcpu);u64 data =kvm_read_edx_eax (vcpu); +int r; + + r =kvm_set_msr (vcpu, ecx, data); + +/* MSR write failed? See if we should ask user space */ +if (r) { + r =kvm_set_msr_user_space (vcpu, ecx, data); +if (r == -ENOENT ) { +/* Bounce to user space */ +return 0 ; + } + } -if (kvm_set_msr (vcpu, ecx, data)) { +/* MSR write failed? Inject a #GP */ +if (r) {trace_kvm_msr_write_ex (ecx, data);kvm_inject_gp (vcpu,0 );return 1 ;@@ -3476,6 +3548,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_MSR_PLATFORM_INFO :case KVM_CAP_EXCEPTION_PAYLOAD :case KVM_CAP_SET_GUEST_DEBUG : +case KVM_CAP_X86_USER_SPACE_MSR : r =1 ;break ;case KVM_CAP_SYNC_REGS :@@ -4990,6 +5063,10 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, kvm->arch.exception_payload_enabled = cap->args[0 ]; r =0 ;break ; +case KVM_CAP_X86_USER_SPACE_MSR : + kvm->arch.user_space_msr_enabled = cap->args[0 ]; + r =0 ; +break ;default : r = -EINVAL ;break ;@@ -6319,13 +6396,39 @@ static void emulator_set_segment(struct x86_emulate_ctxt *ctxt, u16 selector,static int emulator_get_msr (struct x86_emulate_ctxt *ctxt,u32 msr_index,u64 *pdata) { -return kvm_get_msr (emul_to_vcpu (ctxt), msr_index, pdata); +struct kvm_vcpu *vcpu =emul_to_vcpu (ctxt); +int r; + + r =kvm_get_msr (vcpu, msr_index, pdata); + +if (r) { + r =kvm_get_msr_user_space (vcpu, msr_index, pdata); +if (r == -ENOENT ) { +/* Bounce to user space */ +return X86EMUL_IO_NEEDED ; + } + } + +return r; }static int emulator_set_msr (struct x86_emulate_ctxt *ctxt,u32 msr_index,u64 data) { -return kvm_set_msr (emul_to_vcpu (ctxt), msr_index, data); +struct kvm_vcpu *vcpu =emul_to_vcpu (ctxt); +int r; + + r =kvm_set_msr (emul_to_vcpu (ctxt), msr_index, data); + +if (r) { + r =kvm_set_msr_user_space (vcpu, msr_index, data); +if (r == -ENOENT ) { +/* Bounce to user space */ +return X86EMUL_IO_NEEDED ; + } + } + +return r; }static u64 emulator_get_smbase (struct x86_emulate_ctxt *ctxt)include/trace/events/kvm.h +0
-0
include/trace/events/kvm.h line 20
Quoted 5 lines
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 (HYPERV ),ERSN (ARM_NISV ),ERSN (RDMSR ),ERSN (WRMSR )
Nit: adding ARM_NISV here is definitely a good thing but I'd suggest we do this in a separate patch (just think about poor backporters :-)
include/uapi/linux/kvm.h struct kvm_hyperv_exit { · line 252
Quoted 13 lines
include/trace/events/kvm.h +0
-0TRACE_EVENT(kvm_userspace_exit, TP_PROTO(__u32 reason, int errno),include/uapi/linux/kvm.h +2
-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_RDMSR 29 +#define KVM_EXIT_WRMSR 30
It is actually weird we still don't have KVM_EXIT_X86_* exits (but we have KVM_EXIT_ARM_*/KVM_EXIT_S390_*), maybe we should take the opportunity (as these are difinitely X86 specific)?
Quoted 25 lines
include/uapi/linux/kvm.h +9
-0/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */ @@ -412,6 +414,14 @@ struct kvm_run {__u64 esr_iss;__u64 fault_ipa; } arm_nisv; +/* KVM_EXIT_RDMSR / KVM_EXIT_WRMSR */ +struct { +__u8 reply; +__u8 error; +__u8 pad[2 ]; +__u32 index; +__u64 data; + } msr;/* Fix the size of the union. */ char padding[256 ]; };@@ -1031,6 +1041,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 · 1 line
Vitaly
Re: [PATCH v2 1/3] KVM: x86: Deflect unknown MSR accesses to user space
In reply to Alexander GrafQuoted 17 lines · Alexander Graf
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.
Quoted 6 lines
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.Signed-off-by Alexander Graf <[email protected]>
Can we just drop em_wrmsr and em_rdmsr? The in-kernel emulator is already incomplete, and I don't think there is ever a good reason for kvm to emulate RDMSR or WRMSR if the VM-exit was for some other reason (and we shouldn't end up here if the VM-exit was for RDMSR or WRMSR). Am I missing something?
You seem to be assuming that the instruction at CS:IP will still be RDMSR (or WRMSR) after returning from userspace, and we will come through kvm_{get,set}_msr_user_space again at the next KVM_RUN. That isn't necessarily the case, for a variety of reasons. I think the 'completion' of the userspace instruction emulation should be done with the complete_userspace_io [sic] mechanism instead.
I'd really like to see this mechanism apply only in the case of invalid/unknown MSRs, and not for illegal reads/writes as well.
Re: [PATCH v2 1/3] KVM: x86: Deflect unknown MSR accesses to user space
Quoted 24 lines · Jim Mattson
Quoted 22 lines · Alexander Graf
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.
Quoted 7 lines
Quoted 1 line
Signed-off-by Alexander Graf <[email protected]>Can we just drop
em_wrmsrandem_rdmsr? The in-kernel emulator is already incomplete, and I don't think there is ever a good reason for kvm to emulate RDMSR or WRMSR if the VM-exit was for some other reason (and we shouldn't end up here if the VM-exit was for RDMSR or WRMSR). Am I missing something?
On certain combinations of CPUs and guest modes, such as real mode on pre-Nehalem(?) at least, we are running all guest code through the emulator and thus may encounter a RDMSR or WRMSR instruction. I *think* we also do so for big real mode on more modern CPUs, but I'm not 100% sure.
Quoted 4 lines
You seem to be assuming that the instruction at CS:IP will still be RDMSR (or WRMSR) after returning from userspace, and we will come through kvm_{get,set}_msr_user_space again at the next
KVM_RUN. That isn't necessarily the case, for a variety of reasons. I think the
Do you have a particular situation in mind where that would not be the case and where we would still want to actually complete an MSR operation after the environment changed?
Quoted 2 lines
'completion' of the userspace instruction emulation should be done with the
complete_userspace_io[sic] mechanism instead.
Hm, that would avoid a roundtrip into guest mode, but add a cycle through the in-kernel emulator. I'm not sure that's a net win quite yet.
Quoted 3 lines
I'd really like to see this mechanism apply only in the case of invalid/unknown MSRs, and not for illegal reads/writes as well.
Why? Any #GP inducing MSR access will be on the slow path. What's the problem if you get a few more of them in user space that you just bounce back as failing, so they actually do inject a fault?
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
Re: [PATCH v2 1/3] KVM: x86: Deflect unknown MSR accesses to user space
Quoted 36 lines · Alexander Graf
Quoted 24 lines · Jim Mattson
Quoted 22 lines · Alexander Graf
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.Quoted 7 lines
Quoted 1 line
Signed-off-by Alexander Graf <[email protected]>Can we just drop
em_wrmsrandem_rdmsr? The in-kernel emulator is already incomplete, and I don't think there is ever a good reason for kvm to emulate RDMSR or WRMSR if the VM-exit was for some other reason (and we shouldn't end up here if the VM-exit was for RDMSR or WRMSR). Am I missing something?
Quoted 4 lines
On certain combinations of CPUs and guest modes, such as real mode on pre-Nehalem(?) at least, we are running all guest code through the emulator and thus may encounter a RDMSR or WRMSR instruction. I *think* we also do so for big real mode on more modern CPUs, but I'm not 100% sure.
Oh, gag me with a spoon! (BTW, we shouldn't have to emulate big real mode if the CPU supports unrestricted guest mode. If we do, something is probably wrong.)
Quoted 8 lines
Quoted 4 lines
You seem to be assuming that the instruction at CS:IP will still be RDMSR (or WRMSR) after returning from userspace, and we will come through kvm_{get,set}_msr_user_space again at the next
KVM_RUN. That isn't necessarily the case, for a variety of reasons. I think theDo you have a particular situation in mind where that would not be the case and where we would still want to actually complete an MSR operation after the environment changed?
As far as userspace is concerned, if it has replied with error=0, the instruction has completed and retired. If the kernel executes a different instruction at CS:RIP, the state is certainly inconsistent for WRMSR exits. It would also be inconsistent for RDMSR exits if the RDMSR emulation on the userspace side had any side-effects.
Quoted 7 lines
Quoted 2 lines
'completion' of the userspace instruction emulation should be done with the
complete_userspace_io[sic] mechanism instead.Hm, that would avoid a roundtrip into guest mode, but add a cycle through the in-kernel emulator. I'm not sure that's a net win quite yet.
Quoted 1 line
Quoted 6 lines
Quoted 2 lines
I'd really like to see this mechanism apply only in the case of invalid/unknown MSRs, and not for illegal reads/writes as well.
Why? Any #GP inducing MSR access will be on the slow path. What's the problem if you get a few more of them in user space that you just bounce back as failing, so they actually do inject a fault?
I'm not concerned about the performance. I think I'm just biased because of what we have today. But since we're planning on dropping that anyway, I take it back. IIRC, the plumbing to make the distinction is a little painful, and I don't want to ask you to go there.
Re: [PATCH v2 1/3] KVM: x86: Deflect unknown MSR accesses to user space
Quoted 11 lines · Jim Mattson
Quoted 3 lines · Alexander Graf
Do you have a particular situation in mind where that would not be the case and where we would still want to actually complete an MSR operation after the environment changed?
As far as userspace is concerned, if it has replied with error=0, the instruction has completed and retired. If the kernel executes a different instruction at CS:RIP, the state is certainly inconsistent for WRMSR exits. It would also be inconsistent for RDMSR exits if the RDMSR emulation on the userspace side had any side-effects.
Actually, I think there's a potential problem with interrupt delivery even if the instruction bytes are the same. On the second pass, an interrupt could be delivered on the CS:IP of a WRMSR, even though userspace has already emulated the WRMSR instruction. This could be particularly awkward if the WRMSR was to the x2APIC TPR register, and in fact lowered the TPR sufficiently to allow a pending interrupt to be delivered.
Re: [PATCH v2 1/3] KVM: x86: Deflect unknown MSR accesses to user space
Quoted 17 lines · Jim Mattson
CAUTION: This email originated from outside of the organization. Do not click links or open attachments unless you can confirm the sender and know the content is safe.
Quoted 11 lines · Jim Mattson
Quoted 3 lines · Alexander Graf
Do you have a particular situation in mind where that would not be the case and where we would still want to actually complete an MSR operation after the environment changed?
As far as userspace is concerned, if it has replied with error=0, the instruction has completed and retired. If the kernel executes a different instruction at CS:RIP, the state is certainly inconsistent for WRMSR exits. It would also be inconsistent for RDMSR exits if the RDMSR emulation on the userspace side had any side-effects.
Quoted 7 lines
Actually, I think there's a potential problem with interrupt delivery even if the instruction bytes are the same. On the second pass, an interrupt could be delivered on the CS:IP of a WRMSR, even though userspace has already emulated the WRMSR instruction. This could be particularly awkward if the WRMSR was to the x2APIC TPR register, and in fact lowered the TPR sufficiently to allow a pending interrupt to be delivered.
Ok, you got me convinced here :). The following flow breaks with my model:
* rdmsr on 0x123, traps to user space
* user space handles it, writes data into run->msr
* kernel injects pending IRQ
* IRQ handler does rdmsr on 0x124, which would be handled by user space
* kernel returns value for 0x123 to the read
So yes, I agree, we have to finish the instruction handling before we can go back into normal operation flow.
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
PATCH v2 2/3 KVM: x86: Introduce allow list for MSR emulation
In reply to Alexander GrafIt's not desireable to have all MSRs always handled by KVM kernel space. Some MSRs would be useful to handle in user space to either emulate behavior (like uCode updates) or differentiate whether they are valid based on the CPU model.
To allow user space to specify which MSRs it wants to see handled by KVM, this patch introduces a new ioctl to push allow lists of bitmaps into KVM. Based on these bitmaps, KVM can then decide whether to reject MSR access. With the addition of KVM_CAP_X86_USER_SPACE_MSR it can also deflect the denied MSR events to user space to operate on.
If no allowlist is populated, MSR handling stays identical to before.
--- Documentation/virt/kvm/api.rst | 53 ++++++++++++++ arch/x86/include/asm/kvm_host.h | 10 +++ arch/x86/include/uapi/asm/kvm.h | 15 ++++ arch/x86/kvm/x86.c | 123 ++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 4 ++ 5 files changed, 205 insertions(+)
Documentation/virt/kvm/api.rst +53 -0
@@ -4697,6 +4697,45 @@ KVM_PV_VM_VERIFY Verify the integrity of the unpacked image. Only if this succeeds, KVM is allowed to start protected VCPUs. +4.126 KVM_ADD_MSR_ALLOWLIST +------------------------- + +:Capability: KVM_CAP_ADD_MSR_ALLOWLIST +:Architectures: x86 +:Type: vm ioctl +:Parameters: struct kvm_msr_allowlist +:Returns: 0 on success, < 0 on error + +:: + + struct kvm_msr_allowlist { + __u32 flags; + __u32 nmsrs; /* number of msrs in bitmap */ + __u32 base; /* base address for the MSRs bitmap */ + __u32 pad; + + __u8 bitmap[0]; /* a set bit allows that the operation set in flags */ + }; + +This ioctl allows user space to define a set of bitmaps of MSR ranges to +specify whether a certain MSR access is allowed or not. + +If this ioctl has never been invoked, MSR accesses are not guarded and the +old KVM in-kernel emulation behavior is fully preserved. + +As soon as the first allow list was specified, only allowed MSR accesses +are permitted inside of KVM's MSR code. + +Each allowlist specifies a range of MSRs to potentially allow access on. +The range goes from MSR index [base .. base+nmsrs]. The flags field +indicates whether reads, writes or both reads and writes are permitted +by setting a 1 bit in the bitmap for the corresponding MSR index. + +If an MSR access is not permitted through the allow list, it generates a +#GP inside the guest. When combined with KVM_CAP_X86_USER_SPACE_MSR, that +allows user space to deflect and potentially handle various MSR accesses +into user space. + 5. The kvm_run structure ========================
@@ -6213,3 +6252,17 @@ 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_RDMSR and KVM_EXIT_WRMSR exit notifications. + +8.25 KVM_CAP_ADD_MSR_ALLOWLIST +------------------------------ + +:Architectures: x86 + +This capability indicates that KVM supports emulation of only select MSR +registers. With this capability exposed, KVM exports a new VM ioctl +KVM_ADD_MSR_ALLOWLIST which allows user space to specify bitmaps of MSR +ranges that KVM should emulate in kernel space. + +In combination with KVM_CAP_X86_USER_SPACE_MSR, this allows user space to +trap and emulate MSRs that are outside of the scope of KVM as well as +limit the attack surface on KVM's MSR emulation code.
arch/x86/include/asm/kvm_host.h +10 -0
@@ -901,6 +901,13 @@ struct kvm_hv {struct kvm_hv_syndbg hv_syndbg; }; +struct msr_bitmap_range { +u32 flags; +u32 nmsrs; +u32 base; +unsigned long *bitmap; +}; +enum kvm_irqchip_mode {KVM_IRQCHIP_NONE ,KVM_IRQCHIP_KERNEL ,/* created with KVM_CREATE_IRQCHIP */
@@ -1005,6 +1012,9 @@ struct kvm_arch {/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */ bool user_space_msr_enabled; +struct msr_bitmap_range msr_allowlist_ranges[10 ]; +int msr_allowlist_ranges_count; +struct kvm_pmu_event_filter *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread; };
arch/x86/include/uapi/asm/kvm.h +15 -0
@@ -192,6 +192,21 @@ struct kvm_msr_list {__u32 indices[0 ]; }; +#define KVM_MSR_ALLOW_READ (1 << 0) +#define KVM_MSR_ALLOW_WRITE (1 << 1) + +/* Maximum size of the of the bitmap in bytes */ +#define KVM_MSR_ALLOWLIST_MAX_LEN 0x600 + +/* for KVM_ADD_MSR_ALLOWLIST */ +struct kvm_msr_allowlist { +__u32 flags; +__u32 nmsrs;/* number of msrs in bitmap */ +__u32 base;/* base address for the MSRs bitmap */ +__u32 pad; + +__u8 bitmap[0 ];/* a set bit allows that the operation set in flags */ +};struct kvm_cpuid_entry {__u32 function;
arch/x86/kvm/x86.c +123 -0
171 lines not on this page · raw message
include/uapi/linux/kvm.h +4 -0
@@ -1042,6 +1042,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_HALT_POLL 182#define KVM_CAP_ASYNC_PF_INT 183#define KVM_CAP_X86_USER_SPACE_MSR 184 +#define KVM_CAP_ADD_MSR_ALLOWLIST 185#ifdef KVM_CAP_IRQ_ROUTING
@@ -1543,6 +1544,9 @@ struct kvm_pv_cmd {/* Available with KVM_CAP_S390_PROTECTED */ #define KVM_S390_PV_COMMAND _IOWR(KVMIO, 0xc5, struct kvm_pv_cmd) +/* Available with KVM_CAP_ADD_MSR_ALLOWLIST */ +#define KVM_ADD_MSR_ALLOWLIST _IOW(KVMIO, 0xc6, struct kvm_msr_allowlist) +/* Secure Encrypted Virtualization command */ enum sev_cmd_id {/* Guest initialization commands */
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
Re: [PATCH v2 2/3] KVM: x86: Introduce allow list for MSR emulation
Quoted 53 lines · Alexander Graf
It's not desireable to have all MSRs always handled by KVM kernel space. Some MSRs would be useful to handle in user space to either emulate behavior (like uCode updates) or differentiate whether they are valid based on the CPU model.
To allow user space to specify which MSRs it wants to see handled by KVM, this patch introduces a new ioctl to push allow lists of bitmaps into KVM. Based on these bitmaps, KVM can then decide whether to reject MSR access. With the addition of
KVM_CAP_X86_USER_SPACE_MSRit can also deflect the denied MSR events to user space to operate on.If no allowlist is populated, MSR handling stays identical to before.
Signed-off-by KarimAllah Ahmed <[email protected]>Signed-off-by Alexander Graf <[email protected]>--- Documentation/virt/kvm/api.rst | 53 ++++++++++++++ arch/x86/include/asm/kvm_host.h | 10 +++ arch/x86/include/uapi/asm/kvm.h | 15 ++++ arch/x86/kvm/x86.c | 123 ++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 4 ++ 5 files changed, 205 insertions(+)Documentation/virt/kvm/api.rst +23
-0@@ -4697,6 +4697,45 @@ KVM_PV_VM_VERIFY Verify the integrity of the unpacked image. Only if this succeeds, KVM is allowed to start protected VCPUs. +4.126 KVM_ADD_MSR_ALLOWLIST +------------------------- + +:Capability: KVM_CAP_ADD_MSR_ALLOWLIST +:Architectures: x86 +:Type: vm ioctl +:Parameters: struct kvm_msr_allowlist +:Returns: 0 on success, < 0 on error + +:: + + struct kvm_msr_allowlist { + __u32 flags; + __u32 nmsrs; /* number of msrs in bitmap */ + __u32 base; /* base address for the MSRs bitmap */ + __u32 pad; + + __u8 bitmap[0]; /* a set bit allows that the operation set in flags */ + }; + +This ioctl allows user space to define a set of bitmaps of MSR ranges to +specify whether a certain MSR access is allowed or not. +
Documentation/virt/kvm/api.rst KVM_PV_VM_VERIFY · line 4732
Quoted 10 lines
Documentation/virt/kvm/api.rst +10
-0+If this ioctl has never been invoked, MSR accesses are not guarded and the +old KVM in-kernel emulation behavior is fully preserved. + +As soon as the first allow list was specified, only allowed MSR accesses +are permitted inside of KVM's MSR code. + +Each allowlist specifies a range of MSRs to potentially allow access on. +The range goes from MSR index [base .. base+nmsrs]. The flags field +indicates whether reads, writes or both reads and writes are permitted +by setting a 1 bit in the bitmap for the corresponding MSR index.
I think it would make sense to add KVM_MSR_ALLOW_READ/WRITE definitions here as well to make the doc complete.
Quoted 60 lines
Documentation/virt/kvm/api.rst +20
-0+ +If an MSR access is not permitted through the allow list, it generates a +#GP inside the guest. When combined with KVM_CAP_X86_USER_SPACE_MSR, that +allows user space to deflect and potentially handle various MSR accesses +into user space. + 5. The kvm_run structure ========================@@ -6213,3 +6252,17 @@ 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_RDMSR and KVM_EXIT_WRMSR exit notifications. + +8.25 KVM_CAP_ADD_MSR_ALLOWLIST +------------------------------ + +:Architectures: x86 + +This capability indicates that KVM supports emulation of only select MSR +registers. With this capability exposed, KVM exports a new VM ioctl +KVM_ADD_MSR_ALLOWLIST which allows user space to specify bitmaps of MSR +ranges that KVM should emulate in kernel space. + +In combination with KVM_CAP_X86_USER_SPACE_MSR, this allows user space to +trap and emulate MSRs that are outside of the scope of KVM as well as +limit the attack surface on KVM's MSR emulation code.arch/x86/include/asm/kvm_host.h +10
-0@@ -901,6 +901,13 @@ struct kvm_hv {struct kvm_hv_syndbg hv_syndbg; }; +struct msr_bitmap_range { +u32 flags; +u32 nmsrs; +u32 base; +unsigned long *bitmap; +}; +enum kvm_irqchip_mode {KVM_IRQCHIP_NONE ,KVM_IRQCHIP_KERNEL ,/* created with KVM_CREATE_IRQCHIP */ @@ -1005,6 +1012,9 @@ struct kvm_arch {/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */ bool user_space_msr_enabled; +struct msr_bitmap_range msr_allowlist_ranges[10 ]; +int msr_allowlist_ranges_count; +struct kvm_pmu_event_filter *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread; };arch/x86/include/uapi/asm/kvm.h +0
-0
arch/x86/include/uapi/asm/kvm.h struct kvm_msr_list { · line 196
Quoted 5 lines
arch/x86/include/uapi/asm/kvm.h +2
-0@@ -192,6 +192,21 @@ struct kvm_msr_list {__u32 indices[0 ]; }; +#define KVM_MSR_ALLOW_READ (1 << 0) +#define KVM_MSR_ALLOW_WRITE (1 << 1)
Nit: BIT(0)/BIT(1) maybe?
Quoted 88 lines
arch/x86/include/uapi/asm/kvm.h +13
-0+ +/* Maximum size of the of the bitmap in bytes */ +#define KVM_MSR_ALLOWLIST_MAX_LEN 0x600 + +/* for KVM_ADD_MSR_ALLOWLIST */ +struct kvm_msr_allowlist { +__u32 flags; +__u32 nmsrs;/* number of msrs in bitmap */ +__u32 base;/* base address for the MSRs bitmap */ +__u32 pad; + +__u8 bitmap[0 ];/* a set bit allows that the operation set in flags */ +};struct kvm_cpuid_entry {__u32 function;arch/x86/kvm/x86.c +36
-0@@ -1472,6 +1472,29 @@ void kvm_enable_efer_bits(u64 mask) }EXPORT_SYMBOL_GPL (kvm_enable_efer_bits); +static bool kvm_msr_allowed (struct kvm_vcpu *vcpu,u32 index,u32 type) +{ +struct msr_bitmap_range *ranges = vcpu->kvm->arch.msr_allowlist_ranges; +u32 count = vcpu->kvm->arch.msr_allowlist_ranges_count; +u32 i; + +/* MSR allowlist not set up, allow everything */ +if (!count) +return true; + +for (i =0 ; i < count; i++) { +u32 start = ranges[i].base; +u32 end = start + ranges[i].nmsrs; +int flags = ranges[i].flags; +unsigned long *bitmap = ranges[i].bitmap; + +if ((index >= start) && (index < end) && (flags & type)) +return !!test_bit (index - start, bitmap); + } + +return false; +} +/* * Write @data into the MSR specified by @index. Select MSR specific fault * checks are bypassed if @host_initiated is %true. @@ -1483,6 +1506,9 @@ static int __kvm_set_msr(struct kvm_vcpu *vcpu, u32 index, u64 data, {struct msr_data msr; +if (!host_initiated && !kvm_msr_allowed (vcpu, index,KVM_MSR_ALLOW_WRITE )) +return -ENOENT ; +switch (index) {case MSR_FS_BASE :case MSR_GS_BASE :@@ -1528,6 +1554,9 @@ int __kvm_get_msr(struct kvm_vcpu *vcpu, u32 index, u64 *data,struct msr_data msr;int ret; +if (!host_initiated && !kvm_msr_allowed (vcpu, index,KVM_MSR_ALLOW_READ )) +return -ENOENT ; + msr.index = index; msr.host_initiated = host_initiated;@@ -3549,6 +3578,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_EXCEPTION_PAYLOAD :case KVM_CAP_SET_GUEST_DEBUG :case KVM_CAP_X86_USER_SPACE_MSR : +case KVM_CAP_ADD_MSR_ALLOWLIST : r =1 ;break ;case KVM_CAP_SYNC_REGS :@@ -5074,6 +5104,92 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm,return r; } +static bool msr_range_overlaps (struct kvm *kvm,struct msr_bitmap_range *range) +{ +struct msr_bitmap_range *ranges = kvm->arch.msr_allowlist_ranges; +u32 i, count = kvm->arch.msr_allowlist_ranges_count; + +for (i =0 ; i < count; i++) {
arch/x86/kvm/x86.c int kvm_vm_ioctl_enable_cap(struct kvm *kvm, · line 5122
Quoted 10 lines
arch/x86/kvm/x86.c +10
-0+u32 start =max (range->base, ranges[i].base); +u32 end =min (range->base + range->nmsrs, + ranges[i].base + ranges[i].nmsrs); + +if ((start < end) && (range->flags & ranges[i].flags)) +return true; + } + +return false; +}
It is a bit weird that we can only add something to allowlist, there is no way to remove anything/everything from it.
E.g. if I add a range of msrs allowing read access only but later some feature gets enabled and I'd like to convert some of these MSRs to read/write, I, apparently can add overlapping ranges with "write-only" access (as range->flags & ranges[i].flags allows me to do that) but I can't add an overlapping 'read/write' region. This is not obvious.
Quoted 56 lines
arch/x86/kvm/x86.c +56
-0+ +static int kvm_vm_ioctl_add_msr_allowlist (struct kvm *kvm,void __user *argp) +{ +struct msr_bitmap_range *ranges = kvm->arch.msr_allowlist_ranges; +struct kvm_msr_allowlist __user *user_msr_allowlist = argp; +struct msr_bitmap_range range; +struct kvm_msr_allowlist kernel_msr_allowlist; +unsigned long *bitmap =NULL ; +size_t bitmap_size; +int r; + +if (copy_from_user (&kernel_msr_allowlist, user_msr_allowlist, +sizeof (kernel_msr_allowlist))) { + r = -EFAULT ; + goto out_err; + } + + bitmap_size =BITS_TO_LONGS (kernel_msr_allowlist.nmsrs) *sizeof (long ); +if (bitmap_size >KVM_MSR_ALLOWLIST_MAX_LEN ) { + r = -EINVAL ; + goto out_err; + } + + bitmap =memdup_user (user_msr_allowlist->bitmap, bitmap_size); +if (IS_ERR (bitmap)) { + r =PTR_ERR (bitmap); + goto out_err; + } + + range = (struct msr_bitmap_range ) { + .flags = kernel_msr_allowlist.flags, + .base = kernel_msr_allowlist.base, + .nmsrs = kernel_msr_allowlist.nmsrs, + .bitmap = bitmap, + }; + +if (range.flags & ~(KVM_MSR_ALLOW_READ |KVM_MSR_ALLOW_WRITE )) { + r = -EINVAL ; + goto out_err; + } + +/* +* Protect from concurrent calls to this function that could trigger +* a TOCTOU violation on kvm->arch.msr_allowlist_ranges_count. +*/ +mutex_lock (&kvm->lock); + +if (kvm->arch.msr_allowlist_ranges_count >= +ARRAY_SIZE (kvm->arch.msr_allowlist_ranges)) { + r = -E2BIG ; + goto out_err; + } + +if (msr_range_overlaps (kvm, &range)) { + r = -EINVAL ; + goto out_err;
arch/x86/kvm/x86.c int kvm_vm_ioctl_enable_cap(struct kvm *kvm, · line 5188
Quoted 10 lines
arch/x86/kvm/x86.c +10
-0+ } + +/* Everything ok, add this range identifier to our global pool */ + ranges[kvm->arch.msr_allowlist_ranges_count++] = range; + +mutex_unlock (&kvm->lock); + +return 0 ; + +out_err:
You seem to forget to unlock &kvm->lock here.
Quoted 40 lines
arch/x86/kvm/x86.c +11
-0+kfree (bitmap); +return r; +} +long kvm_arch_vm_ioctl (struct file *filp,unsigned int ioctl,unsigned long arg) {@@ -5380,6 +5496,9 @@ long kvm_arch_vm_ioctl(struct file *filp,case KVM_SET_PMU_EVENT_FILTER : r =kvm_vm_ioctl_set_pmu_event_filter (kvm, argp);break ; +case KVM_ADD_MSR_ALLOWLIST : + r =kvm_vm_ioctl_add_msr_allowlist (kvm, argp); +break ;default : r = -ENOTTY ; }@@ -10091,6 +10210,8 @@ void kvm_arch_pre_destroy_vm(struct kvm *kvm)void kvm_arch_destroy_vm (struct kvm *kvm) { +int i; +if (current->mm == kvm->mm) {/* * Free memory regions allocated on behalf of userspace, @@ -10107,6 +10228,8 @@ void kvm_arch_destroy_vm(struct kvm *kvm) }if (kvm_x86_ops.vm_destroy) kvm_x86_ops.vm_destroy (kvm); +for (i =0 ; i < kvm->arch.msr_allowlist_ranges_count; i++) +kfree (kvm->arch.msr_allowlist_ranges[i].bitmap);kvm_pic_destroy (kvm);kvm_ioapic_destroy (kvm);kvm_free_vcpus (kvm);include/uapi/linux/kvm.h +0
-0
include/uapi/linux/kvm.h struct kvm_ppc_resize_hpt { · line 1045
Quoted 4 lines
include/uapi/linux/kvm.h +1
-0@@ -1042,6 +1042,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_HALT_POLL 182#define KVM_CAP_ASYNC_PF_INT 183#define KVM_CAP_X86_USER_SPACE_MSR 184 +#define KVM_CAP_ADD_MSR_ALLOWLIST 185
X86?
Quoted 13 lines
include/uapi/linux/kvm.h +3
-0#ifdef KVM_CAP_IRQ_ROUTING @@ -1543,6 +1544,9 @@ struct kvm_pv_cmd {/* Available with KVM_CAP_S390_PROTECTED */ #define KVM_S390_PV_COMMAND _IOWR(KVMIO, 0xc5, struct kvm_pv_cmd) +/* Available with KVM_CAP_ADD_MSR_ALLOWLIST */ +#define KVM_ADD_MSR_ALLOWLIST _IOW(KVMIO, 0xc6, struct kvm_msr_allowlist) +/* Secure Encrypted Virtualization command */ enum sev_cmd_id {/* Guest initialization commands */
Signature · 1 line
Vitaly
Re: [PATCH v2 2/3] KVM: x86: Introduce allow list for MSR emulation
Quoted 60 lines · Vitaly Kuznetsov
Quoted 58 lines · Alexander Graf
It's not desireable to have all MSRs always handled by KVM kernel space. Some MSRs would be useful to handle in user space to either emulate behavior (like uCode updates) or differentiate whether they are valid based on the CPU model.
To allow user space to specify which MSRs it wants to see handled by KVM, this patch introduces a new ioctl to push allow lists of bitmaps into KVM. Based on these bitmaps, KVM can then decide whether to reject MSR access. With the addition of
KVM_CAP_X86_USER_SPACE_MSRit can also deflect the denied MSR events to user space to operate on.If no allowlist is populated, MSR handling stays identical to before.
Signed-off-by KarimAllah Ahmed <[email protected]>Signed-off-by Alexander Graf <[email protected]>--- Documentation/virt/kvm/api.rst | 53 ++++++++++++++ arch/x86/include/asm/kvm_host.h | 10 +++ arch/x86/include/uapi/asm/kvm.h | 15 ++++ arch/x86/kvm/x86.c | 123 ++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 4 ++ 5 files changed, 205 insertions(+)Documentation/virt/kvm/api.rst +28
-0@@ -4697,6 +4697,45 @@ KVM_PV_VM_VERIFY Verify the integrity of the unpacked image. Only if this succeeds, KVM is allowed to start protected VCPUs. +4.126 KVM_ADD_MSR_ALLOWLIST +------------------------- + +:Capability: KVM_CAP_ADD_MSR_ALLOWLIST +:Architectures: x86 +:Type: vm ioctl +:Parameters: struct kvm_msr_allowlist +:Returns: 0 on success, < 0 on error + +:: + + struct kvm_msr_allowlist { + __u32 flags; + __u32 nmsrs; /* number of msrs in bitmap */ + __u32 base; /* base address for the MSRs bitmap */ + __u32 pad; + + __u8 bitmap[0]; /* a set bit allows that the operation set in flags */ + }; + +This ioctl allows user space to define a set of bitmaps of MSR ranges to +specify whether a certain MSR access is allowed or not. + +If this ioctl has never been invoked, MSR accesses are not guarded and the +old KVM in-kernel emulation behavior is fully preserved. + +As soon as the first allow list was specified, only allowed MSR accesses +are permitted inside of KVM's MSR code.
Quoted 8 lines
Documentation/virt/kvm/api.rst KVM_PV_VM_VERIFY · line 4732
Quoted 5 lines
Documentation/virt/kvm/api.rst +5
-0+ +Each allowlist specifies a range of MSRs to potentially allow access on. +The range goes from MSR index [base .. base+nmsrs]. The flags field +indicates whether reads, writes or both reads and writes are permitted +by setting a 1 bit in the bitmap for the corresponding MSR index.I think it would make sense to add KVM_MSR_ALLOW_READ/WRITE definitions here as well to make the doc complete.
Great point, will add :)
Quoted 64 lines
Quoted 64 lines
Documentation/virt/kvm/api.rst +20
-0+ +If an MSR access is not permitted through the allow list, it generates a +#GP inside the guest. When combined with KVM_CAP_X86_USER_SPACE_MSR, that +allows user space to deflect and potentially handle various MSR accesses +into user space. + 5. The kvm_run structure ========================@@ -6213,3 +6252,17 @@ 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_RDMSR and KVM_EXIT_WRMSR exit notifications. + +8.25 KVM_CAP_ADD_MSR_ALLOWLIST +------------------------------ + +:Architectures: x86 + +This capability indicates that KVM supports emulation of only select MSR +registers. With this capability exposed, KVM exports a new VM ioctl +KVM_ADD_MSR_ALLOWLIST which allows user space to specify bitmaps of MSR +ranges that KVM should emulate in kernel space. + +In combination with KVM_CAP_X86_USER_SPACE_MSR, this allows user space to +trap and emulate MSRs that are outside of the scope of KVM as well as +limit the attack surface on KVM's MSR emulation code.arch/x86/include/asm/kvm_host.h +10
-0@@ -901,6 +901,13 @@ struct kvm_hv {struct kvm_hv_syndbg hv_syndbg; }; +struct msr_bitmap_range { +u32 flags; +u32 nmsrs; +u32 base; +unsigned long *bitmap; +}; +enum kvm_irqchip_mode {KVM_IRQCHIP_NONE ,KVM_IRQCHIP_KERNEL ,/* created with KVM_CREATE_IRQCHIP */ @@ -1005,6 +1012,9 @@ struct kvm_arch {/* Deflect RDMSR and WRMSR to user space when they trigger a #GP */ bool user_space_msr_enabled; +struct msr_bitmap_range msr_allowlist_ranges[10 ]; +int msr_allowlist_ranges_count; +struct kvm_pmu_event_filter *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread; };arch/x86/include/uapi/asm/kvm.h +0
-0@@ -192,6 +192,21 @@ struct kvm_msr_list {__u32 indices[0 ]; };
Quoted 4 lines
arch/x86/include/uapi/asm/kvm.h struct kvm_msr_list { · line 196
Quoted 2 lines
arch/x86/include/uapi/asm/kvm.h +2
-0+#define KVM_MSR_ALLOW_READ (1 << 0) +#define KVM_MSR_ALLOW_WRITE (1 << 1)Nit: BIT(0)/BIT(1) maybe?
I don't think the BIT() macros are exposed in uapi, are they? This is definitely a lot more portable and seems to be in line with other uapi bit definitions.
Quoted 103 lines
Quoted 89 lines
arch/x86/include/uapi/asm/kvm.h +13
-0+ +/* Maximum size of the of the bitmap in bytes */ +#define KVM_MSR_ALLOWLIST_MAX_LEN 0x600 + +/* for KVM_ADD_MSR_ALLOWLIST */ +struct kvm_msr_allowlist { +__u32 flags; +__u32 nmsrs;/* number of msrs in bitmap */ +__u32 base;/* base address for the MSRs bitmap */ +__u32 pad; + +__u8 bitmap[0 ];/* a set bit allows that the operation set in flags */ +};struct kvm_cpuid_entry {__u32 function;arch/x86/kvm/x86.c +36
-0@@ -1472,6 +1472,29 @@ void kvm_enable_efer_bits(u64 mask) }EXPORT_SYMBOL_GPL (kvm_enable_efer_bits); +static bool kvm_msr_allowed (struct kvm_vcpu *vcpu,u32 index,u32 type) +{ +struct msr_bitmap_range *ranges = vcpu->kvm->arch.msr_allowlist_ranges; +u32 count = vcpu->kvm->arch.msr_allowlist_ranges_count; +u32 i; + +/* MSR allowlist not set up, allow everything */ +if (!count) +return true; + +for (i =0 ; i < count; i++) { +u32 start = ranges[i].base; +u32 end = start + ranges[i].nmsrs; +int flags = ranges[i].flags; +unsigned long *bitmap = ranges[i].bitmap; + +if ((index >= start) && (index < end) && (flags & type)) +return !!test_bit (index - start, bitmap); + } + +return false; +} +/* * Write @data into the MSR specified by @index. Select MSR specific fault * checks are bypassed if @host_initiated is %true. @@ -1483,6 +1506,9 @@ static int __kvm_set_msr(struct kvm_vcpu *vcpu, u32 index, u64 data, {struct msr_data msr; +if (!host_initiated && !kvm_msr_allowed (vcpu, index,KVM_MSR_ALLOW_WRITE )) +return -ENOENT ; +switch (index) {case MSR_FS_BASE :case MSR_GS_BASE :@@ -1528,6 +1554,9 @@ int __kvm_get_msr(struct kvm_vcpu *vcpu, u32 index, u64 *data,struct msr_data msr;int ret; +if (!host_initiated && !kvm_msr_allowed (vcpu, index,KVM_MSR_ALLOW_READ )) +return -ENOENT ; + msr.index = index; msr.host_initiated = host_initiated;@@ -3549,6 +3578,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_EXCEPTION_PAYLOAD :case KVM_CAP_SET_GUEST_DEBUG :case KVM_CAP_X86_USER_SPACE_MSR : +case KVM_CAP_ADD_MSR_ALLOWLIST : r =1 ;break ;case KVM_CAP_SYNC_REGS :@@ -5074,6 +5104,92 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm,return r; } +static bool msr_range_overlaps (struct kvm *kvm,struct msr_bitmap_range *range) +{ +struct msr_bitmap_range *ranges = kvm->arch.msr_allowlist_ranges; +u32 i, count = kvm->arch.msr_allowlist_ranges_count; + +for (i =0 ; i < count; i++) {arch/x86/kvm/x86.c int kvm_vm_ioctl_enable_cap(struct kvm *kvm, · line 5122
Quoted 10 lines
arch/x86/kvm/x86.c +10
-0+u32 start =max (range->base, ranges[i].base); +u32 end =min (range->base + range->nmsrs, + ranges[i].base + ranges[i].nmsrs); + +if ((start < end) && (range->flags & ranges[i].flags)) +return true; + } + +return false; +}It is a bit weird that we can only add something to allowlist, there is no way to remove anything/everything from it.
Quoted 5 lines
E.g. if I add a range of msrs allowing read access only but later some feature gets enabled and I'd like to convert some of these MSRs to read/write, I, apparently can add overlapping ranges with "write-only" access (as
range->flags& ranges[i].flags allows me to do that) but I can't add an overlapping 'read/write' region. This is not obvious.
When assembling the patch, I could not think of cases where anyone would want to have that list changable at runtime, but I guess you may want to do that based on whether the guest enables features or not.
So I'll add a clear operation. That way user space can stop all vcpus, clear the list, add all entries again and resume if it really wants to change MSR permissions at runtime.
Quoted 61 lines
Quoted 61 lines
arch/x86/kvm/x86.c +60
-0+ +static int kvm_vm_ioctl_add_msr_allowlist (struct kvm *kvm,void __user *argp) +{ +struct msr_bitmap_range *ranges = kvm->arch.msr_allowlist_ranges; +struct kvm_msr_allowlist __user *user_msr_allowlist = argp; +struct msr_bitmap_range range; +struct kvm_msr_allowlist kernel_msr_allowlist; +unsigned long *bitmap =NULL ; +size_t bitmap_size; +int r; + +if (copy_from_user (&kernel_msr_allowlist, user_msr_allowlist, +sizeof (kernel_msr_allowlist))) { + r = -EFAULT ; + goto out_err; + } + + bitmap_size =BITS_TO_LONGS (kernel_msr_allowlist.nmsrs) *sizeof (long ); +if (bitmap_size >KVM_MSR_ALLOWLIST_MAX_LEN ) { + r = -EINVAL ; + goto out_err; + } + + bitmap =memdup_user (user_msr_allowlist->bitmap, bitmap_size); +if (IS_ERR (bitmap)) { + r =PTR_ERR (bitmap); + goto out_err; + } + + range = (struct msr_bitmap_range ) { + .flags = kernel_msr_allowlist.flags, + .base = kernel_msr_allowlist.base, + .nmsrs = kernel_msr_allowlist.nmsrs, + .bitmap = bitmap, + }; + +if (range.flags & ~(KVM_MSR_ALLOW_READ |KVM_MSR_ALLOW_WRITE )) { + r = -EINVAL ; + goto out_err; + } + +/* +* Protect from concurrent calls to this function that could trigger +* a TOCTOU violation on kvm->arch.msr_allowlist_ranges_count. +*/ +mutex_lock (&kvm->lock); + +if (kvm->arch.msr_allowlist_ranges_count >= +ARRAY_SIZE (kvm->arch.msr_allowlist_ranges)) { + r = -E2BIG ; + goto out_err; + } + +if (msr_range_overlaps (kvm, &range)) { + r = -EINVAL ; + goto out_err; + } + +/* Everything ok, add this range identifier to our global pool */ + ranges[kvm->arch.msr_allowlist_ranges_count++] = range;
Quoted 8 lines
arch/x86/kvm/x86.c int kvm_vm_ioctl_enable_cap(struct kvm *kvm, · line 5188
Quoted 6 lines
arch/x86/kvm/x86.c +6
-0+ +mutex_unlock (&kvm->lock); + +return 0 ; + +out_err:You seem to forget to unlock
&kvm->lockhere.
Ugh, thanks!
Quoted 39 lines
Quoted 39 lines
arch/x86/kvm/x86.c +11
-0+kfree (bitmap); +return r; +} +long kvm_arch_vm_ioctl (struct file *filp,unsigned int ioctl,unsigned long arg) {@@ -5380,6 +5496,9 @@ long kvm_arch_vm_ioctl(struct file *filp,case KVM_SET_PMU_EVENT_FILTER : r =kvm_vm_ioctl_set_pmu_event_filter (kvm, argp);break ; +case KVM_ADD_MSR_ALLOWLIST : + r =kvm_vm_ioctl_add_msr_allowlist (kvm, argp); +break ;default : r = -ENOTTY ; }@@ -10091,6 +10210,8 @@ void kvm_arch_pre_destroy_vm(struct kvm *kvm)void kvm_arch_destroy_vm (struct kvm *kvm) { +int i; +if (current->mm == kvm->mm) {/* * Free memory regions allocated on behalf of userspace, @@ -10107,6 +10228,8 @@ void kvm_arch_destroy_vm(struct kvm *kvm) }if (kvm_x86_ops.vm_destroy) kvm_x86_ops.vm_destroy (kvm); +for (i =0 ; i < kvm->arch.msr_allowlist_ranges_count; i++) +kfree (kvm->arch.msr_allowlist_ranges[i].bitmap);kvm_pic_destroy (kvm);kvm_ioapic_destroy (kvm);kvm_free_vcpus (kvm);include/uapi/linux/kvm.h +0
-1--- a/include/uapi/linux/kvm.h
Quoted 8 lines
include/uapi/linux/kvm.h struct kvm_ppc_resize_hpt { · line 1045
Quoted 6 lines
+++
b/include/uapi/linux/kvm.hinclude/uapi/linux/kvm.h +1
-0@@ -1042,6 +1042,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_HALT_POLL 182#define KVM_CAP_ASYNC_PF_INT 183#define KVM_CAP_X86_USER_SPACE_MSR 184 +#define KVM_CAP_ADD_MSR_ALLOWLIST 185X86?
Yup :). Same for the add ioctl I guess.
Alex
Quoted 8 lines
Quoted 8 lines
include/uapi/linux/kvm.h +0
-0#ifdef KVM_CAP_IRQ_ROUTING @@ -1543,6 +1544,9 @@ struct kvm_pv_cmd {/* Available with KVM_CAP_S390_PROTECTED */ #define KVM_S390_PV_COMMAND _IOWR(KVMIO, 0xc5, struct kvm_pv_cmd)
Quoted 10 lines
include/uapi/linux/kvm.h struct kvm_pv_cmd { · line 1552
Quoted 6 lines
include/uapi/linux/kvm.h +3
-0+/* Available with KVM_CAP_ADD_MSR_ALLOWLIST */ +#define KVM_ADD_MSR_ALLOWLIST _IOW(KVMIO, 0xc6, struct kvm_msr_allowlist) +/* Secure Encrypted Virtualization command */ enum sev_cmd_id {/* Guest initialization commands */ --
Vitaly
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 v2 3/3 KVM: selftests: Add test for user space MSR handling
In reply to Alexander GrafNow that we have the ability to handle MSRs from user space and also to select which ones we do want to prevent in-kernel KVM code from handling, let's add a selftest to show case and verify the API.
--- tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/x86_64/user_msr_test.c | 199 ++++++++++++++++++ 2 files changed, 200 insertions(+) create mode 100644 tools/testing/selftests/kvm/x86_64/user_msr_test.c
tools/testing/selftests/kvm/Makefile +1 -0
@@ -55,6 +55,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/vmx_set_nested_state_test TEST_GEN_PROGS_x86_64 += x86_64/vmx_tsc_adjust_test TEST_GEN_PROGS_x86_64 += x86_64/xss_msr_test TEST_GEN_PROGS_x86_64 += x86_64/debug_regs +TEST_GEN_PROGS_x86_64 += x86_64/user_msr_test TEST_GEN_PROGS_x86_64 += clear_dirty_log_test TEST_GEN_PROGS_x86_64 += demand_paging_test TEST_GEN_PROGS_x86_64 += dirty_log_test
tools/testing/selftests/kvm/x86_64/user_msr_test.c new file +199 -0
199 lines not on this page · raw message
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