1/* 2 * arch/s390/kernel/entry64.S 3 * S390 low-level entry points. 4 * 5 * Copyright (C) IBM Corp. 1999,2010 6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com), 7 * Hartmut Penner (hp@de.ibm.com), 8 * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com), 9 * Heiko Carstens <heiko.carstens@de.ibm.com> 10 */ 11 12#include <linux/linkage.h> 13#include <linux/init.h> 14#include <asm/cache.h> 15#include <asm/errno.h> 16#include <asm/ptrace.h> 17#include <asm/thread_info.h> 18#include <asm/asm-offsets.h> 19#include <asm/unistd.h> 20#include <asm/page.h> 21 22/* 23 * Stack layout for the system_call stack entry. 24 * The first few entries are identical to the user_regs_struct. 25 */ 26SP_PTREGS = STACK_FRAME_OVERHEAD 27SP_ARGS = STACK_FRAME_OVERHEAD + __PT_ARGS 28SP_PSW = STACK_FRAME_OVERHEAD + __PT_PSW 29SP_R0 = STACK_FRAME_OVERHEAD + __PT_GPRS 30SP_R1 = STACK_FRAME_OVERHEAD + __PT_GPRS + 8 31SP_R2 = STACK_FRAME_OVERHEAD + __PT_GPRS + 16 32SP_R3 = STACK_FRAME_OVERHEAD + __PT_GPRS + 24 33SP_R4 = STACK_FRAME_OVERHEAD + __PT_GPRS + 32 34SP_R5 = STACK_FRAME_OVERHEAD + __PT_GPRS + 40 35SP_R6 = STACK_FRAME_OVERHEAD + __PT_GPRS + 48 36SP_R7 = STACK_FRAME_OVERHEAD + __PT_GPRS + 56 37SP_R8 = STACK_FRAME_OVERHEAD + __PT_GPRS + 64 38SP_R9 = STACK_FRAME_OVERHEAD + __PT_GPRS + 72 39SP_R10 = STACK_FRAME_OVERHEAD + __PT_GPRS + 80 40SP_R11 = STACK_FRAME_OVERHEAD + __PT_GPRS + 88 41SP_R12 = STACK_FRAME_OVERHEAD + __PT_GPRS + 96 42SP_R13 = STACK_FRAME_OVERHEAD + __PT_GPRS + 104 43SP_R14 = STACK_FRAME_OVERHEAD + __PT_GPRS + 112 44SP_R15 = STACK_FRAME_OVERHEAD + __PT_GPRS + 120 45SP_ORIG_R2 = STACK_FRAME_OVERHEAD + __PT_ORIG_GPR2 46SP_ILC = STACK_FRAME_OVERHEAD + __PT_ILC 47SP_SVCNR = STACK_FRAME_OVERHEAD + __PT_SVCNR 48SP_SIZE = STACK_FRAME_OVERHEAD + __PT_SIZE 49 50STACK_SHIFT = PAGE_SHIFT + THREAD_ORDER 51STACK_SIZE = 1 << STACK_SHIFT 52 53_TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \ 54 _TIF_MCCK_PENDING | _TIF_RESTART_SVC | _TIF_SINGLE_STEP ) 55_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \ 56 _TIF_MCCK_PENDING) 57_TIF_SYSCALL = (_TIF_SYSCALL_TRACE>>8 | _TIF_SYSCALL_AUDIT>>8 | \ 58 _TIF_SECCOMP>>8 | _TIF_SYSCALL_TRACEPOINT>>8) 59 60#define BASED(name) name-system_call(%r13) 61 62 .macro HANDLE_SIE_INTERCEPT 63#if defined(CONFIG_KVM) || defined(CONFIG_KVM_MODULE) 64 lg %r3,__LC_SIE_HOOK 65 ltgr %r3,%r3 66 jz 0f 67 basr %r14,%r3 680: 69#endif 70 .endm 71 72#ifdef CONFIG_TRACE_IRQFLAGS 73 .macro TRACE_IRQS_ON 74 basr %r2,%r0 75 brasl %r14,trace_hardirqs_on_caller 76 .endm 77 78 .macro TRACE_IRQS_OFF 79 basr %r2,%r0 80 brasl %r14,trace_hardirqs_off_caller 81 .endm 82 83 .macro TRACE_IRQS_CHECK_ON 84 tm SP_PSW(%r15),0x03 # irqs enabled? 85 jz 0f 86 TRACE_IRQS_ON 870: 88 .endm 89 90 .macro TRACE_IRQS_CHECK_OFF 91 tm SP_PSW(%r15),0x03 # irqs enabled? 92 jz 0f 93 TRACE_IRQS_OFF 940: 95 .endm 96#else 97#define TRACE_IRQS_ON 98#define TRACE_IRQS_OFF 99#define TRACE_IRQS_CHECK_ON 100#define TRACE_IRQS_CHECK_OFF 101#endif 102 103#ifdef CONFIG_LOCKDEP 104 .macro LOCKDEP_SYS_EXIT 105 tm SP_PSW+1(%r15),0x01 # returning to user ? 106 jz 0f 107 brasl %r14,lockdep_sys_exit 1080: 109 .endm 110#else 111#define LOCKDEP_SYS_EXIT 112#endif 113 114 .macro UPDATE_VTIME lc_from,lc_to,lc_sum 115 lg %r10,\lc_from 116 slg %r10,\lc_to 117 alg %r10,\lc_sum 118 stg %r10,\lc_sum 119 .endm 120 121/* 122 * Register usage in interrupt handlers: 123 * R9 - pointer to current task structure 124 * R13 - pointer to literal pool 125 * R14 - return register for function calls 126 * R15 - kernel stack pointer 127 */ 128 129 .macro SAVE_ALL_SVC psworg,savearea 130 stmg %r11,%r15,\savearea 131 lg %r15,__LC_KERNEL_STACK # problem state -> load ksp 132 aghi %r15,-SP_SIZE # make room for registers & psw 133 lg %r11,__LC_LAST_BREAK 134 .endm 135 136 .macro SAVE_ALL_PGM psworg,savearea 137 stmg %r11,%r15,\savearea 138 tm \psworg+1,0x01 # test problem state bit 139#ifdef CONFIG_CHECK_STACK 140 jnz 1f 141 tml %r15,STACK_SIZE - CONFIG_STACK_GUARD 142 jnz 2f 143 la %r12,\psworg 144 j stack_overflow 145#else 146 jz 2f 147#endif 1481: lg %r15,__LC_KERNEL_STACK # problem state -> load ksp 1492: aghi %r15,-SP_SIZE # make room for registers & psw 150 larl %r13,system_call 151 lg %r11,__LC_LAST_BREAK 152 .endm 153 154 .macro SAVE_ALL_ASYNC psworg,savearea 155 stmg %r11,%r15,\savearea 156 larl %r13,system_call 157 lg %r11,__LC_LAST_BREAK 158 la %r12,\psworg 159 tm \psworg+1,0x01 # test problem state bit 160 jnz 1f # from user -> load kernel stack 161 clc \psworg+8(8),BASED(.Lcritical_end) 162 jhe 0f 163 clc \psworg+8(8),BASED(.Lcritical_start) 164 jl 0f 165 brasl %r14,cleanup_critical 166 tm 1(%r12),0x01 # retest problem state after cleanup 167 jnz 1f 1680: lg %r14,__LC_ASYNC_STACK # are we already on the async. stack ? 169 slgr %r14,%r15 170 srag %r14,%r14,STACK_SHIFT 171#ifdef CONFIG_CHECK_STACK 172 jnz 1f 173 tml %r15,STACK_SIZE - CONFIG_STACK_GUARD 174 jnz 2f 175 j stack_overflow 176#else 177 jz 2f 178#endif 1791: lg %r15,__LC_ASYNC_STACK # load async stack 1802: aghi %r15,-SP_SIZE # make room for registers & psw 181 .endm 182 183 .macro CREATE_STACK_FRAME savearea 184 xc __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15) 185 stg %r2,SP_ORIG_R2(%r15) # store original content of gpr 2 186 mvc SP_R11(40,%r15),\savearea # move %r11-%r15 to stack 187 stmg %r0,%r10,SP_R0(%r15) # store gprs %r0-%r10 to kernel stack 188 .endm 189 190 .macro RESTORE_ALL psworg,sync 191 mvc \psworg(16),SP_PSW(%r15) # move user PSW to lowcore 192 .if !\sync 193 ni \psworg+1,0xfd # clear wait state bit 194 .endif 195 lg %r14,__LC_VDSO_PER_CPU 196 lmg %r0,%r13,SP_R0(%r15) # load gprs 0-13 of user 197 stpt __LC_EXIT_TIMER 198 mvc __VDSO_ECTG_BASE(16,%r14),__LC_EXIT_TIMER 199 lmg %r14,%r15,SP_R14(%r15) # load grps 14-15 of user 200 lpswe \psworg # back to caller 201 .endm 202 203 .macro LAST_BREAK 204 srag %r10,%r11,23 205 jz 0f 206 stg %r11,__TI_last_break(%r12) 2070: 208 .endm 209 210/* 211 * Scheduler resume function, called by switch_to 212 * gpr2 = (task_struct *) prev 213 * gpr3 = (task_struct *) next 214 * Returns: 215 * gpr2 = prev 216 */ 217 .globl __switch_to 218__switch_to: 219 tm __THREAD_per+4(%r3),0xe8 # is the new process using per ? 220 jz __switch_to_noper # if not we're fine 221 stctg %c9,%c11,__SF_EMPTY(%r15)# We are using per stuff 222 clc __THREAD_per(24,%r3),__SF_EMPTY(%r15) 223 je __switch_to_noper # we got away without bashing TLB's 224 lctlg %c9,%c11,__THREAD_per(%r3) # Nope we didn't 225__switch_to_noper: 226 lg %r4,__THREAD_info(%r2) # get thread_info of prev 227 tm __TI_flags+7(%r4),_TIF_MCCK_PENDING # machine check pending? 228 jz __switch_to_no_mcck 229 ni __TI_flags+7(%r4),255-_TIF_MCCK_PENDING # clear flag in prev 230 lg %r4,__THREAD_info(%r3) # get thread_info of next 231 oi __TI_flags+7(%r4),_TIF_MCCK_PENDING # set it in next 232__switch_to_no_mcck: 233 stmg %r6,%r15,__SF_GPRS(%r15)# store __switch_to registers of prev task 234 stg %r15,__THREAD_ksp(%r2) # store kernel stack to prev->tss.ksp 235 lg %r15,__THREAD_ksp(%r3) # load kernel stack from next->tss.ksp 236 lmg %r6,%r15,__SF_GPRS(%r15)# load __switch_to registers of next task 237 stg %r3,__LC_CURRENT # __LC_CURRENT = current task struct 238 lctl %c4,%c4,__TASK_pid(%r3) # load pid to control reg. 4 239 lg %r3,__THREAD_info(%r3) # load thread_info from task struct 240 stg %r3,__LC_THREAD_INFO 241 aghi %r3,STACK_SIZE 242 stg %r3,__LC_KERNEL_STACK # __LC_KERNEL_STACK = new kernel stack 243 br %r14 244 245__critical_start: 246/* 247 * SVC interrupt handler routine. System calls are synchronous events and 248 * are executed with interrupts enabled. 249 */ 250 251 .globl system_call 252system_call: 253 stpt __LC_SYNC_ENTER_TIMER 254sysc_saveall: 255 SAVE_ALL_SVC __LC_SVC_OLD_PSW,__LC_SAVE_AREA 256 CREATE_STACK_FRAME __LC_SAVE_AREA 257 mvc SP_PSW(16,%r15),__LC_SVC_OLD_PSW 258 mvc SP_ILC(4,%r15),__LC_SVC_ILC 259 stg %r7,SP_ARGS(%r15) 260 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 261sysc_vtime: 262 UPDATE_VTIME __LC_EXIT_TIMER,__LC_SYNC_ENTER_TIMER,__LC_USER_TIMER 263sysc_stime: 264 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 265sysc_update: 266 mvc __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER 267 LAST_BREAK 268sysc_do_svc: 269 llgh %r7,SP_SVCNR(%r15) 270 slag %r7,%r7,2 # shift and test for svc 0 271 jnz sysc_nr_ok 272 # svc 0: system call number in %r1 273 llgfr %r1,%r1 # clear high word in r1 274 cghi %r1,NR_syscalls 275 jnl sysc_nr_ok 276 sth %r1,SP_SVCNR(%r15) 277 slag %r7,%r1,2 # shift and test for svc 0 278sysc_nr_ok: 279 larl %r10,sys_call_table 280#ifdef CONFIG_COMPAT 281 tm __TI_flags+5(%r12),(_TIF_31BIT>>16) # running in 31 bit mode ? 282 jno sysc_noemu 283 larl %r10,sys_call_table_emu # use 31 bit emulation system calls 284sysc_noemu: 285#endif 286 tm __TI_flags+6(%r12),_TIF_SYSCALL 287 lgf %r8,0(%r7,%r10) # load address of system call routine 288 jnz sysc_tracesys 289 basr %r14,%r8 # call sys_xxxx 290 stg %r2,SP_R2(%r15) # store return value (change R2 on stack) 291 292sysc_return: 293 LOCKDEP_SYS_EXIT 294sysc_tif: 295 tm __TI_flags+7(%r12),_TIF_WORK_SVC 296 jnz sysc_work # there is work to do (signals etc.) 297sysc_restore: 298 RESTORE_ALL __LC_RETURN_PSW,1 299sysc_done: 300 301# 302# There is work to do, but first we need to check if we return to userspace. 303# 304sysc_work: 305 tm SP_PSW+1(%r15),0x01 # returning to user ? 306 jno sysc_restore 307 308# 309# One of the work bits is on. Find out which one. 310# 311sysc_work_tif: 312 tm __TI_flags+7(%r12),_TIF_MCCK_PENDING 313 jo sysc_mcck_pending 314 tm __TI_flags+7(%r12),_TIF_NEED_RESCHED 315 jo sysc_reschedule 316 tm __TI_flags+7(%r12),_TIF_SIGPENDING 317 jo sysc_sigpending 318 tm __TI_flags+7(%r12),_TIF_NOTIFY_RESUME 319 jo sysc_notify_resume 320 tm __TI_flags+7(%r12),_TIF_RESTART_SVC 321 jo sysc_restart 322 tm __TI_flags+7(%r12),_TIF_SINGLE_STEP 323 jo sysc_singlestep 324 j sysc_return # beware of critical section cleanup 325 326# 327# _TIF_NEED_RESCHED is set, call schedule 328# 329sysc_reschedule: 330 larl %r14,sysc_return 331 jg schedule # return point is sysc_return 332 333# 334# _TIF_MCCK_PENDING is set, call handler 335# 336sysc_mcck_pending: 337 larl %r14,sysc_return 338 jg s390_handle_mcck # TIF bit will be cleared by handler 339 340# 341# _TIF_SIGPENDING is set, call do_signal 342# 343sysc_sigpending: 344 ni __TI_flags+7(%r12),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP 345 la %r2,SP_PTREGS(%r15) # load pt_regs 346 brasl %r14,do_signal # call do_signal 347 tm __TI_flags+7(%r12),_TIF_RESTART_SVC 348 jo sysc_restart 349 tm __TI_flags+7(%r12),_TIF_SINGLE_STEP 350 jo sysc_singlestep 351 j sysc_return 352 353# 354# _TIF_NOTIFY_RESUME is set, call do_notify_resume 355# 356sysc_notify_resume: 357 la %r2,SP_PTREGS(%r15) # load pt_regs 358 larl %r14,sysc_return 359 jg do_notify_resume # call do_notify_resume 360 361# 362# _TIF_RESTART_SVC is set, set up registers and restart svc 363# 364sysc_restart: 365 ni __TI_flags+7(%r12),255-_TIF_RESTART_SVC # clear TIF_RESTART_SVC 366 lg %r7,SP_R2(%r15) # load new svc number 367 mvc SP_R2(8,%r15),SP_ORIG_R2(%r15) # restore first argument 368 lmg %r2,%r6,SP_R2(%r15) # load svc arguments 369 sth %r7,SP_SVCNR(%r15) 370 slag %r7,%r7,2 371 j sysc_nr_ok # restart svc 372 373# 374# _TIF_SINGLE_STEP is set, call do_single_step 375# 376sysc_singlestep: 377 ni __TI_flags+7(%r12),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP 378 xc SP_SVCNR(2,%r15),SP_SVCNR(%r15) # clear svc number 379 la %r2,SP_PTREGS(%r15) # address of register-save area 380 larl %r14,sysc_return # load adr. of system return 381 jg do_single_step # branch to do_sigtrap 382 383# 384# call tracehook_report_syscall_entry/tracehook_report_syscall_exit before 385# and after the system call 386# 387sysc_tracesys: 388 la %r2,SP_PTREGS(%r15) # load pt_regs 389 la %r3,0 390 llgh %r0,SP_SVCNR(%r15) 391 stg %r0,SP_R2(%r15) 392 brasl %r14,do_syscall_trace_enter 393 lghi %r0,NR_syscalls 394 clgr %r0,%r2 395 jnh sysc_tracenogo 396 sllg %r7,%r2,2 # svc number *4 397 lgf %r8,0(%r7,%r10) 398sysc_tracego: 399 lmg %r3,%r6,SP_R3(%r15) 400 lg %r2,SP_ORIG_R2(%r15) 401 basr %r14,%r8 # call sys_xxx 402 stg %r2,SP_R2(%r15) # store return value 403sysc_tracenogo: 404 tm __TI_flags+6(%r12),_TIF_SYSCALL 405 jz sysc_return 406 la %r2,SP_PTREGS(%r15) # load pt_regs 407 larl %r14,sysc_return # return point is sysc_return 408 jg do_syscall_trace_exit 409 410# 411# a new process exits the kernel with ret_from_fork 412# 413 .globl ret_from_fork 414ret_from_fork: 415 lg %r13,__LC_SVC_NEW_PSW+8 416 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 417 tm SP_PSW+1(%r15),0x01 # forking a kernel thread ? 418 jo 0f 419 stg %r15,SP_R15(%r15) # store stack pointer for new kthread 4200: brasl %r14,schedule_tail 421 TRACE_IRQS_ON 422 stosm 24(%r15),0x03 # reenable interrupts 423 j sysc_tracenogo 424 425# 426# kernel_execve function needs to deal with pt_regs that is not 427# at the usual place 428# 429 .globl kernel_execve 430kernel_execve: 431 stmg %r12,%r15,96(%r15) 432 lgr %r14,%r15 433 aghi %r15,-SP_SIZE 434 stg %r14,__SF_BACKCHAIN(%r15) 435 la %r12,SP_PTREGS(%r15) 436 xc 0(__PT_SIZE,%r12),0(%r12) 437 lgr %r5,%r12 438 brasl %r14,do_execve 439 ltgfr %r2,%r2 440 je 0f 441 aghi %r15,SP_SIZE 442 lmg %r12,%r15,96(%r15) 443 br %r14 444 # execve succeeded. 4450: stnsm __SF_EMPTY(%r15),0xfc # disable interrupts 446# TRACE_IRQS_OFF 447 lg %r15,__LC_KERNEL_STACK # load ksp 448 aghi %r15,-SP_SIZE # make room for registers & psw 449 lg %r13,__LC_SVC_NEW_PSW+8 450 mvc SP_PTREGS(__PT_SIZE,%r15),0(%r12) # copy pt_regs 451 lg %r12,__LC_THREAD_INFO 452 xc __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15) 453# TRACE_IRQS_ON 454 stosm __SF_EMPTY(%r15),0x03 # reenable interrupts 455 brasl %r14,execve_tail 456 j sysc_return 457 458/* 459 * Program check handler routine 460 */ 461 462 .globl pgm_check_handler 463pgm_check_handler: 464 stpt __LC_SYNC_ENTER_TIMER 465 tm __LC_PGM_INT_CODE+1,0x80 # check whether we got a per exception 466 jnz pgm_per # got per exception -> special case 467 SAVE_ALL_PGM __LC_PGM_OLD_PSW,__LC_SAVE_AREA 468 CREATE_STACK_FRAME __LC_SAVE_AREA 469 xc SP_ILC(4,%r15),SP_ILC(%r15) 470 mvc SP_PSW(16,%r15),__LC_PGM_OLD_PSW 471 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 472 tm SP_PSW+1(%r15),0x01 # interrupting from user ? 473 jz pgm_no_vtime 474 UPDATE_VTIME __LC_EXIT_TIMER,__LC_SYNC_ENTER_TIMER,__LC_USER_TIMER 475 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 476 mvc __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER 477 LAST_BREAK 478pgm_no_vtime: 479 HANDLE_SIE_INTERCEPT 480 TRACE_IRQS_CHECK_OFF 481 stg %r11,SP_ARGS(%r15) 482 lgf %r3,__LC_PGM_ILC # load program interruption code 483 lghi %r8,0x7f 484 ngr %r8,%r3 485pgm_do_call: 486 sll %r8,3 487 larl %r1,pgm_check_table 488 lg %r1,0(%r8,%r1) # load address of handler routine 489 la %r2,SP_PTREGS(%r15) # address of register-save area 490 basr %r14,%r1 # branch to interrupt-handler 491pgm_exit: 492 TRACE_IRQS_CHECK_ON 493 j sysc_return 494 495# 496# handle per exception 497# 498pgm_per: 499 tm __LC_PGM_OLD_PSW,0x40 # test if per event recording is on 500 jnz pgm_per_std # ok, normal per event from user space 501# ok its one of the special cases, now we need to find out which one 502 clc __LC_PGM_OLD_PSW(16),__LC_SVC_NEW_PSW 503 je pgm_svcper 504# no interesting special case, ignore PER event 505 lpswe __LC_PGM_OLD_PSW 506 507# 508# Normal per exception 509# 510pgm_per_std: 511 SAVE_ALL_PGM __LC_PGM_OLD_PSW,__LC_SAVE_AREA 512 CREATE_STACK_FRAME __LC_SAVE_AREA 513 mvc SP_PSW(16,%r15),__LC_PGM_OLD_PSW 514 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 515 tm SP_PSW+1(%r15),0x01 # interrupting from user ? 516 jz pgm_no_vtime2 517 UPDATE_VTIME __LC_EXIT_TIMER,__LC_SYNC_ENTER_TIMER,__LC_USER_TIMER 518 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 519 mvc __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER 520 LAST_BREAK 521pgm_no_vtime2: 522 HANDLE_SIE_INTERCEPT 523 TRACE_IRQS_CHECK_OFF 524 lg %r1,__TI_task(%r12) 525 tm SP_PSW+1(%r15),0x01 # kernel per event ? 526 jz kernel_per 527 mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID 528 mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS 529 mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID 530 oi __TI_flags+7(%r12),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP 531 lgf %r3,__LC_PGM_ILC # load program interruption code 532 lghi %r8,0x7f 533 ngr %r8,%r3 # clear per-event-bit and ilc 534 je pgm_exit2 535 sll %r8,3 536 larl %r1,pgm_check_table 537 lg %r1,0(%r8,%r1) # load address of handler routine 538 la %r2,SP_PTREGS(%r15) # address of register-save area 539 basr %r14,%r1 # branch to interrupt-handler 540pgm_exit2: 541 TRACE_IRQS_ON 542 stosm __SF_EMPTY(%r15),0x03 # reenable interrupts 543 j sysc_return 544 545# 546# it was a single stepped SVC that is causing all the trouble 547# 548pgm_svcper: 549 SAVE_ALL_PGM __LC_SVC_OLD_PSW,__LC_SAVE_AREA 550 CREATE_STACK_FRAME __LC_SAVE_AREA 551 mvc SP_PSW(16,%r15),__LC_SVC_OLD_PSW 552 mvc SP_ILC(4,%r15),__LC_SVC_ILC 553 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 554 UPDATE_VTIME __LC_EXIT_TIMER,__LC_SYNC_ENTER_TIMER,__LC_USER_TIMER 555 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 556 mvc __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER 557 LAST_BREAK 558 TRACE_IRQS_OFF 559 lg %r8,__TI_task(%r12) 560 mvc __THREAD_per+__PER_atmid(2,%r8),__LC_PER_ATMID 561 mvc __THREAD_per+__PER_address(8,%r8),__LC_PER_ADDRESS 562 mvc __THREAD_per+__PER_access_id(1,%r8),__LC_PER_ACCESS_ID 563 oi __TI_flags+7(%r12),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP 564 TRACE_IRQS_ON 565 stosm __SF_EMPTY(%r15),0x03 # reenable interrupts 566 lmg %r2,%r6,SP_R2(%r15) # load svc arguments 567 j sysc_do_svc 568 569# 570# per was called from kernel, must be kprobes 571# 572kernel_per: 573 xc SP_SVCNR(2,%r15),SP_SVCNR(%r15) # clear svc number 574 la %r2,SP_PTREGS(%r15) # address of register-save area 575 brasl %r14,do_single_step 576 j pgm_exit 577 578/* 579 * IO interrupt handler routine 580 */ 581 .globl io_int_handler 582io_int_handler: 583 stck __LC_INT_CLOCK 584 stpt __LC_ASYNC_ENTER_TIMER 585 SAVE_ALL_ASYNC __LC_IO_OLD_PSW,__LC_SAVE_AREA+40 586 CREATE_STACK_FRAME __LC_SAVE_AREA+40 587 mvc SP_PSW(16,%r15),0(%r12) # move user PSW to stack 588 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 589 tm SP_PSW+1(%r15),0x01 # interrupting from user ? 590 jz io_no_vtime 591 UPDATE_VTIME __LC_EXIT_TIMER,__LC_ASYNC_ENTER_TIMER,__LC_USER_TIMER 592 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 593 mvc __LC_LAST_UPDATE_TIMER(8),__LC_ASYNC_ENTER_TIMER 594 LAST_BREAK 595io_no_vtime: 596 HANDLE_SIE_INTERCEPT 597 TRACE_IRQS_OFF 598 la %r2,SP_PTREGS(%r15) # address of register-save area 599 brasl %r14,do_IRQ # call standard irq handler 600io_return: 601 LOCKDEP_SYS_EXIT 602 TRACE_IRQS_ON 603io_tif: 604 tm __TI_flags+7(%r12),_TIF_WORK_INT 605 jnz io_work # there is work to do (signals etc.) 606io_restore: 607 RESTORE_ALL __LC_RETURN_PSW,0 608io_done: 609 610# 611# There is work todo, find out in which context we have been interrupted: 612# 1) if we return to user space we can do all _TIF_WORK_INT work 613# 2) if we return to kernel code and kvm is enabled check if we need to 614# modify the psw to leave SIE 615# 3) if we return to kernel code and preemptive scheduling is enabled check 616# the preemption counter and if it is zero call preempt_schedule_irq 617# Before any work can be done, a switch to the kernel stack is required. 618# 619io_work: 620 tm SP_PSW+1(%r15),0x01 # returning to user ? 621 jo io_work_user # yes -> do resched & signal 622#ifdef CONFIG_PREEMPT 623 # check for preemptive scheduling 624 icm %r0,15,__TI_precount(%r12) 625 jnz io_restore # preemption is disabled 626 tm __TI_flags+7(%r12),_TIF_NEED_RESCHED 627 jno io_restore 628 # switch to kernel stack 629 lg %r1,SP_R15(%r15) 630 aghi %r1,-SP_SIZE 631 mvc SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15) 632 xc __SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1) # clear back chain 633 lgr %r15,%r1 634 # TRACE_IRQS_ON already done at io_return, call 635 # TRACE_IRQS_OFF to keep things symmetrical 636 TRACE_IRQS_OFF 637 brasl %r14,preempt_schedule_irq 638 j io_return 639#else 640 j io_restore 641#endif 642 643# 644# Need to do work before returning to userspace, switch to kernel stack 645# 646io_work_user: 647 lg %r1,__LC_KERNEL_STACK 648 aghi %r1,-SP_SIZE 649 mvc SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15) 650 xc __SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1) # clear back chain 651 lgr %r15,%r1 652 653# 654# One of the work bits is on. Find out which one. 655# Checked are: _TIF_SIGPENDING, _TIF_NOTIFY_RESUME, _TIF_NEED_RESCHED 656# and _TIF_MCCK_PENDING 657# 658io_work_tif: 659 tm __TI_flags+7(%r12),_TIF_MCCK_PENDING 660 jo io_mcck_pending 661 tm __TI_flags+7(%r12),_TIF_NEED_RESCHED 662 jo io_reschedule 663 tm __TI_flags+7(%r12),_TIF_SIGPENDING 664 jo io_sigpending 665 tm __TI_flags+7(%r12),_TIF_NOTIFY_RESUME 666 jo io_notify_resume 667 j io_return # beware of critical section cleanup 668 669# 670# _TIF_MCCK_PENDING is set, call handler 671# 672io_mcck_pending: 673 # TRACE_IRQS_ON already done at io_return 674 brasl %r14,s390_handle_mcck # TIF bit will be cleared by handler 675 TRACE_IRQS_OFF 676 j io_return 677 678# 679# _TIF_NEED_RESCHED is set, call schedule 680# 681io_reschedule: 682 # TRACE_IRQS_ON already done at io_return 683 stosm __SF_EMPTY(%r15),0x03 # reenable interrupts 684 brasl %r14,schedule # call scheduler 685 stnsm __SF_EMPTY(%r15),0xfc # disable I/O and ext. interrupts 686 TRACE_IRQS_OFF 687 j io_return 688 689# 690# _TIF_SIGPENDING or is set, call do_signal 691# 692io_sigpending: 693 # TRACE_IRQS_ON already done at io_return 694 stosm __SF_EMPTY(%r15),0x03 # reenable interrupts 695 la %r2,SP_PTREGS(%r15) # load pt_regs 696 brasl %r14,do_signal # call do_signal 697 stnsm __SF_EMPTY(%r15),0xfc # disable I/O and ext. interrupts 698 TRACE_IRQS_OFF 699 j io_return 700 701# 702# _TIF_NOTIFY_RESUME or is set, call do_notify_resume 703# 704io_notify_resume: 705 # TRACE_IRQS_ON already done at io_return 706 stosm __SF_EMPTY(%r15),0x03 # reenable interrupts 707 la %r2,SP_PTREGS(%r15) # load pt_regs 708 brasl %r14,do_notify_resume # call do_notify_resume 709 stnsm __SF_EMPTY(%r15),0xfc # disable I/O and ext. interrupts 710 TRACE_IRQS_OFF 711 j io_return 712 713/* 714 * External interrupt handler routine 715 */ 716 .globl ext_int_handler 717ext_int_handler: 718 stck __LC_INT_CLOCK 719 stpt __LC_ASYNC_ENTER_TIMER 720 SAVE_ALL_ASYNC __LC_EXT_OLD_PSW,__LC_SAVE_AREA+40 721 CREATE_STACK_FRAME __LC_SAVE_AREA+40 722 mvc SP_PSW(16,%r15),0(%r12) # move user PSW to stack 723 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 724 tm SP_PSW+1(%r15),0x01 # interrupting from user ? 725 jz ext_no_vtime 726 UPDATE_VTIME __LC_EXIT_TIMER,__LC_ASYNC_ENTER_TIMER,__LC_USER_TIMER 727 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 728 mvc __LC_LAST_UPDATE_TIMER(8),__LC_ASYNC_ENTER_TIMER 729 LAST_BREAK 730ext_no_vtime: 731 HANDLE_SIE_INTERCEPT 732 TRACE_IRQS_OFF 733 la %r2,SP_PTREGS(%r15) # address of register-save area 734 llgh %r3,__LC_EXT_INT_CODE # get interruption code 735 brasl %r14,do_extint 736 j io_return 737 738__critical_end: 739 740/* 741 * Machine check handler routines 742 */ 743 .globl mcck_int_handler 744mcck_int_handler: 745 stck __LC_MCCK_CLOCK 746 la %r1,4095 # revalidate r1 747 spt __LC_CPU_TIMER_SAVE_AREA-4095(%r1) # revalidate cpu timer 748 lmg %r0,%r15,__LC_GPREGS_SAVE_AREA-4095(%r1)# revalidate gprs 749 stmg %r11,%r15,__LC_SAVE_AREA+80 750 larl %r13,system_call 751 lg %r11,__LC_LAST_BREAK 752 la %r12,__LC_MCK_OLD_PSW 753 tm __LC_MCCK_CODE,0x80 # system damage? 754 jo mcck_int_main # yes -> rest of mcck code invalid 755 la %r14,4095 756 mvc __LC_MCCK_ENTER_TIMER(8),__LC_CPU_TIMER_SAVE_AREA-4095(%r14) 757 tm __LC_MCCK_CODE+5,0x02 # stored cpu timer value valid? 758 jo 1f 759 la %r14,__LC_SYNC_ENTER_TIMER 760 clc 0(8,%r14),__LC_ASYNC_ENTER_TIMER 761 jl 0f 762 la %r14,__LC_ASYNC_ENTER_TIMER 7630: clc 0(8,%r14),__LC_EXIT_TIMER 764 jl 0f 765 la %r14,__LC_EXIT_TIMER 7660: clc 0(8,%r14),__LC_LAST_UPDATE_TIMER 767 jl 0f 768 la %r14,__LC_LAST_UPDATE_TIMER 7690: spt 0(%r14) 770 mvc __LC_MCCK_ENTER_TIMER(8),0(%r14) 7711: tm __LC_MCCK_CODE+2,0x09 # mwp + ia of old psw valid? 772 jno mcck_int_main # no -> skip cleanup critical 773 tm __LC_MCK_OLD_PSW+1,0x01 # test problem state bit 774 jnz mcck_int_main # from user -> load kernel stack 775 clc __LC_MCK_OLD_PSW+8(8),BASED(.Lcritical_end) 776 jhe mcck_int_main 777 clc __LC_MCK_OLD_PSW+8(8),BASED(.Lcritical_start) 778 jl mcck_int_main 779 brasl %r14,cleanup_critical 780mcck_int_main: 781 lg %r14,__LC_PANIC_STACK # are we already on the panic stack? 782 slgr %r14,%r15 783 srag %r14,%r14,PAGE_SHIFT 784 jz 0f 785 lg %r15,__LC_PANIC_STACK # load panic stack 7860: aghi %r15,-SP_SIZE # make room for registers & psw 787 CREATE_STACK_FRAME __LC_SAVE_AREA+80 788 mvc SP_PSW(16,%r15),0(%r12) 789 lg %r12,__LC_THREAD_INFO # load pointer to thread_info struct 790 tm __LC_MCCK_CODE+2,0x08 # mwp of old psw valid? 791 jno mcck_no_vtime # no -> no timer update 792 tm SP_PSW+1(%r15),0x01 # interrupting from user ? 793 jz mcck_no_vtime 794 UPDATE_VTIME __LC_EXIT_TIMER,__LC_MCCK_ENTER_TIMER,__LC_USER_TIMER 795 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 796 mvc __LC_LAST_UPDATE_TIMER(8),__LC_MCCK_ENTER_TIMER 797 LAST_BREAK 798mcck_no_vtime: 799 la %r2,SP_PTREGS(%r15) # load pt_regs 800 brasl %r14,s390_do_machine_check 801 tm SP_PSW+1(%r15),0x01 # returning to user ? 802 jno mcck_return 803 lg %r1,__LC_KERNEL_STACK # switch to kernel stack 804 aghi %r1,-SP_SIZE 805 mvc SP_PTREGS(__PT_SIZE,%r1),SP_PTREGS(%r15) 806 xc __SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1) # clear back chain 807 lgr %r15,%r1 808 stosm __SF_EMPTY(%r15),0x04 # turn dat on 809 tm __TI_flags+7(%r12),_TIF_MCCK_PENDING 810 jno mcck_return 811 HANDLE_SIE_INTERCEPT 812 TRACE_IRQS_OFF 813 brasl %r14,s390_handle_mcck 814 TRACE_IRQS_ON 815mcck_return: 816 mvc __LC_RETURN_MCCK_PSW(16),SP_PSW(%r15) # move return PSW 817 ni __LC_RETURN_MCCK_PSW+1,0xfd # clear wait state bit 818 lmg %r0,%r15,SP_R0(%r15) # load gprs 0-15 819 tm __LC_RETURN_MCCK_PSW+1,0x01 # returning to user ? 820 jno 0f 821 stpt __LC_EXIT_TIMER 8220: lpswe __LC_RETURN_MCCK_PSW # back to caller 823mcck_done: 824 825/* 826 * Restart interruption handler, kick starter for additional CPUs 827 */ 828#ifdef CONFIG_SMP 829 __CPUINIT 830 .globl restart_int_handler 831restart_int_handler: 832 basr %r1,0 833restart_base: 834 spt restart_vtime-restart_base(%r1) 835 stck __LC_LAST_UPDATE_CLOCK 836 mvc __LC_LAST_UPDATE_TIMER(8),restart_vtime-restart_base(%r1) 837 mvc __LC_EXIT_TIMER(8),restart_vtime-restart_base(%r1) 838 lg %r15,__LC_SAVE_AREA+120 # load ksp 839 lghi %r10,__LC_CREGS_SAVE_AREA 840 lctlg %c0,%c15,0(%r10) # get new ctl regs 841 lghi %r10,__LC_AREGS_SAVE_AREA 842 lam %a0,%a15,0(%r10) 843 lmg %r6,%r15,__SF_GPRS(%r15) # load registers from clone 844 lg %r1,__LC_THREAD_INFO 845 mvc __LC_USER_TIMER(8),__TI_user_timer(%r1) 846 mvc __LC_SYSTEM_TIMER(8),__TI_system_timer(%r1) 847 xc __LC_STEAL_TIMER(8),__LC_STEAL_TIMER 848 stosm __SF_EMPTY(%r15),0x04 # now we can turn dat on 849 jg start_secondary 850 .align 8 851restart_vtime: 852 .long 0x7fffffff,0xffffffff 853 .previous 854#else 855/* 856 * If we do not run with SMP enabled, let the new CPU crash ... 857 */ 858 .globl restart_int_handler 859restart_int_handler: 860 basr %r1,0 861restart_base: 862 lpswe restart_crash-restart_base(%r1) 863 .align 8 864restart_crash: 865 .long 0x000a0000,0x00000000,0x00000000,0x00000000 866restart_go: 867#endif 868 869#ifdef CONFIG_CHECK_STACK 870/* 871 * The synchronous or the asynchronous stack overflowed. We are dead. 872 * No need to properly save the registers, we are going to panic anyway. 873 * Setup a pt_regs so that show_trace can provide a good call trace. 874 */ 875stack_overflow: 876 lg %r15,__LC_PANIC_STACK # change to panic stack 877 aghi %r15,-SP_SIZE 878 mvc SP_PSW(16,%r15),0(%r12) # move user PSW to stack 879 stmg %r0,%r10,SP_R0(%r15) # store gprs %r0-%r10 to kernel stack 880 la %r1,__LC_SAVE_AREA 881 chi %r12,__LC_SVC_OLD_PSW 882 je 0f 883 chi %r12,__LC_PGM_OLD_PSW 884 je 0f 885 la %r1,__LC_SAVE_AREA+40 8860: mvc SP_R11(40,%r15),0(%r1) # move %r11-%r15 to stack 887 mvc SP_ARGS(8,%r15),__LC_LAST_BREAK 888 xc __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15) # clear back chain 889 la %r2,SP_PTREGS(%r15) # load pt_regs 890 jg kernel_stack_overflow 891#endif 892 893cleanup_table_system_call: 894 .quad system_call, sysc_do_svc 895cleanup_table_sysc_tif: 896 .quad sysc_tif, sysc_restore 897cleanup_table_sysc_restore: 898 .quad sysc_restore, sysc_done 899cleanup_table_io_tif: 900 .quad io_tif, io_restore 901cleanup_table_io_restore: 902 .quad io_restore, io_done 903 904cleanup_critical: 905 clc 8(8,%r12),BASED(cleanup_table_system_call) 906 jl 0f 907 clc 8(8,%r12),BASED(cleanup_table_system_call+8) 908 jl cleanup_system_call 9090: 910 clc 8(8,%r12),BASED(cleanup_table_sysc_tif) 911 jl 0f 912 clc 8(8,%r12),BASED(cleanup_table_sysc_tif+8) 913 jl cleanup_sysc_tif 9140: 915 clc 8(8,%r12),BASED(cleanup_table_sysc_restore) 916 jl 0f 917 clc 8(8,%r12),BASED(cleanup_table_sysc_restore+8) 918 jl cleanup_sysc_restore 9190: 920 clc 8(8,%r12),BASED(cleanup_table_io_tif) 921 jl 0f 922 clc 8(8,%r12),BASED(cleanup_table_io_tif+8) 923 jl cleanup_io_tif 9240: 925 clc 8(8,%r12),BASED(cleanup_table_io_restore) 926 jl 0f 927 clc 8(8,%r12),BASED(cleanup_table_io_restore+8) 928 jl cleanup_io_restore 9290: 930 br %r14 931 932cleanup_system_call: 933 mvc __LC_RETURN_PSW(16),0(%r12) 934 clc __LC_RETURN_PSW+8(8),BASED(cleanup_system_call_insn+8) 935 jh 0f 936 mvc __LC_SYNC_ENTER_TIMER(8),__LC_MCCK_ENTER_TIMER 937 cghi %r12,__LC_MCK_OLD_PSW 938 je 0f 939 mvc __LC_SYNC_ENTER_TIMER(8),__LC_ASYNC_ENTER_TIMER 9400: cghi %r12,__LC_MCK_OLD_PSW 941 la %r12,__LC_SAVE_AREA+80 942 je 0f 943 la %r12,__LC_SAVE_AREA+40 9440: clc __LC_RETURN_PSW+8(8),BASED(cleanup_system_call_insn+16) 945 jhe cleanup_vtime 946 clc __LC_RETURN_PSW+8(8),BASED(cleanup_system_call_insn) 947 jh 0f 948 mvc __LC_SAVE_AREA(40),0(%r12) 9490: lg %r15,__LC_KERNEL_STACK # problem state -> load ksp 950 aghi %r15,-SP_SIZE # make room for registers & psw 951 stg %r15,32(%r12) 952 stg %r11,0(%r12) 953 CREATE_STACK_FRAME __LC_SAVE_AREA 954 mvc SP_PSW(16,%r15),__LC_SVC_OLD_PSW 955 mvc SP_ILC(4,%r15),__LC_SVC_ILC 956 stg %r7,SP_ARGS(%r15) 957 mvc 8(8,%r12),__LC_THREAD_INFO 958cleanup_vtime: 959 clc __LC_RETURN_PSW+8(8),BASED(cleanup_system_call_insn+24) 960 jhe cleanup_stime 961 UPDATE_VTIME __LC_EXIT_TIMER,__LC_SYNC_ENTER_TIMER,__LC_USER_TIMER 962cleanup_stime: 963 clc __LC_RETURN_PSW+8(8),BASED(cleanup_system_call_insn+32) 964 jh cleanup_update 965 UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMER 966cleanup_update: 967 mvc __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER 968 srag %r12,%r11,23 969 lg %r12,__LC_THREAD_INFO 970 jz 0f 971 stg %r11,__TI_last_break(%r12) 9720: mvc __LC_RETURN_PSW+8(8),BASED(cleanup_table_system_call+8) 973 la %r12,__LC_RETURN_PSW 974 br %r14 975cleanup_system_call_insn: 976 .quad sysc_saveall 977 .quad system_call 978 .quad sysc_vtime 979 .quad sysc_stime 980 .quad sysc_update 981 982cleanup_sysc_tif: 983 mvc __LC_RETURN_PSW(8),0(%r12) 984 mvc __LC_RETURN_PSW+8(8),BASED(cleanup_table_sysc_tif) 985 la %r12,__LC_RETURN_PSW 986 br %r14 987 988cleanup_sysc_restore: 989 clc 8(8,%r12),BASED(cleanup_sysc_restore_insn) 990 je 2f 991 clc 8(8,%r12),BASED(cleanup_sysc_restore_insn+8) 992 jhe 0f 993 mvc __LC_EXIT_TIMER(8),__LC_MCCK_ENTER_TIMER 994 cghi %r12,__LC_MCK_OLD_PSW 995 je 0f 996 mvc __LC_EXIT_TIMER(8),__LC_ASYNC_ENTER_TIMER 9970: mvc __LC_RETURN_PSW(16),SP_PSW(%r15) 998 cghi %r12,__LC_MCK_OLD_PSW 999 la %r12,__LC_SAVE_AREA+80 1000 je 1f 1001 la %r12,__LC_SAVE_AREA+40 10021: mvc 0(40,%r12),SP_R11(%r15) 1003 lmg %r0,%r10,SP_R0(%r15) 1004 lg %r15,SP_R15(%r15) 10052: la %r12,__LC_RETURN_PSW 1006 br %r14 1007cleanup_sysc_restore_insn: 1008 .quad sysc_done - 4 1009 .quad sysc_done - 16 1010 1011cleanup_io_tif: 1012 mvc __LC_RETURN_PSW(8),0(%r12) 1013 mvc __LC_RETURN_PSW+8(8),BASED(cleanup_table_io_tif) 1014 la %r12,__LC_RETURN_PSW 1015 br %r14 1016 1017cleanup_io_restore: 1018 clc 8(8,%r12),BASED(cleanup_io_restore_insn) 1019 je 1f 1020 clc 8(8,%r12),BASED(cleanup_io_restore_insn+8) 1021 jhe 0f 1022 mvc __LC_EXIT_TIMER(8),__LC_MCCK_ENTER_TIMER 10230: mvc __LC_RETURN_PSW(16),SP_PSW(%r15) 1024 mvc __LC_SAVE_AREA+80(40),SP_R11(%r15) 1025 lmg %r0,%r10,SP_R0(%r15) 1026 lg %r15,SP_R15(%r15) 10271: la %r12,__LC_RETURN_PSW 1028 br %r14 1029cleanup_io_restore_insn: 1030 .quad io_done - 4 1031 .quad io_done - 16 1032 1033/* 1034 * Integer constants 1035 */ 1036 .align 4 1037.Lcritical_start: 1038 .quad __critical_start 1039.Lcritical_end: 1040 .quad __critical_end 1041 1042 .section .rodata, "a" 1043#define SYSCALL(esa,esame,emu) .long esame 1044 .globl sys_call_table 1045sys_call_table: 1046#include "syscalls.S" 1047#undef SYSCALL 1048 1049#ifdef CONFIG_COMPAT 1050 1051#define SYSCALL(esa,esame,emu) .long emu 1052sys_call_table_emu: 1053#include "syscalls.S" 1054#undef SYSCALL 1055#endif 1056