/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This is an assembly file that gets #include-ed into the brand-specific
 * assembly files (e.g. sn1_brand_asm.s) for Solaris-derived brands.
 * We can't make these into functions since in the trap context there's
 * no easy place to save the extra parameters that would be required, so
 * each brand module needs its own copy of this code.  We #include this and
 * use brand-specific #defines to replace the XXX_brand_... definitions.
 */ 

#include <sys/asm_linkage.h>
#include <sys/machthread.h>
#include <sys/privregs.h>
#include "assym.h"

#ifdef _ASM	/* The remainder of this file is only for assembly files */

#if defined(sun4v)

#define	GLOBALS_SWAP(reg)				\
	rdpr	%gl, reg;				\
	wrpr	reg, 1, %gl

/*
 * The GLOBALS_RESTORE macro can only be one instruction since it's
 * used in a delay slot.
 */
#define	GLOBALS_RESTORE(reg)				\
	wrpr	reg, 0, %gl

#else /* !sun4v */

#define	GLOBALS_SWAP(reg)				\
	rdpr	%pstate, reg;				\
	wrpr	reg, PSTATE_AG, %pstate

/*
 * The GLOBALS_RESTORE macro can only be one instruction since it's
 * used in a delay slot.
 */
#define	GLOBALS_RESTORE(reg)				\
	wrpr	reg, %g0, %pstate

#endif /* !sun4v */

/*
 * Input parameters:
 * %g1: return point
 * %g2: pointer to our cpu structure
 */
ENTRY(XXX_brand_syscall32_callback)
	/*
	 * 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.
	 */
	rdpr	%tstate, %g3;		/* %tstate.am is the trapping */
	andcc	%g3, TSTATE_AM, %g3;	/*   threads address mask bit */
	bne,pt	%xcc, _entry;
	nop;
	jmp	%g1;			/* 64 bit process, bail out */
	nop;
SET_SIZE(XXX_brand_syscall32_callback)

/*
 * Input parameters:
 * %g1: return point
 * %g2: pointer to our cpu structure
 */
ENTRY(XXX_brand_syscall_callback)
	/*
	 * 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.
	 */
	rdpr	%tstate, %g3;		/* %tstate.am is the trapping */
	andcc	%g3, TSTATE_AM, %g3;	/*   threads address mask bit */
	be,pt	%xcc, _entry;
	nop;
	jmp	%g1;			/* 32 bit process, bail out */
	nop;
SET_SIZE(XXX_brand_syscall_callback)

ENTRY(XXX_brand_syscall_callback_common)
_entry:
	/*
	 * Input parameters:
	 * %g1: return point
	 * %g2: pointer to our cpu structure
	 *
	 * Note that we're free to use any %g? registers as long as
	 * we are are executing with alternate globals.  If we're
	 * executing with user globals we need to backup any registers
	 * that we want to use so that we can restore them when we're
	 * done.
	 *
	 * Save some locals in the CPU tmp area to give us a little
	 * room to work.
	 */
	stn	%l0, [%g2 + CPU_TMP1];
	stn	%l1, [%g2 + CPU_TMP2];

#if defined(sun4v)
	/*
	 * On sun4v save our input parameters (which are stored in the
	 * alternate globals) since we'll need to switch between alternate
	 * globals and normal globals, and on sun4v the alternate globals
	 * are not preserved across these types of switches.
	 */
	stn	%l2, [%g2 + CPU_TMP3];
	stn	%l3, [%g2 + CPU_TMP4];

	mov	%g1, %l2;		/* save %g1 in %l2 */
	mov	%g2, %l3;		/* save %g2 in %l3 */
#endif /* sun4v */

	/*
	 * Switch from the alternate to user globals to grab the syscall
	 * number.
	 */
	GLOBALS_SWAP(%l0);		/* switch to normal globals */

	/*
	 * If the system call number is >= 1024, then it is a native
	 * syscall that doesn't need emulation.
	 */
	cmp	%g1, 1024;		/* is this a native syscall? */
	bl,a	_indirect_check;	/* probably not, continue checking */
	mov	%g1, %l1;		/* delay slot - grab syscall number */

	/*
	 * This is a native syscall, probably from the emulation library.
	 * Subtract 1024 from the syscall number and let it go through.
	 */
	sub	%g1, 1024, %g1;		/* convert magic num to real syscall */
	ba	_exit;			/* jump back into syscall path */
	GLOBALS_RESTORE(%l0);		/* delay slot - */
					/* switch back to alternate globals */

