KVM: Prepare memslot data structures for multiple hugepage sizes

[deliverable/linux.git] / arch / x86 / kvm / paging_tmpl.h

diff --git a/arch/x86/kvm/paging_tmpl.h b/arch/x86/kvm/paging_tmpl.h
index 258e4591e1ca02246801fc380ae19472b2375b0a..53e129cec5fd39142e83d197c56f6b57224dc305 100644 (file)
--- a/arch/x86/kvm/paging_tmpl.h
+++ b/arch/x86/kvm/paging_tmpl.h
@@ -131,8 +131,8 @@ walk:
        pte = vcpu->arch.cr3;
 #if PTTYPE == 64
        if (!is_long_mode(vcpu)) {
-               pte = vcpu->arch.pdptrs[(addr >> 30) & 3];
-               if (!is_present_pte(pte))
+               pte = kvm_pdptr_read(vcpu, (addr >> 30) & 3);
+               if (!is_present_gpte(pte))
                        goto not_present;
                --walker->level;
        }
@@ -155,7 +155,7 @@ walk:
 
                kvm_read_guest(vcpu->kvm, pte_gpa, &pte, sizeof(pte));
 
-               if (!is_present_pte(pte))
+               if (!is_present_gpte(pte))
                        goto not_present;
 
                rsvd_fault = is_rsvd_bits_set(vcpu, pte, walker->level);
@@ -205,7 +205,7 @@ walk:
                --walker->level;
        }
 
