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