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