path: root/usr/src/uts/sparc/v9/ml/syscall_trap.s

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * System call trap handler.
 */
#include <sys/asm_linkage.h>
#include <sys/machpcb.h>
#include <sys/machthread.h>
#include <sys/syscall.h>
#include <sys/trap.h>
#include <sys/machtrap.h>
#include <sys/pcb.h>
#include <sys/machparam.h>

#include "assym.h"

#ifdef TRAPTRACE
#include <sys/traptrace.h>
#endif /* TRAPTRACE */

#if (1 << SYSENT_SHIFT) != SYSENT_SIZE
#error	"SYSENT_SHIFT does not correspond to size of sysent structure"
#endif
	
/*
 * Native System call trap handler.
 *
 * We branch here from sys_trap when a 64-bit system call occurs.
 *
 * Entry:
 *	%o0 = regs
 *
 * Usage:
 *	%l0 = saved return address
 *	%l1 = saved regs
 *	%l2 = lwp
 */
	ENTRY_NP(syscall_trap)
	ldn	[THREAD_REG + T_CPU], %g1	! get cpu pointer
	mov	%o7, %l0			! save return addr
	!
	! If the trapping thread has the address mask bit set, then it's
	!   a 32-bit process, and has no business calling 64-bit syscalls.
	!
	ldx	[%o0 + TSTATE_OFF], %l1		! saved %tstate.am is that
	andcc	%l1, TSTATE_AM, %l1		!   of the trapping proc
	bne,pn	%xcc, _syscall_ill		!
	mov	%o0, %l1			! save reg pointer
	mov	%i0, %o0			! copy 1st arg
	mov	%i1, %o1			! copy 2nd arg
	ldx	[%g1 + CPU_STATS_SYS_SYSCALL], %g2
	inc	%g2				! cpu_stats.sys.syscall++
	stx	%g2, [%g1 + CPU_STATS_SYS_SYSCALL]

	!
	! Set new state for LWP
	!
	ldn	[THREAD_REG + T_LWP], %l2
	mov	LWP_SYS, %g3
	mov	%i2, %o2			! copy 3rd arg
	stb	%g3, [%l2 + LWP_STATE]
	mov	%i3, %o3			! copy 4th arg
	ldx	[%l2 + LWP_RU_SYSC], %g2	! pesky statistics
	mov	%i4, %o4			! copy 5th arg
	addx	%g2, 1, %g2
	stx	%g2, [%l2 + LWP_RU_SYSC]
	mov	%i5, %o5			! copy 6th arg
	! args for direct syscalls now set up

#ifdef TRAPTRACE
	!
	! make trap trace entry - helps in debugging
	!
	rdpr	%pstate, %l3
	andn	%l3, PSTATE_IE | PSTATE_AM, %g3
	wrpr	%g0, %g3, %pstate		! disable interrupt
	TRACE_PTR(%g3, %g2)			! get trace pointer
	GET_TRACE_TICK(%g1, %g2)
	stxa	%g1, [%g3 + TRAP_ENT_TICK]%asi
	ldx	[%l1 + G1_OFF], %g1		! get syscall code
	TRACE_SAVE_TL_VAL(%g3, %g1)
	TRACE_SAVE_GL_VAL(%g3, %g0)
	set	TT_SC_ENTR, %g2
	stha	%g2, [%g3 + TRAP_ENT_TT]%asi
	stxa	%g7, [%g3 + TRAP_ENT_TSTATE]%asi ! save thread in tstate space
	stna	%sp, [%g3 + TRAP_ENT_SP]%asi
	stna	%o0, [%g3 + TRAP_ENT_F1]%asi
	stna	%o1, [%g3 + TRAP_ENT_F2]%asi
	stna	%o2, [%g3 + TRAP_ENT_F3]%asi
	stna	%o3, [%g3 + TRAP_ENT_F4]%asi
	stna	%o4, [%g3 + TRAP_ENT_TPC]%asi
	stna	%o5, [%g3 + TRAP_ENT_TR]%asi
	TRACE_NEXT(%g3, %g2, %g1)		! set new trace pointer
	wrpr	%g0, %l3, %pstate		! enable interrupt
