riscv: Implement syscall wrappers

Commit f0bddf50586d ("riscv: entry: Convert to generic entry") moved
syscall handling to C code, which exposed function pointer type
mismatches that trip fine-grained forward-edge Control-Flow Integrity
(CFI) checks as syscall handlers are all called through the same
syscall_t pointer type. To fix the type mismatches, implement pt_regs
based syscall wrappers similarly to x86 and arm64.

This patch is based on arm64 syscall wrappers added in commit
4378a7d4be30 ("arm64: implement syscall wrappers"), where the main goal
was to minimize the risk of userspace-controlled values being used
under speculation. This may be a concern for riscv in future as well.

Following other architectures, the syscall wrappers generate three
functions for each syscall; __riscv_<compat_>sys_<name> takes a pt_regs
pointer and extracts arguments from registers, __se_<compat_>sys_<name>
is a sign-extension wrapper that casts the long arguments to the
correct types for the real syscall implementation, which is named
__do_<compat_>sys_<name>.

Reviewed-by: Kees Cook <keescook@chromium.org>
Tested-by: Nathan Chancellor <nathan@kernel.org>
Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
Link: https://lore.kernel.org/r/20230710183544.999540-9-samitolvanen@google.com
Signed-off-by: Palmer Dabbelt <palmer@rivosinc.com>

diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig
index 4c07b9189c867b715f96ec3beaf1c14a810bb2ae..a475ef1a0c1cf234704bcbdaad7be5883c541fa0 100644 (file)
--- a/arch/riscv/Kconfig
+++ b/arch/riscv/Kconfig
@@ -35,6 +35,7 @@ config RISCV
        select ARCH_HAS_SET_MEMORY if MMU
        select ARCH_HAS_STRICT_KERNEL_RWX if MMU && !XIP_KERNEL
        select ARCH_HAS_STRICT_MODULE_RWX if MMU && !XIP_KERNEL
+       select ARCH_HAS_SYSCALL_WRAPPER
        select ARCH_HAS_TICK_BROADCAST if GENERIC_CLOCKEVENTS_BROADCAST
        select ARCH_HAS_UBSAN_SANITIZE_ALL
        select ARCH_HAS_VDSO_DATA

diff --git a/arch/riscv/include/asm/syscall.h b/arch/riscv/include/asm/syscall.h
index 0148c6bd9675d01141454862a65fa221baf87958..121fff429dce66b31fe79b691b8edd816c8019e9 100644 (file)
--- a/arch/riscv/include/asm/syscall.h
+++ b/arch/riscv/include/asm/syscall.h
@@ -75,7 +75,7 @@ static inline int syscall_get_arch(struct task_struct *task)
 #endif
 }
 
-typedef long (*syscall_t)(ulong, ulong, ulong, ulong, ulong, ulong, ulong);
+typedef long (*syscall_t)(const struct pt_regs *);
 static inline void syscall_handler(struct pt_regs *regs, ulong syscall)
 {
        syscall_t fn;
@@ -87,8 +87,7 @@ static inline void syscall_handler(struct pt_regs *regs, ulong syscall)
 #endif
                fn = sys_call_table[syscall];
 
-       regs->a0 = fn(regs->orig_a0, regs->a1, regs->a2,
-                     regs->a3, regs->a4, regs->a5, regs->a6);
+       regs->a0 = fn(regs);
 }
 
 static inline bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs)

