From patchwork Wed Aug 28 23:27:41 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Brown X-Patchwork-Id: 13782187 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 87BAFC7114C for ; Wed, 28 Aug 2024 23:31:43 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 198336B00C1; Wed, 28 Aug 2024 19:31:43 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 148186B00C2; Wed, 28 Aug 2024 19:31:42 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id D09C76B00C3; Wed, 28 Aug 2024 19:31:42 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id B151B6B00C1 for ; Wed, 28 Aug 2024 19:31:42 -0400 (EDT) Received: from smtpin13.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay09.hostedemail.com (Postfix) with ESMTP id 6F7E3803C9 for ; Wed, 28 Aug 2024 23:31:42 +0000 (UTC) X-FDA: 82503253644.13.AA06126 Received: from sin.source.kernel.org (sin.source.kernel.org [145.40.73.55]) by imf23.hostedemail.com (Postfix) with ESMTP id 156C1140003 for ; Wed, 28 Aug 2024 23:31:39 +0000 (UTC) Authentication-Results: imf23.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=mU25rA27; spf=pass (imf23.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=1724887813; 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=1qWyhHAuZcYS0iDTBs3zX5RdOM6oeW6S5H55HeP26vQ=; b=K93kBwCWPNR0m1Y66s2ler5YmigYvNp9NL8QmtglB61g+0RLvfKZwt2FIyqYoROu1zmGUv B998OU0brUJwcRENzLO5Jj0HruDgCXZZtp/yCfpsbiVS9Xebc3ueBn2eZDWC+iSwCf6+Jq qiI7HYB8Z9Q9xP6Vp6U60JTF8SJJBlM= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1724887813; a=rsa-sha256; cv=none; b=zdFM+iA0G4iM3dbkBJ35Ur2tdU0m+/sIf2lv7uJd0UZPBL7rRcBlWezP65GweBN7cfNNw2 EMvJbiwqrfZ3GyQCdhuSJ8i2Qgd49+y9DiSvpATjKMbwdpxDmVajRdmI8yaoSW4UHyXonT 3f1qM0/ZF8s2Of+cs/xL+pR3S0xDce0= ARC-Authentication-Results: i=1; imf23.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=mU25rA27; spf=pass (imf23.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 6900ECE19B8; Wed, 28 Aug 2024 23:31:37 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id CFA72C4CEC6; Wed, 28 Aug 2024 23:31:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1724887896; bh=73C3smpBK+UnDqakFPuhaJzLufKqaiexCIFYr/fa1x0=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=mU25rA27yjAUF5W16xtWcEV6nAyCAajNvImZSqLFWynmrWqAxF0lu2GrxyKbXz+Jb VNNi7LOgmLnAB08yS3PLQ46AhOnNHx9dWmVGkAzj8adagkORLMrnhVjzFd5/yELW3x uqhzDZw0JSPrx0OeziFzdT/PwmXxmLzsmLtVfX8Yian4Y8LfwY/cnUJS5fHTo85kPk YlBLcqXZsGsPrSYVv7++Ll2cwTpXz5ZaUS2FIELm0BShIt7+TDSZuZ5ktWTxI8baRD 7+n/xwagW9tCHLj7hYz6naaxc0Lx7vHyrQve1MPX0JeNQQQs84m60x5k9nkg+/fb2x 5zie35lHjz+Zg== From: Mark Brown Date: Thu, 29 Aug 2024 00:27:41 +0100 Subject: [PATCH v12 25/39] arm64/signal: Expose GCS state in signal frames MIME-Version: 1.0 Message-Id: <20240829-arm64-gcs-v12-25-42fec947436a@kernel.org> References: <20240829-arm64-gcs-v12-0-42fec947436a@kernel.org> In-Reply-To: <20240829-arm64-gcs-v12-0-42fec947436a@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=6128; i=broonie@kernel.org; h=from:subject:message-id; bh=73C3smpBK+UnDqakFPuhaJzLufKqaiexCIFYr/fa1x0=; b=owEBbQGS/pANAwAKASTWi3JdVIfQAcsmYgBmz7KMtztuBk31zqZisL+pxTd1y9CxV6vFGkXr1zkr QLSfPm2JATMEAAEKAB0WIQSt5miqZ1cYtZ/in+ok1otyXVSH0AUCZs+yjAAKCRAk1otyXVSH0MPJB/ 9wLDGvs2zJBV6dYauqi3g2Kp0xDAFNgnGNlcMrp8JZIxION7DrvKdDFAwWyG/WNvmTtHTd97lTBOcp dzi0E5TyMfZKY6bogTnXfadhUgoehzIRtu9OTeRmGeiHf29qFns6JtmeIHPlezvOE8owkiPlmBDapD 7tRHMok169p4iNbYVuVyMM/i2JSTIVm+Sb52QH6/0hDJW5DbGjXMTINncdkO1Q53IFDeI7x7o/X04K 5jAsDnlNMzXf/cP0axq6Mlx4LcIYh5RKxoy9HERGlDD996QwoEVeQ9nZJ6ZIibVleUMSgLHfzNhgA4 wm+Ma44vBnN+MCRXHAgtoEH/yMVG5H X-Developer-Key: i=broonie@kernel.org; a=openpgp; fpr=3F2568AAC26998F9E813A1C5C3F436CA30F5D8EB X-Rspamd-Queue-Id: 156C1140003 X-Stat-Signature: tj585z8i58cycxhhefjhoampnh4jnfa5 X-Rspamd-Server: rspam09 X-Rspam-User: X-HE-Tag: 1724887899-155957 X-HE-Meta: U2FsdGVkX18mzb/jGe7qDdDAeFetU+MZgzSCkF1MRMoIbAkB2voWCtoVm1Hi7mtwYm4ym0hs7sTjjs+jG4uSkdXM1MucMc0hSb3A1/OK2u64xv/qXHe0oYX5cwzW3RBp9SEg+Mk/MfhLAv9R3PCo+OGHVSFpTocYbIsV9LLunSeHDlTuqcqEJ3JXSwibmoSKzgG8r0t4Up2K8R4+gzLe+Nhu0zbrz97p/6mrqdkq41I65sTJdBD5d9qbJw46dnacfCp5YPne02y9XiDIXKvpeRZMYtZikIKdipb1v60hTQpGj1f0tE1RYQGB5V9xSExcEtrfROjBmkGXjU1FLi/8Nn+RxaXkyL0eE7JJntRRiznHV97VkYrRbnaaLxEx8BwBO5VAGvNY39OpY2GEVX8nmNeGL+YGiJZZZHMSayrxmyrUAvB/xoPsUpMPwMDPCWKwxSgDmWAG+0+ZYsyfU+SPRIj/Td/F2feyvFCbSRzLdDdHmi8jIyqzFuhfqtxFmZ5FDTJxVarjuFFuQXKciBLrg5ab6W631S3OAE3nBKQak3WXnTp7lIIGK3ZJqzhZpxeLoub1lLTLaOL3DFnI13vCOpryngEVp1TeDfGD5hah6ONieJPAyRspQB2iU2UO2wCnTkNvD7ZCJc/R22q8sTPQJKSvr+rX0BBQxErmEb3FjeQfoZt85LWQpyhxi5xPXLsdtwQrGzrSh7c5MSfmsiqGms8NOyeVuzwXbQJ4pELiV2m/WuMSR4FnyKaB90aZw7MdQTjxq7/OfsJh6A6Tg5YNXvx9aNK5fQQSQYsKMc1VdgA5xVBijfUgOGJi4r3ObagIvS9RpDVPhXu1act0i9pJljccq1FesPuXoHrS1puJhrnjR7XHkdrwsSwyJ+z2zLP9QSJj6vfYHSxYS/596HPP2HFOIWC7UQ5GmkjbUi0CmG1iii8/tUhrD+xZg2ny/d9Y1/sdvcxY6N9VVH3hUCn XcCabAYe 4y5mMZXujhsB220ptgZl7RwxDqeld01Il5yStbkQtYwcG5OjKkp6rxvuZkf9D5LpHYJ2QkPyhoXGUHf7i/IS9FYzcUH0RxQ39rMHBOwb7LS/vqs3H7lYdnjUCKcWPqkwXGMcQQwKdam2ynnBr3P6hO4+CNDJCrYPJhI1B1x0RDI3rTap+ip/OWD6xVr8HM46JYS5DSNr3PnnIFU5JGvFjf4XdYcFrnkznGNZs2r2o0fYoCb6h/c1Dhu/Wz3A68jw9ptAyl3I149MzVV7OK6dn52y1frNCF+VERphQDllQ4wEToFeuCbO7cW656VxspFWIX+PHYmngAhP/9BVijLarkgoxjv2gGMZfXi71 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: Add a context for the GCS state and include it in the signal context when running on a system that supports GCS. We reuse the same flags that the prctl() uses to specify which GCS features are enabled and also provide the current GCS pointer. We do not support enabling GCS via signal return, there is a conflict between specifying GCSPR_EL0 and allocation of a new GCS and this is not an ancticipated use case. We also enforce GCS configuration locking on signal return. Signed-off-by: Mark Brown Reviewed-by: Catalin Marinas Acked-by: Yury Khrustalev --- arch/arm64/include/uapi/asm/sigcontext.h | 9 +++ arch/arm64/kernel/signal.c | 109 +++++++++++++++++++++++++++++++ 2 files changed, 118 insertions(+) diff --git a/arch/arm64/include/uapi/asm/sigcontext.h b/arch/arm64/include/uapi/asm/sigcontext.h index 8a45b7a411e0..c2d61e8efc84 100644 --- a/arch/arm64/include/uapi/asm/sigcontext.h +++ b/arch/arm64/include/uapi/asm/sigcontext.h @@ -176,6 +176,15 @@ struct zt_context { __u16 __reserved[3]; }; +#define GCS_MAGIC 0x47435300 + +struct gcs_context { + struct _aarch64_ctx head; + __u64 gcspr; + __u64 features_enabled; + __u64 reserved; +}; + #endif /* !__ASSEMBLY__ */ #include diff --git a/arch/arm64/kernel/signal.c b/arch/arm64/kernel/signal.c index 3f52ce11f791..dd2ed27b8bdd 100644 --- a/arch/arm64/kernel/signal.c +++ b/arch/arm64/kernel/signal.c @@ -66,6 +66,7 @@ struct rt_sigframe_user_layout { unsigned long fpsimd_offset; unsigned long esr_offset; + unsigned long gcs_offset; unsigned long sve_offset; unsigned long tpidr2_offset; unsigned long za_offset; @@ -195,6 +196,8 @@ struct user_ctxs { u32 zt_size; struct fpmr_context __user *fpmr; u32 fpmr_size; + struct gcs_context __user *gcs; + u32 gcs_size; }; static int preserve_fpsimd_context(struct fpsimd_context __user *ctx) @@ -614,6 +617,82 @@ extern int restore_zt_context(struct user_ctxs *user); #endif /* ! CONFIG_ARM64_SME */ +#ifdef CONFIG_ARM64_GCS + +static int preserve_gcs_context(struct gcs_context __user *ctx) +{ + int err = 0; + u64 gcspr = read_sysreg_s(SYS_GCSPR_EL0); + + /* + * If GCS is enabled we will add a cap token to the frame, + * include it in the GCSPR_EL0 we report to support stack + * switching via sigreturn if GCS is enabled. We do not allow + * enabling via sigreturn so the token is only relevant for + * threads with GCS enabled. + */ + if (task_gcs_el0_enabled(current)) + gcspr -= 8; + + __put_user_error(GCS_MAGIC, &ctx->head.magic, err); + __put_user_error(sizeof(*ctx), &ctx->head.size, err); + __put_user_error(gcspr, &ctx->gcspr, err); + __put_user_error(0, &ctx->reserved, err); + __put_user_error(current->thread.gcs_el0_mode, + &ctx->features_enabled, err); + + return err; +} + +static int restore_gcs_context(struct user_ctxs *user) +{ + u64 gcspr, enabled; + int err = 0; + + if (user->gcs_size != sizeof(*user->gcs)) + return -EINVAL; + + __get_user_error(gcspr, &user->gcs->gcspr, err); + __get_user_error(enabled, &user->gcs->features_enabled, err); + if (err) + return err; + + /* Don't allow unknown modes */ + if (enabled & ~PR_SHADOW_STACK_SUPPORTED_STATUS_MASK) + return -EINVAL; + + err = gcs_check_locked(current, enabled); + if (err != 0) + return err; + + /* Don't allow enabling */ + if (!task_gcs_el0_enabled(current) && + (enabled & PR_SHADOW_STACK_ENABLE)) + return -EINVAL; + + /* If we are disabling disable everything */ + if (!(enabled & PR_SHADOW_STACK_ENABLE)) + enabled = 0; + + current->thread.gcs_el0_mode = enabled; + + /* + * We let userspace set GCSPR_EL0 to anything here, we will + * validate later in gcs_restore_signal(). + */ + write_sysreg_s(gcspr, SYS_GCSPR_EL0); + + return 0; +} + +#else /* ! CONFIG_ARM64_GCS */ + +/* Turn any non-optimised out attempts to use these into a link error: */ +extern int preserve_gcs_context(void __user *ctx); +extern int restore_gcs_context(struct user_ctxs *user); + +#endif /* ! CONFIG_ARM64_GCS */ + static int parse_user_sigframe(struct user_ctxs *user, struct rt_sigframe __user *sf) { @@ -631,6 +710,7 @@ static int parse_user_sigframe(struct user_ctxs *user, user->za = NULL; user->zt = NULL; user->fpmr = NULL; + user->gcs = NULL; if (!IS_ALIGNED((unsigned long)base, 16)) goto invalid; @@ -736,6 +816,17 @@ static int parse_user_sigframe(struct user_ctxs *user, user->fpmr_size = size; break; + case GCS_MAGIC: + if (!system_supports_gcs()) + goto invalid; + + if (user->gcs) + goto invalid; + + user->gcs = (struct gcs_context __user *)head; + user->gcs_size = size; + break; + case EXTRA_MAGIC: if (have_extra_context) goto invalid; @@ -855,6 +946,9 @@ static int restore_sigframe(struct pt_regs *regs, err = restore_fpsimd_context(&user); } + if (err == 0 && system_supports_gcs() && user.gcs) + err = restore_gcs_context(&user); + if (err == 0 && system_supports_tpidr2() && user.tpidr2) err = restore_tpidr2_context(&user); @@ -985,6 +1079,15 @@ static int setup_sigframe_layout(struct rt_sigframe_user_layout *user, return err; } +#ifdef CONFIG_ARM64_GCS + if (add_all || current->thread.gcspr_el0) { + err = sigframe_alloc(user, &user->gcs_offset, + sizeof(struct gcs_context)); + if (err) + return err; + } +#endif + if (system_supports_sve() || system_supports_sme()) { unsigned int vq = 0; @@ -1085,6 +1188,12 @@ static int setup_sigframe(struct rt_sigframe_user_layout *user, __put_user_error(current->thread.fault_code, &esr_ctx->esr, err); } + if (system_supports_gcs() && err == 0 && user->gcs_offset) { + struct gcs_context __user *gcs_ctx = + apply_user_offset(user, user->gcs_offset); + err |= preserve_gcs_context(gcs_ctx); + } + /* Scalable Vector Extension state (including streaming), if present */ if ((system_supports_sve() || system_supports_sme()) && err == 0 && user->sve_offset) {