#endif /* TRAPTRACE */

	!
	! Test for pre-system-call handling
	!
	ldub	[THREAD_REG + T_PRE_SYS], %g3	! pre-syscall proc?
#ifdef SYSCALLTRACE
	sethi	%hi(syscalltrace), %g4
	ld	[%g4 + %lo(syscalltrace)], %g4
	orcc	%g3, %g4, %g0			! pre_syscall OR syscalltrace?
#else
	tst	%g3				! is pre_syscall flag set?
#endif /* SYSCALLTRACE */

	bnz,pn	%icc, _syscall_pre
	nop

	! Fast path invocation of new_mstate

	mov	LMS_USER, %o0
	call	syscall_mstate
	mov	LMS_SYSTEM, %o1
	
	ldx	[%l1 + O0_OFF], %o0		! restore %o0
	ldx	[%l1 + O1_OFF], %o1		! restore %o1
	ldx	[%l1 + O2_OFF], %o2
	ldx     [%l1 + O3_OFF], %o3
	ldx     [%l1 + O4_OFF], %o4
	ldx	[%l1 + O5_OFF], %o5
	
	! lwp_arg now set up
3:
	!
	! Call the handler.  The %o's and lwp_arg have been set up.
	!
	ldx	[%l1 + G1_OFF], %g1		! get code
	set	sysent, %g3			! load address of vector table
	cmp	%g1, NSYSCALL			! check range
	sth	%g1, [THREAD_REG + T_SYSNUM]	! save syscall code
	bgeu,pn	%ncc, _syscall_ill
	  sll	%g1, SYSENT_SHIFT, %g4			! delay - get index 
	add	%g3, %g4, %l4
	ldn	[%l4 + SY_CALLC], %g3		! load system call handler

	call	%g3				! call system call handler
	  nop
	!
	! If handler returns two ints, then we need to split the 64-bit
	! return value in %o0 into %o0 and %o1
	!
	lduh	[%l4 + SY_FLAGS], %l4		! load sy_flags
	andcc	%l4, SE_32RVAL2, %g0		! check for 2 x 32-bit
	bz,pt	%xcc, 5f
	  nop
	srl	%o0, 0, %o1			! lower 32-bits into %o1
	srlx	%o0, 32, %o0			! upper 32-bits into %o0
5:

#ifdef TRAPTRACE
	!
	! make trap trace entry for return - helps in debugging
	!
	rdpr	%pstate, %g5
	andn	%g5, PSTATE_IE | PSTATE_AM, %g4
	wrpr	%g0, %g4, %pstate		! disable interrupt
	TRACE_PTR(%g4, %g2)			! get trace pointer
	GET_TRACE_TICK(%g2, %g3)
	stxa	%g2, [%g4 + TRAP_ENT_TICK]%asi
	lduh	[THREAD_REG + T_SYSNUM], %g2
	TRACE_SAVE_TL_VAL(%g4, %g2)
	TRACE_SAVE_GL_VAL(%g4, %g0)
	mov	TT_SC_RET, %g2			! system call return code
	stha	%g2, [%g4 + TRAP_ENT_TT]%asi
	ldn	[%l1 + nPC_OFF], %g2		! get saved npc (new pc)
	stna	%g2, [%g4 + TRAP_ENT_TPC]%asi
	ldx	[%l1 + TSTATE_OFF], %g2		! get saved tstate
	stxa	%g2, [%g4 + TRAP_ENT_TSTATE]%asi
	stna	%sp, [%g4 + TRAP_ENT_SP]%asi
	stna	THREAD_REG, [%g4 + TRAP_ENT_TR]%asi
	stna	%o0, [%g4 + TRAP_ENT_F1]%asi
	stna	%o1, [%g4 + TRAP_ENT_F2]%asi
	stna	%g0, [%g4 + TRAP_ENT_F3]%asi
	stna	%g0, [%g4 + TRAP_ENT_F4]%asi
	TRACE_NEXT(%g4, %g2, %g3)		! set new trace pointer
	wrpr	%g0, %g5, %pstate		! enable interrupt
