Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
[muen/linux.git] / arch / s390 / kernel / entry.S
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  *    S390 low-level entry points.
4  *
5  *    Copyright IBM Corp. 1999, 2012
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/init.h>
13 #include <linux/linkage.h>
14 #include <asm/alternative-asm.h>
15 #include <asm/processor.h>
16 #include <asm/cache.h>
17 #include <asm/ctl_reg.h>
18 #include <asm/dwarf.h>
19 #include <asm/errno.h>
20 #include <asm/ptrace.h>
21 #include <asm/thread_info.h>
22 #include <asm/asm-offsets.h>
23 #include <asm/unistd.h>
24 #include <asm/page.h>
25 #include <asm/sigp.h>
26 #include <asm/irq.h>
27 #include <asm/vx-insn.h>
28 #include <asm/setup.h>
29 #include <asm/nmi.h>
30 #include <asm/export.h>
31
32 __PT_R0      =  __PT_GPRS
33 __PT_R1      =  __PT_GPRS + 8
34 __PT_R2      =  __PT_GPRS + 16
35 __PT_R3      =  __PT_GPRS + 24
36 __PT_R4      =  __PT_GPRS + 32
37 __PT_R5      =  __PT_GPRS + 40
38 __PT_R6      =  __PT_GPRS + 48
39 __PT_R7      =  __PT_GPRS + 56
40 __PT_R8      =  __PT_GPRS + 64
41 __PT_R9      =  __PT_GPRS + 72
42 __PT_R10     =  __PT_GPRS + 80
43 __PT_R11     =  __PT_GPRS + 88
44 __PT_R12     =  __PT_GPRS + 96
45 __PT_R13     =  __PT_GPRS + 104
46 __PT_R14     =  __PT_GPRS + 112
47 __PT_R15     =  __PT_GPRS + 120
48
49 STACK_SHIFT = PAGE_SHIFT + THREAD_SIZE_ORDER
50 STACK_SIZE  = 1 << STACK_SHIFT
51 STACK_INIT = STACK_SIZE - STACK_FRAME_OVERHEAD - __PT_SIZE
52
53 _TIF_WORK       = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
54                    _TIF_UPROBE | _TIF_GUARDED_STORAGE | _TIF_PATCH_PENDING)
55 _TIF_TRACE      = (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP | \
56                    _TIF_SYSCALL_TRACEPOINT)
57 _CIF_WORK       = (_CIF_MCCK_PENDING | _CIF_ASCE_PRIMARY | \
58                    _CIF_ASCE_SECONDARY | _CIF_FPU)
59 _PIF_WORK       = (_PIF_PER_TRAP | _PIF_SYSCALL_RESTART)
60
61 _LPP_OFFSET     = __LC_LPP
62
63 #define BASED(name) name-cleanup_critical(%r13)
64
65         .macro  TRACE_IRQS_ON
66 #ifdef CONFIG_TRACE_IRQFLAGS
67         basr    %r2,%r0
68         brasl   %r14,trace_hardirqs_on_caller
69 #endif
70         .endm
71
72         .macro  TRACE_IRQS_OFF
73 #ifdef CONFIG_TRACE_IRQFLAGS
74         basr    %r2,%r0
75         brasl   %r14,trace_hardirqs_off_caller
76 #endif
77         .endm
78
79         .macro  LOCKDEP_SYS_EXIT
80 #ifdef CONFIG_LOCKDEP
81         tm      __PT_PSW+1(%r11),0x01   # returning to user ?
82         jz      .+10
83         brasl   %r14,lockdep_sys_exit
84 #endif
85         .endm
86
87         .macro  CHECK_STACK stacksize,savearea
88 #ifdef CONFIG_CHECK_STACK
89         tml     %r15,\stacksize - CONFIG_STACK_GUARD
90         lghi    %r14,\savearea
91         jz      stack_overflow
92 #endif
93         .endm
94
95         .macro  SWITCH_ASYNC savearea,timer
96         tmhh    %r8,0x0001              # interrupting from user ?
97         jnz     1f
98         lgr     %r14,%r9
99         slg     %r14,BASED(.Lcritical_start)
100         clg     %r14,BASED(.Lcritical_length)
101         jhe     0f
102         lghi    %r11,\savearea          # inside critical section, do cleanup
103         brasl   %r14,cleanup_critical
104         tmhh    %r8,0x0001              # retest problem state after cleanup
105         jnz     1f
106 0:      lg      %r14,__LC_ASYNC_STACK   # are we already on the async stack?
107         slgr    %r14,%r15
108         srag    %r14,%r14,STACK_SHIFT
109         jnz     2f
110         CHECK_STACK 1<<STACK_SHIFT,\savearea
111         aghi    %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
112         j       3f
113 1:      UPDATE_VTIME %r14,%r15,\timer
114         BPENTER __TI_flags(%r12),_TIF_ISOLATE_BP
115 2:      lg      %r15,__LC_ASYNC_STACK   # load async stack
116 3:      la      %r11,STACK_FRAME_OVERHEAD(%r15)
117         .endm
118
119         .macro UPDATE_VTIME w1,w2,enter_timer
120         lg      \w1,__LC_EXIT_TIMER
121         lg      \w2,__LC_LAST_UPDATE_TIMER
122         slg     \w1,\enter_timer
123         slg     \w2,__LC_EXIT_TIMER
124         alg     \w1,__LC_USER_TIMER
125         alg     \w2,__LC_SYSTEM_TIMER
126         stg     \w1,__LC_USER_TIMER
127         stg     \w2,__LC_SYSTEM_TIMER
128         mvc     __LC_LAST_UPDATE_TIMER(8),\enter_timer
129         .endm
130
131         .macro REENABLE_IRQS
132         stg     %r8,__LC_RETURN_PSW
133         ni      __LC_RETURN_PSW,0xbf
134         ssm     __LC_RETURN_PSW
135         .endm
136
137         .macro STCK savearea
138 #ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES
139         .insn   s,0xb27c0000,\savearea          # store clock fast
140 #else
141         .insn   s,0xb2050000,\savearea          # store clock
142 #endif
143         .endm
144
145         /*
146          * The TSTMSK macro generates a test-under-mask instruction by
147          * calculating the memory offset for the specified mask value.
148          * Mask value can be any constant.  The macro shifts the mask
149          * value to calculate the memory offset for the test-under-mask
150          * instruction.
151          */
152         .macro TSTMSK addr, mask, size=8, bytepos=0
153                 .if (\bytepos < \size) && (\mask >> 8)
154                         .if (\mask & 0xff)
155                                 .error "Mask exceeds byte boundary"
156                         .endif
157                         TSTMSK \addr, "(\mask >> 8)", \size, "(\bytepos + 1)"
158                         .exitm
159                 .endif
160                 .ifeq \mask
161                         .error "Mask must not be zero"
162                 .endif
163                 off = \size - \bytepos - 1
164                 tm      off+\addr, \mask
165         .endm
166
167         .macro BPOFF
168         ALTERNATIVE "", ".long 0xb2e8c000", 82
169         .endm
170
171         .macro BPON
172         ALTERNATIVE "", ".long 0xb2e8d000", 82
173         .endm
174
175         .macro BPENTER tif_ptr,tif_mask
176         ALTERNATIVE "TSTMSK \tif_ptr,\tif_mask; jz .+8; .long 0xb2e8d000", \
177                     "", 82
178         .endm
179
180         .macro BPEXIT tif_ptr,tif_mask
181         TSTMSK  \tif_ptr,\tif_mask
182         ALTERNATIVE "jz .+8;  .long 0xb2e8c000", \
183                     "jnz .+8; .long 0xb2e8d000", 82
184         .endm
185
186 #ifdef CONFIG_EXPOLINE
187
188         .macro GEN_BR_THUNK name,reg,tmp
189         .section .text.\name,"axG",@progbits,\name,comdat
190         .globl \name
191         .hidden \name
192         .type \name,@function
193 \name:
194         CFI_STARTPROC
195 #ifdef CONFIG_HAVE_MARCH_Z10_FEATURES
196         exrl    0,0f
197 #else
198         larl    \tmp,0f
199         ex      0,0(\tmp)
200 #endif
201         j       .
202 0:      br      \reg
203         CFI_ENDPROC
204         .endm
205
206         GEN_BR_THUNK __s390x_indirect_jump_r1use_r9,%r9,%r1
207         GEN_BR_THUNK __s390x_indirect_jump_r1use_r14,%r14,%r1
208         GEN_BR_THUNK __s390x_indirect_jump_r11use_r14,%r14,%r11
209
210         .macro BASR_R14_R9
211 0:      brasl   %r14,__s390x_indirect_jump_r1use_r9
212         .pushsection .s390_indirect_branches,"a",@progbits
213         .long   0b-.
214         .popsection
215         .endm
216
217         .macro BR_R1USE_R14
218 0:      jg      __s390x_indirect_jump_r1use_r14
219         .pushsection .s390_indirect_branches,"a",@progbits
220         .long   0b-.
221         .popsection
222         .endm
223
224         .macro BR_R11USE_R14
225 0:      jg      __s390x_indirect_jump_r11use_r14
226         .pushsection .s390_indirect_branches,"a",@progbits
227         .long   0b-.
228         .popsection
229         .endm
230
231 #else   /* CONFIG_EXPOLINE */
232
233         .macro BASR_R14_R9
234         basr    %r14,%r9
235         .endm
236
237         .macro BR_R1USE_R14
238         br      %r14
239         .endm
240
241         .macro BR_R11USE_R14
242         br      %r14
243         .endm
244
245 #endif /* CONFIG_EXPOLINE */
246
247
248         .section .kprobes.text, "ax"
249 .Ldummy:
250         /*
251          * This nop exists only in order to avoid that __switch_to starts at
252          * the beginning of the kprobes text section. In that case we would
253          * have several symbols at the same address. E.g. objdump would take
254          * an arbitrary symbol name when disassembling this code.
255          * With the added nop in between the __switch_to symbol is unique
256          * again.
257          */
258         nop     0
259
260 ENTRY(__bpon)
261         .globl __bpon
262         BPON
263         BR_R1USE_R14
264
265 /*
266  * Scheduler resume function, called by switch_to
267  *  gpr2 = (task_struct *) prev
268  *  gpr3 = (task_struct *) next
269  * Returns:
270  *  gpr2 = prev
271  */
272 ENTRY(__switch_to)
273         stmg    %r6,%r15,__SF_GPRS(%r15)        # store gprs of prev task
274         lghi    %r4,__TASK_stack
275         lghi    %r1,__TASK_thread
276         lg      %r5,0(%r4,%r3)                  # start of kernel stack of next
277         stg     %r15,__THREAD_ksp(%r1,%r2)      # store kernel stack of prev
278         lgr     %r15,%r5
279         aghi    %r15,STACK_INIT                 # end of kernel stack of next
280         stg     %r3,__LC_CURRENT                # store task struct of next
281         stg     %r15,__LC_KERNEL_STACK          # store end of kernel stack
282         lg      %r15,__THREAD_ksp(%r1,%r3)      # load kernel stack of next
283         aghi    %r3,__TASK_pid
284         mvc     __LC_CURRENT_PID(4,%r0),0(%r3)  # store pid of next
285         lmg     %r6,%r15,__SF_GPRS(%r15)        # load gprs of next task
286         ALTERNATIVE "", ".insn s,0xb2800000,_LPP_OFFSET", 40
287         BR_R1USE_R14
288
289 .L__critical_start:
290
291 #if IS_ENABLED(CONFIG_KVM)
292 /*
293  * sie64a calling convention:
294  * %r2 pointer to sie control block
295  * %r3 guest register save area
296  */
297 ENTRY(sie64a)
298         stmg    %r6,%r14,__SF_GPRS(%r15)        # save kernel registers
299         lg      %r12,__LC_CURRENT
300         stg     %r2,__SF_SIE_CONTROL(%r15)      # save control block pointer
301         stg     %r3,__SF_SIE_SAVEAREA(%r15)     # save guest register save area
302         xc      __SF_SIE_REASON(8,%r15),__SF_SIE_REASON(%r15) # reason code = 0
303         mvc     __SF_SIE_FLAGS(8,%r15),__TI_flags(%r12) # copy thread flags
304         TSTMSK  __LC_CPU_FLAGS,_CIF_FPU         # load guest fp/vx registers ?
305         jno     .Lsie_load_guest_gprs
306         brasl   %r14,load_fpu_regs              # load guest fp/vx regs
307 .Lsie_load_guest_gprs:
308         lmg     %r0,%r13,0(%r3)                 # load guest gprs 0-13
309         lg      %r14,__LC_GMAP                  # get gmap pointer
310         ltgr    %r14,%r14
311         jz      .Lsie_gmap
312         lctlg   %c1,%c1,__GMAP_ASCE(%r14)       # load primary asce
313 .Lsie_gmap:
314         lg      %r14,__SF_SIE_CONTROL(%r15)     # get control block pointer
315         oi      __SIE_PROG0C+3(%r14),1          # we are going into SIE now
316         tm      __SIE_PROG20+3(%r14),3          # last exit...
317         jnz     .Lsie_skip
318         TSTMSK  __LC_CPU_FLAGS,_CIF_FPU
319         jo      .Lsie_skip                      # exit if fp/vx regs changed
320         BPEXIT  __SF_SIE_FLAGS(%r15),(_TIF_ISOLATE_BP|_TIF_ISOLATE_BP_GUEST)
321 .Lsie_entry:
322         sie     0(%r14)
323 .Lsie_exit:
324         BPOFF
325         BPENTER __SF_SIE_FLAGS(%r15),(_TIF_ISOLATE_BP|_TIF_ISOLATE_BP_GUEST)
326 .Lsie_skip:
327         ni      __SIE_PROG0C+3(%r14),0xfe       # no longer in SIE
328         lctlg   %c1,%c1,__LC_USER_ASCE          # load primary asce
329 .Lsie_done:
330 # some program checks are suppressing. C code (e.g. do_protection_exception)
331 # will rewind the PSW by the ILC, which is often 4 bytes in case of SIE. There
332 # are some corner cases (e.g. runtime instrumentation) where ILC is unpredictable.
333 # Other instructions between sie64a and .Lsie_done should not cause program
334 # interrupts. So lets use 3 nops as a landing pad for all possible rewinds.
335 # See also .Lcleanup_sie
336 .Lrewind_pad6:
337         nopr    7
338 .Lrewind_pad4:
339         nopr    7
340 .Lrewind_pad2:
341         nopr    7
342         .globl sie_exit
343 sie_exit:
344         lg      %r14,__SF_SIE_SAVEAREA(%r15)    # load guest register save area
345         stmg    %r0,%r13,0(%r14)                # save guest gprs 0-13
346         xgr     %r0,%r0                         # clear guest registers to
347         xgr     %r1,%r1                         # prevent speculative use
348         xgr     %r2,%r2
349         xgr     %r3,%r3
350         xgr     %r4,%r4
351         xgr     %r5,%r5
352         lmg     %r6,%r14,__SF_GPRS(%r15)        # restore kernel registers
353         lg      %r2,__SF_SIE_REASON(%r15)       # return exit reason code
354         BR_R1USE_R14
355 .Lsie_fault:
356         lghi    %r14,-EFAULT
357         stg     %r14,__SF_SIE_REASON(%r15)      # set exit reason code
358         j       sie_exit
359
360         EX_TABLE(.Lrewind_pad6,.Lsie_fault)
361         EX_TABLE(.Lrewind_pad4,.Lsie_fault)
362         EX_TABLE(.Lrewind_pad2,.Lsie_fault)
363         EX_TABLE(sie_exit,.Lsie_fault)
364 EXPORT_SYMBOL(sie64a)
365 EXPORT_SYMBOL(sie_exit)
366 #endif
367
368 /*
369  * SVC interrupt handler routine. System calls are synchronous events and
370  * are executed with interrupts enabled.
371  */
372
373 ENTRY(system_call)
374         stpt    __LC_SYNC_ENTER_TIMER
375 .Lsysc_stmg:
376         stmg    %r8,%r15,__LC_SAVE_AREA_SYNC
377         BPOFF
378         lg      %r12,__LC_CURRENT
379         lghi    %r13,__TASK_thread
380         lghi    %r14,_PIF_SYSCALL
381 .Lsysc_per:
382         lg      %r15,__LC_KERNEL_STACK
383         la      %r11,STACK_FRAME_OVERHEAD(%r15) # pointer to pt_regs
384 .Lsysc_vtime:
385         UPDATE_VTIME %r8,%r9,__LC_SYNC_ENTER_TIMER
386         BPENTER __TI_flags(%r12),_TIF_ISOLATE_BP
387         stmg    %r0,%r7,__PT_R0(%r11)
388         mvc     __PT_R8(64,%r11),__LC_SAVE_AREA_SYNC
389         mvc     __PT_PSW(16,%r11),__LC_SVC_OLD_PSW
390         mvc     __PT_INT_CODE(4,%r11),__LC_SVC_ILC
391         stg     %r14,__PT_FLAGS(%r11)
392 .Lsysc_do_svc:
393         # clear user controlled register to prevent speculative use
394         xgr     %r0,%r0
395         # load address of system call table
396         lg      %r10,__THREAD_sysc_table(%r13,%r12)
397         llgh    %r8,__PT_INT_CODE+2(%r11)
398         slag    %r8,%r8,2                       # shift and test for svc 0
399         jnz     .Lsysc_nr_ok
400         # svc 0: system call number in %r1
401         llgfr   %r1,%r1                         # clear high word in r1
402         cghi    %r1,NR_syscalls
403         jnl     .Lsysc_nr_ok
404         sth     %r1,__PT_INT_CODE+2(%r11)
405         slag    %r8,%r1,2
406 .Lsysc_nr_ok:
407         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
408         stg     %r2,__PT_ORIG_GPR2(%r11)
409         stg     %r7,STACK_FRAME_OVERHEAD(%r15)
410         lgf     %r9,0(%r8,%r10)                 # get system call add.
411         TSTMSK  __TI_flags(%r12),_TIF_TRACE
412         jnz     .Lsysc_tracesys
413         BASR_R14_R9                             # call sys_xxxx
414         stg     %r2,__PT_R2(%r11)               # store return value
415
416 .Lsysc_return:
417         LOCKDEP_SYS_EXIT
418 .Lsysc_tif:
419         TSTMSK  __PT_FLAGS(%r11),_PIF_WORK
420         jnz     .Lsysc_work
421         TSTMSK  __TI_flags(%r12),_TIF_WORK
422         jnz     .Lsysc_work                     # check for work
423         TSTMSK  __LC_CPU_FLAGS,_CIF_WORK
424         jnz     .Lsysc_work
425         BPEXIT  __TI_flags(%r12),_TIF_ISOLATE_BP
426 .Lsysc_restore:
427         lg      %r14,__LC_VDSO_PER_CPU
428         lmg     %r0,%r10,__PT_R0(%r11)
429         mvc     __LC_RETURN_PSW(16),__PT_PSW(%r11)
430 .Lsysc_exit_timer:
431         stpt    __LC_EXIT_TIMER
432         mvc     __VDSO_ECTG_BASE(16,%r14),__LC_EXIT_TIMER
433         lmg     %r11,%r15,__PT_R11(%r11)
434         lpswe   __LC_RETURN_PSW
435 .Lsysc_done:
436
437 #
438 # One of the work bits is on. Find out which one.
439 #
440 .Lsysc_work:
441         TSTMSK  __LC_CPU_FLAGS,_CIF_MCCK_PENDING
442         jo      .Lsysc_mcck_pending
443         TSTMSK  __TI_flags(%r12),_TIF_NEED_RESCHED
444         jo      .Lsysc_reschedule
445         TSTMSK  __PT_FLAGS(%r11),_PIF_SYSCALL_RESTART
446         jo      .Lsysc_syscall_restart
447 #ifdef CONFIG_UPROBES
448         TSTMSK  __TI_flags(%r12),_TIF_UPROBE
449         jo      .Lsysc_uprobe_notify
450 #endif
451         TSTMSK  __TI_flags(%r12),_TIF_GUARDED_STORAGE
452         jo      .Lsysc_guarded_storage
453         TSTMSK  __PT_FLAGS(%r11),_PIF_PER_TRAP
454         jo      .Lsysc_singlestep
455 #ifdef CONFIG_LIVEPATCH
456         TSTMSK  __TI_flags(%r12),_TIF_PATCH_PENDING
457         jo      .Lsysc_patch_pending    # handle live patching just before
458                                         # signals and possible syscall restart
459 #endif
460         TSTMSK  __PT_FLAGS(%r11),_PIF_SYSCALL_RESTART
461         jo      .Lsysc_syscall_restart
462         TSTMSK  __TI_flags(%r12),_TIF_SIGPENDING
463         jo      .Lsysc_sigpending
464         TSTMSK  __TI_flags(%r12),_TIF_NOTIFY_RESUME
465         jo      .Lsysc_notify_resume
466         TSTMSK  __LC_CPU_FLAGS,_CIF_FPU
467         jo      .Lsysc_vxrs
468         TSTMSK  __LC_CPU_FLAGS,(_CIF_ASCE_PRIMARY|_CIF_ASCE_SECONDARY)
469         jnz     .Lsysc_asce
470         j       .Lsysc_return           # beware of critical section cleanup
471
472 #
473 # _TIF_NEED_RESCHED is set, call schedule
474 #
475 .Lsysc_reschedule:
476         larl    %r14,.Lsysc_return
477         jg      schedule
478
479 #
480 # _CIF_MCCK_PENDING is set, call handler
481 #
482 .Lsysc_mcck_pending:
483         larl    %r14,.Lsysc_return
484         jg      s390_handle_mcck        # TIF bit will be cleared by handler
485
486 #
487 # _CIF_ASCE_PRIMARY and/or _CIF_ASCE_SECONDARY set, load user space asce
488 #
489 .Lsysc_asce:
490         ni      __LC_CPU_FLAGS+7,255-_CIF_ASCE_SECONDARY
491         lctlg   %c7,%c7,__LC_VDSO_ASCE          # load secondary asce
492         TSTMSK  __LC_CPU_FLAGS,_CIF_ASCE_PRIMARY
493         jz      .Lsysc_return
494 #ifndef CONFIG_HAVE_MARCH_Z10_FEATURES
495         tm      __LC_STFLE_FAC_LIST+3,0x10      # has MVCOS ?
496         jnz     .Lsysc_set_fs_fixup
497         ni      __LC_CPU_FLAGS+7,255-_CIF_ASCE_PRIMARY
498         lctlg   %c1,%c1,__LC_USER_ASCE          # load primary asce
499         j       .Lsysc_return
500 .Lsysc_set_fs_fixup:
501 #endif
502         larl    %r14,.Lsysc_return
503         jg      set_fs_fixup
504
505 #
506 # CIF_FPU is set, restore floating-point controls and floating-point registers.
507 #
508 .Lsysc_vxrs:
509         larl    %r14,.Lsysc_return
510         jg      load_fpu_regs
511
512 #
513 # _TIF_SIGPENDING is set, call do_signal
514 #
515 .Lsysc_sigpending:
516         lgr     %r2,%r11                # pass pointer to pt_regs
517         brasl   %r14,do_signal
518         TSTMSK  __PT_FLAGS(%r11),_PIF_SYSCALL
519         jno     .Lsysc_return
520 .Lsysc_do_syscall:
521         lghi    %r13,__TASK_thread
522         lmg     %r2,%r7,__PT_R2(%r11)   # load svc arguments
523         lghi    %r1,0                   # svc 0 returns -ENOSYS
524         j       .Lsysc_do_svc
525
526 #
527 # _TIF_NOTIFY_RESUME is set, call do_notify_resume
528 #
529 .Lsysc_notify_resume:
530         lgr     %r2,%r11                # pass pointer to pt_regs
531         larl    %r14,.Lsysc_return
532         jg      do_notify_resume
533
534 #
535 # _TIF_UPROBE is set, call uprobe_notify_resume
536 #
537 #ifdef CONFIG_UPROBES
538 .Lsysc_uprobe_notify:
539         lgr     %r2,%r11                # pass pointer to pt_regs
540         larl    %r14,.Lsysc_return
541         jg      uprobe_notify_resume
542 #endif
543
544 #
545 # _TIF_GUARDED_STORAGE is set, call guarded_storage_load
546 #
547 .Lsysc_guarded_storage:
548         lgr     %r2,%r11                # pass pointer to pt_regs
549         larl    %r14,.Lsysc_return
550         jg      gs_load_bc_cb
551 #
552 # _TIF_PATCH_PENDING is set, call klp_update_patch_state
553 #
554 #ifdef CONFIG_LIVEPATCH
555 .Lsysc_patch_pending:
556         lg      %r2,__LC_CURRENT        # pass pointer to task struct
557         larl    %r14,.Lsysc_return
558         jg      klp_update_patch_state
559 #endif
560
561 #
562 # _PIF_PER_TRAP is set, call do_per_trap
563 #
564 .Lsysc_singlestep:
565         ni      __PT_FLAGS+7(%r11),255-_PIF_PER_TRAP
566         lgr     %r2,%r11                # pass pointer to pt_regs
567         larl    %r14,.Lsysc_return
568         jg      do_per_trap
569
570 #
571 # _PIF_SYSCALL_RESTART is set, repeat the current system call
572 #
573 .Lsysc_syscall_restart:
574         ni      __PT_FLAGS+7(%r11),255-_PIF_SYSCALL_RESTART
575         lmg     %r1,%r7,__PT_R1(%r11)   # load svc arguments
576         lg      %r2,__PT_ORIG_GPR2(%r11)
577         j       .Lsysc_do_svc
578
579 #
580 # call tracehook_report_syscall_entry/tracehook_report_syscall_exit before
581 # and after the system call
582 #
583 .Lsysc_tracesys:
584         lgr     %r2,%r11                # pass pointer to pt_regs
585         la      %r3,0
586         llgh    %r0,__PT_INT_CODE+2(%r11)
587         stg     %r0,__PT_R2(%r11)
588         brasl   %r14,do_syscall_trace_enter
589         lghi    %r0,NR_syscalls
590         clgr    %r0,%r2
591         jnh     .Lsysc_tracenogo
592         sllg    %r8,%r2,2
593         lgf     %r9,0(%r8,%r10)
594 .Lsysc_tracego:
595         lmg     %r3,%r7,__PT_R3(%r11)
596         stg     %r7,STACK_FRAME_OVERHEAD(%r15)
597         lg      %r2,__PT_ORIG_GPR2(%r11)
598         BASR_R14_R9                     # call sys_xxx
599         stg     %r2,__PT_R2(%r11)       # store return value
600 .Lsysc_tracenogo:
601         TSTMSK  __TI_flags(%r12),_TIF_TRACE
602         jz      .Lsysc_return
603         lgr     %r2,%r11                # pass pointer to pt_regs
604         larl    %r14,.Lsysc_return
605         jg      do_syscall_trace_exit
606
607 #
608 # a new process exits the kernel with ret_from_fork
609 #
610 ENTRY(ret_from_fork)
611         la      %r11,STACK_FRAME_OVERHEAD(%r15)
612         lg      %r12,__LC_CURRENT
613         brasl   %r14,schedule_tail
614         TRACE_IRQS_ON
615         ssm     __LC_SVC_NEW_PSW        # reenable interrupts
616         tm      __PT_PSW+1(%r11),0x01   # forking a kernel thread ?
617         jne     .Lsysc_tracenogo
618         # it's a kernel thread
619         lmg     %r9,%r10,__PT_R9(%r11)  # load gprs
620 ENTRY(kernel_thread_starter)
621         la      %r2,0(%r10)
622         BASR_R14_R9
623         j       .Lsysc_tracenogo
624
625 /*
626  * Program check handler routine
627  */
628
629 ENTRY(pgm_check_handler)
630         stpt    __LC_SYNC_ENTER_TIMER
631         BPOFF
632         stmg    %r8,%r15,__LC_SAVE_AREA_SYNC
633         lg      %r10,__LC_LAST_BREAK
634         lg      %r12,__LC_CURRENT
635         lghi    %r11,0
636         larl    %r13,cleanup_critical
637         lmg     %r8,%r9,__LC_PGM_OLD_PSW
638         tmhh    %r8,0x0001              # test problem state bit
639         jnz     2f                      # -> fault in user space
640 #if IS_ENABLED(CONFIG_KVM)
641         # cleanup critical section for program checks in sie64a
642         lgr     %r14,%r9
643         slg     %r14,BASED(.Lsie_critical_start)
644         clg     %r14,BASED(.Lsie_critical_length)
645         jhe     0f
646         lg      %r14,__SF_SIE_CONTROL(%r15)     # get control block pointer
647         ni      __SIE_PROG0C+3(%r14),0xfe       # no longer in SIE
648         lctlg   %c1,%c1,__LC_USER_ASCE          # load primary asce
649         larl    %r9,sie_exit                    # skip forward to sie_exit
650         lghi    %r11,_PIF_GUEST_FAULT
651 #endif
652 0:      tmhh    %r8,0x4000              # PER bit set in old PSW ?
653         jnz     1f                      # -> enabled, can't be a double fault
654         tm      __LC_PGM_ILC+3,0x80     # check for per exception
655         jnz     .Lpgm_svcper            # -> single stepped svc
656 1:      CHECK_STACK STACK_SIZE,__LC_SAVE_AREA_SYNC
657         aghi    %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
658         j       4f
659 2:      UPDATE_VTIME %r14,%r15,__LC_SYNC_ENTER_TIMER
660         BPENTER __TI_flags(%r12),_TIF_ISOLATE_BP
661         lg      %r15,__LC_KERNEL_STACK
662         lgr     %r14,%r12
663         aghi    %r14,__TASK_thread      # pointer to thread_struct
664         lghi    %r13,__LC_PGM_TDB
665         tm      __LC_PGM_ILC+2,0x02     # check for transaction abort
666         jz      3f
667         mvc     __THREAD_trap_tdb(256,%r14),0(%r13)
668 3:      stg     %r10,__THREAD_last_break(%r14)
669 4:      lgr     %r13,%r11
670         la      %r11,STACK_FRAME_OVERHEAD(%r15)
671         stmg    %r0,%r7,__PT_R0(%r11)
672         # clear user controlled registers to prevent speculative use
673         xgr     %r0,%r0
674         xgr     %r1,%r1
675         xgr     %r2,%r2
676         xgr     %r3,%r3
677         xgr     %r4,%r4
678         xgr     %r5,%r5
679         xgr     %r6,%r6
680         xgr     %r7,%r7
681         mvc     __PT_R8(64,%r11),__LC_SAVE_AREA_SYNC
682         stmg    %r8,%r9,__PT_PSW(%r11)
683         mvc     __PT_INT_CODE(4,%r11),__LC_PGM_ILC
684         mvc     __PT_INT_PARM_LONG(8,%r11),__LC_TRANS_EXC_CODE
685         stg     %r13,__PT_FLAGS(%r11)
686         stg     %r10,__PT_ARGS(%r11)
687         tm      __LC_PGM_ILC+3,0x80     # check for per exception
688         jz      5f
689         tmhh    %r8,0x0001              # kernel per event ?
690         jz      .Lpgm_kprobe
691         oi      __PT_FLAGS+7(%r11),_PIF_PER_TRAP
692         mvc     __THREAD_per_address(8,%r14),__LC_PER_ADDRESS
693         mvc     __THREAD_per_cause(2,%r14),__LC_PER_CODE
694         mvc     __THREAD_per_paid(1,%r14),__LC_PER_ACCESS_ID
695 5:      REENABLE_IRQS
696         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
697         larl    %r1,pgm_check_table
698         llgh    %r10,__PT_INT_CODE+2(%r11)
699         nill    %r10,0x007f
700         sll     %r10,2
701         je      .Lpgm_return
702         lgf     %r9,0(%r10,%r1)         # load address of handler routine
703         lgr     %r2,%r11                # pass pointer to pt_regs
704         BASR_R14_R9                     # branch to interrupt-handler
705 .Lpgm_return:
706         LOCKDEP_SYS_EXIT
707         tm      __PT_PSW+1(%r11),0x01   # returning to user ?
708         jno     .Lsysc_restore
709         TSTMSK  __PT_FLAGS(%r11),_PIF_SYSCALL
710         jo      .Lsysc_do_syscall
711         j       .Lsysc_tif
712
713 #
714 # PER event in supervisor state, must be kprobes
715 #
716 .Lpgm_kprobe:
717         REENABLE_IRQS
718         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
719         lgr     %r2,%r11                # pass pointer to pt_regs
720         brasl   %r14,do_per_trap
721         j       .Lpgm_return
722
723 #
724 # single stepped system call
725 #
726 .Lpgm_svcper:
727         mvc     __LC_RETURN_PSW(8),__LC_SVC_NEW_PSW
728         lghi    %r13,__TASK_thread
729         larl    %r14,.Lsysc_per
730         stg     %r14,__LC_RETURN_PSW+8
731         lghi    %r14,_PIF_SYSCALL | _PIF_PER_TRAP
732         lpswe   __LC_RETURN_PSW         # branch to .Lsysc_per and enable irqs
733
734 /*
735  * IO interrupt handler routine
736  */
737 ENTRY(io_int_handler)
738         STCK    __LC_INT_CLOCK
739         stpt    __LC_ASYNC_ENTER_TIMER
740         BPOFF
741         stmg    %r8,%r15,__LC_SAVE_AREA_ASYNC
742         lg      %r12,__LC_CURRENT
743         larl    %r13,cleanup_critical
744         lmg     %r8,%r9,__LC_IO_OLD_PSW
745         SWITCH_ASYNC __LC_SAVE_AREA_ASYNC,__LC_ASYNC_ENTER_TIMER
746         stmg    %r0,%r7,__PT_R0(%r11)
747         # clear user controlled registers to prevent speculative use
748         xgr     %r0,%r0
749         xgr     %r1,%r1
750         xgr     %r2,%r2
751         xgr     %r3,%r3
752         xgr     %r4,%r4
753         xgr     %r5,%r5
754         xgr     %r6,%r6
755         xgr     %r7,%r7
756         xgr     %r10,%r10
757         mvc     __PT_R8(64,%r11),__LC_SAVE_AREA_ASYNC
758         stmg    %r8,%r9,__PT_PSW(%r11)
759         mvc     __PT_INT_CODE(12,%r11),__LC_SUBCHANNEL_ID
760         xc      __PT_FLAGS(8,%r11),__PT_FLAGS(%r11)
761         TSTMSK  __LC_CPU_FLAGS,_CIF_IGNORE_IRQ
762         jo      .Lio_restore
763         TRACE_IRQS_OFF
764         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
765 .Lio_loop:
766         lgr     %r2,%r11                # pass pointer to pt_regs
767         lghi    %r3,IO_INTERRUPT
768         tm      __PT_INT_CODE+8(%r11),0x80      # adapter interrupt ?
769         jz      .Lio_call
770         lghi    %r3,THIN_INTERRUPT
771 .Lio_call:
772         brasl   %r14,do_IRQ
773         TSTMSK  __LC_MACHINE_FLAGS,MACHINE_FLAG_LPAR
774         jz      .Lio_return
775         tpi     0
776         jz      .Lio_return
777         mvc     __PT_INT_CODE(12,%r11),__LC_SUBCHANNEL_ID
778         j       .Lio_loop
779 .Lio_return:
780         LOCKDEP_SYS_EXIT
781         TRACE_IRQS_ON
782 .Lio_tif:
783         TSTMSK  __TI_flags(%r12),_TIF_WORK
784         jnz     .Lio_work               # there is work to do (signals etc.)
785         TSTMSK  __LC_CPU_FLAGS,_CIF_WORK
786         jnz     .Lio_work
787 .Lio_restore:
788         lg      %r14,__LC_VDSO_PER_CPU
789         lmg     %r0,%r10,__PT_R0(%r11)
790         mvc     __LC_RETURN_PSW(16),__PT_PSW(%r11)
791         tm      __PT_PSW+1(%r11),0x01   # returning to user ?
792         jno     .Lio_exit_kernel
793         BPEXIT  __TI_flags(%r12),_TIF_ISOLATE_BP
794 .Lio_exit_timer:
795         stpt    __LC_EXIT_TIMER
796         mvc     __VDSO_ECTG_BASE(16,%r14),__LC_EXIT_TIMER
797 .Lio_exit_kernel:
798         lmg     %r11,%r15,__PT_R11(%r11)
799         lpswe   __LC_RETURN_PSW
800 .Lio_done:
801
802 #
803 # There is work todo, find out in which context we have been interrupted:
804 # 1) if we return to user space we can do all _TIF_WORK work
805 # 2) if we return to kernel code and kvm is enabled check if we need to
806 #    modify the psw to leave SIE
807 # 3) if we return to kernel code and preemptive scheduling is enabled check
808 #    the preemption counter and if it is zero call preempt_schedule_irq
809 # Before any work can be done, a switch to the kernel stack is required.
810 #
811 .Lio_work:
812         tm      __PT_PSW+1(%r11),0x01   # returning to user ?
813         jo      .Lio_work_user          # yes -> do resched & signal
814 #ifdef CONFIG_PREEMPT
815         # check for preemptive scheduling
816         icm     %r0,15,__LC_PREEMPT_COUNT
817         jnz     .Lio_restore            # preemption is disabled
818         TSTMSK  __TI_flags(%r12),_TIF_NEED_RESCHED
819         jno     .Lio_restore
820         # switch to kernel stack
821         lg      %r1,__PT_R15(%r11)
822         aghi    %r1,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
823         mvc     STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
824         xc      __SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1)
825         la      %r11,STACK_FRAME_OVERHEAD(%r1)
826         lgr     %r15,%r1
827         # TRACE_IRQS_ON already done at .Lio_return, call
828         # TRACE_IRQS_OFF to keep things symmetrical
829         TRACE_IRQS_OFF
830         brasl   %r14,preempt_schedule_irq
831         j       .Lio_return
832 #else
833         j       .Lio_restore
834 #endif
835
836 #
837 # Need to do work before returning to userspace, switch to kernel stack
838 #
839 .Lio_work_user:
840         lg      %r1,__LC_KERNEL_STACK
841         mvc     STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
842         xc      __SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1)
843         la      %r11,STACK_FRAME_OVERHEAD(%r1)
844         lgr     %r15,%r1
845
846 #
847 # One of the work bits is on. Find out which one.
848 #
849 .Lio_work_tif:
850         TSTMSK  __LC_CPU_FLAGS,_CIF_MCCK_PENDING
851         jo      .Lio_mcck_pending
852         TSTMSK  __TI_flags(%r12),_TIF_NEED_RESCHED
853         jo      .Lio_reschedule
854 #ifdef CONFIG_LIVEPATCH
855         TSTMSK  __TI_flags(%r12),_TIF_PATCH_PENDING
856         jo      .Lio_patch_pending
857 #endif
858         TSTMSK  __TI_flags(%r12),_TIF_SIGPENDING
859         jo      .Lio_sigpending
860         TSTMSK  __TI_flags(%r12),_TIF_NOTIFY_RESUME
861         jo      .Lio_notify_resume
862         TSTMSK  __TI_flags(%r12),_TIF_GUARDED_STORAGE
863         jo      .Lio_guarded_storage
864         TSTMSK  __LC_CPU_FLAGS,_CIF_FPU
865         jo      .Lio_vxrs
866         TSTMSK  __LC_CPU_FLAGS,(_CIF_ASCE_PRIMARY|_CIF_ASCE_SECONDARY)
867         jnz     .Lio_asce
868         j       .Lio_return             # beware of critical section cleanup
869
870 #
871 # _CIF_MCCK_PENDING is set, call handler
872 #
873 .Lio_mcck_pending:
874         # TRACE_IRQS_ON already done at .Lio_return
875         brasl   %r14,s390_handle_mcck   # TIF bit will be cleared by handler
876         TRACE_IRQS_OFF
877         j       .Lio_return
878
879 #
880 # _CIF_ASCE_PRIMARY and/or CIF_ASCE_SECONDARY set, load user space asce
881 #
882 .Lio_asce:
883         ni      __LC_CPU_FLAGS+7,255-_CIF_ASCE_SECONDARY
884         lctlg   %c7,%c7,__LC_VDSO_ASCE          # load secondary asce
885         TSTMSK  __LC_CPU_FLAGS,_CIF_ASCE_PRIMARY
886         jz      .Lio_return
887 #ifndef CONFIG_HAVE_MARCH_Z10_FEATURES
888         tm      __LC_STFLE_FAC_LIST+3,0x10      # has MVCOS ?
889         jnz     .Lio_set_fs_fixup
890         ni      __LC_CPU_FLAGS+7,255-_CIF_ASCE_PRIMARY
891         lctlg   %c1,%c1,__LC_USER_ASCE          # load primary asce
892         j       .Lio_return
893 .Lio_set_fs_fixup:
894 #endif
895         larl    %r14,.Lio_return
896         jg      set_fs_fixup
897
898 #
899 # CIF_FPU is set, restore floating-point controls and floating-point registers.
900 #
901 .Lio_vxrs:
902         larl    %r14,.Lio_return
903         jg      load_fpu_regs
904
905 #
906 # _TIF_GUARDED_STORAGE is set, call guarded_storage_load
907 #
908 .Lio_guarded_storage:
909         # TRACE_IRQS_ON already done at .Lio_return
910         ssm     __LC_SVC_NEW_PSW        # reenable interrupts
911         lgr     %r2,%r11                # pass pointer to pt_regs
912         brasl   %r14,gs_load_bc_cb
913         ssm     __LC_PGM_NEW_PSW        # disable I/O and ext. interrupts
914         TRACE_IRQS_OFF
915         j       .Lio_return
916
917 #
918 # _TIF_NEED_RESCHED is set, call schedule
919 #
920 .Lio_reschedule:
921         # TRACE_IRQS_ON already done at .Lio_return
922         ssm     __LC_SVC_NEW_PSW        # reenable interrupts
923         brasl   %r14,schedule           # call scheduler
924         ssm     __LC_PGM_NEW_PSW        # disable I/O and ext. interrupts
925         TRACE_IRQS_OFF
926         j       .Lio_return
927
928 #
929 # _TIF_PATCH_PENDING is set, call klp_update_patch_state
930 #
931 #ifdef CONFIG_LIVEPATCH
932 .Lio_patch_pending:
933         lg      %r2,__LC_CURRENT        # pass pointer to task struct
934         larl    %r14,.Lio_return
935         jg      klp_update_patch_state
936 #endif
937
938 #
939 # _TIF_SIGPENDING or is set, call do_signal
940 #
941 .Lio_sigpending:
942         # TRACE_IRQS_ON already done at .Lio_return
943         ssm     __LC_SVC_NEW_PSW        # reenable interrupts
944         lgr     %r2,%r11                # pass pointer to pt_regs
945         brasl   %r14,do_signal
946         ssm     __LC_PGM_NEW_PSW        # disable I/O and ext. interrupts
947         TRACE_IRQS_OFF
948         j       .Lio_return
949
950 #
951 # _TIF_NOTIFY_RESUME or is set, call do_notify_resume
952 #
953 .Lio_notify_resume:
954         # TRACE_IRQS_ON already done at .Lio_return
955         ssm     __LC_SVC_NEW_PSW        # reenable interrupts
956         lgr     %r2,%r11                # pass pointer to pt_regs
957         brasl   %r14,do_notify_resume
958         ssm     __LC_PGM_NEW_PSW        # disable I/O and ext. interrupts
959         TRACE_IRQS_OFF
960         j       .Lio_return
961
962 /*
963  * External interrupt handler routine
964  */
965 ENTRY(ext_int_handler)
966         STCK    __LC_INT_CLOCK
967         stpt    __LC_ASYNC_ENTER_TIMER
968         BPOFF
969         stmg    %r8,%r15,__LC_SAVE_AREA_ASYNC
970         lg      %r12,__LC_CURRENT
971         larl    %r13,cleanup_critical
972         lmg     %r8,%r9,__LC_EXT_OLD_PSW
973         SWITCH_ASYNC __LC_SAVE_AREA_ASYNC,__LC_ASYNC_ENTER_TIMER
974         stmg    %r0,%r7,__PT_R0(%r11)
975         # clear user controlled registers to prevent speculative use
976         xgr     %r0,%r0
977         xgr     %r1,%r1
978         xgr     %r2,%r2
979         xgr     %r3,%r3
980         xgr     %r4,%r4
981         xgr     %r5,%r5
982         xgr     %r6,%r6
983         xgr     %r7,%r7
984         xgr     %r10,%r10
985         mvc     __PT_R8(64,%r11),__LC_SAVE_AREA_ASYNC
986         stmg    %r8,%r9,__PT_PSW(%r11)
987         lghi    %r1,__LC_EXT_PARAMS2
988         mvc     __PT_INT_CODE(4,%r11),__LC_EXT_CPU_ADDR
989         mvc     __PT_INT_PARM(4,%r11),__LC_EXT_PARAMS
990         mvc     __PT_INT_PARM_LONG(8,%r11),0(%r1)
991         xc      __PT_FLAGS(8,%r11),__PT_FLAGS(%r11)
992         TSTMSK  __LC_CPU_FLAGS,_CIF_IGNORE_IRQ
993         jo      .Lio_restore
994         TRACE_IRQS_OFF
995         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
996         lgr     %r2,%r11                # pass pointer to pt_regs
997         lghi    %r3,EXT_INTERRUPT
998         brasl   %r14,do_IRQ
999         j       .Lio_return
1000
1001 /*
1002  * Load idle PSW. The second "half" of this function is in .Lcleanup_idle.
1003  */
1004 ENTRY(psw_idle)
1005         stg     %r3,__SF_EMPTY(%r15)
1006         larl    %r1,.Lpsw_idle_lpsw+4
1007         stg     %r1,__SF_EMPTY+8(%r15)
1008 #ifdef CONFIG_SMP
1009         larl    %r1,smp_cpu_mtid
1010         llgf    %r1,0(%r1)
1011         ltgr    %r1,%r1
1012         jz      .Lpsw_idle_stcctm
1013         .insn   rsy,0xeb0000000017,%r1,5,__SF_EMPTY+16(%r15)
1014 .Lpsw_idle_stcctm:
1015 #endif
1016         oi      __LC_CPU_FLAGS+7,_CIF_ENABLED_WAIT
1017         BPON
1018         STCK    __CLOCK_IDLE_ENTER(%r2)
1019         stpt    __TIMER_IDLE_ENTER(%r2)
1020 .Lpsw_idle_lpsw:
1021         lpswe   __SF_EMPTY(%r15)
1022         BR_R1USE_R14
1023 .Lpsw_idle_end:
1024
1025 /*
1026  * Store floating-point controls and floating-point or vector register
1027  * depending whether the vector facility is available.  A critical section
1028  * cleanup assures that the registers are stored even if interrupted for
1029  * some other work.  The CIF_FPU flag is set to trigger a lazy restore
1030  * of the register contents at return from io or a system call.
1031  */
1032 ENTRY(save_fpu_regs)
1033         lg      %r2,__LC_CURRENT
1034         aghi    %r2,__TASK_thread
1035         TSTMSK  __LC_CPU_FLAGS,_CIF_FPU
1036         jo      .Lsave_fpu_regs_exit
1037         stfpc   __THREAD_FPU_fpc(%r2)
1038         lg      %r3,__THREAD_FPU_regs(%r2)
1039         TSTMSK  __LC_MACHINE_FLAGS,MACHINE_FLAG_VX
1040         jz      .Lsave_fpu_regs_fp        # no -> store FP regs
1041         VSTM    %v0,%v15,0,%r3            # vstm 0,15,0(3)
1042         VSTM    %v16,%v31,256,%r3         # vstm 16,31,256(3)
1043         j       .Lsave_fpu_regs_done      # -> set CIF_FPU flag
1044 .Lsave_fpu_regs_fp:
1045         std     0,0(%r3)
1046         std     1,8(%r3)
1047         std     2,16(%r3)
1048         std     3,24(%r3)
1049         std     4,32(%r3)
1050         std     5,40(%r3)
1051         std     6,48(%r3)
1052         std     7,56(%r3)
1053         std     8,64(%r3)
1054         std     9,72(%r3)
1055         std     10,80(%r3)
1056         std     11,88(%r3)
1057         std     12,96(%r3)
1058         std     13,104(%r3)
1059         std     14,112(%r3)
1060         std     15,120(%r3)
1061 .Lsave_fpu_regs_done:
1062         oi      __LC_CPU_FLAGS+7,_CIF_FPU
1063 .Lsave_fpu_regs_exit:
1064         BR_R1USE_R14
1065 .Lsave_fpu_regs_end:
1066 EXPORT_SYMBOL(save_fpu_regs)
1067
1068 /*
1069  * Load floating-point controls and floating-point or vector registers.
1070  * A critical section cleanup assures that the register contents are
1071  * loaded even if interrupted for some other work.
1072  *
1073  * There are special calling conventions to fit into sysc and io return work:
1074  *      %r15:   <kernel stack>
1075  * The function requires:
1076  *      %r4
1077  */
1078 load_fpu_regs:
1079         lg      %r4,__LC_CURRENT
1080         aghi    %r4,__TASK_thread
1081         TSTMSK  __LC_CPU_FLAGS,_CIF_FPU
1082         jno     .Lload_fpu_regs_exit
1083         lfpc    __THREAD_FPU_fpc(%r4)
1084         TSTMSK  __LC_MACHINE_FLAGS,MACHINE_FLAG_VX
1085         lg      %r4,__THREAD_FPU_regs(%r4)      # %r4 <- reg save area
1086         jz      .Lload_fpu_regs_fp              # -> no VX, load FP regs
1087         VLM     %v0,%v15,0,%r4
1088         VLM     %v16,%v31,256,%r4
1089         j       .Lload_fpu_regs_done
1090 .Lload_fpu_regs_fp:
1091         ld      0,0(%r4)
1092         ld      1,8(%r4)
1093         ld      2,16(%r4)
1094         ld      3,24(%r4)
1095         ld      4,32(%r4)
1096         ld      5,40(%r4)
1097         ld      6,48(%r4)
1098         ld      7,56(%r4)
1099         ld      8,64(%r4)
1100         ld      9,72(%r4)
1101         ld      10,80(%r4)
1102         ld      11,88(%r4)
1103         ld      12,96(%r4)
1104         ld      13,104(%r4)
1105         ld      14,112(%r4)
1106         ld      15,120(%r4)
1107 .Lload_fpu_regs_done:
1108         ni      __LC_CPU_FLAGS+7,255-_CIF_FPU
1109 .Lload_fpu_regs_exit:
1110         BR_R1USE_R14
1111 .Lload_fpu_regs_end:
1112
1113 .L__critical_end:
1114
1115 /*
1116  * Machine check handler routines
1117  */
1118 ENTRY(mcck_int_handler)
1119         STCK    __LC_MCCK_CLOCK
1120         BPOFF
1121         la      %r1,4095                # validate r1
1122         spt     __LC_CPU_TIMER_SAVE_AREA-4095(%r1)      # validate cpu timer
1123         sckc    __LC_CLOCK_COMPARATOR                   # validate comparator
1124         lam     %a0,%a15,__LC_AREGS_SAVE_AREA-4095(%r1) # validate acrs
1125         lmg     %r0,%r15,__LC_GPREGS_SAVE_AREA-4095(%r1)# validate gprs
1126         lg      %r12,__LC_CURRENT
1127         larl    %r13,cleanup_critical
1128         lmg     %r8,%r9,__LC_MCK_OLD_PSW
1129         TSTMSK  __LC_MCCK_CODE,MCCK_CODE_SYSTEM_DAMAGE
1130         jo      .Lmcck_panic            # yes -> rest of mcck code invalid
1131         TSTMSK  __LC_MCCK_CODE,MCCK_CODE_CR_VALID
1132         jno     .Lmcck_panic            # control registers invalid -> panic
1133         la      %r14,4095
1134         lctlg   %c0,%c15,__LC_CREGS_SAVE_AREA-4095(%r14) # validate ctl regs
1135         ptlb
1136         lg      %r11,__LC_MCESAD-4095(%r14) # extended machine check save area
1137         nill    %r11,0xfc00             # MCESA_ORIGIN_MASK
1138         TSTMSK  __LC_CREGS_SAVE_AREA+16-4095(%r14),CR2_GUARDED_STORAGE
1139         jno     0f
1140         TSTMSK  __LC_MCCK_CODE,MCCK_CODE_GS_VALID
1141         jno     0f
1142         .insn    rxy,0xe3000000004d,0,__MCESA_GS_SAVE_AREA(%r11) # LGSC
1143 0:      l       %r14,__LC_FP_CREG_SAVE_AREA-4095(%r14)
1144         TSTMSK  __LC_MCCK_CODE,MCCK_CODE_FC_VALID
1145         jo      0f
1146         sr      %r14,%r14
1147 0:      sfpc    %r14
1148         TSTMSK  __LC_MACHINE_FLAGS,MACHINE_FLAG_VX
1149         jo      0f
1150         lghi    %r14,__LC_FPREGS_SAVE_AREA
1151         ld      %f0,0(%r14)
1152         ld      %f1,8(%r14)
1153         ld      %f2,16(%r14)
1154         ld      %f3,24(%r14)
1155         ld      %f4,32(%r14)
1156         ld      %f5,40(%r14)
1157         ld      %f6,48(%r14)
1158         ld      %f7,56(%r14)
1159         ld      %f8,64(%r14)
1160         ld      %f9,72(%r14)
1161         ld      %f10,80(%r14)
1162         ld      %f11,88(%r14)
1163         ld      %f12,96(%r14)
1164         ld      %f13,104(%r14)
1165         ld      %f14,112(%r14)
1166         ld      %f15,120(%r14)
1167         j       1f
1168 0:      VLM     %v0,%v15,0,%r11
1169         VLM     %v16,%v31,256,%r11
1170 1:      lghi    %r14,__LC_CPU_TIMER_SAVE_AREA
1171         mvc     __LC_MCCK_ENTER_TIMER(8),0(%r14)
1172         TSTMSK  __LC_MCCK_CODE,MCCK_CODE_CPU_TIMER_VALID
1173         jo      3f
1174         la      %r14,__LC_SYNC_ENTER_TIMER
1175         clc     0(8,%r14),__LC_ASYNC_ENTER_TIMER
1176         jl      0f
1177         la      %r14,__LC_ASYNC_ENTER_TIMER
1178 0:      clc     0(8,%r14),__LC_EXIT_TIMER
1179         jl      1f
1180         la      %r14,__LC_EXIT_TIMER
1181 1:      clc     0(8,%r14),__LC_LAST_UPDATE_TIMER
1182         jl      2f
1183         la      %r14,__LC_LAST_UPDATE_TIMER
1184 2:      spt     0(%r14)
1185         mvc     __LC_MCCK_ENTER_TIMER(8),0(%r14)
1186 3:      TSTMSK  __LC_MCCK_CODE,MCCK_CODE_PSW_MWP_VALID
1187         jno     .Lmcck_panic
1188         tmhh    %r8,0x0001              # interrupting from user ?
1189         jnz     4f
1190         TSTMSK  __LC_MCCK_CODE,MCCK_CODE_PSW_IA_VALID
1191         jno     .Lmcck_panic
1192 4:      SWITCH_ASYNC __LC_GPREGS_SAVE_AREA+64,__LC_MCCK_ENTER_TIMER
1193 .Lmcck_skip:
1194         lghi    %r14,__LC_GPREGS_SAVE_AREA+64
1195         stmg    %r0,%r7,__PT_R0(%r11)
1196         # clear user controlled registers to prevent speculative use
1197         xgr     %r0,%r0
1198         xgr     %r1,%r1
1199         xgr     %r2,%r2
1200         xgr     %r3,%r3
1201         xgr     %r4,%r4
1202         xgr     %r5,%r5
1203         xgr     %r6,%r6
1204         xgr     %r7,%r7
1205         xgr     %r10,%r10
1206         mvc     __PT_R8(64,%r11),0(%r14)
1207         stmg    %r8,%r9,__PT_PSW(%r11)
1208         xc      __PT_FLAGS(8,%r11),__PT_FLAGS(%r11)
1209         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
1210         lgr     %r2,%r11                # pass pointer to pt_regs
1211         brasl   %r14,s390_do_machine_check
1212         tm      __PT_PSW+1(%r11),0x01   # returning to user ?
1213         jno     .Lmcck_return
1214         lg      %r1,__LC_KERNEL_STACK   # switch to kernel stack
1215         mvc     STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
1216         xc      __SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1)
1217         la      %r11,STACK_FRAME_OVERHEAD(%r1)
1218         lgr     %r15,%r1
1219         ssm     __LC_PGM_NEW_PSW        # turn dat on, keep irqs off
1220         TSTMSK  __LC_CPU_FLAGS,_CIF_MCCK_PENDING
1221         jno     .Lmcck_return
1222         TRACE_IRQS_OFF
1223         brasl   %r14,s390_handle_mcck
1224         TRACE_IRQS_ON
1225 .Lmcck_return:
1226         lg      %r14,__LC_VDSO_PER_CPU
1227         lmg     %r0,%r10,__PT_R0(%r11)
1228         mvc     __LC_RETURN_MCCK_PSW(16),__PT_PSW(%r11) # move return PSW
1229         tm      __LC_RETURN_MCCK_PSW+1,0x01 # returning to user ?
1230         jno     0f
1231         BPEXIT  __TI_flags(%r12),_TIF_ISOLATE_BP
1232         stpt    __LC_EXIT_TIMER
1233         mvc     __VDSO_ECTG_BASE(16,%r14),__LC_EXIT_TIMER
1234 0:      lmg     %r11,%r15,__PT_R11(%r11)
1235         lpswe   __LC_RETURN_MCCK_PSW
1236
1237 .Lmcck_panic:
1238         lg      %r15,__LC_PANIC_STACK
1239         la      %r11,STACK_FRAME_OVERHEAD(%r15)
1240         j       .Lmcck_skip
1241
1242 #
1243 # PSW restart interrupt handler
1244 #
1245 ENTRY(restart_int_handler)
1246         ALTERNATIVE "", ".insn s,0xb2800000,_LPP_OFFSET", 40
1247         stg     %r15,__LC_SAVE_AREA_RESTART
1248         lg      %r15,__LC_RESTART_STACK
1249         aghi    %r15,-__PT_SIZE                 # create pt_regs on stack
1250         xc      0(__PT_SIZE,%r15),0(%r15)
1251         stmg    %r0,%r14,__PT_R0(%r15)
1252         mvc     __PT_R15(8,%r15),__LC_SAVE_AREA_RESTART
1253         mvc     __PT_PSW(16,%r15),__LC_RST_OLD_PSW # store restart old psw
1254         aghi    %r15,-STACK_FRAME_OVERHEAD      # create stack frame on stack
1255         xc      0(STACK_FRAME_OVERHEAD,%r15),0(%r15)
1256         lg      %r1,__LC_RESTART_FN             # load fn, parm & source cpu
1257         lg      %r2,__LC_RESTART_DATA
1258         lg      %r3,__LC_RESTART_SOURCE
1259         ltgr    %r3,%r3                         # test source cpu address
1260         jm      1f                              # negative -> skip source stop
1261 0:      sigp    %r4,%r3,SIGP_SENSE              # sigp sense to source cpu
1262         brc     10,0b                           # wait for status stored
1263 1:      basr    %r14,%r1                        # call function
1264         stap    __SF_EMPTY(%r15)                # store cpu address
1265         llgh    %r3,__SF_EMPTY(%r15)
1266 2:      sigp    %r4,%r3,SIGP_STOP               # sigp stop to current cpu
1267         brc     2,2b
1268 3:      j       3b
1269
1270         .section .kprobes.text, "ax"
1271
1272 #ifdef CONFIG_CHECK_STACK
1273 /*
1274  * The synchronous or the asynchronous stack overflowed. We are dead.
1275  * No need to properly save the registers, we are going to panic anyway.
1276  * Setup a pt_regs so that show_trace can provide a good call trace.
1277  */
1278 stack_overflow:
1279         lg      %r15,__LC_PANIC_STACK   # change to panic stack
1280         la      %r11,STACK_FRAME_OVERHEAD(%r15)
1281         stmg    %r0,%r7,__PT_R0(%r11)
1282         stmg    %r8,%r9,__PT_PSW(%r11)
1283         mvc     __PT_R8(64,%r11),0(%r14)
1284         stg     %r10,__PT_ORIG_GPR2(%r11) # store last break to orig_gpr2
1285         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
1286         lgr     %r2,%r11                # pass pointer to pt_regs
1287         jg      kernel_stack_overflow
1288 #endif
1289
1290 cleanup_critical:
1291 #if IS_ENABLED(CONFIG_KVM)
1292         clg     %r9,BASED(.Lcleanup_table_sie)  # .Lsie_gmap
1293         jl      0f
1294         clg     %r9,BASED(.Lcleanup_table_sie+8)# .Lsie_done
1295         jl      .Lcleanup_sie
1296 #endif
1297         clg     %r9,BASED(.Lcleanup_table)      # system_call
1298         jl      0f
1299         clg     %r9,BASED(.Lcleanup_table+8)    # .Lsysc_do_svc
1300         jl      .Lcleanup_system_call
1301         clg     %r9,BASED(.Lcleanup_table+16)   # .Lsysc_tif
1302         jl      0f
1303         clg     %r9,BASED(.Lcleanup_table+24)   # .Lsysc_restore
1304         jl      .Lcleanup_sysc_tif
1305         clg     %r9,BASED(.Lcleanup_table+32)   # .Lsysc_done
1306         jl      .Lcleanup_sysc_restore
1307         clg     %r9,BASED(.Lcleanup_table+40)   # .Lio_tif
1308         jl      0f
1309         clg     %r9,BASED(.Lcleanup_table+48)   # .Lio_restore
1310         jl      .Lcleanup_io_tif
1311         clg     %r9,BASED(.Lcleanup_table+56)   # .Lio_done
1312         jl      .Lcleanup_io_restore
1313         clg     %r9,BASED(.Lcleanup_table+64)   # psw_idle
1314         jl      0f
1315         clg     %r9,BASED(.Lcleanup_table+72)   # .Lpsw_idle_end
1316         jl      .Lcleanup_idle
1317         clg     %r9,BASED(.Lcleanup_table+80)   # save_fpu_regs
1318         jl      0f
1319         clg     %r9,BASED(.Lcleanup_table+88)   # .Lsave_fpu_regs_end
1320         jl      .Lcleanup_save_fpu_regs
1321         clg     %r9,BASED(.Lcleanup_table+96)   # load_fpu_regs
1322         jl      0f
1323         clg     %r9,BASED(.Lcleanup_table+104)  # .Lload_fpu_regs_end
1324         jl      .Lcleanup_load_fpu_regs
1325 0:      BR_R11USE_R14
1326
1327         .align  8
1328 .Lcleanup_table:
1329         .quad   system_call
1330         .quad   .Lsysc_do_svc
1331         .quad   .Lsysc_tif
1332         .quad   .Lsysc_restore
1333         .quad   .Lsysc_done
1334         .quad   .Lio_tif
1335         .quad   .Lio_restore
1336         .quad   .Lio_done
1337         .quad   psw_idle
1338         .quad   .Lpsw_idle_end
1339         .quad   save_fpu_regs
1340         .quad   .Lsave_fpu_regs_end
1341         .quad   load_fpu_regs
1342         .quad   .Lload_fpu_regs_end
1343
1344 #if IS_ENABLED(CONFIG_KVM)
1345 .Lcleanup_table_sie:
1346         .quad   .Lsie_gmap
1347         .quad   .Lsie_done
1348
1349 .Lcleanup_sie:
1350         cghi    %r11,__LC_SAVE_AREA_ASYNC       #Is this in normal interrupt?
1351         je      1f
1352         slg     %r9,BASED(.Lsie_crit_mcck_start)
1353         clg     %r9,BASED(.Lsie_crit_mcck_length)
1354         jh      1f
1355         oi      __LC_CPU_FLAGS+7, _CIF_MCCK_GUEST
1356 1:      BPENTER __SF_SIE_FLAGS(%r15),(_TIF_ISOLATE_BP|_TIF_ISOLATE_BP_GUEST)
1357         lg      %r9,__SF_SIE_CONTROL(%r15)      # get control block pointer
1358         ni      __SIE_PROG0C+3(%r9),0xfe        # no longer in SIE
1359         lctlg   %c1,%c1,__LC_USER_ASCE          # load primary asce
1360         larl    %r9,sie_exit                    # skip forward to sie_exit
1361         BR_R11USE_R14
1362 #endif
1363
1364 .Lcleanup_system_call:
1365         # check if stpt has been executed
1366         clg     %r9,BASED(.Lcleanup_system_call_insn)
1367         jh      0f
1368         mvc     __LC_SYNC_ENTER_TIMER(8),__LC_ASYNC_ENTER_TIMER
1369         cghi    %r11,__LC_SAVE_AREA_ASYNC
1370         je      0f
1371         mvc     __LC_SYNC_ENTER_TIMER(8),__LC_MCCK_ENTER_TIMER
1372 0:      # check if stmg has been executed
1373         clg     %r9,BASED(.Lcleanup_system_call_insn+8)
1374         jh      0f
1375         mvc     __LC_SAVE_AREA_SYNC(64),0(%r11)
1376 0:      # check if base register setup + TIF bit load has been done
1377         clg     %r9,BASED(.Lcleanup_system_call_insn+16)
1378         jhe     0f
1379         # set up saved register r12 task struct pointer
1380         stg     %r12,32(%r11)
1381         # set up saved register r13 __TASK_thread offset
1382         mvc     40(8,%r11),BASED(.Lcleanup_system_call_const)
1383 0:      # check if the user time update has been done
1384         clg     %r9,BASED(.Lcleanup_system_call_insn+24)
1385         jh      0f
1386         lg      %r15,__LC_EXIT_TIMER
1387         slg     %r15,__LC_SYNC_ENTER_TIMER
1388         alg     %r15,__LC_USER_TIMER
1389         stg     %r15,__LC_USER_TIMER
1390 0:      # check if the system time update has been done
1391         clg     %r9,BASED(.Lcleanup_system_call_insn+32)
1392         jh      0f
1393         lg      %r15,__LC_LAST_UPDATE_TIMER
1394         slg     %r15,__LC_EXIT_TIMER
1395         alg     %r15,__LC_SYSTEM_TIMER
1396         stg     %r15,__LC_SYSTEM_TIMER
1397 0:      # update accounting time stamp
1398         mvc     __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER
1399         BPENTER __TI_flags(%r12),_TIF_ISOLATE_BP
1400         # set up saved register r11
1401         lg      %r15,__LC_KERNEL_STACK
1402         la      %r9,STACK_FRAME_OVERHEAD(%r15)
1403         stg     %r9,24(%r11)            # r11 pt_regs pointer
1404         # fill pt_regs
1405         mvc     __PT_R8(64,%r9),__LC_SAVE_AREA_SYNC
1406         stmg    %r0,%r7,__PT_R0(%r9)
1407         mvc     __PT_PSW(16,%r9),__LC_SVC_OLD_PSW
1408         mvc     __PT_INT_CODE(4,%r9),__LC_SVC_ILC
1409         xc      __PT_FLAGS(8,%r9),__PT_FLAGS(%r9)
1410         mvi     __PT_FLAGS+7(%r9),_PIF_SYSCALL
1411         # setup saved register r15
1412         stg     %r15,56(%r11)           # r15 stack pointer
1413         # set new psw address and exit
1414         larl    %r9,.Lsysc_do_svc
1415         BR_R11USE_R14
1416 .Lcleanup_system_call_insn:
1417         .quad   system_call
1418         .quad   .Lsysc_stmg
1419         .quad   .Lsysc_per
1420         .quad   .Lsysc_vtime+36
1421         .quad   .Lsysc_vtime+42
1422 .Lcleanup_system_call_const:
1423         .quad   __TASK_thread
1424
1425 .Lcleanup_sysc_tif:
1426         larl    %r9,.Lsysc_tif
1427         BR_R11USE_R14
1428
1429 .Lcleanup_sysc_restore:
1430         # check if stpt has been executed
1431         clg     %r9,BASED(.Lcleanup_sysc_restore_insn)
1432         jh      0f
1433         mvc     __LC_EXIT_TIMER(8),__LC_ASYNC_ENTER_TIMER
1434         cghi    %r11,__LC_SAVE_AREA_ASYNC
1435         je      0f
1436         mvc     __LC_EXIT_TIMER(8),__LC_MCCK_ENTER_TIMER
1437 0:      clg     %r9,BASED(.Lcleanup_sysc_restore_insn+8)
1438         je      1f
1439         lg      %r9,24(%r11)            # get saved pointer to pt_regs
1440         mvc     __LC_RETURN_PSW(16),__PT_PSW(%r9)
1441         mvc     0(64,%r11),__PT_R8(%r9)
1442         lmg     %r0,%r7,__PT_R0(%r9)
1443 1:      lmg     %r8,%r9,__LC_RETURN_PSW
1444         BR_R11USE_R14
1445 .Lcleanup_sysc_restore_insn:
1446         .quad   .Lsysc_exit_timer
1447         .quad   .Lsysc_done - 4
1448
1449 .Lcleanup_io_tif:
1450         larl    %r9,.Lio_tif
1451         BR_R11USE_R14
1452
1453 .Lcleanup_io_restore:
1454         # check if stpt has been executed
1455         clg     %r9,BASED(.Lcleanup_io_restore_insn)
1456         jh      0f
1457         mvc     __LC_EXIT_TIMER(8),__LC_MCCK_ENTER_TIMER
1458 0:      clg     %r9,BASED(.Lcleanup_io_restore_insn+8)
1459         je      1f
1460         lg      %r9,24(%r11)            # get saved r11 pointer to pt_regs
1461         mvc     __LC_RETURN_PSW(16),__PT_PSW(%r9)
1462         mvc     0(64,%r11),__PT_R8(%r9)
1463         lmg     %r0,%r7,__PT_R0(%r9)
1464 1:      lmg     %r8,%r9,__LC_RETURN_PSW
1465         BR_R11USE_R14
1466 .Lcleanup_io_restore_insn:
1467         .quad   .Lio_exit_timer
1468         .quad   .Lio_done - 4
1469
1470 .Lcleanup_idle:
1471         ni      __LC_CPU_FLAGS+7,255-_CIF_ENABLED_WAIT
1472         # copy interrupt clock & cpu timer
1473         mvc     __CLOCK_IDLE_EXIT(8,%r2),__LC_INT_CLOCK
1474         mvc     __TIMER_IDLE_EXIT(8,%r2),__LC_ASYNC_ENTER_TIMER
1475         cghi    %r11,__LC_SAVE_AREA_ASYNC
1476         je      0f
1477         mvc     __CLOCK_IDLE_EXIT(8,%r2),__LC_MCCK_CLOCK
1478         mvc     __TIMER_IDLE_EXIT(8,%r2),__LC_MCCK_ENTER_TIMER
1479 0:      # check if stck & stpt have been executed
1480         clg     %r9,BASED(.Lcleanup_idle_insn)
1481         jhe     1f
1482         mvc     __CLOCK_IDLE_ENTER(8,%r2),__CLOCK_IDLE_EXIT(%r2)
1483         mvc     __TIMER_IDLE_ENTER(8,%r2),__TIMER_IDLE_EXIT(%r2)
1484 1:      # calculate idle cycles
1485 #ifdef CONFIG_SMP
1486         clg     %r9,BASED(.Lcleanup_idle_insn)
1487         jl      3f
1488         larl    %r1,smp_cpu_mtid
1489         llgf    %r1,0(%r1)
1490         ltgr    %r1,%r1
1491         jz      3f
1492         .insn   rsy,0xeb0000000017,%r1,5,__SF_EMPTY+80(%r15)
1493         larl    %r3,mt_cycles
1494         ag      %r3,__LC_PERCPU_OFFSET
1495         la      %r4,__SF_EMPTY+16(%r15)
1496 2:      lg      %r0,0(%r3)
1497         slg     %r0,0(%r4)
1498         alg     %r0,64(%r4)
1499         stg     %r0,0(%r3)
1500         la      %r3,8(%r3)
1501         la      %r4,8(%r4)
1502         brct    %r1,2b
1503 #endif
1504 3:      # account system time going idle
1505         lg      %r9,__LC_STEAL_TIMER
1506         alg     %r9,__CLOCK_IDLE_ENTER(%r2)
1507         slg     %r9,__LC_LAST_UPDATE_CLOCK
1508         stg     %r9,__LC_STEAL_TIMER
1509         mvc     __LC_LAST_UPDATE_CLOCK(8),__CLOCK_IDLE_EXIT(%r2)
1510         lg      %r9,__LC_SYSTEM_TIMER
1511         alg     %r9,__LC_LAST_UPDATE_TIMER
1512         slg     %r9,__TIMER_IDLE_ENTER(%r2)
1513         stg     %r9,__LC_SYSTEM_TIMER
1514         mvc     __LC_LAST_UPDATE_TIMER(8),__TIMER_IDLE_EXIT(%r2)
1515         # prepare return psw
1516         nihh    %r8,0xfcfd              # clear irq & wait state bits
1517         lg      %r9,48(%r11)            # return from psw_idle
1518         BR_R11USE_R14
1519 .Lcleanup_idle_insn:
1520         .quad   .Lpsw_idle_lpsw
1521
1522 .Lcleanup_save_fpu_regs:
1523         larl    %r9,save_fpu_regs
1524         BR_R11USE_R14
1525
1526 .Lcleanup_load_fpu_regs:
1527         larl    %r9,load_fpu_regs
1528         BR_R11USE_R14
1529
1530 /*
1531  * Integer constants
1532  */
1533         .align  8
1534 .Lcritical_start:
1535         .quad   .L__critical_start
1536 .Lcritical_length:
1537         .quad   .L__critical_end - .L__critical_start
1538 #if IS_ENABLED(CONFIG_KVM)
1539 .Lsie_critical_start:
1540         .quad   .Lsie_gmap
1541 .Lsie_critical_length:
1542         .quad   .Lsie_done - .Lsie_gmap
1543 .Lsie_crit_mcck_start:
1544         .quad   .Lsie_entry
1545 .Lsie_crit_mcck_length:
1546         .quad   .Lsie_skip - .Lsie_entry
1547 #endif
1548         .section .rodata, "a"
1549 #define SYSCALL(esame,emu)      .long esame
1550         .globl  sys_call_table
1551 sys_call_table:
1552 #include "asm/syscall_table.h"
1553 #undef SYSCALL
1554
1555 #ifdef CONFIG_COMPAT
1556
1557 #define SYSCALL(esame,emu)      .long emu
1558         .globl  sys_call_table_emu
1559 sys_call_table_emu:
1560 #include "asm/syscall_table.h"
1561 #undef SYSCALL
1562 #endif