From nobody Sat Apr 11 02:17:40 2026 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 A7CB3C28B2B for ; Wed, 17 Aug 2022 00:36:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238049AbiHQAgY (ORCPT ); Tue, 16 Aug 2022 20:36:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56192 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237995AbiHQAgV (ORCPT ); Tue, 16 Aug 2022 20:36:21 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B60978D3D3 for ; Tue, 16 Aug 2022 17:36:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1660696579; 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=e/SVxUH9CqIfzsVnNZsd2Uihd8CdpKj/1oI3QClWoPk=; b=NqCQfPjjE4H71DARY83H9QlQo0RUPd4iOkjtfGvuWS9VH/G5Ad4Q0M1A/mXf71c6WqrVuz D6I5YDK9MmpWADPRfJoAQa7GAWU0bfv+d8gw94W9B4kpURnVDnH8Sggf/qugE6KxFrzBn4 PT4Gw+uJIlKO25HIUDmgPOfHGhU+Y0A= Received: from mail-qt1-f197.google.com (mail-qt1-f197.google.com [209.85.160.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-111-i1v-IH9EPLy9wPFXfLVXTA-1; Tue, 16 Aug 2022 20:36:18 -0400 X-MC-Unique: i1v-IH9EPLy9wPFXfLVXTA-1 Received: by mail-qt1-f197.google.com with SMTP id fy12-20020a05622a5a0c00b00344569022f7so6433759qtb.17 for ; Tue, 16 Aug 2022 17:36:18 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=e/SVxUH9CqIfzsVnNZsd2Uihd8CdpKj/1oI3QClWoPk=; b=UXwfucYZqz/88JqIHrf9RmY5NzduPsqitKyWmXKnCrZP0uzhHiWbIb+bqvyuL4r6Gd Qb9oDvm58JQ4yYJLoZPnqGDMgjEYwt1RbEoV9EklAXJz+P6tlDKFM0BnyZx93SNL2lZF 93FIzlRhAJyOOgOPSqfp8tKNAv9IcWEv1Ono1SsenxCC2XnlzpRj4r2+sA+mMFT7ZbVq e3I+JuNemQh4iSrqKfUj147lFvcObS7sK2vbW/ksP/UQ9OwhgBL4FKmLc2ARH2inWZoC pLJb79+/29/aaXeya94TjAgCJaUlwgwrhEfhmVOOXdB74AjKqb7Khzvc2KFHkFrCrOCe LPeA== X-Gm-Message-State: ACgBeo2g3K6ZTqCC80Ln5Nap1+LF1qLboL/8T40F+WXjVRTmS6huzmZp Zlo+oRuIPN97fWw/hyTalyKaJLCMPy06fxq1D5BgGHpYv0pp+FAfTGJpasncI62OOELmSJhcQse On7jmWZ1nqYgG1Plm97zjRB0eMULtG75J64IpxzBLMcYaBTQr2JB3B+06M4g/p/nYVKyfx3j2Hg == X-Received: by 2002:a05:620a:164b:b0:6bb:761:fe1d with SMTP id c11-20020a05620a164b00b006bb0761fe1dmr10840804qko.597.1660696578088; Tue, 16 Aug 2022 17:36:18 -0700 (PDT) X-Google-Smtp-Source: AA6agR43jJoPki+u1Yj/TOnNQJFWojKLBcEgxpYaJnT2CS+d5ISlEfpihIPryWn36nZhVvg5r/Yv2g== X-Received: by 2002:a05:620a:164b:b0:6bb:761:fe1d with SMTP id c11-20020a05620a164b00b006bb0761fe1dmr10840780qko.597.1660696577744; Tue, 16 Aug 2022 17:36:17 -0700 (PDT) Received: from localhost.localdomain (bras-base-aurron9127w-grc-35-70-27-3-10.dsl.bell.ca. [70.27.3.10]) by smtp.gmail.com with ESMTPSA id c13-20020ac87dcd000000b0034358bfc3c8sm12007175qte.67.2022.08.16.17.36.16 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Tue, 16 Aug 2022 17:36:17 -0700 (PDT) From: Peter Xu To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Sean Christopherson , David Hildenbrand , Andrew Morton , Andrea Arcangeli , peterx@redhat.com, Paolo Bonzini , "Dr . David Alan Gilbert" , Linux MM Mailing List , John Hubbard Subject: [PATCH v3 1/3] mm/gup: Add FOLL_INTERRUPTIBLE Date: Tue, 16 Aug 2022 20:36:12 -0400 Message-Id: <20220817003614.58900-2-peterx@redhat.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20220817003614.58900-1-peterx@redhat.com> References: <20220817003614.58900-1-peterx@redhat.com> 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" We have had FAULT_FLAG_INTERRUPTIBLE but it was never applied to GUPs. One issue with it is that not all GUP paths are able to handle signal delivers besides SIGKILL. That's not ideal for the GUP users who are actually able to handle these cases, like KVM. KVM uses GUP extensively on faulting guest pages, during which we've got existing infrastructures to retry a page fault at a later time. Allowing the GUP to be interrupted by generic signals can make KVM related threads to be more responsive. For examples: (1) SIGUSR1: which QEMU/KVM uses to deliver an inter-process IPI, e.g. when the admin issues a vm_stop QMP command, SIGUSR1 can be generated to kick the vcpus out of kernel context immediately, (2) SIGINT: which can be used with interactive hypervisor users to stop a virtual machine with Ctrl-C without any delays/hangs, (3) SIGTRAP: which grants GDB capability even during page faults that are stuck for a long time. Normally hypervisor will be able to receive these signals properly, but not if we're stuck in a GUP for a long time for whatever reason. It happens easily with a stucked postcopy migration when e.g. a network temp failure happens, then some vcpu threads can hang death waiting for the pages. With the new FOLL_INTERRUPTIBLE, we can allow GUP users like KVM to selectively enable the ability to trap these signals. Reviewed-by: John Hubbard Reviewed-by: David Hildenbrand Signed-off-by: Peter Xu --- include/linux/mm.h | 1 + mm/gup.c | 33 +++++++++++++++++++++++++++++---- mm/hugetlb.c | 5 ++++- 3 files changed, 34 insertions(+), 5 deletions(-) diff --git a/include/linux/mm.h b/include/linux/mm.h index cf3d0d673f6b..c09eccd5d553 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2941,6 +2941,7 @@ struct page *follow_page(struct vm_area_struct *vma, = unsigned long address, #define FOLL_SPLIT_PMD 0x20000 /* split huge pmd before returning */ #define FOLL_PIN 0x40000 /* pages must be released via unpin_user_page */ #define FOLL_FAST_ONLY 0x80000 /* gup_fast: prevent fall-back to slow gup = */ +#define FOLL_INTERRUPTIBLE 0x100000 /* allow interrupts from generic sign= als */ =20 /* * FOLL_PIN and FOLL_LONGTERM may be used in various combinations with each diff --git a/mm/gup.c b/mm/gup.c index 551264407624..f39cbe011cf1 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -933,8 +933,17 @@ static int faultin_page(struct vm_area_struct *vma, fault_flags |=3D FAULT_FLAG_WRITE; if (*flags & FOLL_REMOTE) fault_flags |=3D FAULT_FLAG_REMOTE; - if (locked) + if (locked) { fault_flags |=3D FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE; + /* + * FAULT_FLAG_INTERRUPTIBLE is opt-in. GUP callers must set + * FOLL_INTERRUPTIBLE to enable FAULT_FLAG_INTERRUPTIBLE. + * That's because some callers may not be prepared to + * handle early exits caused by non-fatal signals. + */ + if (*flags & FOLL_INTERRUPTIBLE) + fault_flags |=3D FAULT_FLAG_INTERRUPTIBLE; + } if (*flags & FOLL_NOWAIT) fault_flags |=3D FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT; if (*flags & FOLL_TRIED) { @@ -1322,6 +1331,22 @@ int fixup_user_fault(struct mm_struct *mm, } EXPORT_SYMBOL_GPL(fixup_user_fault); =20 +/* + * GUP always responds to fatal signals. When FOLL_INTERRUPTIBLE is + * specified, it'll also respond to generic signals. The caller of GUP + * that has FOLL_INTERRUPTIBLE should take care of the GUP interruption. + */ +static bool gup_signal_pending(unsigned int flags) +{ + if (fatal_signal_pending(current)) + return true; + + if (!(flags & FOLL_INTERRUPTIBLE)) + return false; + + return signal_pending(current); +} + /* * Please note that this function, unlike __get_user_pages will not * return 0 for nr_pages > 0 without FOLL_NOWAIT @@ -1403,11 +1428,11 @@ static __always_inline long __get_user_pages_locked= (struct mm_struct *mm, * Repeat on the address that fired VM_FAULT_RETRY * with both FAULT_FLAG_ALLOW_RETRY and * FAULT_FLAG_TRIED. Note that GUP can be interrupted - * by fatal signals, so we need to check it before we + * by fatal signals of even common signals, depending on + * the caller's request. So we need to check it before we * start trying again otherwise it can loop forever. */ - - if (fatal_signal_pending(current)) { + if (gup_signal_pending(flags)) { if (!pages_done) pages_done =3D -EINTR; break; diff --git a/mm/hugetlb.c b/mm/hugetlb.c index a57e1be41401..4025a305d573 100644 --- a/mm/hugetlb.c +++ b/mm/hugetlb.c @@ -6176,9 +6176,12 @@ long follow_hugetlb_page(struct mm_struct *mm, struc= t vm_area_struct *vma, fault_flags |=3D FAULT_FLAG_WRITE; else if (unshare) fault_flags |=3D FAULT_FLAG_UNSHARE; - if (locked) + if (locked) { fault_flags |=3D FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE; + if (flags & FOLL_INTERRUPTIBLE) + fault_flags |=3D FAULT_FLAG_INTERRUPTIBLE; + } if (flags & FOLL_NOWAIT) fault_flags |=3D FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT; --=20 2.32.0 From nobody Sat Apr 11 02:17:40 2026 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 477C1C25B0E for ; Wed, 17 Aug 2022 00:36:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238066AbiHQAgc (ORCPT ); Tue, 16 Aug 2022 20:36:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56226 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238045AbiHQAgX (ORCPT ); Tue, 16 Aug 2022 20:36:23 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7D52A8D3D3 for ; Tue, 16 Aug 2022 17:36:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1660696581; 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=FLbPJ7hy11GyuxEWqZ14BS1jQ5aTLxQT7Al42LT3IDU=; b=bRuOTLYTE4r3KVhlDU00D0JvYewqSqsxg9HpbGf2Mdv16vezd46eVxocoBUKusB+mm1Vu6 CxuywuvktSGevRR4JZT2hkPYZMSIx6/69VQ0aGd8rFd7ReIIA0bnjsC83hkoszTjIZuTvY AtmrNkqJDDe9gHXZ305zMqMeO5DcLDo= Received: from mail-qk1-f199.google.com (mail-qk1-f199.google.com [209.85.222.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-435-sj6TuJSnO9GMNE7ZTG3VzA-1; Tue, 16 Aug 2022 20:36:20 -0400 X-MC-Unique: sj6TuJSnO9GMNE7ZTG3VzA-1 Received: by mail-qk1-f199.google.com with SMTP id i15-20020a05620a404f00b006b55998179bso10453905qko.4 for ; Tue, 16 Aug 2022 17:36:20 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=FLbPJ7hy11GyuxEWqZ14BS1jQ5aTLxQT7Al42LT3IDU=; b=uY/n5D2Tgj3ErBUlgdXbvSIvBEhm+Acnl6UHgyo3y9rbFCTczmvbPHf1aPyXpw9HsB h5JFg9lXADREGisf9zzM9G57lCXr1lU1cyu02LoJOtxi7dGmOmXem+Dri9QR8ZXAFl8H o+rqZbEpT///rBfvM3v+QUMQkhS204mOiwXEYKw0A6OZk4YX/877sqaDIaHQZdzWK4HG dqng4vT8MtyDadiViVRqudf1O9ZPqu5MIbx7iu2NhBpA54UpFfC+oGMGaR5qbFjWoYrM IuxIPZTWqCe28VMgIO5nn7HGO59WehK7CmMYKWDWVejYQOk9i4zC2BcxLQC5npn8Cf+o ZtUQ== X-Gm-Message-State: ACgBeo3kfpB1QicQl+1F9zka4ybpUcF6vvwsbg2BB5JiLEk0bGHAZeeW mYMq4TEXdKdnq6vEGIKbjXUQE6USlB0aQZtV1/lTHYMKKFa/xL33Q7vEVx/pWVI781YdFaFI2AZ Qae39ovQWKVvKO0C6Bv//72nEoJnRoeIRY8anMzxG6rGWaee6158sUKmj4Ge3ZTEPJqRSUOo7jg == X-Received: by 2002:ae9:e004:0:b0:6bb:5a15:2889 with SMTP id m4-20020ae9e004000000b006bb5a152889mr5337120qkk.235.1660696579408; Tue, 16 Aug 2022 17:36:19 -0700 (PDT) X-Google-Smtp-Source: AA6agR5QpgX57yEUqRa2TlfnMEJNrK5HHiJcugAOY7ms5GMSgdMLg91tEP6F3QIsUQIES+lP5ek7EA== X-Received: by 2002:ae9:e004:0:b0:6bb:5a15:2889 with SMTP id m4-20020ae9e004000000b006bb5a152889mr5337102qkk.235.1660696579048; Tue, 16 Aug 2022 17:36:19 -0700 (PDT) Received: from localhost.localdomain (bras-base-aurron9127w-grc-35-70-27-3-10.dsl.bell.ca. [70.27.3.10]) by smtp.gmail.com with ESMTPSA id c13-20020ac87dcd000000b0034358bfc3c8sm12007175qte.67.2022.08.16.17.36.17 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Tue, 16 Aug 2022 17:36:18 -0700 (PDT) From: Peter Xu To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Sean Christopherson , David Hildenbrand , Andrew Morton , Andrea Arcangeli , peterx@redhat.com, Paolo Bonzini , "Dr . David Alan Gilbert" , Linux MM Mailing List , John Hubbard Subject: [PATCH v3 2/3] kvm: Add new pfn error KVM_PFN_ERR_SIGPENDING Date: Tue, 16 Aug 2022 20:36:13 -0400 Message-Id: <20220817003614.58900-3-peterx@redhat.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20220817003614.58900-1-peterx@redhat.com> References: <20220817003614.58900-1-peterx@redhat.com> 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" Add one new PFN error type to show when KVM got interrupted when fetching the PFN due to any kind of signal pending. Add a new "interruptible" flag showing that the caller is willing to be interrupted by signals during the __gfn_to_pfn_memslot() request. Wire it up with a FOLL_INTERRUPTIBLE flag that we've just introduced. This prepares KVM to be able to respond to SIGUSR1 (for QEMU that's the SIGIPI) even during e.g. handling an userfaultfd page fault. Since at it, renaming kvm_handle_bad_page to kvm_handle_error_pfn assuming that'll match better with what it does, e.g. KVM_PFN_ERR_SIGPENDING is not accurately a bad page but just one kind of errors. No functional change intended so far with the patch. Signed-off-by: Peter Xu --- arch/arm64/kvm/mmu.c | 2 +- arch/powerpc/kvm/book3s_64_mmu_hv.c | 2 +- arch/powerpc/kvm/book3s_64_mmu_radix.c | 2 +- arch/x86/kvm/mmu/mmu.c | 13 +++++++---- include/linux/kvm_host.h | 14 ++++++++++-- virt/kvm/kvm_main.c | 30 ++++++++++++++++---------- virt/kvm/kvm_mm.h | 4 ++-- virt/kvm/pfncache.c | 2 +- 8 files changed, 46 insertions(+), 23 deletions(-) diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c index 87f1cd0df36e..8b730e809e9f 100644 --- a/arch/arm64/kvm/mmu.c +++ b/arch/arm64/kvm/mmu.c @@ -1204,7 +1204,7 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys= _addr_t fault_ipa, */ smp_rmb(); =20 - pfn =3D __gfn_to_pfn_memslot(memslot, gfn, false, NULL, + pfn =3D __gfn_to_pfn_memslot(memslot, gfn, false, false, NULL, write_fault, &writable, NULL); if (pfn =3D=3D KVM_PFN_ERR_HWPOISON) { kvm_send_hwpoison_signal(hva, vma_shift); diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_= 64_mmu_hv.c index 514fd45c1994..7aed5ef6588e 100644 --- a/arch/powerpc/kvm/book3s_64_mmu_hv.c +++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c @@ -598,7 +598,7 @@ int kvmppc_book3s_hv_page_fault(struct kvm_vcpu *vcpu, write_ok =3D true; } else { /* Call KVM generic code to do the slow-path check */ - pfn =3D __gfn_to_pfn_memslot(memslot, gfn, false, NULL, + pfn =3D __gfn_to_pfn_memslot(memslot, gfn, false, false, NULL, writing, &write_ok, NULL); if (is_error_noslot_pfn(pfn)) return -EFAULT; diff --git a/arch/powerpc/kvm/book3s_64_mmu_radix.c b/arch/powerpc/kvm/book= 3s_64_mmu_radix.c index 42851c32ff3b..9991f9d9ee59 100644 --- a/arch/powerpc/kvm/book3s_64_mmu_radix.c +++ b/arch/powerpc/kvm/book3s_64_mmu_radix.c @@ -845,7 +845,7 @@ int kvmppc_book3s_instantiate_page(struct kvm_vcpu *vcp= u, unsigned long pfn; =20 /* Call KVM generic code to do the slow-path check */ - pfn =3D __gfn_to_pfn_memslot(memslot, gfn, false, NULL, + pfn =3D __gfn_to_pfn_memslot(memslot, gfn, false, false, NULL, writing, upgrade_p, NULL); if (is_error_noslot_pfn(pfn)) return -EFAULT; diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 3e1317325e1f..23dc46da2f18 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -3134,8 +3134,13 @@ static void kvm_send_hwpoison_signal(unsigned long a= ddress, struct task_struct * send_sig_mceerr(BUS_MCEERR_AR, (void __user *)address, PAGE_SHIFT, tsk); } =20 -static int kvm_handle_bad_page(struct kvm_vcpu *vcpu, gfn_t gfn, kvm_pfn_t= pfn) +static int kvm_handle_error_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, kvm_pfn_= t pfn) { + if (is_sigpending_pfn(pfn)) { + kvm_handle_signal_exit(vcpu); + return -EINTR; + } + /* * Do not cache the mmio info caused by writing the readonly gfn * into the spte otherwise read access on readonly gfn also can @@ -3157,7 +3162,7 @@ static int handle_abnormal_pfn(struct kvm_vcpu *vcpu,= struct kvm_page_fault *fau { /* The pfn is invalid, report the error! */ if (unlikely(is_error_pfn(fault->pfn))) - return kvm_handle_bad_page(vcpu, fault->gfn, fault->pfn); + return kvm_handle_error_pfn(vcpu, fault->gfn, fault->pfn); =20 if (unlikely(!fault->slot)) { gva_t gva =3D fault->is_tdp ? 0 : fault->addr; @@ -4155,7 +4160,7 @@ static int kvm_faultin_pfn(struct kvm_vcpu *vcpu, str= uct kvm_page_fault *fault) } =20 async =3D false; - fault->pfn =3D __gfn_to_pfn_memslot(slot, fault->gfn, false, &async, + fault->pfn =3D __gfn_to_pfn_memslot(slot, fault->gfn, false, false, &asyn= c, fault->write, &fault->map_writable, &fault->hva); if (!async) @@ -4172,7 +4177,7 @@ static int kvm_faultin_pfn(struct kvm_vcpu *vcpu, str= uct kvm_page_fault *fault) } } =20 - fault->pfn =3D __gfn_to_pfn_memslot(slot, fault->gfn, false, NULL, + fault->pfn =3D __gfn_to_pfn_memslot(slot, fault->gfn, false, false, NULL, fault->write, &fault->map_writable, &fault->hva); return RET_PF_CONTINUE; diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 1c480b1821e1..1d792f60cfda 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h @@ -96,6 +96,7 @@ #define KVM_PFN_ERR_FAULT (KVM_PFN_ERR_MASK) #define KVM_PFN_ERR_HWPOISON (KVM_PFN_ERR_MASK + 1) #define KVM_PFN_ERR_RO_FAULT (KVM_PFN_ERR_MASK + 2) +#define KVM_PFN_ERR_SIGPENDING (KVM_PFN_ERR_MASK + 3) =20 /* * error pfns indicate that the gfn is in slot but faild to @@ -106,6 +107,15 @@ static inline bool is_error_pfn(kvm_pfn_t pfn) return !!(pfn & KVM_PFN_ERR_MASK); } =20 +/* + * KVM_PFN_ERR_SIGPENDING indicates that fetching the PFN was interrupted + * by a pending signal. Note, the signal may or may not be fatal. + */ +static inline bool is_sigpending_pfn(kvm_pfn_t pfn) +{ + return pfn =3D=3D KVM_PFN_ERR_SIGPENDING; +} + /* * error_noslot pfns indicate that the gfn can not be * translated to pfn - it is not in slot or failed to @@ -1141,8 +1151,8 @@ kvm_pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn,= bool write_fault, kvm_pfn_t gfn_to_pfn_memslot(const struct kvm_memory_slot *slot, gfn_t gfn= ); kvm_pfn_t gfn_to_pfn_memslot_atomic(const struct kvm_memory_slot *slot, gf= n_t gfn); kvm_pfn_t __gfn_to_pfn_memslot(const struct kvm_memory_slot *slot, gfn_t g= fn, - bool atomic, bool *async, bool write_fault, - bool *writable, hva_t *hva); + bool atomic, bool interruptible, bool *async, + bool write_fault, bool *writable, hva_t *hva); =20 void kvm_release_pfn_clean(kvm_pfn_t pfn); void kvm_release_pfn_dirty(kvm_pfn_t pfn); diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 32896c845ffe..56dde0e141b4 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -2498,7 +2498,7 @@ static bool hva_to_pfn_fast(unsigned long addr, bool = write_fault, * 1 indicates success, -errno is returned if error is detected. */ static int hva_to_pfn_slow(unsigned long addr, bool *async, bool write_fau= lt, - bool *writable, kvm_pfn_t *pfn) + bool interruptible, bool *writable, kvm_pfn_t *pfn) { unsigned int flags =3D FOLL_HWPOISON; struct page *page; @@ -2513,6 +2513,8 @@ static int hva_to_pfn_slow(unsigned long addr, bool *= async, bool write_fault, flags |=3D FOLL_WRITE; if (async) flags |=3D FOLL_NOWAIT; + if (interruptible) + flags |=3D FOLL_INTERRUPTIBLE; =20 npages =3D get_user_pages_unlocked(addr, 1, &page, flags); if (npages !=3D 1) @@ -2622,6 +2624,7 @@ static int hva_to_pfn_remapped(struct vm_area_struct = *vma, * Pin guest page in memory and return its pfn. * @addr: host virtual address which maps memory to the guest * @atomic: whether this function can sleep + * @interruptible: whether the process can be interrupted by non-fatal sig= nals * @async: whether this function need to wait IO complete if the * host page is not in the memory * @write_fault: whether we should get a writable host page @@ -2632,8 +2635,8 @@ static int hva_to_pfn_remapped(struct vm_area_struct = *vma, * 2): @write_fault =3D false && @writable, @writable will tell the caller * whether the mapping is writable. */ -kvm_pfn_t hva_to_pfn(unsigned long addr, bool atomic, bool *async, - bool write_fault, bool *writable) +kvm_pfn_t hva_to_pfn(unsigned long addr, bool atomic, bool interruptible, + bool *async, bool write_fault, bool *writable) { struct vm_area_struct *vma; kvm_pfn_t pfn; @@ -2648,9 +2651,12 @@ kvm_pfn_t hva_to_pfn(unsigned long addr, bool atomic= , bool *async, if (atomic) return KVM_PFN_ERR_FAULT; =20 - npages =3D hva_to_pfn_slow(addr, async, write_fault, writable, &pfn); + npages =3D hva_to_pfn_slow(addr, async, write_fault, interruptible, + writable, &pfn); if (npages =3D=3D 1) return pfn; + if (npages =3D=3D -EINTR) + return KVM_PFN_ERR_SIGPENDING; =20 mmap_read_lock(current->mm); if (npages =3D=3D -EHWPOISON || @@ -2681,8 +2687,8 @@ kvm_pfn_t hva_to_pfn(unsigned long addr, bool atomic,= bool *async, } =20 kvm_pfn_t __gfn_to_pfn_memslot(const struct kvm_memory_slot *slot, gfn_t g= fn, - bool atomic, bool *async, bool write_fault, - bool *writable, hva_t *hva) + bool atomic, bool interruptible, bool *async, + bool write_fault, bool *writable, hva_t *hva) { unsigned long addr =3D __gfn_to_hva_many(slot, gfn, NULL, write_fault); =20 @@ -2707,7 +2713,7 @@ kvm_pfn_t __gfn_to_pfn_memslot(const struct kvm_memor= y_slot *slot, gfn_t gfn, writable =3D NULL; } =20 - return hva_to_pfn(addr, atomic, async, write_fault, + return hva_to_pfn(addr, atomic, interruptible, async, write_fault, writable); } EXPORT_SYMBOL_GPL(__gfn_to_pfn_memslot); @@ -2715,20 +2721,22 @@ EXPORT_SYMBOL_GPL(__gfn_to_pfn_memslot); kvm_pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault, bool *writable) { - return __gfn_to_pfn_memslot(gfn_to_memslot(kvm, gfn), gfn, false, NULL, - write_fault, writable, NULL); + return __gfn_to_pfn_memslot(gfn_to_memslot(kvm, gfn), gfn, false, false, + NULL, write_fault, writable, NULL); } EXPORT_SYMBOL_GPL(gfn_to_pfn_prot); =20 kvm_pfn_t gfn_to_pfn_memslot(const struct kvm_memory_slot *slot, gfn_t gfn) { - return __gfn_to_pfn_memslot(slot, gfn, false, NULL, true, NULL, NULL); + return __gfn_to_pfn_memslot(slot, gfn, false, false, NULL, true, + NULL, NULL); } EXPORT_SYMBOL_GPL(gfn_to_pfn_memslot); =20 kvm_pfn_t gfn_to_pfn_memslot_atomic(const struct kvm_memory_slot *slot, gf= n_t gfn) { - return __gfn_to_pfn_memslot(slot, gfn, true, NULL, true, NULL, NULL); + return __gfn_to_pfn_memslot(slot, gfn, true, false, NULL, true, + NULL, NULL); } EXPORT_SYMBOL_GPL(gfn_to_pfn_memslot_atomic); =20 diff --git a/virt/kvm/kvm_mm.h b/virt/kvm/kvm_mm.h index 41da467d99c9..a1ab15006af3 100644 --- a/virt/kvm/kvm_mm.h +++ b/virt/kvm/kvm_mm.h @@ -24,8 +24,8 @@ #define KVM_MMU_READ_UNLOCK(kvm) spin_unlock(&(kvm)->mmu_lock) #endif /* KVM_HAVE_MMU_RWLOCK */ =20 -kvm_pfn_t hva_to_pfn(unsigned long addr, bool atomic, bool *async, - bool write_fault, bool *writable); +kvm_pfn_t hva_to_pfn(unsigned long addr, bool atomic, bool interruptible, + bool *async, bool write_fault, bool *writable); =20 #ifdef CONFIG_HAVE_KVM_PFNCACHE void gfn_to_pfn_cache_invalidate_start(struct kvm *kvm, diff --git a/virt/kvm/pfncache.c b/virt/kvm/pfncache.c index ab519f72f2cd..6dacb58bf4d0 100644 --- a/virt/kvm/pfncache.c +++ b/virt/kvm/pfncache.c @@ -181,7 +181,7 @@ static kvm_pfn_t hva_to_pfn_retry(struct kvm *kvm, stru= ct gfn_to_pfn_cache *gpc) } =20 /* We always request a writeable mapping */ - new_pfn =3D hva_to_pfn(gpc->uhva, false, NULL, true, NULL); + new_pfn =3D hva_to_pfn(gpc->uhva, false, false, NULL, true, NULL); if (is_error_noslot_pfn(new_pfn)) goto out_error; =20 --=20 2.32.0 From nobody Sat Apr 11 02:17:40 2026 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 D7159C25B0E for ; Wed, 17 Aug 2022 00:36:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238057AbiHQAg3 (ORCPT ); Tue, 16 Aug 2022 20:36:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56220 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238037AbiHQAgX (ORCPT ); Tue, 16 Aug 2022 20:36:23 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id ECD258D3ED for ; Tue, 16 Aug 2022 17:36:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1660696582; 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=BTwL0O3UlpIIc32A0xilckqyKglNDPBffWl5+tmKDhQ=; b=C0p03NakmFceQ6cSVLRUBMTu7w9lmT2cZSP6FjNFZIpl/LG363I8yChl7OR/0x9HJww74l T3pFrCMp8NwyV83BNMiInVcAf8yvfkeUr+b0w2UBSVkCFckzQoEzwz/MkKq85L1E2ACpcD oKeQixM2jNvqxnyUthZUXxbfY4eOVe8= Received: from mail-qt1-f198.google.com (mail-qt1-f198.google.com [209.85.160.198]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-202-CBPFjjdfN-Kx71pxerRdew-1; Tue, 16 Aug 2022 20:36:21 -0400 X-MC-Unique: CBPFjjdfN-Kx71pxerRdew-1 Received: by mail-qt1-f198.google.com with SMTP id b10-20020a05622a020a00b003437e336ca7so8844087qtx.16 for ; Tue, 16 Aug 2022 17:36:21 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=BTwL0O3UlpIIc32A0xilckqyKglNDPBffWl5+tmKDhQ=; b=4Ww1iB9hKA75/peXPooyrcV1aWtk18kHYii69EnUEcSIfkjA+WWcxTZmMATYgEv/Ge nAsXKuWDupyJa/R3RyH14zi6TVMPmuUjW7x+DuUM4zymD5iwsHXcOGMCdjR4KTnjc9kZ mLPblvydQLdhqW97CDDbxwYz6w6QDrcShk7NsYJZ/i7ABY30wOR5z81n94HUMJ1fizXj V4xX65YjRdvcKMkaXjUtpEp+9te1+wVTHjU8GeoZgp1MKqoVyXr5h+5LN7q/ph9fezxE THjwRWP0MBHukyB5rPESfZQevcXm1v1fP76i3fw1SfmlizHVT21f6ua7MNVZ1E29xlE6 +5TQ== X-Gm-Message-State: ACgBeo2Jdy93QdV9T0VTpPHdLSpOpeNN6tmcbC6inr8HgNVR19BeTGcr 9iydeQQ/H4kXsEXFlzgjH1dEJlqQHLhOFiBqcqvbi7Ry0bFX711R8Xf2iU026LSDFcoezo+gbS/ LQxk6Toa3zfc0BNlFDHphBkEGm4OaNCtGxU+X8bRQ12QeAeoG1uuFM/DUdRWu8tafIfvyd5BYeQ == X-Received: by 2002:ad4:4ead:0:b0:474:7bba:9865 with SMTP id ed13-20020ad44ead000000b004747bba9865mr20428368qvb.58.1660696580503; Tue, 16 Aug 2022 17:36:20 -0700 (PDT) X-Google-Smtp-Source: AA6agR4UUHOe8O6QFGIYvp/9K2vK0n6Fp6ajMCcyZcBb9hv+otrDbdfVJjGZcpSZ0cwahduBZbENsw== X-Received: by 2002:ad4:4ead:0:b0:474:7bba:9865 with SMTP id ed13-20020ad44ead000000b004747bba9865mr20428347qvb.58.1660696580285; Tue, 16 Aug 2022 17:36:20 -0700 (PDT) Received: from localhost.localdomain (bras-base-aurron9127w-grc-35-70-27-3-10.dsl.bell.ca. [70.27.3.10]) by smtp.gmail.com with ESMTPSA id c13-20020ac87dcd000000b0034358bfc3c8sm12007175qte.67.2022.08.16.17.36.19 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Tue, 16 Aug 2022 17:36:19 -0700 (PDT) From: Peter Xu To: linux-kernel@vger.kernel.org, kvm@vger.kernel.org Cc: Sean Christopherson , David Hildenbrand , Andrew Morton , Andrea Arcangeli , peterx@redhat.com, Paolo Bonzini , "Dr . David Alan Gilbert" , Linux MM Mailing List , John Hubbard Subject: [PATCH v3 3/3] kvm/x86: Allow to respond to generic signals during slow page faults Date: Tue, 16 Aug 2022 20:36:14 -0400 Message-Id: <20220817003614.58900-4-peterx@redhat.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20220817003614.58900-1-peterx@redhat.com> References: <20220817003614.58900-1-peterx@redhat.com> 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" Enable x86 slow page faults to be able to respond to non-fatal signals. Signed-off-by: Peter Xu --- arch/x86/kvm/mmu/mmu.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 23dc46da2f18..4a7d387a762a 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -4177,7 +4177,12 @@ static int kvm_faultin_pfn(struct kvm_vcpu *vcpu, st= ruct kvm_page_fault *fault) } } =20 - fault->pfn =3D __gfn_to_pfn_memslot(slot, fault->gfn, false, false, NULL, + /* + * Allow gup to bail on pending non-fatal signals when it's also allowed + * to wait for IO. Note, gup always bails if it is unable to quickly + * get a page and a fatal signal, i.e. SIGKILL, is pending. + */ + fault->pfn =3D __gfn_to_pfn_memslot(slot, fault->gfn, false, true, NULL, fault->write, &fault->map_writable, &fault->hva); return RET_PF_CONTINUE; --=20 2.32.0