extern void kvmppc_giveup_ext(struct kvm_vcpu *vcpu, ulong msr);
 extern int kvmppc_emulate_paired_single(struct kvm_vcpu *vcpu);
 extern kvm_pfn_t kvmppc_gpa_to_pfn(struct kvm_vcpu *vcpu, gpa_t gpa,
-                       bool writing, bool *writable);
+                       bool writing, bool *writable, struct page **page);
 extern void kvmppc_add_revmap_chain(struct kvm *kvm, struct revmap_entry *rev,
                        unsigned long *rmap, long pte_index, int realmode);
 extern void kvmppc_update_dirty_map(const struct kvm_memory_slot *memslot,
 
 EXPORT_SYMBOL_GPL(kvmppc_core_prepare_to_enter);
 
 kvm_pfn_t kvmppc_gpa_to_pfn(struct kvm_vcpu *vcpu, gpa_t gpa, bool writing,
-                       bool *writable)
+                           bool *writable, struct page **page)
 {
        ulong mp_pa = vcpu->arch.magic_page_pa & KVM_PAM;
        gfn_t gfn = gpa >> PAGE_SHIFT;
                kvm_pfn_t pfn;
 
                pfn = (kvm_pfn_t)virt_to_phys((void*)shared_page) >> PAGE_SHIFT;
-               get_page(pfn_to_page(pfn));
+               *page = pfn_to_page(pfn);
+               get_page(*page);
                if (writable)
                        *writable = true;
                return pfn;
        }
 
-       return gfn_to_pfn_prot(vcpu->kvm, gfn, writing, writable);
+       return kvm_faultin_pfn(vcpu, gfn, writing, writable, page);
 }
 EXPORT_SYMBOL_GPL(kvmppc_gpa_to_pfn);
 
 
 int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte,
                        bool iswrite)
 {
+       struct page *page;
        kvm_pfn_t hpaddr;
        u64 vpn;
        u64 vsid;
        bool writable;
 
        /* Get host physical address for gpa */
-       hpaddr = kvmppc_gpa_to_pfn(vcpu, orig_pte->raddr, iswrite, &writable);
+       hpaddr = kvmppc_gpa_to_pfn(vcpu, orig_pte->raddr, iswrite, &writable, &page);
        if (is_error_noslot_pfn(hpaddr)) {
                printk(KERN_INFO "Couldn't get guest page for gpa %lx!\n",
                                 orig_pte->raddr);
 
        pte = kvmppc_mmu_hpte_cache_next(vcpu);
        if (!pte) {
-               kvm_release_pfn_clean(hpaddr >> PAGE_SHIFT);
+               kvm_release_page_unused(page);
                r = -EAGAIN;
                goto out;
        }
 
        kvmppc_mmu_hpte_cache_map(vcpu, pte);
 
-       kvm_release_pfn_clean(hpaddr >> PAGE_SHIFT);
+       kvm_release_page_clean(page);
 out:
        return r;
 }
 
        struct hpte_cache *cpte;
        unsigned long gfn = orig_pte->raddr >> PAGE_SHIFT;
        unsigned long pfn;
+       struct page *page;
 
        /* used to check for invalidations in progress */
        mmu_seq = kvm->mmu_invalidate_seq;
        smp_rmb();
 
        /* Get host physical address for gpa */
-       pfn = kvmppc_gpa_to_pfn(vcpu, orig_pte->raddr, iswrite, &writable);
+       pfn = kvmppc_gpa_to_pfn(vcpu, orig_pte->raddr, iswrite, &writable, &page);
        if (is_error_noslot_pfn(pfn)) {
                printk(KERN_INFO "Couldn't get guest page for gpa %lx!\n",
                       orig_pte->raddr);
        }
 
 out_unlock:
-       if (!orig_pte->may_write || !writable)
-               kvm_release_pfn_clean(pfn);
-       else
-               kvm_release_pfn_dirty(pfn);
+       /* FIXME: Don't unconditionally pass unused=false. */
+       kvm_release_faultin_page(kvm, page, false,
+                                orig_pte->may_write && writable);
        spin_unlock(&kvm->mmu_lock);
        if (cpte)
                kvmppc_mmu_hpte_cache_free(cpte);