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 3614AEB64DC for ; Fri, 21 Jul 2023 15:09:51 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id A68D76B0071; Fri, 21 Jul 2023 11:09:50 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id A18D56B0074; Fri, 21 Jul 2023 11:09:50 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 8B9FB6B0075; Fri, 21 Jul 2023 11:09:50 -0400 (EDT) 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 7CC956B0071 for ; Fri, 21 Jul 2023 11:09:50 -0400 (EDT) Received: from smtpin28.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 4C638140329 for ; Fri, 21 Jul 2023 15:09:50 +0000 (UTC) X-FDA: 81035953740.28.3E1BE06 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by imf16.hostedemail.com (Postfix) with ESMTP id BF25218002E for ; Fri, 21 Jul 2023 15:09:47 +0000 (UTC) Authentication-Results: imf16.hostedemail.com; dkim=pass header.d=redhat.com header.s=mimecast20190719 header.b="Gp1RZe/e"; dmarc=pass (policy=none) header.from=redhat.com; spf=pass (imf16.hostedemail.com: domain of pbonzini@redhat.com designates 170.10.129.124 as permitted sender) smtp.mailfrom=pbonzini@redhat.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1689952187; 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:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=0vmYiJ2McNnP+cgtfjeAKniOHtUlesHHQnwePocmwMM=; b=jyTwvl9etJBTK0vBkphhAZQNKd9vGHw3pAOak/hN13bxkWRSGMvw+m2ARL08G6f0UseR2f 3znPDJDLEwzO+2rHVdvh/dBzvyt9gmDurm5dz0oEpi46d9x2sqS18PSXXa2O//V+TedkfE Hy+qgZwdgiBPNDuAtaUugGMOFmluopg= ARC-Authentication-Results: i=1; imf16.hostedemail.com; dkim=pass header.d=redhat.com header.s=mimecast20190719 header.b="Gp1RZe/e"; dmarc=pass (policy=none) header.from=redhat.com; spf=pass (imf16.hostedemail.com: domain of pbonzini@redhat.com designates 170.10.129.124 as permitted sender) smtp.mailfrom=pbonzini@redhat.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1689952187; a=rsa-sha256; cv=none; b=fJiYuEzW0HeaAumodceZzjUJ35dJfASS4oBI9cwfrfmoKJmB77KPrzZGARsAH56Jzx7i7/ fbCx77Sp4Q127R29Uj4jmzBopOkFyi1yOpyHwpejuZJKODmWwH9xS97gT9GjDLmy6Embbi O5VOzHHtj3Q9194zIfjFIiaeK3DIupY= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1689952186; h=from:from: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:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=0vmYiJ2McNnP+cgtfjeAKniOHtUlesHHQnwePocmwMM=; b=Gp1RZe/eX0sx8D/pJpTysbGIHqoOjb+4kmsW5A6FYKlkcCIyjavtkUsGJgAFNUtE/Q1S8T 0MZbM5halPhXtZW66W8+aEjfELLbv5q/pxRQUwG1PQIMjVNokviAbewa1lJ9PBoX4Pasp6 g8egOESY0y2iGSB/8PZNKv4oq47Avbw= Received: from mail-lf1-f69.google.com (mail-lf1-f69.google.com [209.85.167.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-401-RMQTXDMTMZyyoo4J7FWukg-1; Fri, 21 Jul 2023 11:09:45 -0400 X-MC-Unique: RMQTXDMTMZyyoo4J7FWukg-1 Received: by mail-lf1-f69.google.com with SMTP id 2adb3069b0e04-4fbcdca8fcbso2004833e87.1 for ; Fri, 21 Jul 2023 08:09:45 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1689952184; x=1690556984; h=content-transfer-encoding:in-reply-to:from:references:cc:to :content-language:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=0vmYiJ2McNnP+cgtfjeAKniOHtUlesHHQnwePocmwMM=; b=g7HaBQjP+ymmDAyL3uGcuIqtQeZvgq7tZYDqCXUZ//49cuzO8RKoI0kZyIGw3iDYi6 QhsrpxThZ1VqNmWC32ftnN5rBCj+qgli1sHGCWeO1jkQAMV85anOHXWqwHS0kXmhv2fg ULySDM/PXXCMCZPy0I2R4E9sImuWFOJC+aHy6slsHbxwdsTTBVRW+U0wfGkZ17anmSK9 aUN+sYjdzkemg42m5WbncA9awaaDN/1FclOckda0LUPp41f5JRM08BYlHDJ6kgZNb+Df 8c86tewIpLf0zblIsnqGynXdLkSMeQMxcixySmfSh+iVL0fpqYk1A6/0j/Xco1h0YR2W KZGg== X-Gm-Message-State: ABy/qLYRvXnrnLGEB63lG3SOHWfYN+LyV00EizroqZh57OhnZTODVuPa my534pGrUaFr+2rVjegxHU4cLyhQwyJo3p73WnXaJ4ugn4O1xH75CcWTsKmB30hNJAf61AB6wW/ 3oQkRJUq1ptM= X-Received: by 2002:a05:6512:328d:b0:4fb:9050:1d92 with SMTP id p13-20020a056512328d00b004fb90501d92mr1367601lfe.51.1689952183970; Fri, 21 Jul 2023 08:09:43 -0700 (PDT) X-Google-Smtp-Source: APBJJlFPJFXvjHxdY0caGfwUnetqbu+BXv0f0ZakHLJfQbsd3FM7efS9VuBluWIt3TKTV7uVBQdwmQ== X-Received: by 2002:a05:6512:328d:b0:4fb:9050:1d92 with SMTP id p13-20020a056512328d00b004fb90501d92mr1367563lfe.51.1689952183505; Fri, 21 Jul 2023 08:09:43 -0700 (PDT) Received: from ?IPV6:2001:b07:6468:f312:9af8:e5f5:7516:fa89? ([2001:b07:6468:f312:9af8:e5f5:7516:fa89]) by smtp.googlemail.com with ESMTPSA id d17-20020aa7ce11000000b00521d42fb41asm2212963edv.67.2023.07.21.08.09.41 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 21 Jul 2023 08:09:42 -0700 (PDT) Message-ID: <68ce1eff-807c-d637-d992-f83e8af81514@redhat.com> Date: Fri, 21 Jul 2023 17:09:40 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.13.0 Subject: Re: [RFC PATCH v11 14/29] KVM: x86/mmu: Handle page fault for private memory To: Sean Christopherson , Marc Zyngier , Oliver Upton , Huacai Chen , Michael Ellerman , Anup Patel , Paul Walmsley , Palmer Dabbelt , Albert Ou , "Matthew Wilcox (Oracle)" , Andrew Morton , Paul Moore , James Morris , "Serge E. Hallyn" Cc: kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.linux.dev, linux-mips@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, kvm-riscv@lists.infradead.org, linux-riscv@lists.infradead.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, linux-security-module@vger.kernel.org, linux-kernel@vger.kernel.org, Chao Peng , Fuad Tabba , Jarkko Sakkinen , Yu Zhang , Vishal Annapurve , Ackerley Tng , Maciej Szmigiero , Vlastimil Babka , David Hildenbrand , Quentin Perret , Michael Roth , Wang , Liam Merwick , Isaku Yamahata , "Kirill A . Shutemov" References: <20230718234512.1690985-1-seanjc@google.com> <20230718234512.1690985-15-seanjc@google.com> From: Paolo Bonzini In-Reply-To: <20230718234512.1690985-15-seanjc@google.com> X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-Rspamd-Queue-Id: BF25218002E X-Rspam-User: X-Rspamd-Server: rspam04 X-Stat-Signature: fz9b1rbw5mqha6mccyinochptwt9hq9z X-HE-Tag: 1689952187-751068 X-HE-Meta: U2FsdGVkX1/qo/5d7XakXqcHymw/MDHQ+aNDeqKAHjFJ9sbpXGygUuYJi2lKxzlRCcgXNZb2AAq8j7CvBtZSnC0fyBTaJyywD42/NSnhc0JLGZF6PgIakr5TMtkLEH2uX1sEh+DggIpPAyPmsqUeNTk39LPUF3ctEmCTrp8Fa98XLxrJ3awvck9xLcnh3McMYdqtQCfYhmtjkdM3tKf99Z2TdIhBURELFKwMuxsxbOztudMtLAgDF60ASPFgvfhplTX9kIIcGrA6MpishFt5qC2RXvazBznPLqRVpSAsPXX2UNaHb3NiUI4kzJ0iWMwT0pNRb2y9mVtTsmaFnXHksoKzdr2xUqyJsdFLPP3nwTVYlyeuc3WkY5ZlfaB/FhYcp+5Dt42jNWT/9LSBfGbzqNaxY4wfnIdDH1KSEamw38aXaZoHZSiWGoI+nKI7hvDANrT/fFh8iUJTTiFVJNLIffJpax3W/DIYxEl/5FYLTptrlVTExY2kWdWtgdOaqA8x8AsTncVaGOgAVJ3afCvnWrkeSlehR7tQGkkaEinOmZpVi6arBd4KnpcJYPA+4PjBqvjP7FKAqgiX6phcggTy2kp689Y1caen10CjhQ5eKdi+8dcKg3A2NCYueB1AbeRvUmubHqCLTp/Ep6CWOgB+BV+PeCHgnciAtZK4Zq0CSV4WJD4+XXkwAXfTTJzobVBeIpi4YTIhb8qdWmZavOcUgAsWgjYnz6vDjTg+p6FFILMDpsz3sVQfifqi2vS/3xgWo0bEyia3JGEf1QTaCTyE6ZcCMcQhMNCeUuX835ERLvoXuxY06PMde5QZ8Dwb671uedRRMSCVa/beqI9GXRIya0CIfb9EQ9Nr0pLLMpAXBeyrwHmn0Ar7WcD0naD+2VAoHcN5CdbmO1ZOD17FNe5F8AsoexZT2BJtniyhd7KgBayzXM0zgrZJMyp5HHq3Fa5chLsriOEP9PbyoamT0sw 7YX0920U ReX4rLai+tavcoElP14PqImYT4O8tN9ainHCrQkw7OdmVhH0zxwSbfbVBMNcjIY6jHNpQw1Mg5dNm77rvp9CnFtgQ9h0hB6L8EJRk2c2DxRxoO4ElW394atEONpqGZEfU+qEaKdWQaNb2znJ99oe7DLvmMd23ksqDr2K0Vg3PhKuWjfguGHj/EZk6P7vWlEFHVmIfbgkB7Dqe3lO4qDZdOgSliExDdyxb8r1JJtanBhNhQm16SvTpsJGv6hZzmwPIb7Wcf3Pbos4GciXxzNj340pWL34qUyNDUaNYaFwCpXNaFFnCCC6VkqPNCpQbW89hm6CfluR2oSK/lCJJGvocUEFdhJu8pLdUK97CSw1EMU8L672IPt+nexCBHS/vtAGs9GIwZYJpLbDFph76udJFB8m3jjaBBhEd1EIA5VQ6QspFtXtufnaTXun6mXYNuhH/DcPdOV/1XbrwwimTT/ZQN752vIapKxmCMaQRK0AzZIpklPU= 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: On 7/19/23 01:44, Sean Christopherson wrote: > From: Chao Peng > > A KVM_MEM_PRIVATE memslot 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() 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 > Reviewed-by: Fuad Tabba > Tested-by: Fuad Tabba > Signed-off-by: Sean Christopherson > --- > arch/x86/kvm/mmu/mmu.c | 82 +++++++++++++++++++++++++++++++-- > arch/x86/kvm/mmu/mmu_internal.h | 3 ++ > arch/x86/kvm/mmu/mmutrace.h | 1 + > 3 files changed, 81 insertions(+), 5 deletions(-) > > diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c > index aefe67185637..4cf73a579ee1 100644 > --- a/arch/x86/kvm/mmu/mmu.c > +++ b/arch/x86/kvm/mmu/mmu.c > @@ -3179,9 +3179,9 @@ static int host_pfn_mapping_level(struct kvm *kvm, gfn_t gfn, > return level; > } > > -int kvm_mmu_max_mapping_level(struct kvm *kvm, > - const struct kvm_memory_slot *slot, gfn_t gfn, > - int max_level) > +static int __kvm_mmu_max_mapping_level(struct kvm *kvm, > + const struct kvm_memory_slot *slot, > + gfn_t gfn, int max_level, bool is_private) > { > struct kvm_lpage_info *linfo; > int host_level; > @@ -3193,6 +3193,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; > > @@ -3200,6 +3203,16 @@ int kvm_mmu_max_mapping_level(struct kvm *kvm, > return min(host_level, max_level); > } > > +int kvm_mmu_max_mapping_level(struct kvm *kvm, > + const struct kvm_memory_slot *slot, gfn_t gfn, > + int max_level) > +{ > + bool is_private = kvm_slot_can_be_private(slot) && > + kvm_mem_is_private(kvm, gfn); > + > + return __kvm_mmu_max_mapping_level(kvm, slot, gfn, max_level, is_private); > +} > + > void kvm_mmu_hugepage_adjust(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault) > { > struct kvm_memory_slot *slot = fault->slot; > @@ -3220,8 +3233,9 @@ 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 = kvm_mmu_max_mapping_level(vcpu->kvm, slot, > - fault->gfn, fault->max_level); > + fault->req_level = __kvm_mmu_max_mapping_level(vcpu->kvm, slot, > + fault->gfn, fault->max_level, > + fault->is_private); > if (fault->req_level == PG_LEVEL_4K || fault->huge_page_disallowed) > return; > > @@ -4304,6 +4318,55 @@ 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, NULL); > } > > +static inline u8 kvm_max_level_for_order(int order) > +{ > + BUILD_BUG_ON(KVM_MAX_HUGEPAGE_LEVEL > PG_LEVEL_1G); > + > + MMU_WARN_ON(order != KVM_HPAGE_GFN_SHIFT(PG_LEVEL_1G) && > + order != KVM_HPAGE_GFN_SHIFT(PG_LEVEL_2M) && > + order != KVM_HPAGE_GFN_SHIFT(PG_LEVEL_4K)); > + > + 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_do_memory_fault_exit(struct kvm_vcpu *vcpu, > + struct kvm_page_fault *fault) > +{ > + 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.gpa = fault->gfn << PAGE_SHIFT; > + vcpu->run->memory.size = PAGE_SIZE; > + return RET_PF_USER; > +} > + > +static int kvm_faultin_pfn_private(struct kvm_vcpu *vcpu, > + struct kvm_page_fault *fault) > +{ > + int max_order, r; > + > + if (!kvm_slot_can_be_private(fault->slot)) > + return kvm_do_memory_fault_exit(vcpu, fault); > + > + r = kvm_gmem_get_pfn(vcpu->kvm, fault->slot, fault->gfn, &fault->pfn, > + &max_order); > + if (r) > + return r; > + > + fault->max_level = min(kvm_max_level_for_order(max_order), > + fault->max_level); > + fault->map_writable = !(fault->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; > @@ -4336,6 +4399,12 @@ static int __kvm_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault > return RET_PF_EMULATE; > } > > + if (fault->is_private != kvm_mem_is_private(vcpu->kvm, fault->gfn)) > + return kvm_do_memory_fault_exit(vcpu, fault); > + > + if (fault->is_private) > + return kvm_faultin_pfn_private(vcpu, fault); > + > async = false; > fault->pfn = __gfn_to_pfn_memslot(slot, fault->gfn, false, false, &async, > fault->write, &fault->map_writable, > @@ -5771,6 +5840,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) > diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_internal.h > index d39af5639ce9..268b517e88cb 100644 > --- a/arch/x86/kvm/mmu/mmu_internal.h > +++ b/arch/x86/kvm/mmu/mmu_internal.h > @@ -203,6 +203,7 @@ struct kvm_page_fault { > > /* Derived from mmu and global state. */ > const bool is_tdp; > + const bool is_private; > const bool nx_huge_page_workaround_enabled; > > /* > @@ -259,6 +260,7 @@ int kvm_tdp_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault); > * RET_PF_RETRY: let CPU fault again on the address. > * RET_PF_EMULATE: mmio page fault, emulate the instruction directly. > * RET_PF_INVALID: the spte is invalid, let the real page fault path update it. > + * RET_PF_USER: need to exit to userspace to handle this fault. > * RET_PF_FIXED: The faulting entry has been fixed. > * RET_PF_SPURIOUS: The faulting entry was already fixed, e.g. by another vCPU. > * > @@ -275,6 +277,7 @@ enum { > RET_PF_RETRY, > RET_PF_EMULATE, > RET_PF_INVALID, > + RET_PF_USER, > RET_PF_FIXED, > RET_PF_SPURIOUS, > }; > diff --git a/arch/x86/kvm/mmu/mmutrace.h b/arch/x86/kvm/mmu/mmutrace.h > index ae86820cef69..2d7555381955 100644 > --- a/arch/x86/kvm/mmu/mmutrace.h > +++ b/arch/x86/kvm/mmu/mmutrace.h > @@ -58,6 +58,7 @@ TRACE_DEFINE_ENUM(RET_PF_CONTINUE); > TRACE_DEFINE_ENUM(RET_PF_RETRY); > TRACE_DEFINE_ENUM(RET_PF_EMULATE); > TRACE_DEFINE_ENUM(RET_PF_INVALID); > +TRACE_DEFINE_ENUM(RET_PF_USER); > TRACE_DEFINE_ENUM(RET_PF_FIXED); > TRACE_DEFINE_ENUM(RET_PF_SPURIOUS); > Reviewed-by: Paolo Bonzini