_indirect_check:
	/*
	 * If the system call number is 0 (SYS_syscall), then this might be
	 * an indirect syscall, in which case the actual syscall number
	 * would be stored in %o0, in which case we need to redo the
	 * the whole >= 1024 check.
	 */
	brnz,pt %g1, _emulation_check;	/* is this an indirect syscall? */
	nop;				/* if not, goto the emulation check */

	/*
	 * Indirect syscalls are only supported for 32 bit processes so
	 * consult the tstate address mask again.
	 */
	rdpr	%tstate, %l1;		/* %tstate.am is the trapping */
	andcc	%l1, TSTATE_AM, %l1;	/*   threads address mask bit */
	be,a,pn	%xcc, _exit;
	GLOBALS_RESTORE(%l0);		/* delay slot -	*/
					/* switch back to alternate globals */

	/*
	 * The caller is 32 bit and this an indirect system call.
	 */
	cmp	%o0, 1024;		/* is this a native syscall? */
	bl,a	_emulation_check;	/* no, goto the emulation check */
	mov	%o0, %l1;		/* delay slot - grab syscall number */

	/*
	 * This is native indirect syscall, probably from the emulation
	 * library.  Subtract 1024 from the syscall number and let it go
	 * through.
	 */
	sub	%o0, 1024, %o0;		/* convert magic num to real syscall */
	ba	_exit;			/* jump back into syscall path */
	GLOBALS_RESTORE(%l0);		/* delay slot - */
					/* switch back to alternate globals */

_emulation_check:
	GLOBALS_RESTORE(%l0);		/* switch back to alternate globals */

	/*
	 * Check to see if we want to interpose on this system call.  If
	 * not, we jump back into the normal syscall path and pretend
	 * nothing happened.  %l1 contains the syscall we're invoking.
	 */
	set	XXX_emulation_table, %g3;
	ldn	[%g3], %g3;
	add	%g3, %l1, %g3;
	ldub	[%g3], %g3;
	brz	%g3, _exit;
	nop;

	/*
	 * Find the address of the userspace handler.
	 * cpu->cpu_thread->t_procp->p_brand_data->spd_handler.
	 */
#if defined(sun4v)
	/* restore the alternate global registers after incrementing %gl */
	mov	%l3, %g2;
#endif /* sun4v */
	ldn	[%g2 + CPU_THREAD], %g3;	/* get thread ptr */
	ldn	[%g3 + T_PROCP], %g4;		/* get proc ptr */
	ldn	[%g4 + P_BRAND_DATA], %g5;	/* get brand data ptr */
	ldn	[%g5 + SPD_HANDLER], %g5;	/* get userland brnd hdlr ptr */
	brz	%g5, _exit;			/* has it been set? */
	nop;

	/*
	 * Make sure this isn't an agent lwp.  We can't do syscall
	 * interposition for system calls made by a agent lwp.  See
	 * the block comments in the top of the brand emulation library
	 * for more information.
	 */
	ldn	[%g4 + P_AGENTTP], %g4;		/* get agent thread ptr */
	cmp	%g3, %g4;			/* is this an agent thread? */
	be,pn	%xcc, _exit;			/* if so don't emulate */
	nop;

	/*
	 * Now the magic happens.  Grab the trap return address and then
	 * reset it to point to the user space handler.  When we execute
	 * the 'done' instruction, we will jump into our handler instead of
	 * the user's code.  We also stick the old return address in %g5,
	 * so we can return to the proper instruction in the user's code.
	 * Note: we also pass back the base address of the syscall
	 * emulation table.  This is a performance hack to avoid having to
	 * look it up on every call.
	 */
	rdpr	%tnpc, %l1;		/* save old tnpc */
	wrpr	%g0, %g5, %tnpc;	/* setup tnpc */
	GLOBALS_SWAP(%l0);		/* switch to normal globals */
	mov	%l1, %g5;		/* pass tnpc to user code in %g5 */
	GLOBALS_RESTORE(%l0);		/* switch back to alternate globals */

	/* Update the address we're going to return to */
#if defined(sun4v)
	set	fast_trap_done_chk_intr, %l2;
#else /* !sun4v */
	set	fast_trap_done_chk_intr, %g1;
#endif /* !sun4v */

_exit:
	/*
	 * Restore registers before returning.
	 *
	 * Note that %g2 should be loaded with the CPU struct addr and
	 * %g1 should be loaded the address we're going to return to.
	 */
#if defined(sun4v)
	/* restore the alternate global registers after incrementing %gl */
	mov	%l2, %g1;		/* restore %g1 from %l2 */
	mov	%l3, %g2;		/* restore %g2 from %l3 */

	ldn	[%g2 + CPU_TMP4], %l3;	/* restore locals */
	ldn	[%g2 + CPU_TMP3], %l2;
#endif /* sun4v */

	ldn	[%g2 + CPU_TMP2], %l1;	/* restore locals */
	ldn	[%g2 + CPU_TMP1], %l0;

	jmp	%g1;
	nop;
SET_SIZE(XXX_brand_syscall_callback_common)

#endif	/* _ASM */