From patchwork Wed Apr 3 23:35:03 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Deepak Gupta X-Patchwork-Id: 13616779 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 5B84BCD128A for ; Wed, 3 Apr 2024 23:42:17 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 4EEE96B00B3; Wed, 3 Apr 2024 19:42:13 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 49E3D6B00B4; Wed, 3 Apr 2024 19:42:13 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 2A4086B00B5; Wed, 3 Apr 2024 19:42:13 -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 007F66B00B3 for ; Wed, 3 Apr 2024 19:42:12 -0400 (EDT) Received: from smtpin05.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id C0A16A0129 for ; Wed, 3 Apr 2024 23:42:12 +0000 (UTC) X-FDA: 81969846504.05.A084C8A Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com [209.85.214.174]) by imf08.hostedemail.com (Postfix) with ESMTP id E3C21160014 for ; Wed, 3 Apr 2024 23:42:10 +0000 (UTC) Authentication-Results: imf08.hostedemail.com; dkim=pass header.d=rivosinc-com.20230601.gappssmtp.com header.s=20230601 header.b=SM+aPwgv; spf=pass (imf08.hostedemail.com: domain of debug@rivosinc.com designates 209.85.214.174 as permitted sender) smtp.mailfrom=debug@rivosinc.com; dmarc=none ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1712187731; a=rsa-sha256; cv=none; b=Oh0MkW709pKbeLwqly/gLhvLNpQZgXIN3h7sMmbwVG1zVIYZiE4f5CilXEJIiO7BaDR+sE 6nnQNHN0KhVGHyu3p60n4pGyrsZljnb9NY4tCgfc2BEAZXW13I4FyepvP84qvwAymKXByV dd8r2wEA0jPsopu1XWFwMikGiMfMOq4= ARC-Authentication-Results: i=1; imf08.hostedemail.com; dkim=pass header.d=rivosinc-com.20230601.gappssmtp.com header.s=20230601 header.b=SM+aPwgv; spf=pass (imf08.hostedemail.com: domain of debug@rivosinc.com designates 209.85.214.174 as permitted sender) smtp.mailfrom=debug@rivosinc.com; dmarc=none ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1712187731; 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-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=psj+OseZc+8KPm/HqbdNZUd3eG1YiWsTUgUhoWSY+VA=; b=smGjPnave/u7YvqWOxti4TUU1hN2j5SEPTd1LdlzUXAkrc/QC3LUXYjHcZDXgZiSwhUB86 CiPYzy/So45omKgzENIGzPvHJbCy4OD5PQT9gEmSLbTFne83Ok1ip3cqMUkM7Df6j/uA9e I8m9LhBhLcmNyAIYldaa5KLXe7WKi8Q= Received: by mail-pl1-f174.google.com with SMTP id d9443c01a7336-1e223025ccbso2054995ad.3 for ; Wed, 03 Apr 2024 16:42:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1712187730; x=1712792530; darn=kvack.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=psj+OseZc+8KPm/HqbdNZUd3eG1YiWsTUgUhoWSY+VA=; b=SM+aPwgv0Q+xNHwZDV1yu5hAAphSn9fUcFJzA7fGBN6AfsPBD3w9zH2TYZxCzoEz3W j1REpryIw4x6J6+kWDoN6lHPErMJVL4DiyUs1yS6e8RPvmkGRSUCiXLXaEEcm0jsL2ki vNDK0S0Y5Rovt6pbtQaRJL/49rOd3sAShMLNBcfkj6ALkGh5+SyXrNEmjRzii8RYcSM6 eWS+3ct19CD6zoq9bCwUFOHJANuSIf9lryQVC8U+t4vb1qzxcsMP9hBahzBqwHGF34fW Tha4MRmoZ0Hub75GprRqXz4VtIUgsMhstCzPlBHcUiXPnKGh7+6vVlldy14iUiJ7gFWx xJTQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1712187730; x=1712792530; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=psj+OseZc+8KPm/HqbdNZUd3eG1YiWsTUgUhoWSY+VA=; b=tC42U4Ih61n2UgaPWfbDHkacw4FiT1f4HpgLLTqSdI0o2joRWF+AZxTx5ixDpG7nHL e3og1MGWTbMoriqzPN4Am3aWaZ/GBqSgylb9QwMwlslgSQc14sdQhRGW59U2RC5t/hYW MWbYOYnk6w1MvhdGA8Re7IIkM+fCIjmnBk1O9/FLi5O+k97XdLqo+kjosJ54yg8UYDIt jGMpAfSZPjBtdRx2wzbBlJ7n+nz3tD4xezREJ5qOd5k1k7Z9VEY7Jiue6pGjMsQ7Ypaz zDEXQjPZ5EqI4M59qOkmQNHoOx12MP6uq8p0E9NfGzHmnSZfhV/M8vv7Z/WFHB+iJ3LA VdqA== X-Forwarded-Encrypted: i=1; AJvYcCVYVNmVUauKpdSzsGecKzWO0jlG1wr2tLFiJxESsDS0IMYuBk8+xA6jJB5g5EpREXyfwyJKuKUsz1LPqbJTp7m0EKI= X-Gm-Message-State: AOJu0Yzx350CYExPisoj/R56GXw4VbFrQxQG0WURUYW1BYhCLuTNqqAR RHrFLS1xz3YpJ22b64Gca8xpzF+dcBptZU7fYWv18hJjTk91WHvEMMzV0WnZWxc= X-Google-Smtp-Source: AGHT+IFOeWXopoIAOl/E2pm7Fe9NTtywf9IyxEpXwVfgoOIZpkKANuKFSCozkyD2lYgORvDFgKEZ4Q== X-Received: by 2002:a17:902:c407:b0:1e0:f5b7:d6e8 with SMTP id k7-20020a170902c40700b001e0f5b7d6e8mr768005plk.61.1712187729642; Wed, 03 Apr 2024 16:42:09 -0700 (PDT) Received: from debug.ba.rivosinc.com ([64.71.180.162]) by smtp.gmail.com with ESMTPSA id b18-20020a170902d51200b001deeac592absm13899117plg.180.2024.04.03.16.42.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 03 Apr 2024 16:42:09 -0700 (PDT) From: Deepak Gupta To: paul.walmsley@sifive.com, rick.p.edgecombe@intel.com, broonie@kernel.org, Szabolcs.Nagy@arm.com, kito.cheng@sifive.com, keescook@chromium.org, ajones@ventanamicro.com, conor.dooley@microchip.com, cleger@rivosinc.com, atishp@atishpatra.org, alex@ghiti.fr, bjorn@rivosinc.com, alexghiti@rivosinc.com, samuel.holland@sifive.com, conor@kernel.org Cc: linux-doc@vger.kernel.org, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-mm@kvack.org, linux-arch@vger.kernel.org, linux-kselftest@vger.kernel.org, corbet@lwn.net, palmer@dabbelt.com, aou@eecs.berkeley.edu, robh+dt@kernel.org, krzysztof.kozlowski+dt@linaro.org, oleg@redhat.com, akpm@linux-foundation.org, arnd@arndb.de, ebiederm@xmission.com, Liam.Howlett@oracle.com, vbabka@suse.cz, lstoakes@gmail.com, shuah@kernel.org, brauner@kernel.org, debug@rivosinc.com, andy.chiu@sifive.com, jerry.shih@sifive.com, hankuan.chen@sifive.com, greentime.hu@sifive.com, evan@rivosinc.com, xiao.w.wang@intel.com, charlie@rivosinc.com, apatel@ventanamicro.com, mchitale@ventanamicro.com, dbarboza@ventanamicro.com, sameo@rivosinc.com, shikemeng@huaweicloud.com, willy@infradead.org, vincent.chen@sifive.com, guoren@kernel.org, samitolvanen@google.com, songshuaishuai@tinylab.org, gerg@kernel.org, heiko@sntech.de, bhe@redhat.com, jeeheng.sia@starfivetech.com, cyy@cyyself.name, maskray@google.com, ancientmodern4@gmail.com, mathis.salmen@matsal.de, cuiyunhui@bytedance.com, bgray@linux.ibm.com, mpe@ellerman.id.au, baruch@tkos.co.il, alx@kernel.org, david@redhat.com, catalin.marinas@arm.com, revest@chromium.org, josh@joshtriplett.org, shr@devkernel.io, deller@gmx.de, omosnace@redhat.com, ojeda@kernel.org, jhubbard@nvidia.com Subject: [PATCH v3 15/29] riscv/shstk: If needed allocate a new shadow stack on clone Date: Wed, 3 Apr 2024 16:35:03 -0700 Message-ID: <20240403234054.2020347-16-debug@rivosinc.com> X-Mailer: git-send-email 2.43.2 In-Reply-To: <20240403234054.2020347-1-debug@rivosinc.com> References: <20240403234054.2020347-1-debug@rivosinc.com> MIME-Version: 1.0 X-Rspamd-Server: rspam08 X-Rspamd-Queue-Id: E3C21160014 X-Stat-Signature: urtpkxot34mubp7n4finbi4nqxanf3ph X-Rspam-User: X-HE-Tag: 1712187730-817542 X-HE-Meta: U2FsdGVkX1/Yf2egwHbK0Zf0o3WLJMFVXTb7l3SKHSmje5wYhoJGnsm6sRNi2WYPpYOGP9KZaaFKpuFLSOGnTYjfi7NqIA/kPoe4RvFJUfQONdzWKdmBTMU3ir2mZXmI8CxiW2qWamvXpFF+8f62Uyt37viwAHQeYYkCKwtTl6jVJJykJrSPkKY105YlG+EXO/V9AMi656qXfkqE2xQ4g9iDOYuqCu88x+9Zwhe5383yl2VfQHfWfE4H3otqVKIYjW3247LVpLftMIYw0WL0sOCgw8OOolZlmvaoz28ihAf/7M6u3mv463Ei4DeghvhxWdgJdNpENnjxOWF8ZF80UDMDjZ9P3Tu9NYrYRk+wUoO/Bezp1ZdNZiZ2kHIdbwxnvkeh0qLkoi3Ekf/mTTF093Ts7vNPSqFiOhkNoHS3/uB7NyR3aNAIhgeoajsmvdeZODnBgyaFyONu667TTHji9JTGX2jMzhbm6Qnvkn+y+1PHRCWQkRpr3zrHrOq+vPnCRtVhd1jd28i+A70lyx56a3vF6/tpHnGNRgKk4OXyKWsXltUe3IMbNGfNOU0WeI61K5IHHmwAR+h0G6bJsvBqE43+WvRE2QXVli4+kOZlH2zD5HM3IZ13eT72r3xQ5mhDk6MGqZe/GhLIzXRcOQe9XEitzRTDFWfbm+f8k9kiPlOANep0lh4bDugK6MdeYWI0gTN9oBkW64NsYR4m0ki/4s5rya9yP+ng9D6AwYuXfDtCUITOG19vWHzBK2RmTQ3jEwDTOXvWFiZ2q6uEtf/QQ8I5uoFgwZY4Fn1yoL7c0tNUeAJt/OsyFOvrZZqe6aZYa3dmqKRk3xtfzoQTGWcqhjqGDygTpKDmywUFz6nJ+KdkffIJ0XNn2aGGtCE73XH4LiqCF3PxUZQVwIWFQSa64QOaMhptl/ogX1aO/m3b9NyJD46MxxVP8P2UC1gNRefiJSRjLTiMRHcXS85ilz0 nIY7iE7G QvUFpTqzjeNjwtm6j7zeRXXwJ16bXWWvEEUakSr4nOsft/vlHd7fNW7yCwzZfPzMLGM0ZpFTYbPvl/AzCvln+Y/CF2OUW8MNHgr/lTO0kZY8xIejwh6mzteE/7TqAyS0e+Ed5mfKfRX9mgcbztppVYf3EGbaXEDmsFLqDWUgU9CfOtSdxyh553+1tVP6TV7LTCamiLSF9BU+s3WBwntEdliuw4pnbOq9OV2MKAlFYtAvn46VUldeSSGwnOU47ATR470pGWLOxkYBdVw6cgY/SgH8Z8ekfJ98n9Piht2GDonVbqFrdjA878K1ZaKe18ZlcCCuN1btuh+V94/oxCX5NC7RlOsPgw9oacaLbco9ksr9eYs106EXupZMhPw6+sJFA3ewkTN2eHXacbmTvb5BX+08T5lcMcVk0hr6BJBeoSHgcl3iWTvTqSBF2kBxNi8MtNucQ+HBvGzcjVFrlARXwKUaoNZIyatdjeqZX9e25UBgN9VChLLR44KeTzSgaj0C+wWlDe7oIdIGLJmE= 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: Userspace specifies VM_CLONE to share address space and spawn new thread. `clone` allow userspace to specify a new stack for new thread. However there is no way to specify new shadow stack base address without changing API. This patch allocates a new shadow stack whenever VM_CLONE is given. In case of VM_FORK, parent is suspended until child finishes and thus can child use parent shadow stack. In case of !VM_CLONE, COW kicks in because entire address space is copied from parent to child. `clone3` is extensible and can provide mechanisms using which shadow stack as an input parameter can be provided. This is not settled yet and being extensively discussed on mailing list. Once that's settled, this commit will adapt to that. Signed-off-by: Deepak Gupta --- arch/riscv/include/asm/usercfi.h | 39 ++++++++++ arch/riscv/kernel/process.c | 12 ++- arch/riscv/kernel/usercfi.c | 121 +++++++++++++++++++++++++++++++ 3 files changed, 171 insertions(+), 1 deletion(-) diff --git a/arch/riscv/include/asm/usercfi.h b/arch/riscv/include/asm/usercfi.h index 4fa201b4fc4e..b47574a7a8c9 100644 --- a/arch/riscv/include/asm/usercfi.h +++ b/arch/riscv/include/asm/usercfi.h @@ -8,6 +8,9 @@ #ifndef __ASSEMBLY__ #include +struct task_struct; +struct kernel_clone_args; + #ifdef CONFIG_RISCV_USER_CFI struct cfi_status { unsigned long ubcfi_en : 1; /* Enable for backward cfi. */ @@ -17,6 +20,42 @@ struct cfi_status { unsigned long shdw_stk_size; /* size of shadow stack */ }; +unsigned long shstk_alloc_thread_stack(struct task_struct *tsk, + const struct kernel_clone_args *args); +void shstk_release(struct task_struct *tsk); +void set_shstk_base(struct task_struct *task, unsigned long shstk_addr, unsigned long size); +void set_active_shstk(struct task_struct *task, unsigned long shstk_addr); +bool is_shstk_enabled(struct task_struct *task); + +#else + +static inline unsigned long shstk_alloc_thread_stack(struct task_struct *tsk, + const struct kernel_clone_args *args) +{ + return 0; +} + +static inline void shstk_release(struct task_struct *tsk) +{ + +} + +static inline void set_shstk_base(struct task_struct *task, unsigned long shstk_addr, + unsigned long size) +{ + +} + +static inline void set_active_shstk(struct task_struct *task, unsigned long shstk_addr) +{ + +} + +static inline bool is_shstk_enabled(struct task_struct *task) +{ + return false; +} + #endif /* CONFIG_RISCV_USER_CFI */ #endif /* __ASSEMBLY__ */ diff --git a/arch/riscv/kernel/process.c b/arch/riscv/kernel/process.c index ce577cdc2af3..ef48a25b0eff 100644 --- a/arch/riscv/kernel/process.c +++ b/arch/riscv/kernel/process.c @@ -26,6 +26,7 @@ #include #include #include +#include register unsigned long gp_in_global __asm__("gp"); @@ -202,7 +203,8 @@ int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src) void exit_thread(struct task_struct *tsk) { - + if (IS_ENABLED(CONFIG_RISCV_USER_CFI)) + shstk_release(tsk); } int copy_thread(struct task_struct *p, const struct kernel_clone_args *args) @@ -210,6 +212,7 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args) unsigned long clone_flags = args->flags; unsigned long usp = args->stack; unsigned long tls = args->tls; + unsigned long ssp = 0; struct pt_regs *childregs = task_pt_regs(p); memset(&p->thread.s, 0, sizeof(p->thread.s)); @@ -225,11 +228,18 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args) p->thread.s[0] = (unsigned long)args->fn; p->thread.s[1] = (unsigned long)args->fn_arg; } else { + /* allocate new shadow stack if needed. In case of CLONE_VM we have to */ + ssp = shstk_alloc_thread_stack(p, args); + if (IS_ERR_VALUE(ssp)) + return PTR_ERR((void *)ssp); + *childregs = *(current_pt_regs()); /* Turn off status.VS */ riscv_v_vstate_off(childregs); if (usp) /* User fork */ childregs->sp = usp; + if (ssp) /* if needed, set new ssp */ + set_active_shstk(p, ssp); if (clone_flags & CLONE_SETTLS) childregs->tp = tls; childregs->a0 = 0; /* Return value of fork() */ diff --git a/arch/riscv/kernel/usercfi.c b/arch/riscv/kernel/usercfi.c index c4ed0d4e33d6..11ef7ab925c9 100644 --- a/arch/riscv/kernel/usercfi.c +++ b/arch/riscv/kernel/usercfi.c @@ -19,6 +19,41 @@ #define SHSTK_ENTRY_SIZE sizeof(void *) +bool is_shstk_enabled(struct task_struct *task) +{ + return task->thread_info.user_cfi_state.ubcfi_en ? true : false; +} + +void set_shstk_base(struct task_struct *task, unsigned long shstk_addr, unsigned long size) +{ + task->thread_info.user_cfi_state.shdw_stk_base = shstk_addr; + task->thread_info.user_cfi_state.shdw_stk_size = size; +} + +unsigned long get_shstk_base(struct task_struct *task, unsigned long *size) +{ + if (size) + *size = task->thread_info.user_cfi_state.shdw_stk_size; + return task->thread_info.user_cfi_state.shdw_stk_base; +} + +void set_active_shstk(struct task_struct *task, unsigned long shstk_addr) +{ + task->thread_info.user_cfi_state.user_shdw_stk = shstk_addr; +} + +/* + * If size is 0, then to be compatible with regular stack we want it to be as big as + * regular stack. Else PAGE_ALIGN it and return back + */ +static unsigned long calc_shstk_size(unsigned long size) +{ + if (size) + return PAGE_ALIGN(size); + + return PAGE_ALIGN(min_t(unsigned long long, rlimit(RLIMIT_STACK), SZ_4G)); +} + /* * Writes on shadow stack can either be `sspush` or `ssamoswap`. `sspush` can happen * implicitly on current shadow stack pointed to by CSR_SSP. `ssamoswap` takes pointer to @@ -147,3 +182,89 @@ SYSCALL_DEFINE3(map_shadow_stack, unsigned long, addr, unsigned long, size, unsi return allocate_shadow_stack(addr, aligned_size, size, set_tok); } + +/* + * This gets called during clone/clone3/fork. And is needed to allocate a shadow stack for + * cases where CLONE_VM is specified and thus a different stack is specified by user. We + * thus need a separate shadow stack too. How does separate shadow stack is specified by + * user is still being debated. Once that's settled, remove this part of the comment. + * This function simply returns 0 if shadow stack are not supported or if separate shadow + * stack allocation is not needed (like in case of !CLONE_VM) + */ +unsigned long shstk_alloc_thread_stack(struct task_struct *tsk, + const struct kernel_clone_args *args) +{ + unsigned long addr, size; + + /* If shadow stack is not supported, return 0 */ + if (!cpu_supports_shadow_stack()) + return 0; + + /* + * If shadow stack is not enabled on the new thread, skip any + * switch to a new shadow stack. + */ + if (is_shstk_enabled(tsk)) + return 0; + + /* + * For CLONE_VFORK the child will share the parents shadow stack. + * Set base = 0 and size = 0, this is special means to track this state + * so the freeing logic run for child knows to leave it alone. + */ + if (args->flags & CLONE_VFORK) { + set_shstk_base(tsk, 0, 0); + return 0; + } + + /* + * For !CLONE_VM the child will use a copy of the parents shadow + * stack. + */ + if (!(args->flags & CLONE_VM)) + return 0; + + /* + * reaching here means, CLONE_VM was specified and thus a separate shadow + * stack is needed for new cloned thread. Note: below allocation is happening + * using current mm. + */ + size = calc_shstk_size(args->stack_size); + addr = allocate_shadow_stack(0, size, 0, false); + if (IS_ERR_VALUE(addr)) + return addr; + + set_shstk_base(tsk, addr, size); + + return addr + size; +} + +void shstk_release(struct task_struct *tsk) +{ + unsigned long base = 0, size = 0; + /* If shadow stack is not supported or not enabled, nothing to release */ + if (!cpu_supports_shadow_stack() || + !is_shstk_enabled(tsk)) + return; + + /* + * When fork() with CLONE_VM fails, the child (tsk) already has a + * shadow stack allocated, and exit_thread() calls this function to + * free it. In this case the parent (current) and the child share + * the same mm struct. Move forward only when they're same. + */ + if (!tsk->mm || tsk->mm != current->mm) + return; + + /* + * We know shadow stack is enabled but if base is NULL, then + * this task is not managing its own shadow stack (CLONE_VFORK). So + * skip freeing it. + */ + base = get_shstk_base(tsk, &size); + if (!base) + return; + + vm_munmap(base, size); + set_shstk_base(tsk, 0, 0); +}