Merge tag 'kvm-3.8-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm

Pull KVM updates from Marcelo Tosatti:
 "Considerable KVM/PPC work, x86 kvmclock vsyscall support,
  IA32_TSC_ADJUST MSR emulation, amongst others."

Fix up trivial conflict in kernel/sched/core.c due to cross-cpu
migration notifier added next to rq migration call-back.

* tag 'kvm-3.8-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (156 commits)
  KVM: emulator: fix real mode segment checks in address linearization
  VMX: remove unneeded enable_unrestricted_guest check
  KVM: VMX: fix DPL during entry to protected mode
  x86/kexec: crash_vmclear_local_vmcss needs __rcu
  kvm: Fix irqfd resampler list walk
  KVM: VMX: provide the vmclear function and a bitmap to support VMCLEAR in kdump
  x86/kexec: VMCLEAR VMCSs loaded on all cpus if necessary
  KVM: MMU: optimize for set_spte
  KVM: PPC: booke: Get/set guest EPCR register using ONE_REG interface
  KVM: PPC: bookehv: Add EPCR support in mtspr/mfspr emulation
  KVM: PPC: bookehv: Add guest computation mode for irq delivery
  KVM: PPC: Make EPCR a valid field for booke64 and bookehv
  KVM: PPC: booke: Extend MAS2 EPN mask for 64-bit
  KVM: PPC: e500: Mask MAS2 EPN high 32-bits in 32/64 tlbwe emulation
  KVM: PPC: Mask ea's high 32-bits in 32/64 instr emulation
  KVM: PPC: e500: Add emulation helper for getting instruction ea
  KVM: PPC: bookehv64: Add support for interrupt handling
  KVM: PPC: bookehv: Remove GET_VCPU macro from exception handler
  KVM: PPC: booke: Fix get_tb() compile error on 64-bit
  KVM: PPC: e500: Silence bogus GCC warning in tlb code
  ...

1 files changed, 41 insertions, 74 deletions

diff --git a/arch/x86/kvm/paging_tmpl.h b/arch/x86/kvm/paging_tmpl.h
index 714e2c01a6fe..891eb6d93b8b 100644
--- a/arch/x86/kvm/paging_tmpl.h
+++ b/arch/x86/kvm/paging_tmpl.h
@@ -305,51 +305,43 @@ static int FNAME(walk_addr_nested)(struct guest_walker *walker,
                                         addr, access);
 }
 