#endif /* TRAPTRACE */
	!
	! Check for post-syscall processing.
	! This tests all members of the union containing t_astflag, t_post_sys,
	! and t_sig_check with one test.
	!
	ld	[THREAD_REG + T_POST_SYS_AST], %g1
#ifdef SYSCALLTRACE
	sethi	%hi(syscalltrace), %g4
	ld	[%g4 + %lo(syscalltrace)], %g4
	orcc	%g4, %g1, %g0			! OR in syscalltrace
#else
	tst	%g1				! need post-processing?
#endif /* SYSCALLTRACE */
	bnz,pn	%icc, _syscall_post		! yes - post_syscall or AST set
	mov	LWP_USER, %g1
	stb	%g1, [%l2 + LWP_STATE]		! set lwp_state
	stx	%o0, [%l1 + O0_OFF]		! set rp->r_o0
	stx	%o1, [%l1 + O1_OFF]		! set rp->r_o1
	clrh	[THREAD_REG + T_SYSNUM]		! clear syscall code
	ldx	[%l1 + TSTATE_OFF], %g1		! get saved tstate
	ldn	[%l1 + nPC_OFF], %g2		! get saved npc (new pc)
	mov	CCR_IC, %g3
	sllx	%g3, TSTATE_CCR_SHIFT, %g3
	add	%g2, 4, %g4			! calc new npc
	andn	%g1, %g3, %g1			! clear carry bit for no error
	stn	%g2, [%l1 + PC_OFF]
	stn	%g4, [%l1 + nPC_OFF]
	stx	%g1, [%l1 + TSTATE_OFF]

	! Switch mstate back on the way out

	mov	LMS_SYSTEM, %o0
	call	syscall_mstate
	mov	LMS_USER, %o1
	jmp	%l0 + 8
	 nop

_syscall_pre:
	ldx	[%l1 + G1_OFF], %g1
	call	pre_syscall			! abort = pre_syscall(arg0)
	sth	%g1, [THREAD_REG + T_SYSNUM]

	brnz,pn	%o0, _syscall_post		! did it abort?
	nop
	ldx	[%l1 + O0_OFF], %o0		! reload args
	ldx	[%l1 + O1_OFF], %o1
	ldx	[%l1 + O2_OFF], %o2
	ldx	[%l1 + O3_OFF], %o3
	ldx	[%l1 + O4_OFF], %o4
	ba,pt	%xcc, 3b
	ldx	[%l1 + O5_OFF], %o5

	!
	! Floating-point trap was pending at start of system call.
	! Here with:
	!	%l3 = mpcb_flags
	!
_syscall_fp:
	andn	%l3, FP_TRAPPED, %l3
	st	%l3, [%sp + STACK_BIAS + MPCB_FLAGS] 	! clear FP_TRAPPED
	jmp	%l0 + 8				! return to user_rtt
	clrh	[THREAD_REG + T_SYSNUM]		! clear syscall code

	!
	! illegal system call - syscall number out of range
	!
_syscall_ill:
	call	nosys
	nop
	!
	! Post-syscall with special processing needed.
	!
_syscall_post:
	call	post_syscall			! post_syscall(rvals)
	nop
	jmp	%l0 + 8				! return to user_rtt
	nop
	SET_SIZE(syscall_trap)

