940 lines · 25.4 KB · Assembly
RawDownload
/* *    S390 low-level entry points. * *    Copyright IBM Corp. 1999, 2012 *    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/init.h>#include <linux/linkage.h>#include <asm/cache.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>#include <asm/sigp.h>#include <asm/irq.h> __PT_R0      =	__PT_GPRS__PT_R1      =	__PT_GPRS + 4__PT_R2      =	__PT_GPRS + 8__PT_R3      =	__PT_GPRS + 12__PT_R4      =	__PT_GPRS + 16__PT_R5      =	__PT_GPRS + 20__PT_R6      =	__PT_GPRS + 24__PT_R7      =	__PT_GPRS + 28__PT_R8      =	__PT_GPRS + 32__PT_R9      =	__PT_GPRS + 36__PT_R10     =	__PT_GPRS + 40__PT_R11     =	__PT_GPRS + 44__PT_R12     =	__PT_GPRS + 48__PT_R13     =	__PT_GPRS + 524__PT_R14     =	__PT_GPRS + 56__PT_R15     =	__PT_GPRS + 60 _TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \		 _TIF_MCCK_PENDING | _TIF_PER_TRAP )_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_NEED_RESCHED | \		 _TIF_MCCK_PENDING)_TIF_TRACE    = (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP | \		 _TIF_SYSCALL_TRACEPOINT) STACK_SHIFT = PAGE_SHIFT + THREAD_ORDERSTACK_SIZE  = 1 << STACK_SHIFTSTACK_INIT  = STACK_SIZE - STACK_FRAME_OVERHEAD - __PT_SIZE #define BASED(name) name-system_call(%r13) 	.macro	TRACE_IRQS_ON#ifdef CONFIG_TRACE_IRQFLAGS	basr	%r2,%r0	l	%r1,BASED(.Lhardirqs_on)	basr	%r14,%r1		# call trace_hardirqs_on_caller#endif	.endm 	.macro	TRACE_IRQS_OFF#ifdef CONFIG_TRACE_IRQFLAGS	basr	%r2,%r0	l	%r1,BASED(.Lhardirqs_off)	basr	%r14,%r1		# call trace_hardirqs_off_caller#endif	.endm 	.macro	LOCKDEP_SYS_EXIT#ifdef CONFIG_LOCKDEP	tm	__PT_PSW+1(%r11),0x01	# returning to user ?	jz	.+10	l	%r1,BASED(.Llockdep_sys_exit)	basr	%r14,%r1		# call lockdep_sys_exit#endif	.endm 	.macro	CHECK_STACK stacksize,savearea#ifdef CONFIG_CHECK_STACK	tml	%r15,\stacksize - CONFIG_STACK_GUARD	la	%r14,\savearea	jz	stack_overflow#endif	.endm 	.macro	SWITCH_ASYNC savearea,stack,shift	tmh	%r8,0x0001		# interrupting from user ?	jnz	1f	lr	%r14,%r9	sl	%r14,BASED(.Lcritical_start)	cl	%r14,BASED(.Lcritical_length)	jhe	0f	la	%r11,\savearea		# inside critical section, do cleanup	bras	%r14,cleanup_critical	tmh	%r8,0x0001		# retest problem state after cleanup	jnz	1f0:	l	%r14,\stack		# are we already on the target stack?	slr	%r14,%r15	sra	%r14,\shift	jnz	1f	CHECK_STACK 1<<\shift,\savearea	ahi	%r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)	j	2f1:	l	%r15,\stack		# load target stack2:	la	%r11,STACK_FRAME_OVERHEAD(%r15)	.endm 	.macro	ADD64 high,low,timer	al	\high,\timer	al	\low,4+\timer	brc	12,.+8	ahi	\high,1	.endm 	.macro	SUB64 high,low,timer	sl	\high,\timer	sl	\low,4+\timer	brc	3,.+8	ahi	\high,-1	.endm 	.macro	UPDATE_VTIME high,low,enter_timer	lm	\high,\low,__LC_EXIT_TIMER	SUB64	\high,\low,\enter_timer	ADD64	\high,\low,__LC_USER_TIMER	stm	\high,\low,__LC_USER_TIMER	lm	\high,\low,__LC_LAST_UPDATE_TIMER	SUB64	\high,\low,__LC_EXIT_TIMER	ADD64	\high,\low,__LC_SYSTEM_TIMER	stm	\high,\low,__LC_SYSTEM_TIMER	mvc	__LC_LAST_UPDATE_TIMER(8),\enter_timer	.endm 	.macro REENABLE_IRQS	st	%r8,__LC_RETURN_PSW	ni	__LC_RETURN_PSW,0xbf	ssm	__LC_RETURN_PSW	.endm 	.section .kprobes.text, "ax" /* * Scheduler resume function, called by switch_to *  gpr2 = (task_struct *) prev *  gpr3 = (task_struct *) next * Returns: *  gpr2 = prev */ENTRY(__switch_to)	stm	%r6,%r15,__SF_GPRS(%r15)	# store gprs of prev task	st	%r15,__THREAD_ksp(%r2)		# store kernel stack of prev	l	%r4,__THREAD_info(%r2)		# get thread_info of prev	l	%r5,__THREAD_info(%r3)		# get thread_info of next	lr	%r15,%r5	ahi	%r15,STACK_INIT			# end of kernel stack of next	st	%r3,__LC_CURRENT		# store task struct of next	st	%r5,__LC_THREAD_INFO		# store thread info of next	st	%r15,__LC_KERNEL_STACK		# store end of kernel stack	lctl	%c4,%c4,__TASK_pid(%r3)		# load pid to control reg. 4	mvc	__LC_CURRENT_PID(4,%r0),__TASK_pid(%r3)	# store pid of next	l	%r15,__THREAD_ksp(%r3)		# load kernel stack of next	tm	__TI_flags+3(%r4),_TIF_MCCK_PENDING # machine check pending?	jz	0f	ni	__TI_flags+3(%r4),255-_TIF_MCCK_PENDING	# clear flag in prev	oi	__TI_flags+3(%r5),_TIF_MCCK_PENDING	# set it in next0:	lm	%r6,%r15,__SF_GPRS(%r15)	# load gprs of next task	br	%r14 __critical_start:/* * SVC interrupt handler routine. System calls are synchronous events and * are executed with interrupts enabled. */ ENTRY(system_call)	stpt	__LC_SYNC_ENTER_TIMERsysc_stm:	stm	%r8,%r15,__LC_SAVE_AREA_SYNC	l	%r12,__LC_THREAD_INFO	l	%r13,__LC_SVC_NEW_PSW+4sysc_per:	l	%r15,__LC_KERNEL_STACK	la	%r11,STACK_FRAME_OVERHEAD(%r15)	# pointer to pt_regssysc_vtime:	UPDATE_VTIME %r8,%r9,__LC_SYNC_ENTER_TIMER	stm	%r0,%r7,__PT_R0(%r11)	mvc	__PT_R8(32,%r11),__LC_SAVE_AREA_SYNC	mvc	__PT_PSW(8,%r11),__LC_SVC_OLD_PSW	mvc	__PT_INT_CODE(4,%r11),__LC_SVC_ILCsysc_do_svc:	oi	__TI_flags+3(%r12),_TIF_SYSCALL	l	%r10,__TI_sysc_table(%r12)	# 31 bit system call table	lh	%r8,__PT_INT_CODE+2(%r11)	sla	%r8,2				# shift and test for svc0	jnz	sysc_nr_ok	# svc 0: system call number in %r1	cl	%r1,BASED(.Lnr_syscalls)	jnl	sysc_nr_ok	sth	%r1,__PT_INT_CODE+2(%r11)	lr	%r8,%r1	sla	%r8,2sysc_nr_ok:	xc	__SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)	st	%r2,__PT_ORIG_GPR2(%r11)	st	%r7,STACK_FRAME_OVERHEAD(%r15)	l	%r9,0(%r8,%r10)			# get system call addr.	tm	__TI_flags+2(%r12),_TIF_TRACE >> 8	jnz	sysc_tracesys	basr	%r14,%r9			# call sys_xxxx	st	%r2,__PT_R2(%r11)		# store return value sysc_return:	LOCKDEP_SYS_EXITsysc_tif:	tm	__PT_PSW+1(%r11),0x01		# returning to user ?	jno	sysc_restore	tm	__TI_flags+3(%r12),_TIF_WORK_SVC	jnz	sysc_work			# check for work	ni	__TI_flags+3(%r12),255-_TIF_SYSCALLsysc_restore:	mvc	__LC_RETURN_PSW(8),__PT_PSW(%r11)	stpt	__LC_EXIT_TIMER	lm	%r0,%r15,__PT_R0(%r11)	lpsw	__LC_RETURN_PSWsysc_done: ## One of the work bits is on. Find out which one.#sysc_work:	tm	__TI_flags+3(%r12),_TIF_MCCK_PENDING	jo	sysc_mcck_pending	tm	__TI_flags+3(%r12),_TIF_NEED_RESCHED	jo	sysc_reschedule	tm	__TI_flags+3(%r12),_TIF_PER_TRAP	jo	sysc_singlestep	tm	__TI_flags+3(%r12),_TIF_SIGPENDING	jo	sysc_sigpending	tm	__TI_flags+3(%r12),_TIF_NOTIFY_RESUME	jo	sysc_notify_resume	j	sysc_return		# beware of critical section cleanup ## _TIF_NEED_RESCHED is set, call schedule#sysc_reschedule:	l	%r1,BASED(.Lschedule)	la	%r14,BASED(sysc_return)	br	%r1			# call schedule ## _TIF_MCCK_PENDING is set, call handler#sysc_mcck_pending:	l	%r1,BASED(.Lhandle_mcck)	la	%r14,BASED(sysc_return)	br	%r1			# TIF bit will be cleared by handler ## _TIF_SIGPENDING is set, call do_signal#sysc_sigpending:	lr	%r2,%r11		# pass pointer to pt_regs	l	%r1,BASED(.Ldo_signal)	basr	%r14,%r1		# call do_signal	tm	__TI_flags+3(%r12),_TIF_SYSCALL	jno	sysc_return	lm	%r2,%r7,__PT_R2(%r11)	# load svc arguments	l	%r10,__TI_sysc_table(%r12)	# 31 bit system call table	xr	%r8,%r8			# svc 0 returns -ENOSYS	clc	__PT_INT_CODE+2(2,%r11),BASED(.Lnr_syscalls+2)	jnl	sysc_nr_ok		# invalid svc number -> do svc 0	lh	%r8,__PT_INT_CODE+2(%r11)	# load new svc number	sla	%r8,2	j	sysc_nr_ok		# restart svc ## _TIF_NOTIFY_RESUME is set, call do_notify_resume#sysc_notify_resume:	lr	%r2,%r11		# pass pointer to pt_regs	l	%r1,BASED(.Ldo_notify_resume)	la	%r14,BASED(sysc_return)	br	%r1			# call do_notify_resume ## _TIF_PER_TRAP is set, call do_per_trap#sysc_singlestep:	ni	__TI_flags+3(%r12),255-_TIF_PER_TRAP	lr	%r2,%r11		# pass pointer to pt_regs	l	%r1,BASED(.Ldo_per_trap)	la	%r14,BASED(sysc_return)	br	%r1			# call do_per_trap ## call tracehook_report_syscall_entry/tracehook_report_syscall_exit before# and after the system call#sysc_tracesys:	l	%r1,BASED(.Ltrace_enter)	lr	%r2,%r11		# pass pointer to pt_regs	la	%r3,0	xr	%r0,%r0	icm	%r0,3,__PT_INT_CODE+2(%r11)	st	%r0,__PT_R2(%r11)	basr	%r14,%r1		# call do_syscall_trace_enter	cl	%r2,BASED(.Lnr_syscalls)	jnl	sysc_tracenogo	lr	%r8,%r2	sll	%r8,2	l	%r9,0(%r8,%r10)sysc_tracego:	lm	%r3,%r7,__PT_R3(%r11)	st	%r7,STACK_FRAME_OVERHEAD(%r15)	l	%r2,__PT_ORIG_GPR2(%r11)	basr	%r14,%r9		# call sys_xxx	st	%r2,__PT_R2(%r11)	# store return valuesysc_tracenogo:	tm	__TI_flags+2(%r12),_TIF_TRACE >> 8	jz	sysc_return	l	%r1,BASED(.Ltrace_exit)	lr	%r2,%r11		# pass pointer to pt_regs	la	%r14,BASED(sysc_return)	br	%r1			# call do_syscall_trace_exit ## a new process exits the kernel with ret_from_fork#ENTRY(ret_from_fork)	la	%r11,STACK_FRAME_OVERHEAD(%r15)	l	%r12,__LC_THREAD_INFO	l	%r13,__LC_SVC_NEW_PSW+4	l	%r1,BASED(.Lschedule_tail)	basr	%r14,%r1		# call schedule_tail	TRACE_IRQS_ON	ssm	__LC_SVC_NEW_PSW	# reenable interrupts	tm	__PT_PSW+1(%r11),0x01	# forking a kernel thread ?	jne	sysc_tracenogo	# it's a kernel thread	lm	%r9,%r10,__PT_R9(%r11)	# load gprsENTRY(kernel_thread_starter)	la	%r2,0(%r10)	basr	%r14,%r9	j	sysc_tracenogo /* * Program check handler routine */ ENTRY(pgm_check_handler)	stpt	__LC_SYNC_ENTER_TIMER	stm	%r8,%r15,__LC_SAVE_AREA_SYNC	l	%r12,__LC_THREAD_INFO	l	%r13,__LC_SVC_NEW_PSW+4	lm	%r8,%r9,__LC_PGM_OLD_PSW	tmh	%r8,0x0001		# test problem state bit	jnz	1f			# -> fault in user space	tmh	%r8,0x4000		# PER bit set in old PSW ?	jnz	0f			# -> enabled, can't be a double fault	tm	__LC_PGM_ILC+3,0x80	# check for per exception	jnz	pgm_svcper		# -> single stepped svc0:	CHECK_STACK STACK_SIZE,__LC_SAVE_AREA_SYNC	ahi	%r15,-(STACK_FRAME_OVERHEAD + __PT_SIZE)	j	2f1:	UPDATE_VTIME %r14,%r15,__LC_SYNC_ENTER_TIMER	l	%r15,__LC_KERNEL_STACK2:	la	%r11,STACK_FRAME_OVERHEAD(%r15)	stm	%r0,%r7,__PT_R0(%r11)	mvc	__PT_R8(32,%r11),__LC_SAVE_AREA_SYNC	stm	%r8,%r9,__PT_PSW(%r11)	mvc	__PT_INT_CODE(4,%r11),__LC_PGM_ILC	mvc	__PT_INT_PARM_LONG(4,%r11),__LC_TRANS_EXC_CODE	tm	__LC_PGM_ILC+3,0x80	# check for per exception	jz	0f	l	%r1,__TI_task(%r12)	tmh	%r8,0x0001		# kernel per event ?	jz	pgm_kprobe	oi	__TI_flags+3(%r12),_TIF_PER_TRAP	mvc	__THREAD_per_address(4,%r1),__LC_PER_ADDRESS	mvc	__THREAD_per_cause(2,%r1),__LC_PER_CAUSE	mvc	__THREAD_per_paid(1,%r1),__LC_PER_PAID0:	REENABLE_IRQS	xc	__SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)	l	%r1,BASED(.Ljump_table)	la	%r10,0x7f	n	%r10,__PT_INT_CODE(%r11)	je	sysc_return	sll	%r10,2	l	%r1,0(%r10,%r1)		# load address of handler routine	lr	%r2,%r11		# pass pointer to pt_regs	basr	%r14,%r1		# branch to interrupt-handler	j	sysc_return ## PER event in supervisor state, must be kprobes#pgm_kprobe:	REENABLE_IRQS	xc	__SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)	l	%r1,BASED(.Ldo_per_trap)	lr	%r2,%r11		# pass pointer to pt_regs	basr	%r14,%r1		# call do_per_trap	j	sysc_return ## single stepped system call#pgm_svcper:	oi	__TI_flags+3(%r12),_TIF_PER_TRAP	mvc	__LC_RETURN_PSW(4),__LC_SVC_NEW_PSW	mvc	__LC_RETURN_PSW+4(4),BASED(.Lsysc_per)	lpsw	__LC_RETURN_PSW		# branch to sysc_per and enable irqs /* * IO interrupt handler routine */ ENTRY(io_int_handler)	stck	__LC_INT_CLOCK	stpt	__LC_ASYNC_ENTER_TIMER	stm	%r8,%r15,__LC_SAVE_AREA_ASYNC	l	%r12,__LC_THREAD_INFO	l	%r13,__LC_SVC_NEW_PSW+4	lm	%r8,%r9,__LC_IO_OLD_PSW	tmh	%r8,0x0001		# interrupting from user ?	jz	io_skip	UPDATE_VTIME %r14,%r15,__LC_ASYNC_ENTER_TIMERio_skip:	SWITCH_ASYNC __LC_SAVE_AREA_ASYNC,__LC_ASYNC_STACK,STACK_SHIFT	stm	%r0,%r7,__PT_R0(%r11)	mvc	__PT_R8(32,%r11),__LC_SAVE_AREA_ASYNC	stm	%r8,%r9,__PT_PSW(%r11)	mvc	__PT_INT_CODE(12,%r11),__LC_SUBCHANNEL_ID	TRACE_IRQS_OFF	xc	__SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15)io_loop:	l	%r1,BASED(.Ldo_IRQ)	lr	%r2,%r11		# pass pointer to pt_regs	lhi	%r3,IO_INTERRUPT	tm	__PT_INT_CODE+8(%r11),0x80	# adapter interrupt ?	jz	io_call	lhi	%r3,THIN_INTERRUPTio_call:	basr	%r14,%r1		# call do_IRQ	tm	__LC_MACHINE_FLAGS+2,0x10	# MACHINE_FLAG_LPAR	jz	io_return	tpi	0	jz	io_return	mvc	__PT_INT_CODE(12,%r11),__LC_SUBCHANNEL_ID	j	io_loopio_return:	LOCKDEP_SYS_EXIT	TRACE_IRQS_ONio_tif:	tm	__TI_flags+3(%r12),_TIF_WORK_INT	jnz	io_work			# there is work to do (signals etc.)io_restore:	mvc	__LC_RETURN_PSW(8),__PT_PSW(%r11)	stpt	__LC_EXIT_TIMER	lm	%r0,%r15,__PT_R0(%r11)	lpsw	__LC_RETURN_PSWio_done: ## There is work todo, find out in which context we have been interrupted:# 1) if we return to user space we can do all _TIF_WORK_INT work# 2) if we return to kernel code and preemptive scheduling is enabled check#    the preemption counter and if it is zero call preempt_schedule_irq# Before any work can be done, a switch to the kernel stack is required.#io_work:	tm	__PT_PSW+1(%r11),0x01	# returning to user ?	jo	io_work_user		# yes -> do resched & signal#ifdef CONFIG_PREEMPT	# check for preemptive scheduling	icm	%r0,15,__TI_precount(%r12)	jnz	io_restore		# preemption disabled	tm	__TI_flags+3(%r12),_TIF_NEED_RESCHED	jno	io_restore	# switch to kernel stack	l	%r1,__PT_R15(%r11)	ahi	%r1,-(STACK_FRAME_OVERHEAD + __PT_SIZE)	mvc	STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)	xc	__SF_BACKCHAIN(4,%r1),__SF_BACKCHAIN(%r1)	la	%r11,STACK_FRAME_OVERHEAD(%r1)	lr	%r15,%r1	# TRACE_IRQS_ON already done at io_return, call	# TRACE_IRQS_OFF to keep things symmetrical	TRACE_IRQS_OFF	l	%r1,BASED(.Lpreempt_irq)	basr	%r14,%r1		# call preempt_schedule_irq	j	io_return#else	j	io_restore#endif ## Need to do work before returning to userspace, switch to kernel stack#

Lines 1–500 of 940.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t