[PATCH 00/24] arm64: Decouple MTE code from KASAN support

2 views
Skip to first unread message

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:09 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Peter Collingbourne, sta...@vger.kernel.org, Pierre-Clément Tosi, Shuah Khan, linux-k...@vger.kernel.org, Alexander Potapenko, Andrew Morton, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, linu...@kvack.org
MTE is a hardware feature, KASAN is software infrastructure.

The direction of the dependency should be clear: KASAN uses MTE.

However, the code does not reflect this split: many mte_*() functions
are actually only intended for HW_TAGS such that there is no way to make
use of in-kernel MTE functionality without enabling KASAN. Furthermore,
there is a lot of unnecessary indirection in those functions, causing
duplication, code that is harder to follow than it should be, and making
it easier for subtle inconsistencies to hide.

Instead, this series aims to untangle the two into a set of reusable,
arch-level MTE functions and a thin wrapper around them that KASAN
needs. For non-KASAN MTE-related code, instead of attempting to reuse
KASAN functions, break out individual MTE primitives into KASAN-agnostic
functions and use them where needed by aligning in style with how other
features are supported e.g. during kernel entry/exit.

The result of this rework made some bugs and inefficiencies obvious so
I ordered the patches into 3 sets: first, bug fixes, then, functional
improvements, and finally the refactor. Specifically:

- patch 1 fixes a bug in the support for userspace MTE, with a kselftest
reproducer in patch 2
- patch 3 fixes an unsound inline asm statement
- patches 4-7 address inefficiencies in PSTATE.TCO-guarded sections, TCO
lazy clearing, and harden TTBR1 address categorization
- patches 9-12 rework MTE-specific code in arch-agnostic KASAN, with an
arch-level early refactor in patch 8 to keep those minimal
- patches 13-23 then proceed with the methodical untangling of MTE
from KASAN, leaving only a thin KASAN_HW_TAGS wrapper in <asm/kasan.h>
- patch 24 introduces a hidden Kconfig flag ARM64_MTE_KERNEL, to better
document in the code when logic is required for EL1 MTE, as opposed to
KASAN

