1/* 2 * linux/arch/arm/kernel/entry-common.S 3 * 4 * Copyright (C) 2000 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11#include <asm/unistd.h> 12#include <asm/ftrace.h> 13#include <mach/entry-macro.S> 14 15#include "entry-header.S" 16 17 18 .align 5 19/* 20 * This is the fast syscall return path. We do as little as 21 * possible here, and this includes saving r0 back into the SVC 22 * stack. 23 */ 24ret_fast_syscall: 25 disable_irq @ disable interrupts 26 ldr r1, [tsk, #TI_FLAGS] 27 tst r1, #_TIF_WORK_MASK 28 bne fast_work_pending 29 30 /* perform architecture specific actions before user return */ 31 arch_ret_to_user r1, lr 32 33 @ fast_restore_user_regs 34 ldr r1, [sp, #S_OFF + S_PSR] @ get calling cpsr 35 ldr lr, [sp, #S_OFF + S_PC]! @ get pc 36 msr spsr_cxsf, r1 @ save in spsr_svc 37 ldmdb sp, {r1 - lr}^ @ get calling r1 - lr 38 mov r0, r0 39 add sp, sp, #S_FRAME_SIZE - S_PC 40 movs pc, lr @ return & move spsr_svc into cpsr 41 42/* 43 * Ok, we need to do extra processing, enter the slow path. 44 */ 45fast_work_pending: 46 str r0, [sp, #S_R0+S_OFF]! @ returned r0 47work_pending: 48 tst r1, #_TIF_NEED_RESCHED 49 bne work_resched 50 tst r1, #_TIF_SIGPENDING 51 beq no_work_pending 52 mov r0, sp @ 'regs' 53 mov r2, why @ 'syscall' 54 bl do_notify_resume 55 b ret_slow_syscall @ Check work again 56 57work_resched: 58 bl schedule 59/* 60 * "slow" syscall return path. "why" tells us if this was a real syscall. 61 */ 62ENTRY(ret_to_user) 63ret_slow_syscall: 64 disable_irq @ disable interrupts 65 ldr r1, [tsk, #TI_FLAGS] 66 tst r1, #_TIF_WORK_MASK 67 bne work_pending 68no_work_pending: 69 /* perform architecture specific actions before user return */ 70 arch_ret_to_user r1, lr 71 72 @ slow_restore_user_regs 73 ldr r1, [sp, #S_PSR] @ get calling cpsr 74 ldr lr, [sp, #S_PC]! @ get pc 75 msr spsr_cxsf, r1 @ save in spsr_svc 76 ldmdb sp, {r0 - lr}^ @ get calling r0 - lr 77 mov r0, r0 78 add sp, sp, #S_FRAME_SIZE - S_PC 79 movs pc, lr @ return & move spsr_svc into cpsr 80ENDPROC(ret_to_user) 81 82/* 83 * This is how we return from a fork. 84 */ 85ENTRY(ret_from_fork) 86 bl schedule_tail 87 get_thread_info tsk 88 ldr r1, [tsk, #TI_FLAGS] @ check for syscall tracing 89 mov why, #1 90 tst r1, #_TIF_SYSCALL_TRACE @ are we tracing syscalls? 91 beq ret_slow_syscall 92 mov r1, sp 93 mov r0, #1 @ trace exit [IP = 1] 94 bl syscall_trace 95 b ret_slow_syscall 96ENDPROC(ret_from_fork) 97 98 .equ NR_syscalls,0 99#define CALL(x) .equ NR_syscalls,NR_syscalls+1 100#include "calls.S" 101#undef CALL 102#define CALL(x) .long x 103 104#ifdef CONFIG_FUNCTION_TRACER 105#ifdef CONFIG_DYNAMIC_FTRACE 106ENTRY(mcount) 107 stmdb sp!, {r0-r3, lr} 108 mov r0, lr 109 sub r0, r0, #MCOUNT_INSN_SIZE 110 111 .globl mcount_call 112mcount_call: 113 bl ftrace_stub 114 ldmia sp!, {r0-r3, pc} 115 116ENTRY(ftrace_caller) 117 stmdb sp!, {r0-r3, lr} 118 ldr r1, [fp, #-4] 119 mov r0, lr 120 sub r0, r0, #MCOUNT_INSN_SIZE 121 122 .globl ftrace_call 123ftrace_call: 124 bl ftrace_stub 125 ldmia sp!, {r0-r3, pc} 126 127#else 128 129ENTRY(mcount) 130 stmdb sp!, {r0-r3, lr} 131 ldr r0, =ftrace_trace_function 132 ldr r2, [r0] 133 adr r0, ftrace_stub 134 cmp r0, r2 135 bne trace 136 ldmia sp!, {r0-r3, pc} 137 138trace: 139 ldr r1, [fp, #-4] 140 mov r0, lr 141 sub r0, r0, #MCOUNT_INSN_SIZE 142 mov lr, pc 143 mov pc, r2 144 ldmia sp!, {r0-r3, pc} 145 146#endif /* CONFIG_DYNAMIC_FTRACE */ 147 148 .globl ftrace_stub 149ftrace_stub: 150 mov pc, lr 151 152#endif /* CONFIG_FUNCTION_TRACER */ 153 154/*============================================================================= 155 * SWI handler 156 *----------------------------------------------------------------------------- 157 */ 158 159 /* If we're optimising for StrongARM the resulting code won't 160 run on an ARM7 and we can save a couple of instructions. 161 --pb */ 162#ifdef CONFIG_CPU_ARM710 163#define A710(code...) code 164.Larm710bug: 165 ldmia sp, {r0 - lr}^ @ Get calling r0 - lr 166 mov r0, r0 167 add sp, sp, #S_FRAME_SIZE 168 subs pc, lr, #4 169#else 170#define A710(code...) 171#endif 172 173 .align 5 174ENTRY(vector_swi) 175 sub sp, sp, #S_FRAME_SIZE 176 stmia sp, {r0 - r12} @ Calling r0 - r12 177 add r8, sp, #S_PC 178 stmdb r8, {sp, lr}^ @ Calling sp, lr 179 mrs r8, spsr @ called from non-FIQ mode, so ok. 180 str lr, [sp, #S_PC] @ Save calling PC 181 str r8, [sp, #S_PSR] @ Save CPSR 182 str r0, [sp, #S_OLD_R0] @ Save OLD_R0 183 zero_fp 184 185 /* 186 * Get the system call number. 187 */ 188 189#if defined(CONFIG_OABI_COMPAT) 190 191 /* 192 * If we have CONFIG_OABI_COMPAT then we need to look at the swi 193 * value to determine if it is an EABI or an old ABI call. 194 */ 195#ifdef CONFIG_ARM_THUMB 196 tst r8, #PSR_T_BIT 197 movne r10, #0 @ no thumb OABI emulation 198 ldreq r10, [lr, #-4] @ get SWI instruction 199#else 200 ldr r10, [lr, #-4] @ get SWI instruction 201 A710( and ip, r10, #0x0f000000 @ check for SWI ) 202 A710( teq ip, #0x0f000000 ) 203 A710( bne .Larm710bug ) 204#endif 205 206#elif defined(CONFIG_AEABI) 207 208 /* 209 * Pure EABI user space always put syscall number into scno (r7). 210 */ 211 A710( ldr ip, [lr, #-4] @ get SWI instruction ) 212 A710( and ip, ip, #0x0f000000 @ check for SWI ) 213 A710( teq ip, #0x0f000000 ) 214 A710( bne .Larm710bug ) 215 216#elif defined(CONFIG_ARM_THUMB) 217 218 /* Legacy ABI only, possibly thumb mode. */ 219 tst r8, #PSR_T_BIT @ this is SPSR from save_user_regs 220 addne scno, r7, #__NR_SYSCALL_BASE @ put OS number in 221 ldreq scno, [lr, #-4] 222 223#else 224 225 /* Legacy ABI only. */ 226 ldr scno, [lr, #-4] @ get SWI instruction 227 A710( and ip, scno, #0x0f000000 @ check for SWI ) 228 A710( teq ip, #0x0f000000 ) 229 A710( bne .Larm710bug ) 230 231#endif 232 233#ifdef CONFIG_ALIGNMENT_TRAP 234 ldr ip, __cr_alignment 235 ldr ip, [ip] 236 mcr p15, 0, ip, c1, c0 @ update control register 237#endif 238 enable_irq 239 240 get_thread_info tsk 241 adr tbl, sys_call_table @ load syscall table pointer 242 ldr ip, [tsk, #TI_FLAGS] @ check for syscall tracing 243 244#if defined(CONFIG_OABI_COMPAT) 245 /* 246 * If the swi argument is zero, this is an EABI call and we do nothing. 247 * 248 * If this is an old ABI call, get the syscall number into scno and 249 * get the old ABI syscall table address. 250 */ 251 bics r10, r10, #0xff000000 252 eorne scno, r10, #__NR_OABI_SYSCALL_BASE 253 ldrne tbl, =sys_oabi_call_table 254#elif !defined(CONFIG_AEABI) 255 bic scno, scno, #0xff000000 @ mask off SWI op-code 256 eor scno, scno, #__NR_SYSCALL_BASE @ check OS number 257#endif 258 259 stmdb sp!, {r4, r5} @ push fifth and sixth args 260 tst ip, #_TIF_SYSCALL_TRACE @ are we tracing syscalls? 261 bne __sys_trace 262 263 cmp scno, #NR_syscalls @ check upper syscall limit 264 adr lr, ret_fast_syscall @ return address 265 ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine 266 267 add r1, sp, #S_OFF 2682: mov why, #0 @ no longer a real syscall 269 cmp scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE) 270 eor r0, scno, #__NR_SYSCALL_BASE @ put OS number back 271 bcs arm_syscall 272 b sys_ni_syscall @ not private func 273ENDPROC(vector_swi) 274 275 /* 276 * This is the really slow path. We're going to be doing 277 * context switches, and waiting for our parent to respond. 278 */ 279__sys_trace: 280 mov r2, scno 281 add r1, sp, #S_OFF 282 mov r0, #0 @ trace entry [IP = 0] 283 bl syscall_trace 284 285 adr lr, __sys_trace_return @ return address 286 mov scno, r0 @ syscall number (possibly new) 287 add r1, sp, #S_R0 + S_OFF @ pointer to regs 288 cmp scno, #NR_syscalls @ check upper syscall limit 289 ldmccia r1, {r0 - r3} @ have to reload r0 - r3 290 ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine 291 b 2b 292 293__sys_trace_return: 294 str r0, [sp, #S_R0 + S_OFF]! @ save returned r0 295 mov r2, scno 296 mov r1, sp 297 mov r0, #1 @ trace exit [IP = 1] 298 bl syscall_trace 299 b ret_slow_syscall 300 301 .align 5 302#ifdef CONFIG_ALIGNMENT_TRAP 303 .type __cr_alignment, #object 304__cr_alignment: 305 .word cr_alignment 306#endif 307 .ltorg 308 309/* 310 * This is the syscall table declaration for native ABI syscalls. 311 * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall. 312 */ 313#define ABI(native, compat) native 314#ifdef CONFIG_AEABI 315#define OBSOLETE(syscall) sys_ni_syscall 316#else 317#define OBSOLETE(syscall) syscall 318#endif 319 320 .type sys_call_table, #object 321ENTRY(sys_call_table) 322#include "calls.S" 323#undef ABI 324#undef OBSOLETE 325 326/*============================================================================ 327 * Special system call wrappers 328 */ 329@ r0 = syscall number 330@ r8 = syscall table 331sys_syscall: 332 bic scno, r0, #__NR_OABI_SYSCALL_BASE 333 cmp scno, #__NR_syscall - __NR_SYSCALL_BASE 334 cmpne scno, #NR_syscalls @ check range 335 stmloia sp, {r5, r6} @ shuffle args 336 movlo r0, r1 337 movlo r1, r2 338 movlo r2, r3 339 movlo r3, r4 340 ldrlo pc, [tbl, scno, lsl #2] 341 b sys_ni_syscall 342ENDPROC(sys_syscall) 343 344sys_fork_wrapper: 345 add r0, sp, #S_OFF 346 b sys_fork 347ENDPROC(sys_fork_wrapper) 348 349sys_vfork_wrapper: 350 add r0, sp, #S_OFF 351 b sys_vfork 352ENDPROC(sys_vfork_wrapper) 353 354sys_execve_wrapper: 355 add r3, sp, #S_OFF 356 b sys_execve 357ENDPROC(sys_execve_wrapper) 358 359sys_clone_wrapper: 360 add ip, sp, #S_OFF 361 str ip, [sp, #4] 362 b sys_clone 363ENDPROC(sys_clone_wrapper) 364 365sys_sigsuspend_wrapper: 366 add r3, sp, #S_OFF 367 b sys_sigsuspend 368ENDPROC(sys_sigsuspend_wrapper) 369 370sys_rt_sigsuspend_wrapper: 371 add r2, sp, #S_OFF 372 b sys_rt_sigsuspend 373ENDPROC(sys_rt_sigsuspend_wrapper) 374 375sys_sigreturn_wrapper: 376 add r0, sp, #S_OFF 377 b sys_sigreturn 378ENDPROC(sys_sigreturn_wrapper) 379 380sys_rt_sigreturn_wrapper: 381 add r0, sp, #S_OFF 382 b sys_rt_sigreturn 383ENDPROC(sys_rt_sigreturn_wrapper) 384 385sys_sigaltstack_wrapper: 386 ldr r2, [sp, #S_OFF + S_SP] 387 b do_sigaltstack 388ENDPROC(sys_sigaltstack_wrapper) 389 390sys_statfs64_wrapper: 391 teq r1, #88 392 moveq r1, #84 393 b sys_statfs64 394ENDPROC(sys_statfs64_wrapper) 395 396sys_fstatfs64_wrapper: 397 teq r1, #88 398 moveq r1, #84 399 b sys_fstatfs64 400ENDPROC(sys_fstatfs64_wrapper) 401 402/* 403 * Note: off_4k (r5) is always units of 4K. If we can't do the requested 404 * offset, we return EINVAL. 405 */ 406sys_mmap2: 407#if PAGE_SHIFT > 12 408 tst r5, #PGOFF_MASK 409 moveq r5, r5, lsr #PAGE_SHIFT - 12 410 streq r5, [sp, #4] 411 beq do_mmap2 412 mov r0, #-EINVAL 413 mov pc, lr 414#else 415 str r5, [sp, #4] 416 b do_mmap2 417#endif 418ENDPROC(sys_mmap2) 419 420ENTRY(pabort_ifar) 421 mrc p15, 0, r0, cr6, cr0, 2 422ENTRY(pabort_noifar) 423 mov pc, lr 424ENDPROC(pabort_ifar) 425ENDPROC(pabort_noifar) 426 427#ifdef CONFIG_OABI_COMPAT 428 429/* 430 * These are syscalls with argument register differences 431 */ 432 433sys_oabi_pread64: 434 stmia sp, {r3, r4} 435 b sys_pread64 436ENDPROC(sys_oabi_pread64) 437 438sys_oabi_pwrite64: 439 stmia sp, {r3, r4} 440 b sys_pwrite64 441ENDPROC(sys_oabi_pwrite64) 442 443sys_oabi_truncate64: 444 mov r3, r2 445 mov r2, r1 446 b sys_truncate64 447ENDPROC(sys_oabi_truncate64) 448 449sys_oabi_ftruncate64: 450 mov r3, r2 451 mov r2, r1 452 b sys_ftruncate64 453ENDPROC(sys_oabi_ftruncate64) 454 455sys_oabi_readahead: 456 str r3, [sp] 457 mov r3, r2 458 mov r2, r1 459 b sys_readahead 460ENDPROC(sys_oabi_readahead) 461 462/* 463 * Let's declare a second syscall table for old ABI binaries 464 * using the compatibility syscall entries. 465 */ 466#define ABI(native, compat) compat 467#define OBSOLETE(syscall) syscall 468 469 .type sys_oabi_call_table, #object 470ENTRY(sys_oabi_call_table) 471#include "calls.S" 472#undef ABI 473#undef OBSOLETE 474 475#endif 476 477