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

Pull KVM changes from Paolo Bonzini:
 "Here are the 3.13 KVM changes.  There was a lot of work on the PPC
  side: the HV and emulation flavors can now coexist in a single kernel
  is probably the most interesting change from a user point of view.

  On the x86 side there are nested virtualization improvements and a few
  bugfixes.

  ARM got transparent huge page support, improved overcommit, and
  support for big endian guests.

  Finally, there is a new interface to connect KVM with VFIO.  This
  helps with devices that use NoSnoop PCI transactions, letting the
  driver in the guest execute WBINVD instructions.  This includes some
  nVidia cards on Windows, that fail to start without these patches and
  the corresponding userspace changes"

* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (146 commits)
  kvm, vmx: Fix lazy FPU on nested guest
  arm/arm64: KVM: PSCI: propagate caller endianness to the incoming vcpu
  arm/arm64: KVM: MMIO support for BE guest
  kvm, cpuid: Fix sparse warning
  kvm: Delete prototype for non-existent function kvm_check_iopl
  kvm: Delete prototype for non-existent function complete_pio
  hung_task: add method to reset detector
  pvclock: detect watchdog reset at pvclock read
  kvm: optimize out smp_mb after srcu_read_unlock
  srcu: API for barrier after srcu read unlock
  KVM: remove vm mmap method
  KVM: IOMMU: hva align mapping page size
  KVM: x86: trace cpuid emulation when called from emulator
  KVM: emulator: cleanup decode_register_operand() a bit
  KVM: emulator: check rex prefix inside decode_register()
  KVM: x86: fix emulation of "movzbl %bpl, %eax"
  kvm_host: typo fix
  KVM: x86: emulate SAHF instruction
  MAINTAINERS: add tree for kvm.git
  Documentation/kvm: add a 00-INDEX file
  ...

5 files changed, 348 insertions, 113 deletions

diff --git a/virt/kvm/Kconfig b/virt/kvm/Kconfig
index 779262f59e25..fbe1a48bd629 100644
--- a/virt/kvm/Kconfig
+++ b/virt/kvm/Kconfig
@@ -27,3 +27,6 @@ config HAVE_KVM_MSI
 
 config HAVE_KVM_CPU_RELAX_INTERCEPT
        bool
+
+config KVM_VFIO
+       bool
diff --git a/virt/kvm/async_pf.c b/virt/kvm/async_pf.c
index 8a39dda7a325..8631d9c14320 100644
--- a/virt/kvm/async_pf.c
+++ b/virt/kvm/async_pf.c
@@ -56,7 +56,6 @@ void kvm_async_pf_vcpu_init(struct kvm_vcpu *vcpu)
 
 static void async_pf_execute(struct work_struct *work)
 {
-        struct page *page = NULL;
         struct kvm_async_pf *apf =
                 container_of(work, struct kvm_async_pf, work);
         struct mm_struct *mm = apf->mm;
@@ -68,14 +67,12 @@ static void async_pf_execute(struct work_struct *work)
 
         use_mm(mm);
         down_read(&mm->mmap_sem);
-        get_user_pages(current, mm, addr, 1, 1, 0, &page, NULL);
+        get_user_pages(current, mm, addr, 1, 1, 0, NULL, NULL);
         up_read(&mm->mmap_sem);
         unuse_mm(mm);
 
         spin_lock(&vcpu->async_pf.lock);
         list_add_tail(&apf->link, &vcpu->async_pf.done);
-        apf->page = page;
-        apf->done = true;
         spin_unlock(&vcpu->async_pf.lock);
 
         /*
@@ -83,7 +80,7 @@ static void async_pf_execute(struct work_struct *work)
          * this point
          */
 
-        trace_kvm_async_pf_completed(addr, page, gva);
+        trace_kvm_async_pf_completed(addr, gva);
 
         if (waitqueue_active(&vcpu->wq))
                 wake_up_interruptible(&vcpu->wq);
@@ -99,9 +96,8 @@ void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu)
                 struct kvm_async_pf *work =
                         list_entry(vcpu->async_pf.queue.next,
                                    typeof(*work), queue);
-                cancel_work_sync(&work->work);
                 list_del(&work->queue);