/*
 * System call trap handler for ILP32 processes.
 *
 * We branch here from sys_trap when a system call occurs.
 *
 * Entry:
 *	%o0 = regs
 *
 * Usage:
 *	%l0 = saved return address
 *	%l1 = saved regs
 *	%l2 = lwp
 */
	ENTRY_NP(syscall_trap32)
	ldx	[THREAD_REG + T_CPU], %g1	! get cpu pointer
	mov	%o7, %l0			! save return addr

	!
	! If the trapping thread has the address mask bit clear, then it's
	!   a 64-bit process, and has no business calling 32-bit syscalls.
	!
	ldx	[%o0 + TSTATE_OFF], %l1		! saved %tstate.am is that
	andcc	%l1, TSTATE_AM, %l1		!   of the trapping proc
	be,pn	%xcc, _syscall_ill32		!
	  mov	%o0, %l1			! save reg pointer
	srl	%i0, 0, %o0			! copy 1st arg, clear high bits
	srl	%i1, 0, %o1			! copy 2nd arg, clear high bits
	ldx	[%g1 + CPU_STATS_SYS_SYSCALL], %g2
	inc	%g2				! cpu_stats.sys.syscall++
	stx	%g2, [%g1 + CPU_STATS_SYS_SYSCALL]

	!
	! Set new state for LWP
	!
	ldx	[THREAD_REG + T_LWP], %l2
	mov	LWP_SYS, %g3
	srl	%i2, 0, %o2			! copy 3rd arg, clear high bits
	stb	%g3, [%l2 + LWP_STATE]
	srl	%i3, 0, %o3			! copy 4th arg, clear high bits
	ldx	[%l2 + LWP_RU_SYSC], %g2	! pesky statistics
	srl	%i4, 0, %o4			! copy 5th arg, clear high bits
	addx	%g2, 1, %g2
	stx	%g2, [%l2 + LWP_RU_SYSC]
	srl	%i5, 0, %o5			! copy 6th arg, clear high bits
	! args for direct syscalls now set up

#ifdef TRAPTRACE
	!
	! make trap trace entry - helps in debugging
	!
	rdpr	%pstate, %l3
	andn	%l3, PSTATE_IE | PSTATE_AM, %g3
	wrpr	%g0, %g3, %pstate		! disable interrupt
	TRACE_PTR(%g3, %g2)			! get trace pointer
	GET_TRACE_TICK(%g1, %g2)
	stxa	%g1, [%g3 + TRAP_ENT_TICK]%asi
	ldx	[%l1 + G1_OFF], %g1		! get syscall code
	TRACE_SAVE_TL_VAL(%g3, %g1)
	TRACE_SAVE_GL_VAL(%g3, %g0)
	set	TT_SC_ENTR, %g2
	stha	%g2, [%g3 + TRAP_ENT_TT]%asi
	stxa	%g7, [%g3 + TRAP_ENT_TSTATE]%asi ! save thread in tstate space
	stna	%sp, [%g3 + TRAP_ENT_SP]%asi
	stna	%o0, [%g3 + TRAP_ENT_F1]%asi
	stna	%o1, [%g3 + TRAP_ENT_F2]%asi
	stna	%o2, [%g3 + TRAP_ENT_F3]%asi
	stna	%o3, [%g3 + TRAP_ENT_F4]%asi
	stna	%o4, [%g3 + TRAP_ENT_TPC]%asi
	stna	%o5, [%g3 + TRAP_ENT_TR]%asi
	TRACE_NEXT(%g3, %g2, %g1)		! set new trace pointer
	wrpr	%g0, %l3, %pstate		! enable interrupt
#endif /* TRAPTRACE */

	!
	! Test for pre-system-call handling
	!
	ldub	[THREAD_REG + T_PRE_SYS], %g3	! pre-syscall proc?
#ifdef SYSCALLTRACE
	sethi	%hi(syscalltrace), %g4
	ld	[%g4 + %lo(syscalltrace)], %g4
	orcc	%g3, %g4, %g0			! pre_syscall OR syscalltrace?
#else
	tst	%g3				! is pre_syscall flag set?
#endif /* SYSCALLTRACE */
	bnz,pn	%icc, _syscall_pre32		! yes - pre_syscall needed
	  nop

	! Fast path invocation of new_mstate
	mov	LMS_USER, %o0
	call 	syscall_mstate
	mov	LMS_SYSTEM, %o1
		
 	lduw	[%l1 + O0_OFF + 4], %o0		! reload 32-bit args
	lduw	[%l1 + O1_OFF + 4], %o1
	lduw	[%l1 + O2_OFF + 4], %o2
	lduw	[%l1 + O3_OFF + 4], %o3
	lduw	[%l1 + O4_OFF + 4], %o4
	lduw	[%l1 + O5_OFF + 4], %o5

	! lwp_arg now set up
