From patchwork Thu Aug 22 01:15:27 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Brown X-Patchwork-Id: 13772379 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id BB19AC52D6F for ; Thu, 22 Aug 2024 01:21:04 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 4B22F6B0254; Wed, 21 Aug 2024 21:21:04 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 43A786B0255; Wed, 21 Aug 2024 21:21:04 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 266CA6B0256; Wed, 21 Aug 2024 21:21:04 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id 043AD6B0254 for ; Wed, 21 Aug 2024 21:21:03 -0400 (EDT) Received: from smtpin11.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id AAAC8140453 for ; Thu, 22 Aug 2024 01:21:03 +0000 (UTC) X-FDA: 82478127606.11.AC7DCA8 Received: from sin.source.kernel.org (sin.source.kernel.org [145.40.73.55]) by imf26.hostedemail.com (Postfix) with ESMTP id 4D89A140008 for ; Thu, 22 Aug 2024 01:21:00 +0000 (UTC) Authentication-Results: imf26.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=kLlb3tDt; spf=pass (imf26.hostedemail.com: domain of broonie@kernel.org designates 145.40.73.55 as permitted sender) smtp.mailfrom=broonie@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1724289581; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=Tt3jEodIuAs66QguRVITZfa571ieNZ7SknFiHqdPwNQ=; b=mA7vnSI65/03NFXZdZ1iCxkMbdhVppAXma4v64NaqC2PaKiOnCp5jD15wcvZa7S2jkYDbd 0LSR3LiOKnOqAkUwiNuLHCZApYneiudRPsBVA8OyWwF0CbmLtYUcNgDMbi7T1SQdmwAxTp j9sGSsMfD/dNZ1lVrZCL6eRs9w8ZOJY= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1724289581; a=rsa-sha256; cv=none; b=1wQis+vB/AlU8jf9uTTBJd3JPUU2W2Orfl+q+IUM6LFJgQuabn3b3aHMNTK+CLfapODZ71 QAsjvTRaKhUO2mEfzr/GK+dsS1DMEgVYYSDI23BTPcuL6S40ovlnZJf19jyi9iEO13blls h4vIJppv5ghXB9ViMeDsRrXOZ2h3F4A= ARC-Authentication-Results: i=1; imf26.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=kLlb3tDt; spf=pass (imf26.hostedemail.com: domain of broonie@kernel.org designates 145.40.73.55 as permitted sender) smtp.mailfrom=broonie@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sin.source.kernel.org (Postfix) with ESMTP id 4F57FCE0B61; Thu, 22 Aug 2024 01:20:58 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 409F2C4AF11; Thu, 22 Aug 2024 01:20:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1724289657; bh=Bo/Tuy38edFM69UNKGI4QycprcPw3RCFToNOT50DNNg=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=kLlb3tDtbpxhwIym9y36033hDygsfzrbG2d+bcdRG8eQgXJ+MYCGaTQIwRquAKVJA kJKEn9f0YmjbhCOIrpPJsTwwsW5ZQPt5W6S+R381SSZkhgi0DTbQjA4oj18xsS8wh0 GC6vzXkfzZd1d8CaCmOriLK7sJgLYLlNnhI9BP1sc1SBXnI6P3ynXLz2W0ZNyHCQJ2 qSFTa8yQIWJAnMAkFrZblZCYSTIgL3K868YqLQT6+9HzuJ3sHZjH7UZFbg1ixV04az 7ZybYS9eiL5fSFmUYBvft/JrQlrZS5m5jfFHUDOQVrsLrFfpXV1byIVA5piB4cxhjc 4BcZFCDtTARwA== From: Mark Brown Date: Thu, 22 Aug 2024 02:15:27 +0100 Subject: [PATCH v11 24/39] arm64/signal: Set up and restore the GCS context for signal handlers MIME-Version: 1.0 Message-Id: <20240822-arm64-gcs-v11-24-41b81947ecb5@kernel.org> References: <20240822-arm64-gcs-v11-0-41b81947ecb5@kernel.org> In-Reply-To: <20240822-arm64-gcs-v11-0-41b81947ecb5@kernel.org> To: Catalin Marinas , Will Deacon , Jonathan Corbet , Andrew Morton , Marc Zyngier , Oliver Upton , James Morse , Suzuki K Poulose , Arnd Bergmann , Oleg Nesterov , Eric Biederman , Shuah Khan , "Rick P. Edgecombe" , Deepak Gupta , Ard Biesheuvel , Szabolcs Nagy , Kees Cook Cc: "H.J. Lu" , Paul Walmsley , Palmer Dabbelt , Albert Ou , Florian Weimer , Christian Brauner , Thiago Jung Bauermann , Ross Burton , Yury Khrustalev , Wilco Dijkstra , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, kvmarm@lists.linux.dev, linux-fsdevel@vger.kernel.org, linux-arch@vger.kernel.org, linux-mm@kvack.org, linux-kselftest@vger.kernel.org, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, Mark Brown X-Mailer: b4 0.15-dev-37811 X-Developer-Signature: v=1; a=openpgp-sha256; l=6767; i=broonie@kernel.org; h=from:subject:message-id; bh=Bo/Tuy38edFM69UNKGI4QycprcPw3RCFToNOT50DNNg=; b=owEBbQGS/pANAwAKASTWi3JdVIfQAcsmYgBmxpE2y+bur/yTlT1ckBEJCoMsz8VdX9n6F8AmKIM7 ORbXHsmJATMEAAEKAB0WIQSt5miqZ1cYtZ/in+ok1otyXVSH0AUCZsaRNgAKCRAk1otyXVSH0CdlB/ 0fcLeh2rovj/XHFI8pXMOsE5NjJuHgPFiqmv0M0mBKI16LRd/uj0iQ9Fd09/Ij2Xn7Z7JOhKWJo/Hf qrT5Exg9cNu5A6rzbm9BF6cSUJEvrKOTUYFlkhgdoFRs71uuxlPzXjkhLHUc9IdGd34oy681LRWr4F aHXk+shxBUsFcIvh2f1TL+6ZaiqIdyo1lVb2HszgvbAr8caE8tN02dD+VayEp6sCfONW/jVv6EcYNL l3RXUFCC0rtz6RwdqE1cQLL3E20Fqwj3+DK2j05zbBerTywqdT3Bn5S60MWIXKSGYb6GEcDYkrPRbu Y0xV2o4dzkjazRyxVKtOiggbA0Rx9m X-Developer-Key: i=broonie@kernel.org; a=openpgp; fpr=3F2568AAC26998F9E813A1C5C3F436CA30F5D8EB X-Stat-Signature: x3974cyfis7j93qgfa96b8ypcyam9ezz X-Rspamd-Queue-Id: 4D89A140008 X-Rspam-User: X-Rspamd-Server: rspam08 X-HE-Tag: 1724289660-207919 X-HE-Meta: U2FsdGVkX19n1SaavCSVzYD1kJgd0s/URgfOd1b1f3i7t9+g69f876wLnlgsmvNIi7MFG+ALPZPmbeE7tvDOAZvnG2kTAQ8TYRggSlw7P0MSk7ioc5obPHQ5hageV5bIRsMctUVzxhWrs6jNQuzFV11DuiLoCdBWqfQjx1xxRoIs7JYUYG1vdzTkuOUmZb8BokizhNesWXE89SnO/8LDg76GSS9DJuuA4z9JGh+pNzQHqgctQJ3r1jGqaPCyM2UcbR++2rfpLnGpNwB45c+h8v3s4cdTAzFqGQm1PVCYilOyoLogd4R6yAV98xgbMBpadU4kDfOm7TWFM8FntlwmRn1oACfAHrbGYlOQU7jU2RwBB4q/PCZviLIeluB2SujOi7g9K31aAZZ7yuIKNyNKn5rdYYGXos+V/g0gLnKiWs13bz9LHtW4DPE+3YO8DNRpC/aKcT2eumpYs0geP8FZ79M9RrG2XuJrMURJo9o6xKizMciCL7SgkEIIMrHxD2LND8Dhe/+RHY687gG8KKhItqY52ib0Eu+gW4l0sqx9N2hIR0kVxLvhc4c87ryOdNjIxpzQeb8NYkdyjlzearQx+iXJlvj3arrTwQrSBieVdbGv7pDwHj4Ljr1TV1zQKfqnHPHJoiaBvp18KGrGGbPHTbm8Ip7QRFfFrB4uKmUH+HJvl5J1L6NRXiYWkkCG7SvseWSb0R2z3LHao+Bz8LaA4KQ1UJRXUrkGrpc6gGu1ZIZ12yQ2/AU2mfz5ObhWq1XD2A47YynUfPKn3JaK1zSfLW9T83q4WZzm9ZtGpABAm2TqtKudujgL+YHqVA8VM1AvMAyeeqzaH6gvVfF+Q5ez009wnpwGJq6Vw2etpUDDSyiU6ja6RUTuFbHja4Es6++RolIYsPrH5Jm7fehTdSpPGxN0bbmiiyaq6fD9klWjAF+UniA7zFp9us1XgaFz/IsqoUUIX8NTuJDnfAC054H 65YCOP+E 9d+4zKsL/aFHafhDYAQe2Dw0hSP+Vyd0+MP0atpNrjnCLc3wfvhxemEJ1A5X6wbI/mDhq6p+C5UQ02sVawPTvUg5fUI7nbAC7rkvFv88SSUHnoX6i1gHxaIH+85u07D8lq0y55jJ0Ytjbgr5I2iD76yIkTr/ibizmYt+SsFCVS5mEWl8DX2VEPa2W1rStDJBFIYLEJZdqTDp5+8fhrKUackH8Uq43WV1Tb3qHQVu57V19zVGJaXciyFoNwZBDOdbTBSeVPhBPizO9b0eP3WPBxR5VAD9qKCB9dU0gS78HYlYEnQL88PCqA7e6jj4oO6YqFkFfap/uppEjWqcfqol1NqyDyijXcCSGDYazaLVtMPepODojRiMVTNB2aYzmdPa0o7kygxw0fxoqbZY= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: When invoking a signal handler we use the GCS configuration and stack for the current thread. Since we implement signal return by calling the signal handler with a return address set up pointing to a trampoline in the vDSO we need to also configure any active GCS for this by pushing a frame for the trampoline onto the GCS. If we do not do this then signal return will generate a GCS protection fault. In order to guard against attempts to bypass GCS protections via signal return we only allow returning with GCSPR_EL0 pointing to an address where it was previously preempted by a signal. We do this by pushing a cap onto the GCS, this takes the form of an architectural GCS cap token with the top bit set and token type of 0 which we add on signal entry and validate and pop off on signal return. The combination of the top bit being set and the token type mean that this can't be interpreted as a valid token or address. Reviewed-by: Thiago Jung Bauermann Signed-off-by: Mark Brown Reviewed-by: Catalin Marinas --- arch/arm64/include/asm/gcs.h | 1 + arch/arm64/kernel/signal.c | 112 +++++++++++++++++++++++++++++++++++++++++-- arch/arm64/mm/gcs.c | 1 + 3 files changed, 109 insertions(+), 5 deletions(-) diff --git a/arch/arm64/include/asm/gcs.h b/arch/arm64/include/asm/gcs.h index 48c97e63e56a..f50660603ecf 100644 --- a/arch/arm64/include/asm/gcs.h +++ b/arch/arm64/include/asm/gcs.h @@ -9,6 +9,7 @@ #include struct kernel_clone_args; +struct ksignal; static inline void gcsb_dsync(void) { diff --git a/arch/arm64/kernel/signal.c b/arch/arm64/kernel/signal.c index 4a77f4976e11..b54d684c4bf8 100644 --- a/arch/arm64/kernel/signal.c +++ b/arch/arm64/kernel/signal.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -34,6 +35,15 @@ #include #include +#ifdef CONFIG_ARM64_GCS +#define GCS_SIGNAL_CAP(addr) (((unsigned long)addr) & GCS_CAP_ADDR_MASK) + +static bool gcs_signal_cap_valid(u64 addr, u64 val) +{ + return val == GCS_SIGNAL_CAP(addr); +} +#endif + /* * Do a signal return; undo the signal stack. These are aligned to 128-bit. */ @@ -860,6 +870,50 @@ static int restore_sigframe(struct pt_regs *regs, return err; } +#ifdef CONFIG_ARM64_GCS +static int gcs_restore_signal(void) +{ + u64 gcspr_el0, cap; + int ret; + + if (!system_supports_gcs()) + return 0; + + if (!(current->thread.gcs_el0_mode & PR_SHADOW_STACK_ENABLE)) + return 0; + + gcspr_el0 = read_sysreg_s(SYS_GCSPR_EL0); + + /* + * GCSPR_EL0 should be pointing at a capped GCS, read the cap... + */ + gcsb_dsync(); + ret = copy_from_user(&cap, (__user void*)gcspr_el0, sizeof(cap)); + if (ret) + return -EFAULT; + + /* + * ...then check that the cap is the actual GCS before + * restoring it. + */ + if (!gcs_signal_cap_valid(gcspr_el0, cap)) + return -EINVAL; + + /* Invalidate the token to prevent reuse */ + put_user_gcs(0, (__user void*)gcspr_el0, &ret); + if (ret != 0) + return -EFAULT; + + current->thread.gcspr_el0 = gcspr_el0 + sizeof(cap); + write_sysreg_s(current->thread.gcspr_el0, SYS_GCSPR_EL0); + + return 0; +} + +#else +static int gcs_restore_signal(void) { return 0; } +#endif + SYSCALL_DEFINE0(rt_sigreturn) { struct pt_regs *regs = current_pt_regs(); @@ -886,6 +940,9 @@ SYSCALL_DEFINE0(rt_sigreturn) if (restore_altstack(&frame->uc.uc_stack)) goto badframe; + if (gcs_restore_signal()) + goto badframe; + return regs->regs[0]; badframe: @@ -1130,7 +1187,50 @@ static int get_sigframe(struct rt_sigframe_user_layout *user, return 0; } -static void setup_return(struct pt_regs *regs, struct k_sigaction *ka, +#ifdef CONFIG_ARM64_GCS + +static int gcs_signal_entry(__sigrestore_t sigtramp, struct ksignal *ksig) +{ + unsigned long __user *gcspr_el0; + int ret = 0; + + if (!system_supports_gcs()) + return 0; + + if (!task_gcs_el0_enabled(current)) + return 0; + + /* + * We are entering a signal handler, current register state is + * active. + */ + gcspr_el0 = (unsigned long __user *)read_sysreg_s(SYS_GCSPR_EL0); + + /* + * Push a cap and the GCS entry for the trampoline onto the GCS. + */ + put_user_gcs((unsigned long)sigtramp, gcspr_el0 - 2, &ret); + put_user_gcs(GCS_SIGNAL_CAP(gcspr_el0 - 1), gcspr_el0 - 1, &ret); + if (ret != 0) + return ret; + + gcsb_dsync(); + + gcspr_el0 -= 2; + write_sysreg_s((unsigned long)gcspr_el0, SYS_GCSPR_EL0); + + return 0; +} +#else + +static int gcs_signal_entry(__sigrestore_t sigtramp, struct ksignal *ksig) +{ + return 0; +} + +#endif + +static int setup_return(struct pt_regs *regs, struct ksignal *ksig, struct rt_sigframe_user_layout *user, int usig) { __sigrestore_t sigtramp; @@ -1138,7 +1238,7 @@ static void setup_return(struct pt_regs *regs, struct k_sigaction *ka, regs->regs[0] = usig; regs->sp = (unsigned long)user->sigframe; regs->regs[29] = (unsigned long)&user->next_frame->fp; - regs->pc = (unsigned long)ka->sa.sa_handler; + regs->pc = (unsigned long)ksig->ka.sa.sa_handler; /* * Signal delivery is a (wacky) indirect function call in @@ -1178,12 +1278,14 @@ static void setup_return(struct pt_regs *regs, struct k_sigaction *ka, sme_smstop(); } - if (ka->sa.sa_flags & SA_RESTORER) - sigtramp = ka->sa.sa_restorer; + if (ksig->ka.sa.sa_flags & SA_RESTORER) + sigtramp = ksig->ka.sa.sa_restorer; else sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp); regs->regs[30] = (unsigned long)sigtramp; + + return gcs_signal_entry(sigtramp, ksig); } static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set, @@ -1206,7 +1308,7 @@ static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set, err |= __save_altstack(&frame->uc.uc_stack, regs->sp); err |= setup_sigframe(&user, regs, set); if (err == 0) { - setup_return(regs, &ksig->ka, &user, usig); + err = setup_return(regs, ksig, &user, usig); if (ksig->ka.sa.sa_flags & SA_SIGINFO) { err |= copy_siginfo_to_user(&frame->info, &ksig->info); regs->regs[1] = (unsigned long)&frame->info; diff --git a/arch/arm64/mm/gcs.c b/arch/arm64/mm/gcs.c index d9614900c910..3e3218fb3c58 100644 --- a/arch/arm64/mm/gcs.c +++ b/arch/arm64/mm/gcs.c @@ -7,6 +7,7 @@ #include #include +#include #include static unsigned long alloc_gcs(unsigned long addr, unsigned long size)