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