riscv/shstk: If needed allocate a new shadow stack on clone

Userspace specifies CLONE_VM to share address space and spawn new
thread.  'clone' allows userspace to specify a new stack for a new
thread. However there is no way to specify a new shadow stack base
address without changing the API. This patch allocates a new shadow
stack whenever CLONE_VM is given.

In case of CLONE_VFORK, the parent is suspended until the child
finishes; thus the child can use the parent's shadow stack. In case of
!CLONE_VM, COW kicks in because entire address space is copied from
parent to child.

'clone3' is extensible and can provide mechanisms for specifying the
shadow stack as an input parameter. This is not settled yet and is
being extensively discussed on the mailing list. Once that's settled,
this code should be adapted.

Reviewed-by: Zong Li <zong.li@sifive.com>
Signed-off-by: Deepak Gupta <debug@rivosinc.com>
Tested-by: Andreas Korb <andreas.korb@aisec.fraunhofer.de> # QEMU, custom CVA6
Tested-by: Valentin Haudiquet <valentin.haudiquet@canonical.com>
Link: https://patch.msgid.link/20251112-v5_user_cfi_series-v23-11-b55691eacf4f@rivosinc.com
[pjw@kernel.org: cleaned up patch description]
Signed-off-by: Paul Walmsley <pjw@kernel.org>

diff --git a/arch/riscv/include/asm/mmu_context.h b/arch/riscv/include/asm/mmu_context.h
index 8c4bc49a3a0f5b8949a030e9ae7421052136ae34..dbf27a78df6c87a19fc79a72b505cb85e67226fd 100644 (file)
--- a/arch/riscv/include/asm/mmu_context.h
+++ b/arch/riscv/include/asm/mmu_context.h
@@ -48,6 +48,13 @@ static inline unsigned long mm_untag_mask(struct mm_struct *mm)
 }
 #endif
 
+#define deactivate_mm deactivate_mm
+static inline void deactivate_mm(struct task_struct *tsk,
+                                struct mm_struct *mm)
+{
+       shstk_release(tsk);
+}
+
 #include <asm-generic/mmu_context.h>
 
 #endif /* _ASM_RISCV_MMU_CONTEXT_H */

diff --git a/arch/riscv/include/asm/usercfi.h b/arch/riscv/include/asm/usercfi.h
index 4c5233e8f3f9ef00de1d2d5b5b32471d0023ab6c..a16a5dff8b0ec44b9866676a534e5ee68f6e6cb1 100644 (file)
--- a/arch/riscv/include/asm/usercfi.h
+++ b/arch/riscv/include/asm/usercfi.h
@@ -8,6 +8,9 @@
 #ifndef __ASSEMBLER__
 #include <linux/types.h>
 
+struct task_struct;
+struct kernel_clone_args;
+
 #ifdef CONFIG_RISCV_USER_CFI
 struct cfi_state {
        unsigned long ubcfi_en : 1; /* Enable for backward cfi. */
@@ -16,6 +19,28 @@ struct cfi_state {
        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);
+unsigned long get_shstk_base(struct task_struct *task, unsigned long *size);
+void set_active_shstk(struct task_struct *task, unsigned long shstk_addr);
+bool is_shstk_enabled(struct task_struct *task);
+
+#else
+
+#define shstk_alloc_thread_stack(tsk, args) 0
+
+#define shstk_release(tsk)
+
+#define get_shstk_base(task, size) 0UL
+
+#define set_shstk_base(task, shstk_addr, size) do {} while (0)
+
+#define set_active_shstk(task, shstk_addr) do {} while (0)
+
+#define is_shstk_enabled(task) false
+
 #endif /* CONFIG_RISCV_USER_CFI */
 
 #endif /* __ASSEMBLER__ */

diff --git a/arch/riscv/kernel/process.c b/arch/riscv/kernel/process.c
index 31a392993cb4521e035065a0e51c12a6c4b36f6f..72d35adc6e0efb70f3ee8a4b10c998dad45283db 100644 (file)
--- a/arch/riscv/kernel/process.c
+++ b/arch/riscv/kernel/process.c
@@ -31,6 +31,7 @@
 #include <asm/vector.h>
 #include <asm/cpufeature.h>
 #include <asm/exec.h>
+#include <asm/usercfi.h>
 
 #if defined(CONFIG_STACKPROTECTOR) && !defined(CONFIG_STACKPROTECTOR_PER_TASK)
 #include <linux/stackprotector.h>
@@ -226,6 +227,7 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args)
        u64 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);
 
        /* Ensure all threads in this mm have the same pointer masking mode. */
@@ -245,11 +247,19 @@ int copy_thread(struct task_struct *p, const struct kernel_clone_args *args)
                p->thread.s[1] = (unsigned long)args->fn_arg;
                p->thread.ra = (unsigned long)ret_from_fork_kernel_asm;
        } 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 needed, set new ssp */
+               if (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 9717321d3bd64548fd87d5bdfab546d42987138a..59cdd6f69d3f5429f5b430173ca92875ebaff158 100644 (file)
--- 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;
+}
+
+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
@@ -138,3 +173,88 @@ 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 a 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 stacks 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);
+}