Allow userspace to manage MSRs
Subsystems (6)
v2 cover Allow userspace to manage MSRs
This series makes it possible for userspace to manage MSRs by having KVM forward select MSRs to it when rdmsr and wrmsr are executed in the guest. Userspace can set this up by calling the ioctl KVM_SET_EXIT_MSRS with a list of MSRs it wants to manage. When KVM encounters any of these MSRs they are forwarded to userspace for processing. Userspace can then read from or write to the MSR, or it can also throw a #GP if needed.
This series includes the kernel changes needed to implement this feature and a test that exercises this behavior. Also, included is an implementation of expection handling in selftests, which allows the test to excercise throwing a #GP.
v1 -> v2:
- Added support for generic instruction emulator bouncing to userspace when rdmsr or wrmsr are called, and userspace has asked to manage the MSR. These changes are committed in patch 3, and are based on changes made by Alexander Graf <[email protected]>.
- Added tests to excercise the code paths for em_{rdmsr,wrmsr} and emulator_{get,set}_msr. These chagnes are committed in patch 8.
Aaron Lewis (8):
KVM: x86: Add ioctl for accepting a userspace provided MSR list
KVM: x86: Add support for exiting to userspace on rdmsr or wrmsr
KVM: x86: Allow em_{rdmsr,wrmsr} to bounce to userspace
KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
KVM: x86: Ensure the MSR bitmap never clears userspace tracked MSRs
selftests: kvm: Fix the segment descriptor layout to match the actual
layout
selftests: kvm: Add test to exercise userspace MSR list
selftests: kvm: Add emulated rdmsr, wrmsr tests
Documentation/virt/kvm/api.rst | 53 ++- arch/x86/include/asm/kvm_host.h | 5 + arch/x86/kvm/emulate.c | 18 +- arch/x86/kvm/svm/svm.c | 93 ++-- arch/x86/kvm/trace.h | 24 + arch/x86/kvm/vmx/nested.c | 2 +- arch/x86/kvm/vmx/vmx.c | 94 ++-- arch/x86/kvm/vmx/vmx.h | 2 +- arch/x86/kvm/x86.c | 174 +++++++- include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 12 + tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 20 +- .../selftests/kvm/include/x86_64/processor.h | 29 +- tools/testing/selftests/kvm/lib/kvm_util.c | 17 + .../selftests/kvm/lib/kvm_util_internal.h | 2 + .../selftests/kvm/lib/x86_64/handlers.S | 83 ++++ .../selftests/kvm/lib/x86_64/processor.c | 168 ++++++- .../testing/selftests/kvm/lib/x86_64/ucall.c | 3 + .../selftests/kvm/x86_64/userspace_msr_exit.c | 421 ++++++++++++++++++ 20 files changed, 1129 insertions(+), 94 deletions(-) create mode 100644 tools/testing/selftests/kvm/lib/x86_64/handlers.S create mode 100644 tools/testing/selftests/kvm/x86_64/userspace_msr_exit.c
Signature · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 1/8 KVM: x86: Add ioctl for accepting a userspace provided MSR list
Add KVM_SET_EXIT_MSRS ioctl to allow userspace to pass in a list of MSRs that force an exit to userspace when rdmsr or wrmsr are used by the guest.
KVM_SET_EXIT_MSRS will need to be called before any vCPUs are created to protect the 'user_exit_msrs' list from being mutated while vCPUs are running.
Add KVM_CAP_SET_MSR_EXITS to identify the feature exists.
--- Documentation/virt/kvm/api.rst | 24 +++++++++++++++++++ arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/x86.c | 41 +++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 2 ++ 4 files changed, 69 insertions(+)
Documentation/virt/kvm/api.rst +24 -0
@@ -1006,6 +1006,30 @@ such as migration. :Parameters: struct kvm_vcpu_event (out) :Returns: 0 on success, -1 on error +4.32 KVM_SET_EXIT_MSRS +------------------ + +:Capability: KVM_CAP_SET_MSR_EXITS +:Architectures: x86 +:Type: vm ioctl +:Parameters: struct kvm_msr_list (in) +:Returns: 0 on success, -1 on error + +Sets the userspace MSR list which is used to track which MSRs KVM should send +to userspace to be serviced when the guest executes rdmsr or wrmsr. + +This ioctl needs to be called before vCPUs are setup otherwise the list of MSRs +will not be accepted and an EINVAL error will be returned. Also, if a list of +MSRs has already been supplied, and this ioctl is called again an EEXIST error +will be returned. + +:: + + struct kvm_msr_list { + __u32 nmsrs; + __u32 indices[0]; +}; + X86: ^^^^
arch/x86/include/asm/kvm_host.h +2 -0
@@ -1004,6 +1004,8 @@ struct kvm_arch {struct kvm_pmu_event_filter *pmu_event_filter;struct task_struct *nx_lpage_recovery_thread; + +struct kvm_msr_list *user_exit_msrs; };struct kvm_vm_stat {
arch/x86/kvm/x86.c +41 -0
59 lines not on this page · raw message
include/uapi/linux/kvm.h +2 -0
@@ -1031,6 +1031,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_SET_MSR_EXITS 185#ifdef KVM_CAP_IRQ_ROUTING
@@ -1371,6 +1372,7 @@ struct kvm_s390_ucas_mapping {/* Available with KVM_CAP_PMU_EVENT_FILTER */ #define KVM_SET_PMU_EVENT_FILTER _IOW(KVMIO, 0xb2, struct kvm_pmu_event_filter)#define KVM_PPC_SVM_OFF _IO(KVMIO, 0xb3) +#define KVM_SET_EXIT_MSRS _IOW(KVMIO, 0xb4, struct kvm_msr_list)/* ioctl for vm fd */ #define KVM_CREATE_DEVICE _IOWR(KVMIO, 0xe0, struct kvm_create_device)
Signature · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 2/8 KVM: x86: Add support for exiting to userspace on rdmsr or wrmsr
In reply to Aaron LewisAdd support for exiting to userspace on a rdmsr or wrmsr instruction if the MSR being read from or written to is in the user_exit_msrs list.
--- Documentation/virt/kvm/api.rst | 29 +++++++++++- arch/x86/kvm/trace.h | 24 ++++++++++ arch/x86/kvm/x86.c | 83 ++++++++++++++++++++++++++++++++++ include/trace/events/kvm.h | 2 +- include/uapi/linux/kvm.h | 10 ++++ 5 files changed, 145 insertions(+), 3 deletions(-)
Documentation/virt/kvm/api.rst +27 -2
@@ -4885,8 +4885,9 @@ 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
@@ -5179,6 +5180,30 @@ 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 inject_gp; + __u8 pad[3]; + __u32 index; + __u64 data; + } msr; + +If the exit_reason is KVM_EXIT_X86_RDMSR then a rdmsr instruction in the guest +needs to be processed by userspace. If the exit_reason is KVM_EXIT_X86_WRMSR +then a wrmsr instruction in the guest needs to be processed by userspace. + +Userspace can tell KVM to inject a #GP into the guest by setting the +'inject_gp' flag. Setting the flag to 1 tells KVM to inject a GP into the +guest. Setting the flag to 0 tells KVM to not inject a GP into the guest. + +The MSR being processed is indicated by 'index'. If a read is being processed +the 'data' field is expected to be filled out by userspace (as an out +parameter). If a write is being processed the 'data' field will contain the +updated value of the MSR (as an in parameter). + :: /* Fix the size of the union. */
arch/x86/kvm/trace.h +24 -0
@@ -367,6 +367,30 @@ TRACE_EVENT(kvm_msr,#define trace_kvm_msr_read_ex (ecx) trace_kvm_msr(0, ecx, 0, true)#define trace_kvm_msr_write_ex (ecx, data) trace_kvm_msr(1, ecx, data, true) +TRACE_EVENT (kvm_userspace_msr, + TP_PROTO(bool is_write, u8 inject_gp, u32 index, u64 data), +TP_ARGS (is_write, inject_gp, index, data), + +TP_STRUCT__entry ( + __field(bool, is_write) + __field(u8, inject_gp) + __field(u32, index) +__field (u64, data) + ), + +TP_fast_assign ( + __entry->is_write = is_write; + __entry->inject_gp = inject_gp; + __entry->index = index; + __entry->data = data; + ), + +TP_printk ("userspace %s %x = 0x%llx, %s" , + __entry->is_write ?"wrmsr" :"rdmsr" , + __entry->index, __entry->data, + __entry->inject_gp ?"inject_gp" :"no_gp" ) +); +/* * Tracepoint for guest CR access. */
arch/x86/kvm/x86.c +83 -0
115 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(X86_RDMSR), ERSN(X86_WRMSR) TRACE_EVENT(kvm_userspace_exit, TP_PROTO(__u32 reason, int errno),
include/uapi/linux/kvm.h +10 -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,14 @@ struct kvm_run {__u64 esr_iss;__u64 fault_ipa; } arm_nisv; +/* KVM_EXIT_X86_RDMSR */ +/* KVM_EXIT_X86_WRMSR */ +struct { +__u8 inject_gp; +__u8 pad[3 ]; +__u32 index; +__u64 data; + } msr;/* Fix the size of the union. */ char padding[256 ]; };
Signature · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 3/8 KVM: x86: Allow em_{rdmsr,wrmsr} to bounce to userspace
In reply to Aaron LewisRefactor em_{rdmsr,wrmsr} to allow an MSR to bounce to userspace when it exists in the list of MSRs userspace has requested to manage with the ioctl KVM_SET_EXIT_MSRS.
--- arch/x86/kvm/emulate.c | 18 +++++++++-- arch/x86/kvm/x86.c | 70 ++++++++++++++++++++++++++++++------------ 2 files changed, 66 insertions(+), 22 deletions(-)
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 +50 -20
100 lines not on this page · raw message
Signature · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 4/8 KVM: x86: Prepare MSR bitmaps for userspace tracked MSRs
In reply to Aaron LewisPrepare vmx and svm for a subsequent change that ensures the MSR bitmap allows for a vm_exit for all MSRs that userspace is tracking.
--- 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 · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 5/8 KVM: x86: Ensure the MSR bitmap never clears userspace tracked MSRs
In reply to Aaron LewisSDM volume 3: 24.6.9 "MSR-Bitmap Address" and APM volume 2: 15.11 "MS intercepts" describe MSR permission bitmaps. Permission bitmaps are used to control whether an execution of rdmsr or wrmsr will cause a vm exit. For userspace tracked MSRs it is required they cause a vm exit, so the host is able to forward the MSR to userspace. This change adds vmx/svm support to ensure the permission bitmap is properly set to cause a vm_exit to the host when rdmsr or wrmsr is used by one of the userspace tracked MSRs. Also, to avoid repeatedly setting them, kvm_make_request() is used to coalesce these into a single call.
--- arch/x86/include/asm/kvm_host.h | 3 ++ arch/x86/kvm/svm/svm.c | 49 ++++++++++++++++++++++++++------- arch/x86/kvm/vmx/vmx.c | 13 ++++++++- arch/x86/kvm/x86.c | 16 +++++++++++ 4 files changed, 70 insertions(+), 11 deletions(-)
arch/x86/include/asm/kvm_host.h +3 -0
@@ -87,6 +87,7 @@#define KVM_REQ_HV_TLB_FLUSH \ KVM_ARCH_REQ_FLAGS(27, KVM_REQUEST_NO_WAKEUP)#define KVM_REQ_APF_READY KVM_ARCH_REQ(28) +#define KVM_REQ_USER_MSR_UPDATE KVM_ARCH_REQ(29)#define CR0_RESERVED_BITS \ (~(unsigned long)(X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS \
@@ -1271,6 +1272,8 @@ struct kvm_x86_ops {int (*enable_direct_tlbflush)(struct kvm_vcpu *vcpu);void (*migrate_timers)(struct kvm_vcpu *vcpu); + +void (*set_user_msr_intercept)(struct kvm_vcpu *vcpu,u32 msr); };struct kvm_x86_nested_ops {
arch/x86/kvm/svm/svm.c +39 -10
75 lines not on this page · raw message
arch/x86/kvm/vmx/vmx.c +12 -1
@@ -3728,6 +3728,10 @@ static __always_inline void vmx_disable_intercept_for_msr(struct kvm_vcpu *vcpu,__clear_bit (msr, msr_bitmap +0xc00 / f); } + +if (type &MSR_TYPE_R || type &MSR_TYPE_W ) { +kvm_make_request (KVM_REQ_USER_MSR_UPDATE , vcpu); + } } static __always_inline void vmx_enable_intercept_for_msr(struct kvm_vcpu *vcpu,
@@ -3795,7 +3799,7 @@ static u8 vmx_msr_bitmap_mode(struct kvm_vcpu *vcpu) }static void vmx_update_msr_bitmap_x2apic (struct kvm_vcpu *vcpu, -unsigned long *msr_bitmap,u8 mode) +unsigned long *msr_bitmap,u8 mode) {int msr;
@@ -3819,6 +3823,11 @@ static void vmx_update_msr_bitmap_x2apic(struct kvm_vcpu *vcpu, } } +void vmx_set_user_msr_intercept (struct kvm_vcpu *vcpu,u32 msr) +{ +vmx_enable_intercept_for_msr (vcpu, msr,MSR_TYPE_RW ); +} +void vmx_update_msr_bitmap (struct kvm_vcpu *vcpu) {struct vcpu_vmx *vmx =to_vmx (vcpu);
@@ -7965,6 +7974,8 @@ static struct kvm_x86_ops vmx_x86_ops __initdata = { .need_emulation_on_page_fault = vmx_need_emulation_on_page_fault, .apic_init_signal_blocked = vmx_apic_init_signal_blocked, .migrate_timers = vmx_migrate_timers, + + .set_user_msr_intercept = vmx_set_user_msr_intercept, };static __init int hardware_setup (void )
arch/x86/kvm/x86.c +16 -0
@@ -3555,6 +3555,19 @@ bool kvm_msr_user_exit(struct kvm *kvm, u32 index) }EXPORT_SYMBOL_GPL (kvm_msr_user_exit); +static void kvm_set_user_msr_intercepts (struct kvm_vcpu *vcpu) +{ +struct kvm_msr_list *msr_list = vcpu->kvm->arch.user_exit_msrs; +u32 i, msr; + +if (msr_list) { +for (i =0 ; i < msr_list->nmsrs; i++) { + msr = msr_list->indices[i]; + kvm_x86_ops.set_user_msr_intercept (vcpu, msr); + } + } +} +int kvm_vm_ioctl_check_extension (struct kvm *kvm,long ext) {int r =0 ;
@@ -8583,6 +8596,9 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)kvm_vcpu_update_apicv (vcpu);if (kvm_check_request (KVM_REQ_APF_READY , vcpu))kvm_check_async_pf_completion (vcpu); + +if (kvm_check_request (KVM_REQ_USER_MSR_UPDATE , vcpu)) +kvm_set_user_msr_intercepts (vcpu); }if (kvm_check_request (KVM_REQ_EVENT , vcpu) || req_int_win) {
Signature · 1 line
2.28.0.236.gb10cc79966-goog
kernel test robot
build botRe: [PATCH v2 5/8] KVM: x86: Ensure the MSR bitmap never clears userspace tracked MSRs
Thank you for the patch! Perhaps something to improve:
Hi Aaron,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on v5.8]
[cannot apply to kvm/linux-next next-20200810]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Aaron-Lewis/Allow-userspace-to-manage-MSRs/20200811-041443 base: bcf876870b95592b52519ed4aafcf9d95999bc9c config: x86_64-randconfig-a003-20200810 (attached as .config) compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project 3a34228bff6fdf45b50cb57cf5fb85d659eeb672)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
>> arch/x86/kvm/vmx/vmx.c:3826:6: warning: no previous prototype for function 'vmx_set_user_msr_intercept' [-Wmissing-prototypes]
void vmx_set_user_msr_intercept(struct kvm_vcpu *vcpu, u32 msr)
^ arch/x86/kvm/vmx/vmx.c:3826:1: note: declare 'static' if the function is not intended to be used outside of this translation unit void vmx_set_user_msr_intercept(struct kvm_vcpu *vcpu, u32 msr)
^
static
1 warning generated.
--
>> arch/x86/kvm/svm/svm.c:636:6: warning: no previous prototype for function 'svm_set_user_msr_intercept' [-Wmissing-prototypes]
void svm_set_user_msr_intercept(struct kvm_vcpu *vcpu, u32 msr)
^ arch/x86/kvm/svm/svm.c:636:1: note: declare 'static' if the function is not intended to be used outside of this translation unit void svm_set_user_msr_intercept(struct kvm_vcpu *vcpu, u32 msr)
^
static
1 warning generated.
vim +/vmx_set_user_msr_intercept +3826 arch/x86/kvm/vmx/vmx.c
3825
> 3826 void vmx_set_user_msr_intercept(struct kvm_vcpu *vcpu, u32 msr)
3827 {
3828 vmx_enable_intercept_for_msr(vcpu, msr, MSR_TYPE_RW);
3829 }
3830
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
PATCH v2 6/8 selftests: kvm: Fix the segment descriptor layout to match the actual layout
In reply to Aaron LewisFix the layout of 'struct desc64' to match the layout described in the SDM Vol 3, 3.4.5 Segment Descriptors, Figure 3-8. The test added later in this series relies on this and crashes if this layout is not correct.
--- tools/testing/selftests/kvm/include/x86_64/processor.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/testing/selftests/kvm/include/x86_64/processor.h +1 -1
@@ -59,7 +59,7 @@ struct gpr64_regs {struct desc64 {uint16_t limit0;uint16_t base0; -unsigned base1:8 , s:1 , type:4 , dpl:2 , p:1 ; +unsigned base1:8 , type:4 , s:1 , dpl:2 , p:1 ;unsigned limit1:4 , avl:1 , l:1 , db:1 , g:1 , base2:8 ;uint32_t base3;uint32_t zero1;
Signature · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 7/8 selftests: kvm: Add test to exercise userspace MSR list
In reply to Aaron LewisAdd a selftest to test that when ioctl KVM_SET_EXIT_MSRS is called with an MSR list the guest exits to the host and then to userspace when an MSR in that list is read from or written to.
This test uses 3 MSRs to test these new features:
1. MSR_IA32_XSS, an MSR the kernel knows about.
2. MSR_IA32_FLUSH_CMD, an MSR the kernel does not know about.
3. MSR_NON_EXISTENT, an MSR invented in this test for the purposes of passing a fake MSR from the guest to userspace and having the guest be able to read from and write to it, with userspace handling it. KVM just acts as a pass through.
Userspace is also able to inject a #GP. This is demonstrated when MSR_IA32_XSS and MSR_IA32_FLUSH_CMD are misused in the test. When this happens a #GP is initiated in userspace to be thrown in the guest. To be able to handle this, exception handling was added to selftests, and a to inject a #GP and be able to handle it gracefully.
--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 20 +- .../selftests/kvm/include/x86_64/processor.h | 27 ++ tools/testing/selftests/kvm/lib/kvm_util.c | 17 ++ .../selftests/kvm/lib/kvm_util_internal.h | 2 + .../selftests/kvm/lib/x86_64/handlers.S | 83 ++++++ .../selftests/kvm/lib/x86_64/processor.c | 168 ++++++++++- .../testing/selftests/kvm/lib/x86_64/ucall.c | 3 + .../selftests/kvm/x86_64/userspace_msr_exit.c | 279 ++++++++++++++++++ 9 files changed, 590 insertions(+), 10 deletions(-) create mode 100644 tools/testing/selftests/kvm/lib/x86_64/handlers.S create mode 100644 tools/testing/selftests/kvm/x86_64/userspace_msr_exit.c
tools/testing/selftests/kvm/.gitignore +1 -0
@@ -14,6 +14,7 @@ /x86_64/vmx_preemption_timer_test /x86_64/svm_vmcall_test /x86_64/sync_regs_test +/x86_64/userspace_msr_exit /x86_64/vmx_close_while_nested_test /x86_64/vmx_dirty_log_test /x86_64/vmx_set_nested_state_test
tools/testing/selftests/kvm/Makefile +14 -6
@@ -34,7 +34,7 @@ ifeq ($(ARCH),s390) endif LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/sparsebit.c lib/test_util.c -LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c +LIBKVM_x86_64 = lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c
@@ -49,6 +49,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/state_test TEST_GEN_PROGS_x86_64 += x86_64/vmx_preemption_timer_test TEST_GEN_PROGS_x86_64 += x86_64/svm_vmcall_test TEST_GEN_PROGS_x86_64 += x86_64/sync_regs_test +TEST_GEN_PROGS_x86_64 += x86_64/userspace_msr_exit TEST_GEN_PROGS_x86_64 += x86_64/vmx_close_while_nested_test TEST_GEN_PROGS_x86_64 += x86_64/vmx_dirty_log_test TEST_GEN_PROGS_x86_64 += x86_64/vmx_set_nested_state_test
@@ -108,14 +109,21 @@ LDFLAGS += -pthread $(no-pie-option) $(pgste-option) include ../lib.mk STATIC_LIBS := $(OUTPUT)/libkvm.a -LIBKVM_OBJ := $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM)) -EXTRA_CLEAN += $(LIBKVM_OBJ) $(STATIC_LIBS) cscope.* +LIBKVM_C := $(filter %.c,$(LIBKVM)) +LIBKVM_S := $(filter %.S,$(LIBKVM)) +LIBKVM_C_OBJ := $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM_C)) +LIBKVM_S_OBJ := $(patsubst %.S, $(OUTPUT)/%.o, $(LIBKVM_S)) +EXTRA_CLEAN += $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) $(STATIC_LIBS) cscope.* + +x := $(shell mkdir -p $(sort $(dir $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ)))) +$(LIBKVM_C_OBJ): $(OUTPUT)/%.o: %.c + $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@ -x := $(shell mkdir -p $(sort $(dir $(LIBKVM_OBJ)))) -$(LIBKVM_OBJ): $(OUTPUT)/%.o: %.c +$(LIBKVM_S_OBJ): $(OUTPUT)/%.o: %.S $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@ -$(OUTPUT)/libkvm.a: $(LIBKVM_OBJ) +LIBKVM_OBJS = $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) +$(OUTPUT)/libkvm.a: $(LIBKVM_OBJS) $(AR) crs $@ $^ x := $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS))))
tools/testing/selftests/kvm/include/x86_64/processor.h +27 -0
@@ -36,6 +36,8 @@#define X86_CR4_SMAP (1ul << 21)#define X86_CR4_PKE (1ul << 22) +#define UNEXPECTED_VECTOR_PORT 0xfff0u +/* General Registers in 64-Bit Mode */ struct gpr64_regs {u64 rax;
@@ -239,6 +241,11 @@ static inline struct desc_ptr get_idt(void)return idt; } +static inline void outl (uint16_t port,uint32_t value) +{ + __asm__ __volatile__("outl %%eax, %%dx" : :"d" (port),"a" (value)); +} +#define SET_XMM (__var, __xmm) \ asm volatile("movq %0, %%"#__xmm : : "r"(__var) : #__xmm)
@@ -334,10 +341,30 @@ int _vcpu_set_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index,void vcpu_set_msr (struct kvm_vm *vm,uint32_t vcpuid,uint64_t msr_index,uint64_t msr_value); +void kvm_set_exit_msrs (struct kvm_vm *vm,uint32_t nmsrs, +uint32_t msr_indices[]); +uint32_t kvm_get_cpuid_max_basic (void );uint32_t kvm_get_cpuid_max_extended (void );void kvm_get_cpu_address_width (unsigned int *pa_bits,unsigned int *va_bits); +struct ex_regs { +uint64_t rax, rcx, rdx, rbx; +uint64_t dummy, rbp, rsi, rdi; +uint64_t r8, r9, r10, r11; +uint64_t r12, r13, r14, r15; +uint64_t vector; +uint64_t error_code; +uint64_t rip; +uint64_t cs; +uint64_t rflags; +}; + +void vm_init_descriptor_tables (struct kvm_vm *vm); +void vcpu_init_descriptor_tables (struct kvm_vm *vm,uint32_t vcpuid); +void vm_handle_exception (struct kvm_vm *vm,int vector, +void (*handler)(struct ex_regs *)); +/* * Basic CPU control in CR0 */
tools/testing/selftests/kvm/lib/kvm_util.c +17 -0
@@ -1195,6 +1195,21 @@ int _vcpu_run(struct kvm_vm *vm, uint32_t vcpuid)do { rc =ioctl (vcpu->fd,KVM_RUN ,NULL ); }while (rc ==-1 && errno ==EINTR ); + +#ifdef __x86_64__ +if (vcpu_state (vm, vcpuid)->exit_reason ==KVM_EXIT_IO + &&vcpu_state (vm, vcpuid)->io.port ==UNEXPECTED_VECTOR_PORT + &&vcpu_state (vm, vcpuid)->io.size ==4 ) { +/* Grab pointer to io data */ +uint32_t *data = (void *)vcpu_state (vm, vcpuid) + +vcpu_state (vm, vcpuid)->io.data_offset; + +TEST_ASSERT (false, +"Unexpected vectored event in guest (vector:0x%x)" , + *data); + } +#endif +return rc; }
@@ -1590,6 +1605,8 @@ static struct exit_reason { {KVM_EXIT_INTERNAL_ERROR, "INTERNAL_ERROR"}, {KVM_EXIT_OSI, "OSI"}, {KVM_EXIT_PAPR_HCALL, "PAPR_HCALL"}, + {KVM_EXIT_X86_RDMSR, "RDMSR"}, + {KVM_EXIT_X86_WRMSR, "WRMSR"}, #ifdef KVM_EXIT_MEMORY_NOT_PRESENT {KVM_EXIT_MEMORY_NOT_PRESENT, "MEMORY_NOT_PRESENT"}, #endif
tools/testing/selftests/kvm/lib/kvm_util_internal.h +2 -0
@@ -50,6 +50,8 @@ struct kvm_vm {vm_paddr_t pgd;vm_vaddr_t gdt;vm_vaddr_t tss; +vm_vaddr_t idt; +vm_vaddr_t handlers; };struct vcpu *vcpu_find (struct kvm_vm *vm,uint32_t vcpuid);
tools/testing/selftests/kvm/lib/x86_64/handlers.S new file +83 -0
83 lines not on this page · raw message
tools/testing/selftests/kvm/lib/x86_64/processor.c +164 -4
199 lines not on this page · raw message
tools/testing/selftests/kvm/lib/x86_64/ucall.c +3 -0
@@ -40,6 +40,9 @@ uint64_t get_ucall(struct kvm_vm *vm, uint32_t vcpu_id, struct ucall *uc)struct kvm_run *run =vcpu_state (vm, vcpu_id);struct ucall ucall = {}; +if (uc) +memset (uc,0 ,sizeof (*uc)); +if (run->exit_reason ==KVM_EXIT_IO && run->io.port ==UCALL_PIO_PORT ) {struct kvm_regs regs;
tools/testing/selftests/kvm/x86_64/userspace_msr_exit.c new file +279 -0
279 lines not on this page · raw message
Signature · 1 line
2.28.0.236.gb10cc79966-goog
PATCH v2 8/8 selftests: kvm: Add emulated rdmsr, wrmsr tests
In reply to Aaron LewisAdd tests to exercise the code paths for em_{rdmsr,wrmsr} and emulator_{get,set}_msr. For the generic instruction emulator to work the module parameter kvm.force_emulation_prefix=1 has to be enabled. If it isn't the tests will be skipped.
--- .../selftests/kvm/x86_64/userspace_msr_exit.c | 158 +++++++++++++++++- 1 file changed, 150 insertions(+), 8 deletions(-)
tools/testing/selftests/kvm/x86_64/userspace_msr_exit.c +150 -8
@@ -12,8 +12,12 @@#include "kvm_util.h" #include "vmx.h" -#define VCPU_ID 1 +/* Forced emulation prefix, used to invoke the emulator unconditionally. */ +#define KVM_FEP "ud2; .byte 'k', 'v', 'm';" +#define KVM_FEP_LENGTH 5 +static int fep_available =1 ; +#define VCPU_ID 1#define MSR_NON_EXISTENT 0x474f4f00uint32_t msrs[] = {
@@ -63,6 +67,39 @@ static noinline void test_wrmsr(uint32_t msr, uint64_t value)extern char rdmsr_start, rdmsr_end;extern char wrmsr_start, wrmsr_end; +/* +* Note: Force test_em_rdmsr() to not be inlined to prevent the labels, +* rdmsr_start and rdmsr_end, from being defined multiple times. +*/ +static noinline uint64_t test_em_rdmsr(uint32_t msr) +{ +uint32_t a, d; + + guest_exception_count =0 ; + + __asm__ __volatile__(KVM_FEP "em_rdmsr_start: rdmsr; em_rdmsr_end:" : +"=a" (a),"=d" (d) :"c" (msr) :"memory" ); + +return a | ((uint64_t ) d <<32 ); +} + +/* +* Note: Force test_em_wrmsr() to not be inlined to prevent the labels, +* wrmsr_start and wrmsr_end, from being defined multiple times. +*/ +static noinline void test_em_wrmsr(uint32_t msr, uint64_t value) +{ +uint32_t a = value; +uint32_t d = value >>32 ; + + guest_exception_count =0 ; + + __asm__ __volatile__(KVM_FEP "em_wrmsr_start: wrmsr; em_wrmsr_end:" :: +"a" (a),"d" (d),"c" (msr) :"memory" ); +} + +extern char em_rdmsr_start, em_rdmsr_end; +extern char em_wrmsr_start, em_wrmsr_end;static void guest_code (void ) {
@@ -112,17 +149,55 @@ static void guest_code(void)GUEST_ASSERT (data ==2 );GUEST_ASSERT (guest_exception_count ==0 ); +/* +* Test to see if the instruction emulator is available (ie: the module +* parameter 'kvm.force_emulation_prefix=1' is set). This instruction +* will #UD if it isn't available. +*/ + __asm__ __volatile__(KVM_FEP "nop" ); + +if (fep_available) { +/* Let userspace know we aren't done. */ +GUEST_SYNC (0 ); + +/* +* Now run the same tests with the instruction emulator. +*/ + data =test_em_rdmsr (MSR_IA32_XSS ); +GUEST_ASSERT (data ==0 ); +GUEST_ASSERT (guest_exception_count ==0 ); +test_em_wrmsr (MSR_IA32_XSS ,0 ); +GUEST_ASSERT (guest_exception_count ==0 ); +test_em_wrmsr (MSR_IA32_XSS ,1 ); +GUEST_ASSERT (guest_exception_count ==1 ); + +test_em_rdmsr (MSR_IA32_FLUSH_CMD ); +GUEST_ASSERT (guest_exception_count ==1 ); +test_em_wrmsr (MSR_IA32_FLUSH_CMD ,0 ); +GUEST_ASSERT (guest_exception_count ==1 ); +test_em_wrmsr (MSR_IA32_FLUSH_CMD ,1 ); +GUEST_ASSERT (guest_exception_count ==0 ); + +test_em_wrmsr (MSR_NON_EXISTENT ,2 ); +GUEST_ASSERT (guest_exception_count ==0 ); + data =test_em_rdmsr (MSR_NON_EXISTENT ); +GUEST_ASSERT (data ==2 ); +GUEST_ASSERT (guest_exception_count ==0 ); + } +GUEST_DONE (); } -static void guest_gp_handler (struct ex_regs *regs) +static void __guest_gp_handler (struct ex_regs *regs, +char *r_start,char *r_end, +char *w_start,char *w_end) { -if (regs->rip == (uintptr_t )&rdmsr_start) { - regs->rip = (uintptr_t )&rdmsr_end; +if (regs->rip == (uintptr_t )r_start) { + regs->rip = (uintptr_t )r_end; regs->rax =0 ; regs->rdx =0 ; - }else if (regs->rip == (uintptr_t )&wrmsr_start) { - regs->rip = (uintptr_t )&wrmsr_end; + }else if (regs->rip == (uintptr_t )w_start) { + regs->rip = (uintptr_t )w_end; }else {GUEST_ASSERT (!"RIP is at an unknown location!" ); }
@@ -130,6 +205,24 @@ static void guest_gp_handler(struct ex_regs *regs) ++guest_exception_count; } +static void guest_gp_handler (struct ex_regs *regs) +{ +__guest_gp_handler (regs, &rdmsr_start, &rdmsr_end, + &wrmsr_start, &wrmsr_end); +} + +static void guest_fep_gp_handler (struct ex_regs *regs) +{ +__guest_gp_handler (regs, &em_rdmsr_start, &em_rdmsr_end, + &em_wrmsr_start, &em_wrmsr_end); +} + +static void guest_ud_handler (struct ex_regs *regs) +{ + fep_available =0 ; + regs->rip +=KVM_FEP_LENGTH ; +} +static void run_guest (struct kvm_vm *vm) {int rc;
@@ -225,6 +318,32 @@ static void process_ucall_done(struct kvm_vm *vm) uc.cmd, UCALL_DONE); } +static uint64_t process_ucall (struct kvm_vm *vm) +{ +struct kvm_run *run =vcpu_state (vm,VCPU_ID ); +struct ucall uc = {}; + +TEST_ASSERT (run->exit_reason ==KVM_EXIT_IO , +"Unexpected exit reason: %u (%s)" , + run->exit_reason, +exit_reason_str (run->exit_reason)); + +switch (get_ucall (vm,VCPU_ID , &uc)) { +case UCALL_SYNC : +break ; +case UCALL_ABORT : +check_for_guest_assert (vm); +break ; +case UCALL_DONE : +process_ucall_done (vm); +break ; +default : +TEST_ASSERT (false,"Unexpected ucall" ); + } + +return uc.cmd; +} +static void run_guest_then_process_rdmsr (struct kvm_vm *vm,uint32_t msr_index) {run_guest (vm);
@@ -260,7 +379,7 @@ int main(int argc, char *argv[])vm_handle_exception (vm,GP_VECTOR , guest_gp_handler); -/* Process guest code userspace exits */ +/* Process guest code userspace exits. */ run_guest_then_process_rdmsr (vm,MSR_IA32_XSS );run_guest_then_process_wrmsr (vm,MSR_IA32_XSS );run_guest_then_process_wrmsr (vm,MSR_IA32_XSS );
@@ -272,7 +391,30 @@ int main(int argc, char *argv[])run_guest_then_process_wrmsr (vm,MSR_NON_EXISTENT );run_guest_then_process_rdmsr (vm,MSR_NON_EXISTENT ); -run_guest_then_process_ucall_done (vm); +vm_handle_exception (vm,UD_VECTOR , guest_ud_handler); +run_guest (vm); +vm_handle_exception (vm,UD_VECTOR ,NULL ); + +if (process_ucall (vm) !=UCALL_DONE ) { +vm_handle_exception (vm,GP_VECTOR , guest_fep_gp_handler); + +/* Process emulated rdmsr and wrmsr instructions. */ +run_guest_then_process_rdmsr (vm,MSR_IA32_XSS ); +run_guest_then_process_wrmsr (vm,MSR_IA32_XSS ); +run_guest_then_process_wrmsr (vm,MSR_IA32_XSS ); + +run_guest_then_process_rdmsr (vm,MSR_IA32_FLUSH_CMD ); +run_guest_then_process_wrmsr (vm,MSR_IA32_FLUSH_CMD ); +run_guest_then_process_wrmsr (vm,MSR_IA32_FLUSH_CMD ); + +run_guest_then_process_wrmsr (vm,MSR_NON_EXISTENT ); +run_guest_then_process_rdmsr (vm,MSR_NON_EXISTENT ); + +/* Confirm the guest completed without issues. */ +run_guest_then_process_ucall_done (vm); + }else { +printf ("To run the instruction emulated tests set the module parameter 'kvm.force_emulation_prefix=1'\n" ); + }kvm_vm_free (vm);return 0 ;
Signature · 1 line
2.28.0.236.gb10cc79966-goog