3:
	!
	! Call the handler.  The %o's have been set up.
	!
	lduw	[%l1 + G1_OFF + 4], %g1		! get 32-bit code
	set	sysent32, %g3			! load address of vector table
	cmp	%g1, NSYSCALL			! check range
	sth	%g1, [THREAD_REG + T_SYSNUM]	! save syscall code
	bgeu,pn	%ncc, _syscall_ill32
	  sll	%g1, SYSENT_SHIFT, %g4		! delay - get index 
	add	%g3, %g4, %g5			! g5 = addr of sysentry
	ldx	[%g5 + SY_CALLC], %g3		! load system call handler

	brnz,a,pt %g1, 4f			! check for indir()
	mov	%g5, %l4			! save addr of sysentry
	!
	! Yuck.  If %g1 is zero, that means we're doing a syscall() via the
	! indirect system call.  That means we have to check the
	! flags of the targetted system call, not the indirect system call
	! itself.  See return value handling code below.
	!
	set	sysent32, %l4			! load address of vector table
	cmp	%o0, NSYSCALL			! check range
	bgeu,pn	%ncc, 4f			! out of range, let C handle it
	  sll	%o0, SYSENT_SHIFT, %g4		! delay - get index
	add	%g4, %l4, %l4			! compute & save addr of sysent
4:
	call	%g3				! call system call handler
	nop

	!
	! If handler returns long long then we need to split the 64 bit
	! return value in %o0 into %o0 and %o1 for ILP32 clients.
	!	
	lduh    [%l4 + SY_FLAGS], %g4           ! load sy_flags
	andcc	%g4, SE_64RVAL | SE_32RVAL2, %g0 ! check for 64-bit return
	bz,a,pt	%xcc, 5f
	  srl	%o0, 0, %o0			! 32-bit only
	srl	%o0, 0, %o1			! lower 32 bits into %o1
	srlx	%o0, 32, %o0			! upper 32 bits into %o0
5:

#ifdef TRAPTRACE
	!
	! make trap trace entry for return - helps in debugging
	!
	rdpr	%pstate, %g5
	andn	%g5, PSTATE_IE | PSTATE_AM, %g4
	wrpr	%g0, %g4, %pstate		! disable interrupt
	TRACE_PTR(%g4, %g2)			! get trace pointer
	GET_TRACE_TICK(%g2, %g3)
	stxa	%g2, [%g4 + TRAP_ENT_TICK]%asi
	lduh	[THREAD_REG + T_SYSNUM], %g2
	TRACE_SAVE_TL_VAL(%g4, %g2)
	TRACE_SAVE_GL_VAL(%g4, %g0)
	mov	TT_SC_RET, %g2			! system call return code
	stha	%g2, [%g4 + TRAP_ENT_TT]%asi
	ldx	[%l1 + nPC_OFF], %g2		! get saved npc (new pc)
	stna	%g2, [%g4 + TRAP_ENT_TPC]%asi
	ldx	[%l1 + TSTATE_OFF], %g2		! get saved tstate
	stxa	%g2, [%g4 + TRAP_ENT_TSTATE]%asi
	stna	%sp, [%g4 + TRAP_ENT_SP]%asi
	stna	THREAD_REG, [%g4 + TRAP_ENT_TR]%asi
	stna	%o0, [%g4 + TRAP_ENT_F1]%asi
	stna	%o1, [%g4 + TRAP_ENT_F2]%asi
	stna	%g0, [%g4 + TRAP_ENT_F3]%asi
	stna	%g0, [%g4 + TRAP_ENT_F4]%asi
	TRACE_NEXT(%g4, %g2, %g3)		! set new trace pointer
	wrpr	%g0, %g5, %pstate		! enable interrupt
#endif /* TRAPTRACE */
	!
	! Check for post-syscall processing.
	! This tests all members of the union containing t_astflag, t_post_sys,
	! and t_sig_check with one test.
	!
	ld	[THREAD_REG + T_POST_SYS_AST], %g1
#ifdef SYSCALLTRACE
	sethi	%hi(syscalltrace), %g4
	ld	[%g4 + %lo(syscalltrace)], %g4
	orcc	%g4, %g1, %g0			! OR in syscalltrace
