11da177e4SLinus Torvalds/* 21da177e4SLinus Torvalds * linux/arch/arm/kernel/entry-common.S 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2000 Russell King 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 71da177e4SLinus Torvalds * it under the terms of the GNU General Public License version 2 as 81da177e4SLinus Torvalds * published by the Free Software Foundation. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds 111da177e4SLinus Torvalds#include <asm/unistd.h> 12395a59d0SAbhishek Sagar#include <asm/ftrace.h> 13a09e64fbSRussell King#include <mach/entry-macro.S> 14c4c5716eSCatalin Marinas#include <asm/unwind.h> 151da177e4SLinus Torvalds 161da177e4SLinus Torvalds#include "entry-header.S" 171da177e4SLinus Torvalds 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds .align 5 201da177e4SLinus Torvalds/* 211da177e4SLinus Torvalds * This is the fast syscall return path. We do as little as 221da177e4SLinus Torvalds * possible here, and this includes saving r0 back into the SVC 231da177e4SLinus Torvalds * stack. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvaldsret_fast_syscall: 26c4c5716eSCatalin Marinas UNWIND(.fnstart ) 27c4c5716eSCatalin Marinas UNWIND(.cantunwind ) 281ec42c0cSRussell King disable_irq @ disable interrupts 291da177e4SLinus Torvalds ldr r1, [tsk, #TI_FLAGS] 301da177e4SLinus Torvalds tst r1, #_TIF_WORK_MASK 311da177e4SLinus Torvalds bne fast_work_pending 32f4dc9a4cSRussell King 33f80dff9dSDan Williams /* perform architecture specific actions before user return */ 34f80dff9dSDan Williams arch_ret_to_user r1, lr 35f80dff9dSDan Williams 36b86040a5SCatalin Marinas restore_user_regs fast = 1, offset = S_OFF 37c4c5716eSCatalin Marinas UNWIND(.fnend ) 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds/* 401da177e4SLinus Torvalds * Ok, we need to do extra processing, enter the slow path. 411da177e4SLinus Torvalds */ 421da177e4SLinus Torvaldsfast_work_pending: 431da177e4SLinus Torvalds str r0, [sp, #S_R0+S_OFF]! @ returned r0 441da177e4SLinus Torvaldswork_pending: 451da177e4SLinus Torvalds tst r1, #_TIF_NEED_RESCHED 461da177e4SLinus Torvalds bne work_resched 47d0420c83SDavid Howells tst r1, #_TIF_SIGPENDING|_TIF_NOTIFY_RESUME 481da177e4SLinus Torvalds beq no_work_pending 491da177e4SLinus Torvalds mov r0, sp @ 'regs' 501da177e4SLinus Torvalds mov r2, why @ 'syscall' 51b2b163bbSRussell King tst r1, #_TIF_SIGPENDING @ delivering a signal? 52b2b163bbSRussell King movne why, #0 @ prevent further restarts 531da177e4SLinus Torvalds bl do_notify_resume 54a6c61e9dSDaniel Jacobowitz b ret_slow_syscall @ Check work again 551da177e4SLinus Torvalds 561da177e4SLinus Torvaldswork_resched: 571da177e4SLinus Torvalds bl schedule 581da177e4SLinus Torvalds/* 591da177e4SLinus Torvalds * "slow" syscall return path. "why" tells us if this was a real syscall. 601da177e4SLinus Torvalds */ 611da177e4SLinus TorvaldsENTRY(ret_to_user) 621da177e4SLinus Torvaldsret_slow_syscall: 631ec42c0cSRussell King disable_irq @ disable interrupts 641da177e4SLinus Torvalds ldr r1, [tsk, #TI_FLAGS] 651da177e4SLinus Torvalds tst r1, #_TIF_WORK_MASK 661da177e4SLinus Torvalds bne work_pending 671da177e4SLinus Torvaldsno_work_pending: 68f80dff9dSDan Williams /* perform architecture specific actions before user return */ 69f80dff9dSDan Williams arch_ret_to_user r1, lr 70f80dff9dSDan Williams 71b86040a5SCatalin Marinas restore_user_regs fast = 0, offset = 0 7293ed3970SCatalin MarinasENDPROC(ret_to_user) 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds/* 751da177e4SLinus Torvalds * This is how we return from a fork. 761da177e4SLinus Torvalds */ 771da177e4SLinus TorvaldsENTRY(ret_from_fork) 781da177e4SLinus Torvalds bl schedule_tail 791da177e4SLinus Torvalds get_thread_info tsk 801da177e4SLinus Torvalds ldr r1, [tsk, #TI_FLAGS] @ check for syscall tracing 811da177e4SLinus Torvalds mov why, #1 821da177e4SLinus Torvalds tst r1, #_TIF_SYSCALL_TRACE @ are we tracing syscalls? 831da177e4SLinus Torvalds beq ret_slow_syscall 841da177e4SLinus Torvalds mov r1, sp 851da177e4SLinus Torvalds mov r0, #1 @ trace exit [IP = 1] 861da177e4SLinus Torvalds bl syscall_trace 871da177e4SLinus Torvalds b ret_slow_syscall 8893ed3970SCatalin MarinasENDPROC(ret_from_fork) 891da177e4SLinus Torvalds 90fa1b4f91SAl Viro .equ NR_syscalls,0 91fa1b4f91SAl Viro#define CALL(x) .equ NR_syscalls,NR_syscalls+1 921da177e4SLinus Torvalds#include "calls.S" 93fa1b4f91SAl Viro#undef CALL 94fa1b4f91SAl Viro#define CALL(x) .long x 951da177e4SLinus Torvalds 96606576ceSSteven Rostedt#ifdef CONFIG_FUNCTION_TRACER 97686ff228SRabin Vincent/* 98686ff228SRabin Vincent * When compiling with -pg, gcc inserts a call to the mcount routine at the 99686ff228SRabin Vincent * start of every function. In mcount, apart from the function's address (in 100686ff228SRabin Vincent * lr), we need to get hold of the function's caller's address. 101686ff228SRabin Vincent * 102686ff228SRabin Vincent * Older GCCs (pre-4.4) inserted a call to a routine called mcount like this: 103686ff228SRabin Vincent * 104686ff228SRabin Vincent * bl mcount 105686ff228SRabin Vincent * 106686ff228SRabin Vincent * These versions have the limitation that in order for the mcount routine to 107686ff228SRabin Vincent * be able to determine the function's caller's address, an APCS-style frame 108686ff228SRabin Vincent * pointer (which is set up with something like the code below) is required. 109686ff228SRabin Vincent * 110686ff228SRabin Vincent * mov ip, sp 111686ff228SRabin Vincent * push {fp, ip, lr, pc} 112686ff228SRabin Vincent * sub fp, ip, #4 113686ff228SRabin Vincent * 114686ff228SRabin Vincent * With EABI, these frame pointers are not available unless -mapcs-frame is 115686ff228SRabin Vincent * specified, and if building as Thumb-2, not even then. 116686ff228SRabin Vincent * 117686ff228SRabin Vincent * Newer GCCs (4.4+) solve this problem by introducing a new version of mcount, 118686ff228SRabin Vincent * with call sites like: 119686ff228SRabin Vincent * 120686ff228SRabin Vincent * push {lr} 121686ff228SRabin Vincent * bl __gnu_mcount_nc 122686ff228SRabin Vincent * 123686ff228SRabin Vincent * With these compilers, frame pointers are not necessary. 124686ff228SRabin Vincent * 125686ff228SRabin Vincent * mcount can be thought of as a function called in the middle of a subroutine 126686ff228SRabin Vincent * call. As such, it needs to be transparent for both the caller and the 127686ff228SRabin Vincent * callee: the original lr needs to be restored when leaving mcount, and no 128686ff228SRabin Vincent * registers should be clobbered. (In the __gnu_mcount_nc implementation, we 129686ff228SRabin Vincent * clobber the ip register. This is OK because the ARM calling convention 130686ff228SRabin Vincent * allows it to be clobbered in subroutines and doesn't use it to hold 131686ff228SRabin Vincent * parameters.) 1323b6c223bSRabin Vincent * 1333b6c223bSRabin Vincent * When using dynamic ftrace, we patch out the mcount call by a "mov r0, r0" 1343b6c223bSRabin Vincent * for the mcount case, and a "pop {lr}" for the __gnu_mcount_nc case (see 1353b6c223bSRabin Vincent * arch/arm/kernel/ftrace.c). 136686ff228SRabin Vincent */ 13709bfafacSRabin Vincent 13809bfafacSRabin Vincent#ifndef CONFIG_OLD_MCOUNT 13909bfafacSRabin Vincent#if (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4)) 14009bfafacSRabin Vincent#error Ftrace requires CONFIG_FRAME_POINTER=y with GCC older than 4.4.0. 14109bfafacSRabin Vincent#endif 14209bfafacSRabin Vincent#endif 14309bfafacSRabin Vincent 144d3b9dc9dSRabin Vincent.macro __mcount suffix 145d3b9dc9dSRabin Vincent mcount_enter 146181f817eSUwe Kleine-König ldr r0, =ftrace_trace_function 147181f817eSUwe Kleine-König ldr r2, [r0] 148a3ba87a6SRabin Vincent adr r0, .Lftrace_stub 149181f817eSUwe Kleine-König cmp r0, r2 150d3b9dc9dSRabin Vincent bne 1f 151376cfa87STim Bird 152376cfa87STim Bird#ifdef CONFIG_FUNCTION_GRAPH_TRACER 153376cfa87STim Bird ldr r1, =ftrace_graph_return 154376cfa87STim Bird ldr r2, [r1] 155376cfa87STim Bird cmp r0, r2 156376cfa87STim Bird bne ftrace_graph_caller\suffix 157376cfa87STim Bird 158376cfa87STim Bird ldr r1, =ftrace_graph_entry 159376cfa87STim Bird ldr r2, [r1] 160376cfa87STim Bird ldr r0, =ftrace_graph_entry_stub 161376cfa87STim Bird cmp r0, r2 162376cfa87STim Bird bne ftrace_graph_caller\suffix 163376cfa87STim Bird#endif 164376cfa87STim Bird 165d3b9dc9dSRabin Vincent mcount_exit 166181f817eSUwe Kleine-König 167d3b9dc9dSRabin Vincent1: mcount_get_lr r1 @ lr of instrumented func 168d3b9dc9dSRabin Vincent mov r0, lr @ instrumented function 169181f817eSUwe Kleine-König sub r0, r0, #MCOUNT_INSN_SIZE 170d3b9dc9dSRabin Vincent adr lr, BSYM(2f) 171181f817eSUwe Kleine-König mov pc, r2 172d3b9dc9dSRabin Vincent2: mcount_exit 173d3b9dc9dSRabin Vincent.endm 174d3b9dc9dSRabin Vincent 175d3b9dc9dSRabin Vincent.macro __ftrace_caller suffix 176d3b9dc9dSRabin Vincent mcount_enter 177d3b9dc9dSRabin Vincent 178d3b9dc9dSRabin Vincent mcount_get_lr r1 @ lr of instrumented func 179d3b9dc9dSRabin Vincent mov r0, lr @ instrumented function 180d3b9dc9dSRabin Vincent sub r0, r0, #MCOUNT_INSN_SIZE 181d3b9dc9dSRabin Vincent 182d3b9dc9dSRabin Vincent .globl ftrace_call\suffix 183d3b9dc9dSRabin Vincentftrace_call\suffix: 184d3b9dc9dSRabin Vincent bl ftrace_stub 185d3b9dc9dSRabin Vincent 186dd686eb1SRabin Vincent#ifdef CONFIG_FUNCTION_GRAPH_TRACER 187dd686eb1SRabin Vincent .globl ftrace_graph_call\suffix 188dd686eb1SRabin Vincentftrace_graph_call\suffix: 189dd686eb1SRabin Vincent mov r0, r0 190dd686eb1SRabin Vincent#endif 191dd686eb1SRabin Vincent 192d3b9dc9dSRabin Vincent mcount_exit 193d3b9dc9dSRabin Vincent.endm 194181f817eSUwe Kleine-König 195376cfa87STim Bird.macro __ftrace_graph_caller 196376cfa87STim Bird sub r0, fp, #4 @ &lr of instrumented routine (&parent) 197dd686eb1SRabin Vincent#ifdef CONFIG_DYNAMIC_FTRACE 198dd686eb1SRabin Vincent @ called from __ftrace_caller, saved in mcount_enter 199dd686eb1SRabin Vincent ldr r1, [sp, #16] @ instrumented routine (func) 200dd686eb1SRabin Vincent#else 201dd686eb1SRabin Vincent @ called from __mcount, untouched in lr 202376cfa87STim Bird mov r1, lr @ instrumented routine (func) 203dd686eb1SRabin Vincent#endif 204376cfa87STim Bird sub r1, r1, #MCOUNT_INSN_SIZE 205376cfa87STim Bird mov r2, fp @ frame pointer 206376cfa87STim Bird bl prepare_ftrace_return 207376cfa87STim Bird mcount_exit 208376cfa87STim Bird.endm 209376cfa87STim Bird 21009bfafacSRabin Vincent#ifdef CONFIG_OLD_MCOUNT 21109bfafacSRabin Vincent/* 212d3b9dc9dSRabin Vincent * mcount 21309bfafacSRabin Vincent */ 214014c257cSAbhishek Sagar 215d3b9dc9dSRabin Vincent.macro mcount_enter 216d3b9dc9dSRabin Vincent stmdb sp!, {r0-r3, lr} 217d3b9dc9dSRabin Vincent.endm 218d3b9dc9dSRabin Vincent 219d3b9dc9dSRabin Vincent.macro mcount_get_lr reg 220d3b9dc9dSRabin Vincent ldr \reg, [fp, #-4] 221d3b9dc9dSRabin Vincent.endm 222d3b9dc9dSRabin Vincent 223d3b9dc9dSRabin Vincent.macro mcount_exit 224d3b9dc9dSRabin Vincent ldr lr, [fp, #-4] 225014c257cSAbhishek Sagar ldmia sp!, {r0-r3, pc} 226d3b9dc9dSRabin Vincent.endm 227d3b9dc9dSRabin Vincent 228d3b9dc9dSRabin VincentENTRY(mcount) 229d3b9dc9dSRabin Vincent#ifdef CONFIG_DYNAMIC_FTRACE 230d3b9dc9dSRabin Vincent stmdb sp!, {lr} 231d3b9dc9dSRabin Vincent ldr lr, [fp, #-4] 232d3b9dc9dSRabin Vincent ldmia sp!, {pc} 233d3b9dc9dSRabin Vincent#else 234d3b9dc9dSRabin Vincent __mcount _old 235d3b9dc9dSRabin Vincent#endif 23672fa62faSRabin VincentENDPROC(mcount) 237d3b9dc9dSRabin Vincent 238d3b9dc9dSRabin Vincent#ifdef CONFIG_DYNAMIC_FTRACE 239d3b9dc9dSRabin VincentENTRY(ftrace_caller_old) 240d3b9dc9dSRabin Vincent __ftrace_caller _old 241d3b9dc9dSRabin VincentENDPROC(ftrace_caller_old) 24209bfafacSRabin Vincent#endif 243014c257cSAbhishek Sagar 244376cfa87STim Bird#ifdef CONFIG_FUNCTION_GRAPH_TRACER 245376cfa87STim BirdENTRY(ftrace_graph_caller_old) 246376cfa87STim Bird __ftrace_graph_caller 247376cfa87STim BirdENDPROC(ftrace_graph_caller_old) 248376cfa87STim Bird#endif 249376cfa87STim Bird 250d3b9dc9dSRabin Vincent.purgem mcount_enter 251d3b9dc9dSRabin Vincent.purgem mcount_get_lr 252d3b9dc9dSRabin Vincent.purgem mcount_exit 253d3b9dc9dSRabin Vincent#endif 254d3b9dc9dSRabin Vincent 255d3b9dc9dSRabin Vincent/* 256d3b9dc9dSRabin Vincent * __gnu_mcount_nc 257d3b9dc9dSRabin Vincent */ 258d3b9dc9dSRabin Vincent 259d3b9dc9dSRabin Vincent.macro mcount_enter 260d3b9dc9dSRabin Vincent stmdb sp!, {r0-r3, lr} 261d3b9dc9dSRabin Vincent.endm 262d3b9dc9dSRabin Vincent 263d3b9dc9dSRabin Vincent.macro mcount_get_lr reg 264d3b9dc9dSRabin Vincent ldr \reg, [sp, #20] 265d3b9dc9dSRabin Vincent.endm 266d3b9dc9dSRabin Vincent 267d3b9dc9dSRabin Vincent.macro mcount_exit 268d3b9dc9dSRabin Vincent ldmia sp!, {r0-r3, ip, lr} 269d3b9dc9dSRabin Vincent mov pc, ip 270d3b9dc9dSRabin Vincent.endm 271d3b9dc9dSRabin Vincent 272d3b9dc9dSRabin VincentENTRY(__gnu_mcount_nc) 273d3b9dc9dSRabin Vincent#ifdef CONFIG_DYNAMIC_FTRACE 274d3b9dc9dSRabin Vincent mov ip, lr 275d3b9dc9dSRabin Vincent ldmia sp!, {lr} 276d3b9dc9dSRabin Vincent mov pc, ip 277d3b9dc9dSRabin Vincent#else 278d3b9dc9dSRabin Vincent __mcount 279d3b9dc9dSRabin Vincent#endif 280d3b9dc9dSRabin VincentENDPROC(__gnu_mcount_nc) 281d3b9dc9dSRabin Vincent 282d3b9dc9dSRabin Vincent#ifdef CONFIG_DYNAMIC_FTRACE 283d3b9dc9dSRabin VincentENTRY(ftrace_caller) 284d3b9dc9dSRabin Vincent __ftrace_caller 285d3b9dc9dSRabin VincentENDPROC(ftrace_caller) 286d3b9dc9dSRabin Vincent#endif 287d3b9dc9dSRabin Vincent 288376cfa87STim Bird#ifdef CONFIG_FUNCTION_GRAPH_TRACER 289376cfa87STim BirdENTRY(ftrace_graph_caller) 290376cfa87STim Bird __ftrace_graph_caller 291376cfa87STim BirdENDPROC(ftrace_graph_caller) 292376cfa87STim Bird#endif 293376cfa87STim Bird 294d3b9dc9dSRabin Vincent.purgem mcount_enter 295d3b9dc9dSRabin Vincent.purgem mcount_get_lr 296d3b9dc9dSRabin Vincent.purgem mcount_exit 297014c257cSAbhishek Sagar 298376cfa87STim Bird#ifdef CONFIG_FUNCTION_GRAPH_TRACER 299376cfa87STim Bird .globl return_to_handler 300376cfa87STim Birdreturn_to_handler: 301376cfa87STim Bird stmdb sp!, {r0-r3} 302376cfa87STim Bird mov r0, fp @ frame pointer 303376cfa87STim Bird bl ftrace_return_to_handler 304376cfa87STim Bird mov lr, r0 @ r0 has real ret addr 305376cfa87STim Bird ldmia sp!, {r0-r3} 306376cfa87STim Bird mov pc, lr 307376cfa87STim Bird#endif 308376cfa87STim Bird 30972fa62faSRabin VincentENTRY(ftrace_stub) 310a3ba87a6SRabin Vincent.Lftrace_stub: 311014c257cSAbhishek Sagar mov pc, lr 31272fa62faSRabin VincentENDPROC(ftrace_stub) 313014c257cSAbhishek Sagar 314606576ceSSteven Rostedt#endif /* CONFIG_FUNCTION_TRACER */ 315014c257cSAbhishek Sagar 3161da177e4SLinus Torvalds/*============================================================================= 3171da177e4SLinus Torvalds * SWI handler 3181da177e4SLinus Torvalds *----------------------------------------------------------------------------- 3191da177e4SLinus Torvalds */ 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds /* If we're optimising for StrongARM the resulting code won't 3221da177e4SLinus Torvalds run on an ARM7 and we can save a couple of instructions. 3231da177e4SLinus Torvalds --pb */ 3241da177e4SLinus Torvalds#ifdef CONFIG_CPU_ARM710 3253f2829a3SNicolas Pitre#define A710(code...) code 3263f2829a3SNicolas Pitre.Larm710bug: 3271da177e4SLinus Torvalds ldmia sp, {r0 - lr}^ @ Get calling r0 - lr 3281da177e4SLinus Torvalds mov r0, r0 3291da177e4SLinus Torvalds add sp, sp, #S_FRAME_SIZE 33060ac133aSNicolas Pitre subs pc, lr, #4 3311da177e4SLinus Torvalds#else 3323f2829a3SNicolas Pitre#define A710(code...) 3331da177e4SLinus Torvalds#endif 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds .align 5 3361da177e4SLinus TorvaldsENTRY(vector_swi) 337f4dc9a4cSRussell King sub sp, sp, #S_FRAME_SIZE 338f4dc9a4cSRussell King stmia sp, {r0 - r12} @ Calling r0 - r12 339b86040a5SCatalin Marinas ARM( add r8, sp, #S_PC ) 340b86040a5SCatalin Marinas ARM( stmdb r8, {sp, lr}^ ) @ Calling sp, lr 341b86040a5SCatalin Marinas THUMB( mov r8, sp ) 342b86040a5SCatalin Marinas THUMB( store_user_sp_lr r8, r10, S_SP ) @ calling sp, lr 343f4dc9a4cSRussell King mrs r8, spsr @ called from non-FIQ mode, so ok. 344f4dc9a4cSRussell King str lr, [sp, #S_PC] @ Save calling PC 345f4dc9a4cSRussell King str r8, [sp, #S_PSR] @ Save CPSR 346f4dc9a4cSRussell King str r0, [sp, #S_OLD_R0] @ Save OLD_R0 3471da177e4SLinus Torvalds zero_fp 348e0f9f4a6SRussell King 349e0f9f4a6SRussell King /* 350e0f9f4a6SRussell King * Get the system call number. 351e0f9f4a6SRussell King */ 3523f2829a3SNicolas Pitre 353dd35afc2SNicolas Pitre#if defined(CONFIG_OABI_COMPAT) 3543f2829a3SNicolas Pitre 355dd35afc2SNicolas Pitre /* 356dd35afc2SNicolas Pitre * If we have CONFIG_OABI_COMPAT then we need to look at the swi 357dd35afc2SNicolas Pitre * value to determine if it is an EABI or an old ABI call. 358dd35afc2SNicolas Pitre */ 359dd35afc2SNicolas Pitre#ifdef CONFIG_ARM_THUMB 360dd35afc2SNicolas Pitre tst r8, #PSR_T_BIT 361dd35afc2SNicolas Pitre movne r10, #0 @ no thumb OABI emulation 362dd35afc2SNicolas Pitre ldreq r10, [lr, #-4] @ get SWI instruction 363dd35afc2SNicolas Pitre#else 364dd35afc2SNicolas Pitre ldr r10, [lr, #-4] @ get SWI instruction 365dd35afc2SNicolas Pitre A710( and ip, r10, #0x0f000000 @ check for SWI ) 366dd35afc2SNicolas Pitre A710( teq ip, #0x0f000000 ) 367dd35afc2SNicolas Pitre A710( bne .Larm710bug ) 368dd35afc2SNicolas Pitre#endif 36926584853SCatalin Marinas#ifdef CONFIG_CPU_ENDIAN_BE8 37026584853SCatalin Marinas rev r10, r10 @ little endian instruction 37126584853SCatalin Marinas#endif 372dd35afc2SNicolas Pitre 373dd35afc2SNicolas Pitre#elif defined(CONFIG_AEABI) 374dd35afc2SNicolas Pitre 375dd35afc2SNicolas Pitre /* 376dd35afc2SNicolas Pitre * Pure EABI user space always put syscall number into scno (r7). 377dd35afc2SNicolas Pitre */ 3783f2829a3SNicolas Pitre A710( ldr ip, [lr, #-4] @ get SWI instruction ) 3793f2829a3SNicolas Pitre A710( and ip, ip, #0x0f000000 @ check for SWI ) 3803f2829a3SNicolas Pitre A710( teq ip, #0x0f000000 ) 3813f2829a3SNicolas Pitre A710( bne .Larm710bug ) 382dd35afc2SNicolas Pitre 3833f2829a3SNicolas Pitre#elif defined(CONFIG_ARM_THUMB) 384dd35afc2SNicolas Pitre 385dd35afc2SNicolas Pitre /* Legacy ABI only, possibly thumb mode. */ 386e0f9f4a6SRussell King tst r8, #PSR_T_BIT @ this is SPSR from save_user_regs 387e0f9f4a6SRussell King addne scno, r7, #__NR_SYSCALL_BASE @ put OS number in 388e0f9f4a6SRussell King ldreq scno, [lr, #-4] 389dd35afc2SNicolas Pitre 390e0f9f4a6SRussell King#else 391dd35afc2SNicolas Pitre 392dd35afc2SNicolas Pitre /* Legacy ABI only. */ 393e0f9f4a6SRussell King ldr scno, [lr, #-4] @ get SWI instruction 3943f2829a3SNicolas Pitre A710( and ip, scno, #0x0f000000 @ check for SWI ) 3953f2829a3SNicolas Pitre A710( teq ip, #0x0f000000 ) 3963f2829a3SNicolas Pitre A710( bne .Larm710bug ) 397dd35afc2SNicolas Pitre 398e0f9f4a6SRussell King#endif 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds#ifdef CONFIG_ALIGNMENT_TRAP 4011da177e4SLinus Torvalds ldr ip, __cr_alignment 4021da177e4SLinus Torvalds ldr ip, [ip] 4031da177e4SLinus Torvalds mcr p15, 0, ip, c1, c0 @ update control register 4041da177e4SLinus Torvalds#endif 4051ec42c0cSRussell King enable_irq 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds get_thread_info tsk 408dd35afc2SNicolas Pitre adr tbl, sys_call_table @ load syscall table pointer 409dd35afc2SNicolas Pitre 410dd35afc2SNicolas Pitre#if defined(CONFIG_OABI_COMPAT) 411dd35afc2SNicolas Pitre /* 412dd35afc2SNicolas Pitre * If the swi argument is zero, this is an EABI call and we do nothing. 413dd35afc2SNicolas Pitre * 414dd35afc2SNicolas Pitre * If this is an old ABI call, get the syscall number into scno and 415dd35afc2SNicolas Pitre * get the old ABI syscall table address. 416dd35afc2SNicolas Pitre */ 417dd35afc2SNicolas Pitre bics r10, r10, #0xff000000 418dd35afc2SNicolas Pitre eorne scno, r10, #__NR_OABI_SYSCALL_BASE 419dd35afc2SNicolas Pitre ldrne tbl, =sys_oabi_call_table 420dd35afc2SNicolas Pitre#elif !defined(CONFIG_AEABI) 4211da177e4SLinus Torvalds bic scno, scno, #0xff000000 @ mask off SWI op-code 422e0f9f4a6SRussell King eor scno, scno, #__NR_SYSCALL_BASE @ check OS number 4233f2829a3SNicolas Pitre#endif 424dd35afc2SNicolas Pitre 42570c70d97SNicolas Pitre ldr r10, [tsk, #TI_FLAGS] @ check for syscall tracing 4263f2829a3SNicolas Pitre stmdb sp!, {r4, r5} @ push fifth and sixth args 42770c70d97SNicolas Pitre 42870c70d97SNicolas Pitre#ifdef CONFIG_SECCOMP 42970c70d97SNicolas Pitre tst r10, #_TIF_SECCOMP 43070c70d97SNicolas Pitre beq 1f 43170c70d97SNicolas Pitre mov r0, scno 43270c70d97SNicolas Pitre bl __secure_computing 43370c70d97SNicolas Pitre add r0, sp, #S_R0 + S_OFF @ pointer to regs 43470c70d97SNicolas Pitre ldmia r0, {r0 - r3} @ have to reload r0 - r3 43570c70d97SNicolas Pitre1: 43670c70d97SNicolas Pitre#endif 43770c70d97SNicolas Pitre 43870c70d97SNicolas Pitre tst r10, #_TIF_SYSCALL_TRACE @ are we tracing syscalls? 4391da177e4SLinus Torvalds bne __sys_trace 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds cmp scno, #NR_syscalls @ check upper syscall limit 442b86040a5SCatalin Marinas adr lr, BSYM(ret_fast_syscall) @ return address 4431da177e4SLinus Torvalds ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine 4441da177e4SLinus Torvalds 4451da177e4SLinus Torvalds add r1, sp, #S_OFF 4461da177e4SLinus Torvalds2: mov why, #0 @ no longer a real syscall 447e0f9f4a6SRussell King cmp scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE) 448e0f9f4a6SRussell King eor r0, scno, #__NR_SYSCALL_BASE @ put OS number back 4491da177e4SLinus Torvalds bcs arm_syscall 4501da177e4SLinus Torvalds b sys_ni_syscall @ not private func 45193ed3970SCatalin MarinasENDPROC(vector_swi) 4521da177e4SLinus Torvalds 4531da177e4SLinus Torvalds /* 4541da177e4SLinus Torvalds * This is the really slow path. We're going to be doing 4551da177e4SLinus Torvalds * context switches, and waiting for our parent to respond. 4561da177e4SLinus Torvalds */ 4571da177e4SLinus Torvalds__sys_trace: 4583f471126SNicolas Pitre mov r2, scno 4591da177e4SLinus Torvalds add r1, sp, #S_OFF 4601da177e4SLinus Torvalds mov r0, #0 @ trace entry [IP = 0] 4611da177e4SLinus Torvalds bl syscall_trace 4621da177e4SLinus Torvalds 463b86040a5SCatalin Marinas adr lr, BSYM(__sys_trace_return) @ return address 4643f471126SNicolas Pitre mov scno, r0 @ syscall number (possibly new) 4651da177e4SLinus Torvalds add r1, sp, #S_R0 + S_OFF @ pointer to regs 4661da177e4SLinus Torvalds cmp scno, #NR_syscalls @ check upper syscall limit 4671da177e4SLinus Torvalds ldmccia r1, {r0 - r3} @ have to reload r0 - r3 4681da177e4SLinus Torvalds ldrcc pc, [tbl, scno, lsl #2] @ call sys_* routine 4691da177e4SLinus Torvalds b 2b 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds__sys_trace_return: 4721da177e4SLinus Torvalds str r0, [sp, #S_R0 + S_OFF]! @ save returned r0 4733f471126SNicolas Pitre mov r2, scno 4741da177e4SLinus Torvalds mov r1, sp 4751da177e4SLinus Torvalds mov r0, #1 @ trace exit [IP = 1] 4761da177e4SLinus Torvalds bl syscall_trace 4771da177e4SLinus Torvalds b ret_slow_syscall 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds .align 5 4801da177e4SLinus Torvalds#ifdef CONFIG_ALIGNMENT_TRAP 4811da177e4SLinus Torvalds .type __cr_alignment, #object 4821da177e4SLinus Torvalds__cr_alignment: 4831da177e4SLinus Torvalds .word cr_alignment 4841da177e4SLinus Torvalds#endif 485dd35afc2SNicolas Pitre .ltorg 486dd35afc2SNicolas Pitre 487dd35afc2SNicolas Pitre/* 488dd35afc2SNicolas Pitre * This is the syscall table declaration for native ABI syscalls. 489dd35afc2SNicolas Pitre * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall. 490dd35afc2SNicolas Pitre */ 491dd35afc2SNicolas Pitre#define ABI(native, compat) native 492dd35afc2SNicolas Pitre#ifdef CONFIG_AEABI 493dd35afc2SNicolas Pitre#define OBSOLETE(syscall) sys_ni_syscall 494dd35afc2SNicolas Pitre#else 495dd35afc2SNicolas Pitre#define OBSOLETE(syscall) syscall 496dd35afc2SNicolas Pitre#endif 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds .type sys_call_table, #object 4991da177e4SLinus TorvaldsENTRY(sys_call_table) 5001da177e4SLinus Torvalds#include "calls.S" 501dd35afc2SNicolas Pitre#undef ABI 502dd35afc2SNicolas Pitre#undef OBSOLETE 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds/*============================================================================ 5051da177e4SLinus Torvalds * Special system call wrappers 5061da177e4SLinus Torvalds */ 5071da177e4SLinus Torvalds@ r0 = syscall number 508567bd980SRussell King@ r8 = syscall table 5091da177e4SLinus Torvaldssys_syscall: 5105247593cSPaul Brook bic scno, r0, #__NR_OABI_SYSCALL_BASE 5111da177e4SLinus Torvalds cmp scno, #__NR_syscall - __NR_SYSCALL_BASE 5121da177e4SLinus Torvalds cmpne scno, #NR_syscalls @ check range 5131da177e4SLinus Torvalds stmloia sp, {r5, r6} @ shuffle args 5141da177e4SLinus Torvalds movlo r0, r1 5151da177e4SLinus Torvalds movlo r1, r2 5161da177e4SLinus Torvalds movlo r2, r3 5171da177e4SLinus Torvalds movlo r3, r4 5181da177e4SLinus Torvalds ldrlo pc, [tbl, scno, lsl #2] 5191da177e4SLinus Torvalds b sys_ni_syscall 52093ed3970SCatalin MarinasENDPROC(sys_syscall) 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvaldssys_fork_wrapper: 5231da177e4SLinus Torvalds add r0, sp, #S_OFF 5241da177e4SLinus Torvalds b sys_fork 52593ed3970SCatalin MarinasENDPROC(sys_fork_wrapper) 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvaldssys_vfork_wrapper: 5281da177e4SLinus Torvalds add r0, sp, #S_OFF 5291da177e4SLinus Torvalds b sys_vfork 53093ed3970SCatalin MarinasENDPROC(sys_vfork_wrapper) 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvaldssys_execve_wrapper: 5331da177e4SLinus Torvalds add r3, sp, #S_OFF 5341da177e4SLinus Torvalds b sys_execve 53593ed3970SCatalin MarinasENDPROC(sys_execve_wrapper) 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvaldssys_clone_wrapper: 5381da177e4SLinus Torvalds add ip, sp, #S_OFF 5391da177e4SLinus Torvalds str ip, [sp, #4] 5401da177e4SLinus Torvalds b sys_clone 54193ed3970SCatalin MarinasENDPROC(sys_clone_wrapper) 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvaldssys_sigreturn_wrapper: 5441da177e4SLinus Torvalds add r0, sp, #S_OFF 545653d48b2SAl Viro mov why, #0 @ prevent syscall restart handling 5461da177e4SLinus Torvalds b sys_sigreturn 54793ed3970SCatalin MarinasENDPROC(sys_sigreturn_wrapper) 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvaldssys_rt_sigreturn_wrapper: 5501da177e4SLinus Torvalds add r0, sp, #S_OFF 551653d48b2SAl Viro mov why, #0 @ prevent syscall restart handling 5521da177e4SLinus Torvalds b sys_rt_sigreturn 55393ed3970SCatalin MarinasENDPROC(sys_rt_sigreturn_wrapper) 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvaldssys_sigaltstack_wrapper: 5561da177e4SLinus Torvalds ldr r2, [sp, #S_OFF + S_SP] 5571da177e4SLinus Torvalds b do_sigaltstack 55893ed3970SCatalin MarinasENDPROC(sys_sigaltstack_wrapper) 5591da177e4SLinus Torvalds 560713c4815SNicolas Pitresys_statfs64_wrapper: 561713c4815SNicolas Pitre teq r1, #88 562713c4815SNicolas Pitre moveq r1, #84 563713c4815SNicolas Pitre b sys_statfs64 56493ed3970SCatalin MarinasENDPROC(sys_statfs64_wrapper) 565713c4815SNicolas Pitre 566713c4815SNicolas Pitresys_fstatfs64_wrapper: 567713c4815SNicolas Pitre teq r1, #88 568713c4815SNicolas Pitre moveq r1, #84 569713c4815SNicolas Pitre b sys_fstatfs64 57093ed3970SCatalin MarinasENDPROC(sys_fstatfs64_wrapper) 571713c4815SNicolas Pitre 5721da177e4SLinus Torvalds/* 5731da177e4SLinus Torvalds * Note: off_4k (r5) is always units of 4K. If we can't do the requested 5741da177e4SLinus Torvalds * offset, we return EINVAL. 5751da177e4SLinus Torvalds */ 5761da177e4SLinus Torvaldssys_mmap2: 5771da177e4SLinus Torvalds#if PAGE_SHIFT > 12 5781da177e4SLinus Torvalds tst r5, #PGOFF_MASK 5791da177e4SLinus Torvalds moveq r5, r5, lsr #PAGE_SHIFT - 12 5801da177e4SLinus Torvalds streq r5, [sp, #4] 581f8b72560SAl Viro beq sys_mmap_pgoff 5821da177e4SLinus Torvalds mov r0, #-EINVAL 5837999d8d7SRussell King mov pc, lr 5841da177e4SLinus Torvalds#else 5851da177e4SLinus Torvalds str r5, [sp, #4] 586f8b72560SAl Viro b sys_mmap_pgoff 5871da177e4SLinus Torvalds#endif 58893ed3970SCatalin MarinasENDPROC(sys_mmap2) 589687ad019SNicolas Pitre 590687ad019SNicolas Pitre#ifdef CONFIG_OABI_COMPAT 591dd35afc2SNicolas Pitre 592687ad019SNicolas Pitre/* 593687ad019SNicolas Pitre * These are syscalls with argument register differences 594687ad019SNicolas Pitre */ 595687ad019SNicolas Pitre 596687ad019SNicolas Pitresys_oabi_pread64: 597687ad019SNicolas Pitre stmia sp, {r3, r4} 598687ad019SNicolas Pitre b sys_pread64 59993ed3970SCatalin MarinasENDPROC(sys_oabi_pread64) 600687ad019SNicolas Pitre 601687ad019SNicolas Pitresys_oabi_pwrite64: 602687ad019SNicolas Pitre stmia sp, {r3, r4} 603687ad019SNicolas Pitre b sys_pwrite64 60493ed3970SCatalin MarinasENDPROC(sys_oabi_pwrite64) 605687ad019SNicolas Pitre 606687ad019SNicolas Pitresys_oabi_truncate64: 607687ad019SNicolas Pitre mov r3, r2 608687ad019SNicolas Pitre mov r2, r1 609687ad019SNicolas Pitre b sys_truncate64 61093ed3970SCatalin MarinasENDPROC(sys_oabi_truncate64) 611687ad019SNicolas Pitre 612687ad019SNicolas Pitresys_oabi_ftruncate64: 613687ad019SNicolas Pitre mov r3, r2 614687ad019SNicolas Pitre mov r2, r1 615687ad019SNicolas Pitre b sys_ftruncate64 61693ed3970SCatalin MarinasENDPROC(sys_oabi_ftruncate64) 617687ad019SNicolas Pitre 618687ad019SNicolas Pitresys_oabi_readahead: 619687ad019SNicolas Pitre str r3, [sp] 620687ad019SNicolas Pitre mov r3, r2 621687ad019SNicolas Pitre mov r2, r1 622687ad019SNicolas Pitre b sys_readahead 62393ed3970SCatalin MarinasENDPROC(sys_oabi_readahead) 624687ad019SNicolas Pitre 625dd35afc2SNicolas Pitre/* 626dd35afc2SNicolas Pitre * Let's declare a second syscall table for old ABI binaries 627dd35afc2SNicolas Pitre * using the compatibility syscall entries. 628dd35afc2SNicolas Pitre */ 629dd35afc2SNicolas Pitre#define ABI(native, compat) compat 630dd35afc2SNicolas Pitre#define OBSOLETE(syscall) syscall 631dd35afc2SNicolas Pitre 632dd35afc2SNicolas Pitre .type sys_oabi_call_table, #object 633dd35afc2SNicolas PitreENTRY(sys_oabi_call_table) 634dd35afc2SNicolas Pitre#include "calls.S" 635dd35afc2SNicolas Pitre#undef ABI 636dd35afc2SNicolas Pitre#undef OBSOLETE 637dd35afc2SNicolas Pitre 638687ad019SNicolas Pitre#endif 639687ad019SNicolas Pitre 640