/* *  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>#include <asm/page.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 + 8SP_R2        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 16SP_R3        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 24SP_R4        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 32SP_R5        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 40SP_R6        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 48SP_R7        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 56SP_R8        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 64SP_R9        =  STACK_FRAME_OVERHEAD + __PT_GPRS + 72SP_R10       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 80SP_R11       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 88SP_R12       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 96SP_R13       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 104SP_R14       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 112SP_R15       =  STACK_FRAME_OVERHEAD + __PT_GPRS + 120SP_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_SIZESTACK_SHIFT = PAGE_SHIFT + THREAD_ORDERSTACK_SIZE  = 1 << STACK_SHIFT_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)	.macro  STORE_TIMER lc_offset#ifdef CONFIG_VIRT_CPU_ACCOUNTING	stpt	\lc_offset#endif	.endm#ifdef CONFIG_VIRT_CPU_ACCOUNTING	.macro  UPDATE_VTIME lc_from,lc_to,lc_sum	lg	%r10,\lc_from	slg	%r10,\lc_to	alg	%r10,\lc_sum	stg	%r10,\lc_sum	.endm#endif/* * 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	stmg	%r12,%r15,\savearea	larl	%r13,system_call	.endm        .macro  SAVE_ALL psworg,savearea,sync	la	%r12,\psworg	.if	\sync	tm	\psworg+1,0x01		# test problem state bit	jz	2f			# skip stack setup save	lg	%r15,__LC_KERNEL_STACK	# problem state -> load ksp	.else	tm	\psworg+1,0x01		# test problem state bit	jnz	1f			# from user -> load kernel stack	clc	\psworg+8(8),BASED(.Lcritical_end)	jhe	0f	clc	\psworg+8(8),BASED(.Lcritical_start)	jl	0f	brasl	%r14,cleanup_critical	tm	0(%r12),0x01		# retest problem state after cleanup	jnz	1f0:	lg	%r14,__LC_ASYNC_STACK	# are we already on the async. stack ?	slgr	%r14,%r15	srag	%r14,%r14,STACK_SHIFT	jz	2f1:	lg	%r15,__LC_ASYNC_STACK	# load async stack	.endif#ifdef CONFIG_CHECK_STACK	j	3f2:	tml	%r15,STACK_SIZE - CONFIG_STACK_GUARD	jz	stack_overflow3:#endif2:	aghi    %r15,-SP_SIZE		# make room for registers & psw	mvc     SP_PSW(16,%r15),0(%r12)	# move user PSW to stack	la	%r12,\psworg	stg	%r2,SP_ORIG_R2(%r15)	# store original content of gpr 2	icm	%r12,12,__LC_SVC_ILC	stmg	%r0,%r11,SP_R0(%r15)	# store gprs %r0-%r11 to kernel stack	st	%r12,SP_ILC(%r15)	mvc	SP_R12(32,%r15),\savearea # move %r12-%r15 to stack	la	%r12,0	stg	%r12,__SF_BACKCHAIN(%r15)        .endm	.macro	RESTORE_ALL sync	mvc	__LC_RETURN_PSW(16),SP_PSW(%r15) # move user PSW to lowcore	.if !\sync	ni	__LC_RETURN_PSW+1,0xfd	# clear wait state bit	.endif	lmg	%r0,%r15,SP_R0(%r15)	# load gprs 0-15 of user	STORE_TIMER __LC_EXIT_TIMER	lpswe	__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:	tm	__THREAD_per+4(%r3),0xe8 # is the new process using per ?	jz	__switch_to_noper		# if not we're fine        stctg   %c9,%c11,__SF_EMPTY(%r15)# We are using per stuff        clc     __THREAD_per(24,%r3),__SF_EMPTY(%r15)        je      __switch_to_noper            # we got away without bashing TLB's        lctlg   %c9,%c11,__THREAD_per(%r3)	# Nope we didn't__switch_to_noper:        stmg    %r6,%r15,__SF_GPRS(%r15)# store __switch_to registers of prev task	stg	%r15,__THREAD_ksp(%r2)	# store kernel stack to prev->tss.ksp	lg	%r15,__THREAD_ksp(%r3)	# load kernel stack from next->tss.ksp        lmg     %r6,%r15,__SF_GPRS(%r15)# load __switch_to registers of next task	stg	%r3,__LC_CURRENT	# __LC_CURRENT = current task struct	lctl	%c4,%c4,__TASK_pid(%r3) # load pid to control reg. 4	lg	%r3,__THREAD_info(%r3)  # load thread_info from task struct	stg	%r3,__LC_THREAD_INFO	aghi	%r3,STACK_SIZE	stg	%r3,__LC_KERNEL_STACK	# __LC_KERNEL_STACK = new kernel stack	br	%r14__critical_start:/* * SVC interrupt handler routine. System calls are synchronous events and * are executed with interrupts enabled. */	.globl  system_callsystem_call:	STORE_TIMER __LC_SYNC_ENTER_TIMERsysc_saveall:	SAVE_ALL_BASE __LC_SAVE_AREA        SAVE_ALL __LC_SVC_OLD_PSW,__LC_SAVE_AREA,1	llgh    %r7,__LC_SVC_INT_CODE # get svc number from lowcore#ifdef CONFIG_VIRT_CPU_ACCOUNTINGsysc_vtime:	tm	SP_PSW+1(%r15),0x01	# interrupting from user ?	jz	sysc_do_svc	UPDATE_VTIME __LC_EXIT_TIMER,__LC_SYNC_ENTER_TIMER,__LC_USER_TIMERsysc_stime:	UPDATE_VTIME __LC_LAST_UPDATE_TIMER,__LC_EXIT_TIMER,__LC_SYSTEM_TIMERsysc_update:	mvc	__LC_LAST_UPDATE_TIMER(8),__LC_SYNC_ENTER_TIMER#endifsysc_do_svc:	lg	%r9,__LC_THREAD_INFO	# load pointer to thread_info struct        slag    %r7,%r7,2         # *4 and test for svc 0	jnz	sysc_nr_ok	# svc 0: system call number in %r1	cl	%r1,BASED(.Lnr_syscalls)	jnl	sysc_nr_ok	lgfr	%r7,%r1           # clear high word in r1	slag    %r7,%r7,2         # svc 0: system call number in %r1sysc_nr_ok:	mvc	SP_ARGS(8,%r15),SP_R7(%r15)sysc_do_restart:	larl    %r10,sys_call_table#ifdef CONFIG_S390_SUPPORT        tm      SP_PSW+3(%r15),0x01  # are we running in 31 bit mode ?        jo      sysc_noemu	larl    %r10,sys_call_table_emu  # use 31 bit emulation system callssysc_noemu:#endif	tm	__TI_flags+7(%r9),(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT)        lgf     %r8,0(%r7,%r10)   # load address of system call routine        jnz     sysc_tracesys        basr    %r14,%r8          # call sys_xxxx        stg     %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 ?        jno     sysc_leave	tm	__TI_flags+7(%r9),_TIF_WORK_SVC	jnz	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+7(%r9),_TIF_WORK_SVC	jz	sysc_leave        # there is no work to do## One of the work bits is on. Find out which one.#sysc_work:	tm	__TI_flags+7(%r9),_TIF_NEED_RESCHED	jo	sysc_reschedule	tm	__TI_flags+7(%r9),_TIF_SIGPENDING	jo	sysc_sigpending	tm	__TI_flags+7(%r9),_TIF_RESTART_SVC	jo	sysc_restart	tm	__TI_flags+7(%r9),_TIF_SINGLE_STEP	jo	sysc_singlestep	j	sysc_leave## _TIF_NEED_RESCHED is set, call schedule#	sysc_reschedule:        	larl    %r14,sysc_work_loop        jg      schedule            # return point is sysc_return## _TIF_SIGPENDING is set, call do_signal#sysc_sigpending:     	ni	__TI_flags+7(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP        la      %r2,SP_PTREGS(%r15) # load pt_regs        sgr     %r3,%r3           # clear *oldset	brasl	%r14,do_signal    # call do_signal	tm	__TI_flags+7(%r9),_TIF_RESTART_SVC	jo	sysc_restart	tm	__TI_flags+7(%r9),_TIF_SINGLE_STEP	jo	sysc_singlestep	j	sysc_leave        # out of here, do NOT recheck## _TIF_RESTART_SVC is set, set up registers and restart svc#sysc_restart:	ni	__TI_flags+7(%r9),255-_TIF_RESTART_SVC # clear TIF_RESTART_SVC	lg	%r7,SP_R2(%r15)        # load new svc number        slag    %r7,%r7,2              # *4	mvc	SP_R2(8,%r15),SP_ORIG_R2(%r15) # restore first argument	lmg	%r2,%r6,SP_R2(%r15)    # load svc arguments	j	sysc_do_restart        # restart svc## _TIF_SINGLE_STEP is set, call do_single_step#sysc_singlestep:	ni	__TI_flags+7(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP	lhi	%r0,__LC_PGM_OLD_PSW	sth	%r0,SP_TRAP(%r15)	# set trap indication to pgm check	la	%r2,SP_PTREGS(%r15)	# address of register-save area	larl	%r14,sysc_return	# load adr. of system return	jg	do_single_step		# branch to do_sigtrap__critical_end:## call syscall_trace before and after system call# special linkage: %r12 contains the return address for trace_svc#sysc_tracesys:	la	%r2,SP_PTREGS(%r15)    # load pt_regs	la	%r3,0	srl	%r7,2	stg     %r7,SP_R2(%r15)        brasl   %r14,syscall_trace	lghi	%r0,NR_syscalls	clg	%r0,SP_R2(%r15)	jnh	sysc_tracenogo	lg	%r7,SP_R2(%r15)   # strace might have changed the	sll     %r7,2             #  system call	lgf	%r8,0(%r7,%r10)sysc_tracego:	lmg     %r3,%r6,SP_R3(%r15)	lg      %r2,SP_ORIG_R2(%r15)        basr    %r14,%r8            # call sys_xxx        stg     %r2,SP_R2(%r15)     # store return valuesysc_tracenogo:	tm	__TI_flags+7(%r9),(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT)        jz      sysc_return	la	%r2,SP_PTREGS(%r15)    # load pt_regs	la	%r3,1	larl	%r14,sysc_return    # return point is sysc_return	jg	syscall_trace## a new process exits the kernel with ret_from_fork#        .globl  ret_from_forkret_from_fork:	lg	%r13,__LC_SVC_NEW_PSW+8	lg	%r9,__LC_THREAD_INFO	# load pointer to thread_info struct	tm	SP_PSW+1(%r15),0x01	# forking a kernel thread ?	jo	0f	stg	%r15,SP_R15(%r15)	# store stack pointer for new kthread0:	brasl   %r14,schedule_tail        stosm   24(%r15),0x03     # reenable interrupts	j	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        jg      sys_clone              # branch to sys_clone#ifdef CONFIG_S390_SUPPORTsys32_clone_glue:         la      %r2,SP_PTREGS(%r15)    # load pt_regs        jg      sys32_clone            # branch to sys32_clone#endifsys_fork_glue:          la      %r2,SP_PTREGS(%r15)    # load pt_regs        jg      sys_fork               # branch to sys_forksys_vfork_glue:         la      %r2,SP_PTREGS(%r15)    # load pt_regs        jg      sys_vfork              # branch to sys_vforksys_execve_glue:                la      %r2,SP_PTREGS(%r15)   # load pt_regs	lgr     %r12,%r14             # save return address        brasl   %r14,sys_execve       # call sys_execve        ltgr    %r2,%r2               # check if execve failed        bnz     0(%r12)               # it did fail -> store result in gpr2        b       6(%r12)               # SKIP STG 2,SP_R2(15) in                                      # system_call/sysc_tracesys#ifdef CONFIG_S390_SUPPORTsys32_execve_glue:                la      %r2,SP_PTREGS(%r15)   # load pt_regs	lgr     %r12,%r14             # save return address        brasl   %r14,sys32_execve     # call sys32_execve        ltgr    %r2,%r2               # check if execve failed        bnz     0(%r12)               # it did fail -> store result in gpr2        b       6(%r12)               # SKIP STG 2,SP_R2(15) in                                      # system_call/sysc_tracesys#endifsys_sigreturn_glue:             la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter        jg      sys_sigreturn         # branch to sys_sigreturn#ifdef CONFIG_S390_SUPPORTsys32_sigreturn_glue:             la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter        jg      sys32_sigreturn       # branch to sys32_sigreturn#endifsys_rt_sigreturn_glue:             la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter        jg      sys_rt_sigreturn      # branch to sys_sigreturn#ifdef CONFIG_S390_SUPPORTsys32_rt_sigreturn_glue:             la      %r2,SP_PTREGS(%r15)   # load pt_regs as parameter        jg      sys32_rt_sigreturn    # branch to sys32_sigreturn#endif## 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:            lgr     %r5,%r4               # move mask back        lgr     %r4,%r3               # move history1 parameter        lgr     %r3,%r2               # move history0 parameter        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter	la      %r14,6(%r14)          # skip store of return value        jg      sys_sigsuspend        # branch to sys_sigsuspend#ifdef CONFIG_S390_SUPPORTsys32_sigsuspend_glue:    	llgfr	%r4,%r4               # unsigned long			        lgr     %r5,%r4               # move mask back	lgfr	%r3,%r3               # int			        lgr     %r4,%r3               # move history1 parameter	lgfr	%r2,%r2               # int			        lgr     %r3,%r2               # move history0 parameter        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter	la      %r14,6(%r14)          # skip store of return value        jg      sys32_sigsuspend      # branch to sys32_sigsuspend#endifsys_rt_sigsuspend_glue:         lgr     %r4,%r3               # move sigsetsize parameter        lgr     %r3,%r2               # move unewset parameter        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter	la      %r14,6(%r14)          # skip store of return value        jg      sys_rt_sigsuspend     # branch to sys_rt_sigsuspend#ifdef CONFIG_S390_SUPPORTsys32_rt_sigsuspend_glue: 	llgfr	%r3,%r3               # size_t			        lgr     %r4,%r3               # move sigsetsize parameter	llgtr	%r2,%r2               # sigset_emu31_t *        lgr     %r3,%r2               # move unewset parameter        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter	la      %r14,6(%r14)          # skip store of return value        jg      sys32_rt_sigsuspend   # branch to sys32_rt_sigsuspend#endif