diff --git a/arch/riscv/include/asm/syscall_wrapper.h b/arch/riscv/include/asm/syscall_wrapper.h
new file mode 100644 (file)
index 0000000..1d7942c
--- /dev/null
+++ b/arch/riscv/include/asm/syscall_wrapper.h
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * syscall_wrapper.h - riscv specific wrappers to syscall definitions
+ *
+ * Based on arch/arm64/include/syscall_wrapper.h
+ */
+
+#ifndef __ASM_SYSCALL_WRAPPER_H
+#define __ASM_SYSCALL_WRAPPER_H
+
+#include <asm/ptrace.h>
+
+asmlinkage long __riscv_sys_ni_syscall(const struct pt_regs *);
+
+#define SC_RISCV_REGS_TO_ARGS(x, ...)                          \
+       __MAP(x,__SC_ARGS                                       \
+             ,,regs->orig_a0,,regs->a1,,regs->a2               \
+             ,,regs->a3,,regs->a4,,regs->a5,,regs->a6)
+
+#ifdef CONFIG_COMPAT
+
+#define COMPAT_SYSCALL_DEFINEx(x, name, ...)                                           \
+       asmlinkage long __riscv_compat_sys##name(const struct pt_regs *regs);           \
+       ALLOW_ERROR_INJECTION(__riscv_compat_sys##name, ERRNO);                         \
+       static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));              \
+       static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));       \
+       asmlinkage long __riscv_compat_sys##name(const struct pt_regs *regs)            \
+       {                                                                               \
+               return __se_compat_sys##name(SC_RISCV_REGS_TO_ARGS(x,__VA_ARGS__));     \
+       }                                                                               \
+       static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))               \
+       {                                                                               \
+               return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));        \
+       }                                                                               \
+       static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
+
+#define COMPAT_SYSCALL_DEFINE0(sname)                                                  \
+       asmlinkage long __riscv_compat_sys_##sname(const struct pt_regs *__unused);     \
+       ALLOW_ERROR_INJECTION(__riscv_compat_sys_##sname, ERRNO);                       \
+       asmlinkage long __riscv_compat_sys_##sname(const struct pt_regs *__unused)
+
+#define COND_SYSCALL_COMPAT(name)                                                      \
+       asmlinkage long __weak __riscv_compat_sys_##name(const struct pt_regs *regs);   \
+       asmlinkage long __weak __riscv_compat_sys_##name(const struct pt_regs *regs)    \
+       {                                                                               \
+               return sys_ni_syscall();                                                \
+       }
+
+#define COMPAT_SYS_NI(name) \
+       SYSCALL_ALIAS(__riscv_compat_sys_##name, sys_ni_posix_timers);
+
+#endif /* CONFIG_COMPAT */
+
+#define __SYSCALL_DEFINEx(x, name, ...)                                                \
+       asmlinkage long __riscv_sys##name(const struct pt_regs *regs);          \
+       ALLOW_ERROR_INJECTION(__riscv_sys##name, ERRNO);                        \
+       static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));             \
+       static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));      \
+       asmlinkage long __riscv_sys##name(const struct pt_regs *regs)           \
+       {                                                                       \
+               return __se_sys##name(SC_RISCV_REGS_TO_ARGS(x,__VA_ARGS__));    \
+       }                                                                       \
+       static long __se_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))              \
+       {                                                                       \
+               long ret = __do_sys##name(__MAP(x,__SC_CAST,__VA_ARGS__));      \
+               __MAP(x,__SC_TEST,__VA_ARGS__);                                 \
+               __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));               \
+               return ret;                                                     \
+       }                                                                       \
+       static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
+
+#define SYSCALL_DEFINE0(sname)                                                 \
+       SYSCALL_METADATA(_##sname, 0);                                          \
+       asmlinkage long __riscv_sys_##sname(const struct pt_regs *__unused);    \
+       ALLOW_ERROR_INJECTION(__riscv_sys_##sname, ERRNO);                      \
+       asmlinkage long __riscv_sys_##sname(const struct pt_regs *__unused)
+
+#define COND_SYSCALL(name)                                                     \
+       asmlinkage long __weak __riscv_sys_##name(const struct pt_regs *regs);  \
+       asmlinkage long __weak __riscv_sys_##name(const struct pt_regs *regs)   \
+       {                                                                       \
+               return sys_ni_syscall();                                        \
+       }
+
+#define SYS_NI(name) SYSCALL_ALIAS(__riscv_sys_##name, sys_ni_posix_timers);
+
+#endif /* __ASM_SYSCALL_WRAPPER_H */

diff --git a/arch/riscv/kernel/compat_syscall_table.c b/arch/riscv/kernel/compat_syscall_table.c
index 651f2b009c2812c6af75d0acce89b45ceaefd835..ad7f2d712f5fd070b3e4d8687a8b8d147f17162c 100644 (file)
--- a/arch/riscv/kernel/compat_syscall_table.c
+++ b/arch/riscv/kernel/compat_syscall_table.c
@@ -9,11 +9,15 @@
 #include <asm/syscall.h>
 
 #undef __SYSCALL
-#define __SYSCALL(nr, call)      [nr] = (call),
+#define __SYSCALL(nr, call)    asmlinkage long __riscv_##call(const struct pt_regs *);
+#include <asm/unistd.h>
+
+#undef __SYSCALL
+#define __SYSCALL(nr, call)      [nr] = __riscv_##call,
 
 asmlinkage long compat_sys_rt_sigreturn(void);
 
 void * const compat_sys_call_table[__NR_syscalls] = {
-       [0 ... __NR_syscalls - 1] = sys_ni_syscall,
+       [0 ... __NR_syscalls - 1] = __riscv_sys_ni_syscall,
 #include <asm/unistd.h>
 };

diff --git a/arch/riscv/kernel/sys_riscv.c b/arch/riscv/kernel/sys_riscv.c
index 26ef5526bfb4cc45e57096b536b75e5bb3116600..473159b5f303ab9c7f784bb388814446b13b61f2 100644 (file)
--- a/arch/riscv/kernel/sys_riscv.c
+++ b/arch/riscv/kernel/sys_riscv.c
@@ -335,3 +335,9 @@ SYSCALL_DEFINE5(riscv_hwprobe, struct riscv_hwprobe __user *, pairs,
        return do_riscv_hwprobe(pairs, pair_count, cpu_count,
                                cpus, flags);
 }
+
+/* Not defined using SYSCALL_DEFINE0 to avoid error injection */
+asmlinkage long __riscv_sys_ni_syscall(const struct pt_regs *__unused)
+{
+       return -ENOSYS;
+}

diff --git a/arch/riscv/kernel/syscall_table.c b/arch/riscv/kernel/syscall_table.c
index 44b1420a22705a81eca174d748bfc2d2986302d7..dda91376490340c111e84f937495c6c35d5b63ee 100644 (file)
--- a/arch/riscv/kernel/syscall_table.c
+++ b/arch/riscv/kernel/syscall_table.c
@@ -10,9 +10,13 @@
 #include <asm/syscall.h>
 
 #undef __SYSCALL
-#define __SYSCALL(nr, call)    [nr] = (call),
+#define __SYSCALL(nr, call)    asmlinkage long __riscv_##call(const struct pt_regs *);
+#include <asm/unistd.h>
+
+#undef __SYSCALL
+#define __SYSCALL(nr, call)    [nr] = __riscv_##call,
 
 void * const sys_call_table[__NR_syscalls] = {
-       [0 ... __NR_syscalls - 1] = sys_ni_syscall,
+       [0 ... __NR_syscalls - 1] = __riscv_sys_ni_syscall,
 #include <asm/unistd.h>
 };