-                if (!work->done) { /* work was canceled */
+                if (cancel_work_sync(&work->work)) {
                         mmdrop(work->mm);
                         kvm_put_kvm(vcpu->kvm); /* == work->vcpu->kvm */
                         kmem_cache_free(async_pf_cache, work);
@@ -114,8 +110,6 @@ void kvm_clear_async_pf_completion_queue(struct kvm_vcpu *vcpu)
                         list_entry(vcpu->async_pf.done.next,
                                    typeof(*work), link);
                 list_del(&work->link);
-                if (!is_error_page(work->page))
-                        kvm_release_page_clean(work->page);
                 kmem_cache_free(async_pf_cache, work);
         }
         spin_unlock(&vcpu->async_pf.lock);
@@ -135,14 +129,11 @@ void kvm_check_async_pf_completion(struct kvm_vcpu *vcpu)
                 list_del(&work->link);
                 spin_unlock(&vcpu->async_pf.lock);
 
-                if (work->page)
-                        kvm_arch_async_page_ready(vcpu, work);
+                kvm_arch_async_page_ready(vcpu, work);
                 kvm_arch_async_page_present(vcpu, work);
 
                 list_del(&work->queue);
                 vcpu->async_pf.queued--;
-                if (!is_error_page(work->page))
-                        kvm_release_page_clean(work->page);
                 kmem_cache_free(async_pf_cache, work);
         }
 }
@@ -165,8 +156,7 @@ int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, gfn_t gfn,
         if (!work)
                 return 0;
 
-        work->page = NULL;
-        work->done = false;
+        work->wakeup_all = false;
         work->vcpu = vcpu;
         work->gva = gva;
         work->addr = gfn_to_hva(vcpu->kvm, gfn);
@@ -206,7 +196,7 @@ int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu)
         if (!work)
                 return -ENOMEM;
 
-        work->page = KVM_ERR_PTR_BAD_PAGE;
+        work->wakeup_all = true;
         INIT_LIST_HEAD(&work->queue); /* for list_del to work */
 
         spin_lock(&vcpu->async_pf.lock);
diff --git a/virt/kvm/iommu.c b/virt/kvm/iommu.c
index 72a130bc448a..0df7d4b34dfe 100644
--- a/virt/kvm/iommu.c
+++ b/virt/kvm/iommu.c
@@ -79,7 +79,7 @@ int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot)
         flags = IOMMU_READ;
         if (!(slot->flags & KVM_MEM_READONLY))
                 flags |= IOMMU_WRITE;
-        if (kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY)
+        if (!kvm->arch.iommu_noncoherent)
                 flags |= IOMMU_CACHE;
 
 
@@ -103,6 +103,10 @@ int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot)
                 while ((gfn << PAGE_SHIFT) & (page_size - 1))
                         page_size >>= 1;
 
+                /* Make sure hva is aligned to the page size we want to map */
+                while (__gfn_to_hva_memslot(slot, gfn) & (page_size - 1))
+                        page_size >>= 1;
+
                 /*
                  * Pin all pages we are about to map in memory. This is
                  * important because we unmap and unpin in 4kb steps later.
@@ -140,6 +144,9 @@ static int kvm_iommu_map_memslots(struct kvm *kvm)
         struct kvm_memslots *slots;
         struct kvm_memory_slot *memslot;
 
+        if (kvm->arch.iommu_noncoherent)
+                kvm_arch_register_noncoherent_dma(kvm);
+
         idx = srcu_read_lock(&kvm->srcu);
         slots = kvm_memslots(kvm);
 
@@ -158,7 +165,8 @@ int kvm_assign_device(struct kvm *kvm,
 {
         struct pci_dev *pdev = NULL;
         struct iommu_domain *domain = kvm->arch.iommu_domain;
-        int r, last_flags;
+        int r;
+        bool noncoherent;
 
         /* check if iommu exists and in use */
         if (!domain)
@@ -174,15 +182,13 @@ int kvm_assign_device(struct kvm *kvm,
                 return r;
         }
 
-        last_flags = kvm->arch.iommu_flags;
-        if (iommu_domain_has_cap(kvm->arch.iommu_domain,
+        noncoherent = !iommu_domain_has_cap(kvm->arch.iommu_domain,
+                                            IOMMU_CAP_CACHE_COHERENCY);