From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4A2504A33EA for ; Tue, 4 Aug 2026 19:53:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785873187; cv=none; b=MEoO/uerWn1UhW0UCB1XAubm4QrOl4pQZMeGCvPBOKuLpWfLu8br+DnhVkH9e3beSBMCjOnd47mX9UFoIuAM+irZ1bFxoTatmoCSbGyVm4U/1i6P+QhwfUfMxcvG3rsLN2sV2dUATXQkdgHEfGNNxkTpdfbcZ1urKyUjTnpb53M= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785873187; c=relaxed/simple; bh=YutjiWblG2FopVY6bRolBghJHohEWt1Cy6l8ToVAxYo=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=jne/s5rBLO0S+N/Q1GfGKWGi4gUjNq2x0E7MZ4RsWETbkI6glpO9xAnEKALZ4SwLEQtJRTuHXE8yux2ttH06pzLt8Pqd8Fze/ElpeUrNqqAVNDEXM+KzldLAHpCq/wZZgHwhRLt2Tei2KE5ppHeEsyTdFO39wI347AXwVPWoweA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ieZEMC+h; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ieZEMC+h" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 391C31F00A3D; Tue, 4 Aug 2026 19:53:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1785873186; bh=TW/LLuOUzOOUBhOG6+e5fvCUb0cMEOKn7NiWBNsaufQ=; h=Date:From:To:Cc:Subject:References:In-Reply-To; b=ieZEMC+hAGqRVORA6npYIFDeuowUzn7cK5IkbtDF7ZHzXeIS+jDIrASfAv62HOmxf KH4VTpo1InUlSP4vMvYRwHzdASUG+P6tdUn+LI4nokI5Kbb1gn5Yg6VEnwEQUqyXDS QUVii700M49Q7wbWpQmxpMQNicsnbDy8VJnZ/LPFA1zyWeJVwVnXF2ja86zh2sQtaA hRSdAG1YhrqoifWX94hZduTaBA3HcsOl5EZvQIBCXe4gEPuR+gtBdmwcXB0dkkoUeg 0xVhITBUmu6JPSBUv0c2Vez7HFdN4kicY/IYlbkw0YmNr0EODpZUiB8/D8uQYvng/U Fw8hegZQXa9Dw== Date: Tue, 4 Aug 2026 19:53:03 +0000 From: Yosry Ahmed To: Brendan Jackman Cc: Borislav Petkov , Dave Hansen , Peter Zijlstra , Andrew Morton , David Hildenbrand , Vlastimil Babka , Mike Rapoport , Wei Xu , Johannes Weiner , Zi Yan , Lorenzo Stoakes , linux-mm@kvack.org, linux-kernel@vger.kernel.org, x86@kernel.org, Sumit Garg , Will Deacon , rientjes@google.com, "Kalyazin, Nikita" , patrick.roy@linux.dev, "Itazuri, Takahiro" , Andy Lutomirski , David Kaplan , Thomas Gleixner , Patrick Bellasi , Reiji Watanabe , Sean Christopherson Subject: Re: [PATCH v3 16/26] mm: add definitions for allocating unmapped pages Message-ID: References: <20260726-page_alloc-unmapped-v3-0-6f5729aa9832@google.com> <20260726-page_alloc-unmapped-v3-16-6f5729aa9832@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20260726-page_alloc-unmapped-v3-16-6f5729aa9832@google.com> On Sun, Jul 26, 2026 at 10:22:49PM +0000, Brendan Jackman wrote: > Create ALLOC_UNMAPPED, which requests pages that are not present in the > direct map. Since this feature has a cost (e.g. more freelists), it's > behind a kconfig. Unlike other conditionally-defined alloc flags, it > doesn't fall back to being 0. This prevents building code that uses > ALLOC_UNMAPPED but doesn't depend on the necessary kconfig, since that > would lead to invisible security issues. > > Create a freetype flag to record that pages on the freelists with this > flag are unmapped. This is currently only needed for MIGRATE_UNMOVABLE > pages, so the freetype encoding remains trivial. > > Also create the corresponding pageblock flag to record the same thing. > > To keep patches from being too overwhelming, the actual implementation > is added separately, this is just types, Kconfig boilerplate, etc. > > Acked-by: Vlastimil Babka (SUSE) > Signed-off-by: Brendan Jackman > --- > include/linux/freetype.h | 70 ++++++++++++++++++++++++++++++++++++++++-------- > mm/Kconfig | 3 +++ > mm/page_alloc.h | 18 +++++++++++++ > 3 files changed, 80 insertions(+), 11 deletions(-) > > diff --git a/include/linux/freetype.h b/include/linux/freetype.h > index 3b0d44023b6a1..37e88dcccdecc 100644 > --- a/include/linux/freetype.h > +++ b/include/linux/freetype.h > @@ -2,6 +2,7 @@ > #ifndef _LINUX_FREETYPE_H > #define _LINUX_FREETYPE_H > > +#include > #include > #include > > @@ -64,20 +65,47 @@ static inline bool migratetype_is_mergeable(int mt) > return mt < MIGRATE_PCPTYPES; > } > > +enum { > + /* Defined unconditionally as a hack to avoid a zero-width bitfield. */ > + FREETYPE_UNMAPPED_BIT, > + NUM_FREETYPE_FLAGS, > +}; > + > /* > * A freetype is the identifier for a page freelist. This consists of a > * migratetype, and other bits which encode orthogonal properties of memory. > */ > typedef struct { > - int migratetype; > + unsigned int migratetype : order_base_2(MIGRATE_TYPES); > + unsigned int flags : NUM_FREETYPE_FLAGS; > } freetype_t; > > +#ifdef CONFIG_PAGE_ALLOC_UNMAPPED > +#define FREETYPE_UNMAPPED BIT(FREETYPE_UNMAPPED_BIT) > +#define NUM_UNMAPPED_FREETYPES 1 > +#else > +#define FREETYPE_UNMAPPED 0 > +#define NUM_UNMAPPED_FREETYPES 0 > +#endif > + > +#define FREETYPE_FLAGS_MASK FREETYPE_UNMAPPED > + > /* > * Return a dense linear index for freetypes that have lists in the free area. > * Return -1 for other freetypes. > */ > static inline int freetype_idx(freetype_t freetype) > { > + /* For FREETYPE_UNMAPPED, only MIGRATE_UNMOVABLE has an index. */ > + if (freetype.flags & FREETYPE_UNMAPPED) { > + VM_WARN_ON_ONCE(freetype.flags & ~FREETYPE_UNMAPPED); If we move this to the beginning of the function we can drop the VM_WARN_ON_ONCE() below, right? > + if (freetype.migratetype != MIGRATE_UNMOVABLE) > + return -1; > + return MIGRATE_TYPES; > + } > + /* No other flags are supported. */ > + VM_WARN_ON_ONCE(freetype.flags); > + > return freetype.migratetype; > } > > @@ -85,33 +113,53 @@ static inline freetype_t freetype_from_idx(unsigned int idx) > { > freetype_t freetype; > > - freetype.migratetype = idx; Do we need a comment here? Something like this maybe: /* * There is one freetype per migratetype, as well as one extra * free type for unmovable unmapped pages. */ > + if (idx == MIGRATE_TYPES) { > + freetype.flags = FREETYPE_UNMAPPED; > + freetype.migratetype = MIGRATE_UNMOVABLE; > + } else { > + VM_WARN_ON_ONCE(idx < 0 || idx > MIGRATE_TYPES); > + freetype.flags = 0; > + freetype.migratetype = idx; > + } > return freetype; > } [..] > diff --git a/mm/page_alloc.h b/mm/page_alloc.h > index 9928aa9012588..fac8e5304bb03 100644 > --- a/mm/page_alloc.h > +++ b/mm/page_alloc.h > @@ -56,6 +56,24 @@ > * alloc_tag_sub_check(). > */ > #define ALLOC_NO_CODETAG 0x1000 > +#ifdef CONFIG_PAGE_ALLOC_UNMAPPED > +/* > + * Allocate pages that aren't present in the direct map. If the caller changes > + * direct map presence, it must be restored to the previous state before freeing > + * the page. (This is true regardless of ALLOC_UNMAPPED). > + * > + * This uses the mermap (when __GFP_ZERO), so it's only valid to allocate with > + * this flag where that's valid, namely from process context after the mermap > + * has been initialised for that process. This also means that the allocator > + * leaves behind stale TLB entries in the mermap region. The caller is > + * responsible for ensuring they are flushed as needed. I think this is no longer true as the allocator does not use the mermap with __GFP_ZERO anymore? > + * > + * This is currently incompatible with __GFP_MOVABLE and __GFP_RECLAIMABLE, but > + * only because of allocator implementation details, if a usecase arises this > + * restriction could be dropped. It would help to explain why it's incompatible with __GFP_MOVABLE and __GFP_RECLAIMABLE, here or in the changelog. I assume mainly because we only have one freetype for unmapped unmovable, but there are also some more interesting details like compaction needing to support copying unmapped pages (e.g. via the mermap)? > + */ > +#define ALLOC_UNMAPPED 0x2000 > +#endif > > /* Flags that allow allocations below the min watermark. */ > #define ALLOC_RESERVES (ALLOC_NON_BLOCK|ALLOC_MIN_RESERVE|ALLOC_HIGHATOMIC|ALLOC_OOM) > > -- > 2.54.0 > >