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 ldr lr, [fp, #-4] @ restore lr 115 ldmia sp!, {r0-r3, pc} 116 117ENTRY(ftrace_caller) 118 stmdb sp!, {r0-r3, lr} 119 ldr r1, [fp, #-4] 120 mov r0, lr 121 sub r0, r0, #MCOUNT_INSN_SIZE 122 123 .globl ftrace_call 124ftrace_call: 125 bl ftrace_stub 126 ldr lr, [fp, #-4] @ restore lr 127 ldmia sp!, {r0-r3, pc} 128 129#else 130 131ENTRY(mcount) 132 stmdb sp!, {r0-r3, lr} 133 ldr r0, =ftrace_trace_function 134 ldr r2, [r0] 135 adr r0, ftrace_stub 136 cmp r0, r2 137 bne trace 138 ldr lr, [fp, #-4] @ restore lr 139 ldmia sp!, {r0-r3, pc} 140 141trace: 142 ldr r1, [fp, #-4] @ lr of instrumented routine 143 mov r0, lr 144 sub r0, r0, #MCOUNT_INSN_SIZE 145 mov lr, pc 146 mov pc, r2 147 mov lr, r1 @ restore lr 148 ldmia sp!, {r0-r3, pc} 149 150#endif /* CONFIG_DYNAMIC_FTRACE */ 151 152 .globl ftrace_stub 153ftrace_stub: 154 mov pc, lr 155 156#endif /* CONFIG_FUNCTION_TRACER */ 157 158/*============================================================================= 159 * SWI handler 160 *----------------------------------------------------------------------------- 161 */ 162 163 /* If we're optimising for StrongARM the resulting code won't 164 run on an ARM7 and we can save a couple of instructions. 165 --pb */ 166#ifdef CONFIG_CPU_ARM710 167#define A710(code...) code 168.Larm710bug: 169 ldmia sp, {r0 - lr}^ @ Get calling r0 - lr 170 mov r0, r0 171 add sp, sp, #S_FRAME_SIZE 172 subs pc, lr, #4 173#else 174#define A710(code...) 175#endif 176 177 .align 5 178ENTRY(vector_swi) 179 sub sp, sp, #S_FRAME_SIZE 180 stmia sp, {r0 - r12} @ Calling r0 - r12 181 add r8, sp, #S_PC 182 stmdb r8, {sp, lr}^ @ Calling sp, lr 183 mrs r8, spsr @ called from non-FIQ mode, so ok. 184 str lr, [sp, #S_PC] @ Save calling PC 185 str r8, [sp, #S_PSR] @ Save CPSR 186 str r0, [sp, #S_OLD_R0] @ Save OLD_R0 187 zero_fp 188 189 /* 190 * Get the system call number. 191 */ 192 193#if defined(CONFIG_OABI_COMPAT) 194 195 /* 196 * If we have CONFIG_OABI_COMPAT then we need to look at the swi 197 * value to determine if it is an EABI or an old ABI call. 198 */ 199#ifdef CONFIG_ARM_THUMB 200 tst r8, #PSR_T_BIT 201 movne r10, #0 @ no thumb OABI emulation 202 ldreq r10, [lr, #-4] @ get SWI instruction 203#else 204 ldr r10, [lr, #-4] @ get SWI instruction 205 A710( and ip, r10, #0x0f000000 @ check for SWI ) 206 A710( teq ip, #0x0f000000 ) 207 A710( bne .Larm710bug ) 208#endif 209 210#elif defined(CONFIG_AEABI) 211 212 /* 213 * Pure EABI user space always put syscall number into scno (r7). 214 */ 215 A710( ldr ip, [lr, #-4] @ get SWI instruction ) 216 A710( and ip, ip, #0x0f000000 @ check for SWI ) 217 A710( teq ip, #0x0f000000 ) 218 A710( bne .Larm710bug ) 219 220#elif defined(CONFIG_ARM_THUMB) 221 222 /* Legacy ABI only, possibly thumb mode. */ 223 tst r8, #PSR_T_BIT @ this is SPSR from save_user_regs 224 addne scno, r7, #__NR_SYSCALL_BASE @ put OS number in 225 ldreq scno, [lr, #-4] 226 227#else 228 229 /* Legacy ABI only. */ 230 ldr scno, [lr, #-4] @ get SWI instruction 231 A710( and ip, scno, #0x0f000000 @ check for SWI ) 232 A710( teq ip, #0x0f000000 ) 233 A710( bne .Larm710bug ) 234 235#endif 236 237#ifdef CONFIG_ALIGNMENT_TRAP 238 ldr ip, __cr_alignment 239 ldr ip, [ip] 240 mcr p15, 0, ip, c1, c0 @ update control register 241#endif 242 enable_irq 243 244 get_thread_info tsk 245 adr tbl, sys_call_table @ load syscall table pointer 246 ldr ip, [tsk, #TI_FLAGS] @ check for syscall tracing 247 248#if defined(CONFIG_OABI_COMPAT) 249 /* 250 * If the swi argument is zero, this is an EABI call and we do nothing. 251 * 252 * If this is an old ABI call, get the syscall number into scno and 253 * get the old ABI syscall table address. 254 */ 255 bics r10, r10, #0xff000000 256 eorne scno, r10, #__NR_OABI_SYSCALL_BASE 257 ldrne tbl, =sys_oabi_call_table 258#elif !defined(CONFIG_AEABI) 259 bic scno, scno, #0xff000000 @ mask off SWI op-code 260 eor scno, scno, #__NR_SYSCALL_BASE @ check OS number 261#endif 262 263 stmdb sp!, {r4, r5} @ push fifth and sixth args 264 tst ip, #_TIF_SYSCALL_TRACE @ are we tracing syscalls? 265 bne __sys_trace 266 267 cmp scno, #NR_syscalls @ check upper syscall limit 268 adr lr, ret_fast_syscall @ return address 269 ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine 270 271 add r1, sp, #S_OFF 2722: mov why, #0 @ no longer a real syscall 273 cmp scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE) 274 eor r0, scno, #__NR_SYSCALL_BASE @ put OS number back 275 bcs arm_syscall 276 b sys_ni_syscall @ not private func 277ENDPROC(vector_swi) 278 279 /* 280 * This is the really slow path. We're going to be doing 281 * context switches, and waiting for our parent to respond. 282 */ 283__sys_trace: 284 mov r2, scno 285 add r1, sp, #S_OFF 286 mov r0, #0 @ trace entry [IP = 0] 287 bl syscall_trace 288 289 adr lr, __sys_trace_return @ return address 290 mov scno, r0 @ syscall number (possibly new) 291 add r1, sp, #S_R0 + S_OFF @ pointer to regs 292 cmp scno, #NR_syscalls @ check upper syscall limit 293 ldmccia r1, {r0 - r3} @ have to reload r0 - r3 294 ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine 295 b 2b 296 297__sys_trace_return: 298 str r0, [sp, #S_R0 + S_OFF]! @ save returned r0 299 mov r2, scno 300 mov r1, sp 301 mov r0, #1 @ trace exit [IP = 1] 302 bl syscall_trace 303 b ret_slow_syscall 304 305 .align 5 306#ifdef CONFIG_ALIGNMENT_TRAP 307 .type __cr_alignment, #object 308__cr_alignment: 309 .word cr_alignment 310#endif 311 .ltorg 312 313/* 314 * This is the syscall table declaration for native ABI syscalls. 315 * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall. 316 */ 317#define ABI(native, compat) native 318#ifdef CONFIG_AEABI 319#define OBSOLETE(syscall) sys_ni_syscall 320#else 321#define OBSOLETE(syscall) syscall 322#endif 323 324 .type sys_call_table, #object 325ENTRY(sys_call_table) 326#include "calls.S" 327#undef ABI 328#undef OBSOLETE 329 330/*============================================================================ 331 * Special system call wrappers 332 */ 333@ r0 = syscall number 334@ r8 = syscall table 335sys_syscall: 336 bic scno, r0, #__NR_OABI_SYSCALL_BASE 337 cmp scno, #__NR_syscall - __NR_SYSCALL_BASE 338 cmpne scno, #NR_syscalls @ check range 339 stmloia sp, {r5, r6} @ shuffle args 340 movlo r0, r1 341 movlo r1, r2 342 movlo r2, r3 343 movlo r3, r4 344 ldrlo pc, [tbl, scno, lsl #2] 345 b sys_ni_syscall 346ENDPROC(sys_syscall) 347 348sys_fork_wrapper: 349 add r0, sp, #S_OFF 350 b sys_fork 351ENDPROC(sys_fork_wrapper) 352 353sys_vfork_wrapper: 354 add r0, sp, #S_OFF 355 b sys_vfork 356ENDPROC(sys_vfork_wrapper) 357 358sys_execve_wrapper: 359 add r3, sp, #S_OFF 360 b sys_execve 361ENDPROC(sys_execve_wrapper) 362 363sys_clone_wrapper: 364 add ip, sp, #S_OFF 365 str ip, [sp, #4] 366 b sys_clone 367ENDPROC(sys_clone_wrapper) 368 369sys_sigsuspend_wrapper: 370 add r3, sp, #S_OFF 371 b sys_sigsuspend 372ENDPROC(sys_sigsuspend_wrapper) 373 374sys_rt_sigsuspend_wrapper: 375 add r2, sp, #S_OFF 376 b sys_rt_sigsuspend 377ENDPROC(sys_rt_sigsuspend_wrapper) 378 379sys_sigreturn_wrapper: 380 add r0, sp, #S_OFF 381 b sys_sigreturn 382ENDPROC(sys_sigreturn_wrapper) 383 384sys_rt_sigreturn_wrapper: 385 add r0, sp, #S_OFF 386 b sys_rt_sigreturn 387ENDPROC(sys_rt_sigreturn_wrapper) 388 389sys_sigaltstack_wrapper: 390 ldr r2, [sp, #S_OFF + S_SP] 391 b do_sigaltstack 392ENDPROC(sys_sigaltstack_wrapper) 393 394sys_statfs64_wrapper: 395 teq r1, #88 396 moveq r1, #84 397 b sys_statfs64 398ENDPROC(sys_statfs64_wrapper) 399 400sys_fstatfs64_wrapper: 401 teq r1, #88 402 moveq r1, #84 403 b sys_fstatfs64 404ENDPROC(sys_fstatfs64_wrapper) 405 406/* 407 * Note: off_4k (r5) is always units of 4K. If we can't do the requested 408 * offset, we return EINVAL. 409 */ 410sys_mmap2: 411#if PAGE_SHIFT > 12 412 tst r5, #PGOFF_MASK 413 moveq r5, r5, lsr #PAGE_SHIFT - 12 414 streq r5, [sp, #4] 415 beq do_mmap2 416 mov r0, #-EINVAL 417 mov pc, lr 418#else 419 str r5, [sp, #4] 420 b do_mmap2 421#endif 422ENDPROC(sys_mmap2) 423 424ENTRY(pabort_ifar) 425 mrc p15, 0, r0, cr6, cr0, 2 426ENTRY(pabort_noifar) 427 mov pc, lr 428ENDPROC(pabort_ifar) 429ENDPROC(pabort_noifar) 430 431#ifdef CONFIG_OABI_COMPAT 432 433/* 434 * These are syscalls with argument register differences 435 */ 436 437sys_oabi_pread64: 438 stmia sp, {r3, r4} 439 b sys_pread64 440ENDPROC(sys_oabi_pread64) 441 442sys_oabi_pwrite64: 443 stmia sp, {r3, r4} 444 b sys_pwrite64 445ENDPROC(sys_oabi_pwrite64) 446 447sys_oabi_truncate64: 448 mov r3, r2 449 mov r2, r1 450 b sys_truncate64 451ENDPROC(sys_oabi_truncate64) 452 453sys_oabi_ftruncate64: 454 mov r3, r2 455 mov r2, r1 456 b sys_ftruncate64 457ENDPROC(sys_oabi_ftruncate64) 458 459sys_oabi_readahead: 460 str r3, [sp] 461 mov r3, r2 462 mov r2, r1 463 b sys_readahead 464ENDPROC(sys_oabi_readahead) 465 466/* 467 * Let's declare a second syscall table for old ABI binaries 468 * using the compatibility syscall entries. 469 */ 470#define ABI(native, compat) compat 471#define OBSOLETE(syscall) syscall 472 473 .type sys_oabi_call_table, #object 474ENTRY(sys_oabi_call_table) 475#include "calls.S" 476#undef ABI 477#undef OBSOLETE 478 479#endif 480 481