Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm

Pull KVM updates from Paolo Bonzini:
 "Small release overall.

  x86:
   - miscellaneous fixes
   - AVIC support (local APIC virtualization, AMD version)

  s390:
   - polling for interrupts after a VCPU goes to halted state is now
     enabled for s390
   - use hardware provided information about facility bits that do not
     need any hypervisor activity, and other fixes for cpu models and
     facilities
   - improve perf output
   - floating interrupt controller improvements.

  MIPS:
   - miscellaneous fixes

  PPC:
   - bugfixes only

  ARM:
   - 16K page size support
   - generic firmware probing layer for timer and GIC

  Christoffer Dall (KVM-ARM maintainer) says:
    "There are a few changes in this pull request touching things
     outside KVM, but they should all carry the necessary acks and it
     made the merge process much easier to do it this way."

  though actually the irqchip maintainers' acks didn't make it into the
  patches.  Marc Zyngier, who is both irqchip and KVM-ARM maintainer,
  later acked at http://mid.gmane.org/573351D1.4060303@arm.com ('more
  formally and for documentation purposes')"

* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (82 commits)
  KVM: MTRR: remove MSR 0x2f8
  KVM: x86: make hwapic_isr_update and hwapic_irr_update look the same
  svm: Manage vcpu load/unload when enable AVIC
  svm: Do not intercept CR8 when enable AVIC
  svm: Do not expose x2APIC when enable AVIC
  KVM: x86: Introducing kvm_x86_ops.apicv_post_state_restore
  svm: Add VMEXIT handlers for AVIC
  svm: Add interrupt injection via AVIC
  KVM: x86: Detect and Initialize AVIC support
  svm: Introduce new AVIC VMCB registers
  KVM: split kvm_vcpu_wake_up from kvm_vcpu_kick
  KVM: x86: Introducing kvm_x86_ops VCPU blocking/unblocking hooks
  KVM: x86: Introducing kvm_x86_ops VM init/destroy hooks
  KVM: x86: Rename kvm_apic_get_reg to kvm_lapic_get_reg
  KVM: x86: Misc LAPIC changes to expose helper functions
  KVM: shrink halt polling even more for invalid wakeups
  KVM: s390: set halt polling to 80 microseconds
  KVM: halt_polling: provide a way to qualify wakeups during poll
  KVM: PPC: Book3S HV: Re-enable XICS fast path for irqfd-generated interrupts
  kvm: Conditionally register IRQ bypass consumer
  ...

4 files changed, 76 insertions, 50 deletions

