KVM: x86/mmu: Move "huge page disallowed" calculation into mapping helpers

Calculate huge_page_disallowed in __direct_map() and FNAME(fetch) in
preparation for reworking the calculation so that it preserves the
requested map level and eventually to avoid flagging a shadow page as
being disallowed for being used as a large/huge page when it couldn't
have been huge in the first place, e.g. because the backing page in the
host is not large.

Pass the error code into the helpers and use it to recalcuate exec and
write_fault instead adding yet more booleans to the parameters.

Opportunistically use huge_page_disallowed instead of lpage_disallowed
to match the nomenclature used within the mapping helpers (though even
they have existing inconsistencies).

No functional change intended.

Signed-off-by: Sean Christopherson <sean.j.christopherson@intel.com>
Message-Id: <20200923183735.584-4-sean.j.christopherson@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c
index a4cbf5e1499194737a5bbbb7b64102cc60c741af..fb156833af00cc25e795ae8162736b07a3413b7b 100644 (file)
--- a/arch/x86/kvm/mmu/mmu.c
+++ b/arch/x86/kvm/mmu/mmu.c
@@ -3335,10 +3335,14 @@ static void disallowed_hugepage_adjust(struct kvm_shadow_walk_iterator it,
        }
 }
 
-static int __direct_map(struct kvm_vcpu *vcpu, gpa_t gpa, int write,
+static int __direct_map(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,
                        int map_writable, int max_level, kvm_pfn_t pfn,
-                       bool prefault, bool account_disallowed_nx_lpage)
+                       bool prefault, bool is_tdp)
 {
+       bool nx_huge_page_workaround_enabled = is_nx_huge_page_enabled();
+       bool write = error_code & PFERR_WRITE_MASK;
+       bool exec = error_code & PFERR_FETCH_MASK;
+       bool huge_page_disallowed = exec && nx_huge_page_workaround_enabled;
        struct kvm_shadow_walk_iterator it;
        struct kvm_mmu_page *sp;
        int level, ret;
@@ -3348,6 +3352,9 @@ static int __direct_map(struct kvm_vcpu *vcpu, gpa_t gpa, int write,
        if (WARN_ON(!VALID_PAGE(vcpu->arch.mmu->root_hpa)))
                return RET_PF_RETRY;
 
+       if (huge_page_disallowed)
+               max_level = PG_LEVEL_4K;
+
        level = kvm_mmu_hugepage_adjust(vcpu, gfn, max_level, &pfn);
 
        trace_kvm_mmu_spte_requested(gpa, level, pfn);
@@ -3368,7 +3375,7 @@ static int __direct_map(struct kvm_vcpu *vcpu, gpa_t gpa, int write,
                                              it.level - 1, true, ACC_ALL);
 
                        link_shadow_page(vcpu, it.sptep, sp);
-                       if (account_disallowed_nx_lpage)
+                       if (is_tdp && huge_page_disallowed)
                                account_huge_nx_page(vcpu->kvm, sp);
                }
        }
