SMM emulation and interrupt shadow fixes
v4 cover SMM emulation and interrupt shadow fixes
This patch series is a result of long debug work to find out why sometimes guests with win11 secure boot
were failing during boot.
During writing a unit test I found another bug, turns out that on rsm emulation, if the rsm instruction was done in real or 32 bit mode, KVM would truncate the restored RIP to 32 bit.
I also refactored the way we write SMRAM so it is easier now to understand what is going on.
The main bug in this series which I fixed is that we allowed #SMI to happen during the STI interrupt shadow, and we did nothing to both reset it on #SMI handler entry and restore it on RSM.
V4:
- rebased on top of patch series from Paolo which allows smm support to be disabled by Kconfig option.
- addressed review feedback.
I included these patches in the series for reference.
Best regards,
Maxim Levitsky
Maxim Levitsky (15):
bug: introduce ASSERT_STRUCT_OFFSET
KVM: x86: emulator: em_sysexit should update ctxt->mode
KVM: x86: emulator: introduce emulator_recalc_and_set_mode
KVM: x86: emulator: update the emulation mode after rsm
KVM: x86: emulator: update the emulation mode after CR0 write
KVM: x86: smm: number of GPRs in the SMRAM image depends on the image
format
KVM: x86: smm: check for failures on smm entry
KVM: x86: smm: add structs for KVM's smram layout
KVM: x86: smm: use smram structs in the common code
KVM: x86: smm: use smram struct for 32 bit smram load/restore
KVM: x86: smm: use smram struct for 64 bit smram load/restore
KVM: svm: drop explicit return value of kvm_vcpu_map
KVM: x86: SVM: use smram structs
KVM: x86: SVM: don't save SVM state to SMRAM when VM is not long mode
capable
KVM: x86: smm: preserve interrupt shadow in SMRAM
Paolo Bonzini (8):
KVM: x86: start moving SMM-related functions to new files
KVM: x86: move SMM entry to a new file
KVM: x86: move SMM exit to a new file
KVM: x86: do not go through ctxt->ops when emulating rsm
KVM: allow compiling out SMM support
KVM: x86: compile out vendor-specific code if SMM is disabled
KVM: x86: remove SMRAM address space if SMM is not supported
KVM: x86: do not define KVM_REQ_SMI if SMM disabled
arch/x86/include/asm/kvm-x86-ops.h | 2 + arch/x86/include/asm/kvm_host.h | 29 +- arch/x86/kvm/Kconfig | 11 + arch/x86/kvm/Makefile | 1 + arch/x86/kvm/emulate.c | 458 +++---------- arch/x86/kvm/kvm_cache_regs.h | 5 - arch/x86/kvm/kvm_emulate.h | 47 +- arch/x86/kvm/lapic.c | 14 +- arch/x86/kvm/lapic.h | 7 +- arch/x86/kvm/mmu/mmu.c | 1 + arch/x86/kvm/smm.c | 637 ++++++++++++++++++ arch/x86/kvm/smm.h | 160 +++++ arch/x86/kvm/svm/nested.c | 3 + arch/x86/kvm/svm/svm.c | 43 +- arch/x86/kvm/vmx/nested.c | 1 + arch/x86/kvm/vmx/vmcs12.h | 5 +- arch/x86/kvm/vmx/vmx.c | 11 +- arch/x86/kvm/x86.c | 353 +--------- include/linux/build_bug.h | 9 + tools/testing/selftests/kvm/x86_64/smm_test.c | 2 + 20 files changed, 1031 insertions(+), 768 deletions(-) create mode 100644 arch/x86/kvm/smm.c create mode 100644 arch/x86/kvm/smm.h
Signature · 1 line
2.34.3
PATCH v4 1/23 KVM: x86: start moving SMM-related functions to new files
From: Paolo Bonzini <[email protected]>
Create a new header and source with code related to system management mode emulation. Entry and exit will move there too; for now, opportunistically rename put_smstate to PUT_SMSTATE while moving it to smm.h, and adjust the SMM state saving code.
--- arch/x86/include/asm/kvm_host.h | 6 -- arch/x86/kvm/Makefile | 1 + arch/x86/kvm/emulate.c | 1 + arch/x86/kvm/kvm_cache_regs.h | 5 -- arch/x86/kvm/lapic.c | 14 ++- arch/x86/kvm/lapic.h | 7 +- arch/x86/kvm/mmu/mmu.c | 1 + arch/x86/kvm/smm.c | 37 ++++++++ arch/x86/kvm/smm.h | 25 ++++++ arch/x86/kvm/svm/nested.c | 1 + arch/x86/kvm/svm/svm.c | 5 +- arch/x86/kvm/vmx/nested.c | 1 + arch/x86/kvm/vmx/vmx.c | 1 + arch/x86/kvm/x86.c | 148 ++++++++++++-------------------- 14 files changed, 138 insertions(+), 115 deletions(-) create mode 100644 arch/x86/kvm/smm.c create mode 100644 arch/x86/kvm/smm.h
arch/x86/include/asm/kvm_host.h +0 -6
@@ -2084,12 +2084,6 @@ static inline int kvm_cpu_get_apicid(int mps_cpu)#endif } -#define put_smstate (type, buf, offset, val) \ - *(type *)((buf) + (offset) - 0x7e00) = val - -#define GET_SMSTATE (type, buf, offset) \ - (*(type *)((buf) + (offset) - 0x7e00)) -int kvm_cpu_dirty_log_size (void );int memslot_rmap_alloc (struct kvm_memory_slot *slot,unsigned long npages);
arch/x86/kvm/Makefile +1 -0
@@ -20,6 +20,7 @@ endif kvm-$(CONFIG_X86_64) += mmu/tdp_iter.o mmu/tdp_mmu.o kvm-$(CONFIG_KVM_XEN) += xen.o +kvm-y += smm.o kvm-intel-y += vmx/vmx.o vmx/vmenter.o vmx/pmu_intel.o vmx/vmcs12.o \ vmx/evmcs.o vmx/nested.o vmx/posted_intr.o
arch/x86/kvm/emulate.c +1 -0
@@ -30,6 +30,7 @@#include "tss.h" #include "mmu.h" #include "pmu.h" +#include "smm.h" /* * Operand types
arch/x86/kvm/kvm_cache_regs.h +0 -5
@@ -200,9 +200,4 @@ static inline bool is_guest_mode(struct kvm_vcpu *vcpu) return vcpu->arch.hflags & HF_GUEST_MASK; } -static inline bool is_smm (struct kvm_vcpu *vcpu) -{ -return vcpu->arch.hflags &HF_SMM_MASK ; -} -#endif
arch/x86/kvm/lapic.c +11 -3
@@ -42,6 +42,7 @@#include "x86.h" #include "cpuid.h" #include "hyperv.h" +#include "smm.h" #ifndef CONFIG_X86_64 #define mod_64 (x, y) ((x) - (y) * div64_u64(x, y))
@@ -1170,9 +1171,10 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,break ;case APIC_DM_SMI : - result =1 ; -kvm_make_request (KVM_REQ_SMI , vcpu); -kvm_vcpu_kick (vcpu); +if (!kvm_inject_smi (vcpu)) { +kvm_vcpu_kick (vcpu); + result =1 ; + }break ;case APIC_DM_NMI :
@@ -3020,6 +3022,12 @@ int kvm_lapic_set_pv_eoi(struct kvm_vcpu *vcpu, u64 data, unsigned long len)return 0 ; } +bool kvm_apic_init_sipi_allowed (struct kvm_vcpu *vcpu) +{ +return !is_smm (vcpu) && + !static_call (kvm_x86_apic_init_signal_blocked)(vcpu); +} +int kvm_apic_accept_events (struct kvm_vcpu *vcpu) {struct kvm_lapic *apic = vcpu->arch.apic;
arch/x86/kvm/lapic.h +1 -6
@@ -7,7 +7,6 @@#include <linux/kvm_host.h> #include "hyperv.h" -#include "kvm_cache_regs.h" #define KVM_APIC_INIT 0#define KVM_APIC_SIPI 1
@@ -229,11 +228,7 @@ static inline bool kvm_apic_has_pending_init_or_sipi(struct kvm_vcpu *vcpu)return lapic_in_kernel (vcpu) && vcpu->arch.apic->pending_events; } -static inline bool kvm_apic_init_sipi_allowed (struct kvm_vcpu *vcpu) -{ -return !is_smm (vcpu) && - !static_call (kvm_x86_apic_init_signal_blocked)(vcpu); -} +bool kvm_apic_init_sipi_allowed (struct kvm_vcpu *vcpu);static inline bool kvm_lowest_prio_delivery (struct kvm_lapic_irq *irq) {
arch/x86/kvm/mmu/mmu.c +1 -0
@@ -22,6 +22,7 @@#include "tdp_mmu.h" #include "x86.h" #include "kvm_cache_regs.h" +#include "smm.h" #include "kvm_emulate.h" #include "cpuid.h" #include "spte.h"
arch/x86/kvm/smm.c new file +37 -0
@@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include <linux/kvm_host.h> +#include "x86.h" +#include "kvm_cache_regs.h" +#include "kvm_emulate.h" +#include "smm.h" +#include "trace.h" + +void kvm_smm_changed (struct kvm_vcpu *vcpu,bool entering_smm) +{ +trace_kvm_smm_transition (vcpu->vcpu_id, vcpu->arch.smbase, entering_smm); + +if (entering_smm) { + vcpu->arch.hflags |=HF_SMM_MASK ; + }else { + vcpu->arch.hflags &= ~(HF_SMM_MASK |HF_SMM_INSIDE_NMI_MASK ); + +/* Process a latched INIT or SMI, if any. */ +kvm_make_request (KVM_REQ_EVENT , vcpu); + +/* +* Even if KVM_SET_SREGS2 loaded PDPTRs out of band, +* on SMM exit we still need to reload them from +* guest memory +*/ + vcpu->arch.pdptrs_from_userspace = false; + } + +kvm_mmu_reset_context (vcpu); +} + +void process_smi (struct kvm_vcpu *vcpu) +{ + vcpu->arch.smi_pending = true; +kvm_make_request (KVM_REQ_EVENT , vcpu); +}
arch/x86/kvm/smm.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef ASM_KVM_SMM_H +#define ASM_KVM_SMM_H + +#define GET_SMSTATE (type, buf, offset) \ + (*(type *)((buf) + (offset) - 0x7e00)) + +#define PUT_SMSTATE (type, buf, offset, val) \ + *(type *)((buf) + (offset) - 0x7e00) = val + +static inline int kvm_inject_smi (struct kvm_vcpu *vcpu) +{ +kvm_make_request (KVM_REQ_SMI , vcpu); +return 0 ; +} + +static inline bool is_smm (struct kvm_vcpu *vcpu) +{ +return vcpu->arch.hflags &HF_SMM_MASK ; +} + +void kvm_smm_changed (struct kvm_vcpu *vcpu,bool in_smm); +void process_smi (struct kvm_vcpu *vcpu); + +#endif
arch/x86/kvm/svm/nested.c +1 -0
@@ -25,6 +25,7 @@#include "trace.h" #include "mmu.h" #include "x86.h" +#include "smm.h" #include "cpuid.h" #include "lapic.h" #include "svm.h"
arch/x86/kvm/svm/svm.c +3 -2
@@ -6,6 +6,7 @@#include "mmu.h" #include "kvm_cache_regs.h" #include "x86.h" +#include "smm.h" #include "cpuid.h" #include "pmu.h"
@@ -4442,9 +4443,9 @@ static int svm_enter_smm(struct kvm_vcpu *vcpu, char *smstate)return 0 ;/* FED8h - SVM Guest */ -put_smstate (u64, smstate,0x7ed8 ,1 ); +PUT_SMSTATE (u64, smstate,0x7ed8 ,1 );/* FEE0h - SVM Guest VMCB Physical Address */ -put_smstate (u64, smstate,0x7ee0 , svm->nested.vmcb12_gpa); +PUT_SMSTATE (u64, smstate,0x7ee0 , svm->nested.vmcb12_gpa); svm->vmcb->save.rax = vcpu->arch.regs[VCPU_REGS_RAX ]; svm->vmcb->save.rsp = vcpu->arch.regs[VCPU_REGS_RSP ];
arch/x86/kvm/vmx/nested.c +1 -0
@@ -16,6 +16,7 @@#include "trace.h" #include "vmx.h" #include "x86.h" +#include "smm.h" static bool __read_mostly enable_shadow_vmcs =1 ;module_param_named (enable_shadow_vmcs, enable_shadow_vmcs, bool,S_IRUGO );
arch/x86/kvm/vmx/vmx.c +1 -0
@@ -66,6 +66,7 @@#include "vmcs12.h" #include "vmx.h" #include "x86.h" +#include "smm.h" MODULE_AUTHOR ("Qumranet" );MODULE_LICENSE ("GPL" );
arch/x86/kvm/x86.c +55 -93
256 lines not on this page · raw message
Signature · 1 line
2.34.3
PATCH v4 2/23 KVM: x86: move SMM entry to a new file
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
Some users of KVM implement the UEFI variable store through a paravirtual device that does not require the "SMM lockbox" component of edk2, and would like to compile out system management mode. In preparation for that, move the SMM entry code out of x86.c and into a new file.
--- arch/x86/include/asm/kvm_host.h | 1 + arch/x86/kvm/smm.c | 235 +++++++++++++++++++++++++++++++ arch/x86/kvm/smm.h | 1 + arch/x86/kvm/x86.c | 239 +------------------------------- 4 files changed, 239 insertions(+), 237 deletions(-)
arch/x86/include/asm/kvm_host.h +1 -0
@@ -1839,6 +1839,7 @@ int kvm_emulate_ap_reset_hold(struct kvm_vcpu *vcpu);int kvm_emulate_wbinvd (struct kvm_vcpu *vcpu);void kvm_get_segment (struct kvm_vcpu *vcpu,struct kvm_segment *var,int seg); +void kvm_set_segment (struct kvm_vcpu *vcpu,struct kvm_segment *var,int seg);int kvm_load_segment_descriptor (struct kvm_vcpu *vcpu,u16 selector,int seg);void kvm_vcpu_deliver_sipi_vector (struct kvm_vcpu *vcpu,u8 vector);
arch/x86/kvm/smm.c +235 -0
244 lines not on this page · raw message
arch/x86/kvm/smm.h +1 -0
@@ -20,6 +20,7 @@ static inline bool is_smm(struct kvm_vcpu *vcpu) }void kvm_smm_changed (struct kvm_vcpu *vcpu,bool in_smm); +void enter_smm (struct kvm_vcpu *vcpu);void process_smi (struct kvm_vcpu *vcpu);#endif
arch/x86/kvm/x86.c +2 -237
257 lines not on this page · raw message
Signature · 1 line
2.34.3
PATCH v4 3/23 KVM: x86: move SMM exit to a new file
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
Some users of KVM implement the UEFI variable store through a paravirtual device that does not require the "SMM lockbox" component of edk2, and would like to compile out system management mode. In preparation for that, move the SMM exit code out of emulate.c and into a new file.
The code is still written as a series of invocations of the emulator callbacks, but the two exiting_smm and leave_smm callbacks are merged into one, and all the code from em_rsm is now part of the callback. This removes all knowledge of the format of the SMM save state area from the emulator. Further patches will clean up the code and invoke KVM's own functions to access control registers, descriptor caches, etc.
--- arch/x86/kvm/emulate.c | 356 +------------------------------------ arch/x86/kvm/kvm_emulate.h | 34 +++- arch/x86/kvm/smm.c | 316 ++++++++++++++++++++++++++++++++ arch/x86/kvm/smm.h | 1 + arch/x86/kvm/x86.c | 14 -- 5 files changed, 351 insertions(+), 370 deletions(-)
arch/x86/kvm/emulate.c +2 -354
@@ -30,7 +30,6 @@#include "tss.h" #include "mmu.h" #include "pmu.h" -#include "smm.h" /* * Operand types
@@ -243,37 +242,6 @@ enum x86_transfer_type { X86_TRANSFER_TASK_SWITCH, }; -static ulong reg_read (struct x86_emulate_ctxt *ctxt,unsigned nr) -{ -if (KVM_EMULATOR_BUG_ON (nr >=NR_EMULATOR_GPRS , ctxt)) - nr &=NR_EMULATOR_GPRS -1 ; - -if (!(ctxt->regs_valid & (1 << nr))) { - ctxt->regs_valid |=1 << nr; - ctxt->_regs[nr] = ctxt->ops->read_gpr (ctxt, nr); - } -return ctxt->_regs[nr]; -} - -static ulong *reg_write (struct x86_emulate_ctxt *ctxt,unsigned nr) -{ -if (KVM_EMULATOR_BUG_ON (nr >=NR_EMULATOR_GPRS , ctxt)) - nr &=NR_EMULATOR_GPRS -1 ; - -BUILD_BUG_ON (sizeof (ctxt->regs_dirty) *BITS_PER_BYTE <NR_EMULATOR_GPRS ); -BUILD_BUG_ON (sizeof (ctxt->regs_valid) *BITS_PER_BYTE <NR_EMULATOR_GPRS ); - - ctxt->regs_valid |=1 << nr; - ctxt->regs_dirty |=1 << nr; -return &ctxt->_regs[nr]; -} - -static ulong *reg_rmw (struct x86_emulate_ctxt *ctxt,unsigned nr) -{ -reg_read (ctxt, nr); -return reg_write (ctxt, nr); -} -static void writeback_registers (struct x86_emulate_ctxt *ctxt) {unsigned long dirty = ctxt->regs_dirty;
@@ -2310,334 +2278,14 @@ static int em_lseg(struct x86_emulate_ctxt *ctxt)return rc; } -static int emulator_has_longmode (struct x86_emulate_ctxt *ctxt) -{ -#ifdef CONFIG_X86_64 -return ctxt->ops->guest_has_long_mode (ctxt); -#else -return false; -#endif -} - -static void rsm_set_desc_flags (struct desc_struct *desc,u32 flags) -{ - desc->g = (flags >>23 ) &1 ; - desc->d = (flags >>22 ) &1 ; - desc->l = (flags >>21 ) &1 ; - desc->avl = (flags >>20 ) &1 ; - desc->p = (flags >>15 ) &1 ; - desc->dpl = (flags >>13 ) &3 ; - desc->s = (flags >>12 ) &1 ; - desc->type = (flags >>8 ) &15 ; -} - -static int rsm_load_seg_32 (struct x86_emulate_ctxt *ctxt,const char *smstate, -int n) -{ -struct desc_struct desc; -int offset; -u16 selector; - - selector =GET_SMSTATE (u32, smstate,0x7fa8 + n *4 ); - -if (n <3 ) - offset =0x7f84 + n *12 ; -else - offset =0x7f2c + (n -3 ) *12 ; - -set_desc_base (&desc,GET_SMSTATE (u32, smstate, offset +8 )); -set_desc_limit (&desc,GET_SMSTATE (u32, smstate, offset +4 )); -rsm_set_desc_flags (&desc,GET_SMSTATE (u32, smstate, offset)); - ctxt->ops->set_segment (ctxt, selector, &desc,0 , n); -return X86EMUL_CONTINUE ; -} - -#ifdef CONFIG_X86_64 -static int rsm_load_seg_64 (struct x86_emulate_ctxt *ctxt,const char *smstate, -int n) -{ -struct desc_struct desc; -int offset; -u16 selector; -u32 base3; - - offset =0x7e00 + n *16 ; - - selector =GET_SMSTATE (u16, smstate, offset); -rsm_set_desc_flags (&desc,GET_SMSTATE (u16, smstate, offset +2 ) <<8 ); -set_desc_limit (&desc,GET_SMSTATE (u32, smstate, offset +4 )); -set_desc_base (&desc,GET_SMSTATE (u32, smstate, offset +8 )); - base3 =GET_SMSTATE (u32, smstate, offset +12 ); - - ctxt->ops->set_segment (ctxt, selector, &desc, base3, n); -return X86EMUL_CONTINUE ; -} -#endif - -static int rsm_enter_protected_mode (struct x86_emulate_ctxt *ctxt, -u64 cr0,u64 cr3,u64 cr4) -{ -int bad; -u64 pcid; - -/* In order to later set CR4.PCIDE, CR3[11:0] must be zero. */ - pcid =0 ; -if (cr4 &X86_CR4_PCIDE ) { - pcid = cr3 &0xfff ; - cr3 &= ~0xfff ; - } - - bad = ctxt->ops->set_cr (ctxt,3 , cr3); -if (bad) -return X86EMUL_UNHANDLEABLE ; - -/* -* First enable PAE, long mode needs it before CR0.PG = 1 is set. -* Then enable protected mode. However, PCID cannot be enabled -* if EFER.LMA=0, so set it separately. -*/ - bad = ctxt->ops->set_cr (ctxt,4 , cr4 & ~X86_CR4_PCIDE ); -if (bad) -return X86EMUL_UNHANDLEABLE ; - - bad = ctxt->ops->set_cr (ctxt,0 , cr0); -if (bad) -return X86EMUL_UNHANDLEABLE ; - -if (cr4 &X86_CR4_PCIDE ) { - bad = ctxt->ops->set_cr (ctxt,4 , cr4); -if (bad) -return X86EMUL_UNHANDLEABLE ; -if (pcid) { - bad = ctxt->ops->set_cr (ctxt,3 , cr3 | pcid); -if (bad) -return X86EMUL_UNHANDLEABLE ; - } - - } - -return X86EMUL_CONTINUE ; -} - -static int rsm_load_state_32 (struct x86_emulate_ctxt *ctxt, -const char *smstate) -{ -struct desc_struct desc; -struct desc_ptr dt; -u16 selector; -u32 val, cr0, cr3, cr4; -int i; - - cr0 =GET_SMSTATE (u32, smstate,0x7ffc ); - cr3 =GET_SMSTATE (u32, smstate,0x7ff8 ); - ctxt->eflags =GET_SMSTATE (u32, smstate,0x7ff4 ) |X86_EFLAGS_FIXED ; - ctxt->_eip =GET_SMSTATE (u32, smstate,0x7ff0 ); - -for (i =0 ; i <NR_EMULATOR_GPRS ; i++) - *reg_write (ctxt, i) =GET_SMSTATE (u32, smstate,0x7fd0 + i *4 ); - - val =GET_SMSTATE (u32, smstate,0x7fcc ); - -if (ctxt->ops->set_dr (ctxt,6 , val)) -return X86EMUL_UNHANDLEABLE ; - - val =GET_SMSTATE (u32, smstate,0x7fc8 ); - -if (ctxt->ops->set_dr (ctxt,7 , val)) -return X86EMUL_UNHANDLEABLE ; - - selector =GET_SMSTATE (u32, smstate,0x7fc4 ); -set_desc_base (&desc,GET_SMSTATE (u32, smstate,0x7f64 )); -set_desc_limit (&desc,GET_SMSTATE (u32, smstate,0x7f60 )); -rsm_set_desc_flags (&desc,GET_SMSTATE (u32, smstate,0x7f5c )); - ctxt->ops->set_segment (ctxt, selector, &desc,0 ,VCPU_SREG_TR ); - - selector =GET_SMSTATE (u32, smstate,0x7fc0 ); -set_desc_base (&desc,GET_SMSTATE (u32, smstate,0x7f80 )); -set_desc_limit (&desc,GET_SMSTATE (u32, smstate,0x7f7c )); -rsm_set_desc_flags (&desc,GET_SMSTATE (u32, smstate,0x7f78 )); - ctxt->ops->set_segment (ctxt, selector, &desc,0 ,VCPU_SREG_LDTR ); - - dt.address =GET_SMSTATE (u32, smstate,0x7f74 ); - dt.size =GET_SMSTATE (u32, smstate,0x7f70 ); - ctxt->ops->set_gdt (ctxt, &dt); - - dt.address =GET_SMSTATE (u32, smstate,0x7f58 ); - dt.size =GET_SMSTATE (u32, smstate,0x7f54 ); - ctxt->ops->set_idt (ctxt, &dt); - -for (i =0 ; i <6 ; i++) { -int r =rsm_load_seg_32 (ctxt, smstate, i); -if (r !=X86EMUL_CONTINUE ) -return r; - } - - cr4 =GET_SMSTATE (u32, smstate,0x7f14 ); - - ctxt->ops->set_smbase (ctxt,GET_SMSTATE (u32, smstate,0x7ef8 )); - -return rsm_enter_protected_mode (ctxt, cr0, cr3, cr4); -} - -#ifdef CONFIG_X86_64 -static int rsm_load_state_64 (struct x86_emulate_ctxt *ctxt, -const char *smstate) -{ -struct desc_struct desc; -struct desc_ptr dt; -u64 val, cr0, cr3, cr4; -u32 base3; -u16 selector; -int i, r; - -for (i =0 ; i <NR_EMULATOR_GPRS ; i++) - *reg_write (ctxt, i) =GET_SMSTATE (u64, smstate,0x7ff8 - i *8 ); - - ctxt->_eip =GET_SMSTATE (u64, smstate,0x7f78 ); - ctxt->eflags =GET_SMSTATE (u32, smstate,0x7f70 ) |X86_EFLAGS_FIXED ; - - val =GET_SMSTATE (u64, smstate,0x7f68 ); - -if (ctxt->ops->set_dr (ctxt,6 , val)) -return X86EMUL_UNHANDLEABLE ; - - val =GET_SMSTATE (u64, smstate,0x7f60 ); - -if (ctxt->ops->set_dr (ctxt,7 , val)) -return X86EMUL_UNHANDLEABLE ; - - cr0 =GET_SMSTATE (u64, smstate,0x7f58 ); - cr3 =GET_SMSTATE (u64, smstate,0x7f50 ); - cr4 =GET_SMSTATE (u64, smstate,0x7f48 ); - ctxt->ops->set_smbase (ctxt,GET_SMSTATE (u32, smstate,0x7f00 )); - val =GET_SMSTATE (u64, smstate,0x7ed0 ); - -if (ctxt->ops->set_msr (ctxt,MSR_EFER , val & ~EFER_LMA )) -return X86EMUL_UNHANDLEABLE ; - - selector =GET_SMSTATE (u32, smstate,0x7e90 ); -rsm_set_desc_flags (&desc,GET_SMSTATE (u32, smstate,0x7e92 ) <<8 ); -set_desc_limit (&desc,GET_SMSTATE (u32, smstate,0x7e94 )); -set_desc_base (&desc,GET_SMSTATE (u32, smstate,0x7e98 )); - base3 =GET_SMSTATE (u32, smstate,0x7e9c ); - ctxt->ops->set_segment (ctxt, selector, &desc, base3,VCPU_SREG_TR ); - - dt.size =GET_SMSTATE (u32, smstate,0x7e84 ); - dt.address =GET_SMSTATE (u64, smstate,0x7e88 ); - ctxt->ops->set_idt (ctxt, &dt); - - selector =GET_SMSTATE (u32, smstate,0x7e70 ); -rsm_set_desc_flags (&desc,GET_SMSTATE (u32, smstate,0x7e72 ) <<8 ); -set_desc_limit (&desc,GET_SMSTATE (u32, smstate,0x7e74 )); -set_desc_base (&desc,GET_SMSTATE (u32, smstate,0x7e78 )); - base3 =GET_SMSTATE (u32, smstate,0x7e7c ); - ctxt->ops->set_segment (ctxt, selector, &desc, base3,VCPU_SREG_LDTR ); - - dt.size =GET_SMSTATE (u32, smstate,0x7e64 ); - dt.address =GET_SMSTATE (u64, smstate,0x7e68 ); - ctxt->ops->set_gdt (ctxt, &dt); - - r =rsm_enter_protected_mode (ctxt, cr0, cr3, cr4); -if (r !=X86EMUL_CONTINUE ) -return r; - -for (i =0 ; i <6 ; i++) { - r =rsm_load_seg_64 (ctxt, smstate, i); -if (r !=X86EMUL_CONTINUE ) -return r; - } - -return X86EMUL_CONTINUE ; -} -#endif -static int em_rsm (struct x86_emulate_ctxt *ctxt) { -unsigned long cr0, cr4, efer; -char buf[512 ]; -u64 smbase; -int ret; -if ((ctxt->ops->get_hflags (ctxt) &X86EMUL_SMM_MASK ) ==0 )return emulate_ud (ctxt); - smbase = ctxt->ops->get_smbase (ctxt); - - ret = ctxt->ops->read_phys (ctxt, smbase +0xfe00 , buf,sizeof (buf)); -if (ret !=X86EMUL_CONTINUE ) -return X86EMUL_UNHANDLEABLE ; - -if ((ctxt->ops->get_hflags (ctxt) &X86EMUL_SMM_INSIDE_NMI_MASK ) ==0 ) - ctxt->ops->set_nmi_mask (ctxt, false); - - ctxt->ops->exiting_smm (ctxt); - -/* -* Get back to real mode, to prepare a safe state in which to load -* CR0/CR3/CR4/EFER. It's all a bit more complicated if the vCPU -* supports long mode. -*/ -if (emulator_has_longmode (ctxt)) { -struct desc_struct cs_desc; - -/* Zero CR4.PCIDE before CR0.PG. */ - cr4 = ctxt->ops->get_cr (ctxt,4 ); -if (cr4 &X86_CR4_PCIDE ) - ctxt->ops->set_cr (ctxt,4 , cr4 & ~X86_CR4_PCIDE ); - -/* A 32-bit code segment is required to clear EFER.LMA. */ -memset (&cs_desc,0 ,sizeof (cs_desc)); - cs_desc.type =0xb ; - cs_desc.s = cs_desc.g = cs_desc.p =1 ; - ctxt->ops->set_segment (ctxt,0 , &cs_desc,0 ,VCPU_SREG_CS ); - } - -/* For the 64-bit case, this will clear EFER.LMA. */ - cr0 = ctxt->ops->get_cr (ctxt,0 ); -if (cr0 &X86_CR0_PE ) - ctxt->ops->set_cr (ctxt,0 , cr0 & ~(X86_CR0_PG |X86_CR0_PE )); - -if (emulator_has_longmode (ctxt)) { -/* Clear CR4.PAE before clearing EFER.LME. */ - cr4 = ctxt->ops->get_cr (ctxt,4 ); -if (cr4 &X86_CR4_PAE ) - ctxt->ops->set_cr (ctxt,4 , cr4 & ~X86_CR4_PAE ); - -/* And finally go back to 32-bit mode. */ - efer =0 ; - ctxt->ops->set_msr (ctxt,MSR_EFER , efer); - } - -/* -* Give leave_smm() a chance to make ISA-specific changes to the vCPU -* state (e.g. enter guest mode) before loading state from the SMM -* state-save area. -*/ -if (ctxt->ops->leave_smm (ctxt, buf)) - goto emulate_shutdown; - -#ifdef CONFIG_X86_64 -if (emulator_has_longmode (ctxt)) - ret =rsm_load_state_64 (ctxt, buf); - else -#endif - ret =rsm_load_state_32 (ctxt, buf); - -if (ret !=X86EMUL_CONTINUE ) - goto emulate_shutdown; - -/* -* Note, the ctxt->ops callbacks are responsible for handling side -* effects when writing MSRs and CRs, e.g. MMU context resets, CPUID -* runtime updates, etc... If that changes, e.g. this flow is moved -* out of the emulator to make it look more like enter_smm(), then -* those side effects need to be explicitly handled for both success -* and shutdown. -*/ -return X86EMUL_CONTINUE ; +if (ctxt->ops->leave_smm (ctxt)) + ctxt->ops->triple_fault (ctxt); -emulate_shutdown: - ctxt->ops->triple_fault (ctxt);return X86EMUL_CONTINUE ; }
arch/x86/kvm/kvm_emulate.h +32 -2
@@ -234,8 +234,7 @@ struct x86_emulate_ops {void (*set_nmi_mask)(struct x86_emulate_ctxt *ctxt,bool masked);unsigned (*get_hflags)(struct x86_emulate_ctxt *ctxt); -void (*exiting_smm)(struct x86_emulate_ctxt *ctxt); -int (*leave_smm)(struct x86_emulate_ctxt *ctxt,const char *smstate); +int (*leave_smm)(struct x86_emulate_ctxt *ctxt);void (*triple_fault)(struct x86_emulate_ctxt *ctxt);int (*set_xcr)(struct x86_emulate_ctxt *ctxt,u32 index,u64 xcr); };
@@ -526,4 +525,35 @@ void emulator_invalidate_register_cache(struct x86_emulate_ctxt *ctxt);void emulator_writeback_register_cache (struct x86_emulate_ctxt *ctxt);bool emulator_can_use_gpa (struct x86_emulate_ctxt *ctxt); +static inline ulong reg_read (struct x86_emulate_ctxt *ctxt,unsigned nr) +{ +if (KVM_EMULATOR_BUG_ON (nr >=NR_EMULATOR_GPRS , ctxt)) + nr &=NR_EMULATOR_GPRS -1 ; + +if (!(ctxt->regs_valid & (1 << nr))) { + ctxt->regs_valid |=1 << nr; + ctxt->_regs[nr] = ctxt->ops->read_gpr (ctxt, nr); + } +return ctxt->_regs[nr]; +} + +static inline ulong *reg_write (struct x86_emulate_ctxt *ctxt,unsigned nr) +{ +if (KVM_EMULATOR_BUG_ON (nr >=NR_EMULATOR_GPRS , ctxt)) + nr &=NR_EMULATOR_GPRS -1 ; + +BUILD_BUG_ON (sizeof (ctxt->regs_dirty) *BITS_PER_BYTE <NR_EMULATOR_GPRS ); +BUILD_BUG_ON (sizeof (ctxt->regs_valid) *BITS_PER_BYTE <NR_EMULATOR_GPRS ); + + ctxt->regs_valid |=1 << nr; + ctxt->regs_dirty |=1 << nr; +return &ctxt->_regs[nr]; +} + +static inline ulong *reg_rmw (struct x86_emulate_ctxt *ctxt,unsigned nr) +{ +reg_read (ctxt, nr); +return reg_write (ctxt, nr); +} +#endif /* _ASM_X86_KVM_X86_EMULATE_H */
arch/x86/kvm/smm.c +316 -0
319 lines not on this page · raw message
arch/x86/kvm/smm.h +1 -0
@@ -21,6 +21,7 @@ static inline bool is_smm(struct kvm_vcpu *vcpu)void kvm_smm_changed (struct kvm_vcpu *vcpu,bool in_smm);void enter_smm (struct kvm_vcpu *vcpu); +int emulator_leave_smm (struct x86_emulate_ctxt *ctxt);void process_smi (struct kvm_vcpu *vcpu);#endif
arch/x86/kvm/x86.c +0 -14
@@ -8108,19 +8108,6 @@ static unsigned emulator_get_hflags(struct x86_emulate_ctxt *ctxt)return emul_to_vcpu (ctxt)->arch.hflags; } -static void emulator_exiting_smm (struct x86_emulate_ctxt *ctxt) -{ -struct kvm_vcpu *vcpu =emul_to_vcpu (ctxt); - -kvm_smm_changed (vcpu, false); -} - -static int emulator_leave_smm (struct x86_emulate_ctxt *ctxt, -const char *smstate) -{ -return static_call (kvm_x86_leave_smm)(emul_to_vcpu (ctxt), smstate); -} -static void emulator_triple_fault (struct x86_emulate_ctxt *ctxt) {kvm_make_request (KVM_REQ_TRIPLE_FAULT ,emul_to_vcpu (ctxt));
@@ -8184,7 +8171,6 @@ static const struct x86_emulate_ops emulate_ops = { .guest_has_rdpid = emulator_guest_has_rdpid, .set_nmi_mask = emulator_set_nmi_mask, .get_hflags = emulator_get_hflags, - .exiting_smm = emulator_exiting_smm, .leave_smm = emulator_leave_smm, .triple_fault = emulator_triple_fault, .set_xcr = emulator_set_xcr,
Signature · 1 line
2.34.3
PATCH v4 4/23 KVM: x86: do not go through ctxt->ops when emulating rsm
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
Now that RSM is implemented in a single emulator callback, there is no point in going through other callbacks for the sake of modifying processor state. Just invoke KVM's own internal functions directly, and remove the callbacks that were only used by em_rsm; the only substantial difference is in the handling of the segment registers and descriptor cache, which have to be parsed into a struct kvm_segment instead of a struct desc_struct.
This also fixes a bug where emulator_set_segment was shifting the limit left by 12 if the G bit is set, but the limit had not been shifted right upon entry to SMM.
The emulator context is still used to restore EIP and the general purpose registers.
--- arch/x86/kvm/kvm_emulate.h | 13 --- arch/x86/kvm/smm.c | 177 +++++++++++++++++-------------------- arch/x86/kvm/x86.c | 33 ------- 3 files changed, 81 insertions(+), 142 deletions(-)
arch/x86/kvm/kvm_emulate.h +0 -13
@@ -116,16 +116,6 @@ struct x86_emulate_ops {unsigned int bytes, struct x86_exception *fault, bool system); -/* -* read_phys: Read bytes of standard (non-emulated/special) memory. -* Used for descriptor reading. -* @addr: [IN ] Physical address from which to read. -* @val: [OUT] Value read from memory. -* @bytes: [IN ] Number of bytes to read from memory. -*/ -int (*read_phys)(struct x86_emulate_ctxt *ctxt,unsigned long addr, -void *val,unsigned int bytes); -/* * write_std: Write bytes of standard (non-emulated/special) memory. * Used for descriptor writing.
@@ -209,11 +199,8 @@ struct x86_emulate_ops {int (*cpl)(struct x86_emulate_ctxt *ctxt);void (*get_dr)(struct x86_emulate_ctxt *ctxt,int dr,ulong *dest);int (*set_dr)(struct x86_emulate_ctxt *ctxt,int dr,ulong value); -u64 (*get_smbase)(struct x86_emulate_ctxt *ctxt); -void (*set_smbase)(struct x86_emulate_ctxt *ctxt,u64 smbase);int (*set_msr_with_filter)(struct x86_emulate_ctxt *ctxt,u32 msr_index,u64 data);int (*get_msr_with_filter)(struct x86_emulate_ctxt *ctxt,u32 msr_index,u64 *pdata); -int (*set_msr)(struct x86_emulate_ctxt *ctxt,u32 msr_index,u64 data);int (*get_msr)(struct x86_emulate_ctxt *ctxt,u32 msr_index,u64 *pdata);int (*check_pmc)(struct x86_emulate_ctxt *ctxt,u32 pmc);int (*read_pmc)(struct x86_emulate_ctxt *ctxt,u32 pmc,u64 *pdata);
arch/x86/kvm/smm.c +81 -96
357 lines not on this page · raw message
arch/x86/kvm/x86.c +0 -33
@@ -7214,15 +7214,6 @@ static int emulator_read_std(struct x86_emulate_ctxt *ctxt,return kvm_read_guest_virt_helper (addr, val, bytes, vcpu, access, exception); } -static int kvm_read_guest_phys_system (struct x86_emulate_ctxt *ctxt, -unsigned long addr,void *val,unsigned int bytes) -{ -struct kvm_vcpu *vcpu =emul_to_vcpu (ctxt); -int r =kvm_vcpu_read_guest (vcpu, addr, val, bytes); - -return r <0 ?X86EMUL_IO_NEEDED :X86EMUL_CONTINUE ; -} -static int kvm_write_guest_virt_helper (gva_t addr,void *val,unsigned int bytes,struct kvm_vcpu *vcpu,u64 access,struct x86_exception *exception)
@@ -8014,26 +8005,6 @@ static int emulator_get_msr(struct x86_emulate_ctxt *ctxt,return kvm_get_msr (emul_to_vcpu (ctxt), msr_index, pdata); } -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); -} - -static u64 emulator_get_smbase (struct x86_emulate_ctxt *ctxt) -{ -struct kvm_vcpu *vcpu =emul_to_vcpu (ctxt); - -return vcpu->arch.smbase; -} - -static void emulator_set_smbase (struct x86_emulate_ctxt *ctxt,u64 smbase) -{ -struct kvm_vcpu *vcpu =emul_to_vcpu (ctxt); - - vcpu->arch.smbase = smbase; -} -static int emulator_check_pmc (struct x86_emulate_ctxt *ctxt,u32 pmc) {
@@ -8132,7 +8103,6 @@ static const struct x86_emulate_ops emulate_ops = { .write_gpr = emulator_write_gpr, .read_std = emulator_read_std, .write_std = emulator_write_std, - .read_phys = kvm_read_guest_phys_system, .fetch = kvm_fetch_guest_virt, .read_emulated = emulator_read_emulated, .write_emulated = emulator_write_emulated,
@@ -8152,11 +8122,8 @@ static const struct x86_emulate_ops emulate_ops = { .cpl = emulator_get_cpl, .get_dr = emulator_get_dr, .set_dr = emulator_set_dr, - .get_smbase = emulator_get_smbase, - .set_smbase = emulator_set_smbase, .set_msr_with_filter = emulator_set_msr_with_filter, .get_msr_with_filter = emulator_get_msr_with_filter, - .set_msr = emulator_set_msr, .get_msr = emulator_get_msr, .check_pmc = emulator_check_pmc, .read_pmc = emulator_read_pmc,
Signature · 1 line
2.34.3
PATCH v4 5/23 KVM: allow compiling out SMM support
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
Some users of KVM implement the UEFI variable store through a paravirtual device that does not require the "SMM lockbox" component of edk2; allow them to compile out system management mode, which is not a full implementation especially in how it interacts with nested virtualization.
--- arch/x86/kvm/Kconfig | 11 ++++++++++ arch/x86/kvm/Makefile | 2 +- arch/x86/kvm/smm.h | 13 ++++++++++++ arch/x86/kvm/svm/svm.c | 2 ++ arch/x86/kvm/vmx/vmx.c | 2 ++ arch/x86/kvm/x86.c | 21 +++++++++++++++++-- tools/testing/selftests/kvm/x86_64/smm_test.c | 2 ++ 7 files changed, 50 insertions(+), 3 deletions(-)
arch/x86/kvm/Kconfig +11 -0
@@ -87,6 +87,17 @@ config KVM_INTEL To compile this as a module, choose M here: the module will be called kvm-intel. +config KVM_SMM + bool "System Management Mode emulation" + default y + depends on KVM + help + Provides support for KVM to emulate System Management Mode (SMM) + in virtual machines. This can be used by the virtual machine + firmware to implement UEFI secure boot. + + If unsure, say Y. + config X86_SGX_KVM bool "Software Guard eXtensions (SGX) Virtualization" depends on X86_SGX && KVM_INTEL
arch/x86/kvm/Makefile +1 -1
@@ -20,7 +20,7 @@ endif kvm-$(CONFIG_X86_64) += mmu/tdp_iter.o mmu/tdp_mmu.o kvm-$(CONFIG_KVM_XEN) += xen.o -kvm-y += smm.o +kvm-$(CONFIG_KVM_SMM) += smm.o kvm-intel-y += vmx/vmx.o vmx/vmenter.o vmx/pmu_intel.o vmx/vmcs12.o \ vmx/evmcs.o vmx/nested.o vmx/posted_intr.o
arch/x86/kvm/smm.h +13 -0
@@ -8,6 +8,7 @@#define PUT_SMSTATE (type, buf, offset, val) \ *(type *)((buf) + (offset) - 0x7e00) = val +#ifdef CONFIG_KVM_SMM static inline int kvm_inject_smi (struct kvm_vcpu *vcpu) {kvm_make_request (KVM_REQ_SMI , vcpu);
@@ -23,5 +24,17 @@ void kvm_smm_changed(struct kvm_vcpu *vcpu, bool in_smm);void enter_smm (struct kvm_vcpu *vcpu);int emulator_leave_smm (struct x86_emulate_ctxt *ctxt);void process_smi (struct kvm_vcpu *vcpu); +#else +static inline int kvm_inject_smi (struct kvm_vcpu *vcpu) {return -ENOTTY ; } +static inline bool is_smm (struct kvm_vcpu *vcpu) {return false; } +static inline void kvm_smm_changed (struct kvm_vcpu *vcpu,bool in_smm) {WARN_ON_ONCE (1 ); } +static inline void enter_smm (struct kvm_vcpu *vcpu) {WARN_ON_ONCE (1 ); } +static inline void process_smi (struct kvm_vcpu *vcpu) {WARN_ON_ONCE (1 ); } + +/* +* emulator_leave_smm is used as a function pointer, so the +* stub is defined in x86.c. +*/ +#endif #endif
arch/x86/kvm/svm/svm.c +2 -0
@@ -4150,6 +4150,8 @@ static bool svm_has_emulated_msr(struct kvm *kvm, u32 index) case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC:return false;case MSR_IA32_SMBASE : +if (!IS_ENABLED (CONFIG_KVM_SMM )) +return false;/* SEV-ES guests do not support SMM, so report false */ if (kvm &&sev_es_guest (kvm))return false;
arch/x86/kvm/vmx/vmx.c +2 -0
@@ -6841,6 +6841,8 @@ static bool vmx_has_emulated_msr(struct kvm *kvm, u32 index) {switch (index) {case MSR_IA32_SMBASE : +if (!IS_ENABLED (CONFIG_KVM_SMM )) +return false;/* * We cannot do SMM unless we can run the guest in big * real mode.
arch/x86/kvm/x86.c +19 -2
@@ -3649,7 +3649,7 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)break ; }case MSR_IA32_SMBASE : -if (!msr_info->host_initiated) +if (!IS_ENABLED (CONFIG_KVM_SMM ) || !msr_info->host_initiated)return 1 ; vcpu->arch.smbase = data;break ;
@@ -4065,7 +4065,7 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info) msr_info->data = vcpu->arch.ia32_misc_enable_msr;break ;case MSR_IA32_SMBASE : -if (!msr_info->host_initiated) +if (!IS_ENABLED (CONFIG_KVM_SMM ) || !msr_info->host_initiated)return 1 ; msr_info->data = vcpu->arch.smbase;break ;
@@ -4439,6 +4439,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) r |=KVM_X86_DISABLE_EXITS_MWAIT ;break ;case KVM_CAP_X86_SMM : +if (!IS_ENABLED (CONFIG_KVM_SMM )) +break ; +/* SMBASE is usually relocated above 1M on modern chipsets, * and SMM handlers might indeed rely on 4G segment limits, * so do not report SMM to be available if real mode is
@@ -5189,6 +5192,12 @@ static int kvm_vcpu_ioctl_x86_set_vcpu_events(struct kvm_vcpu *vcpu, vcpu->arch.apic->sipi_vector = events->sipi_vector;if (events->flags &KVM_VCPUEVENT_VALID_SMM ) { +if (!IS_ENABLED (CONFIG_KVM_SMM ) && + (events->smi.smm || + events->smi.pending || + events->smi.smm_inside_nmi)) +return -EINVAL ; +if (!!(vcpu->arch.hflags &HF_SMM_MASK ) != events->smi.smm) { kvm_x86_ops.nested_ops->leave_nested (vcpu);kvm_smm_changed (vcpu, events->smi.smm);
@@ -8079,6 +8088,14 @@ static unsigned emulator_get_hflags(struct x86_emulate_ctxt *ctxt)return emul_to_vcpu (ctxt)->arch.hflags; } +#ifndef CONFIG_KVM_SMM +static int emulator_leave_smm (struct x86_emulate_ctxt *ctxt) +{ +WARN_ON_ONCE (1 ); +return X86EMUL_UNHANDLEABLE ; +} +#endif +static void emulator_triple_fault (struct x86_emulate_ctxt *ctxt) {kvm_make_request (KVM_REQ_TRIPLE_FAULT ,emul_to_vcpu (ctxt));
tools/testing/selftests/kvm/x86_64/smm_test.c +2 -0
@@ -137,6 +137,8 @@ int main(int argc, char *argv[])struct kvm_x86_state *state;int stage, stage_reported; +TEST_REQUIRE (kvm_has_cap (KVM_CAP_X86_SMM )); +/* Create VM */ vm =vm_create_with_one_vcpu (&vcpu, guest_code);
Signature · 1 line
2.34.3
PATCH v4 6/23 KVM: x86: compile out vendor-specific code if SMM is disabled
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
Vendor-specific code that deals with SMI injection and saving/restoring SMM state is not needed if CONFIG_KVM_SMM is disabled, so remove the four callbacks smi_allowed, enter_smm, leave_smm and enable_smi_window. The users in svm/nested.c and x86.c also have to be compiled out; the amount of #ifdef'ed code is small and it's not worth moving it to smm.c.
enter_smm is now used only within #ifdef CONFIG_KVM_SMM, and the stub can therefore be removed.
--- arch/x86/include/asm/kvm-x86-ops.h | 2 ++ arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/smm.h | 1 - arch/x86/kvm/svm/nested.c | 2 ++ arch/x86/kvm/svm/svm.c | 4 ++++ arch/x86/kvm/vmx/vmx.c | 4 ++++ arch/x86/kvm/x86.c | 4 ++++ 7 files changed, 18 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm-x86-ops.h +2 -0
@@ -110,10 +110,12 @@ KVM_X86_OP_OPTIONAL_RET0(dy_apicv_has_pending_interrupt) KVM_X86_OP_OPTIONAL(set_hv_timer) KVM_X86_OP_OPTIONAL(cancel_hv_timer) KVM_X86_OP(setup_mce) +#ifdef CONFIG_KVM_SMM KVM_X86_OP(smi_allowed) KVM_X86_OP(enter_smm) KVM_X86_OP(leave_smm) KVM_X86_OP(enable_smi_window) +#endif KVM_X86_OP_OPTIONAL(mem_enc_ioctl) KVM_X86_OP_OPTIONAL(mem_enc_register_region) KVM_X86_OP_OPTIONAL(mem_enc_unregister_region)
arch/x86/include/asm/kvm_host.h +2 -0
@@ -1607,10 +1607,12 @@ struct kvm_x86_ops {void (*setup_mce)(struct kvm_vcpu *vcpu); +#ifdef CONFIG_KVM_SMM int (*smi_allowed)(struct kvm_vcpu *vcpu,bool for_injection);int (*enter_smm)(struct kvm_vcpu *vcpu,char *smstate);int (*leave_smm)(struct kvm_vcpu *vcpu,const char *smstate);void (*enable_smi_window)(struct kvm_vcpu *vcpu); +#endif int (*mem_enc_ioctl)(struct kvm *kvm,void __user *argp);int (*mem_enc_register_region)(struct kvm *kvm,struct kvm_enc_region *argp);
arch/x86/kvm/smm.h +0 -1
@@ -28,7 +28,6 @@ void process_smi(struct kvm_vcpu *vcpu);static inline int kvm_inject_smi (struct kvm_vcpu *vcpu) {return -ENOTTY ; }static inline bool is_smm (struct kvm_vcpu *vcpu) {return false; }static inline void kvm_smm_changed (struct kvm_vcpu *vcpu,bool in_smm) {WARN_ON_ONCE (1 ); } -static inline void enter_smm (struct kvm_vcpu *vcpu) {WARN_ON_ONCE (1 ); }static inline void process_smi (struct kvm_vcpu *vcpu) {WARN_ON_ONCE (1 ); }/*
arch/x86/kvm/svm/nested.c +2 -0
@@ -1378,6 +1378,7 @@ static int svm_check_nested_events(struct kvm_vcpu *vcpu)return 0 ; } +#ifdef CONFIG_KVM_SMM if (vcpu->arch.smi_pending && !svm_smi_blocked (vcpu)) {if (block_nested_events)return -EBUSY ;
@@ -1386,6 +1387,7 @@ static int svm_check_nested_events(struct kvm_vcpu *vcpu)nested_svm_simple_vmexit (svm,SVM_EXIT_SMI ); return 0; } +#endif if (vcpu->arch.nmi_pending && !svm_nmi_blocked (vcpu)) {if (block_nested_events)
arch/x86/kvm/svm/svm.c +4 -0
@@ -4408,6 +4408,7 @@ static void svm_setup_mce(struct kvm_vcpu *vcpu) vcpu->arch.mcg_cap &=0x1ff ; } +#ifdef CONFIG_KVM_SMM bool svm_smi_blocked (struct kvm_vcpu *vcpu) {struct vcpu_svm *svm =to_svm (vcpu);
@@ -4557,6 +4558,7 @@ static void svm_enable_smi_window(struct kvm_vcpu *vcpu) /* We must be in SMM; RSM will cause a vmexit anyway. */ } } +#endif static bool svm_can_emulate_instruction (struct kvm_vcpu *vcpu,int emul_type,void *insn,int insn_len)
@@ -4832,10 +4834,12 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { .pi_update_irte = avic_pi_update_irte, .setup_mce = svm_setup_mce, +#ifdef CONFIG_KVM_SMM .smi_allowed = svm_smi_allowed, .enter_smm = svm_enter_smm, .leave_smm = svm_leave_smm, .enable_smi_window = svm_enable_smi_window, +#endif .mem_enc_ioctl = sev_mem_enc_ioctl, .mem_enc_register_region = sev_mem_enc_register_region,
arch/x86/kvm/vmx/vmx.c +4 -0
@@ -7905,6 +7905,7 @@ static void vmx_setup_mce(struct kvm_vcpu *vcpu) ~FEAT_CTL_LMCE_ENABLED ; } +#ifdef CONFIG_KVM_SMM static int vmx_smi_allowed (struct kvm_vcpu *vcpu,bool for_injection) {/* we need a nested vmexit to enter SMM, postpone if run is pending */
@@ -7959,6 +7960,7 @@ static void vmx_enable_smi_window(struct kvm_vcpu *vcpu) {/* RSM will cause a vmexit anyway. */ } +#endif static bool vmx_apic_init_signal_blocked (struct kvm_vcpu *vcpu) {
@@ -8126,10 +8128,12 @@ static struct kvm_x86_ops vmx_x86_ops __initdata = { .setup_mce = vmx_setup_mce, +#ifdef CONFIG_KVM_SMM .smi_allowed = vmx_smi_allowed, .enter_smm = vmx_enter_smm, .leave_smm = vmx_leave_smm, .enable_smi_window = vmx_enable_smi_window, +#endif .can_emulate_instruction = vmx_can_emulate_instruction, .apic_init_signal_blocked = vmx_apic_init_signal_blocked,
arch/x86/kvm/x86.c +4 -0
@@ -9876,6 +9876,7 @@ static int kvm_check_and_inject_events(struct kvm_vcpu *vcpu,* in order to make progress and get back here for another iteration. * The kvm_x86_ops hooks communicate this by returning -EBUSY. */ +#ifdef CONFIG_KVM_SMM if (vcpu->arch.smi_pending) { r = can_inject ?static_call (kvm_x86_smi_allowed)(vcpu, true) : -EBUSY ;if (r <0 )
@@ -9888,6 +9889,7 @@ static int kvm_check_and_inject_events(struct kvm_vcpu *vcpu, } elsestatic_call (kvm_x86_enable_smi_window)(vcpu); } +#endif if (vcpu->arch.nmi_pending) { r = can_inject ?static_call (kvm_x86_nmi_allowed)(vcpu, true) : -EBUSY ;
@@ -12517,10 +12519,12 @@ static inline bool kvm_vcpu_has_events(struct kvm_vcpu *vcpu) static_call(kvm_x86_nmi_allowed)(vcpu, false)))return true; +#ifdef CONFIG_KVM_SMM if (kvm_test_request (KVM_REQ_SMI , vcpu) || (vcpu->arch.smi_pending &&static_call (kvm_x86_smi_allowed)(vcpu, false)))return true; +#endif if (kvm_arch_interrupt_allowed(vcpu) && (kvm_cpu_has_interrupt(vcpu) ||
Signature · 1 line
2.34.3
PATCH v4 7/23 KVM: x86: remove SMRAM address space if SMM is not supported
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
If CONFIG_KVM_SMM is not defined HF_SMM_MASK will always be zero, and we can spare userspace the hassle of setting up the SMRAM address space simply by reporting that only one address space is supported.
--- arch/x86/include/asm/kvm_host.h | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
arch/x86/include/asm/kvm_host.h +8 -5
@@ -1995,11 +1995,14 @@ enum {#define HF_SMM_MASK (1 << 6)#define HF_SMM_INSIDE_NMI_MASK (1 << 7) -#define __KVM_VCPU_MULTIPLE_ADDRESS_SPACE -#define KVM_ADDRESS_SPACE_NUM 2 - -#define kvm_arch_vcpu_memslots_id (vcpu) ((vcpu)->arch.hflags & HF_SMM_MASK ? 1 : 0) -#define kvm_memslots_for_spte_role (kvm, role) __kvm_memslots(kvm, (role).smm) +#ifdef CONFIG_KVM_SMM +# define __KVM_VCPU_MULTIPLE_ADDRESS_SPACE +# define KVM_ADDRESS_SPACE_NUM 2 +# define kvm_arch_vcpu_memslots_id (vcpu) ((vcpu)->arch.hflags & HF_SMM_MASK ? 1 : 0) +# define kvm_memslots_for_spte_role (kvm, role) __kvm_memslots(kvm, (role).smm) +#else +# define kvm_memslots_for_spte_role (kvm, role) __kvm_memslots(kvm, 0) +#endif #define KVM_ARCH_WANT_MMU_NOTIFIER
Signature · 1 line
2.34.3
PATCH v4 8/23 KVM: x86: do not define KVM_REQ_SMI if SMM disabled
In reply to Maxim LevitskyFrom: Paolo Bonzini <[email protected]>
This ensures that all the relevant code is compiled out, in fact the process_smi stub can be removed too.
--- arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/smm.h | 1 - arch/x86/kvm/x86.c | 6 ++++++ 3 files changed, 8 insertions(+), 1 deletion(-)
arch/x86/include/asm/kvm_host.h +2 -0
@@ -81,7 +81,9 @@#define KVM_REQ_NMI KVM_ARCH_REQ(9)#define KVM_REQ_PMU KVM_ARCH_REQ(10)#define KVM_REQ_PMI KVM_ARCH_REQ(11) +#ifdef CONFIG_KVM_SMM #define KVM_REQ_SMI KVM_ARCH_REQ(12) +#endif #define KVM_REQ_MASTERCLOCK_UPDATE KVM_ARCH_REQ(13)#define KVM_REQ_MCLOCK_INPROGRESS \ KVM_ARCH_REQ_FLAGS(14, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
arch/x86/kvm/smm.h +0 -1
@@ -28,7 +28,6 @@ void process_smi(struct kvm_vcpu *vcpu);static inline int kvm_inject_smi (struct kvm_vcpu *vcpu) {return -ENOTTY ; }static inline bool is_smm (struct kvm_vcpu *vcpu) {return false; }static inline void kvm_smm_changed (struct kvm_vcpu *vcpu,bool in_smm) {WARN_ON_ONCE (1 ); } -static inline void process_smi (struct kvm_vcpu *vcpu) {WARN_ON_ONCE (1 ); }/* * emulator_leave_smm is used as a function pointer, so the
arch/x86/kvm/x86.c +6 -0
@@ -5033,8 +5033,10 @@ static void kvm_vcpu_ioctl_x86_get_vcpu_events(struct kvm_vcpu *vcpu,process_nmi (vcpu); +#ifdef CONFIG_KVM_SMM if (kvm_check_request (KVM_REQ_SMI , vcpu))process_smi (vcpu); +#endif /* * KVM's ABI only allows for one exception to be migrated. Luckily,
@@ -10207,8 +10209,10 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) }if (kvm_check_request (KVM_REQ_STEAL_UPDATE , vcpu))record_steal_time (vcpu); +#ifdef CONFIG_KVM_SMM if (kvm_check_request (KVM_REQ_SMI , vcpu))process_smi (vcpu); +#endif if (kvm_check_request (KVM_REQ_NMI , vcpu))process_nmi (vcpu);if (kvm_check_request (KVM_REQ_PMU , vcpu))
@@ -12565,7 +12569,9 @@ bool kvm_arch_dy_runnable(struct kvm_vcpu *vcpu)return true; if (kvm_test_request(KVM_REQ_NMI, vcpu) || +#ifdef CONFIG_KVM_SMM kvm_test_request (KVM_REQ_SMI , vcpu) || +#endif kvm_test_request(KVM_REQ_EVENT, vcpu)) return true;
Signature · 1 line
2.34.3
PATCH v4 9/23 bug: introduce ASSERT_STRUCT_OFFSET
In reply to Maxim LevitskyASSERT_STRUCT_OFFSET allows to assert during the build of the kernel that a field in a struct have an expected offset.
KVM used to have such macro, but there is almost nothing KVM specific in it so move it to build_bug.h, so that it can be used in other places in KVM.
--- arch/x86/kvm/vmx/vmcs12.h | 5 ++--- include/linux/build_bug.h | 9 +++++++++ 2 files changed, 11 insertions(+), 3 deletions(-)
arch/x86/kvm/vmx/vmcs12.h +2 -3
@@ -208,9 +208,8 @@ struct __packed vmcs12 {/* * For save/restore compatibility, the vmcs12 field offsets must not change. */ -#define CHECK_OFFSET (field, loc) \ - BUILD_BUG_ON_MSG(offsetof(struct vmcs12, field) != (loc), \ - "Offset of " #field " in struct vmcs12 has changed.") +#define CHECK_OFFSET (field, loc) \ + ASSERT_STRUCT_OFFSET(struct vmcs12, field, loc)static inline void vmx_check_vmcs12_offsets (void ) {
include/linux/build_bug.h +9 -0
@@ -77,4 +77,13 @@#define static_assert (expr, ...) __static_assert(expr, ##__VA_ARGS__, #expr)#define __static_assert (expr, msg, ...) _Static_assert(expr, msg) + +/* +* Compile time check that field has an expected offset +*/ +#define ASSERT_STRUCT_OFFSET (type, field, expected_offset) \ + BUILD_BUG_ON_MSG(offsetof(type, field) != (expected_offset), \ + "Offset of " #field " in " #type " has changed.") + +#endif /* _LINUX_BUILD_BUG_H */
Signature · 1 line
2.34.3
PATCH v4 10/23 KVM: x86: emulator: em_sysexit should update ctxt->mode
In reply to Maxim LevitskySYSEXIT is one of the instructions that can change the processor mode, thus ctxt->mode should be updated after it.
Note that this is likely a benign bug, because the only problematic mode change is from 32 bit to 64 bit which can lead to truncation of RIP, and it is not possible to do with sysexit,
since sysexit running in 32 bit mode will be limited to 32 bit version.
--- arch/x86/kvm/emulate.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/kvm/emulate.c +1 -0
@@ -2525,6 +2525,7 @@ static int em_sysexit(struct x86_emulate_ctxt *ctxt) ops->set_segment (ctxt, ss_sel, &ss,0 ,VCPU_SREG_SS ); ctxt->_eip = rdx; + ctxt->mode = usermode; *reg_write (ctxt,VCPU_REGS_RSP ) = rcx;return X86EMUL_CONTINUE ;
Signature · 1 line
2.34.3
PATCH v4 11/23 KVM: x86: emulator: introduce emulator_recalc_and_set_mode
In reply to Maxim LevitskySome instructions update the cpu execution mode, which needs to update the emulation mode.
Extract this code, and make assign_eip_far use it.
assign_eip_far now reads CS, instead of getting it via a parameter, which is ok, because callers always assign CS to the same value before calling this function.
No functional change is intended.
--- arch/x86/kvm/emulate.c | 85 ++++++++++++++++++++++++++++-------------- 1 file changed, 57 insertions(+), 28 deletions(-)
arch/x86/kvm/emulate.c +57 -28
@@ -760,8 +760,7 @@ static int linearize(struct x86_emulate_ctxt *ctxt, ctxt->mode, linear); } -static inline int assign_eip (struct x86_emulate_ctxt *ctxt,ulong dst, -enum x86emul_mode mode) +static inline int assign_eip (struct x86_emulate_ctxt *ctxt,ulong dst) {ulong linear;int rc;
@@ -771,41 +770,71 @@ static inline int assign_eip(struct x86_emulate_ctxt *ctxt, ulong dst,if (ctxt->op_bytes !=sizeof (unsigned long )) addr.ea = dst & ((1UL << (ctxt->op_bytes <<3 )) -1 ); - rc =__linearize (ctxt, addr, &max_size,1 , false, true, mode, &linear); + rc =__linearize (ctxt, addr, &max_size,1 , false, true, ctxt->mode, &linear);if (rc ==X86EMUL_CONTINUE ) ctxt->_eip = addr.ea;return rc; } +static inline int emulator_recalc_and_set_mode (struct x86_emulate_ctxt *ctxt) +{ +u64 efer; +struct desc_struct cs; +u16 selector; +u32 base3; + + ctxt->ops->get_msr (ctxt,MSR_EFER , &efer); + +if (!(ctxt->ops->get_cr (ctxt,0 ) &X86_CR0_PE )) { +/* Real mode. cpu must not have long mode active */ +if (efer &EFER_LMA ) +return X86EMUL_UNHANDLEABLE ; + ctxt->mode =X86EMUL_MODE_REAL ; +return X86EMUL_CONTINUE ; + } + +if (ctxt->eflags &X86_EFLAGS_VM ) { +/* Protected/VM86 mode. cpu must not have long mode active */ +if (efer &EFER_LMA ) +return X86EMUL_UNHANDLEABLE ; + ctxt->mode =X86EMUL_MODE_VM86 ; +return X86EMUL_CONTINUE ; + } + +if (!ctxt->ops->get_segment (ctxt, &selector, &cs, &base3,VCPU_SREG_CS )) +return X86EMUL_UNHANDLEABLE ; + +if (efer &EFER_LMA ) { +if (cs.l) { +/* Proper long mode */ + ctxt->mode =X86EMUL_MODE_PROT64 ; + }else if (cs.d) { +/* 32 bit compatibility mode*/ + ctxt->mode =X86EMUL_MODE_PROT32 ; + }else { + ctxt->mode =X86EMUL_MODE_PROT16 ; + } + }else { +/* Legacy 32 bit / 16 bit mode */ + ctxt->mode = cs.d ?X86EMUL_MODE_PROT32 :X86EMUL_MODE_PROT16 ; + } + +return X86EMUL_CONTINUE ; +} +static inline int assign_eip_near (struct x86_emulate_ctxt *ctxt,ulong dst) { -return assign_eip (ctxt, dst, ctxt->mode); +return assign_eip (ctxt, dst); } -static int assign_eip_far (struct x86_emulate_ctxt *ctxt,ulong dst, -const struct desc_struct *cs_desc) +static int assign_eip_far (struct x86_emulate_ctxt *ctxt,ulong dst) { -enum x86emul_mode mode = ctxt->mode; -int rc; +int rc =emulator_recalc_and_set_mode (ctxt); -#ifdef CONFIG_X86_64 -if (ctxt->mode >=X86EMUL_MODE_PROT16 ) { -if (cs_desc->l) { -u64 efer =0 ; +if (rc !=X86EMUL_CONTINUE ) +return rc; - ctxt->ops->get_msr (ctxt,MSR_EFER , &efer); -if (efer &EFER_LMA ) - mode =X86EMUL_MODE_PROT64 ; - }else - mode =X86EMUL_MODE_PROT32 ;/* temporary value */ - } -#endif -if (mode ==X86EMUL_MODE_PROT16 || mode ==X86EMUL_MODE_PROT32 ) - mode = cs_desc->d ?X86EMUL_MODE_PROT32 :X86EMUL_MODE_PROT16 ; - rc =assign_eip (ctxt, dst, mode); -if (rc ==X86EMUL_CONTINUE ) - ctxt->mode = mode; -return rc; +return assign_eip (ctxt, dst); }static inline int jmp_rel (struct x86_emulate_ctxt *ctxt,int rel)
@@ -2141,7 +2170,7 @@ static int em_jmp_far(struct x86_emulate_ctxt *ctxt)if (rc !=X86EMUL_CONTINUE )return rc; - rc =assign_eip_far (ctxt, ctxt->src.val, &new_desc); + rc =assign_eip_far (ctxt, ctxt->src.val);/* Error handling is not implemented. */ if (rc !=X86EMUL_CONTINUE )return X86EMUL_UNHANDLEABLE ;
@@ -2219,7 +2248,7 @@ static int em_ret_far(struct x86_emulate_ctxt *ctxt) &new_desc);if (rc !=X86EMUL_CONTINUE )return rc; - rc =assign_eip_far (ctxt, eip, &new_desc); + rc =assign_eip_far (ctxt, eip);/* Error handling is not implemented. */ if (rc !=X86EMUL_CONTINUE )return X86EMUL_UNHANDLEABLE ;
@@ -3119,7 +3148,7 @@ static int em_call_far(struct x86_emulate_ctxt *ctxt)if (rc !=X86EMUL_CONTINUE )return rc; - rc =assign_eip_far (ctxt, ctxt->src.val, &new_desc); + rc =assign_eip_far (ctxt, ctxt->src.val);if (rc !=X86EMUL_CONTINUE ) goto fail;
Signature · 1 line
2.34.3
PATCH v4 12/23 KVM: x86: emulator: update the emulation mode after rsm
In reply to Maxim LevitskyUpdate the emulation mode after RSM so that RIP will be correctly written back, because the RSM instruction can switch the CPU mode from 32 bit (or less) to 64 bit.
This fixes a guest crash in case the #SMI is received while the guest runs a code from an address > 32 bit.
--- arch/x86/kvm/emulate.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/emulate.c +1 -1
@@ -2315,7 +2315,7 @@ static int em_rsm(struct x86_emulate_ctxt *ctxt)if (ctxt->ops->leave_smm (ctxt)) ctxt->ops->triple_fault (ctxt); -return X86EMUL_CONTINUE ; +return emulator_recalc_and_set_mode (ctxt); } static void
Signature · 1 line
2.34.3
PATCH v4 13/23 KVM: x86: emulator: update the emulation mode after CR0 write
In reply to Maxim LevitskyUpdate the emulation mode when handling writes to CR0, because toggling CR0.PE switches between Real and Protected Mode, and toggling CR0.PG when EFER.LME=1 switches between Long and Protected Mode.
This is likely a benign bug because there is no writeback of state, other than the RIP increment, and when toggling CR0.PE, the CPU has to execute code from a very low memory address.
--- arch/x86/kvm/emulate.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)
arch/x86/kvm/emulate.c +15 -1
@@ -3290,11 +3290,25 @@ static int em_movbe(struct x86_emulate_ctxt *ctxt)static int em_cr_write (struct x86_emulate_ctxt *ctxt) { -if (ctxt->ops->set_cr (ctxt, ctxt->modrm_reg, ctxt->src.val)) +int cr_num = ctxt->modrm_reg; +int r; + +if (ctxt->ops->set_cr (ctxt, cr_num, ctxt->src.val))return emulate_gp (ctxt,0 );/* Disable writeback. */ ctxt->dst.type =OP_NONE ; + +if (cr_num ==0 ) { +/* +* CR0 write might have updated CR0.PE and/or CR0.PG +* which can affect the cpu's execution mode. +*/ + r =emulator_recalc_and_set_mode (ctxt); +if (r !=X86EMUL_CONTINUE ) +return r; + } +return X86EMUL_CONTINUE ; }
Signature · 1 line
2.34.3
PATCH v4 14/23 KVM: x86: smm: number of GPRs in the SMRAM image depends on the image format
In reply to Maxim LevitskyOn 64 bit host, if the guest doesn't have X86_FEATURE_LM, KVM will access 16 gprs to 32-bit smram image, causing out-ouf-bound ram access.
On 32 bit host, the rsm_load_state_64/enter_smm_save_state_64 is compiled out, thus access overflow can't happen.
--- arch/x86/kvm/emulate.c | 1 + arch/x86/kvm/smm.c | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-)
arch/x86/kvm/emulate.c +1 -0
@@ -2307,6 +2307,7 @@ static int em_lseg(struct x86_emulate_ctxt *ctxt)return rc; } +static int em_rsm (struct x86_emulate_ctxt *ctxt) {if ((ctxt->ops->get_hflags (ctxt) &X86EMUL_SMM_MASK ) ==0 )
arch/x86/kvm/smm.c +2 -2
@@ -382,7 +382,7 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt, ctxt->eflags =GET_SMSTATE (u32, smstate,0x7ff4 ) |X86_EFLAGS_FIXED ; ctxt->_eip =GET_SMSTATE (u32, smstate,0x7ff0 ); -for (i =0 ; i <NR_EMULATOR_GPRS ; i++) +for (i =0 ; i <8 ; i++) *reg_write (ctxt, i) =GET_SMSTATE (u32, smstate,0x7fd0 + i *4 ); val =GET_SMSTATE (u32, smstate,0x7fcc );
@@ -438,7 +438,7 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt,u64 val, cr0, cr3, cr4;int i, r; -for (i =0 ; i <NR_EMULATOR_GPRS ; i++) +for (i =0 ; i <16 ; i++) *reg_write (ctxt, i) =GET_SMSTATE (u64, smstate,0x7ff8 - i *8 ); ctxt->_eip =GET_SMSTATE (u64, smstate,0x7f78 );
Signature · 1 line
2.34.3
PATCH v4 15/23 KVM: x86: smm: check for failures on smm entry
In reply to Maxim LevitskyIn the rare case of the failure on SMM entry, the KVM should at least terminate the VM instead of going south.
--- arch/x86/kvm/smm.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-)
arch/x86/kvm/smm.c +15 -4
@@ -211,11 +211,17 @@ void enter_smm(struct kvm_vcpu *vcpu)* Give enter_smm() a chance to make ISA-specific changes to the vCPU * state (e.g. leave guest mode) after we've saved the state into the * SMM state-save area. +* +* Kill the VM in the unlikely case of failure, because the VM +* can be in undefined state in this case. */ -static_call (kvm_x86_enter_smm)(vcpu, buf); +if (static_call (kvm_x86_enter_smm)(vcpu, buf)) + goto error;kvm_smm_changed (vcpu, true); -kvm_vcpu_write_guest (vcpu, vcpu->arch.smbase +0xfe00 , buf,sizeof (buf)); + +if (kvm_vcpu_write_guest (vcpu, vcpu->arch.smbase +0xfe00 , buf,sizeof (buf))) + goto error;if (static_call (kvm_x86_get_nmi_mask)(vcpu)) vcpu->arch.hflags |=HF_SMM_INSIDE_NMI_MASK ;
@@ -235,7 +241,8 @@ void enter_smm(struct kvm_vcpu *vcpu) dt.address = dt.size =0 ;static_call (kvm_x86_set_idt)(vcpu, &dt); -kvm_set_dr (vcpu,7 ,DR7_FIXED_1 ); +if (WARN_ON_ONCE (kvm_set_dr (vcpu,7 ,DR7_FIXED_1 ))) + goto error; cs.selector = (vcpu->arch.smbase >>4 ) &0xffff ; cs.base = vcpu->arch.smbase;
@@ -264,11 +271,15 @@ void enter_smm(struct kvm_vcpu *vcpu)#ifdef CONFIG_X86_64 if (guest_cpuid_has (vcpu,X86_FEATURE_LM )) -static_call (kvm_x86_set_efer)(vcpu,0 ); +if (static_call (kvm_x86_set_efer)(vcpu,0 )) + goto error;#endif kvm_update_cpuid_runtime (vcpu);kvm_mmu_reset_context (vcpu); +return ; +error: +kvm_vm_dead (vcpu->kvm); }static void rsm_set_desc_flags (struct kvm_segment *desc,u32 flags)
Signature · 1 line
2.34.3
PATCH v4 16/23 KVM: x86: smm: add structs for KVM's smram layout
In reply to Maxim LevitskyAdd structs that will be used to define and read/write the KVM's SMRAM layout, instead of reading/writing to raw offsets.
Also document the differences between KVM's SMRAM layout and SMRAM layout that is used by real Intel/AMD cpus.
--- arch/x86/kvm/smm.c | 94 +++++++++++++++++++++++++++++++++ arch/x86/kvm/smm.h | 127 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 221 insertions(+)
arch/x86/kvm/smm.c +94 -0
@@ -8,6 +8,97 @@#include "cpuid.h" #include "trace.h" +#define CHECK_SMRAM32_OFFSET (field, offset) \ + ASSERT_STRUCT_OFFSET(struct kvm_smram_state_32, field, offset - 0xFE00) + +#define CHECK_SMRAM64_OFFSET (field, offset) \ + ASSERT_STRUCT_OFFSET(struct kvm_smram_state_64, field, offset - 0xFE00) + +static void check_smram_offsets (void ) +{ +/* 32 bit SMRAM image */ +CHECK_SMRAM32_OFFSET (reserved1,0xFE00 ); +CHECK_SMRAM32_OFFSET (smbase,0xFEF8 ); +CHECK_SMRAM32_OFFSET (smm_revision,0xFEFC ); +CHECK_SMRAM32_OFFSET (reserved2,0xFF00 ); +CHECK_SMRAM32_OFFSET (cr4,0xFF14 ); +CHECK_SMRAM32_OFFSET (reserved3,0xFF18 ); +CHECK_SMRAM32_OFFSET (ds,0xFF2C ); +CHECK_SMRAM32_OFFSET (fs,0xFF38 ); +CHECK_SMRAM32_OFFSET (gs,0xFF44 ); +CHECK_SMRAM32_OFFSET (idtr,0xFF50 ); +CHECK_SMRAM32_OFFSET (tr,0xFF5C ); +CHECK_SMRAM32_OFFSET (gdtr,0xFF6C ); +CHECK_SMRAM32_OFFSET (ldtr,0xFF78 ); +CHECK_SMRAM32_OFFSET (es,0xFF84 ); +CHECK_SMRAM32_OFFSET (cs,0xFF90 ); +CHECK_SMRAM32_OFFSET (ss,0xFF9C ); +CHECK_SMRAM32_OFFSET (es_sel,0xFFA8 ); +CHECK_SMRAM32_OFFSET (cs_sel,0xFFAC ); +CHECK_SMRAM32_OFFSET (ss_sel,0xFFB0 ); +CHECK_SMRAM32_OFFSET (ds_sel,0xFFB4 ); +CHECK_SMRAM32_OFFSET (fs_sel,0xFFB8 ); +CHECK_SMRAM32_OFFSET (gs_sel,0xFFBC ); +CHECK_SMRAM32_OFFSET (ldtr_sel,0xFFC0 ); +CHECK_SMRAM32_OFFSET (tr_sel,0xFFC4 ); +CHECK_SMRAM32_OFFSET (dr7,0xFFC8 ); +CHECK_SMRAM32_OFFSET (dr6,0xFFCC ); +CHECK_SMRAM32_OFFSET (gprs,0xFFD0 ); +CHECK_SMRAM32_OFFSET (eip,0xFFF0 ); +CHECK_SMRAM32_OFFSET (eflags,0xFFF4 ); +CHECK_SMRAM32_OFFSET (cr3,0xFFF8 ); +CHECK_SMRAM32_OFFSET (cr0,0xFFFC ); + +/* 64 bit SMRAM image */ +CHECK_SMRAM64_OFFSET (es,0xFE00 ); +CHECK_SMRAM64_OFFSET (cs,0xFE10 ); +CHECK_SMRAM64_OFFSET (ss,0xFE20 ); +CHECK_SMRAM64_OFFSET (ds,0xFE30 ); +CHECK_SMRAM64_OFFSET (fs,0xFE40 ); +CHECK_SMRAM64_OFFSET (gs,0xFE50 ); +CHECK_SMRAM64_OFFSET (gdtr,0xFE60 ); +CHECK_SMRAM64_OFFSET (ldtr,0xFE70 ); +CHECK_SMRAM64_OFFSET (idtr,0xFE80 ); +CHECK_SMRAM64_OFFSET (tr,0xFE90 ); +CHECK_SMRAM64_OFFSET (io_restart_rip,0xFEA0 ); +CHECK_SMRAM64_OFFSET (io_restart_rcx,0xFEA8 ); +CHECK_SMRAM64_OFFSET (io_restart_rsi,0xFEB0 ); +CHECK_SMRAM64_OFFSET (io_restart_rdi,0xFEB8 ); +CHECK_SMRAM64_OFFSET (io_restart_dword,0xFEC0 ); +CHECK_SMRAM64_OFFSET (reserved1,0xFEC4 ); +CHECK_SMRAM64_OFFSET (io_inst_restart,0xFEC8 ); +CHECK_SMRAM64_OFFSET (auto_hlt_restart,0xFEC9 ); +CHECK_SMRAM64_OFFSET (reserved2,0xFECA ); +CHECK_SMRAM64_OFFSET (efer,0xFED0 ); +CHECK_SMRAM64_OFFSET (svm_guest_flag,0xFED8 ); +CHECK_SMRAM64_OFFSET (svm_guest_vmcb_gpa,0xFEE0 ); +CHECK_SMRAM64_OFFSET (svm_guest_virtual_int,0xFEE8 ); +CHECK_SMRAM64_OFFSET (reserved3,0xFEF0 ); +CHECK_SMRAM64_OFFSET (smm_revison,0xFEFC ); +CHECK_SMRAM64_OFFSET (smbase,0xFF00 ); +CHECK_SMRAM64_OFFSET (reserved4,0xFF04 ); +CHECK_SMRAM64_OFFSET (ssp,0xFF18 ); +CHECK_SMRAM64_OFFSET (svm_guest_pat,0xFF20 ); +CHECK_SMRAM64_OFFSET (svm_host_efer,0xFF28 ); +CHECK_SMRAM64_OFFSET (svm_host_cr4,0xFF30 ); +CHECK_SMRAM64_OFFSET (svm_host_cr3,0xFF38 ); +CHECK_SMRAM64_OFFSET (svm_host_cr0,0xFF40 ); +CHECK_SMRAM64_OFFSET (cr4,0xFF48 ); +CHECK_SMRAM64_OFFSET (cr3,0xFF50 ); +CHECK_SMRAM64_OFFSET (cr0,0xFF58 ); +CHECK_SMRAM64_OFFSET (dr7,0xFF60 ); +CHECK_SMRAM64_OFFSET (dr6,0xFF68 ); +CHECK_SMRAM64_OFFSET (rflags,0xFF70 ); +CHECK_SMRAM64_OFFSET (rip,0xFF78 ); +CHECK_SMRAM64_OFFSET (gprs,0xFF80 ); + +BUILD_BUG_ON (sizeof (union kvm_smram ) !=512 ); +} + +#undef CHECK_SMRAM64_OFFSET +#undef CHECK_SMRAM32_OFFSET + +void kvm_smm_changed (struct kvm_vcpu *vcpu,bool entering_smm) {trace_kvm_smm_transition (vcpu->vcpu_id, vcpu->arch.smbase, entering_smm);
@@ -199,6 +290,8 @@ void enter_smm(struct kvm_vcpu *vcpu)unsigned long cr0;char buf[512 ]; +check_smram_offsets (); +memset (buf,0 ,512 );#ifdef CONFIG_X86_64 if (guest_cpuid_has (vcpu,X86_FEATURE_LM ))
@@ -449,6 +542,7 @@ static int rsm_load_state_64(struct x86_emulate_ctxt *ctxt,u64 val, cr0, cr3, cr4;int i, r; +for (i =0 ; i <16 ; i++) *reg_write (ctxt, i) =GET_SMSTATE (u64, smstate,0x7ff8 - i *8 );
arch/x86/kvm/smm.h +127 -0
139 lines not on this page · raw message
Signature · 1 line
2.34.3
PATCH v4 17/23 KVM: x86: smm: use smram structs in the common code
In reply to Maxim LevitskyUse kvm_smram union instad of raw arrays in the common smm code.
--- arch/x86/include/asm/kvm_host.h | 5 +++-- arch/x86/kvm/smm.c | 27 ++++++++++++++------------- arch/x86/kvm/svm/svm.c | 8 ++++++-- arch/x86/kvm/vmx/vmx.c | 4 ++-- 4 files changed, 25 insertions(+), 19 deletions(-)
arch/x86/include/asm/kvm_host.h +3 -2
@@ -206,6 +206,7 @@ typedef enum exit_fastpath_completion fastpath_t;struct x86_emulate_ctxt ;struct x86_exception ; +union kvm_smram ;enum x86_intercept ;enum x86_intercept_stage ;
@@ -1611,8 +1612,8 @@ struct kvm_x86_ops {#ifdef CONFIG_KVM_SMM int (*smi_allowed)(struct kvm_vcpu *vcpu,bool for_injection); -int (*enter_smm)(struct kvm_vcpu *vcpu,char *smstate); -int (*leave_smm)(struct kvm_vcpu *vcpu,const char *smstate); +int (*enter_smm)(struct kvm_vcpu *vcpu,union kvm_smram *smram); +int (*leave_smm)(struct kvm_vcpu *vcpu,const union kvm_smram *smram);void (*enable_smi_window)(struct kvm_vcpu *vcpu);#endif
arch/x86/kvm/smm.c +14 -13
@@ -288,17 +288,18 @@ void enter_smm(struct kvm_vcpu *vcpu)struct kvm_segment cs, ds;struct desc_ptr dt;unsigned long cr0; -char buf[512 ]; +union kvm_smram smram;check_smram_offsets (); -memset (buf,0 ,512 ); +memset (smram.bytes,0 ,sizeof (smram.bytes)); +#ifdef CONFIG_X86_64 if (guest_cpuid_has (vcpu,X86_FEATURE_LM )) -enter_smm_save_state_64 (vcpu, buf); +enter_smm_save_state_64 (vcpu, smram.bytes); else#endif -enter_smm_save_state_32 (vcpu, buf); +enter_smm_save_state_32 (vcpu, smram.bytes);/* * Give enter_smm() a chance to make ISA-specific changes to the vCPU
@@ -308,12 +309,12 @@ void enter_smm(struct kvm_vcpu *vcpu)* Kill the VM in the unlikely case of failure, because the VM * can be in undefined state in this case. */ -if (static_call (kvm_x86_enter_smm)(vcpu, buf)) +if (static_call (kvm_x86_enter_smm)(vcpu, &smram)) goto error;kvm_smm_changed (vcpu, true); -if (kvm_vcpu_write_guest (vcpu, vcpu->arch.smbase +0xfe00 , buf,sizeof (buf))) +if (kvm_vcpu_write_guest (vcpu, vcpu->arch.smbase +0xfe00 , &smram,sizeof (smram))) goto error;if (static_call (kvm_x86_get_nmi_mask)(vcpu))
@@ -473,7 +474,7 @@ static int rsm_enter_protected_mode(struct kvm_vcpu *vcpu, }static int rsm_load_state_32 (struct x86_emulate_ctxt *ctxt, -const char *smstate) +u8 *smstate) {struct kvm_vcpu *vcpu = ctxt->vcpu;struct kvm_segment desc;
@@ -534,7 +535,7 @@ static int rsm_load_state_32(struct x86_emulate_ctxt *ctxt,#ifdef CONFIG_X86_64 static int rsm_load_state_64 (struct x86_emulate_ctxt *ctxt, -const char *smstate) +u8 *smstate) {struct kvm_vcpu *vcpu = ctxt->vcpu;struct kvm_segment desc;
@@ -606,13 +607,13 @@ int emulator_leave_smm(struct x86_emulate_ctxt *ctxt) {struct kvm_vcpu *vcpu = ctxt->vcpu;unsigned long cr0, cr4, efer; -char buf[512 ]; +union kvm_smram smram;u64 smbase;int ret; smbase = vcpu->arch.smbase; - ret =kvm_vcpu_read_guest (vcpu, smbase +0xfe00 , buf,sizeof (buf)); + ret =kvm_vcpu_read_guest (vcpu, smbase +0xfe00 , smram.bytes,sizeof (smram));if (ret <0 )return X86EMUL_UNHANDLEABLE ;
@@ -666,13 +667,13 @@ int emulator_leave_smm(struct x86_emulate_ctxt *ctxt)* state (e.g. enter guest mode) before loading state from the SMM * state-save area. */ -if (static_call (kvm_x86_leave_smm)(vcpu, buf)) +if (static_call (kvm_x86_leave_smm)(vcpu, &smram))return X86EMUL_UNHANDLEABLE ;#ifdef CONFIG_X86_64 if (guest_cpuid_has (vcpu,X86_FEATURE_LM )) -return rsm_load_state_64 (ctxt, buf); +return rsm_load_state_64 (ctxt, smram.bytes); else#endif -return rsm_load_state_32 (ctxt, buf); +return rsm_load_state_32 (ctxt, smram.bytes); }
arch/x86/kvm/svm/svm.c +6 -2
@@ -4436,12 +4436,14 @@ static int svm_smi_allowed(struct kvm_vcpu *vcpu, bool for_injection)return 1 ; } -static int svm_enter_smm (struct kvm_vcpu *vcpu,char *smstate) +static int svm_enter_smm (struct kvm_vcpu *vcpu,union kvm_smram *smram) {struct vcpu_svm *svm =to_svm (vcpu);struct kvm_host_map map_save;int ret; +char *smstate = (char *)smram; +if (!is_guest_mode (vcpu))return 0 ;
@@ -4483,7 +4485,7 @@ static int svm_enter_smm(struct kvm_vcpu *vcpu, char *smstate)return 0 ; } -static int svm_leave_smm (struct kvm_vcpu *vcpu,const char *smstate) +static int svm_leave_smm (struct kvm_vcpu *vcpu,const union kvm_smram *smram) {struct vcpu_svm *svm =to_svm (vcpu);struct kvm_host_map map, map_save;
@@ -4491,6 +4493,8 @@ static int svm_leave_smm(struct kvm_vcpu *vcpu, const char *smstate)struct vmcb *vmcb12;int ret; +const char *smstate = (const char *)smram; +if (!guest_cpuid_has (vcpu,X86_FEATURE_LM ))return 0 ;
arch/x86/kvm/vmx/vmx.c +2 -2
@@ -7914,7 +7914,7 @@ static int vmx_smi_allowed(struct kvm_vcpu *vcpu, bool for_injection)return !is_smm (vcpu); } -static int vmx_enter_smm (struct kvm_vcpu *vcpu,char *smstate) +static int vmx_enter_smm (struct kvm_vcpu *vcpu,union kvm_smram *smram) {struct vcpu_vmx *vmx =to_vmx (vcpu);
@@ -7935,7 +7935,7 @@ static int vmx_enter_smm(struct kvm_vcpu *vcpu, char *smstate)return 0 ; } -static int vmx_leave_smm (struct kvm_vcpu *vcpu,const char *smstate) +static int vmx_leave_smm (struct kvm_vcpu *vcpu,const union kvm_smram *smram) {struct vcpu_vmx *vmx =to_vmx (vcpu);int ret;
Signature · 1 line
2.34.3