diff --git a/arch/mips/kvm/emulate.c b/arch/mips/kvm/emulate.c
index 8e945e866a73..396df6eb0a12 100644
--- a/arch/mips/kvm/emulate.c
+++ b/arch/mips/kvm/emulate.c
@@ -302,12 +302,31 @@ static inline ktime_t kvm_mips_count_time(struct kvm_vcpu *vcpu)
  */
 static uint32_t kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now)
 {
-        ktime_t expires;
+        struct mips_coproc *cop0 = vcpu->arch.cop0;
+        ktime_t expires, threshold;
+        uint32_t count, compare;
         int running;
 
-        /* Is the hrtimer pending? */
+        /* Calculate the biased and scaled guest CP0_Count */
+        count = vcpu->arch.count_bias + kvm_mips_ktime_to_count(vcpu, now);
+        compare = kvm_read_c0_guest_compare(cop0);
+
+        /*
+         * Find whether CP0_Count has reached the closest timer interrupt. If
+         * not, we shouldn't inject it.
+         */
+        if ((int32_t)(count - compare) < 0)
+                return count;
+
+        /*
+         * The CP0_Count we're going to return has already reached the closest
+         * timer interrupt. Quickly check if it really is a new interrupt by
+         * looking at whether the interval until the hrtimer expiry time is
+         * less than 1/4 of the timer period.
+         */
         expires = hrtimer_get_expires(&vcpu->arch.comparecount_timer);
-        if (ktime_compare(now, expires) >= 0) {
+        threshold = ktime_add_ns(now, vcpu->arch.count_period / 4);
+        if (ktime_before(expires, threshold)) {
                 /*
                  * Cancel it while we handle it so there's no chance of
                  * interference with the timeout handler.
@@ -329,8 +348,7 @@ static uint32_t kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now)
                 }
         }
 
-        /* Return the biased and scaled guest CP0_Count */
-        return vcpu->arch.count_bias + kvm_mips_ktime_to_count(vcpu, now);
+        return count;
 }
 
 /**
@@ -420,32 +438,6 @@ static void kvm_mips_resume_hrtimer(struct kvm_vcpu *vcpu,
 }
 
 /**
- * kvm_mips_update_hrtimer() - Update next expiry time of hrtimer.
- * @vcpu:       Virtual CPU.
- *
- * Recalculates and updates the expiry time of the hrtimer. This can be used
- * after timer parameters have been altered which do not depend on the time that
- * the change occurs (in those cases kvm_mips_freeze_hrtimer() and
- * kvm_mips_resume_hrtimer() are used directly).
- *
- * It is guaranteed that no timer interrupts will be lost in the process.
- *
- * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running).
- */
-static void kvm_mips_update_hrtimer(struct kvm_vcpu *vcpu)
-{
-        ktime_t now;
-        uint32_t count;
-
-        /*
-         * freeze_hrtimer takes care of a timer interrupts <= count, and
-         * resume_hrtimer the hrtimer takes care of a timer interrupts > count.
-         */
-        now = kvm_mips_freeze_hrtimer(vcpu, &count);
-        kvm_mips_resume_hrtimer(vcpu, now, count);
-}
-
-/**
  * kvm_mips_write_count() - Modify the count and update timer.
  * @vcpu:       Virtual CPU.
  * @count:      Guest CP0_Count value to set.
@@ -540,23 +532,42 @@ int kvm_mips_set_count_hz(struct kvm_vcpu *vcpu, s64 count_hz)
  * kvm_mips_write_compare() - Modify compare and update timer.
  * @vcpu:       Virtual CPU.
  * @compare:    New CP0_Compare value.
+ * @ack:        Whether to acknowledge timer interrupt.
  *
  * Update CP0_Compare to a new value and update the timeout.
+ * If @ack, atomically acknowledge any pending timer interrupt, otherwise ensure
+ * any pending timer interrupt is preserved.
  */
-void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare)
+void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare, bool ack)
 {
         struct mips_coproc *cop0 = vcpu->arch.cop0;
+        int dc;
+        u32 old_compare = kvm_read_c0_guest_compare(cop0);
+        ktime_t now;
+        uint32_t count;
 
         /* if unchanged, must just be an ack */
-        if (kvm_read_c0_guest_compare(cop0) == compare)
+        if (old_compare == compare) {
+                if (!ack)
+                        return;
+                kvm_mips_callbacks->dequeue_timer_int(vcpu);
+                kvm_write_c0_guest_compare(cop0, compare);
                 return;
+        }
+
+        /* freeze_hrtimer() takes care of timer interrupts <= count */
+        dc = kvm_mips_count_disabled(vcpu);
+        if (!dc)
+                now = kvm_mips_freeze_hrtimer(vcpu, &count);
+
+        if (ack)
+                kvm_mips_callbacks->dequeue_timer_int(vcpu);
 
-        /* Update compare */
         kvm_write_c0_guest_compare(cop0, compare);
 
-        /* Update timeout if count enabled */
-        if (!kvm_mips_count_disabled(vcpu))
-                kvm_mips_update_hrtimer(vcpu);
+        /* resume_hrtimer() takes care of timer interrupts > count */
+        if (!dc)
+                kvm_mips_resume_hrtimer(vcpu, now, count);
 }
 
 /**
@@ -1095,9 +1106,9 @@ enum emulation_result kvm_mips_emulate_CP0(uint32_t inst, uint32_t *opc,
 
                                 /* If we are writing to COMPARE */
                                 /* Clear pending timer interrupt, if any */
