Deal with shadow interrupts after emulated instructions
cover Deal with shadow interrupts after emulated instructions
Same story, more avi's comments merged.
PATCH 1/2 replace drop_interrupt_shadow by set_interrupt_shadow
This patch replaces drop_interrupt_shadow with the more general set_interrupt_shadow, that can either drop or raise it, depending on its parameter.
--- arch/x86/include/asm/kvm_host.h | 3 +- arch/x86/include/asm/kvm_x86_emulate.h | 3 ++ arch/x86/kvm/svm.c | 32 +++++++++++++++----- arch/x86/kvm/vmx.c | 49 +++++++++++++++++++++---------- arch/x86/kvm/x86.c | 2 +- 5 files changed, 63 insertions(+), 26 deletions(-)
arch/x86/include/asm/kvm_host.h +2 -1
@@ -510,6 +510,8 @@ struct kvm_x86_ops {void (*run)(struct kvm_vcpu *vcpu,struct kvm_run *run);int (*handle_exit)(struct kvm_run *run,struct kvm_vcpu *vcpu);void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu); +void (*set_interrupt_shadow)(struct kvm_vcpu *vcpu,int mask); +u32 (*get_interrupt_shadow)(struct kvm_vcpu *vcpu,int mask);void (*patch_hypercall)(struct kvm_vcpu *vcpu,unsigned char *hypercall_addr);void (*set_irq)(struct kvm_vcpu *vcpu,int vec);
@@ -521,7 +523,6 @@ struct kvm_x86_ops {void (*enable_nmi_window)(struct kvm_vcpu *vcpu);void (*enable_irq_window)(struct kvm_vcpu *vcpu);void (*update_cr8_intercept)(struct kvm_vcpu *vcpu,int tpr,int irr); -void (*drop_interrupt_shadow)(struct kvm_vcpu *vcpu);int (*set_tss_addr)(struct kvm *kvm,unsigned int addr);int (*get_tdp_level)(void );u64 (*get_mt_mask)(struct kvm_vcpu *vcpu,gfn_t gfn,bool is_mmio);
arch/x86/include/asm/kvm_x86_emulate.h +3 -0
@@ -143,6 +143,9 @@ struct decode_cache {struct fetch_cache fetch; }; +#define X86_SHADOW_INT_MOV_SS 1 +#define X86_SHADOW_INT_STI 2 +struct x86_emulate_ctxt {/* Register state before/after emulation. */ struct kvm_vcpu *vcpu;
arch/x86/kvm/svm.c +24 -8
@@ -202,6 +202,27 @@ static int is_external_interrupt(u32 info)return info == (SVM_EVTINJ_VALID |SVM_EVTINJ_TYPE_INTR ); } +static u32 svm_get_interrupt_shadow (struct kvm_vcpu *vcpu,int mask) +{ +struct vcpu_svm *svm =to_svm (vcpu); +u32 ret =0 ; + +if (svm->vmcb->control.int_state &SVM_INTERRUPT_SHADOW_MASK ) + ret |=X86_SHADOW_INT_STI |X86_SHADOW_INT_MOV_SS ; +return ret & mask; +} + +static void svm_set_interrupt_shadow (struct kvm_vcpu *vcpu,int mask) +{ +struct vcpu_svm *svm =to_svm (vcpu); + +if (mask ==0 ) + svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK ; +else + svm->vmcb->control.int_state |=SVM_INTERRUPT_SHADOW_MASK ; + +} +static void skip_emulated_instruction (struct kvm_vcpu *vcpu) {struct vcpu_svm *svm =to_svm (vcpu);
@@ -215,7 +236,7 @@ static void skip_emulated_instruction(struct kvm_vcpu *vcpu) __func__, kvm_rip_read(vcpu), svm->next_rip);kvm_rip_write (vcpu, svm->next_rip); - svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK ; +svm_set_interrupt_shadow (vcpu,0 ); }static int has_svm (void )
@@ -2229,12 +2250,6 @@ static void pre_svm_run(struct vcpu_svm *svm)new_asid (svm, svm_data); } -static void svm_drop_interrupt_shadow (struct kvm_vcpu *vcpu) -{ -struct vcpu_svm *svm =to_svm (vcpu); - svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK ; -} -static void svm_inject_nmi (struct kvm_vcpu *vcpu) {struct vcpu_svm *svm =to_svm (vcpu);
@@ -2637,6 +2652,8 @@ static struct kvm_x86_ops svm_x86_ops = { .run = svm_vcpu_run, .handle_exit = handle_exit, .skip_emulated_instruction = skip_emulated_instruction, + .set_interrupt_shadow = svm_set_interrupt_shadow, + .get_interrupt_shadow = svm_get_interrupt_shadow, .patch_hypercall = svm_patch_hypercall, .set_irq = svm_set_irq, .set_nmi = svm_inject_nmi,
@@ -2646,7 +2663,6 @@ static struct kvm_x86_ops svm_x86_ops = { .enable_nmi_window = enable_nmi_window, .enable_irq_window = enable_irq_window, .update_cr8_intercept = update_cr8_intercept, - .drop_interrupt_shadow = svm_drop_interrupt_shadow, .set_tss_addr = svm_set_tss_addr, .get_tdp_level = get_npt_level,
arch/x86/kvm/vmx.c +33 -16
81 lines not on this page · raw message
arch/x86/kvm/x86.c +1 -1
@@ -3161,7 +3161,7 @@ static void inject_pending_irq(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) kvm_run->request_interrupt_window;if (vcpu->guest_debug &KVM_GUESTDBG_SINGLESTEP ) - kvm_x86_ops->drop_interrupt_shadow (vcpu); + kvm_x86_ops->set_interrupt_shadow (vcpu,0 );inject_irq (vcpu);
Signature · 1 line
1.5.6.6
PATCH 2/2 deal with interrupt shadow state for emulated instruction
we currently unblock shadow interrupt state when we skip an instruction, but failing to do so when we actually emulate one. This blocks interrupts in key instruction blocks, in particular sti; hlt; sequences
If the instruction emulated is an sti, we have to block shadow interrupts. The same goes for mov ss. pop ss also needs it, but we don't currently emulate it.
Without this patch, I cannot boot gpxe option roms at vmx machines. This is described at https://bugzilla.redhat.com/show_bug.cgi?id=494469
--- arch/x86/include/asm/kvm_x86_emulate.h | 3 +++ arch/x86/kvm/x86.c | 6 +++++- arch/x86/kvm/x86_emulate.c | 20 ++++++++++++++++++++ 3 files changed, 28 insertions(+), 1 deletions(-)
arch/x86/include/asm/kvm_x86_emulate.h +3 -0
@@ -155,6 +155,9 @@ struct x86_emulate_ctxt {int mode;u32 cs_base; +/* interruptibility state, as a result of execution of STI or MOV SS */ +int interruptibility; +/* decode cache */ struct decode_cache decode; };
arch/x86/kvm/x86.c +5 -1
@@ -2362,7 +2362,7 @@ int emulate_instruction(struct kvm_vcpu *vcpu,u16 error_code, int emulation_type) { - int r; + int r, shadow_mask;struct decode_cache *c;kvm_clear_exception_queue (vcpu);
@@ -2416,6 +2416,10 @@ int emulate_instruction(struct kvm_vcpu *vcpu, } r =x86_emulate_insn (&vcpu->arch.emulate_ctxt, &emulate_ops); + shadow_mask = vcpu->arch.emulate_ctxt.interruptibility; + +if (r ==0 ) + kvm_x86_ops->set_interrupt_shadow (vcpu, shadow_mask);if (vcpu->arch.pio.string)return EMULATE_DO_MMIO ;
arch/x86/kvm/x86_emulate.c +20 -0
@@ -1361,6 +1361,20 @@ static inline int writeback(struct x86_emulate_ctxt *ctxt,return 0 ; } +void toggle_interruptibility (struct x86_emulate_ctxt *ctxt,u32 mask) +{ +u32 int_shadow = kvm_x86_ops->get_interrupt_shadow (ctxt->vcpu, mask); +/* +* an sti; sti; sequence only disable interrupts for the first +* instruction. So, if the last instruction, be it emulated or +* not, left the system with the INT_STI flag enabled, it +* means that the last instruction is an sti. We should not +* leave the flag on in this case. The same goes for mov ss +*/ +if (!(int_shadow & mask)) + ctxt->interruptibility = mask; +} +int x86_emulate_insn (struct x86_emulate_ctxt *ctxt,struct x86_emulate_ops *ops) {
@@ -1372,6 +1386,8 @@ x86_emulate_insn(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)int io_dir_in;int rc =0 ; + ctxt->interruptibility =0 ; +/* Shadow copy of register state. Committed on successful emulation. * NOTE: we can copy them from vcpu as x86_decode_insn() doesn't * modify them.
@@ -1618,6 +1634,9 @@ special_insn:int err; sel = c->src.val; +if (c->modrm_reg ==VCPU_SREG_SS ) +toggle_interruptibility (ctxt,X86_SHADOW_INT_MOV_SS ); +if (c->modrm_reg <=5 ) { type_bits = (c->modrm_reg ==1 ) ?9 :1 ; err = kvm_load_segment_descriptor(ctxt->vcpu, sel,
@@ -1847,6 +1866,7 @@ special_insn: c->dst.type =OP_NONE ;/* Disable writeback. */ break ;case 0xfb :/* sti */ +toggle_interruptibility (ctxt,X86_SHADOW_INT_STI ); ctxt->eflags |=X86_EFLAGS_IF ; c->dst.type =OP_NONE ;/* Disable writeback. */ break ;
Signature · 1 line
1.5.6.6
Avi Kivity
AppliedQuoted 4 lines · Glauber Costa
Same story, more avi's comments merged.
Applied, thanks.
Signature · 1 line
Do not meddle in the internals of kernels, for they are subtle and quick to panic.