From mboxrd@z Thu Jan 1 00:00:00 1970 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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9F248C433FE for ; Wed, 16 Nov 2022 20:50:29 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id B727E8E0001; Wed, 16 Nov 2022 15:50:28 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id B216A6B0073; Wed, 16 Nov 2022 15:50:28 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 9E9C98E0001; Wed, 16 Nov 2022 15:50:28 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id 8F8856B0071 for ; Wed, 16 Nov 2022 15:50:28 -0500 (EST) Received: from smtpin30.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay04.hostedemail.com (Postfix) with ESMTP id 488C41A0CB6 for ; Wed, 16 Nov 2022 20:50:28 +0000 (UTC) X-FDA: 80140498536.30.B94D33A Received: from mail-pl1-f202.google.com (mail-pl1-f202.google.com [209.85.214.202]) by imf20.hostedemail.com (Postfix) with ESMTP id A6D2B1C0004 for ; Wed, 16 Nov 2022 20:50:27 +0000 (UTC) Received: by mail-pl1-f202.google.com with SMTP id p18-20020a170902a41200b00188e87d0f04so339964plq.14 for ; Wed, 16 Nov 2022 12:50:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=Vm8HknjbQpP5x1fHUQZ8Fa+JhrBUsKYRYb84Ljw06/8=; b=BxC9ZIiQoKs8ZVqFtGoVwkhZjhvx+R8PRQB6GTtgA210grIKaMUfq2t0MWY3kI6kkp Ri7QGvFmdcQHkk1hdrwKgiBlH7UL9kkXPXLqHdnAIp3PIrrDNkNKuXekVJ7+ZRLfdmPg cQkuCip07OmxTzEL5JEZGej5dA3zvd1W4OtdIo2gBJqiIu2fJkfRqzbucnRGJGmvoaGQ JeagXDUkI3LTmVilwN+XEnCxUy4kfrqeJ1CvBsbW5yvysO4wop2f/STxLeY9zAtDUUFw n8gsLiJIOgQlD8T85gNo08kYyGRdhjrlcaafVDzmuk2vc2ElQCmnrFZnsbi5bwPjtr2C xOpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=Vm8HknjbQpP5x1fHUQZ8Fa+JhrBUsKYRYb84Ljw06/8=; b=kByxzuco12SZvBPhUy10xipdWJjnOXJI96komV1ROzXPk126qg8roYZJl734raTiS3 vYxLYKyaXG8Q/i47mJIEEg2syr2AU5WnX6NgqpuBbiP8ojcYMuXvjDOKI9CdhuRfD2Ti hFEfta3GKRLwpx1o3td1I+0WmNq3uojuxvGi+0y3Yz29T5E5cfAHUbkWsSkf/dMCRQHP 1OMxdPe1kGBIFBQCPt48id6AxvqLPraVWIdCaFQkkK3Pqc16r1BwsgPyuL6CkMVgXfGR raOiVMar/oI1D1J+hY1SC6DwsEkBxAxxDOT5TPaco4SmptJ0J97LspDrBU4SseKAdXIP 45nQ== X-Gm-Message-State: ANoB5pnlKz6tQaNu4Jf8sIVO2iOR661QRbmVkkSdpZDhkNQ7XDIeIety MaUB1WDJbTnMMHAkc1kD64G2cl23/siP4+MmzA== X-Google-Smtp-Source: AA0mqf41ZmTXB/mfU/GsYmUkRkGNKElgXElKSWsJxXMeA5xlBE38lutMTDBINT6VM1Rkky14pOwbEWAq8JgrwGlebg== X-Received: from ackerleytng-cloudtop.c.googlers.com ([fda3:e722:ac3:cc00:7f:e700:c0a8:1f5f]) (user=ackerleytng job=sendgmr) by 2002:aa7:9041:0:b0:572:9681:1018 with SMTP id n1-20020aa79041000000b0057296811018mr6472865pfo.39.1668631826322; Wed, 16 Nov 2022 12:50:26 -0800 (PST) Date: Wed, 16 Nov 2022 20:50:25 +0000 In-Reply-To: <20221025151344.3784230-8-chao.p.peng@linux.intel.com> Mime-Version: 1.0 References: <20221025151344.3784230-8-chao.p.peng@linux.intel.com> X-Mailer: git-send-email 2.38.1.584.g0f3c55d4c2-goog Message-ID: <20221116205025.1510291-1-ackerleytng@google.com> Subject: Re: [PATCH v9 7/8] KVM: Handle page fault for private memory From: Ackerley Tng To: chao.p.peng@linux.intel.com Cc: aarcange@redhat.com, ak@linux.intel.com, akpm@linux-foundation.org, bfields@fieldses.org, bp@alien8.de, corbet@lwn.net, dave.hansen@intel.com, david@redhat.com, ddutile@redhat.com, dhildenb@redhat.com, hpa@zytor.com, hughd@google.com, jlayton@kernel.org, jmattson@google.com, joro@8bytes.org, jun.nakajima@intel.com, kirill.shutemov@linux.intel.com, kvm@vger.kernel.org, linux-api@vger.kernel.org, linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, luto@kernel.org, mail@maciej.szmigiero.name, mhocko@suse.com, michael.roth@amd.com, mingo@redhat.com, pbonzini@redhat.com, qemu-devel@nongnu.org, qperret@google.com, rppt@kernel.org, seanjc@google.com, shuah@kernel.org, songmuchun@bytedance.com, steven.price@arm.com, tabba@google.com, tglx@linutronix.de, vannapurve@google.com, vbabka@suse.cz, vkuznets@redhat.com, wanpengli@tencent.com, wei.w.wang@intel.com, x86@kernel.org, yu.c.zhang@linux.intel.com Content-Type: text/plain; charset="UTF-8" ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1668631827; a=rsa-sha256; cv=none; b=wogfKbKU2UF7lRcjjipe5SC2hkSpWg5PJ1/WJTPOA/KKrtL9/EfQOh4kd6z69xNvW0wqhn rJUhBBTapLheXJzzkIVQl/4Twh8iTGRlW7sUky1E+CDEiT5vPn9acsUit7wi44+bhmsSRX KmcgATcldTAg6w81fTtJwAlb8ouqSXw= ARC-Authentication-Results: i=1; imf20.hostedemail.com; dkim=pass header.d=google.com header.s=20210112 header.b=BxC9ZIiQ; dmarc=pass (policy=reject) header.from=google.com; spf=pass (imf20.hostedemail.com: domain of 3Ek11YwsKCKMDFNHUOHbWQJJRRJOH.FRPOLQXa-PPNYDFN.RUJ@flex--ackerleytng.bounces.google.com designates 209.85.214.202 as permitted sender) smtp.mailfrom=3Ek11YwsKCKMDFNHUOHbWQJJRRJOH.FRPOLQXa-PPNYDFN.RUJ@flex--ackerleytng.bounces.google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1668631827; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=Vm8HknjbQpP5x1fHUQZ8Fa+JhrBUsKYRYb84Ljw06/8=; b=Y7Q83MT880wPyDxn5otvopT5m8BEYwb8QHhtPHrmMQgb028NkjLdLY1QPLBsj1dg0J+Ow0 WvuZLIXDNhhvhiIX3+u24VgzEcOQNp3WRmtdVpSr5gVT4qopWAT9f4Vx0b0dXdpeqQDqji 4GNLkdVkdgvlb5VlZ5s4JoZWQFrwEzA= Authentication-Results: imf20.hostedemail.com; dkim=pass header.d=google.com header.s=20210112 header.b=BxC9ZIiQ; dmarc=pass (policy=reject) header.from=google.com; spf=pass (imf20.hostedemail.com: domain of 3Ek11YwsKCKMDFNHUOHbWQJJRRJOH.FRPOLQXa-PPNYDFN.RUJ@flex--ackerleytng.bounces.google.com designates 209.85.214.202 as permitted sender) smtp.mailfrom=3Ek11YwsKCKMDFNHUOHbWQJJRRJOH.FRPOLQXa-PPNYDFN.RUJ@flex--ackerleytng.bounces.google.com X-Rspam-User: X-Stat-Signature: 6qcouyeeny7z6fpomor8yiiguua7m8up X-Rspamd-Queue-Id: A6D2B1C0004 X-Rspamd-Server: rspam11 X-HE-Tag: 1668631827-906543 X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: > A memslot with KVM_MEM_PRIVATE being set can include both fd-based > private memory and hva-based shared memory. Architecture code (like TDX > code) can tell whether the on-going fault is private or not. This patch > adds a 'is_private' field to kvm_page_fault to indicate this and > architecture code is expected to set it. > > To handle page fault for such memslot, the handling logic is different > depending on whether the fault is private or shared. KVM checks if > 'is_private' matches the host's view of the page (maintained in > mem_attr_array). > - For a successful match, private pfn is obtained with > restrictedmem_get_page () from private fd and shared pfn is obtained > with existing get_user_pages(). > - For a failed match, KVM causes a KVM_EXIT_MEMORY_FAULT exit to > userspace. Userspace then can convert memory between private/shared > in host's view and retry the fault. > > Co-developed-by: Yu Zhang > Signed-off-by: Yu Zhang > Signed-off-by: Chao Peng > --- > arch/x86/kvm/mmu/mmu.c | 56 +++++++++++++++++++++++++++++++-- > arch/x86/kvm/mmu/mmu_internal.h | 14 ++++++++- > arch/x86/kvm/mmu/mmutrace.h | 1 + > arch/x86/kvm/mmu/spte.h | 6 ++++ > arch/x86/kvm/mmu/tdp_mmu.c | 3 +- > include/linux/kvm_host.h | 28 +++++++++++++++++ > 6 files changed, 103 insertions(+), 5 deletions(-) > > diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c > index 67a9823a8c35..10017a9f26ee 100644 > --- a/arch/x86/kvm/mmu/mmu.c > +++ b/arch/x86/kvm/mmu/mmu.c > @@ -3030,7 +3030,7 @@ static int host_pfn_mapping_level(struct kvm *kvm, gfn_t gfn, > > int kvm_mmu_max_mapping_level(struct kvm *kvm, > const struct kvm_memory_slot *slot, gfn_t gfn, > - int max_level) > + int max_level, bool is_private) > { > struct kvm_lpage_info *linfo; > int host_level; > @@ -3042,6 +3042,9 @@ int kvm_mmu_max_mapping_level(struct kvm *kvm, > break; > } > > + if (is_private) > + return max_level; > + > if (max_level == PG_LEVEL_4K) > return PG_LEVEL_4K; > > @@ -3070,7 +3073,8 @@ void kvm_mmu_hugepage_adjust(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault > * level, which will be used to do precise, accurate accounting. > */ > fault->req_level = kvm_mmu_max_mapping_level(vcpu->kvm, slot, > - fault->gfn, fault->max_level); > + fault->gfn, fault->max_level, > + fault->is_private); > if (fault->req_level == PG_LEVEL_4K || fault->huge_page_disallowed) > return; > > @@ -4141,6 +4145,32 @@ void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu, struct kvm_async_pf *work) > kvm_mmu_do_page_fault(vcpu, work->cr2_or_gpa, 0, true); > } > > +static inline u8 order_to_level(int order) > +{ > + BUILD_BUG_ON(KVM_MAX_HUGEPAGE_LEVEL > PG_LEVEL_1G); > + > + if (order >= KVM_HPAGE_GFN_SHIFT(PG_LEVEL_1G)) > + return PG_LEVEL_1G; > + > + if (order >= KVM_HPAGE_GFN_SHIFT(PG_LEVEL_2M)) > + return PG_LEVEL_2M; > + > + return PG_LEVEL_4K; > +} > + > +static int kvm_faultin_pfn_private(struct kvm_page_fault *fault) > +{ > + int order; > + struct kvm_memory_slot *slot = fault->slot; > + > + if (kvm_restricted_mem_get_pfn(slot, fault->gfn, &fault->pfn, &order)) >+ return RET_PF_RETRY; >+ >+ fault->max_level = min(order_to_level(order), fault->max_level); >+ fault->map_writable = !(slot->flags & KVM_MEM_READONLY); >+ return RET_PF_CONTINUE; >+} >+ > static int kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault) > { > struct kvm_memory_slot *slot = fault->slot; >@@ -4173,6 +4203,22 @@ static int kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault) > return RET_PF_EMULATE; > } > >+ if (kvm_slot_can_be_private(slot) && >+ fault->is_private != kvm_mem_is_private(vcpu->kvm, fault->gfn)) { >+ vcpu->run->exit_reason = KVM_EXIT_MEMORY_FAULT; >+ if (fault->is_private) >+ vcpu->run->memory.flags = KVM_MEMORY_EXIT_FLAG_PRIVATE; >+ else >+ vcpu->run->memory.flags = 0; >+ vcpu->run->memory.padding = 0; >+ vcpu->run->memory.gpa = fault->gfn << PAGE_SHIFT; >+ vcpu->run->memory.size = PAGE_SIZE; >+ return RET_PF_USER; >+ } >+ >+ if (fault->is_private) >+ return kvm_faultin_pfn_private(fault); >+ Since each memslot may also not be backed by restricted memory, we should also check if the memslot has been set up for private memory with if (fault->is_private && kvm_slot_can_be_private(slot)) return kvm_faultin_pfn_private(fault); Without this check, restrictedmem_get_page will get called with NULL in slot->restricted_file, which causes a NULL pointer dereference. > async = false; > fault->pfn = __gfn_to_pfn_memslot(slot, fault->gfn, false, &async, > fault->write, &fault->map_writable, >@@ -5557,6 +5603,9 @@ int noinline kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, u64 err > return -EIO; > } > >+ if (r == RET_PF_USER) >+ return 0; >+ > if (r < 0) > return r; > if (r != RET_PF_EMULATE) >@@ -6408,7 +6457,8 @@ static bool kvm_mmu_zap_collapsible_spte(struct kvm *kvm, > */ > if (sp->role.direct && > sp->role.level < kvm_mmu_max_mapping_level(kvm, slot, sp->gfn, >- PG_LEVEL_NUM)) { >+ PG_LEVEL_NUM, >+ false)) { > kvm_zap_one_rmap_spte(kvm, rmap_head, sptep); > > if (kvm_available_flush_tlb_with_range())