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
  ...

1 files changed, 36 insertions, 28 deletions

diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 12f33e662382..c805cf494154 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -161,6 +161,7 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
         { "halt_exits", VCPU_STAT(halt_exits) },
         { "halt_successful_poll", VCPU_STAT(halt_successful_poll) },
         { "halt_attempted_poll", VCPU_STAT(halt_attempted_poll) },
+        { "halt_poll_invalid", VCPU_STAT(halt_poll_invalid) },
         { "halt_wakeup", VCPU_STAT(halt_wakeup) },
         { "hypercalls", VCPU_STAT(hypercalls) },
         { "request_irq", VCPU_STAT(request_irq_exits) },
@@ -2002,22 +2003,8 @@ static void kvmclock_reset(struct kvm_vcpu *vcpu)
         vcpu->arch.pv_time_enabled = false;
 }
 
-static void accumulate_steal_time(struct kvm_vcpu *vcpu)
-{
-        u64 delta;
-
-        if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED))
-                return;
-
-        delta = current->sched_info.run_delay - vcpu->arch.st.last_steal;
-        vcpu->arch.st.last_steal = current->sched_info.run_delay;
-        vcpu->arch.st.accum_steal = delta;
-}
-
 static void record_steal_time(struct kvm_vcpu *vcpu)
 {
-        accumulate_steal_time(vcpu);
-
         if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED))
                 return;
 
@@ -2025,9 +2012,26 @@ static void record_steal_time(struct kvm_vcpu *vcpu)
                 &vcpu->arch.st.steal, sizeof(struct kvm_steal_time))))
                 return;
 
-        vcpu->arch.st.steal.steal += vcpu->arch.st.accum_steal;
-        vcpu->arch.st.steal.version += 2;
-        vcpu->arch.st.accum_steal = 0;
+        if (vcpu->arch.st.steal.version & 1)
+                vcpu->arch.st.steal.version += 1;  /* first time write, random junk */
+
+        vcpu->arch.st.steal.version += 1;
+
+        kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
+                &vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
+
+        smp_wmb();
+
+        vcpu->arch.st.steal.steal += current->sched_info.run_delay -
+                vcpu->arch.st.last_steal;
+        vcpu->arch.st.last_steal = current->sched_info.run_delay;
+
+        kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
+                &vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
+
+        smp_wmb();
+
+        vcpu->arch.st.steal.version += 1;
 
         kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
                 &vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
@@ -7752,6 +7756,9 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
         kvm_page_track_init(kvm);
         kvm_mmu_init_vm(kvm);
 
+        if (kvm_x86_ops->vm_init)
+                return kvm_x86_ops->vm_init(kvm);
+
         return 0;
 }
 
@@ -7873,6 +7880,8 @@ void kvm_arch_destroy_vm(struct kvm *kvm)
                 x86_set_memory_region(kvm, IDENTITY_PAGETABLE_PRIVATE_MEMSLOT, 0, 0);
                 x86_set_memory_region(kvm, TSS_PRIVATE_MEMSLOT, 0, 0);
         }
+        if (kvm_x86_ops->vm_destroy)
+                kvm_x86_ops->vm_destroy(kvm);
         kvm_iommu_unmap_guest(kvm);
         kfree(kvm->arch.vpic);
         kfree(kvm->arch.vioapic);
@@ -8355,19 +8364,21 @@ bool kvm_arch_has_noncoherent_dma(struct kvm *kvm)
 }
 EXPORT_SYMBOL_GPL(kvm_arch_has_noncoherent_dma);
 
+bool kvm_arch_has_irq_bypass(void)
+{
+        return kvm_x86_ops->update_pi_irte != NULL;
+}
+
 int kvm_arch_irq_bypass_add_producer(struct irq_bypass_consumer *cons,
                                       struct irq_bypass_producer *prod)
 {
         struct kvm_kernel_irqfd *irqfd =
                 container_of(cons, struct kvm_kernel_irqfd, consumer);
 
-        if (kvm_x86_ops->update_pi_irte) {
-                irqfd->producer = prod;
-                return kvm_x86_ops->update_pi_irte(irqfd->kvm,
-                                prod->irq, irqfd->gsi, 1);
-        }
+        irqfd->producer = prod;
 
-        return -EINVAL;
+        return kvm_x86_ops->update_pi_irte(irqfd->kvm,
+                                           prod->irq, irqfd->gsi, 1);
 }
 
 void kvm_arch_irq_bypass_del_producer(struct irq_bypass_consumer *cons,
@@ -8377,11 +8388,6 @@ void kvm_arch_irq_bypass_del_producer(struct irq_bypass_consumer *cons,
         struct kvm_kernel_irqfd *irqfd =
                 container_of(cons, struct kvm_kernel_irqfd, consumer);
 
-        if (!kvm_x86_ops->update_pi_irte) {
-                WARN_ON(irqfd->producer != NULL);
-                return;
-        }
-
         WARN_ON(irqfd->producer != prod);
         irqfd->producer = NULL;
 
@@ -8429,3 +8435,5 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_write_tsc_offset);
 EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_ple_window);
 EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_pml_full);
 EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_pi_irte_update);
+EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_avic_unaccelerated_access);
+EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_avic_incomplete_ipi);