@@ -4108,8 +4115,6 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,
                             bool prefault, int max_level, bool is_tdp)
 {
        bool write = error_code & PFERR_WRITE_MASK;
-       bool exec = error_code & PFERR_FETCH_MASK;
-       bool lpage_disallowed = exec && is_nx_huge_page_enabled();
        bool map_writable;
 
        gfn_t gfn = gpa >> PAGE_SHIFT;
@@ -4128,9 +4133,6 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,
        if (r)
                return r;
 
-       if (lpage_disallowed)
-               max_level = PG_LEVEL_4K;
-
        mmu_seq = vcpu->kvm->mmu_notifier_seq;
        smp_rmb();
 
@@ -4147,8 +4149,8 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, gpa_t gpa, u32 error_code,
        r = make_mmu_pages_available(vcpu);
        if (r)
                goto out_unlock;
-       r = __direct_map(vcpu, gpa, write, map_writable, max_level, pfn,
-                        prefault, is_tdp && lpage_disallowed);
+       r = __direct_map(vcpu, gpa, error_code, map_writable, max_level, pfn,
+                        prefault, is_tdp);
 
 out_unlock:
        spin_unlock(&vcpu->kvm->mmu_lock);

diff --git a/arch/x86/kvm/mmu/paging_tmpl.h b/arch/x86/kvm/mmu/paging_tmpl.h
index 188ec2633bc56caff44ff957d940fc8be7f5c99d..cbb6ed32feadec7d2cfe931c358e1b2b9fa96cbf 100644 (file)
--- a/arch/x86/kvm/mmu/paging_tmpl.h
+++ b/arch/x86/kvm/mmu/paging_tmpl.h
@@ -625,11 +625,14 @@ static void FNAME(pte_prefetch)(struct kvm_vcpu *vcpu, struct guest_walker *gw,
  * emulate this operation, return 1 to indicate this case.
  */
 static int FNAME(fetch)(struct kvm_vcpu *vcpu, gpa_t addr,
-                        struct guest_walker *gw,
-                        int write_fault, int max_level,
-                        kvm_pfn_t pfn, bool map_writable, bool prefault,
-                        bool lpage_disallowed)
+                        struct guest_walker *gw, u32 error_code,
+                        int max_level, kvm_pfn_t pfn, bool map_writable,
+                        bool prefault)
 {
+       bool nx_huge_page_workaround_enabled = is_nx_huge_page_enabled();
+       int write_fault = error_code & PFERR_WRITE_MASK;
+       bool exec = error_code & PFERR_FETCH_MASK;
+       bool huge_page_disallowed = exec && nx_huge_page_workaround_enabled;
        struct kvm_mmu_page *sp = NULL;
        struct kvm_shadow_walk_iterator it;
        unsigned direct_access, access = gw->pt_access;
@@ -679,6 +682,9 @@ static int FNAME(fetch)(struct kvm_vcpu *vcpu, gpa_t addr,
                        link_shadow_page(vcpu, it.sptep, sp);
        }
 
+       if (huge_page_disallowed)
+               max_level = PG_LEVEL_4K;
+
        hlevel = kvm_mmu_hugepage_adjust(vcpu, gw->gfn, max_level, &pfn);
 
        trace_kvm_mmu_spte_requested(addr, gw->level, pfn);
@@ -704,7 +710,7 @@ static int FNAME(fetch)(struct kvm_vcpu *vcpu, gpa_t addr,
                        sp = kvm_mmu_get_page(vcpu, base_gfn, addr,
                                              it.level - 1, true, direct_access);
                        link_shadow_page(vcpu, it.sptep, sp);
-                       if (lpage_disallowed)
+                       if (huge_page_disallowed)
                                account_huge_nx_page(vcpu->kvm, sp);
                }
        }
@@ -786,8 +792,6 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gpa_t addr, u32 error_code,
        kvm_pfn_t pfn;
        unsigned long mmu_seq;
        bool map_writable, is_self_change_mapping;
-       bool lpage_disallowed = (error_code & PFERR_FETCH_MASK) &&
-                               is_nx_huge_page_enabled();
        int max_level;
 
        pgprintk("%s: addr %lx err %x\n", __func__, addr, error_code);
@@ -828,7 +832,7 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gpa_t addr, u32 error_code,
        is_self_change_mapping = FNAME(is_self_change_mapping)(vcpu,
              &walker, user_fault, &vcpu->arch.write_fault_to_shadow_pgtable);
 
-       if (lpage_disallowed || is_self_change_mapping)
+       if (is_self_change_mapping)
                max_level = PG_LEVEL_4K;
        else
                max_level = walker.level;
@@ -872,8 +876,8 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gpa_t addr, u32 error_code,
        r = make_mmu_pages_available(vcpu);
        if (r)
                goto out_unlock;
-       r = FNAME(fetch)(vcpu, addr, &walker, write_fault, max_level, pfn,
-                        map_writable, prefault, lpage_disallowed);
+       r = FNAME(fetch)(vcpu, addr, &walker, error_code, max_level, pfn,
+                        map_writable, prefault);
        kvm_mmu_audit(vcpu, AUDIT_POST_PAGE_FAULT);
 
 out_unlock: