1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1995-99, 2000- 02, 06 Ralf Baechle <ralf@linux-mips.org> 7 * Copyright (C) 2001 MIPS Technologies, Inc. 8 * Copyright (C) 2004 Thiemo Seufer 9 * Copyright (C) 2014 Imagination Technologies Ltd. 10 */ 11 #include <linux/errno.h> 12 #include <asm/asm.h> 13 #include <asm/asmmacro.h> 14 #include <asm/irqflags.h> 15 #include <asm/mipsregs.h> 16 #include <asm/regdef.h> 17 #include <asm/stackframe.h> 18 #include <asm/isadep.h> 19 #include <asm/sysmips.h> 20 #include <asm/thread_info.h> 21 #include <asm/unistd.h> 22 #include <asm/war.h> 23 #include <asm/asm-offsets.h> 24 25 .align 5 26 NESTED(handle_sys, PT_SIZE, sp) 27 .set noat 28 SAVE_SOME 29 TRACE_IRQS_ON_RELOAD 30 STI 31 .set at 32 33 lw t1, PT_EPC(sp) # skip syscall on return 34 35 addiu t1, 4 # skip to next instruction 36 sw t1, PT_EPC(sp) 37 38 sw a3, PT_R26(sp) # save a3 for syscall restarting 39 40 /* 41 * More than four arguments. Try to deal with it by copying the 42 * stack arguments from the user stack to the kernel stack. 43 * This Sucks (TM). 44 */ 45 lw t0, PT_R29(sp) # get old user stack pointer 46 47 /* 48 * We intentionally keep the kernel stack a little below the top of 49 * userspace so we don't have to do a slower byte accurate check here. 50 */ 51 lw t5, TI_ADDR_LIMIT($28) 52 addu t4, t0, 32 53 and t5, t4 54 bltz t5, bad_stack # -> sp is bad 55 56 /* 57 * Ok, copy the args from the luser stack to the kernel stack. 58 */ 59 60 .set push 61 .set noreorder 62 .set nomacro 63 64 load_a4: user_lw(t5, 16(t0)) # argument #5 from usp 65 load_a5: user_lw(t6, 20(t0)) # argument #6 from usp 66 load_a6: user_lw(t7, 24(t0)) # argument #7 from usp 67 load_a7: user_lw(t8, 28(t0)) # argument #8 from usp 68 loads_done: 69 70 sw t5, 16(sp) # argument #5 to ksp 71 sw t6, 20(sp) # argument #6 to ksp 72 sw t7, 24(sp) # argument #7 to ksp 73 sw t8, 28(sp) # argument #8 to ksp 74 .set pop 75 76 .section __ex_table,"a" 77 PTR load_a4, bad_stack_a4 78 PTR load_a5, bad_stack_a5 79 PTR load_a6, bad_stack_a6 80 PTR load_a7, bad_stack_a7 81 .previous 82 83 lw t0, TI_FLAGS($28) # syscall tracing enabled? 84 li t1, _TIF_WORK_SYSCALL_ENTRY 85 and t0, t1 86 bnez t0, syscall_trace_entry # -> yes 87 syscall_common: 88 subu v0, v0, __NR_O32_Linux # check syscall number 89 sltiu t0, v0, __NR_O32_Linux_syscalls 90 beqz t0, illegal_syscall 91 92 sll t0, v0, 2 93 la t1, sys_call_table 94 addu t1, t0 95 lw t2, (t1) # syscall routine 96 97 beqz t2, illegal_syscall 98 99 jalr t2 # Do The Real Thing (TM) 100 101 li t0, -EMAXERRNO - 1 # error? 102 sltu t0, t0, v0 103 sw t0, PT_R7(sp) # set error flag 104 beqz t0, 1f 105 106 lw t1, PT_R2(sp) # syscall number 107 negu v0 # error 108 sw t1, PT_R0(sp) # save it for syscall restarting 109 1: sw v0, PT_R2(sp) # result 110 111 o32_syscall_exit: 112 j syscall_exit_partial 113 114 /* ------------------------------------------------------------------------ */ 115 116 syscall_trace_entry: 117 SAVE_STATIC 118 move a0, sp 119 120 /* 121 * syscall number is in v0 unless we called syscall(__NR_###) 122 * where the real syscall number is in a0 123 */ 124 move a1, v0 125 subu t2, v0, __NR_O32_Linux 126 bnez t2, 1f /* __NR_syscall at offset 0 */ 127 lw a1, PT_R4(sp) 128 129 1: jal syscall_trace_enter 130 131 bltz v0, 1f # seccomp failed? Skip syscall 132 133 RESTORE_STATIC 134 lw v0, PT_R2(sp) # Restore syscall (maybe modified) 135 lw a0, PT_R4(sp) # Restore argument registers 136 lw a1, PT_R5(sp) 137 lw a2, PT_R6(sp) 138 lw a3, PT_R7(sp) 139 j syscall_common 140 141 1: j syscall_exit 142 143 /* ------------------------------------------------------------------------ */ 144 145 /* 146 * Our open-coded access area sanity test for the stack pointer 147 * failed. We probably should handle this case a bit more drastic. 148 */ 149 bad_stack: 150 li v0, EFAULT 151 sw v0, PT_R2(sp) 152 li t0, 1 # set error flag 153 sw t0, PT_R7(sp) 154 j o32_syscall_exit 155 156 bad_stack_a4: 157 li t5, 0 158 b load_a5 159 160 bad_stack_a5: 161 li t6, 0 162 b load_a6 163 164 bad_stack_a6: 165 li t7, 0 166 b load_a7 167 168 bad_stack_a7: 169 li t8, 0 170 b loads_done 171 172 /* 173 * The system call does not exist in this kernel 174 */ 175 illegal_syscall: 176 li v0, ENOSYS # error 177 sw v0, PT_R2(sp) 178 li t0, 1 # set error flag 179 sw t0, PT_R7(sp) 180 j o32_syscall_exit 181 END(handle_sys) 182 183 LEAF(sys_syscall) 184 subu t0, a0, __NR_O32_Linux # check syscall number 185 sltiu v0, t0, __NR_O32_Linux_syscalls 186 beqz t0, einval # do not recurse 187 sll t1, t0, 2 188 beqz v0, einval 189 lw t2, sys_call_table(t1) # syscall routine 190 191 move a0, a1 # shift argument registers 192 move a1, a2 193 move a2, a3 194 lw a3, 16(sp) 195 lw t4, 20(sp) 196 lw t5, 24(sp) 197 lw t6, 28(sp) 198 sw t4, 16(sp) 199 sw t5, 20(sp) 200 sw t6, 24(sp) 201 jr t2 202 /* Unreached */ 203 204 einval: li v0, -ENOSYS 205 jr ra 206 END(sys_syscall) 207 208 #ifdef CONFIG_MIPS_MT_FPAFF 209 /* 210 * For FPU affinity scheduling on MIPS MT processors, we need to 211 * intercept sys_sched_xxxaffinity() calls until we get a proper hook 212 * in kernel/sched/core.c. Considered only temporary we only support 213 * these hooks for the 32-bit kernel - there is no MIPS64 MT processor 214 * atm. 215 */ 216 #define sys_sched_setaffinity mipsmt_sys_sched_setaffinity 217 #define sys_sched_getaffinity mipsmt_sys_sched_getaffinity 218 #endif /* CONFIG_MIPS_MT_FPAFF */ 219 220 #define __SYSCALL(nr, entry) PTR entry 221 .align 2 222 .type sys_call_table, @object 223 EXPORT(sys_call_table) 224 #include <asm/syscall_table_32_o32.h> 225 #undef __SYSCALL 226