1 files changed, 102 insertions, 11 deletions

diff --git a/drivers/kvm/svm.c b/drivers/kvm/svm.c
index fa0428735717..ccc06b1b91b5 100644
--- a/drivers/kvm/svm.c
+++ b/drivers/kvm/svm.c
@@ -235,6 +235,8 @@ static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
 
         vcpu->rip = vcpu->svm->vmcb->save.rip = vcpu->svm->next_rip;
         vcpu->svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK;
+
+        vcpu->interrupt_window_open = 1;
 }
 
 static int has_svm(void)
@@ -495,7 +497,6 @@ static void init_vmcb(struct vmcb *vmcb)
                 /*              (1ULL << INTERCEPT_SELECTIVE_CR0) | */
                                 (1ULL << INTERCEPT_CPUID) |
                                 (1ULL << INTERCEPT_HLT) |
-                                (1ULL << INTERCEPT_INVLPG) |
                                 (1ULL << INTERCEPT_INVLPGA) |
                                 (1ULL << INTERCEPT_IOIO_PROT) |
                                 (1ULL << INTERCEPT_MSR_PROT) |
@@ -700,6 +701,10 @@ static void svm_set_gdt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
         vcpu->svm->vmcb->save.gdtr.base = dt->base ;
 }
 
+static void svm_decache_cr0_cr4_guest_bits(struct kvm_vcpu *vcpu)
+{
+}
+
 static void svm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
 {
 #ifdef CONFIG_X86_64
@@ -847,6 +852,7 @@ static int pf_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         u64 fault_address;
         u32 error_code;
         enum emulation_result er;
+        int r;
 
         if (is_external_interrupt(exit_int_info))
                 push_irq(vcpu, exit_int_info & SVM_EVTINJ_VEC_MASK);
@@ -855,7 +861,12 @@ static int pf_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
         fault_address  = vcpu->svm->vmcb->control.exit_info_2;
         error_code = vcpu->svm->vmcb->control.exit_info_1;
-        if (!vcpu->mmu.page_fault(vcpu, fault_address, error_code)) {
+        r = kvm_mmu_page_fault(vcpu, fault_address, error_code);
+        if (r < 0) {
+                spin_unlock(&vcpu->kvm->lock);
+                return r;
+        }
+        if (!r) {
                 spin_unlock(&vcpu->kvm->lock);
                 return 1;
         }
@@ -1031,10 +1042,11 @@ static int halt_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
         vcpu->svm->next_rip = vcpu->svm->vmcb->save.rip + 1;
         skip_emulated_instruction(vcpu);
-        if (vcpu->irq_summary && (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF))
+        if (vcpu->irq_summary)
                 return 1;
 
         kvm_run->exit_reason = KVM_EXIT_HLT;
+        ++kvm_stat.halt_exits;
         return 0;
 }
 
@@ -1186,6 +1198,23 @@ static int msr_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 return rdmsr_interception(vcpu, kvm_run);
 }
 