-static bool FNAME(prefetch_invalid_gpte)(struct kvm_vcpu *vcpu,
-                                    struct kvm_mmu_page *sp, u64 *spte,
-                                    pt_element_t gpte)
+static bool
+FNAME(prefetch_gpte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
+                     u64 *spte, pt_element_t gpte, bool no_dirty_log)
 {
-        if (is_rsvd_bits_set(&vcpu->arch.mmu, gpte, PT_PAGE_TABLE_LEVEL))
-                goto no_present;
-
-        if (!is_present_gpte(gpte))
-                goto no_present;
-
-        if (!(gpte & PT_ACCESSED_MASK))
-                goto no_present;
-
-        return false;
-
-no_present:
-        drop_spte(vcpu->kvm, spte);
-        return true;
-}
-
-static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
-                              u64 *spte, const void *pte)
-{
-        pt_element_t gpte;
         unsigned pte_access;
+        gfn_t gfn;
         pfn_t pfn;
 
-        gpte = *(const pt_element_t *)pte;
-        if (FNAME(prefetch_invalid_gpte)(vcpu, sp, spte, gpte))
-                return;
+        if (prefetch_invalid_gpte(vcpu, sp, spte, gpte))
+                return false;
 
         pgprintk("%s: gpte %llx spte %p\n", __func__, (u64)gpte, spte);
+
+        gfn = gpte_to_gfn(gpte);
         pte_access = sp->role.access & gpte_access(vcpu, gpte);
         protect_clean_gpte(&pte_access, gpte);
-        pfn = gfn_to_pfn_atomic(vcpu->kvm, gpte_to_gfn(gpte));
-        if (mmu_invalid_pfn(pfn))
-                return;
+        pfn = pte_prefetch_gfn_to_pfn(vcpu, gfn,
+                        no_dirty_log && (pte_access & ACC_WRITE_MASK));
+        if (is_error_pfn(pfn))
+                return false;
 
         /*
-         * we call mmu_set_spte() with host_writable = true because that
-         * vcpu->arch.update_pte.pfn was fetched from get_user_pages(write = 1).
+         * we call mmu_set_spte() with host_writable = true because
+         * pte_prefetch_gfn_to_pfn always gets a writable pfn.
          */
         mmu_set_spte(vcpu, spte, sp->role.access, pte_access, 0, 0,
-                     NULL, PT_PAGE_TABLE_LEVEL,
-                     gpte_to_gfn(gpte), pfn, true, true);
+                     NULL, PT_PAGE_TABLE_LEVEL, gfn, pfn, true, true);
+
+        return true;
+}
+
+static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
+                              u64 *spte, const void *pte)
+{
+        pt_element_t gpte = *(const pt_element_t *)pte;
+
+        FNAME(prefetch_gpte)(vcpu, sp, spte, gpte, false);
 }
 
 static bool FNAME(gpte_changed)(struct kvm_vcpu *vcpu,
@@ -395,53 +387,34 @@ static void FNAME(pte_prefetch)(struct kvm_vcpu *vcpu, struct guest_walker *gw,
         spte = sp->spt + i;
 
         for (i = 0; i < PTE_PREFETCH_NUM; i++, spte++) {
-                pt_element_t gpte;
-                unsigned pte_access;
-                gfn_t gfn;
-                pfn_t pfn;
-
                 if (spte == sptep)
                         continue;
 
                 if (is_shadow_present_pte(*spte))
                         continue;
 
-                gpte = gptep[i];
-
-                if (FNAME(prefetch_invalid_gpte)(vcpu, sp, spte, gpte))
-                        continue;
-
-                pte_access = sp->role.access & gpte_access(vcpu, gpte);
-                protect_clean_gpte(&pte_access, gpte);
-                gfn = gpte_to_gfn(gpte);
-                pfn = pte_prefetch_gfn_to_pfn(vcpu, gfn,
-                                      pte_access & ACC_WRITE_MASK);
-                if (mmu_invalid_pfn(pfn))
+                if (!FNAME(prefetch_gpte)(vcpu, sp, spte, gptep[i], true))
                         break;
-
-                mmu_set_spte(vcpu, spte, sp->role.access, pte_access, 0, 0,
-                             NULL, PT_PAGE_TABLE_LEVEL, gfn,
-                             pfn, true, true);
         }
 }
 
 /*
  * Fetch a shadow pte for a specific level in the paging hierarchy.
+ * If the guest tries to write a write-protected page, we need to
+ * emulate this operation, return 1 to indicate this case.
  */
-static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
+static int FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
                          struct guest_walker *gw,
                          int user_fault, int write_fault, int hlevel,
-                         int *emulate, pfn_t pfn, bool map_writable,
-                         bool prefault)
+                         pfn_t pfn, bool map_writable, bool prefault)
 {
-        unsigned access = gw->pt_access;
         struct kvm_mmu_page *sp = NULL;
-        int top_level;
-        unsigned direct_access;
         struct kvm_shadow_walk_iterator it;
+        unsigned direct_access, access = gw->pt_access;
+        int top_level, emulate = 0;
 
         if (!is_present_gpte(gw->ptes[gw->level - 1]))
-                return NULL;
+                return 0;
 
         direct_access = gw->pte_access;
 
@@ -505,17 +478,17 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
 
         clear_sp_write_flooding_count(it.sptep);
         mmu_set_spte(vcpu, it.sptep, access, gw->pte_access,
-                     user_fault, write_fault, emulate, it.level,
+                     user_fault, write_fault, &emulate, it.level,
                      gw->gfn, pfn, prefault, map_writable);
         FNAME(pte_prefetch)(vcpu, gw, it.sptep);
 
-        return it.sptep;
+        return emulate;
 
 out_gpte_changed:
         if (sp)
                 kvm_mmu_put_page(sp, it.sptep);
         kvm_release_pfn_clean(pfn);
-        return NULL;
+        return 0;
 }
 
 /*
@@ -538,8 +511,6 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr, u32 error_code,
         int write_fault = error_code & PFERR_WRITE_MASK;
         int user_fault = error_code & PFERR_USER_MASK;
         struct guest_walker walker;
-        u64 *sptep;
-        int emulate = 0;
         int r;
         pfn_t pfn;
         int level = PT_PAGE_TABLE_LEVEL;
@@ -594,24 +565,20 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr, u32 error_code,
                 return r;
 
         spin_lock(&vcpu->kvm->mmu_lock);
-        if (mmu_notifier_retry(vcpu, mmu_seq))
+        if (mmu_notifier_retry(vcpu->kvm, mmu_seq))
                 goto out_unlock;
 
         kvm_mmu_audit(vcpu, AUDIT_PRE_PAGE_FAULT);
         kvm_mmu_free_some_pages(vcpu);
         if (!force_pt_level)
                 transparent_hugepage_adjust(vcpu, &walker.gfn, &pfn, &level);
-        sptep = FNAME(fetch)(vcpu, addr, &walker, user_fault, write_fault,
-                             level, &emulate, pfn, map_writable, prefault);
-        (void)sptep;
-        pgprintk("%s: shadow pte %p %llx emulate %d\n", __func__,
-                 sptep, *sptep, emulate);
-
+        r = FNAME(fetch)(vcpu, addr, &walker, user_fault, write_fault,
+                         level, pfn, map_writable, prefault);
         ++vcpu->stat.pf_fixed;
         kvm_mmu_audit(vcpu, AUDIT_POST_PAGE_FAULT);
         spin_unlock(&vcpu->kvm->mmu_lock);
 
-        return emulate;
+        return r;
 
 out_unlock:
         spin_unlock(&vcpu->kvm->mmu_lock);
@@ -757,7 +724,7 @@ static int FNAME(sync_page)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
                                           sizeof(pt_element_t)))
                         return -EINVAL;
 
-                if (FNAME(prefetch_invalid_gpte)(vcpu, sp, &sp->spt[i], gpte)) {
+                if (prefetch_invalid_gpte(vcpu, sp, &sp->spt[i], gpte)) {
                         vcpu->kvm->tlbs_dirty++;
                         continue;
                 }