From patchwork Sun Jan 1 16:29:05 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Jason A. Donenfeld" X-Patchwork-Id: 13086390 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 824A1C4332F for ; Sun, 1 Jan 2023 16:29:29 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 75A4F8E0002; Sun, 1 Jan 2023 11:29:28 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 709E98E0001; Sun, 1 Jan 2023 11:29:28 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 5D1F48E0002; Sun, 1 Jan 2023 11:29:28 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id 4E6718E0001 for ; Sun, 1 Jan 2023 11:29:28 -0500 (EST) Received: from smtpin29.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay05.hostedemail.com (Postfix) with ESMTP id 14E7240762 for ; Sun, 1 Jan 2023 16:29:28 +0000 (UTC) X-FDA: 80306765616.29.407398F Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by imf07.hostedemail.com (Postfix) with ESMTP id 7E6E340010 for ; Sun, 1 Jan 2023 16:29:26 +0000 (UTC) Authentication-Results: imf07.hostedemail.com; dkim=pass header.d=zx2c4.com header.s=20210105 header.b=SxmqZpYX; spf=pass (imf07.hostedemail.com: domain of "SRS0=CKF8=46=zx2c4.com=Jason@kernel.org" designates 139.178.84.217 as permitted sender) smtp.mailfrom="SRS0=CKF8=46=zx2c4.com=Jason@kernel.org"; dmarc=pass (policy=quarantine) header.from=zx2c4.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1672590566; 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-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=oUv8kt4i2PYDqAtynOMenDs0ntoUZeP9sq0UzIYkdug=; b=8Bvkw4rwYniOPYcg6Wv519Pms3276gQAJiPiEyWNSxoz+m2tGEz1q2kxyQiCsmUHEMiLk1 jx/s3byXpUIxOZaZux7XtVbmM3dYjruapU1OUUCygmDocINpwKmD9NPlf472M8JMWigzdn 9bkNYM/PGgHTIW7F8KyamL6m/+Y9qaA= ARC-Authentication-Results: i=1; imf07.hostedemail.com; dkim=pass header.d=zx2c4.com header.s=20210105 header.b=SxmqZpYX; spf=pass (imf07.hostedemail.com: domain of "SRS0=CKF8=46=zx2c4.com=Jason@kernel.org" designates 139.178.84.217 as permitted sender) smtp.mailfrom="SRS0=CKF8=46=zx2c4.com=Jason@kernel.org"; dmarc=pass (policy=quarantine) header.from=zx2c4.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1672590566; a=rsa-sha256; cv=none; b=1NlFgn4n784i3MIlTqhrpN/Q3uZIQx9LuaDwiBzz9cLH/doe88MdIhE5Mm36962pFmtpUS h7nxK9FLzNmtGMrwh1lyaS93uO6eLNIcez5aCunmQPxCx2MoSLFLCmMh1nQWdcAJFWuvYy eMCC+fEgl8xFrNZtWu0QPmIZEEEE3Ok= Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 649F960DDD; Sun, 1 Jan 2023 16:29:25 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BAF7FC433F0; Sun, 1 Jan 2023 16:29:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=zx2c4.com; s=20210105; t=1672590562; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=oUv8kt4i2PYDqAtynOMenDs0ntoUZeP9sq0UzIYkdug=; b=SxmqZpYX+0BNf+I6S/59tLCUe6SRSjFtl7Y1nDXgO+XGKbMBvrtiliqPAUMiNZ4UIipDZG TtdZpac9oG3l6Lj7ugw0owo91HHTEEQCZlggIRvfq1flfQ3tMgGuL9yLQwjdOLVg6adA/s pTSwUE4zh/d3TgP+QMXfCro47ipsxe0= Received: by mail.zx2c4.com (ZX2C4 Mail Server) with ESMTPSA id 2f1740c1 (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO); Sun, 1 Jan 2023 16:29:22 +0000 (UTC) From: "Jason A. Donenfeld" To: linux-kernel@vger.kernel.org, patches@lists.linux.dev, tglx@linutronix.de Cc: "Jason A. Donenfeld" , linux-crypto@vger.kernel.org, linux-api@vger.kernel.org, x86@kernel.org, Greg Kroah-Hartman , Adhemerval Zanella Netto , Carlos O'Donell , Florian Weimer , Arnd Bergmann , Jann Horn , Christian Brauner , linux-mm@kvack.org Subject: [PATCH v14 2/7] mm: add VM_DROPPABLE for designating always lazily freeable mappings Date: Sun, 1 Jan 2023 17:29:05 +0100 Message-Id: <20230101162910.710293-3-Jason@zx2c4.com> In-Reply-To: <20230101162910.710293-1-Jason@zx2c4.com> References: <20230101162910.710293-1-Jason@zx2c4.com> MIME-Version: 1.0 X-Rspamd-Server: rspam05 X-Rspamd-Queue-Id: 7E6E340010 X-Stat-Signature: nbd9e3ps58mexob7xb15iaffz9pptk1o X-Rspam-User: X-HE-Tag: 1672590566-100951 X-HE-Meta: U2FsdGVkX19/D1SXrvb7TxQU63/sePIzeBQr9yvJeohIiUcmxdDSAy5GziBlDcPQbcnqgye4bak54LRVp0i453NSl6crhs2dQvBXbinV2Q2iF+UCiwv3HFW45XBbRWBXaYLB4bC1SvsUNKVj8cjIC+BUMxNfQKpGK3MvbYjuTTV1K4753neoxrJurPKxM/LBhU8cyp7j/K1GydBrpD5S/xy7P35lJc7MoRsVhaRFdSTt+GHTZ3zsUu0hPcfhNeLNCoGqH+/v4qsRS743Dn8DEITBf1R/+MoYMAi3CZcGpxCmmDDMrjqXT9xyUwkVIKu7IYdz6m3JEiSWf5Vx6/JVZeSpEoLDw7Qx6rB/uNX2lR45Q7QIaXEZbvvk7bqG1UxQ4iEu0x6FA1lpvOLgnPQLOHFVsJ8eyyq23agi2jr8P9vJdTqtIWf/44lrMA5sGO1MM3UjQ7hbkJLPRzKjrOPjT1LyQWu4yv3aMtOKKTIzDH9jG1muidmFmsMC1kMIM7oRUeNaWQkZmnAzHOdOFXQGdnEorbta9bo1VPjIkX35X+v09bV/JJxyGpKCZ/voDcZ41aL3XKsAW7sEA3hLoofopmX6ilmMLGBZRIm8OOaQqTu0mzOYUOJ17RnP13crUoxvV/rAT0P4U2isYgMJqeEQpwsUvPJBsUd/vOQCUezTuW4MjshtTZj0f9AadV4POwQK1N75Wml4xmq7R3olQNgzkzapBkWZvzMzdbwtB4TE25/I0ev95UBiBe1on85U8x9eChpa5cZlBjBgaX1o2/Ij/nFpNxPBnxvxjCExwr41yYb9wvcbsskRr3e824F7cbI485RcK33jXzpnB3nPQ54H94Noa8ahit3JNcxeAwvwfTUszIZQpRKhpj0OcaK6QX2QKOYREhRFpveiWqW6/s44D2egecbnZAdxeqHqZnw/o6cDJ7iR9Uxc63SfbaOeWqUqy60c1Ia/9gnR0Pcw6Xt O4Yvcs8I Yu+ckxdfpsrB4ittxLKYamkuu1PeHgHpO+5JtQm6J6TMIC0dIHP4a/yLx+wEtz6TGXyUjU6syFBa3hV2daB7TVN0mN0MUazZqim9nX9D7VC+cl/x/NF5kzQbqPXcMpiYhwdb6f4A8/Anqv4VQX375jDwx97sBfnokbw1AvK2qa3fYVBy/SdcK7A0c1tTpneR7NGz2OYsvemzEK6QU7hOV8E9RjGD+7m/uJQdwy60bos4kalxhCYtzEW3WkFK6qeZA5xCLocBQgoUNeiELG/zsJEnZQIDJlOURPRtJSv4UT0kJR69BQkmWgNHuAQ== 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: The vDSO getrandom() implementation works with a buffer allocated with a new system call that has certain requirements: - It shouldn't be written to core dumps. * Easy: VM_DONTDUMP. - It should be zeroed on fork. * Easy: VM_WIPEONFORK. - It shouldn't be written to swap. * Uh-oh: mlock is rlimited. * Uh-oh: mlock isn't inherited by forks. - It shouldn't reserve actual memory, but it also shouldn't crash when page faulting in memory if none is available * Uh-oh: MAP_NORESERVE respects vm.overcommit_memory=2. * Uh-oh: VM_NORESERVE means segfaults. It turns out that the vDSO getrandom() function has three really nice characteristics that we can exploit to solve this problem: 1) Due to being wiped during fork(), the vDSO code is already robust to having the contents of the pages it reads zeroed out midway through the function's execution. 2) In the absolute worst case of whatever contingency we're coding for, we have the option to fallback to the getrandom() syscall, and everything is fine. 3) The buffers the function uses are only ever useful for a maximum of 60 seconds -- a sort of cache, rather than a long term allocation. These characteristics mean that we can introduce VM_DROPPABLE, which has the following semantics: a) It never is written out to swap. b) Under memory pressure, mm can just drop the pages (so that they're zero when read back again). c) If there's not enough memory to service a page fault, it's not fatal, and no signal is sent. Instead, writes are simply lost. d) It is inherited by fork. e) It doesn't count against the mlock budget, since nothing is locked. This is fairly simple to implement, with the one snag that we have to use 64-bit VM_* flags, but this shouldn't be a problem, since the only consumers will probably be 64-bit anyway. This way, allocations used by vDSO getrandom() can use: VM_DROPPABLE | VM_DONTDUMP | VM_WIPEONFORK | VM_NORESERVE And there will be no problem with OOMing, crashing on overcommitment, using memory when not in use, not wiping on fork(), coredumps, or writing out to swap. At the moment, rather than skipping writes on OOM, the fault handler just returns to userspace, and the instruction is retried. This isn't terrible, but it's not quite what is intended. The actual instruction skipping has to be implemented arch-by-arch, but so does this whole vDSO series, so that's fine. The following commit addresses it for x86. Cc: linux-mm@kvack.org Signed-off-by: Jason A. Donenfeld --- fs/proc/task_mmu.c | 3 +++ include/linux/mm.h | 8 ++++++++ include/trace/events/mmflags.h | 7 +++++++ mm/Kconfig | 3 +++ mm/memory.c | 4 ++++ mm/mempolicy.c | 3 +++ mm/mprotect.c | 2 +- mm/rmap.c | 5 +++-- 8 files changed, 32 insertions(+), 3 deletions(-) diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c index e35a0398db63..47c7c046f2be 100644 --- a/fs/proc/task_mmu.c +++ b/fs/proc/task_mmu.c @@ -711,6 +711,9 @@ static void show_smap_vma_flags(struct seq_file *m, struct vm_area_struct *vma) #ifdef CONFIG_HAVE_ARCH_USERFAULTFD_MINOR [ilog2(VM_UFFD_MINOR)] = "ui", #endif /* CONFIG_HAVE_ARCH_USERFAULTFD_MINOR */ +#ifdef CONFIG_NEED_VM_DROPPABLE + [ilog2(VM_DROPPABLE)] = "dp", +#endif }; size_t i; diff --git a/include/linux/mm.h b/include/linux/mm.h index f3f196e4d66d..fba3f1e8616b 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -315,11 +315,13 @@ extern unsigned int kobjsize(const void *objp); #define VM_HIGH_ARCH_BIT_2 34 /* bit only usable on 64-bit architectures */ #define VM_HIGH_ARCH_BIT_3 35 /* bit only usable on 64-bit architectures */ #define VM_HIGH_ARCH_BIT_4 36 /* bit only usable on 64-bit architectures */ +#define VM_HIGH_ARCH_BIT_5 37 /* bit only usable on 64-bit architectures */ #define VM_HIGH_ARCH_0 BIT(VM_HIGH_ARCH_BIT_0) #define VM_HIGH_ARCH_1 BIT(VM_HIGH_ARCH_BIT_1) #define VM_HIGH_ARCH_2 BIT(VM_HIGH_ARCH_BIT_2) #define VM_HIGH_ARCH_3 BIT(VM_HIGH_ARCH_BIT_3) #define VM_HIGH_ARCH_4 BIT(VM_HIGH_ARCH_BIT_4) +#define VM_HIGH_ARCH_5 BIT(VM_HIGH_ARCH_BIT_5) #endif /* CONFIG_ARCH_USES_HIGH_VMA_FLAGS */ #ifdef CONFIG_ARCH_HAS_PKEYS @@ -335,6 +337,12 @@ extern unsigned int kobjsize(const void *objp); #endif #endif /* CONFIG_ARCH_HAS_PKEYS */ +#ifdef CONFIG_NEED_VM_DROPPABLE +# define VM_DROPPABLE VM_HIGH_ARCH_5 +#else +# define VM_DROPPABLE 0 +#endif + #if defined(CONFIG_X86) # define VM_PAT VM_ARCH_1 /* PAT reserves whole VMA at once (x86) */ #elif defined(CONFIG_PPC) diff --git a/include/trace/events/mmflags.h b/include/trace/events/mmflags.h index 412b5a46374c..82b2fb811d06 100644 --- a/include/trace/events/mmflags.h +++ b/include/trace/events/mmflags.h @@ -163,6 +163,12 @@ IF_HAVE_PG_SKIP_KASAN_POISON(PG_skip_kasan_poison, "skip_kasan_poison") # define IF_HAVE_UFFD_MINOR(flag, name) #endif +#ifdef CONFIG_NEED_VM_DROPPABLE +# define IF_HAVE_VM_DROPPABLE(flag, name) {flag, name}, +#else +# define IF_HAVE_VM_DROPPABLE(flag, name) +#endif + #define __def_vmaflag_names \ {VM_READ, "read" }, \ {VM_WRITE, "write" }, \ @@ -195,6 +201,7 @@ IF_HAVE_VM_SOFTDIRTY(VM_SOFTDIRTY, "softdirty" ) \ {VM_MIXEDMAP, "mixedmap" }, \ {VM_HUGEPAGE, "hugepage" }, \ {VM_NOHUGEPAGE, "nohugepage" }, \ +IF_HAVE_VM_DROPPABLE(VM_DROPPABLE, "droppable" ) \ {VM_MERGEABLE, "mergeable" } \ #define show_vma_flags(flags) \ diff --git a/mm/Kconfig b/mm/Kconfig index ff7b209dec05..91fd0be96ca4 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -1030,6 +1030,9 @@ config ARCH_USES_HIGH_VMA_FLAGS bool config ARCH_HAS_PKEYS bool +config NEED_VM_DROPPABLE + select ARCH_USES_HIGH_VMA_FLAGS + bool config ARCH_USES_PG_ARCH_X bool diff --git a/mm/memory.c b/mm/memory.c index aad226daf41b..1ade407ccbf9 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -5220,6 +5220,10 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, lru_gen_exit_fault(); + /* If the mapping is droppable, then errors due to OOM aren't fatal. */ + if (vma->vm_flags & VM_DROPPABLE) + ret &= ~VM_FAULT_OOM; + if (flags & FAULT_FLAG_USER) { mem_cgroup_exit_user_fault(); /* diff --git a/mm/mempolicy.c b/mm/mempolicy.c index 02c8a712282f..ebf2e3694a0a 100644 --- a/mm/mempolicy.c +++ b/mm/mempolicy.c @@ -2173,6 +2173,9 @@ struct folio *vma_alloc_folio(gfp_t gfp, int order, struct vm_area_struct *vma, int preferred_nid; nodemask_t *nmask; + if (vma->vm_flags & VM_DROPPABLE) + gfp |= __GFP_NOWARN | __GFP_NORETRY; + pol = get_vma_policy(vma, addr); if (pol->mode == MPOL_INTERLEAVE) { diff --git a/mm/mprotect.c b/mm/mprotect.c index 908df12caa26..a679cc5d1c75 100644 --- a/mm/mprotect.c +++ b/mm/mprotect.c @@ -593,7 +593,7 @@ mprotect_fixup(struct mmu_gather *tlb, struct vm_area_struct *vma, may_expand_vm(mm, oldflags, nrpages)) return -ENOMEM; if (!(oldflags & (VM_ACCOUNT|VM_WRITE|VM_HUGETLB| - VM_SHARED|VM_NORESERVE))) { + VM_SHARED|VM_NORESERVE|VM_DROPPABLE))) { charged = nrpages; if (security_vm_enough_memory_mm(mm, charged)) return -ENOMEM; diff --git a/mm/rmap.c b/mm/rmap.c index b616870a09be..5ed46e59dfcd 100644 --- a/mm/rmap.c +++ b/mm/rmap.c @@ -1294,7 +1294,8 @@ void page_add_new_anon_rmap(struct page *page, int nr; VM_BUG_ON_VMA(address < vma->vm_start || address >= vma->vm_end, vma); - __SetPageSwapBacked(page); + if (!(vma->vm_flags & VM_DROPPABLE)) + __SetPageSwapBacked(page); if (likely(!PageCompound(page))) { /* increment count (starts at -1) */ @@ -1683,7 +1684,7 @@ static bool try_to_unmap_one(struct folio *folio, struct vm_area_struct *vma, * plus the rmap(s) (dropped by discard:). */ if (ref_count == 1 + map_count && - !folio_test_dirty(folio)) { + (!folio_test_dirty(folio) || (vma->vm_flags & VM_DROPPABLE))) { /* Invalidate as we cleared the pte */ mmu_notifier_invalidate_range(mm, address, address + PAGE_SIZE);