This was tested on v7.4-rc1 and applies cleanly to arm64 for-next/core
at commit f46be4da2cbb ("selftests/arm64: GCS must not leak on a failed
clone3").

The following checkpatch.pl errors are consciously ignored:

- "WARNING: ... does MAINTAINERS need updating?" on patch 2 for the
new kselftest but selftests/arm64/ is already properly maintained
- "WARNING: Macros with flow control statements should be avoided" on
patch 5 but the new __raw_{get,put}_mem_tco() macros are intentionally
consistent in style with the pre-existing __raw_{get,put}_mem()

while the other warnings/error are false-positives I fix in [1] and [2].

[1]: https://lore.kernel.org/r/20261107-checkpatch-asm-com...@google.com
[2]: https://lore.kernel.org/r/20261107-checkpatch-file_pa...@google.com

---
Pierre-Clément Tosi (24):
arm64: Fix lazy TCO clear when enabling user MTE
kselftest/arm64: Test lazy PSTATE.TCO handling
arm64: Fix volatility of IRG inline assembly
arm64: Skip TCO on privileged uaccess without kMTE
arm64: Check MTE once per fault-handling section
arm64: Harden is_ttbr1_addr() on tagged addresses
arm64: Skip redundant TCO clear post-kernel entry
arm64: Introduce mte_get_reset_tfsr() helpers
kasan: rework hw_{force=>flush}_async_tag_fault()
kasan: rework hw_{get=>set}_random_tag()
kasan: provide empty stub for kasan_report_async()
kasan: drop mte-kasan.h from arch-agnostic header
arm64: Introduce set_pstate_tco() helper macro
arm64: Add mte_{enter,exit}_*_{kernel,user}_mode()
arm64: Refactor and remove mte_disable_tco_entry()
arm64: Refactor KERNEL_GCR_EL1 out of <sysreg.h>
arm64: Introduce MTE & KASAN tag handling helpers
arm64: Inline and remove mte_check_tfsr_*()
arm64: Rework static branches for kernel MTE
arm64: Move MTE insn wrappers to <asm/mte-def.h>
arm64: Introduce mte_tag[_and_zero]_range()
arm64: Consolidate MTE-based KASAN in mte-kasan.h
arm64: Fold <asm/mte-kasan.h> into <asm/kasan.h>
arm64: Introduce CONFIG_ARM64_MTE_KERNEL

MAINTAINERS | 2 +-
arch/arm64/Kconfig | 8 +
arch/arm64/include/asm/kasan.h | 103 +++++++-
arch/arm64/include/asm/memory.h | 14 --
arch/arm64/include/asm/mte-def.h | 65 +++++
arch/arm64/include/asm/mte-kasan.h | 266 ---------------------
arch/arm64/include/asm/mte.h | 189 ++++++++++-----
arch/arm64/include/asm/processor.h | 6 +-
arch/arm64/include/asm/sysreg.h | 17 +-
arch/arm64/include/asm/uaccess.h | 106 +++++---
arch/arm64/include/asm/word-at-a-time.h | 22 +-
arch/arm64/kernel/entry-common.c | 58 ++++-
arch/arm64/kernel/entry.S | 3 +-
arch/arm64/kernel/mte.c | 72 +++---
arch/arm64/lib/strlen.S | 4 +-
arch/arm64/mm/copypage.c | 1 +
arch/arm64/mm/fault.c | 2 +-
include/linux/kasan.h | 8 +-
mm/kasan/hw_tags.c | 3 +-
mm/kasan/kasan.h | 14 +-
tools/testing/selftests/arm64/mte/.gitignore | 1 +
tools/testing/selftests/arm64/mte/check_lazy_tco.c | 152 ++++++++++++
22 files changed, 649 insertions(+), 467 deletions(-)
---
base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4
change-id: 20261107-mte-kasan-split-3632e818f997

Best regards,
--
Pierre-Clément Tosi <pt...@google.com>

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:23 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Alexander Potapenko, Andrew Morton, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, linu...@kvack.org, Pierre-Clément Tosi
Separate common arch-agnostic KASAN policy (fault reporting) from arch
HW details (fault flushing) by reworking the function's signature.

Update its only definition (in arm64) accordingly.

This resolves #include challenges arising from the circular dependency:

mte_check_tfsr_exit() ==> kasan_report_async()
kasan_report_async() ==> <linux/kasan.h>
<linux/kasan.h> ==> hw_force_async_tag_fault()
hw_force_async_tag_fault() ==> arch_force_async_tag_fault()
arch_force_async_tag_fault() ==> mte_check_tfsr_exit()

Cc: Alexander Potapenko <gli...@google.com>
Cc: Andrew Morton <ak...@linux-foundation.org>
Cc: Andrey Konovalov <andre...@gmail.com>
Cc: Andrey Ryabinin <ryabin...@gmail.com>
Cc: Dmitry Vyukov <dvy...@google.com>
Cc: kasa...@googlegroups.com
Cc: linu...@kvack.org
Signed-off-by: Pierre-Clément Tosi <pt...@google.com>
---
arch/arm64/include/asm/memory.h | 2 +-
mm/kasan/hw_tags.c | 3 ++-
mm/kasan/kasan.h | 2 +-
3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/arch/arm64/include/asm/memory.h b/arch/arm64/include/asm/memory.h
index a2b7a33966ff..8e751b56d20c 100644
--- a/arch/arm64/include/asm/memory.h
+++ b/arch/arm64/include/asm/memory.h
@@ -316,7 +316,7 @@ static inline const void *__tag_set(const void *addr, u8 tag)
#define arch_enable_tag_checks_write_only() mte_enable_kernel_store_only()
#define arch_suppress_tag_checks_start() mte_enable_tco()
#define arch_suppress_tag_checks_stop() mte_disable_tco()
-#define arch_force_async_tag_fault() mte_check_tfsr_exit()
+#define arch_flush_async_tag_fault() mte_get_reset_tfsr()
#define arch_get_random_tag() mte_get_random_tag()
#define arch_get_mem_tag(addr) mte_get_mem_tag(addr)
#define arch_set_mem_tag_range(addr, size, tag, init) \
diff --git a/mm/kasan/hw_tags.c b/mm/kasan/hw_tags.c
index a848eb2f9910..c4772eebb80d 100644
--- a/mm/kasan/hw_tags.c
+++ b/mm/kasan/hw_tags.c
@@ -428,7 +428,8 @@ EXPORT_SYMBOL_IF_KUNIT(kasan_enable_hw_tags);

VISIBLE_IF_KUNIT void kasan_force_async_fault(void)
{
- hw_force_async_tag_fault();
+ if (hw_flush_async_tag_fault())
+ kasan_report_async();
}
EXPORT_SYMBOL_IF_KUNIT(kasan_force_async_fault);

diff --git a/mm/kasan/kasan.h b/mm/kasan/kasan.h
index fc9169a54766..be5dcf6b052c 100644
--- a/mm/kasan/kasan.h
+++ b/mm/kasan/kasan.h
@@ -431,7 +431,7 @@ static inline const void *arch_kasan_set_tag(const void *addr, u8 tag)
#define hw_enable_tag_checks_asymm() arch_enable_tag_checks_asymm()
#define hw_suppress_tag_checks_start() arch_suppress_tag_checks_start()
#define hw_suppress_tag_checks_stop() arch_suppress_tag_checks_stop()
-#define hw_force_async_tag_fault() arch_force_async_tag_fault()
+#define hw_flush_async_tag_fault() arch_flush_async_tag_fault()
#define hw_enable_tag_checks_write_only() arch_enable_tag_checks_write_only()
#define hw_get_random_tag() arch_get_random_tag()
#define hw_get_mem_tag(addr) arch_get_mem_tag(addr)

--
2.56.0.455.g6c5a503b38-goog

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:24 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Alexander Potapenko, Andrew Morton, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, linu...@kvack.org, Pierre-Clément Tosi
With MTE, the IRG instruction tags a pointer in-place, so that

set_tag(ptr, hw_get_random_tag())

can conceptually be synthesized as a single "IRG %[ptr], %[ptr], 0".

However, with the way the API is currently defined, we confuse the
compiler into generating a random tag with invalid address bits, to then
bitfield-extract the tag and shift-and-mask it into another pointer.

Furthermore, every single (indirect or direct) use-case for a random tag
in arch-agnostic KASAN ends up passing it to set_tag(), which likely is
an indicator of a suboptimal API design.

Therefore, make the function clearer and more optimization-friendly by
directly taking the pointer to be randomly tagged.

Update the only definition (in arm64) accordingly.

Intentionally keep this patch minimal (and limited to KASAN_HW_TAGS) to
reduce its associated risks and make it as uncontentious as possible. A
future patch will refactor the arch-agnostic KASAN code to enable the
optimization mentioned above.

Cc: Alexander Potapenko <gli...@google.com>
Cc: Andrew Morton <ak...@linux-foundation.org>
Cc: Andrey Konovalov <andre...@gmail.com>
Cc: Andrey Ryabinin <ryabin...@gmail.com>
Cc: Dmitry Vyukov <dvy...@google.com>
Cc: kasa...@googlegroups.com
Cc: linu...@kvack.org
Signed-off-by: Pierre-Clément Tosi <pt...@google.com>
---
arch/arm64/include/asm/memory.h | 2 +-
arch/arm64/include/asm/mte-kasan.h | 14 +++++++-------
mm/kasan/kasan.h | 7 +++++--
3 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/arch/arm64/include/asm/memory.h b/arch/arm64/include/asm/memory.h
index 8e751b56d20c..29e7537f5e58 100644
--- a/arch/arm64/include/asm/memory.h
+++ b/arch/arm64/include/asm/memory.h
@@ -317,7 +317,7 @@ static inline const void *__tag_set(const void *addr, u8 tag)
#define arch_suppress_tag_checks_start() mte_enable_tco()
#define arch_suppress_tag_checks_stop() mte_disable_tco()
#define arch_flush_async_tag_fault() mte_get_reset_tfsr()
-#define arch_get_random_tag() mte_get_random_tag()
+#define arch_set_random_tag(addr) mte_set_random_tag(addr)
#define arch_get_mem_tag(addr) mte_get_mem_tag(addr)
#define arch_set_mem_tag_range(addr, size, tag, init) \
mte_set_mem_tag_range((addr), (size), (tag), (init))
diff --git a/arch/arm64/include/asm/mte-kasan.h b/arch/arm64/include/asm/mte-kasan.h
index b474fca3ea56..17e4155781fc 100644
--- a/arch/arm64/include/asm/mte-kasan.h
+++ b/arch/arm64/include/asm/mte-kasan.h
@@ -73,14 +73,14 @@ static inline u8 mte_get_mem_tag(void *addr)
}

