From patchwork Sat Feb 3 12:25:47 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Brown X-Patchwork-Id: 13544146 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 2BE4AC4828D for ; Sat, 3 Feb 2024 12:32:11 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id B3E3A6B00A9; Sat, 3 Feb 2024 07:32:10 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id AEE046B00AB; Sat, 3 Feb 2024 07:32:10 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 98EC56B00AC; Sat, 3 Feb 2024 07:32:10 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id 868CD6B00A9 for ; Sat, 3 Feb 2024 07:32:10 -0500 (EST) Received: from smtpin27.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id 1A9DBC0234 for ; Sat, 3 Feb 2024 12:32:10 +0000 (UTC) X-FDA: 81750430020.27.18199F0 Received: from sin.source.kernel.org (sin.source.kernel.org [145.40.73.55]) by imf29.hostedemail.com (Postfix) with ESMTP id B1EDD12001A for ; Sat, 3 Feb 2024 12:32:07 +0000 (UTC) Authentication-Results: imf29.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="tpLHddu/"; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf29.hostedemail.com: domain of broonie@kernel.org designates 145.40.73.55 as permitted sender) smtp.mailfrom=broonie@kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1706963528; a=rsa-sha256; cv=none; b=o1kYHRSlYbhXHd71F79lbp9eMtl+8TmjFqs8Eemuny7wUbsifwFjpFUcEkXW3EkDCbXYug YQPvJA2ckSagJ8hT3qbLhz3YAvBRsXqLcDZpKDBy0OA7qjY6E+/TKPEpiNGBEcybqS0xsc MzDkXcdl7ycQrCk2HtPBqrhAiHAgNCY= ARC-Authentication-Results: i=1; imf29.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b="tpLHddu/"; dmarc=pass (policy=none) header.from=kernel.org; spf=pass (imf29.hostedemail.com: domain of broonie@kernel.org designates 145.40.73.55 as permitted sender) smtp.mailfrom=broonie@kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1706963528; 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=DZAtClSt5On26RiBpNVNpcBpDsxqlxp8QFws3BPx8IA=; b=N+7za5jaNXUFvjXqpmoByf4XNso35DcWHCH+Sd9/6pAP/C3JSWeR7DHj6sNplFD+ustmpd wscEfnMo2wv9xn09EGaC/8o2U9v93cRRSKTYkTEAWqaLw9RQmRNu9W8wzV3qK0imW3p8/9 px4za6/8GJMGon2Ut8kP7ZnJ/gdmpvY= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sin.source.kernel.org (Postfix) with ESMTP id CCA80CE1F18; Sat, 3 Feb 2024 12:32:04 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 03BD9C43390; Sat, 3 Feb 2024 12:31:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1706963523; bh=U5MciaTL0rYvjCIumqURacdaryA/1hlaB10gSNsfShY=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=tpLHddu/3s6KK5wnT5rQj+Pd5a6ev93vYGZXSRAuAXzWXWvjis8vox9rbuowcCRjO xNH5+6JIOg3XVeikkfgANT2/AIC6wQmgutrXNk4SqzasRQRra0bdiRnpRY387wk4ux 3j3nDdZx2cYT02NiWyK8VDqCodWSHShr6OifHn3PybyqlRGEK3RJfc+J7VZvqBW1ne s3WdrV7DXIedRn80l8EgeUmC45bwLOZvXfwVd532i6BBs18Sa+uRn/Fkt0NlFuKDXl yYQl6LIG2ahA4jC8un1pCKHqP03Dz1q8+V8R2a7KBLF4PJYAR1GMIHWQ9n24mAzWKl drauPDYDOk63g== From: Mark Brown Date: Sat, 03 Feb 2024 12:25:47 +0000 Subject: [PATCH v8 21/38] arm64/gcs: Implement shadow stack prctl() interface MIME-Version: 1.0 Message-Id: <20240203-arm64-gcs-v8-21-c9fec77673ef@kernel.org> References: <20240203-arm64-gcs-v8-0-c9fec77673ef@kernel.org> In-Reply-To: <20240203-arm64-gcs-v8-0-c9fec77673ef@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 , Kees Cook , Shuah Khan , "Rick P. Edgecombe" , Deepak Gupta , Ard Biesheuvel , Szabolcs Nagy Cc: "H.J. Lu" , Paul Walmsley , Palmer Dabbelt , Albert Ou , Florian Weimer , Christian Brauner , Thiago Jung Bauermann , 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.13-dev-a684c X-Developer-Signature: v=1; a=openpgp-sha256; l=5675; i=broonie@kernel.org; h=from:subject:message-id; bh=U5MciaTL0rYvjCIumqURacdaryA/1hlaB10gSNsfShY=; b=owEBbQGS/pANAwAKASTWi3JdVIfQAcsmYgBlvjDhXvrqcGZBd+9/+gfWtioOkspbIVIuapYQkeO4 2Ek4A8+JATMEAAEKAB0WIQSt5miqZ1cYtZ/in+ok1otyXVSH0AUCZb4w4QAKCRAk1otyXVSH0JuzB/ 9Nsil/CkJIgThqvkV7vl+7SUj4tch4kYdrDe1K2VdYijvUW+AeVboEr8gnTvdiOIJwutNGG9JEkV9f KPDIwaRpAUfybv1h5fN6qSvwUClufBTP7FbMRgd2OJfecw5g2ieJgg0q1Ob6AkjLBOa+2tBUxuEMIN xeB/8dMvhw3u/XTn22XIxZSc/sgH18/tKXF+QgsY4Yf+QOw6qVQ8hzeRSmLGb7Yng2SD6ncWl2Ex79 LHwZ2eJofY3G+embhTZ16cXU3FdVF8SkhnAi7FiuJ8JsXPj+X6vANHdevGcvILeiZXc1IflJ7meoyc J74wfqlKIe7HuZQPvCxTshDzN9l0wn X-Developer-Key: i=broonie@kernel.org; a=openpgp; fpr=3F2568AAC26998F9E813A1C5C3F436CA30F5D8EB X-Rspam-User: X-Rspamd-Server: rspam06 X-Rspamd-Queue-Id: B1EDD12001A X-Stat-Signature: 9km9uz1mpf6n5u6nq3icr3ndopi33jw4 X-HE-Tag: 1706963527-973954 X-HE-Meta: U2FsdGVkX18ce2iPRXw9Xv9YsMbE/ovq4fc4LjMQ+vOBp8Q/4M5/0FCSIUa2ZK1tZcy//Ynyif2Di+PRtlJ20nMfg+Jryv/vdnfU9eBdyny5zEtF0t2Rji4t9I+lgOSpUJGu9s36hOViW8O7m0W7NcWRQqupz2SnAKg/0yEmyuHlS6tta0buDOiHh1ECyzNj/KJXtdgR9ip3kQHb98cYjnmvbWM1gt/PfX8K7B+F9+GYM44Sk/5YVocss9d9HaPlvYcfnQW+cvh5Ce5xKmPwy4r8PZsd4Y/9+H5pI2i6oiqDaM2y0H9ltFvyrWANxFe531i4gUMAmj5cwW9aowyAmAAyCeeur716hKQg7KI/5GrE418ehfO/DFEYXuXNEBYTxwkvNa4NHDqKR5xS1hm9ulCcJ6nsiQL78MMjGJW02+HIYNP7xl9dWbv/HEQT1Q9HiCE32ln3sc6hCe6y6PWntTfh0YkYp7slGCjXQOtxdb+bj84MIpdcEqV/5e8wpfC6UqudcrBT6/MKZz6aFEksPYSMUEuGc9Fy31O4zo2dM2ktva1+QA7/lMYpgUGfOfctEnYJE3LW/fEFx7k/3OSV6KhDqXmRHAKIKlw1sSs7V+OBtRVq5uuVMfh2q91uVhWFKRAg2DNE1hQq/VzLQKUGmeRhd3JadNeD3Bn8Bp2osT8ELYXWKlO3GEGlKxqfy9wUxRP2sZKMfVPmY4wGwI6RKT8LmRcsuCxN2YqZJuhIXPtxCDZxZ8GIcsjBCI4y7cgLOGLYaHrIVwur35YIC7yr2iZC+sOBHxoRfeSpTUW/qQkdpDBvu+JiTQbrk5yw9oIwl5ahJnMbp0DA/hx+XsoNHomHpPZmgRoUK6CnTaWKLQZqWqgLT9Sim2q52pDtkDr1Js1pN/78VgEk5s1RO4v4iFgegPDJKntFQgWb6h+gCd8hR4cnf4S16E1snAv1MEdBJoYRZ5UX8whrSlTkTrO pZMcLINb +WiVBMkpji7y3iHh7Yo/vXncO2cf2Dm5bIdy1HjrepJoEezMJ5PrQNuGf7JknM1lpQPre1/zuWECoM50IoDFYEt/MGZevpWwaDV9YCflBTZcK1QhIQGy46ZA/oP6+XZQJLkbhpZrwpu4KD4OFYG5dQH/j6J+nvzHy1hkTuMPIKn+TcqDDF0Q0QpjtfTQcj5xuMkEz2JIjxzhbsU6JmzNlnOL6HAeV/+vTOxwC1eoTzrze2qnQqJI5qf/DK3n5022wU5wsRqp80BOQakLbip5B4d+ek+MUK4UrAdZraAh2VVFDv+d7IKXL0cQrsI9ciCRYetO7 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: Implement the architecture neutral prtctl() interface for setting the shadow stack status, this supports setting and reading the current GCS configuration for the current thread. Userspace can enable basic GCS functionality and additionally also support for GCS pushes and arbitrary GCS stores. It is expected that this prctl() will be called very early in application startup, for example by the dynamic linker, and not subsequently adjusted during normal operation. Users should carefully note that after enabling GCS for a thread GCS will become active with no call stack so it is not normally possible to return from the function that invoked the prctl(). State is stored per thread, enabling GCS for a thread causes a GCS to be allocated for that thread. Userspace may lock the current GCS configuration by specifying PR_SHADOW_STACK_ENABLE_LOCK, this prevents any further changes to the GCS configuration via any means. If GCS is not being enabled then all flags other than _LOCK are ignored, it is not possible to enable stores or pops without enabling GCS. When disabling the GCS we do not free the allocated stack, this allows for inspection of the GCS after disabling as part of fault reporting. Since it is not an expected use case and since it presents some complications in determining what to do with previously initialsed data on the GCS attempts to reenable GCS after this are rejected. This can be revisted if a use case arises. Signed-off-by: Mark Brown --- arch/arm64/include/asm/gcs.h | 22 ++++++++++ arch/arm64/include/asm/processor.h | 1 + arch/arm64/mm/gcs.c | 82 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+) diff --git a/arch/arm64/include/asm/gcs.h b/arch/arm64/include/asm/gcs.h index c1f274fdb9c0..48c97e63e56a 100644 --- a/arch/arm64/include/asm/gcs.h +++ b/arch/arm64/include/asm/gcs.h @@ -50,6 +50,9 @@ static inline u64 gcsss2(void) return Xt; } +#define PR_SHADOW_STACK_SUPPORTED_STATUS_MASK \ + (PR_SHADOW_STACK_ENABLE | PR_SHADOW_STACK_WRITE | PR_SHADOW_STACK_PUSH) + #ifdef CONFIG_ARM64_GCS static inline bool task_gcs_el0_enabled(struct task_struct *task) @@ -63,6 +66,20 @@ void gcs_preserve_current_state(void); unsigned long gcs_alloc_thread_stack(struct task_struct *tsk, const struct kernel_clone_args *args); +static inline int gcs_check_locked(struct task_struct *task, + unsigned long new_val) +{ + unsigned long cur_val = task->thread.gcs_el0_mode; + + cur_val &= task->thread.gcs_el0_locked; + new_val &= task->thread.gcs_el0_locked; + + if (cur_val != new_val) + return -EBUSY; + + return 0; +} + #else static inline bool task_gcs_el0_enabled(struct task_struct *task) @@ -78,6 +95,11 @@ static inline unsigned long gcs_alloc_thread_stack(struct task_struct *tsk, { return -ENOTSUPP; } +static inline int gcs_check_locked(struct task_struct *task, + unsigned long new_val) +{ + return 0; +} #endif diff --git a/arch/arm64/include/asm/processor.h b/arch/arm64/include/asm/processor.h index 6fc6dcbd494c..6a3091ec0f03 100644 --- a/arch/arm64/include/asm/processor.h +++ b/arch/arm64/include/asm/processor.h @@ -184,6 +184,7 @@ struct thread_struct { u64 tpidr2_el0; #ifdef CONFIG_ARM64_GCS unsigned int gcs_el0_mode; + unsigned int gcs_el0_locked; u64 gcspr_el0; u64 gcs_base; u64 gcs_size; diff --git a/arch/arm64/mm/gcs.c b/arch/arm64/mm/gcs.c index 3cbc3a3d4bc7..95f5cf599bc6 100644 --- a/arch/arm64/mm/gcs.c +++ b/arch/arm64/mm/gcs.c @@ -154,3 +154,85 @@ void gcs_free(struct task_struct *task) task->thread.gcs_base = 0; task->thread.gcs_size = 0; } + +int arch_set_shadow_stack_status(struct task_struct *task, unsigned long arg) +{ + unsigned long gcs, size; + int ret; + + if (!system_supports_gcs()) + return -EINVAL; + + if (is_compat_thread(task_thread_info(task))) + return -EINVAL; + + /* Reject unknown flags */ + if (arg & ~PR_SHADOW_STACK_SUPPORTED_STATUS_MASK) + return -EINVAL; + + ret = gcs_check_locked(task, arg); + if (ret != 0) + return ret; + + /* If we are enabling GCS then make sure we have a stack */ + if (arg & PR_SHADOW_STACK_ENABLE) { + if (!task_gcs_el0_enabled(task)) { + /* Do not allow GCS to be reenabled */ + if (task->thread.gcs_base) + return -EINVAL; + + if (task != current) + return -EBUSY; + + size = gcs_size(0); + gcs = alloc_gcs(task->thread.gcspr_el0, size, + 0, 0); + if (!gcs) + return -ENOMEM; + + task->thread.gcspr_el0 = gcs + size - sizeof(u64); + task->thread.gcs_base = gcs; + task->thread.gcs_size = size; + if (task == current) + write_sysreg_s(task->thread.gcspr_el0, + SYS_GCSPR_EL0); + + } + } + + task->thread.gcs_el0_mode = arg; + if (task == current) + gcs_set_el0_mode(task); + + return 0; +} + +int arch_get_shadow_stack_status(struct task_struct *task, + unsigned long __user *arg) +{ + if (!system_supports_gcs()) + return -EINVAL; + + if (is_compat_thread(task_thread_info(task))) + return -EINVAL; + + return put_user(task->thread.gcs_el0_mode, arg); +} + +int arch_lock_shadow_stack_status(struct task_struct *task, + unsigned long arg) +{ + if (!system_supports_gcs()) + return -EINVAL; + + if (is_compat_thread(task_thread_info(task))) + return -EINVAL; + + /* + * We support locking unknown bits so applications can prevent + * any changes in a future proof manner. + */ + task->thread.gcs_el0_locked |= arg; + + return 0; +}