Unverified Commit 08d0ce30 authored by Sami Tolvanen's avatar Sami Tolvanen Committed by Palmer Dabbelt
Browse files

riscv: Implement syscall wrappers 



Commit f0bddf50 ("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
4378a7d4 ("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: default avatarKees Cook <keescook@chromium.org>
Tested-by: default avatarNathan Chancellor <nathan@kernel.org>
Signed-off-by: default avatarSami Tolvanen <samitolvanen@google.com>
Link: https://lore.kernel.org/r/20230710183544.999540-9-samitolvanen@google.com


Signed-off-by: default avatarPalmer Dabbelt <palmer@rivosinc.com>
parent 06c2afb8

arch/riscv/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -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

arch/riscv/include/asm/syscall.h

+2 −3
Original line number Diff line number Diff line
@@ -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)

arch/riscv/include/asm/syscall_wrapper.h

0 → 100644
+87 −0
Original line number Diff line number Diff line 
/* 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 */

arch/riscv/kernel/compat_syscall_table.c

+6 −2
Original line number Diff line number Diff line
@@ -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>

};

arch/riscv/kernel/sys_riscv.c

+6 −0
Original line number Diff line number Diff line
@@ -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;

}