1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * Copyright (C) 2012 ARM Ltd. 4 */ 5 #ifndef __ASM_SYSCALL_H 6 #define __ASM_SYSCALL_H 7 8 #include <uapi/linux/audit.h> 9 #include <linux/compat.h> 10 #include <linux/err.h> 11 12 typedef long (*syscall_fn_t)(const struct pt_regs *regs); 13 14 extern const syscall_fn_t sys_call_table[]; 15 16 #ifdef CONFIG_COMPAT 17 extern const syscall_fn_t compat_sys_call_table[]; 18 #endif 19 20 static inline int syscall_get_nr(struct task_struct *task, 21 struct pt_regs *regs) 22 { 23 return regs->syscallno; 24 } 25 26 static inline void syscall_rollback(struct task_struct *task, 27 struct pt_regs *regs) 28 { 29 regs->regs[0] = regs->orig_x0; 30 } 31 32 static inline long syscall_get_return_value(struct task_struct *task, 33 struct pt_regs *regs) 34 { 35 unsigned long val = regs->regs[0]; 36 37 if (is_compat_thread(task_thread_info(task))) 38 val = sign_extend64(val, 31); 39 40 return val; 41 } 42 43 static inline long syscall_get_error(struct task_struct *task, 44 struct pt_regs *regs) 45 { 46 unsigned long error = syscall_get_return_value(task, regs); 47 48 return IS_ERR_VALUE(error) ? error : 0; 49 } 50 51 static inline void syscall_set_return_value(struct task_struct *task, 52 struct pt_regs *regs, 53 int error, long val) 54 { 55 if (error) 56 val = error; 57 58 if (is_compat_thread(task_thread_info(task))) 59 val = lower_32_bits(val); 60 61 regs->regs[0] = val; 62 } 63 64 static inline void syscall_set_nr(struct task_struct *task, 65 struct pt_regs *regs, 66 int nr) 67 { 68 regs->syscallno = nr; 69 if (nr == -1) { 70 /* 71 * When the syscall number is set to -1, the syscall will be 72 * skipped. In this case the syscall return value has to be 73 * set explicitly, otherwise the first syscall argument is 74 * returned as the syscall return value. 75 */ 76 syscall_set_return_value(task, regs, -ENOSYS, 0); 77 } 78 } 79 80 static inline void syscall_get_arguments(struct task_struct *task, 81 struct pt_regs *regs, 82 unsigned long *args) 83 { 84 args[0] = regs->orig_x0; 85 args[1] = regs->regs[1]; 86 args[2] = regs->regs[2]; 87 args[3] = regs->regs[3]; 88 args[4] = regs->regs[4]; 89 args[5] = regs->regs[5]; 90 } 91 92 static inline void syscall_set_arguments(struct task_struct *task, 93 struct pt_regs *regs, 94 const unsigned long *args) 95 { 96 regs->regs[0] = args[0]; 97 regs->regs[1] = args[1]; 98 regs->regs[2] = args[2]; 99 regs->regs[3] = args[3]; 100 regs->regs[4] = args[4]; 101 regs->regs[5] = args[5]; 102 103 /* 104 * Also copy the first argument into orig_x0 105 * so that syscall_get_arguments() would return it 106 * instead of the previous value. 107 */ 108 regs->orig_x0 = regs->regs[0]; 109 } 110 111 /* 112 * We don't care about endianness (__AUDIT_ARCH_LE bit) here because 113 * AArch64 has the same system calls both on little- and big- endian. 114 */ 115 static inline int syscall_get_arch(struct task_struct *task) 116 { 117 if (is_compat_thread(task_thread_info(task))) 118 return AUDIT_ARCH_ARM; 119 120 return AUDIT_ARCH_AARCH64; 121 } 122 123 int syscall_trace_enter(struct pt_regs *regs); 124 void syscall_trace_exit(struct pt_regs *regs); 125 126 #endif /* __ASM_SYSCALL_H */ 127