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