/* Generate a random tag. */
-static inline u8 mte_get_random_tag(void)
+static inline void *mte_set_random_tag(const void *addr)
{
- void *addr;
-
+ /* Writes the random MTE tag in bits [59:56]. */
asm volatile(__MTE_PREAMBLE "irg %0, %0"
- : "=r" (addr));
+ : "+r" (addr));

- return mte_get_ptr_tag(addr);
+ /* Sets bits [63:60] as KASAN expects. */
+ return (void *)__tag_set(addr, mte_get_ptr_tag((void *)addr));
}

static inline u64 __stg_post(u64 p)
@@ -190,9 +190,9 @@ static inline u8 mte_get_mem_tag(void *addr)
return 0xFF;
}

-static inline u8 mte_get_random_tag(void)
+static inline void *mte_set_random_tag(const void *addr)
{
- return 0xFF;
+ return (void *)__tag_set(addr, 0xFF);
}

static inline void mte_set_mem_tag_range(void *addr, size_t size,
diff --git a/mm/kasan/kasan.h b/mm/kasan/kasan.h
index be5dcf6b052c..0df7daee1864 100644
--- a/mm/kasan/kasan.h
+++ b/mm/kasan/kasan.h
@@ -433,7 +433,7 @@ static inline const void *arch_kasan_set_tag(const void *addr, u8 tag)
#define hw_suppress_tag_checks_stop() arch_suppress_tag_checks_stop()
#define hw_flush_async_tag_fault() arch_flush_async_tag_fault()
#define hw_enable_tag_checks_write_only() arch_enable_tag_checks_write_only()
-#define hw_get_random_tag() arch_get_random_tag()
+#define hw_set_random_tag(addr) arch_set_random_tag(addr)
#define hw_get_mem_tag(addr) arch_get_mem_tag(addr)
#define hw_set_mem_tag_range(addr, size, tag, init) \
arch_set_mem_tag_range((addr), (size), (tag), (init))
@@ -469,7 +469,10 @@ static inline bool kasan_write_only_enabled(void)
#ifdef CONFIG_KASAN_SW_TAGS
u8 kasan_random_tag(void);
#elif defined(CONFIG_KASAN_HW_TAGS)
-static inline u8 kasan_random_tag(void) { return hw_get_random_tag(); }
+static inline u8 kasan_random_tag(void)
+{
+ return get_tag(hw_set_random_tag(NULL));
+}
#else
static inline u8 kasan_random_tag(void) { return 0; }
#endif

--
2.56.0.455.g6c5a503b38-goog

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:26 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Alexander Potapenko, Andrew Morton, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, linu...@kvack.org, Pierre-Clément Tosi
Allow callers to compile without #ifdef guards.

Cc: Alexander Potapenko <gli...@google.com>
Cc: Andrew Morton <ak...@linux-foundation.org>
Cc: Andrey Konovalov <andre...@gmail.com>
Cc: Andrey Ryabinin <ryabin...@gmail.com>
Cc: Dmitry Vyukov <dvy...@google.com>
Cc: kasa...@googlegroups.com
Cc: linu...@kvack.org
Signed-off-by: Pierre-Clément Tosi <pt...@google.com>
---
include/linux/kasan.h | 8 ++------
1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/include/linux/kasan.h b/include/linux/kasan.h
index bf233bde68c7..e429fb483176 100644
--- a/include/linux/kasan.h
+++ b/include/linux/kasan.h
@@ -541,12 +541,6 @@ static inline void *kasan_reset_tag(const void *addr)

#endif /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS*/

-#ifdef CONFIG_KASAN_HW_TAGS
-
-void kasan_report_async(void);
-
-#endif /* CONFIG_KASAN_HW_TAGS */
-
#ifdef CONFIG_KASAN_GENERIC
void __init kasan_init_generic(void);
#else
@@ -562,9 +556,11 @@ static inline void kasan_init_sw_tags(void) { }
#ifdef CONFIG_KASAN_HW_TAGS
void kasan_init_hw_tags_cpu(void);
void __init kasan_init_hw_tags(void);
+void kasan_report_async(void);
#else
static inline void kasan_init_hw_tags_cpu(void) { }
static inline void kasan_init_hw_tags(void) { }
+static inline void kasan_report_async(void) { }
#endif

#ifdef CONFIG_KASAN_VMALLOC

--
2.56.0.455.g6c5a503b38-goog

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:28 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Alexander Potapenko, Andrew Morton, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, linu...@kvack.org, Pierre-Clément Tosi
The inclusion of <asm/mte-kasan.h> (only defined by arm64) is based on
the brittle assumption that KASAN_HW_TAGS is equivalent to MTE, which
will break as soon as another architecture supports it. Furthermore,
exposing the header's contents to common KASAN_HW_TAGS code risks
spreading this wrong assumption further.

Allow KASAN_GRANULE_SIZE to be arch-defined, with a fallback.

Define KASAN_GRANULE_SIZE in arm64's KASAN header when KASAN_HW_TAGS.

Remove the #include, which is now unused as a result.

Cc: Alexander Potapenko <gli...@google.com>
Cc: Andrew Morton <ak...@linux-foundation.org>
Cc: Andrey Konovalov <andre...@gmail.com>
Cc: Andrey Ryabinin <ryabin...@gmail.com>
Cc: Dmitry Vyukov <dvy...@google.com>
Cc: kasa...@googlegroups.com
Cc: linu...@kvack.org
Signed-off-by: Pierre-Clément Tosi <pt...@google.com>
---
arch/arm64/include/asm/kasan.h | 5 +++++
mm/kasan/kasan.h | 5 +----
2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/arch/arm64/include/asm/kasan.h b/arch/arm64/include/asm/kasan.h
index b167e9d3da91..3106a2271781 100644
--- a/arch/arm64/include/asm/kasan.h
+++ b/arch/arm64/include/asm/kasan.h
@@ -6,6 +6,7 @@

#include <linux/linkage.h>
#include <asm/memory.h>
+#include <asm/mte-def.h>
#include <asm/mte-kasan.h>
#include <asm/pgtable-types.h>

@@ -22,5 +23,9 @@ void kasan_init(void);
static inline void kasan_init(void) { }
#endif

+#ifdef CONFIG_KASAN_HW_TAGS
+#define KASAN_GRANULE_SIZE MTE_GRANULE_SIZE
+#endif /* CONFIG_KASAN_HW_TAGS */
+
#endif
#endif
diff --git a/mm/kasan/kasan.h b/mm/kasan/kasan.h
index 0df7daee1864..52c2e7dca739 100644
--- a/mm/kasan/kasan.h
+++ b/mm/kasan/kasan.h
@@ -128,11 +128,8 @@ static inline bool kasan_requires_meta(void)

#endif /* CONFIG_KASAN_GENERIC */

-#if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)
+#ifndef KASAN_GRANULE_SIZE
#define KASAN_GRANULE_SIZE (1UL << KASAN_SHADOW_SCALE_SHIFT)
-#else
-#include <asm/mte-kasan.h>
-#define KASAN_GRANULE_SIZE MTE_GRANULE_SIZE
#endif

#define KASAN_GRANULE_MASK (KASAN_GRANULE_SIZE - 1)

--
2.56.0.455.g6c5a503b38-goog

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:41 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Alexander Potapenko, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, Pierre-Clément Tosi
As the KASAN-agnostic logic has been carved out of these functions into
standalone MTE functions and since all their non-KASAN callers have been
migrated to those KASAN-agnostic functions and/or arch-agnostic KASAN
functions, the only remaining callers are in KASAN core code and access
them through their arch_*() aliases, which are now an unnecessary level
of indirection.

Therefore, fold the aliases into __always_inline functions.

First, note that this now exposes arch_*() as proper C symbols. Although
the aliasing macros were necessary when first introduced by commit
ccbe2aaba1ed ("arm64: kasan: add arch layer for memory tagging helpers")
because of mm/kasan/kasan.h's reliance on #ifndef to provide fallbacks,
they have since been made redundant by commit e34f1e2ee098 ("kasan: drop
empty tagging-related defines").

Second, it moves the KASAN arch definitions out of <asm/memory.h>. It
isn't clear to me why they were originally placed there but since they
are only for arch-agnostic KASAN code and are guarded by KASAN_HW_TAGS,
it seems more appropriate to have them in a KASAN arch header.

Drop the !ARM64_MTE fallbacks for mte_*() instead of renaming them since
they were deadcode, being only called through arch_*(), which were only
defined when KASAN_HW_TAGS and given that KASAN_HW_TAGS means ARM64_MTE.

Move the declarations of mte_enable_kernel_*() to <asm/mte.h> and
provide no alternatives when !ARM64_MTE since their signatures imply
that they never fail (return void) so a currently non-existent caller
could get confused. A future patch might rework that and add fallbacks.

Cc: Alexander Potapenko <gli...@google.com>
Cc: Andrey Konovalov <andre...@gmail.com>
Cc: Andrey Ryabinin <ryabin...@gmail.com>
Cc: Dmitry Vyukov <dvy...@google.com>
Cc: kasa...@googlegroups.com
Signed-off-by: Pierre-Clément Tosi <pt...@google.com>
---
arch/arm64/include/asm/memory.h | 14 -------
arch/arm64/include/asm/mte-kasan.h | 86 ++++++++++++++------------------------
arch/arm64/include/asm/mte.h | 5 +++
3 files changed, 36 insertions(+), 69 deletions(-)

diff --git a/arch/arm64/include/asm/memory.h b/arch/arm64/include/asm/memory.h
index 29e7537f5e58..2aa14788c050 100644
--- a/arch/arm64/include/asm/memory.h
+++ b/arch/arm64/include/asm/memory.h
@@ -309,20 +309,6 @@ static inline const void *__tag_set(const void *addr, u8 tag)
return (const void *)(__addr | __tag_shifted(tag));
}

-#ifdef CONFIG_KASAN_HW_TAGS
-#define arch_enable_tag_checks_sync() mte_enable_kernel_sync()
-#define arch_enable_tag_checks_async() mte_enable_kernel_async()
-#define arch_enable_tag_checks_asymm() mte_enable_kernel_asymm()
-#define arch_enable_tag_checks_write_only() mte_enable_kernel_store_only()
-#define arch_suppress_tag_checks_start() mte_enable_tco()
-#define arch_suppress_tag_checks_stop() mte_disable_tco()
-#define arch_flush_async_tag_fault() mte_get_reset_tfsr()
-#define arch_set_random_tag(addr) mte_set_random_tag(addr)
-#define arch_get_mem_tag(addr) mte_get_mem_tag(addr)
-#define arch_set_mem_tag_range(addr, size, tag, init) \
- mte_set_mem_tag_range((addr), (size), (tag), (init))
-#endif /* CONFIG_KASAN_HW_TAGS */
-
/*
* Physical vs virtual RAM address space conversion. These are
* private definitions which should NOT be used outside memory.h
diff --git a/arch/arm64/include/asm/mte-kasan.h b/arch/arm64/include/asm/mte-kasan.h
index 81a8cf3b9a95..c0224a2bb515 100644
--- a/arch/arm64/include/asm/mte-kasan.h
+++ b/arch/arm64/include/asm/mte-kasan.h
@@ -46,98 +46,74 @@ static __always_inline u8 kasan_tag_from_mte(u8 tag)
return u8_replace_bits(KASAN_TAG_MIN, tag, KASAN_TAG_MTE_MASK);
}

-#ifdef CONFIG_ARM64_MTE
+#ifdef CONFIG_KASAN_HW_TAGS

/*
- * These functions are meant to be only used from KASAN runtime through
- * the arch_*() interface defined in asm/memory.h.
* These functions don't include system_supports_mte() checks,
* as KASAN only calls them when MTE is supported and enabled.
*/

-static inline void mte_disable_tco(void)
+static __always_inline void arch_enable_tag_checks_sync(void)
{
- set_pstate_tco(0);
+ mte_enable_kernel_sync();
}

-static inline void mte_enable_tco(void)
+static __always_inline void arch_enable_tag_checks_async(void)
{
- set_pstate_tco(1);
+ mte_enable_kernel_async();
}

-/* Get allocation tag for the address. */
-static inline u8 mte_get_mem_tag(void *addr)
+static __always_inline void arch_enable_tag_checks_asymm(void)
{
- return kasan_tag_from_mte(__mte_tag_of(__ldg((u64)addr)));
+ mte_enable_kernel_asymm();
}

-/* Generate a random tag. */
-static inline void *mte_set_random_tag(const void *addr)
+static __always_inline int arch_enable_tag_checks_write_only(void)
{
- /* Writes the random MTE tag in bits [59:56]. */
- addr = (const void *)__irg((u64)addr);
-
- /* Sets bits [63:60] as KASAN expects. */
- return (void *)__tag_set(addr, kasan_tag_from_mte(mte_tag_of(addr)));
+ return mte_enable_kernel_store_only();
}

-static inline void mte_set_mem_tag_range(void *addr, size_t size, u8 tag,
- bool zero)
+static __always_inline void arch_suppress_tag_checks_stop(void)
{
- if (zero)
- mte_tag_and_zero_range(addr, size, kasan_tag_to_mte(tag));
- else
- mte_tag_range(addr, size, kasan_tag_to_mte(tag));
-}
-
-void mte_enable_kernel_sync(void);
-void mte_enable_kernel_async(void);
-void mte_enable_kernel_asymm(void);
-int mte_enable_kernel_store_only(void);
-
-#else /* CONFIG_ARM64_MTE */
-
-static inline void mte_disable_tco(void)
-{
-}
-
-static inline void mte_enable_tco(void)
-{
-}
-
-static inline u8 mte_get_mem_tag(void *addr)
-{
- return 0xFF;
+ set_pstate_tco(0);
}

-static inline void *mte_set_random_tag(const void *addr)
+static __always_inline void arch_suppress_tag_checks_start(void)
{
- return (void *)__tag_set(addr, 0xFF);
+ set_pstate_tco(1);
}

-static inline void mte_set_mem_tag_range(void *addr, size_t size,
- u8 tag, bool init)
+static __always_inline bool arch_flush_async_tag_fault(void)
{
+ return mte_get_reset_tfsr();
}

-static inline void mte_enable_kernel_sync(void)
+/* Get allocation tag for the address. */
+static __always_inline u8 arch_get_mem_tag(void *addr)
{
+ return kasan_tag_from_mte(__mte_tag_of(__ldg((u64)addr)));
}

-static inline void mte_enable_kernel_async(void)
+/* Generate a random tag. */
+static __always_inline void *arch_set_random_tag(const void *addr)
{
-}
+ /* Writes the random MTE tag in bits [59:56]. */
+ addr = (const void *)__irg((u64)addr);

-static inline void mte_enable_kernel_asymm(void)
-{
+ /* Sets bits [63:60] as KASAN expects. */
+ return (void *)__tag_set(addr, kasan_tag_from_mte(mte_tag_of(addr)));
}

-static inline int mte_enable_kernel_store_only(void)
+static __always_inline void arch_set_mem_tag_range(void *addr, size_t size,
+ u8 tag, bool zero)
{
- return -EINVAL;
+ if (zero)
+ mte_tag_and_zero_range(addr, size, kasan_tag_to_mte(tag));
+ else
+ mte_tag_range(addr, size, kasan_tag_to_mte(tag));
}

-#endif /* CONFIG_ARM64_MTE */
+#endif /* CONFIG_KASAN_HW_TAGS */

#endif /* __ASSEMBLER__ */

diff --git a/arch/arm64/include/asm/mte.h b/arch/arm64/include/asm/mte.h
index 9ba215b2b0fd..34d1438019ed 100644
--- a/arch/arm64/include/asm/mte.h
+++ b/arch/arm64/include/asm/mte.h
@@ -47,6 +47,11 @@ static inline bool system_uses_async_mte_faults(void)
{
return static_branch_unlikely(&mte_async_or_asymm_mode);
}
+
+void mte_enable_kernel_sync(void);
+void mte_enable_kernel_async(void);
+void mte_enable_kernel_asymm(void);
+int mte_enable_kernel_store_only(void);
#else
static inline bool system_uses_sync_mte_faults(void)
{

--
2.56.0.455.g6c5a503b38-goog

Pierre-Clément Tosi

unread,
Nov 7, 2026, 10:37:42 AM (12 days ago) Nov 7
to Catalin Marinas, Will Deacon, Mark Rutland, Vincenzo Frascino, linux-ar...@lists.infradead.org, linux-...@vger.kernel.org, Alexander Potapenko, Andrey Konovalov, Andrey Ryabinin, Dmitry Vyukov, kasa...@googlegroups.com, Pierre-Clément Tosi
Now that all MTE-specific implementation details have been extracted to
<asm/mte-def.h> and <asm/mte.h>, <asm/mte-kasan.h> only contains a thin
KASAN-to-MTE wrapping layer so fold it directly into <asm/kasan.h> to
prevent confusion or misuse and simplify header dependencies.

Update MAINTAINERS to remove the pattern that was specifically added to
track this header. This silences a checkpatch warning. If future arm64
KASAN headers are added, they should probably favor the arch-agnostic
header naming convention <asm/kasan*.h> instead, anyway.

Cc: Alexander Potapenko <gli...@google.com>
Cc: Andrey Konovalov <andre...@gmail.com>
Cc: Andrey Ryabinin <ryabin...@gmail.com>
Cc: Dmitry Vyukov <dvy...@google.com>
Cc: kasa...@googlegroups.com
Signed-off-by: Pierre-Clément Tosi <pt...@google.com>
---
MAINTAINERS | 2 +-
arch/arm64/include/asm/kasan.h | 100 ++++++++++++++++++++++++++++++-
arch/arm64/include/asm/mte-kasan.h | 120 -------------------------------------
arch/arm64/kernel/entry.S | 2 +-
arch/arm64/kernel/mte.c | 2 +-
5 files changed, 101 insertions(+), 125 deletions(-)

diff --git a/MAINTAINERS b/MAINTAINERS
index 93abbb315065..990237c9ac32 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -14358,7 +14358,7 @@ L: kasa...@googlegroups.com
S: Maintained
B: https://bugzilla.kernel.org/buglist.cgi?component=Sanitizers&product=Memory%20Management
F: Documentation/dev-tools/kasan.rst
-F: arch/*/include/asm/*kasan.h
+F: arch/*/include/asm/kasan.h
F: arch/*/mm/kasan_init*
F: include/linux/kasan*.h
F: lib/Kconfig.kasan
diff --git a/arch/arm64/include/asm/kasan.h b/arch/arm64/include/asm/kasan.h
index 3106a2271781..45af725d6fd3 100644
--- a/arch/arm64/include/asm/kasan.h
+++ b/arch/arm64/include/asm/kasan.h
@@ -2,18 +2,54 @@
#ifndef __ASM_KASAN_H
#define __ASM_KASAN_H

+#include <linux/bits.h>
+#include <linux/const.h>
+#include <linux/kasan-tags.h>
+
+#include <asm/mte-def.h>
+
+#define __KASAN_TAG_MTE_MASK GENMASK(MTE_TAG_SIZE - 1, 0)
+/*
+ * KASAN always uses a whole byte for its tags. With CONFIG_KASAN_HW_TAGS it
+ * only uses tags in the range 0xF0-0xFF, which we map to MTE tags 0x0-0xF.
+ */
+#define __kasan_tag_to_mte(tag) ((tag) & __KASAN_TAG_MTE_MASK)
+#define __kasan_tag_from_mte(tag) ((KASAN_TAG_MIN & ~__KASAN_TAG_MTE_MASK) | (tag))
+
+#ifdef CONFIG_KASAN_HW_TAGS
+#define KASAN_GCR_INCL \
+ GENMASK(__kasan_tag_to_mte(KASAN_TAG_MAX), __kasan_tag_to_mte(KASAN_TAG_MIN))
+#else
+#define KASAN_GCR_INCL UL(0)
+#endif
+
#ifndef __ASSEMBLER__

+#include <linux/bitfield.h>
#include <linux/linkage.h>
+#include <linux/types.h>
+
#include <asm/memory.h>
-#include <asm/mte-def.h>
-#include <asm/mte-kasan.h>
+#include <asm/mte.h>
#include <asm/pgtable-types.h>
+#include <asm/sysreg.h>

#define arch_kasan_set_tag(addr, tag) __tag_set(addr, tag)
#define arch_kasan_reset_tag(addr) __tag_reset(addr)
#define arch_kasan_get_tag(addr) __tag_get(addr)

+#define KASAN_TAG_MTE_MASK GENMASK_U8(MTE_TAG_SIZE - 1, 0)
+
+static __always_inline u8 kasan_tag_to_mte(u8 tag)
+{
+ return u8_get_bits(tag, KASAN_TAG_MTE_MASK);
+}
+
+static __always_inline u8 kasan_tag_from_mte(u8 tag)
+{
+ return u8_replace_bits(KASAN_TAG_MIN, tag, KASAN_TAG_MTE_MASK);
+}
+
#if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)

asmlinkage void kasan_early_init(void);
@@ -24,7 +60,67 @@ static inline void kasan_init(void) { }
#endif

#ifdef CONFIG_KASAN_HW_TAGS
+
#define KASAN_GRANULE_SIZE MTE_GRANULE_SIZE
+
+static __always_inline void arch_enable_tag_checks_sync(void)
+{
+ mte_enable_kernel_sync();
+}
+
+static __always_inline void arch_enable_tag_checks_async(void)
+{
+ mte_enable_kernel_async();
+}
+
+static __always_inline void arch_enable_tag_checks_asymm(void)
+{
+ mte_enable_kernel_asymm();
+}
+
+static __always_inline int arch_enable_tag_checks_write_only(void)
+{
+ return mte_enable_kernel_store_only();
+}
+
+static __always_inline void arch_suppress_tag_checks_stop(void)
+{
+ set_pstate_tco(0);
+}
+
+static __always_inline void arch_suppress_tag_checks_start(void)
+{
+ set_pstate_tco(1);
+}
+
+static __always_inline bool arch_flush_async_tag_fault(void)
+{
+ return mte_get_reset_tfsr();
+}
+
+static __always_inline u8 arch_get_mem_tag(void *addr)
+{
+ return kasan_tag_from_mte(__mte_tag_of(__ldg((u64)addr)));
+}
+
+static __always_inline void *arch_set_random_tag(const void *addr)
+{
+ /* Writes the random MTE tag in bits [59:56]. */
+ addr = (const void *)__irg((u64)addr);
+
+ /* Sets bits [63:60] as KASAN expects. */
+ return (void *)__tag_set(addr, kasan_tag_from_mte(mte_tag_of(addr)));
+}
+
+static __always_inline void arch_set_mem_tag_range(void *addr, size_t size,
+ u8 tag, bool zero)
+{
+ if (zero)
+ mte_tag_and_zero_range(addr, size, kasan_tag_to_mte(tag));
+ else
+ mte_tag_range(addr, size, kasan_tag_to_mte(tag));
+}
+
#endif /* CONFIG_KASAN_HW_TAGS */

#endif
diff --git a/arch/arm64/include/asm/mte-kasan.h b/arch/arm64/include/asm/mte-kasan.h
deleted file mode 100644
index c0224a2bb515..000000000000
--- a/arch/arm64/include/asm/mte-kasan.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2020 ARM Ltd.
- */
-#ifndef __ASM_MTE_KASAN_H
-#define __ASM_MTE_KASAN_H
-
-#include <linux/bits.h>
-#include <linux/const.h>
-#include <linux/kasan-tags.h>
-
-#include <asm/mte-def.h>
-
-#define __KASAN_TAG_MTE_MASK GENMASK(MTE_TAG_SIZE - 1, 0)
-/*
- * KASAN always uses a whole byte for its tags. With CONFIG_KASAN_HW_TAGS it
- * only uses tags in the range 0xF0-0xFF, which we map to MTE tags 0x0-0xF.
- */
-#define __kasan_tag_to_mte(tag) ((tag) & __KASAN_TAG_MTE_MASK)
-#define __kasan_tag_from_mte(tag) ((KASAN_TAG_MIN & ~__KASAN_TAG_MTE_MASK) | (tag))
-
-#ifdef CONFIG_KASAN_HW_TAGS
-#define KASAN_GCR_INCL \
- GENMASK(__kasan_tag_to_mte(KASAN_TAG_MAX), __kasan_tag_to_mte(KASAN_TAG_MIN))
-#else
-#define KASAN_GCR_INCL UL(0)
-#endif
-
-#ifndef __ASSEMBLER__
-
-#include <linux/bitfield.h>
-#include <linux/types.h>
-
-#include <asm/mte.h>
-#include <asm/sysreg.h>
-
-#define KASAN_TAG_MTE_MASK GENMASK_U8(MTE_TAG_SIZE - 1, 0)
-
-static __always_inline u8 kasan_tag_to_mte(u8 tag)
-{
- return u8_get_bits(tag, KASAN_TAG_MTE_MASK);
-}
-
-static __always_inline u8 kasan_tag_from_mte(u8 tag)
-{
- return u8_replace_bits(KASAN_TAG_MIN, tag, KASAN_TAG_MTE_MASK);
-}
-
-#ifdef CONFIG_KASAN_HW_TAGS
-
-/*
- * These functions don't include system_supports_mte() checks,
- * as KASAN only calls them when MTE is supported and enabled.
- */
-
-static __always_inline void arch_enable_tag_checks_sync(void)
-{
- mte_enable_kernel_sync();
-}
-
-static __always_inline void arch_enable_tag_checks_async(void)
-{
- mte_enable_kernel_async();
-}
-
-static __always_inline void arch_enable_tag_checks_asymm(void)
-{
- mte_enable_kernel_asymm();
-}
-
-static __always_inline int arch_enable_tag_checks_write_only(void)
-{
- return mte_enable_kernel_store_only();
-}
-
-static __always_inline void arch_suppress_tag_checks_stop(void)
-{
- set_pstate_tco(0);
-}
-
-static __always_inline void arch_suppress_tag_checks_start(void)
-{
- set_pstate_tco(1);
-}
-
-static __always_inline bool arch_flush_async_tag_fault(void)
-{
- return mte_get_reset_tfsr();
-}
-
-/* Get allocation tag for the address. */
-static __always_inline u8 arch_get_mem_tag(void *addr)
-{
- return kasan_tag_from_mte(__mte_tag_of(__ldg((u64)addr)));
-}
-
-/* Generate a random tag. */
-static __always_inline void *arch_set_random_tag(const void *addr)
-{
- /* Writes the random MTE tag in bits [59:56]. */
- addr = (const void *)__irg((u64)addr);
-
- /* Sets bits [63:60] as KASAN expects. */
- return (void *)__tag_set(addr, kasan_tag_from_mte(mte_tag_of(addr)));
-}
-
-static __always_inline void arch_set_mem_tag_range(void *addr, size_t size,
- u8 tag, bool zero)
-{
- if (zero)
- mte_tag_and_zero_range(addr, size, kasan_tag_to_mte(tag));
- else
- mte_tag_range(addr, size, kasan_tag_to_mte(tag));
-}
-
-#endif /* CONFIG_KASAN_HW_TAGS */
-
-#endif /* __ASSEMBLER__ */
-
-#endif /* __ASM_MTE_KASAN_H */
diff --git a/arch/arm64/kernel/entry.S b/arch/arm64/kernel/entry.S
index d1d9a7a049a7..2da704f53b5a 100644
--- a/arch/arm64/kernel/entry.S
+++ b/arch/arm64/kernel/entry.S
@@ -20,8 +20,8 @@
#include <asm/errno.h>
#include <asm/esr.h>
#include <asm/irq.h>
+#include <asm/kasan.h>
#include <asm/memory.h>
-#include <asm/mte-kasan.h>
#include <asm/mmu.h>
#include <asm/processor.h>
#include <asm/ptrace.h>
diff --git a/arch/arm64/kernel/mte.c b/arch/arm64/kernel/mte.c
index 675ba6a803cf..d072cb76ad05 100644
--- a/arch/arm64/kernel/mte.c
+++ b/arch/arm64/kernel/mte.c
@@ -24,8 +24,8 @@

#include <asm/barrier.h>
#include <asm/cpufeature.h>
+#include <asm/kasan.h>
#include <asm/mte.h>
-#include <asm/mte-kasan.h>
#include <asm/ptrace.h>
#include <asm/sysreg.h>


--
2.56.0.455.g6c5a503b38-goog

Reply all
Reply to author
Forward
0 new messages