#else
	tst	%g1				! need post-processing?
#endif /* SYSCALLTRACE */
	bnz,pn	%icc, _syscall_post32		! yes - post_syscall or AST set
	mov	LWP_USER, %g1
	stb	%g1, [%l2 + LWP_STATE]		! set lwp_state
	stx	%o0, [%l1 + O0_OFF]		! set rp->r_o0
	stx	%o1, [%l1 + O1_OFF]		! set rp->r_o1
	clrh	[THREAD_REG + T_SYSNUM]		! clear syscall code
	ldx	[%l1 + TSTATE_OFF], %g1		! get saved tstate
	ldx	[%l1 + nPC_OFF], %g2		! get saved npc (new pc)
	mov	CCR_IC, %g3
	sllx	%g3, TSTATE_CCR_SHIFT, %g3
	add	%g2, 4, %g4			! calc new npc
	andn	%g1, %g3, %g1			! clear carry bit for no error
	stx	%g2, [%l1 + PC_OFF]
	stx	%g4, [%l1 + nPC_OFF]
	stx	%g1, [%l1 + TSTATE_OFF]

	! fast path outbound microstate accounting call
	mov	LMS_SYSTEM, %o0
	call 	syscall_mstate
	mov	LMS_USER, %o1

	jmp	%l0 + 8
	 nop


_syscall_pre32:
	ldx	[%l1 + G1_OFF], %g1
	call	pre_syscall			! abort = pre_syscall(arg0)
	sth	%g1, [THREAD_REG + T_SYSNUM]

	brnz,pn	%o0, _syscall_post32		! did it abort?
	nop
 	lduw	[%l1 + O0_OFF + 4], %o0		! reload 32-bit args
	lduw	[%l1 + O1_OFF + 4], %o1
	lduw	[%l1 + O2_OFF + 4], %o2
	lduw	[%l1 + O3_OFF + 4], %o3
	lduw	[%l1 + O4_OFF + 4], %o4
	ba,pt	%xcc, 3b
	lduw	[%l1 + O5_OFF + 4], %o5

	!
	! Floating-point trap was pending at start of system call.
	! Here with:
	!	%l3 = mpcb_flags
	!
_syscall_fp32:
	andn	%l3, FP_TRAPPED, %l3
	st	%l3, [%sp + STACK_BIAS + MPCB_FLAGS] 	! clear FP_TRAPPED
	jmp	%l0 + 8				! return to user_rtt
	clrh	[THREAD_REG + T_SYSNUM]		! clear syscall code

	!
	! illegal system call - syscall number out of range
	!
_syscall_ill32:
	call	nosys
	nop
	!
	! Post-syscall with special processing needed.
	!
_syscall_post32:
	call	post_syscall			! post_syscall(rvals)
	nop
	jmp	%l0 + 8				! return to user_rtt
	nop
	SET_SIZE(syscall_trap32)


/*
 * lwp_rtt - start execution in newly created LWP.
 *	Here with t_post_sys set by lwp_create, and lwp_eosys == JUSTRETURN,
 *	so that post_syscall() will run and the registers will
 *	simply be restored.
 *	This must go out through sys_rtt instead of syscall_rtt.
 */
	ENTRY_NP(lwp_rtt_initial)
	ldn	[THREAD_REG + T_STACK], %l7
	call	__dtrace_probe___proc_start
	sub	%l7, STACK_BIAS, %sp
	ba,a,pt	%xcc, 0f

	ENTRY_NP(lwp_rtt)
	ldn	[THREAD_REG + T_STACK], %l7
	sub	%l7, STACK_BIAS, %sp
0:
	call	__dtrace_probe___proc_lwp__start
	nop
	call	dtrace_systrace_rtt
	add	%sp, REGOFF + STACK_BIAS, %l7
	ldx	[%l7 + O0_OFF], %o0
	call	post_syscall
	ldx	[%l7 + O1_OFF], %o1
	ba,a,pt	%xcc, user_rtt
	SET_SIZE(lwp_rtt)
	SET_SIZE(lwp_rtt_initial)