-       if (write_fault && !is_dirty_pte(pte)) {
+       if (write_fault && !is_dirty_gpte(pte)) {
                bool ret;
 
                mark_page_dirty(vcpu->kvm, table_gfn);
@@ -252,8 +252,8 @@ static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *page,
 
        gpte = *(const pt_element_t *)pte;
        if (~gpte & (PT_PRESENT_MASK | PT_ACCESSED_MASK)) {
-               if (!is_present_pte(gpte))
-                       set_shadow_pte(spte, shadow_notrap_nonpresent_pte);
+               if (!is_present_gpte(gpte))
+                       __set_spte(spte, shadow_notrap_nonpresent_pte);
                return;
        }
        pgprintk("%s: gpte %llx spte %p\n", __func__, (u64)gpte, spte);
@@ -281,7 +281,7 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
 {
        unsigned access = gw->pt_access;
        struct kvm_mmu_page *shadow_page;
-       u64 spte, *sptep;
+       u64 spte, *sptep = NULL;
        int direct;
        gfn_t table_gfn;
        int r;
@@ -289,7 +289,7 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
        pt_element_t curr_pte;
        struct kvm_shadow_walk_iterator iterator;
 
-       if (!is_present_pte(gw->ptes[gw->level - 1]))
+       if (!is_present_gpte(gw->ptes[gw->level - 1]))
                return NULL;
 
        for_each_shadow_entry(vcpu, addr, iterator) {
@@ -311,14 +311,14 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
 
                if (is_large_pte(*sptep)) {
                        rmap_remove(vcpu->kvm, sptep);
-                       set_shadow_pte(sptep, shadow_trap_nonpresent_pte);
+                       __set_spte(sptep, shadow_trap_nonpresent_pte);
                        kvm_flush_remote_tlbs(vcpu->kvm);
                }
 
                if (level == PT_DIRECTORY_LEVEL
                    && gw->level == PT_DIRECTORY_LEVEL) {
                        direct = 1;
-                       if (!is_dirty_pte(gw->ptes[level - 1]))
+                       if (!is_dirty_gpte(gw->ptes[level - 1]))
                                access &= ~ACC_WRITE_MASK;
                        table_gfn = gpte_to_gfn(gw->ptes[level - 1]);
                } else {
@@ -369,7 +369,7 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
        int user_fault = error_code & PFERR_USER_MASK;
        int fetch_fault = error_code & PFERR_FETCH_MASK;
        struct guest_walker walker;
-       u64 *shadow_pte;
+       u64 *sptep;
        int write_pt = 0;
        int r;
        pfn_t pfn;
@@ -401,7 +401,8 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
 
        if (walker.level == PT_DIRECTORY_LEVEL) {
                gfn_t large_gfn;
-               large_gfn = walker.gfn & ~(KVM_PAGES_PER_HPAGE-1);
+               large_gfn = walker.gfn &
+                       ~(KVM_PAGES_PER_HPAGE(PT_DIRECTORY_LEVEL) - 1);
                if (is_largepage_backed(vcpu, large_gfn)) {
                        walker.gfn = large_gfn;
                        largepage = 1;
@@ -422,11 +423,11 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
        if (mmu_notifier_retry(vcpu, mmu_seq))
                goto out_unlock;
        kvm_mmu_free_some_pages(vcpu);
-       shadow_pte = FNAME(fetch)(vcpu, addr, &walker, user_fault, write_fault,
-                                 largepage, &write_pt, pfn);
+       sptep = FNAME(fetch)(vcpu, addr, &walker, user_fault, write_fault,
+                            largepage, &write_pt, pfn);
 
        pgprintk("%s: shadow pte %p %llx ptwrite %d\n", __func__,
-                shadow_pte, *shadow_pte, write_pt);
+                sptep, *sptep, write_pt);
 
        if (!write_pt)
                vcpu->arch.last_pt_write_count = 0; /* reset fork detector */
@@ -472,7 +473,7 @@ static void FNAME(invlpg)(struct kvm_vcpu *vcpu, gva_t gva)
                                        --vcpu->kvm->stat.lpages;
                                need_flush = 1;
                        }
-                       set_shadow_pte(sptep, shadow_trap_nonpresent_pte);
+                       __set_spte(sptep, shadow_trap_nonpresent_pte);
                        break;
                }
 
@@ -489,7 +490,7 @@ static void FNAME(invlpg)(struct kvm_vcpu *vcpu, gva_t gva)
        if (kvm_read_guest_atomic(vcpu->kvm, pte_gpa, &gpte,
                                  sizeof(pt_element_t)))
                return;
-       if (is_present_pte(gpte) && (gpte & PT_ACCESSED_MASK)) {
+       if (is_present_gpte(gpte) && (gpte & PT_ACCESSED_MASK)) {
                if (mmu_topup_memory_caches(vcpu))
                        return;
                kvm_mmu_pte_write(vcpu, pte_gpa, (const u8 *)&gpte,
@@ -536,7 +537,7 @@ static void FNAME(prefetch_page)(struct kvm_vcpu *vcpu,
                r = kvm_read_guest_atomic(vcpu->kvm, pte_gpa, pt, sizeof pt);
                pte_gpa += ARRAY_SIZE(pt) * sizeof(pt_element_t);
                for (j = 0; j < ARRAY_SIZE(pt); ++j)
-                       if (r || is_present_pte(pt[j]))
+                       if (r || is_present_gpte(pt[j]))
                                sp->spt[i+j] = shadow_trap_nonpresent_pte;
                        else
                                sp->spt[i+j] = shadow_notrap_nonpresent_pte;
@@ -574,23 +575,23 @@ static int FNAME(sync_page)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
                                          sizeof(pt_element_t)))
                        return -EINVAL;
 
-               if (gpte_to_gfn(gpte) != gfn || !is_present_pte(gpte) ||
+               if (gpte_to_gfn(gpte) != gfn || !is_present_gpte(gpte) ||
                    !(gpte & PT_ACCESSED_MASK)) {
                        u64 nonpresent;
 
                        rmap_remove(vcpu->kvm, &sp->spt[i]);
-                       if (is_present_pte(gpte))
+                       if (is_present_gpte(gpte))
                                nonpresent = shadow_trap_nonpresent_pte;
                        else
                                nonpresent = shadow_notrap_nonpresent_pte;
-                       set_shadow_pte(&sp->spt[i], nonpresent);
+                       __set_spte(&sp->spt[i], nonpresent);
                        continue;
                }
 
                nr_present++;
                pte_access = sp->role.access & FNAME(gpte_access)(vcpu, gpte);
                set_spte(vcpu, &sp->spt[i], pte_access, 0, 0,
-                        is_dirty_pte(gpte), 0, gfn,
+                        is_dirty_gpte(gpte), 0, gfn,
                         spte_to_pfn(sp->spt[i]), true, false);
        }