+static int interrupt_window_interception(struct kvm_vcpu *vcpu,
+                                   struct kvm_run *kvm_run)
+{
+        /*
+         * If the user space waits to inject interrupts, exit as soon as
+         * possible
+         */
+        if (kvm_run->request_interrupt_window &&
+            !vcpu->irq_summary) {
+                ++kvm_stat.irq_window_exits;
+                kvm_run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
+                return 0;
+        }
+
+        return 1;
+}
+
 static int (*svm_exit_handlers[])(struct kvm_vcpu *vcpu,
                                       struct kvm_run *kvm_run) = {
         [SVM_EXIT_READ_CR0]                     = emulate_on_interception,
@@ -1210,6 +1239,7 @@ static int (*svm_exit_handlers[])(struct kvm_vcpu *vcpu,
         [SVM_EXIT_NMI]                          = nop_on_interception,
         [SVM_EXIT_SMI]                          = nop_on_interception,
         [SVM_EXIT_INIT]                         = nop_on_interception,
+        [SVM_EXIT_VINTR]                        = interrupt_window_interception,
         /* [SVM_EXIT_CR0_SEL_WRITE]             = emulate_on_interception, */
         [SVM_EXIT_CPUID]                        = cpuid_interception,
         [SVM_EXIT_HLT]                          = halt_interception,
@@ -1278,15 +1308,11 @@ static void pre_svm_run(struct kvm_vcpu *vcpu)
 }
 
 
-static inline void kvm_try_inject_irq(struct kvm_vcpu *vcpu)
+static inline void kvm_do_inject_irq(struct kvm_vcpu *vcpu)
 {
         struct vmcb_control_area *control;
 
-        if (!vcpu->irq_summary)
-                return;
-
         control = &vcpu->svm->vmcb->control;
-
         control->int_vector = pop_irq(vcpu);
         control->int_ctl &= ~V_INTR_PRIO_MASK;
         control->int_ctl |= V_IRQ_MASK |
@@ -1301,6 +1327,59 @@ static void kvm_reput_irq(struct kvm_vcpu *vcpu)
                 control->int_ctl &= ~V_IRQ_MASK;
                 push_irq(vcpu, control->int_vector);
         }
+
+        vcpu->interrupt_window_open =
+                !(control->int_state & SVM_INTERRUPT_SHADOW_MASK);
+}
+
+static void do_interrupt_requests(struct kvm_vcpu *vcpu,
+                                       struct kvm_run *kvm_run)
+{
+        struct vmcb_control_area *control = &vcpu->svm->vmcb->control;
+
+        vcpu->interrupt_window_open =
+                (!(control->int_state & SVM_INTERRUPT_SHADOW_MASK) &&
+                 (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF));
+
+        if (vcpu->interrupt_window_open && vcpu->irq_summary)
+                /*
+                 * If interrupts enabled, and not blocked by sti or mov ss. Good.
+                 */
+                kvm_do_inject_irq(vcpu);
+
+        /*
+         * Interrupts blocked.  Wait for unblock.
+         */
+        if (!vcpu->interrupt_window_open &&
+            (vcpu->irq_summary || kvm_run->request_interrupt_window)) {
+                control->intercept |= 1ULL << INTERCEPT_VINTR;
+        } else
+                control->intercept &= ~(1ULL << INTERCEPT_VINTR);
+}
+
+static void post_kvm_run_save(struct kvm_vcpu *vcpu,
+                              struct kvm_run *kvm_run)
+{
+        kvm_run->ready_for_interrupt_injection = (vcpu->interrupt_window_open &&
+                                                  vcpu->irq_summary == 0);
+        kvm_run->if_flag = (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF) != 0;
+        kvm_run->cr8 = vcpu->cr8;
+        kvm_run->apic_base = vcpu->apic_base;
+}
+
+/*
+ * Check if userspace requested an interrupt window, and that the
+ * interrupt window is open.
+ *
+ * No need to exit to userspace if we already have an interrupt queued.
+ */
+static int dm_request_for_irq_injection(struct kvm_vcpu *vcpu,
+                                          struct kvm_run *kvm_run)
+{
+        return (!vcpu->irq_summary &&
+                kvm_run->request_interrupt_window &&
+                vcpu->interrupt_window_open &&
+                (vcpu->svm->vmcb->save.rflags & X86_EFLAGS_IF));
 }
 
 static void save_db_regs(unsigned long *db_regs)
@@ -1324,9 +1403,10 @@ static int svm_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         u16 fs_selector;
         u16 gs_selector;
         u16 ldt_selector;
+        int r;
 
 again:
-        kvm_try_inject_irq(vcpu);
+        do_interrupt_requests(vcpu, kvm_run);
 
         clgi();
 
@@ -1487,18 +1567,28 @@ again:
         if (vcpu->svm->vmcb->control.exit_code == SVM_EXIT_ERR) {
                 kvm_run->exit_type = KVM_EXIT_TYPE_FAIL_ENTRY;
                 kvm_run->exit_reason = vcpu->svm->vmcb->control.exit_code;
+                post_kvm_run_save(vcpu, kvm_run);
                 return 0;
         }
 
-        if (handle_exit(vcpu, kvm_run)) {
+        r = handle_exit(vcpu, kvm_run);
+        if (r > 0) {
                 if (signal_pending(current)) {
                         ++kvm_stat.signal_exits;
+                        post_kvm_run_save(vcpu, kvm_run);
+                        return -EINTR;
+                }
+
+                if (dm_request_for_irq_injection(vcpu, kvm_run)) {
+                        ++kvm_stat.request_irq_exits;
+                        post_kvm_run_save(vcpu, kvm_run);
                         return -EINTR;
                 }
                 kvm_resched(vcpu);
                 goto again;
         }
-        return 0;
+        post_kvm_run_save(vcpu, kvm_run);
+        return r;
 }
 
 static void svm_flush_tlb(struct kvm_vcpu *vcpu)
@@ -1565,6 +1655,7 @@ static struct kvm_arch_ops svm_arch_ops = {
         .get_segment = svm_get_segment,
         .set_segment = svm_set_segment,
         .get_cs_db_l_bits = svm_get_cs_db_l_bits,
+        .decache_cr0_cr4_guest_bits = svm_decache_cr0_cr4_guest_bits,
         .set_cr0 = svm_set_cr0,
         .set_cr0_no_modeswitch = svm_set_cr0,
         .set_cr3 = svm_set_cr3,