From nobody Thu Sep 18 07:00:24 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D427CC4167B for ; Thu, 8 Dec 2022 23:37:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230368AbiLHXg7 (ORCPT ); Thu, 8 Dec 2022 18:36:59 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45664 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230208AbiLHXgJ (ORCPT ); Thu, 8 Dec 2022 18:36:09 -0500 Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B82BE70B81; Thu, 8 Dec 2022 15:36:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1670542562; x=1702078562; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=OruNx6JSRjFi416SwFgD4HRIwqgwPkuEngRvcyMCZnU=; b=hsMgtmVxyBGqayhCC/kDtWG5WGiiLYX1BXgftIOLtfswYYcHn8LhXX4C FcKuFDnVWWH8zMysPD6HjUpcOFsU37to9skkhsxjMs7uKB0bn6xAiTRJu nE7S7zXiRPxJGmRDRj+28ROgoK3xCCNNOhsZntsJUICbRBC5BC4IeAKi2 pKsWMPAEMWV91uDrU3HpqOjXHJeZ7jXG8z9ymsR8QyW16DfVmMoxnpAnE 1guA5OmHTHvWBn5GpJH4PNcSio6tbGhSUK5cfw7BmljwMef0UrBoaaW1L 3YTZpNBkdXF2CYXzxfkqAKjIoeI9Q/6RnSfvB6Ju3ekCy9EEmiBxf+hKF w==; X-IronPort-AV: E=McAfee;i="6500,9779,10555"; a="403586567" X-IronPort-AV: E=Sophos;i="5.96,228,1665471600"; d="scan'208";a="403586567" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Dec 2022 15:36:01 -0800 X-IronPort-AV: E=McAfee;i="6500,9779,10555"; a="677951038" X-IronPort-AV: E=Sophos;i="5.96,228,1665471600"; d="scan'208";a="677951038" Received: from ls.sc.intel.com (HELO localhost) ([143.183.96.54]) by orsmga008-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Dec 2022 15:36:01 -0800 From: isaku.yamahata@intel.com To: kvm@vger.kernel.org, linux-kernel@vger.kernel.org Cc: isaku.yamahata@intel.com, isaku.yamahata@gmail.com, Paolo Bonzini , Sean Christopherson , David Matlack Subject: [RFC PATCH v2 14/15] KVM: x86/mmu: Make kvm fault handelr aware of large page of private memslot Date: Thu, 8 Dec 2022 15:35:49 -0800 Message-Id: <96c1c1e2281e9172244c838ccccc4c32bc150b34.1670541736.git.isaku.yamahata@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Isaku Yamahata struct kvm_page_fault.req_level is the page level which takes care of the faulted-in page size. For now its calculation is only for the conventional kvm memslot by host_pfn_mapping_level() that traverses page table. However, host_pfn_mapping_level() cannot be used for private kvm memslot because pages of private kvm memlost aren't mapped into user virtual address space. Instead page order is given when getting pfn. Remember it in struct kvm_page_fault and use it. Signed-off-by: Isaku Yamahata --- arch/x86/kvm/mmu/mmu.c | 36 +++++++++++++++++++++------------ arch/x86/kvm/mmu/mmu_internal.h | 8 ++++++++ 2 files changed, 31 insertions(+), 13 deletions(-) diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 7f56b1dd76fa..c011ea0b6444 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -3132,12 +3132,12 @@ static int host_pfn_mapping_level(struct kvm *kvm, = gfn_t gfn, return level; } =20 -int kvm_mmu_max_mapping_level(struct kvm *kvm, - const struct kvm_memory_slot *slot, gfn_t gfn, - int max_level, bool is_private) +static int __kvm_mmu_max_mapping_level(struct kvm *kvm, + const struct kvm_memory_slot *slot, + gfn_t gfn, int max_level, int host_level, + bool faultin_private) { struct kvm_lpage_info *linfo; - int host_level; =20 max_level =3D min(max_level, max_huge_page_level); for ( ; max_level > PG_LEVEL_4K; max_level--) { @@ -3146,16 +3146,24 @@ int kvm_mmu_max_mapping_level(struct kvm *kvm, break; } =20 - if (is_private) - return max_level; - if (max_level =3D=3D PG_LEVEL_4K) return PG_LEVEL_4K; =20 - host_level =3D host_pfn_mapping_level(kvm, gfn, slot); + if (!faultin_private) { + WARN_ON_ONCE(host_level !=3D PG_LEVEL_NONE); + host_level =3D host_pfn_mapping_level(kvm, gfn, slot); + } + WARN_ON_ONCE(host_level =3D=3D PG_LEVEL_NONE); return min(host_level, max_level); } =20 +int kvm_mmu_max_mapping_level(struct kvm *kvm, + const struct kvm_memory_slot *slot, gfn_t gfn, + int max_level, bool faultin_private) +{ + return __kvm_mmu_max_mapping_level(kvm, slot, gfn, max_level, PG_LEVEL_NO= NE, faultin_private); +} + void kvm_mmu_hugepage_adjust(struct kvm_vcpu *vcpu, struct kvm_page_fault = *fault) { struct kvm_memory_slot *slot =3D fault->slot; @@ -3176,9 +3184,10 @@ void kvm_mmu_hugepage_adjust(struct kvm_vcpu *vcpu, = struct kvm_page_fault *fault * Enforce the iTLB multihit workaround after capturing the requested * level, which will be used to do precise, accurate accounting. */ - fault->req_level =3D kvm_mmu_max_mapping_level(vcpu->kvm, slot, - fault->gfn, fault->max_level, - fault->is_private); + fault->req_level =3D __kvm_mmu_max_mapping_level(vcpu->kvm, slot, + fault->gfn, fault->max_level, + fault->host_level, + kvm_is_faultin_private(fault)); if (fault->req_level =3D=3D PG_LEVEL_4K || fault->huge_page_disallowed) return; =20 @@ -4311,7 +4320,8 @@ static int kvm_faultin_pfn_private(struct kvm_vcpu *v= cpu, if (kvm_restricted_mem_get_pfn(slot, fault->gfn, &fault->pfn, &order)) return RET_PF_RETRY; =20 - fault->max_level =3D min(order_to_level(order), fault->max_level); + fault->host_level =3D order_to_level(order); + fault->max_level =3D min((u8)fault->host_level, fault->max_level); fault->map_writable =3D !(slot->flags & KVM_MEM_READONLY); return RET_PF_CONTINUE; } @@ -4355,7 +4365,7 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, s= truct kvm_page_fault *fault if (fault->is_private !=3D kvm_mem_is_private(vcpu->kvm, fault->gfn)) return kvm_do_memory_fault_exit(vcpu, fault); =20 - if (fault->is_private && kvm_slot_can_be_private(slot)) + if (kvm_is_faultin_private(fault)) return kvm_faultin_pfn_private(vcpu, fault); =20 async =3D false; diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_interna= l.h index 2b7c16dfdf5e..f7ff39b90ba4 100644 --- a/arch/x86/kvm/mmu/mmu_internal.h +++ b/arch/x86/kvm/mmu/mmu_internal.h @@ -333,6 +333,7 @@ struct kvm_page_fault { kvm_pfn_t pfn; hva_t hva; bool map_writable; + enum pg_level host_level; /* valid only for private memslot && private gf= n */ }; =20 int kvm_tdp_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault= ); @@ -446,4 +447,11 @@ static inline int kvm_restricted_mem_get_pfn(struct kv= m_memory_slot *slot, } #endif /* CONFIG_HAVE_KVM_RESTRICTED_MEM */ =20 +static inline bool kvm_is_faultin_private(const struct kvm_page_fault *fau= lt) +{ + if (IS_ENABLED(CONFIG_HAVE_KVM_RESTRICTED_MEM)) + return fault->is_private && kvm_slot_can_be_private(fault->slot); + return false; +} + #endif /* __KVM_X86_MMU_INTERNAL_H */ --=20 2.25.1