-                                kvm_mips_callbacks->dequeue_timer_int(vcpu);
                                 kvm_mips_write_compare(vcpu,
-                                                       vcpu->arch.gprs[rt]);
+                                                       vcpu->arch.gprs[rt],
+                                                       true);
                         } else if ((rd == MIPS_CP0_STATUS) && (sel == 0)) {
                                 unsigned int old_val, val, change;
 
diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c
index 70ef1a43c114..dc052fb5c7a2 100644
--- a/arch/mips/kvm/mips.c
+++ b/arch/mips/kvm/mips.c
@@ -56,6 +56,7 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
         { "flush_dcache", VCPU_STAT(flush_dcache_exits), KVM_STAT_VCPU },
         { "halt_successful_poll", VCPU_STAT(halt_successful_poll), KVM_STAT_VCPU },
         { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll), KVM_STAT_VCPU },
+        { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid), KVM_STAT_VCPU },
         { "halt_wakeup",  VCPU_STAT(halt_wakeup),        KVM_STAT_VCPU },
         {NULL}
 };
@@ -1079,7 +1080,8 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
                 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
                 break;
         case KVM_CAP_MIPS_FPU:
-                r = !!cpu_has_fpu;
+                /* We don't handle systems with inconsistent cpu_has_fpu */
+                r = !!raw_cpu_has_fpu;
                 break;
         case KVM_CAP_MIPS_MSA:
                 /*
@@ -1555,8 +1557,10 @@ void kvm_lose_fpu(struct kvm_vcpu *vcpu)
 
                 /* Disable MSA & FPU */
                 disable_msa();
-                if (vcpu->arch.fpu_inuse & KVM_MIPS_FPU_FPU)
+                if (vcpu->arch.fpu_inuse & KVM_MIPS_FPU_FPU) {
                         clear_c0_status(ST0_CU1 | ST0_FR);
+                        disable_fpu_hazard();
+                }
                 vcpu->arch.fpu_inuse &= ~(KVM_MIPS_FPU_FPU | KVM_MIPS_FPU_MSA);
         } else if (vcpu->arch.fpu_inuse & KVM_MIPS_FPU_FPU) {
                 set_c0_status(ST0_CU1);
@@ -1567,6 +1571,7 @@ void kvm_lose_fpu(struct kvm_vcpu *vcpu)
 
                 /* Disable FPU */
                 clear_c0_status(ST0_CU1 | ST0_FR);
+                disable_fpu_hazard();
         }
         preempt_enable();
 }
