riscv: Implement indirect branch tracking prctls

This patch adds a RISC-V implementation of the following prctls:
PR_SET_INDIR_BR_LP_STATUS, PR_GET_INDIR_BR_LP_STATUS and
PR_LOCK_INDIR_BR_LP_STATUS.

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>
Tested-by: Valentin Haudiquet <valentin.haudiquet@canonical.com>
Link: https://patch.msgid.link/20251112-v5_user_cfi_series-v23-14-b55691eacf4f@rivosinc.com
[pjw@kernel.org: clean up patch description]
Signed-off-by: Paul Walmsley <pjw@kernel.org>

diff --git a/arch/riscv/include/asm/usercfi.h b/arch/riscv/include/asm/usercfi.h
index d71093f414df1eff932eeb4fcee21bf967027f28..4501d741a609d5f7ca18ec64eb7a82c64d76e5b3 100644 (file)
--- a/arch/riscv/include/asm/usercfi.h
+++ b/arch/riscv/include/asm/usercfi.h
@@ -16,6 +16,8 @@ struct kernel_clone_args;
 struct cfi_state {
        unsigned long ubcfi_en : 1; /* Enable for backward cfi. */
        unsigned long ubcfi_locked : 1;
+       unsigned long ufcfi_en : 1; /* Enable for forward cfi. Note that ELP goes in sstatus */
+       unsigned long ufcfi_locked : 1;
        unsigned long user_shdw_stk; /* Current user shadow stack pointer */
        unsigned long shdw_stk_base; /* Base address of shadow stack */
        unsigned long shdw_stk_size; /* size of shadow stack */
@@ -32,6 +34,10 @@ bool is_shstk_locked(struct task_struct *task);
 bool is_shstk_allocated(struct task_struct *task);
 void set_shstk_lock(struct task_struct *task);
 void set_shstk_status(struct task_struct *task, bool enable);
+bool is_indir_lp_enabled(struct task_struct *task);
+bool is_indir_lp_locked(struct task_struct *task);
+void set_indir_lp_status(struct task_struct *task, bool enable);
+void set_indir_lp_lock(struct task_struct *task);
 
 #define PR_SHADOW_STACK_SUPPORTED_STATUS_MASK (PR_SHADOW_STACK_ENABLE)
 
@@ -57,6 +63,14 @@ void set_shstk_status(struct task_struct *task, bool enable);
 
 #define set_shstk_status(task, enable) do {} while (0)
 
+#define is_indir_lp_enabled(task) false
+
+#define is_indir_lp_locked(task) false
+
+#define set_indir_lp_status(task, enable) do {} while (0)
+
+#define set_indir_lp_lock(task) do {} while (0)
+
 #endif /* CONFIG_RISCV_USER_CFI */
 
 #endif /* __ASSEMBLER__ */

diff --git a/arch/riscv/kernel/entry.S b/arch/riscv/kernel/entry.S
index 0f1394d71720cea36a844acaef8e6f0a53db5b80..2d0a9a3ce231f238c8ab736d36222bf65b179112 100644 (file)
--- a/arch/riscv/kernel/entry.S
+++ b/arch/riscv/kernel/entry.S
@@ -174,6 +174,10 @@ SYM_CODE_START(handle_exception)
         * or vector in kernel space.
         */
        li t0, SR_SUM | SR_FS_VS
+#ifdef CONFIG_64BIT
+       li t1, SR_ELP
+       or t0, t0, t1
+#endif
 
        REG_L s0, TASK_TI_USER_SP(tp)
        csrrc s1, CSR_STATUS, t0

diff --git a/arch/riscv/kernel/process.c b/arch/riscv/kernel/process.c
index a137d3483646219afeab164da0eb34db518273fe..49f527e3acfdff9236d3416eb035553ed3b227c1 100644 (file)
--- a/arch/riscv/kernel/process.c
+++ b/arch/riscv/kernel/process.c
@@ -163,6 +163,11 @@ void start_thread(struct pt_regs *regs, unsigned long pc,
        set_shstk_status(current, false);
        set_shstk_base(current, 0, 0);
        set_active_shstk(current, 0);
+       /*
+        * disable indirect branch tracking on exec.
+        * libc will enable it later via prctl.
+        */
+       set_indir_lp_status(current, false);
 
 #ifdef CONFIG_64BIT
        regs->status &= ~SR_UXL;

diff --git a/arch/riscv/kernel/usercfi.c b/arch/riscv/kernel/usercfi.c
index 778930f79cfa302179fb78455e8cfdaa087ecedd..db3ba51af5a5331b5c2d04a286af02c91be5a5d3 100644 (file)
--- a/arch/riscv/kernel/usercfi.c
+++ b/arch/riscv/kernel/usercfi.c
@@ -72,6 +72,35 @@ void set_shstk_lock(struct task_struct *task)
        task->thread_info.user_cfi_state.ubcfi_locked = 1;
 }
 
+bool is_indir_lp_enabled(struct task_struct *task)
+{
+       return task->thread_info.user_cfi_state.ufcfi_en;
+}
+
+bool is_indir_lp_locked(struct task_struct *task)
+{
+       return task->thread_info.user_cfi_state.ufcfi_locked;
+}
+
+void set_indir_lp_status(struct task_struct *task, bool enable)
+{
+       if (!cpu_supports_indirect_br_lp_instr())
+               return;
+
+       task->thread_info.user_cfi_state.ufcfi_en = enable ? 1 : 0;
+
+       if (enable)
+               task->thread.envcfg |= ENVCFG_LPE;
+       else
+               task->thread.envcfg &= ~ENVCFG_LPE;
+
+       csr_write(CSR_ENVCFG, task->thread.envcfg);
+}
+
+void set_indir_lp_lock(struct task_struct *task)
+{
+       task->thread_info.user_cfi_state.ufcfi_locked = 1;
+}
 /*
  * 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
@@ -368,3 +397,53 @@ int arch_lock_shadow_stack_status(struct task_struct *task,
 
        return 0;
 }
+
+int arch_get_indir_br_lp_status(struct task_struct *t, unsigned long __user *status)
+{
+       unsigned long fcfi_status = 0;
+
+       if (!cpu_supports_indirect_br_lp_instr())
+               return -EINVAL;
+
+       /* indirect branch tracking is enabled on the task or not */
+       fcfi_status |= (is_indir_lp_enabled(t) ? PR_INDIR_BR_LP_ENABLE : 0);
+
+       return copy_to_user(status, &fcfi_status, sizeof(fcfi_status)) ? -EFAULT : 0;
+}
+
+int arch_set_indir_br_lp_status(struct task_struct *t, unsigned long status)
+{
+       bool enable_indir_lp = false;
+
+       if (!cpu_supports_indirect_br_lp_instr())
+               return -EINVAL;
+
+       /* indirect branch tracking is locked and further can't be modified by user */
+       if (is_indir_lp_locked(t))
+               return -EINVAL;
+
+       /* Reject unknown flags */
+       if (status & ~PR_INDIR_BR_LP_ENABLE)
+               return -EINVAL;
+
+       enable_indir_lp = (status & PR_INDIR_BR_LP_ENABLE);
+       set_indir_lp_status(t, enable_indir_lp);
+
+       return 0;
+}
+
+int arch_lock_indir_br_lp_status(struct task_struct *task,
+                                unsigned long arg)
+{
+       /*
+        * If indirect branch tracking is not supported or not enabled on task,
+        * nothing to lock here
+        */
+       if (!cpu_supports_indirect_br_lp_instr() ||
+           !is_indir_lp_enabled(task) || arg != 0)
+               return -EINVAL;
+
+       set_indir_lp_lock(task);
+
+       return 0;
+}