/* *  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), *		 Heiko Carstens <heiko.carstens@de.ibm.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/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 + 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_MCCK_PENDING | \		 _TIF_RESTART_SVC | _TIF_SINGLE_STEP )_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_MCCK_PENDING)STACK_SHIFT = PAGE_SHIFT + THREAD_ORDERSTACK_SIZE  = 1 << STACK_SHIFT#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  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	lm	%r10,%r11,\lc_from	sl	%r10,\lc_to	sl	%r11,\lc_to+4	bc	3,BASED(0f)	sl	%r10,BASED(.Lc_1)0:	al	%r10,\lc_sum	al	%r11,\lc_sum+4	bc	12,BASED(1f)	al	%r10,BASED(.Lc_1)1:	stm	%r10,%r11,\lc_sum	.endm#endif	.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	1(%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,STACK_SHIFT	be	BASED(2f)1:	l	%r15,__LC_ASYNC_STACK	.endif#ifdef CONFIG_CHECK_STACK	b	BASED(3f)2:	tml	%r15,STACK_SIZE - CONFIG_STACK_GUARD	bz	BASED(stack_overflow)3:#endif2:	.endm	.macro  CREATE_STACK_FRAME psworg,savearea	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,__SF_BACKCHAIN(%r15)	# clear back chain	.endm	.macro  RESTORE_ALL psworg,sync	mvc	\psworg(8),SP_PSW(%r15) # move user PSW to lowcore	.if !\sync	ni	\psworg+1,0xfd		# clear wait state bit	.endif	lm	%r0,%r15,SP_R0(%r15)	# load gprs 0-15 of user	STORE_TIMER __LC_EXIT_TIMER	lpsw	\psworg			# 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,__SF_EMPTY(%r15)	# We are using per stuff        clc     __THREAD_per(12,%r3),__SF_EMPTY(%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:	l	%r4,__THREAD_info(%r2)		# get thread_info of prev	tm	__TI_flags+3(%r4),_TIF_MCCK_PENDING # machine check pending?	bz	__switch_to_no_mcck-__switch_to_base(%r1)	ni	__TI_flags+3(%r4),255-_TIF_MCCK_PENDING # clear flag in prev	l	%r4,__THREAD_info(%r3)		# get thread_info of next	oi	__TI_flags+3(%r4),_TIF_MCCK_PENDING # set it in next__switch_to_no_mcck:        stm     %r6,%r15,__SF_GPRS(%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,__SF_GPRS(%r15)# load __switch_to registers of next task	st	%r3,__LC_CURRENT	# __LC_CURRENT = current task struct	lctl	%c4,%c4,__TASK_pid(%r3) # load pid to control reg. 4	l	%r3,__THREAD_info(%r3)  # load thread_info from task struct	st	%r3,__LC_THREAD_INFO	ahi	%r3,STACK_SIZE	st	%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	CREATE_STACK_FRAME __LC_SVC_OLD_PSW,__LC_SAVE_AREA	lh	%r7,0x8a	  # get svc number from lowcore#ifdef CONFIG_VIRT_CPU_ACCOUNTINGsysc_vtime:	tm	SP_PSW+1(%r15),0x01	# interrupting from user ?	bz	BASED(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:	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 __LC_RETURN_PSW,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_MCCK_PENDING	bo	BASED(sysc_mcck_pending)	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_MCCK_PENDING is set, call handler#sysc_mcck_pending:	l	%r1,BASED(.Ls390_handle_mcck)	la	%r14,BASED(sysc_work_loop)	br	%r1			# TIF bit will be cleared by handler## _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)	tm	__TI_flags+3(%r9),_TIF_SINGLE_STEP	bo	BASED(sysc_singlestep)	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## 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)