From: Greg Kroah-Hartman Date: Thu, 11 Sep 2025 11:16:19 +0000 (+0200) Subject: 6.6-stable patches X-Git-Tag: v5.10.244~14 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=1aead2f6edc0024688c4072743344d53e62b704d;p=thirdparty%2Fkernel%2Fstable-queue.git 6.6-stable patches added patches: kunit-kasan_test-disable-fortify-string-checker-on-kasan_strings-test.patch mm-introduce-and-use-pgd-p4d-_populate_kernel.patch series --- diff --git a/queue-6.6/kunit-kasan_test-disable-fortify-string-checker-on-kasan_strings-test.patch b/queue-6.6/kunit-kasan_test-disable-fortify-string-checker-on-kasan_strings-test.patch new file mode 100644 index 0000000000..a5b3a4ba46 --- /dev/null +++ b/queue-6.6/kunit-kasan_test-disable-fortify-string-checker-on-kasan_strings-test.patch @@ -0,0 +1,57 @@ +From 7a19afee6fb39df63ddea7ce78976d8c521178c6 Mon Sep 17 00:00:00 2001 +From: Yeoreum Yun +Date: Fri, 1 Aug 2025 13:02:36 +0100 +Subject: kunit: kasan_test: disable fortify string checker on kasan_strings() test + +From: Yeoreum Yun + +commit 7a19afee6fb39df63ddea7ce78976d8c521178c6 upstream. + +Similar to commit 09c6304e38e4 ("kasan: test: fix compatibility with +FORTIFY_SOURCE") the kernel is panicing in kasan_string(). + +This is due to the `src` and `ptr` not being hidden from the optimizer +which would disable the runtime fortify string checker. + +Call trace: + __fortify_panic+0x10/0x20 (P) + kasan_strings+0x980/0x9b0 + kunit_try_run_case+0x68/0x190 + kunit_generic_run_threadfn_adapter+0x34/0x68 + kthread+0x1c4/0x228 + ret_from_fork+0x10/0x20 + Code: d503233f a9bf7bfd 910003fd 9424b243 (d4210000) + ---[ end trace 0000000000000000 ]--- + note: kunit_try_catch[128] exited with irqs disabled + note: kunit_try_catch[128] exited with preempt_count 1 + # kasan_strings: try faulted: last +** replaying previous printk message ** + # kasan_strings: try faulted: last line seen mm/kasan/kasan_test_c.c:1600 + # kasan_strings: internal error occurred preventing test case from running: -4 + +Link: https://lkml.kernel.org/r/20250801120236.2962642-1-yeoreum.yun@arm.com +Fixes: 73228c7ecc5e ("KASAN: port KASAN Tests to KUnit") +Signed-off-by: Yeoreum Yun +Cc: Alexander Potapenko +Cc: Andrey Konovalov +Cc: Andrey Ryabinin +Cc: Dmitriy Vyukov +Cc: Vincenzo Frascino +Cc: +Signed-off-by: Andrew Morton +Signed-off-by: Yeoreum Yun +Signed-off-by: Greg Kroah-Hartman +--- + mm/kasan/kasan_test.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/mm/kasan/kasan_test.c ++++ b/mm/kasan/kasan_test.c +@@ -1053,6 +1053,7 @@ static void kasan_strings(struct kunit * + + ptr = kmalloc(size, GFP_KERNEL | __GFP_ZERO); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr); ++ OPTIMIZER_HIDE_VAR(ptr); + + kfree(ptr); + diff --git a/queue-6.6/mm-introduce-and-use-pgd-p4d-_populate_kernel.patch b/queue-6.6/mm-introduce-and-use-pgd-p4d-_populate_kernel.patch new file mode 100644 index 0000000000..e5ab00265e --- /dev/null +++ b/queue-6.6/mm-introduce-and-use-pgd-p4d-_populate_kernel.patch @@ -0,0 +1,287 @@ +From f2d2f9598ebb0158a3fe17cda0106d7752e654a2 Mon Sep 17 00:00:00 2001 +From: Harry Yoo +Date: Mon, 18 Aug 2025 11:02:05 +0900 +Subject: mm: introduce and use {pgd,p4d}_populate_kernel() + +From: Harry Yoo + +commit f2d2f9598ebb0158a3fe17cda0106d7752e654a2 upstream. + +Introduce and use {pgd,p4d}_populate_kernel() in core MM code when +populating PGD and P4D entries for the kernel address space. These +helpers ensure proper synchronization of page tables when updating the +kernel portion of top-level page tables. + +Until now, the kernel has relied on each architecture to handle +synchronization of top-level page tables in an ad-hoc manner. For +example, see commit 9b861528a801 ("x86-64, mem: Update all PGDs for direct +mapping and vmemmap mapping changes"). + +However, this approach has proven fragile for following reasons: + + 1) It is easy to forget to perform the necessary page table + synchronization when introducing new changes. + For instance, commit 4917f55b4ef9 ("mm/sparse-vmemmap: improve memory + savings for compound devmaps") overlooked the need to synchronize + page tables for the vmemmap area. + + 2) It is also easy to overlook that the vmemmap and direct mapping areas + must not be accessed before explicit page table synchronization. + For example, commit 8d400913c231 ("x86/vmemmap: handle unpopulated + sub-pmd ranges")) caused crashes by accessing the vmemmap area + before calling sync_global_pgds(). + +To address this, as suggested by Dave Hansen, introduce _kernel() variants +of the page table population helpers, which invoke architecture-specific +hooks to properly synchronize page tables. These are introduced in a new +header file, include/linux/pgalloc.h, so they can be called from common +code. + +They reuse existing infrastructure for vmalloc and ioremap. +Synchronization requirements are determined by ARCH_PAGE_TABLE_SYNC_MASK, +and the actual synchronization is performed by +arch_sync_kernel_mappings(). + +This change currently targets only x86_64, so only PGD and P4D level +helpers are introduced. Currently, these helpers are no-ops since no +architecture sets PGTBL_{PGD,P4D}_MODIFIED in ARCH_PAGE_TABLE_SYNC_MASK. + +In theory, PUD and PMD level helpers can be added later if needed by other +architectures. For now, 32-bit architectures (x86-32 and arm) only handle +PGTBL_PMD_MODIFIED, so p*d_populate_kernel() will never affect them unless +we introduce a PMD level helper. + +[harry.yoo@oracle.com: fix KASAN build error due to p*d_populate_kernel()] + Link: https://lkml.kernel.org/r/20250822020727.202749-1-harry.yoo@oracle.com +Link: https://lkml.kernel.org/r/20250818020206.4517-3-harry.yoo@oracle.com +Fixes: 8d400913c231 ("x86/vmemmap: handle unpopulated sub-pmd ranges") +Signed-off-by: Harry Yoo +Suggested-by: Dave Hansen +Acked-by: Kiryl Shutsemau +Reviewed-by: Mike Rapoport (Microsoft) +Reviewed-by: Lorenzo Stoakes +Acked-by: David Hildenbrand +Cc: Alexander Potapenko +Cc: Alistair Popple +Cc: Andrey Konovalov +Cc: Andrey Ryabinin +Cc: Andy Lutomirski +Cc: "Aneesh Kumar K.V" +Cc: Anshuman Khandual +Cc: Ard Biesheuvel +Cc: Arnd Bergmann +Cc: bibo mao +Cc: Borislav Betkov +Cc: Christoph Lameter (Ampere) +Cc: Dennis Zhou +Cc: Dev Jain +Cc: Dmitriy Vyukov +Cc: Gwan-gyeong Mun +Cc: Ingo Molnar +Cc: Jane Chu +Cc: Joao Martins +Cc: Joerg Roedel +Cc: John Hubbard +Cc: Kevin Brodsky +Cc: Liam Howlett +Cc: Michal Hocko +Cc: Oscar Salvador +Cc: Peter Xu +Cc: Peter Zijlstra +Cc: Qi Zheng +Cc: Ryan Roberts +Cc: Suren Baghdasaryan +Cc: Tejun Heo +Cc: Thomas Gleinxer +Cc: Thomas Huth +Cc: "Uladzislau Rezki (Sony)" +Cc: Vincenzo Frascino +Cc: Vlastimil Babka +Cc: +Signed-off-by: Andrew Morton +[ Adjust context ] +Signed-off-by: Harry Yoo +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/pgalloc.h | 29 +++++++++++++++++++++++++++++ + include/linux/pgtable.h | 13 +++++++------ + mm/kasan/init.c | 12 ++++++------ + mm/percpu.c | 6 +++--- + mm/sparse-vmemmap.c | 6 +++--- + 5 files changed, 48 insertions(+), 18 deletions(-) + create mode 100644 include/linux/pgalloc.h + +--- /dev/null ++++ b/include/linux/pgalloc.h +@@ -0,0 +1,29 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++#ifndef _LINUX_PGALLOC_H ++#define _LINUX_PGALLOC_H ++ ++#include ++#include ++ ++/* ++ * {pgd,p4d}_populate_kernel() are defined as macros to allow ++ * compile-time optimization based on the configured page table levels. ++ * Without this, linking may fail because callers (e.g., KASAN) may rely ++ * on calls to these functions being optimized away when passing symbols ++ * that exist only for certain page table levels. ++ */ ++#define pgd_populate_kernel(addr, pgd, p4d) \ ++ do { \ ++ pgd_populate(&init_mm, pgd, p4d); \ ++ if (ARCH_PAGE_TABLE_SYNC_MASK & PGTBL_PGD_MODIFIED) \ ++ arch_sync_kernel_mappings(addr, addr); \ ++ } while (0) ++ ++#define p4d_populate_kernel(addr, p4d, pud) \ ++ do { \ ++ p4d_populate(&init_mm, p4d, pud); \ ++ if (ARCH_PAGE_TABLE_SYNC_MASK & PGTBL_P4D_MODIFIED) \ ++ arch_sync_kernel_mappings(addr, addr); \ ++ } while (0) ++ ++#endif /* _LINUX_PGALLOC_H */ +--- a/include/linux/pgtable.h ++++ b/include/linux/pgtable.h +@@ -1467,8 +1467,8 @@ static inline int pmd_protnone(pmd_t pmd + + /* + * Architectures can set this mask to a combination of PGTBL_P?D_MODIFIED values +- * and let generic vmalloc and ioremap code know when arch_sync_kernel_mappings() +- * needs to be called. ++ * and let generic vmalloc, ioremap and page table update code know when ++ * arch_sync_kernel_mappings() needs to be called. + */ + #ifndef ARCH_PAGE_TABLE_SYNC_MASK + #define ARCH_PAGE_TABLE_SYNC_MASK 0 +@@ -1601,10 +1601,11 @@ static inline bool arch_has_pfn_modify_c + /* + * Page Table Modification bits for pgtbl_mod_mask. + * +- * These are used by the p?d_alloc_track*() set of functions an in the generic +- * vmalloc/ioremap code to track at which page-table levels entries have been +- * modified. Based on that the code can better decide when vmalloc and ioremap +- * mapping changes need to be synchronized to other page-tables in the system. ++ * These are used by the p?d_alloc_track*() and p*d_populate_kernel() ++ * functions in the generic vmalloc, ioremap and page table update code ++ * to track at which page-table levels entries have been modified. ++ * Based on that the code can better decide when page table changes need ++ * to be synchronized to other page-tables in the system. + */ + #define __PGTBL_PGD_MODIFIED 0 + #define __PGTBL_P4D_MODIFIED 1 +--- a/mm/kasan/init.c ++++ b/mm/kasan/init.c +@@ -13,9 +13,9 @@ + #include + #include + #include ++#include + + #include +-#include + + #include "kasan.h" + +@@ -197,7 +197,7 @@ static int __ref zero_p4d_populate(pgd_t + pud_t *pud; + pmd_t *pmd; + +- p4d_populate(&init_mm, p4d, ++ p4d_populate_kernel(addr, p4d, + lm_alias(kasan_early_shadow_pud)); + pud = pud_offset(p4d, addr); + pud_populate(&init_mm, pud, +@@ -218,7 +218,7 @@ static int __ref zero_p4d_populate(pgd_t + } else { + p = early_alloc(PAGE_SIZE, NUMA_NO_NODE); + pud_init(p); +- p4d_populate(&init_mm, p4d, p); ++ p4d_populate_kernel(addr, p4d, p); + } + } + zero_pud_populate(p4d, addr, next); +@@ -257,10 +257,10 @@ int __ref kasan_populate_early_shadow(co + * puds,pmds, so pgd_populate(), pud_populate() + * is noops. + */ +- pgd_populate(&init_mm, pgd, ++ pgd_populate_kernel(addr, pgd, + lm_alias(kasan_early_shadow_p4d)); + p4d = p4d_offset(pgd, addr); +- p4d_populate(&init_mm, p4d, ++ p4d_populate_kernel(addr, p4d, + lm_alias(kasan_early_shadow_pud)); + pud = pud_offset(p4d, addr); + pud_populate(&init_mm, pud, +@@ -279,7 +279,7 @@ int __ref kasan_populate_early_shadow(co + if (!p) + return -ENOMEM; + } else { +- pgd_populate(&init_mm, pgd, ++ pgd_populate_kernel(addr, pgd, + early_alloc(PAGE_SIZE, NUMA_NO_NODE)); + } + } +--- a/mm/percpu.c ++++ b/mm/percpu.c +@@ -3157,7 +3157,7 @@ out_free: + #endif /* BUILD_EMBED_FIRST_CHUNK */ + + #ifdef BUILD_PAGE_FIRST_CHUNK +-#include ++#include + + #ifndef P4D_TABLE_SIZE + #define P4D_TABLE_SIZE PAGE_SIZE +@@ -3185,7 +3185,7 @@ void __init __weak pcpu_populate_pte(uns + p4d = memblock_alloc(P4D_TABLE_SIZE, P4D_TABLE_SIZE); + if (!p4d) + goto err_alloc; +- pgd_populate(&init_mm, pgd, p4d); ++ pgd_populate_kernel(addr, pgd, p4d); + } + + p4d = p4d_offset(pgd, addr); +@@ -3193,7 +3193,7 @@ void __init __weak pcpu_populate_pte(uns + pud = memblock_alloc(PUD_TABLE_SIZE, PUD_TABLE_SIZE); + if (!pud) + goto err_alloc; +- p4d_populate(&init_mm, p4d, pud); ++ p4d_populate_kernel(addr, p4d, pud); + } + + pud = pud_offset(p4d, addr); +--- a/mm/sparse-vmemmap.c ++++ b/mm/sparse-vmemmap.c +@@ -27,9 +27,9 @@ + #include + #include + #include ++#include + + #include +-#include + + /* + * Allocate a block of memory to be used to back the virtual memory map +@@ -225,7 +225,7 @@ p4d_t * __meminit vmemmap_p4d_populate(p + if (!p) + return NULL; + pud_init(p); +- p4d_populate(&init_mm, p4d, p); ++ p4d_populate_kernel(addr, p4d, p); + } + return p4d; + } +@@ -237,7 +237,7 @@ pgd_t * __meminit vmemmap_pgd_populate(u + void *p = vmemmap_alloc_block_zero(PAGE_SIZE, node); + if (!p) + return NULL; +- pgd_populate(&init_mm, pgd, p); ++ pgd_populate_kernel(addr, pgd, p); + } + return pgd; + } diff --git a/queue-6.6/series b/queue-6.6/series new file mode 100644 index 0000000000..db6474c27c --- /dev/null +++ b/queue-6.6/series @@ -0,0 +1,2 @@ +kunit-kasan_test-disable-fortify-string-checker-on-kasan_strings-test.patch +mm-introduce-and-use-pgd-p4d-_populate_kernel.patch