FAILED: patch "[PATCH] arm64: mm: Fix rodata=full block mapping support for realm" failed to apply to 6.18-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 6.18-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.18.y
git checkout FETCH_HEAD
git cherry-pick -x f12b435de2f2bb09ce406467020181ada528844c
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026042741-lagged-ricotta-aa8b@gregkh' --subject-prefix 'PATCH 6.18.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From f12b435de2f2bb09ce406467020181ada528844c Mon Sep 17 00:00:00 2001
From: Ryan Roberts <[email protected]>
Date: Mon, 30 Mar 2026 17:17:02 +0100
Subject: [PATCH] arm64: mm: Fix rodata=full block mapping support for realm
guests
Commit a166563e7ec37 ("arm64: mm: support large block mapping when rodata=full") enabled the linear map to be mapped by block/cont while still allowing granular permission changes on BBML2_NOABORT systems by lazily splitting the live mappings. This mechanism was intended to be usable by realm guests since they need to dynamically share dma buffers with the host by "decrypting" them - which for Arm CCA, means marking them as shared in the page tables.
However, it turns out that the mechanism was failing for realm guests because realms need to share their dma buffers (via __set_memory_enc_dec()) much earlier during boot than split_kernel_leaf_mapping() was able to handle. The report linked below showed that GIC's ITS was one such user. But during the investigation I found other callsites that could not meet the split_kernel_leaf_mapping() constraints.
The problem is that we block map the linear map based on the boot CPU supporting BBML2_NOABORT, then check that all the other CPUs support it too when finalizing the caps. If they don't, then we stop_machine() and split to ptes. For safety, split_kernel_leaf_mapping() previously wouldn't permit splitting until after the caps were finalized. That ensured that if any secondary cpus were running that didn't support BBML2_NOABORT, we wouldn't risk breaking them.
I've fix this problem by reducing the black-out window where we refuse to split; there are now 2 windows. The first is from T0 until the page allocator is inititialized. Splitting allocates memory for the page allocator so it must be in use. The second covers the period between starting to online the secondary cpus until the system caps are finalized (this is a very small window).
All of the problematic callers are calling __set_memory_enc_dec() before the secondary cpus come online, so this solves the problem. However, one of these callers, swiotlb_update_mem_attributes(), was trying to split before the page allocator was initialized. So I have moved this call from arch_mm_preinit() to mem_init(), which solves the ordering issue.
I've added warnings and return an error if any attempt is made to split in the black-out windows.
Note there are other issues which prevent booting all the way to user space, which will be fixed in subsequent patches.
arch/arm64/include/asm/mmu.h +2 -0
@@ -112,5 +112,7 @@ void kpti_install_ng_mappings(void);static inline void kpti_install_ng_mappings (void ) {}#endif +extern bool page_alloc_available; +#endif /* !__ASSEMBLER__ */ #endif
arch/arm64/mm/init.c +8 -1
@@ -350,7 +350,6 @@ void __init arch_mm_preinit(void) }swiotlb_init (swiotlb, flags); -swiotlb_update_mem_attributes ();/* * Check boundaries twice: Some fundamental inconsistencies can be
@@ -377,6 +376,14 @@ void __init arch_mm_preinit(void) } } +bool page_alloc_available__ro_after_init ; + +void __init mem_init (void ) +{ + page_alloc_available = true; +swiotlb_update_mem_attributes (); +} +void free_initmem (void ) {void *lm_init_begin =lm_alias (__init_begin);
arch/arm64/mm/mmu.c +32 -13
70 lines not on this page · raw message
Sasha Levin
maintainerPATCH 1/2 arm64: mm: Simplify check in arch_kfence_init_pool()
From: Kevin Brodsky <[email protected]>
[ Upstream commit b7737c38e7cb611c2fbd87af3b09afeb92c96fe7 ]
TL;DR: checking force_pte_mapping() in arch_kfence_init_pool() is sufficient
Commit ce2b3a50ad92 ("arm64: mm: Don't sleep in split_kernel_leaf_mapping() when in atomic context") recently added an arm64 implementation of arch_kfence_init_pool() to ensure that the KFENCE pool is PTE-mapped. Assuming that the pool was not initialised early, block splitting is necessary if the linear mapping is not fully PTE-mapped, in other words if force_pte_mapping() is false.
arch_kfence_init_pool() currently makes another check: whether BBML2-noabort is supported, i.e. whether we are *able* to split block mappings. This check is however unnecessary, because force_pte_mapping() is always true if KFENCE is enabled and BBML2-noabort is not supported. This must be the case by design, since KFENCE requires PTE-mapped pages in all cases. We can therefore remove that check.
The situation is different in split_kernel_leaf_mapping(), as that function is called unconditionally regardless of the configuration. If BBML2-noabort is not supported, it cannot do anything and bails out. If force_pte_mapping() is true, there is nothing to do and it also bails out, but these are independent checks.
Commit 53357f14f924 ("arm64: mm: Tidy up force_pte_mapping()") grouped these checks into a helper, split_leaf_mapping_possible(). This isn't so helpful as only split_kernel_leaf_mapping() should check both. Revert the parts of that commit that introduced the helper, reintroducing the more accurate comments in split_kernel_leaf_mapping().
Stable-dep-of: f12b435de2f2 ("arm64: mm: Fix rodata=full block mapping support for realm guests")
--- arch/arm64/mm/mmu.c | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-)
arch/arm64/mm/mmu.c +16 -17
@@ -773,18 +773,6 @@ static inline bool force_pte_mapping(void)return rodata_full ||arm64_kfence_can_set_direct_map () ||is_realm_world (); } -static inline bool split_leaf_mapping_possible (void ) -{ -/* -* !BBML2_NOABORT systems should never run into scenarios where we would -* have to split. So exit early and let calling code detect it and raise -* a warning. -*/ -if (!system_supports_bbml2_noabort ()) -return false; -return !force_pte_mapping (); -} -static DEFINE_MUTEX (pgtable_split_lock);int split_kernel_leaf_mapping (unsigned long start,unsigned long end)
@@ -792,11 +780,22 @@ int split_kernel_leaf_mapping(unsigned long start, unsigned long end)int ret;/* -* Exit early if the region is within a pte-mapped area or if we can't -* split. For the latter case, the permission change code will raise a -* warning if not already pte-mapped. +* !BBML2_NOABORT systems should not be trying to change permissions on +* anything that is not pte-mapped in the first place. Just return early +* and let the permission change code raise a warning if not already +* pte-mapped. */ -if (!split_leaf_mapping_possible () ||is_kfence_address ((void *)start)) +if (!system_supports_bbml2_noabort ()) +return 0 ; + +/* +* If the region is within a pte-mapped area, there is no need to try to +* split. Additionally, CONFIG_DEBUG_PAGEALLOC and CONFIG_KFENCE may +* change permissions from atomic context so for those cases (which are +* always pte-mapped), we must not go any further because taking the +* mutex below may sleep. +*/ +if (force_pte_mapping () ||is_kfence_address ((void *)start))return 0 ;/*
@@ -1095,7 +1094,7 @@ bool arch_kfence_init_pool(void)int ret;/* Exit early if we know the linear map is already pte-mapped. */ -if (!split_leaf_mapping_possible ()) +if (force_pte_mapping ())return true;/* Kfence pool is already pte-mapped for the early init case. */
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 arm64: mm: Fix rodata=full block mapping support for realm guests
From: Ryan Roberts <[email protected]>
[ Upstream commit f12b435de2f2bb09ce406467020181ada528844c ]
Commit a166563e7ec37 ("arm64: mm: support large block mapping when rodata=full") enabled the linear map to be mapped by block/cont while still allowing granular permission changes on BBML2_NOABORT systems by lazily splitting the live mappings. This mechanism was intended to be usable by realm guests since they need to dynamically share dma buffers with the host by "decrypting" them - which for Arm CCA, means marking them as shared in the page tables.
However, it turns out that the mechanism was failing for realm guests because realms need to share their dma buffers (via __set_memory_enc_dec()) much earlier during boot than split_kernel_leaf_mapping() was able to handle. The report linked below showed that GIC's ITS was one such user. But during the investigation I found other callsites that could not meet the split_kernel_leaf_mapping() constraints.
The problem is that we block map the linear map based on the boot CPU supporting BBML2_NOABORT, then check that all the other CPUs support it too when finalizing the caps. If they don't, then we stop_machine() and split to ptes. For safety, split_kernel_leaf_mapping() previously wouldn't permit splitting until after the caps were finalized. That ensured that if any secondary cpus were running that didn't support BBML2_NOABORT, we wouldn't risk breaking them.
I've fix this problem by reducing the black-out window where we refuse to split; there are now 2 windows. The first is from T0 until the page allocator is inititialized. Splitting allocates memory for the page allocator so it must be in use. The second covers the period between starting to online the secondary cpus until the system caps are finalized (this is a very small window).
All of the problematic callers are calling __set_memory_enc_dec() before the secondary cpus come online, so this solves the problem. However, one of these callers, swiotlb_update_mem_attributes(), was trying to split before the page allocator was initialized. So I have moved this call from arch_mm_preinit() to mem_init(), which solves the ordering issue.
I've added warnings and return an error if any attempt is made to split in the black-out windows.
Note there are other issues which prevent booting all the way to user space, which will be fixed in subsequent patches.
--- arch/arm64/include/asm/mmu.h | 2 ++ arch/arm64/mm/init.c | 9 +++++++- arch/arm64/mm/mmu.c | 45 +++++++++++++++++++++++++----------- 3 files changed, 42 insertions(+), 14 deletions(-)
arch/arm64/include/asm/mmu.h +2 -0
@@ -112,5 +112,7 @@ void kpti_install_ng_mappings(void);static inline void kpti_install_ng_mappings (void ) {}#endif +extern bool page_alloc_available; +#endif /* !__ASSEMBLY__ */ #endif
arch/arm64/mm/init.c +8 -1
@@ -357,7 +357,6 @@ void __init arch_mm_preinit(void) }swiotlb_init (swiotlb, flags); -swiotlb_update_mem_attributes ();/* * Check boundaries twice: Some fundamental inconsistencies can be
@@ -384,6 +383,14 @@ void __init arch_mm_preinit(void) } } +bool page_alloc_available__ro_after_init ; + +void __init mem_init (void ) +{ + page_alloc_available = true; +swiotlb_update_mem_attributes (); +} +void free_initmem (void ) {void *lm_init_begin =lm_alias (__init_begin);
arch/arm64/mm/mmu.c +32 -13
70 lines not on this page · raw message
Signature · 1 line
2.53.0