riscv: Fix syscall wrapper for >word-size arguments

The current syscall wrapper macros break 64-bit arguments on
rv32 because they only guarantee the first N input registers are
passed to syscalls that accept N arguments. According to the
calling convention, values twice the word size reside in register
pairs and as a result, syscall arguments don't always have a
direct register mapping on rv32.

Instead of using `__MAP(x,__SC_LONG,__VA_ARGS__)` to declare the
type of the `__se(_compat)_sys_*` functions on rv32, change the
function declarations to accept `ulong` arguments and alias them
to the actual syscall implementations, similarly to the existing
macros in include/linux/syscalls.h. This matches previous
behavior and ensures registers are passed to syscalls as-is, no
matter which argument types they expect.

Fixes: 08d0ce30e0e4 ("riscv: Implement syscall wrappers")
Reported-by: Khem Raj <raj.khem@gmail.com>
Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
Link: https://lore.kernel.org/r/20240311193143.2981310-2-samitolvanen@google.com
Signed-off-by: Palmer Dabbelt <palmer@rivosinc.com>

diff --git a/arch/riscv/include/asm/syscall_wrapper.h b/arch/riscv/include/asm/syscall_wrapper.h
index eeec04b..980094c 100644 (file)
--- a/arch/riscv/include/asm/syscall_wrapper.h
+++ b/arch/riscv/include/asm/syscall_wrapper.h
@@ -12,25 +12,51 @@
 
 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               \
+#ifdef CONFIG_64BIT
+
+#define __SYSCALL_SE_DEFINEx(x, prefix, name, ...)                                     \
+       static long __se_##prefix##name(__MAP(x,__SC_LONG,__VA_ARGS__));                \
+       static long __se_##prefix##name(__MAP(x,__SC_LONG,__VA_ARGS__))
+
+#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)
 
+#else
+/*
+ * Use type aliasing to ensure registers a0-a6 are correctly passed to the syscall
+ * implementation when >word-size arguments are used.
+ */
+#define __SYSCALL_SE_DEFINEx(x, prefix, name, ...)                                     \
+       __diag_push();                                                                  \
+       __diag_ignore(GCC, 8, "-Wattribute-alias",                                      \
+                       "Type aliasing is used to sanitize syscall arguments");         \
+       static long __se_##prefix##name(ulong, ulong, ulong, ulong, ulong, ulong,       \
+                                       ulong)                                          \
+                       __attribute__((alias(__stringify(___se_##prefix##name))));      \
+       __diag_pop();                                                                   \
+       static long noinline ___se_##prefix##name(__MAP(x,__SC_LONG,__VA_ARGS__));      \
+       static long ___se_##prefix##name(__MAP(x,__SC_LONG,__VA_ARGS__))
+
+#define SC_RISCV_REGS_TO_ARGS(x, ...) \
+       regs->orig_a0,regs->a1,regs->a2,regs->a3,regs->a4,regs->a5,regs->a6
+
+#endif /* CONFIG_64BIT */
+
 #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)            \
+       __SYSCALL_SE_DEFINEx(x, compat_sys, name, __VA_ARGS__)                          \
        {                                                                               \
-               return __se_compat_sys##name(SC_RISCV_REGS_TO_ARGS(x,__VA_ARGS__));     \
+               return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));        \
        }                                                                               \
-       static long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))               \
+       asmlinkage long __riscv_compat_sys##name(const struct pt_regs *regs)            \
        {                                                                               \
-               return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));        \
+               return __se_compat_sys##name(SC_RISCV_REGS_TO_ARGS(x,__VA_ARGS__));     \
        }                                                                               \
        static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
 
@@ -51,19 +77,18 @@ asmlinkage long __riscv_sys_ni_syscall(const struct pt_regs *);
 #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__))              \
+       __SYSCALL_SE_DEFINEx(x, sys, name, __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;                                                     \
        }                                                                       \
+       asmlinkage long __riscv_sys##name(const struct pt_regs *regs)           \
+       {                                                                       \
+               return __se_sys##name(SC_RISCV_REGS_TO_ARGS(x,__VA_ARGS__));    \
+       }                                                                       \
        static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
 
 #define SYSCALL_DEFINE0(sname)                                                 \