2 * arch/s390/kernel/entry.S
3 * S390 low-level entry points.
5 * Copyright (C) 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>
12 #include <linux/init.h>
13 #include <linux/linkage.h>
14 #include <asm/cache.h>
15 #include <asm/errno.h>
16 #include <asm/ptrace.h>
17 #include <asm/thread_info.h>
18 #include <asm/asm-offsets.h>
19 #include <asm/unistd.h>
24 __PT_R1 = __PT_GPRS + 4
25 __PT_R2 = __PT_GPRS + 8
26 __PT_R3 = __PT_GPRS + 12
27 __PT_R4 = __PT_GPRS + 16
28 __PT_R5 = __PT_GPRS + 20
29 __PT_R6 = __PT_GPRS + 24
30 __PT_R7 = __PT_GPRS + 28
31 __PT_R8 = __PT_GPRS + 32
32 __PT_R9 = __PT_GPRS + 36
33 __PT_R10 = __PT_GPRS + 40
34 __PT_R11 = __PT_GPRS + 44
35 __PT_R12 = __PT_GPRS + 48
36 __PT_R13 = __PT_GPRS + 524
37 __PT_R14 = __PT_GPRS + 56
38 __PT_R15 = __PT_GPRS + 60
40 _TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
41 _TIF_MCCK_PENDING | _TIF_PER_TRAP )
42 _TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \
44 _TIF_TRACE = (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP | \
45 _TIF_SYSCALL_TRACEPOINT)
47 STACK_SHIFT = PAGE_SHIFT + THREAD_ORDER
48 STACK_SIZE = 1 << STACK_SHIFT
50 #define BASED(name) name-system_call(%r13)
53 #ifdef CONFIG_TRACE_IRQFLAGS
55 l %r1,BASED(.Lhardirqs_on)
56 basr %r14,%r1 # call trace_hardirqs_on_caller
61 #ifdef CONFIG_TRACE_IRQFLAGS
63 l %r1,BASED(.Lhardirqs_off)
64 basr %r14,%r1 # call trace_hardirqs_off_caller
68 .macro LOCKDEP_SYS_EXIT
70 tm __PT_PSW+1(%r11),0x01 # returning to user ?
72 l %r1,BASED(.Llockdep_sys_exit)
73 basr %r14,%r1 # call lockdep_sys_exit
77 .macro CHECK_STACK stacksize,savearea
78 #ifdef CONFIG_CHECK_STACK
79 tml %r15,\stacksize - CONFIG_STACK_GUARD
85 .macro SWITCH_ASYNC savearea,stack,shift
86 tmh %r8,0x0001 # interrupting from user ?
89 sl %r14,BASED(.Lcritical_start)
90 cl %r14,BASED(.Lcritical_length)
92 la %r11,\savearea # inside critical section, do cleanup
93 bras %r14,cleanup_critical
94 tmh %r8,0x0001 # retest problem state after cleanup
96 0: l %r14,\stack # are we already on the target stack?
100 CHECK_STACK 1<<\shift,\savearea
102 1: l %r15,\stack # load target stack
103 2: ahi %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
104 la %r11,STACK_FRAME_OVERHEAD(%r15)
107 .macro ADD64 high,low,timer
114 .macro SUB64 high,low,timer
121 .macro UPDATE_VTIME high,low,enter_timer
122 lm \high,\low,__LC_EXIT_TIMER
123 SUB64 \high,\low,\enter_timer
124 ADD64 \high,\low,__LC_USER_TIMER
125 stm \high,\low,__LC_USER_TIMER
126 lm \high,\low,__LC_LAST_UPDATE_TIMER
127 SUB64 \high,\low,__LC_EXIT_TIMER
128 ADD64 \high,\low,__LC_SYSTEM_TIMER
129 stm \high,\low,__LC_SYSTEM_TIMER
130 mvc __LC_LAST_UPDATE_TIMER(8),\enter_timer
134 st %r8,__LC_RETURN_PSW
135 ni __LC_RETURN_PSW,0xbf
139 .section .kprobes.text, "ax"
142 * Scheduler resume function, called by switch_to
143 * gpr2 = (task_struct *) prev
144 * gpr3 = (task_struct *) next
149 stm %r6,%r15,__SF_GPRS(%r15) # store gprs of prev task
150 st %r15,__THREAD_ksp(%r2) # store kernel stack of prev
151 l %r4,__THREAD_info(%r2) # get thread_info of prev
152 l %r5,__THREAD_info(%r3) # get thread_info of next
154 ahi %r15,STACK_SIZE # end of kernel stack of next
155 st %r3,__LC_CURRENT # store task struct of next
156 st %r5,__LC_THREAD_INFO # store thread info of next
157 st %r15,__LC_KERNEL_STACK # store end of kernel stack
158 lctl %c4,%c4,__TASK_pid(%r3) # load pid to control reg. 4
159 mvc __LC_CURRENT_PID(4,%r0),__TASK_pid(%r3) # store pid of next
160 l %r15,__THREAD_ksp(%r3) # load kernel stack of next
161 tm __TI_flags+3(%r4),_TIF_MCCK_PENDING # machine check pending?
163 ni __TI_flags+3(%r4),255-_TIF_MCCK_PENDING # clear flag in prev
164 oi __TI_flags+3(%r5),_TIF_MCCK_PENDING # set it in next
165 0: lm %r6,%r15,__SF_GPRS(%r15) # load gprs of next task
170 * SVC interrupt handler routine. System calls are synchronous events and
171 * are executed with interrupts enabled.
175 stpt __LC_SYNC_ENTER_TIMER
177 stm %r8,%r15,__LC_SAVE_AREA_SYNC
178 l %r12,__LC_THREAD_INFO
179 l %r13,__LC_SVC_NEW_PSW+4
181 l %r15,__LC_KERNEL_STACK
182 ahi %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
183 la %r11,STACK_FRAME_OVERHEAD(%r15) # pointer to pt_regs
185 UPDATE_VTIME %r8,%r9,__LC_SYNC_ENTER_TIMER
186 stm %r0,%r7,__PT_R0(%r11)
187 mvc __PT_R8(32,%r11),__LC_SAVE_AREA_SYNC
188 mvc __PT_PSW(8,%r11),__LC_SVC_OLD_PSW
189 mvc __PT_INT_CODE(4,%r11),__LC_SVC_ILC
191 oi __TI_flags+3(%r12),_TIF_SYSCALL
192 lh %r8,__PT_INT_CODE+2(%r11)
193 sla %r8,2 # shift and test for svc0
195 # svc 0: system call number in %r1
196 cl %r1,BASED(.Lnr_syscalls)
198 sth %r1,__PT_INT_CODE+2(%r11)
202 l %r10,BASED(.Lsys_call_table) # 31 bit system call table
203 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
204 st %r2,__PT_ORIG_GPR2(%r11)
205 st %r7,STACK_FRAME_OVERHEAD(%r15)
206 l %r9,0(%r8,%r10) # get system call addr.
207 tm __TI_flags+2(%r12),_TIF_TRACE >> 8
209 basr %r14,%r9 # call sys_xxxx
210 st %r2,__PT_R2(%r11) # store return value
215 tm __PT_PSW+1(%r11),0x01 # returning to user ?
217 tm __TI_flags+3(%r12),_TIF_WORK_SVC
218 jnz sysc_work # check for work
219 ni __TI_flags+3(%r12),255-_TIF_SYSCALL
221 mvc __LC_RETURN_PSW(8),__PT_PSW(%r11)
223 lm %r0,%r15,__PT_R0(%r11)
228 # One of the work bits is on. Find out which one.
231 tm __TI_flags+3(%r12),_TIF_MCCK_PENDING
233 tm __TI_flags+3(%r12),_TIF_NEED_RESCHED
235 tm __TI_flags+3(%r12),_TIF_SIGPENDING
237 tm __TI_flags+3(%r12),_TIF_NOTIFY_RESUME
238 jo sysc_notify_resume
239 tm __TI_flags+3(%r12),_TIF_PER_TRAP
241 j sysc_return # beware of critical section cleanup
244 # _TIF_NEED_RESCHED is set, call schedule
247 l %r1,BASED(.Lschedule)
248 la %r14,BASED(sysc_return)
249 br %r1 # call schedule
252 # _TIF_MCCK_PENDING is set, call handler
255 l %r1,BASED(.Lhandle_mcck)
256 la %r14,BASED(sysc_return)
257 br %r1 # TIF bit will be cleared by handler
260 # _TIF_SIGPENDING is set, call do_signal
263 ni __TI_flags+3(%r12),255-_TIF_PER_TRAP # clear TIF_PER_TRAP
264 lr %r2,%r11 # pass pointer to pt_regs
265 l %r1,BASED(.Ldo_signal)
266 basr %r14,%r1 # call do_signal
267 tm __TI_flags+3(%r12),_TIF_SYSCALL
269 lm %r2,%r7,__PT_R2(%r11) # load svc arguments
270 xr %r8,%r8 # svc 0 returns -ENOSYS
271 clc __PT_INT_CODE+2(2,%r11),BASED(.Lnr_syscalls+2)
272 jnl sysc_nr_ok # invalid svc number -> do svc 0
273 lh %r8,__PT_INT_CODE+2(%r11) # load new svc number
275 j sysc_nr_ok # restart svc
278 # _TIF_NOTIFY_RESUME is set, call do_notify_resume
281 lr %r2,%r11 # pass pointer to pt_regs
282 l %r1,BASED(.Ldo_notify_resume)
283 la %r14,BASED(sysc_return)
284 br %r1 # call do_notify_resume
287 # _TIF_PER_TRAP is set, call do_per_trap
290 ni __TI_flags+3(%r12),255-(_TIF_SYSCALL | _TIF_PER_TRAP)
291 lr %r2,%r11 # pass pointer to pt_regs
292 l %r1,BASED(.Ldo_per_trap)
293 la %r14,BASED(sysc_return)
294 br %r1 # call do_per_trap
297 # call tracehook_report_syscall_entry/tracehook_report_syscall_exit before
298 # and after the system call
301 l %r1,BASED(.Ltrace_enter)
302 lr %r2,%r11 # pass pointer to pt_regs
305 icm %r0,3,__PT_INT_CODE+2(%r11)
307 basr %r14,%r1 # call do_syscall_trace_enter
308 cl %r2,BASED(.Lnr_syscalls)
314 lm %r3,%r7,__PT_R3(%r11)
315 st %r7,STACK_FRAME_OVERHEAD(%r15)
316 l %r2,__PT_ORIG_GPR2(%r11)
317 basr %r14,%r9 # call sys_xxx
318 st %r2,__PT_R2(%r11) # store return value
320 tm __TI_flags+2(%r12),_TIF_TRACE >> 8
322 l %r1,BASED(.Ltrace_exit)
323 lr %r2,%r11 # pass pointer to pt_regs
324 la %r14,BASED(sysc_return)
325 br %r1 # call do_syscall_trace_exit
328 # a new process exits the kernel with ret_from_fork
331 la %r11,STACK_FRAME_OVERHEAD(%r15)
332 l %r12,__LC_THREAD_INFO
333 l %r13,__LC_SVC_NEW_PSW+4
334 tm __PT_PSW+1(%r11),0x01 # forking a kernel thread ?
336 st %r15,__PT_R15(%r11) # store stack pointer for new kthread
337 0: l %r1,BASED(.Lschedule_tail)
338 basr %r14,%r1 # call schedule_tail
340 ssm __LC_SVC_NEW_PSW # reenable interrupts
344 # kernel_execve function needs to deal with pt_regs that is not
348 stm %r12,%r15,48(%r15)
350 l %r13,__LC_SVC_NEW_PSW+4
351 ahi %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
352 st %r14,__SF_BACKCHAIN(%r15)
353 la %r12,STACK_FRAME_OVERHEAD(%r15)
354 xc 0(__PT_SIZE,%r12),0(%r12)
355 l %r1,BASED(.Ldo_execve)
357 basr %r14,%r1 # call do_execve
360 ahi %r15,(STACK_FRAME_OVERHEAD + __PT_SIZE)
361 lm %r12,%r15,48(%r15)
364 0: ssm __LC_PGM_NEW_PSW # disable I/O and ext. interrupts
365 l %r15,__LC_KERNEL_STACK # load ksp
366 ahi %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
367 la %r11,STACK_FRAME_OVERHEAD(%r15)
368 mvc 0(__PT_SIZE,%r11),0(%r12) # copy pt_regs
369 l %r12,__LC_THREAD_INFO
370 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
371 ssm __LC_SVC_NEW_PSW # reenable interrupts
372 l %r1,BASED(.Lexecve_tail)
373 basr %r14,%r1 # call execve_tail
377 * Program check handler routine
380 ENTRY(pgm_check_handler)
381 stpt __LC_SYNC_ENTER_TIMER
382 stm %r8,%r15,__LC_SAVE_AREA_SYNC
383 l %r12,__LC_THREAD_INFO
384 l %r13,__LC_SVC_NEW_PSW+4
385 lm %r8,%r9,__LC_PGM_OLD_PSW
386 tmh %r8,0x0001 # test problem state bit
387 jnz 1f # -> fault in user space
388 tmh %r8,0x4000 # PER bit set in old PSW ?
389 jnz 0f # -> enabled, can't be a double fault
390 tm __LC_PGM_ILC+3,0x80 # check for per exception
391 jnz pgm_svcper # -> single stepped svc
392 0: CHECK_STACK STACK_SIZE,__LC_SAVE_AREA_SYNC
394 1: UPDATE_VTIME %r14,%r15,__LC_SYNC_ENTER_TIMER
395 l %r15,__LC_KERNEL_STACK
396 2: ahi %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
397 la %r11,STACK_FRAME_OVERHEAD(%r15)
398 stm %r0,%r7,__PT_R0(%r11)
399 mvc __PT_R8(32,%r11),__LC_SAVE_AREA_SYNC
400 stm %r8,%r9,__PT_PSW(%r11)
401 mvc __PT_INT_CODE(4,%r11),__LC_PGM_ILC
402 mvc __PT_INT_PARM_LONG(4,%r11),__LC_TRANS_EXC_CODE
403 tm __LC_PGM_ILC+3,0x80 # check for per exception
405 l %r1,__TI_task(%r12)
406 tmh %r8,0x0001 # kernel per event ?
408 oi __TI_flags+3(%r12),_TIF_PER_TRAP
409 mvc __THREAD_per_address(4,%r1),__LC_PER_ADDRESS
410 mvc __THREAD_per_cause(2,%r1),__LC_PER_CAUSE
411 mvc __THREAD_per_paid(1,%r1),__LC_PER_PAID
413 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
414 l %r1,BASED(.Ljump_table)
416 n %r10,__PT_INT_CODE(%r11)
419 l %r1,0(%r10,%r1) # load address of handler routine
420 lr %r2,%r11 # pass pointer to pt_regs
421 basr %r14,%r1 # branch to interrupt-handler
425 # PER event in supervisor state, must be kprobes
429 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
430 l %r1,BASED(.Ldo_per_trap)
431 lr %r2,%r11 # pass pointer to pt_regs
432 basr %r14,%r1 # call do_per_trap
436 # single stepped system call
439 oi __TI_flags+3(%r12),_TIF_PER_TRAP
440 mvc __LC_RETURN_PSW(4),__LC_SVC_NEW_PSW
441 mvc __LC_RETURN_PSW+4(4),BASED(.Lsysc_per)
442 lpsw __LC_RETURN_PSW # branch to sysc_per and enable irqs
445 * IO interrupt handler routine
448 ENTRY(io_int_handler)
450 stpt __LC_ASYNC_ENTER_TIMER
451 stm %r8,%r15,__LC_SAVE_AREA_ASYNC
452 l %r12,__LC_THREAD_INFO
453 l %r13,__LC_SVC_NEW_PSW+4
454 lm %r8,%r9,__LC_IO_OLD_PSW
455 tmh %r8,0x0001 # interrupting from user ?
457 UPDATE_VTIME %r14,%r15,__LC_ASYNC_ENTER_TIMER
459 SWITCH_ASYNC __LC_SAVE_AREA_ASYNC,__LC_ASYNC_STACK,STACK_SHIFT
460 stm %r0,%r7,__PT_R0(%r11)
461 mvc __PT_R8(32,%r11),__LC_SAVE_AREA_ASYNC
462 stm %r8,%r9,__PT_PSW(%r11)
464 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
465 l %r1,BASED(.Ldo_IRQ)
466 lr %r2,%r11 # pass pointer to pt_regs
467 basr %r14,%r1 # call do_IRQ
472 tm __TI_flags+3(%r12),_TIF_WORK_INT
473 jnz io_work # there is work to do (signals etc.)
475 mvc __LC_RETURN_PSW(8),__PT_PSW(%r11)
477 lm %r0,%r15,__PT_R0(%r11)
482 # There is work todo, find out in which context we have been interrupted:
483 # 1) if we return to user space we can do all _TIF_WORK_INT work
484 # 2) if we return to kernel code and preemptive scheduling is enabled check
485 # the preemption counter and if it is zero call preempt_schedule_irq
486 # Before any work can be done, a switch to the kernel stack is required.
489 tm __PT_PSW+1(%r11),0x01 # returning to user ?
490 jo io_work_user # yes -> do resched & signal
491 #ifdef CONFIG_PREEMPT
492 # check for preemptive scheduling
493 icm %r0,15,__TI_precount(%r12)
494 jnz io_restore # preemption disabled
495 tm __TI_flags+3(%r12),_TIF_NEED_RESCHED
497 # switch to kernel stack
499 ahi %r1,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
500 mvc STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
501 xc __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1)
502 la %r11,STACK_FRAME_OVERHEAD(%r1)
504 # TRACE_IRQS_ON already done at io_return, call
505 # TRACE_IRQS_OFF to keep things symmetrical
507 l %r1,BASED(.Lpreempt_irq)
508 basr %r14,%r1 # call preempt_schedule_irq
515 # Need to do work before returning to userspace, switch to kernel stack
518 l %r1,__LC_KERNEL_STACK
519 ahi %r1,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
520 mvc STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
521 xc __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1)
522 la %r11,STACK_FRAME_OVERHEAD(%r1)
526 # One of the work bits is on. Find out which one.
527 # Checked are: _TIF_SIGPENDING, _TIF_NOTIFY_RESUME, _TIF_NEED_RESCHED
528 # and _TIF_MCCK_PENDING
531 tm __TI_flags+3(%r12),_TIF_MCCK_PENDING
533 tm __TI_flags+3(%r12),_TIF_NEED_RESCHED
535 tm __TI_flags+3(%r12),_TIF_SIGPENDING
537 tm __TI_flags+3(%r12),_TIF_NOTIFY_RESUME
539 j io_return # beware of critical section cleanup
542 # _TIF_MCCK_PENDING is set, call handler
545 # TRACE_IRQS_ON already done at io_return
546 l %r1,BASED(.Lhandle_mcck)
547 basr %r14,%r1 # TIF bit will be cleared by handler
552 # _TIF_NEED_RESCHED is set, call schedule
555 # TRACE_IRQS_ON already done at io_return
556 l %r1,BASED(.Lschedule)
557 ssm __LC_SVC_NEW_PSW # reenable interrupts
558 basr %r14,%r1 # call scheduler
559 ssm __LC_PGM_NEW_PSW # disable I/O and ext. interrupts
564 # _TIF_SIGPENDING is set, call do_signal
567 # TRACE_IRQS_ON already done at io_return
568 l %r1,BASED(.Ldo_signal)
569 ssm __LC_SVC_NEW_PSW # reenable interrupts
570 lr %r2,%r11 # pass pointer to pt_regs
571 basr %r14,%r1 # call do_signal
572 ssm __LC_PGM_NEW_PSW # disable I/O and ext. interrupts
577 # _TIF_SIGPENDING is set, call do_signal
580 # TRACE_IRQS_ON already done at io_return
581 l %r1,BASED(.Ldo_notify_resume)
582 ssm __LC_SVC_NEW_PSW # reenable interrupts
583 lr %r2,%r11 # pass pointer to pt_regs
584 basr %r14,%r1 # call do_notify_resume
585 ssm __LC_PGM_NEW_PSW # disable I/O and ext. interrupts
590 * External interrupt handler routine
593 ENTRY(ext_int_handler)
595 stpt __LC_ASYNC_ENTER_TIMER
596 stm %r8,%r15,__LC_SAVE_AREA_ASYNC
597 l %r12,__LC_THREAD_INFO
598 l %r13,__LC_SVC_NEW_PSW+4
599 lm %r8,%r9,__LC_EXT_OLD_PSW
600 tmh %r8,0x0001 # interrupting from user ?
602 UPDATE_VTIME %r14,%r15,__LC_ASYNC_ENTER_TIMER
604 SWITCH_ASYNC __LC_SAVE_AREA_ASYNC,__LC_ASYNC_STACK,STACK_SHIFT
605 stm %r0,%r7,__PT_R0(%r11)
606 mvc __PT_R8(32,%r11),__LC_SAVE_AREA_ASYNC
607 stm %r8,%r9,__PT_PSW(%r11)
609 lr %r2,%r11 # pass pointer to pt_regs
610 l %r3,__LC_EXT_CPU_ADDR # get cpu address + interruption code
611 l %r4,__LC_EXT_PARAMS # get external parameters
612 l %r1,BASED(.Ldo_extint)
613 basr %r14,%r1 # call do_extint
617 * Load idle PSW. The second "half" of this function is in cleanup_idle.
620 st %r4,__SF_EMPTY(%r15)
622 la %r1,psw_idle_lpsw+4-.(%r1)
623 st %r1,__SF_EMPTY+4(%r15)
624 oi __SF_EMPTY+4(%r15),0x80
625 la %r1,.Lvtimer_max-psw_idle_lpsw-4(%r1)
626 stck __IDLE_ENTER(%r2)
628 stpt __VQ_IDLE_ENTER(%r3)
632 lpsw __SF_EMPTY(%r15)
639 * Machine check handler routines
642 ENTRY(mcck_int_handler)
644 spt __LC_CPU_TIMER_SAVE_AREA # revalidate cpu timer
645 lm %r0,%r15,__LC_GPREGS_SAVE_AREA # revalidate gprs
646 l %r12,__LC_THREAD_INFO
647 l %r13,__LC_SVC_NEW_PSW+4
648 lm %r8,%r9,__LC_MCK_OLD_PSW
649 tm __LC_MCCK_CODE,0x80 # system damage?
650 jo mcck_panic # yes -> rest of mcck code invalid
651 la %r14,__LC_CPU_TIMER_SAVE_AREA
652 mvc __LC_MCCK_ENTER_TIMER(8),0(%r14)
653 tm __LC_MCCK_CODE+5,0x02 # stored cpu timer value valid?
655 la %r14,__LC_SYNC_ENTER_TIMER
656 clc 0(8,%r14),__LC_ASYNC_ENTER_TIMER
658 la %r14,__LC_ASYNC_ENTER_TIMER
659 0: clc 0(8,%r14),__LC_EXIT_TIMER
661 la %r14,__LC_EXIT_TIMER
662 1: clc 0(8,%r14),__LC_LAST_UPDATE_TIMER
664 la %r14,__LC_LAST_UPDATE_TIMER
666 mvc __LC_MCCK_ENTER_TIMER(8),0(%r14)
667 3: tm __LC_MCCK_CODE+2,0x09 # mwp + ia of old psw valid?
668 jno mcck_panic # no -> skip cleanup critical
669 tm %r8,0x0001 # interrupting from user ?
671 UPDATE_VTIME %r14,%r15,__LC_MCCK_ENTER_TIMER
673 SWITCH_ASYNC __LC_GPREGS_SAVE_AREA+32,__LC_PANIC_STACK,PAGE_SHIFT
674 mvc __PT_R0(64,%r11),__LC_GPREGS_SAVE_AREA
675 stm %r8,%r9,__PT_PSW(%r11)
676 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
677 l %r1,BASED(.Ldo_machine_check)
678 lr %r2,%r11 # pass pointer to pt_regs
679 basr %r14,%r1 # call s390_do_machine_check
680 tm __PT_PSW+1(%r11),0x01 # returning to user ?
682 l %r1,__LC_KERNEL_STACK # switch to kernel stack
683 ahi %r1,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
684 mvc STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
685 xc __SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1)
686 la %r11,STACK_FRAME_OVERHEAD(%r15)
688 ssm __LC_PGM_NEW_PSW # turn dat on, keep irqs off
689 tm __TI_flags+3(%r12),_TIF_MCCK_PENDING
692 l %r1,BASED(.Lhandle_mcck)
693 basr %r14,%r1 # call s390_handle_mcck
696 mvc __LC_RETURN_MCCK_PSW(8),__PT_PSW(%r11) # move return PSW
697 tm __LC_RETURN_MCCK_PSW+1,0x01 # returning to user ?
699 lm %r0,%r15,__PT_R0(%r11)
701 lpsw __LC_RETURN_MCCK_PSW
702 0: lm %r0,%r15,__PT_R0(%r11)
703 lpsw __LC_RETURN_MCCK_PSW
706 l %r14,__LC_PANIC_STACK
710 l %r15,__LC_PANIC_STACK
711 0: ahi %r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)
715 # PSW restart interrupt handler
717 ENTRY(restart_int_handler)
718 st %r15,__LC_SAVE_AREA_RESTART
719 l %r15,__LC_RESTART_STACK
720 ahi %r15,-__PT_SIZE # create pt_regs on stack
721 xc 0(__PT_SIZE,%r15),0(%r15)
722 stm %r0,%r14,__PT_R0(%r15)
723 mvc __PT_R15(4,%r15),__LC_SAVE_AREA_RESTART
724 mvc __PT_PSW(8,%r15),__LC_RST_OLD_PSW # store restart old psw
725 ahi %r15,-STACK_FRAME_OVERHEAD # create stack frame on stack
726 xc 0(STACK_FRAME_OVERHEAD,%r15),0(%r15)
727 l %r1,__LC_RESTART_FN # load fn, parm & source cpu
728 l %r2,__LC_RESTART_DATA
729 l %r3,__LC_RESTART_SOURCE
730 ltr %r3,%r3 # test source cpu address
731 jm 1f # negative -> skip source stop
732 0: sigp %r4,%r3,SIGP_SENSE # sigp sense to source cpu
733 brc 10,0b # wait for status stored
734 1: basr %r14,%r1 # call function
735 stap __SF_EMPTY(%r15) # store cpu address
736 lh %r3,__SF_EMPTY(%r15)
737 2: sigp %r4,%r3,SIGP_STOP # sigp stop to current cpu
741 .section .kprobes.text, "ax"
743 #ifdef CONFIG_CHECK_STACK
745 * The synchronous or the asynchronous stack overflowed. We are dead.
746 * No need to properly save the registers, we are going to panic anyway.
747 * Setup a pt_regs so that show_trace can provide a good call trace.
750 l %r15,__LC_PANIC_STACK # change to panic stack
751 ahi %r15,-__PT_SIZE # create pt_regs
752 stm %r0,%r7,__PT_R0(%r15)
753 stm %r8,%r9,__PT_PSW(%r15)
754 mvc __PT_R8(32,%r11),0(%r14)
756 ahi %r15,-STACK_FRAME_OVERHEAD
758 xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)
759 lr %r2,%r11 # pass pointer to pt_regs
760 br %r1 # branch to kernel_stack_overflow
761 1: .long kernel_stack_overflow
765 .long system_call + 0x80000000
766 .long sysc_do_svc + 0x80000000
767 .long sysc_tif + 0x80000000
768 .long sysc_restore + 0x80000000
769 .long sysc_done + 0x80000000
770 .long io_tif + 0x80000000
771 .long io_restore + 0x80000000
772 .long io_done + 0x80000000
773 .long psw_idle + 0x80000000
774 .long psw_idle_end + 0x80000000
777 cl %r9,BASED(cleanup_table) # system_call
779 cl %r9,BASED(cleanup_table+4) # sysc_do_svc
780 jl cleanup_system_call
781 cl %r9,BASED(cleanup_table+8) # sysc_tif
783 cl %r9,BASED(cleanup_table+12) # sysc_restore
785 cl %r9,BASED(cleanup_table+16) # sysc_done
786 jl cleanup_sysc_restore
787 cl %r9,BASED(cleanup_table+20) # io_tif
789 cl %r9,BASED(cleanup_table+24) # io_restore
791 cl %r9,BASED(cleanup_table+28) # io_done
792 jl cleanup_io_restore
793 cl %r9,BASED(cleanup_table+32) # psw_idle
795 cl %r9,BASED(cleanup_table+36) # psw_idle_end
800 # check if stpt has been executed
801 cl %r9,BASED(cleanup_system_call_insn)
803 mvc __LC_SYNC_ENTER_TIMER(8),__LC_ASYNC_ENTER_TIMER
804 chi %r11,__LC_SAVE_AREA_ASYNC
806 mvc __LC_SYNC_ENTER_TIMER(8),__LC_MCCK_ENTER_TIMER
807 0: # check if stm has been executed
808 cl %r9,BASED(cleanup_system_call_insn+4)
810 mvc __LC_SAVE_AREA_SYNC(32),0(%r11)
811 0: # set up saved registers r12, and r13
812 st %r12,16(%r11) # r12 thread-info pointer
813 st %r13,20(%r11) # r13 literal-pool pointer
814 # check if the user time calculation has been done
815 cl %r9,BASED(cleanup_system_call_insn+8)
817 l %r10,__LC_EXIT_TIMER
818 l %r15,__LC_EXIT_TIMER+4
819 SUB64 %r10,%r15,__LC_SYNC_ENTER_TIMER
820 ADD64 %r10,%r15,__LC_USER_TIMER
821 st %r10,__LC_USER_TIMER
822 st %r15,__LC_USER_TIMER+4
823 0: # check if the system time calculation has been done
824 cl %r9,BASED(cleanup_system_call_insn+12)
826 l %r10,__LC_LAST_UPDATE_TIMER
827 l %r15,__LC_LAST_UPDATE_TIMER+4
828 SUB64 %r10,%r15,__LC_EXIT_TIMER
829 ADD64 %r10,%r15,__LC_SYSTEM_TIMER
830 st %r10,__LC_SYSTEM_TIMER
831 st %r15,__LC_SYSTEM_TIMER+4
832 0: # update accounting time stamp
833 mvc __LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER
834 # set up saved register 11
835 l %r15,__LC_KERNEL_STACK
837 st %r15,12(%r11) # r11 pt_regs pointer
839 mvc __PT_R8(32,%r15),__LC_SAVE_AREA_SYNC
840 stm %r0,%r7,__PT_R0(%r15)
841 mvc __PT_PSW(8,%r15),__LC_SVC_OLD_PSW
842 mvc __PT_INT_CODE(4,%r15),__LC_SVC_ILC
843 # setup saved register 15
844 ahi %r15,-STACK_FRAME_OVERHEAD
845 st %r15,28(%r11) # r15 stack pointer
846 # set new psw address and exit
847 l %r9,BASED(cleanup_table+4) # sysc_do_svc + 0x80000000
849 cleanup_system_call_insn:
850 .long system_call + 0x80000000
851 .long sysc_stm + 0x80000000
852 .long sysc_vtime + 0x80000000 + 36
853 .long sysc_vtime + 0x80000000 + 76
856 l %r9,BASED(cleanup_table+8) # sysc_tif + 0x80000000
859 cleanup_sysc_restore:
860 cl %r9,BASED(cleanup_sysc_restore_insn)
862 l %r9,12(%r11) # get saved pointer to pt_regs
863 mvc __LC_RETURN_PSW(8),__PT_PSW(%r9)
864 mvc 0(32,%r11),__PT_R8(%r9)
865 lm %r0,%r7,__PT_R0(%r9)
866 0: lm %r8,%r9,__LC_RETURN_PSW
868 cleanup_sysc_restore_insn:
869 .long sysc_done - 4 + 0x80000000
872 l %r9,BASED(cleanup_table+20) # io_tif + 0x80000000
876 cl %r9,BASED(cleanup_io_restore_insn)
878 l %r9,12(%r11) # get saved r11 pointer to pt_regs
879 mvc __LC_RETURN_PSW(8),__PT_PSW(%r9)
880 mvc 0(32,%r11),__PT_R8(%r9)
881 lm %r0,%r7,__PT_R0(%r9)
882 0: lm %r8,%r9,__LC_RETURN_PSW
884 cleanup_io_restore_insn:
885 .long io_done - 4 + 0x80000000
888 # copy interrupt clock & cpu timer
889 mvc __IDLE_EXIT(8,%r2),__LC_INT_CLOCK
890 mvc __VQ_IDLE_EXIT(8,%r3),__LC_ASYNC_ENTER_TIMER
891 chi %r11,__LC_SAVE_AREA_ASYNC
893 mvc __IDLE_EXIT(8,%r2),__LC_MCCK_CLOCK
894 mvc __VQ_IDLE_EXIT(8,%r3),__LC_MCCK_ENTER_TIMER
895 0: # check if stck has been executed
896 cl %r9,BASED(cleanup_idle_insn)
898 mvc __IDLE_ENTER(8,%r2),__IDLE_EXIT(%r2)
899 mvc __VQ_IDLE_ENTER(8,%r3),__VQ_IDLE_EXIT(%r3)
901 1: # check if the cpu timer has been reprogrammed
904 spt __VQ_IDLE_ENTER(%r3)
905 2: # account system time going idle
906 lm %r9,%r10,__LC_STEAL_TIMER
907 ADD64 %r9,%r10,__IDLE_ENTER(%r2)
908 SUB64 %r9,%r10,__LC_LAST_UPDATE_CLOCK
909 stm %r9,%r10,__LC_STEAL_TIMER
910 mvc __LC_LAST_UPDATE_CLOCK(8),__IDLE_EXIT(%r2)
911 lm %r9,%r10,__LC_SYSTEM_TIMER
912 ADD64 %r9,%r10,__LC_LAST_UPDATE_TIMER
913 SUB64 %r9,%r10,__VQ_IDLE_ENTER(%r3)
914 stm %r9,%r10,__LC_SYSTEM_TIMER
915 mvc __LC_LAST_UPDATE_TIMER(8),__VQ_IDLE_EXIT(%r3)
917 n %r8,BASED(cleanup_idle_wait) # clear wait state bit
918 l %r9,24(%r11) # return from psw_idle
921 .long psw_idle_lpsw + 0x80000000
932 .quad 0x7fffffffffffffff
937 .Ldo_machine_check: .long s390_do_machine_check
938 .Lhandle_mcck: .long s390_handle_mcck
939 .Ldo_IRQ: .long do_IRQ
940 .Ldo_extint: .long do_extint
941 .Ldo_signal: .long do_signal
942 .Ldo_notify_resume: .long do_notify_resume
943 .Ldo_per_trap: .long do_per_trap
944 .Ldo_execve: .long do_execve
945 .Lexecve_tail: .long execve_tail
946 .Ljump_table: .long pgm_check_table
947 .Lschedule: .long schedule
948 #ifdef CONFIG_PREEMPT
949 .Lpreempt_irq: .long preempt_schedule_irq
951 .Ltrace_enter: .long do_syscall_trace_enter
952 .Ltrace_exit: .long do_syscall_trace_exit
953 .Lschedule_tail: .long schedule_tail
954 .Lsys_call_table: .long sys_call_table
955 .Lsysc_per: .long sysc_per + 0x80000000
956 #ifdef CONFIG_TRACE_IRQFLAGS
957 .Lhardirqs_on: .long trace_hardirqs_on_caller
958 .Lhardirqs_off: .long trace_hardirqs_off_caller
960 #ifdef CONFIG_LOCKDEP
961 .Llockdep_sys_exit: .long lockdep_sys_exit
963 .Lcritical_start: .long __critical_start + 0x80000000
964 .Lcritical_length: .long __critical_end - __critical_start
966 .section .rodata, "a"
967 #define SYSCALL(esa,esame,emu) .long esa
968 .globl sys_call_table
970 #include "syscalls.S"