From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-ej1-f50.google.com (mail-ej1-f50.google.com [209.85.218.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1FC9D55D89B for ; Tue, 8 Sep 2026 13:14:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.218.50 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788873255; cv=none; b=dnQUjinif4HTVMzjnOypUOxbcoi5gimSV07CgK1vfTumWm5EX9BM/XjiOiWc2qe4p40Utr0It0qzSoGVrWtupLPVrJgdcF+0crD0d5+k8SeWRyBoup0KpAC6gfsNRno7KVzCaRWC0lgWByVUvDdOfUDqBwHhGN3mbAuOmSTdz2E= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788873255; c=relaxed/simple; bh=qc+jEK7mFoMKlqaFPviVtorgYOoRV33PJN3e/4W/smw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=O/HTTl88GAiKwJ7XfyFpxznVRgqi0ydCCPxFpnfP6Uznoqa7GlrQMqvdj9sbZZfzAad+05dJjs+M2j8bge7o3GAaov1yWjR7NKHM12qHnBpSmp+oRXyImxXPkWOWirpOi/KpCWede78rF8vBk1/jPDTJSk17oRwiyVh00GY7X0k= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=eg8Kf3XI; arc=none smtp.client-ip=209.85.218.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="eg8Kf3XI" Received: by mail-ej1-f50.google.com with SMTP id a640c23a62f3a-c2533d83e3bso793440366b.2 for ; Tue, 08 Sep 2026 06:14:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1788873241; x=1789478041; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=whtEbb8/XqGjTBPOJjMO+bu+KwkFFXfQbBIPnf5a/B4=; b=eg8Kf3XIY18Q/Ovwao0xRReJNz4pbQ8GhuLE8gvujUkhZi/NgaQm5Jr8q4mzdFt5NE 3Nm6SfCu9gNuIdLkrvrm1a+swGVuQrrwhsFT79d+glyoFecdkMLLc5hlmNLfo5WpMH1d ou+B1HCVwvjaanr6gGW4qT1g8fr5ITl0kaQIN/3BFDkCQpBdnffLJpOndbV7P0GegFuY vvGCMNkgPosdvC1lF9VUO14drPLk9HFKcyfbhjDMDbXqJ/kGlAyy+yAkSB1tOl/VKAFI BC2rVCjXW1QLFTbancKSrqbDJcjulNXw6ICJr31oLHEVRgrLM9EZotSWlhwBlYaG+GcD +ecQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788873241; x=1789478041; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=whtEbb8/XqGjTBPOJjMO+bu+KwkFFXfQbBIPnf5a/B4=; b=AvHgVWwJCDm0Gkm1A+Rkx7c3AgLm+v8/GjwAB6yyCuiMUNmmpm7JHnJErCFfOoIRzg ea1np+CfXo/nloVy2Qod+N892qJiDAKYEIwLfWbLttLzi5IFJpeJboA4e4NW7xPTTWuj cSE71GwQk58aSeJNVwCmxiNa1Moe5HZXpQC8w8oVPLU8wd5OJLnDak/TBALLABtziyNv /CoY1YI1i93c9mn3iRXmOMmrLx3s0nXnEcxQ5YBid6Rrqi4NlcazYlGIsRbEVVumJpu9 F4nqAW4PvQ5zJd3TcN6JhA5uQUjJEtvxAWXF4ilewOFSc8jhIWbXvNDaE/wTrqVR1Dgm amlg== X-Forwarded-Encrypted: i=1; AKwUvByg+2oPtborKCHSlLCYh8vW6RQIx8NciIZlm24nK7wxYwvZZuwqa74aUMLNIDOPyR8+sXLEUonIWI2a6ko=@vger.kernel.org X-Gm-Message-State: AFuF++n6Ae3GwG/+u9dRx6hD9ziFl0WQfNmKSBM8W4D3kzDeVj/4Bs0Y 8tGjKQIyoVYUFZULDmouTZSwKlXyuS+jgPfLulJmhPn7eNZ86l3Dibgg X-Gm-Gg: AYBFou2TD9kd4xQNxoZMfm5tKtSNI2sakVF0iT/s8dkXfGFSuRDflCjOuLpXL5dY06I SmOzMLMTkpTTYtqKGFp0+QJhMxQ/AIy/q7uM1++XcmEIb4zZ6lSeP6kfcQxv9AF/0V4Wz8IzLXe pc2+xOtokkN9aQRhzeJxDhipBS+6bJHErulq7ARv7Ub6qbup3yt9n5NCDTaPis7Idh/NbrnkVr9 Z29PQ5fg2jonWWke6Ny9233zv5ozC0/qBNRUFoLK3XI2eAeGS/OHsEaqtHzVYSEFfEIRk/YbCyi 2LqEdG3SsylUcUibtgNLcebEUZCTZ6m3vV5cbYbAP6l6stU/DeCam5fl+S/DpXvNUxeZR+bnV4z au8p8E/0vBW/vjqfWRx0uUJ7Y2Qn75BzYBpUas3i3x/NQejXZPlvtUNnUzR3+ArQePI3UASamtr rNTaBzS9xeWhUa9Cvle3SG5RhrKPmz44VeNTL8d/hHQstao1T6yg== X-Received: by 2002:a17:907:7b8c:b0:c19:49ee:19b9 with SMTP id a640c23a62f3a-c260cbfa1a6mr2202057266b.15.1788873241205; Tue, 08 Sep 2026 06:14:01 -0700 (PDT) Received: from [127.0.0.1] ([2a09:bac6:37a9:1e5a::306:1]) by smtp.gmail.com with ESMTPSA id a640c23a62f3a-c260d6e1c93sm625170866b.63.2026.09.08.06.14.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 08 Sep 2026 06:14:00 -0700 (PDT) From: Caleb Kan Date: Tue, 08 Sep 2026 14:13:42 +0100 Subject: [PATCH RFC v2 09/11] stackdepot: add architecture hooks for compact frame storage 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="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20260908-stackdepot-trie-v2-9-1996d5cef732@cloudflare.com> References: <20260908-stackdepot-trie-v2-0-1996d5cef732@cloudflare.com> In-Reply-To: <20260908-stackdepot-trie-v2-0-1996d5cef732@cloudflare.com> To: Andrew Morton Cc: linux-mm@kvack.org, linux-kernel@vger.kernel.org, kasan-dev@googlegroups.com, Vlastimil Babka , Alexander Potapenko , Marco Elver , Dmitry Vyukov , Andrey Konovalov , Oscar Salvador , Caleb Kan , kernel-team@cloudflare.com X-Mailer: b4 0.16.0 From: Caleb Kan Path-compressed trie nodes can reduce their frame storage further when an architecture can represent kernel text and module addresses in 32 bits. Add architecture hooks that compress a frame only when decompression reproduces the original address exactly. Store arm64 frames as signed 32-bit offsets from _text. This covers the 2 GB module relocation window without depending on a 4 GB high-bit boundary. On x86-64, store the low 32 bits when the upper 32 bits are all set. Keep other frames full-width, and provide a generic implementation that always rejects compression. Make the generic header available to architectures without a specialized implementation and wire it explicitly for UML. Add KUnit coverage for raw fallback, arm64 boundary round trips, and native x86-64 prefix compression. These hooks do not change stack depot behavior until a later patch adds trie storage. Signed-off-by: Caleb Kan --- arch/arm64/include/asm/stackdepot.h | 42 ++++++++++++++++++ arch/um/include/asm/Kbuild | 1 + arch/x86/include/asm/stackdepot.h | 37 ++++++++++++++++ include/asm-generic/Kbuild | 1 + include/asm-generic/stackdepot.h | 19 ++++++++ lib/tests/stackdepot_kunit.c | 86 +++++++++++++++++++++++++++++++++++++ 6 files changed, 186 insertions(+) diff --git a/arch/arm64/include/asm/stackdepot.h b/arch/arm64/include/asm/stackdepot.h new file mode 100644 index 000000000000..df8959d59336 --- /dev/null +++ b/arch/arm64/include/asm/stackdepot.h @@ -0,0 +1,42 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ASM_STACKDEPOT_H +#define __ASM_STACKDEPOT_H + +#include +#include + +/* + * Modules are allocated inside a 2 GB relocation window containing the + * kernel image. Store a signed 32-bit offset from _text so compression is + * independent of 4 GB high-bit boundaries crossed by that window. + */ +static inline unsigned long arch_stack_depot_frame_from_payload(u32 payload) +{ + long offset; + + offset = (s32)payload; + if (offset < 0) + return (unsigned long)_text - (unsigned long)(-offset); + return (unsigned long)_text + (unsigned long)offset; +} + +static inline bool +arch_stack_depot_frame_try_compress(unsigned long frame, u32 *payload) +{ + u32 candidate; + + candidate = (u32)(frame - (unsigned long)_text); + if (arch_stack_depot_frame_from_payload(candidate) != frame) + return false; + + *payload = candidate; + return true; +} + +static inline void +arch_stack_depot_frame_decompress(u32 payload, unsigned long *frame) +{ + *frame = arch_stack_depot_frame_from_payload(payload); +} + +#endif /* __ASM_STACKDEPOT_H */ diff --git a/arch/um/include/asm/Kbuild b/arch/um/include/asm/Kbuild index 8fdc0bd9ab6f..14778d2457d7 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -21,6 +21,7 @@ generic-y += preempt.h generic-y += ring_buffer.h generic-y += runtime-const.h generic-y += softirq_stack.h +generic-y += stackdepot.h generic-y += switch_to.h generic-y += topology.h generic-y += trace_clock.h diff --git a/arch/x86/include/asm/stackdepot.h b/arch/x86/include/asm/stackdepot.h new file mode 100644 index 000000000000..9a8d04fa8c1c --- /dev/null +++ b/arch/x86/include/asm/stackdepot.h @@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_STACKDEPOT_H +#define _ASM_X86_STACKDEPOT_H + +#include + +#ifdef CONFIG_X86_64 +/* + * Compress canonical kernel text/module addresses whose upper 32 bits are all + * ones. Other kernel virtual addresses stay raw, so decompression reconstructs + * the original frame by restoring this prefix. + */ +#define STACK_DEPOT_X86_64_FRAME_PREFIX 0xffffffff00000000UL +#define STACK_DEPOT_X86_64_FRAME_LOW_MASK 0x00000000ffffffffUL + +static inline bool +arch_stack_depot_frame_try_compress(unsigned long frame, u32 *low) +{ + if ((frame & ~STACK_DEPOT_X86_64_FRAME_LOW_MASK) != + STACK_DEPOT_X86_64_FRAME_PREFIX) + return false; + + *low = (u32)frame; + return true; +} + +static inline void +arch_stack_depot_frame_decompress(u32 low, unsigned long *frame) +{ + *frame = STACK_DEPOT_X86_64_FRAME_PREFIX | low; +} + +#else +#include +#endif /* CONFIG_X86_64 */ + +#endif /* _ASM_X86_STACKDEPOT_H */ diff --git a/include/asm-generic/Kbuild b/include/asm-generic/Kbuild index 2bc00c67dc54..d8402a6afc70 100644 --- a/include/asm-generic/Kbuild +++ b/include/asm-generic/Kbuild @@ -55,6 +55,7 @@ mandatory-y += serial.h mandatory-y += shmparam.h mandatory-y += simd.h mandatory-y += softirq_stack.h +mandatory-y += stackdepot.h mandatory-y += switch_to.h mandatory-y += timex.h mandatory-y += tlbflush.h diff --git a/include/asm-generic/stackdepot.h b/include/asm-generic/stackdepot.h new file mode 100644 index 000000000000..846975767bdd --- /dev/null +++ b/include/asm-generic/stackdepot.h @@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ASM_GENERIC_STACKDEPOT_H +#define __ASM_GENERIC_STACKDEPOT_H + +#include + +static inline bool +arch_stack_depot_frame_try_compress(unsigned long frame, u32 *low) +{ + return false; +} + +static inline void +arch_stack_depot_frame_decompress(u32 low, unsigned long *frame) +{ + /* Generic code never compresses frames, so this hook is unreachable. */ +} + +#endif /* __ASM_GENERIC_STACKDEPOT_H */ diff --git a/lib/tests/stackdepot_kunit.c b/lib/tests/stackdepot_kunit.c index 3c526791ef93..e4a7f1c83457 100644 --- a/lib/tests/stackdepot_kunit.c +++ b/lib/tests/stackdepot_kunit.c @@ -3,9 +3,21 @@ #include #include #include +#include #include #include +#include + +#ifdef CONFIG_ARM64 +#include + +static inline unsigned long stackdepot_arm64_frame(long offset) +{ + return (unsigned long)((long)_text + offset); +} +#endif + static void stackdepot_countable_public(struct kunit *test) { unsigned long plain_entries[] = { @@ -125,10 +137,84 @@ static void stackdepot_fetch_into_rejects_missing_or_short_stack(struct kunit *t KUNIT_EXPECT_MEMEQ(test, fetched, expected, sizeof(expected)); } +static void stackdepot_frame_raw_fallback(struct kunit *test) +{ + unsigned long frame = 0x1000UL; + bool compressed; + u32 payload; + +#ifdef CONFIG_ARM64 + frame = (unsigned long)_text + (unsigned long)S32_MAX + 1UL; +#endif + + compressed = arch_stack_depot_frame_try_compress(frame, &payload); + KUNIT_EXPECT_FALSE(test, compressed); +} + +#if defined(CONFIG_X86_64) && !defined(CONFIG_UML) +static void stackdepot_frame_x86_64(struct kunit *test) +{ + unsigned long direct_map = 0xffff888000001000UL; + unsigned long frame = 0xffffffff81234567UL; + unsigned long out; + bool compressed; + u32 low; + + compressed = arch_stack_depot_frame_try_compress(frame, &low); + KUNIT_EXPECT_TRUE(test, compressed); + KUNIT_EXPECT_EQ(test, low, (u32)0x81234567); + arch_stack_depot_frame_decompress(low, &out); + KUNIT_EXPECT_EQ(test, out, frame); + + compressed = arch_stack_depot_frame_try_compress(direct_map, &low); + KUNIT_EXPECT_FALSE(test, compressed); +} +#endif /* CONFIG_X86_64 && !CONFIG_UML */ + +#ifdef CONFIG_ARM64 +static void stackdepot_frame_arm64(struct kunit *test) +{ + long negative_offset = S32_MIN; + long positive_offset = S32_MAX; + long offset = 0x123456; + unsigned long frame = stackdepot_arm64_frame(offset); + unsigned long out; + bool compressed; + u32 payload; + + compressed = arch_stack_depot_frame_try_compress(frame, &payload); + KUNIT_EXPECT_TRUE(test, compressed); + KUNIT_EXPECT_EQ(test, payload, (u32)(s32)offset); + arch_stack_depot_frame_decompress(payload, &out); + KUNIT_EXPECT_EQ(test, out, frame); + + frame = stackdepot_arm64_frame(negative_offset); + compressed = arch_stack_depot_frame_try_compress(frame, &payload); + KUNIT_EXPECT_TRUE(test, compressed); + KUNIT_EXPECT_EQ(test, payload, (u32)(s32)negative_offset); + arch_stack_depot_frame_decompress(payload, &out); + KUNIT_EXPECT_EQ(test, out, frame); + + frame = stackdepot_arm64_frame(positive_offset); + compressed = arch_stack_depot_frame_try_compress(frame, &payload); + KUNIT_EXPECT_TRUE(test, compressed); + KUNIT_EXPECT_EQ(test, payload, (u32)(s32)positive_offset); + arch_stack_depot_frame_decompress(payload, &out); + KUNIT_EXPECT_EQ(test, out, frame); +} +#endif /* CONFIG_ARM64 */ + static struct kunit_case stackdepot_test_cases[] = { KUNIT_CASE(stackdepot_countable_public), KUNIT_CASE(stackdepot_fetch_into_roundtrip), KUNIT_CASE(stackdepot_fetch_into_rejects_missing_or_short_stack), + KUNIT_CASE(stackdepot_frame_raw_fallback), +#if defined(CONFIG_X86_64) && !defined(CONFIG_UML) + KUNIT_CASE(stackdepot_frame_x86_64), +#endif +#ifdef CONFIG_ARM64 + KUNIT_CASE(stackdepot_frame_arm64), +#endif {} }; -- Git-155)