diff --git a/arch/mips/kvm/tlb.c b/arch/mips/kvm/tlb.c
index b9c52c1d35d6..ed021ae7867a 100644
--- a/arch/mips/kvm/tlb.c
+++ b/arch/mips/kvm/tlb.c
@@ -275,6 +275,7 @@ int kvm_mips_handle_kseg0_tlb_fault(unsigned long badvaddr,
         int even;
         struct kvm *kvm = vcpu->kvm;
         const int flush_dcache_mask = 0;
+        int ret;
 
         if (KVM_GUEST_KSEGX(badvaddr) != KVM_GUEST_KSEG0) {
                 kvm_err("%s: Invalid BadVaddr: %#lx\n", __func__, badvaddr);
@@ -306,14 +307,18 @@ int kvm_mips_handle_kseg0_tlb_fault(unsigned long badvaddr,
                 pfn1 = kvm->arch.guest_pmap[gfn];
         }
 
-        entryhi = (vaddr | kvm_mips_get_kernel_asid(vcpu));
         entrylo0 = mips3_paddr_to_tlbpfn(pfn0 << PAGE_SHIFT) | (0x3 << 3) |
                    (1 << 2) | (0x1 << 1);
         entrylo1 = mips3_paddr_to_tlbpfn(pfn1 << PAGE_SHIFT) | (0x3 << 3) |
                    (1 << 2) | (0x1 << 1);
 
-        return kvm_mips_host_tlb_write(vcpu, entryhi, entrylo0, entrylo1,
-                                       flush_dcache_mask);
+        preempt_disable();
+        entryhi = (vaddr | kvm_mips_get_kernel_asid(vcpu));
+        ret = kvm_mips_host_tlb_write(vcpu, entryhi, entrylo0, entrylo1,
+                                      flush_dcache_mask);
+        preempt_enable();
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(kvm_mips_handle_kseg0_tlb_fault);
 
@@ -368,6 +373,7 @@ int kvm_mips_handle_mapped_seg_tlb_fault(struct kvm_vcpu *vcpu,
         unsigned long entryhi = 0, entrylo0 = 0, entrylo1 = 0;
         struct kvm *kvm = vcpu->kvm;
         kvm_pfn_t pfn0, pfn1;
+        int ret;
 
         if ((tlb->tlb_hi & VPN2_MASK) == 0) {
                 pfn0 = 0;
@@ -394,9 +400,6 @@ int kvm_mips_handle_mapped_seg_tlb_fault(struct kvm_vcpu *vcpu,
                 *hpa1 = pfn1 << PAGE_SHIFT;
 
         /* Get attributes from the Guest TLB */
-        entryhi = (tlb->tlb_hi & VPN2_MASK) | (KVM_GUEST_KERNEL_MODE(vcpu) ?
-                                               kvm_mips_get_kernel_asid(vcpu) :
-                                               kvm_mips_get_user_asid(vcpu));
         entrylo0 = mips3_paddr_to_tlbpfn(pfn0 << PAGE_SHIFT) | (0x3 << 3) |
                    (tlb->tlb_lo0 & MIPS3_PG_D) | (tlb->tlb_lo0 & MIPS3_PG_V);
         entrylo1 = mips3_paddr_to_tlbpfn(pfn1 << PAGE_SHIFT) | (0x3 << 3) |
@@ -405,8 +408,15 @@ int kvm_mips_handle_mapped_seg_tlb_fault(struct kvm_vcpu *vcpu,
         kvm_debug("@ %#lx tlb_lo0: 0x%08lx tlb_lo1: 0x%08lx\n", vcpu->arch.pc,
                   tlb->tlb_lo0, tlb->tlb_lo1);
 
-        return kvm_mips_host_tlb_write(vcpu, entryhi, entrylo0, entrylo1,
-                                       tlb->tlb_mask);
+        preempt_disable();
+        entryhi = (tlb->tlb_hi & VPN2_MASK) | (KVM_GUEST_KERNEL_MODE(vcpu) ?
+                                               kvm_mips_get_kernel_asid(vcpu) :
+                                               kvm_mips_get_user_asid(vcpu));
+        ret = kvm_mips_host_tlb_write(vcpu, entryhi, entrylo0, entrylo1,
+                                      tlb->tlb_mask);
+        preempt_enable();
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(kvm_mips_handle_mapped_seg_tlb_fault);
 
diff --git a/arch/mips/kvm/trap_emul.c b/arch/mips/kvm/trap_emul.c
index fd43f0afdb9f..6ba0fafcecbc 100644
--- a/arch/mips/kvm/trap_emul.c
+++ b/arch/mips/kvm/trap_emul.c
@@ -547,7 +547,7 @@ static int kvm_trap_emul_set_one_reg(struct kvm_vcpu *vcpu,
                 kvm_mips_write_count(vcpu, v);
                 break;
         case KVM_REG_MIPS_CP0_COMPARE:
-                kvm_mips_write_compare(vcpu, v);
+                kvm_mips_write_compare(vcpu, v, false);
                 break;
         case KVM_REG_MIPS_CP0_CAUSE:
                 /*