/* *  arch/s390/kernel/entry.S *    S390 low-level entry points. * *  S390 version *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com), *               Hartmut Penner (hp@de.ibm.com), *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com), */#include <linux/sys.h>#include <linux/linkage.h>#include <linux/config.h>#include <asm/cache.h>#include <asm/lowcore.h>#include <asm/errno.h>#include <asm/ptrace.h>#include <asm/thread_info.h>#include <asm/offsets.h>#include <asm/unistd.h>/* * Stack layout for the system_call stack entry. * The first few entries are identical to the user_regs_struct. */SP_PTREGS    =  STACK_FRAME_OVERHEADSP_ARGS      =  STACK_FRAME_OVERHEAD + __PT_ARGSSP_PSW       =  STACK_FRAME_OVERHEAD + __PT_PSWSP_R0        =  STACK_FRAME_OVERHEAD + __PT_GPRSSP_R1        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 4SP_R2        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 8SP_R3        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 12SP_R4        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 16SP_R5        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 20SP_R6        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 24SP_R7        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 28SP_R8        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 32SP_R9        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 36SP_R10       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 40SP_R11       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 44SP_R12       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 48SP_R13       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 52SP_R14       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 56SP_R15       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 60SP_ORIG_R2   =  STACK_FRAME_OVERHEAD + __PT_ORIG_GPR2SP_ILC       =  STACK_FRAME_OVERHEAD + __PT_ILCSP_TRAP      =  STACK_FRAME_OVERHEAD + __PT_TRAPSP_SIZE      =  STACK_FRAME_OVERHEAD + __PT_SIZE_TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NEED_RESCHED | \		 _TIF_RESTART_SVC | _TIF_SINGLE_STEP )_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NEED_RESCHED)#define BASED(name) name-system_call(%r13)/* * Register usage in interrupt handlers: *    R9  - pointer to current task structure *    R13 - pointer to literal pool *    R14 - return register for function calls *    R15 - kernel stack pointer */	.macro	SAVE_ALL_BASE savearea	stm	%r12,%r15,\savearea	l	%r13,__LC_SVC_NEW_PSW+4	# load &system_call to %r13	.endm	.macro	SAVE_ALL psworg,savearea,sync	la	%r12,\psworg	.if	\sync	tm	\psworg+1,0x01		# test problem state bit	bz	BASED(2f)		# skip stack setup save	l	%r15,__LC_KERNEL_STACK	# problem state -> load ksp	.else	tm	\psworg+1,0x01		# test problem state bit	bnz	BASED(1f)		# from user -> load async stack	clc	\psworg+4(4),BASED(.Lcritical_end)	bhe	BASED(0f)	clc	\psworg+4(4),BASED(.Lcritical_start)	bl	BASED(0f)	l	%r14,BASED(.Lcleanup_critical)	basr	%r14,%r14	tm	0(%r12),0x01		# retest problem state after cleanup	bnz	BASED(1f)0:	l	%r14,__LC_ASYNC_STACK	# are we already on the async stack ?	slr	%r14,%r15	sra	%r14,13	be	BASED(2f)1:	l	%r15,__LC_ASYNC_STACK	.endif2:	s	%r15,BASED(.Lc_spsize)	# make room for registers & psw	mvc	SP_PSW(8,%r15),0(%r12)	# move user PSW to stack	la	%r12,\psworg	st	%r2,SP_ORIG_R2(%r15)	# store original content of gpr 2	icm	%r12,12,__LC_SVC_ILC	stm	%r0,%r11,SP_R0(%r15)	# store gprs %r0-%r11 to kernel stack	st	%r12,SP_ILC(%r15)	mvc	SP_R12(16,%r15),\savearea # move %r12-%r15 to stack	la	%r12,0	st	%r12,0(%r15)		# clear back chain	.endm	.macro  RESTORE_ALL sync	mvc	__LC_RETURN_PSW(8),SP_PSW(%r15) # move user PSW to lowcore	.if !\sync	ni	__LC_RETURN_PSW+1,0xfd	# clear wait state bit	.endif	lm	%r0,%r15,SP_R0(%r15)	# load gprs 0-15 of user	lpsw	__LC_RETURN_PSW		# back to caller	.endm/* * Scheduler resume function, called by switch_to *  gpr2 = (task_struct *) prev *  gpr3 = (task_struct *) next * Returns: *  gpr2 = prev */        .globl  __switch_to__switch_to:        basr    %r1,0__switch_to_base:	tm	__THREAD_per(%r3),0xe8		# new process is using per ?	bz	__switch_to_noper-__switch_to_base(%r1)	# if not we're fine        stctl   %c9,%c11,24(%r15)		# We are using per stuff        clc     __THREAD_per(12,%r3),24(%r15)        be      __switch_to_noper-__switch_to_base(%r1)	# we got away w/o bashing TLB's        lctl    %c9,%c11,__THREAD_per(%r3)	# Nope we didn't__switch_to_noper:        stm     %r6,%r15,24(%r15)       # store __switch_to registers of prev task	st	%r15,__THREAD_ksp(%r2)	# store kernel stack to prev->tss.ksp	l	%r15,__THREAD_ksp(%r3)	# load kernel stack from next->tss.ksp	lm	%r6,%r15,24(%r15)	# load __switch_to registers of next task	st	%r3,__LC_CURRENT	# __LC_CURRENT = current task struct	l	%r3,__THREAD_info(%r3)  # load thread_info from task struct	st	%r3,__LC_THREAD_INFO	ahi	%r3,8192	st	%r3,__LC_KERNEL_STACK	# __LC_KERNEL_STACK = new kernel stack	br	%r14/* * do_softirq calling function. We want to run the softirq functions on the * asynchronous interrupt stack. */	.global do_call_softirqdo_call_softirq:	stnsm	24(%r15),0xfc	stm	%r12,%r15,28(%r15)	lr	%r12,%r15        basr    %r13,0do_call_base:	l	%r0,__LC_ASYNC_STACK	slr     %r0,%r15	sra	%r0,13	be	0f-do_call_base(%r13)	l	%r15,__LC_ASYNC_STACK0:	sl	%r15,.Lc_overhead-do_call_base(%r13)        st	%r12,0(%r15)	# store backchain	l	%r1,.Ldo_softirq-do_call_base(%r13)	basr	%r14,%r1	lm	%r12,%r15,28(%r12)	ssm	24(%r15)	br	%r14	__critical_start:/* * SVC interrupt handler routine. System calls are synchronous events and * are executed with interrupts enabled. */	.globl  system_callsystem_call:	SAVE_ALL_BASE __LC_SAVE_AREA        SAVE_ALL __LC_SVC_OLD_PSW,__LC_SAVE_AREA,1	lh	%r7,0x8a	  # get svc number from lowcoresysc_do_svc:	l	%r9,__LC_THREAD_INFO	# load pointer to thread_info struct	sla	%r7,2             # *4 and test for svc 0	bnz	BASED(sysc_nr_ok) # svc number > 0	# svc 0: system call number in %r1	cl	%r1,BASED(.Lnr_syscalls)	bnl	BASED(sysc_nr_ok)	lr	%r7,%r1           # copy svc number to %r7	sla	%r7,2             # *4sysc_nr_ok:	mvc	SP_ARGS(4,%r15),SP_R7(%r15)sysc_do_restart:	tm	__TI_flags+3(%r9),(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT)        l       %r8,sys_call_table-system_call(%r7,%r13) # get system call addr.        bnz     BASED(sysc_tracesys)        basr    %r14,%r8          # call sys_xxxx        st      %r2,SP_R2(%r15)   # store return value (change R2 on stack)                                  # ATTENTION: check sys_execve_glue before                                  # changing anything here !!sysc_return:	tm	SP_PSW+1(%r15),0x01	# returning to user ?	bno	BASED(sysc_leave)	tm	__TI_flags+3(%r9),_TIF_WORK_SVC	bnz	BASED(sysc_work)  # there is work to do (signals etc.)sysc_leave:        RESTORE_ALL 1## recheck if there is more work to do#sysc_work_loop:	tm	__TI_flags+3(%r9),_TIF_WORK_SVC	bz	BASED(sysc_leave)      # there is no work to do## One of the work bits is on. Find out which one.#sysc_work:	tm	__TI_flags+3(%r9),_TIF_NEED_RESCHED	bo	BASED(sysc_reschedule)	tm	__TI_flags+3(%r9),_TIF_SIGPENDING	bo	BASED(sysc_sigpending)	tm	__TI_flags+3(%r9),_TIF_RESTART_SVC	bo	BASED(sysc_restart)	tm	__TI_flags+3(%r9),_TIF_SINGLE_STEP	bo	BASED(sysc_singlestep)	b	BASED(sysc_leave)## _TIF_NEED_RESCHED is set, call schedule#	sysc_reschedule:                l       %r1,BASED(.Lschedule)	la      %r14,BASED(sysc_work_loop)	br      %r1		       # call scheduler## _TIF_SIGPENDING is set, call do_signal#sysc_sigpending:     	ni	__TI_flags+3(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP        la      %r2,SP_PTREGS(%r15)    # load pt_regs        sr      %r3,%r3                # clear *oldset        l       %r1,BASED(.Ldo_signal)	basr	%r14,%r1               # call do_signal	tm	__TI_flags+3(%r9),_TIF_RESTART_SVC	bo	BASED(sysc_restart)	b	BASED(sysc_leave)      # out of here, do NOT recheck## _TIF_RESTART_SVC is set, set up registers and restart svc#sysc_restart:	ni	__TI_flags+3(%r9),255-_TIF_RESTART_SVC # clear TIF_RESTART_SVC	l	%r7,SP_R2(%r15)        # load new svc number	sla	%r7,2	mvc	SP_R2(4,%r15),SP_ORIG_R2(%r15) # restore first argument	lm	%r2,%r6,SP_R2(%r15)    # load svc arguments	b	BASED(sysc_do_restart) # restart svc## _TIF_SINGLE_STEP is set, call do_single_step#sysc_singlestep:	ni	__TI_flags+3(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP	mvi	SP_TRAP+1(%r15),0x28	# set trap indication to pgm check	la	%r2,SP_PTREGS(%r15)	# address of register-save area	l	%r1,BASED(.Lhandle_per)	# load adr. of per handler	la	%r14,BASED(sysc_return)	# load adr. of system return	br	%r1			# branch to do_single_step__critical_end:## call trace before and after sys_call#sysc_tracesys:        l       %r1,BASED(.Ltrace)	la	%r2,SP_PTREGS(%r15)    # load pt_regs	la	%r3,0	srl	%r7,2	st	%r7,SP_R2(%r15)	basr	%r14,%r1	clc	SP_R2(4,%r15),BASED(.Lnr_syscalls)	bnl	BASED(sysc_tracenogo)	l	%r7,SP_R2(%r15)        # strace might have changed the 	sll	%r7,2                  #  system call	l	%r8,sys_call_table-system_call(%r7,%r13)sysc_tracego:	lm	%r3,%r6,SP_R3(%r15)	l	%r2,SP_ORIG_R2(%r15)	basr	%r14,%r8          # call sys_xxx	st	%r2,SP_R2(%r15)   # store return valuesysc_tracenogo:	tm	__TI_flags+3(%r9),(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT)        bz      BASED(sysc_return)	l	%r1,BASED(.Ltrace)	la	%r2,SP_PTREGS(%r15)    # load pt_regs	la	%r3,1	la	%r14,BASED(sysc_return)	br	%r1## a new process exits the kernel with ret_from_fork#        .globl  ret_from_forkret_from_fork:	l	%r13,__LC_SVC_NEW_PSW+4	l	%r9,__LC_THREAD_INFO	# load pointer to thread_info struct        l       %r1,BASED(.Lschedtail)	basr    %r14,%r1        stosm   24(%r15),0x03     # reenable interrupts	b	BASED(sysc_return)## clone, fork, vfork, exec and sigreturn need glue,# because they all expect pt_regs as parameter,# but are called with different parameter.# return-address is set up above#sys_clone_glue:         la      %r2,SP_PTREGS(%r15)    # load pt_regs        l       %r1,BASED(.Lclone)        br      %r1                   # branch to sys_clonesys_fork_glue:          la      %r2,SP_PTREGS(%r15)    # load pt_regs        l       %r1,BASED(.Lfork)        br      %r1                   # branch to sys_forksys_vfork_glue:         la      %r2,SP_PTREGS(%r15)    # load pt_regs        l       %r1,BASED(.Lvfork)        br      %r1                   # branch to sys_vforksys_execve_glue:                la      %r2,SP_PTREGS(%r15)   # load pt_regs        l       %r1,BASED(.Lexecve)	lr      %r12,%r14             # save return address        basr    %r14,%r1              # call sys_execve        ltr     %r2,%r2               # check if execve failed        bnz     0(%r12)               # it did fail -> store result in gpr2        b       4(%r12)               # SKIP ST 2,SP_R2(15) after BASR 14,8                                      # in system_call/sysc_tracesyssys_sigreturn_glue:             la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter        l       %r1,BASED(.Lsigreturn)        br      %r1                   # branch to sys_sigreturnsys_rt_sigreturn_glue:             la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter        l       %r1,BASED(.Lrt_sigreturn)        br      %r1                   # branch to sys_sigreturn## sigsuspend and rt_sigsuspend need pt_regs as an additional# parameter and they have to skip the store of %r2 into the# user register %r2 because the return value was set in # sigsuspend and rt_sigsuspend already and must not be overwritten!#sys_sigsuspend_glue:            lr      %r5,%r4               # move mask back        lr      %r4,%r3               # move history1 parameter        lr      %r3,%r2               # move history0 parameter        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter