[mirror_ubuntu-artful-kernel.git] / arch / parisc / kernel / syscall.S

/* 
 * Linux/PA-RISC Project (http://www.parisc-linux.org/)
 * 
 * System call entry code Copyright (c) Matthew Wilcox 1999 <willy@bofh.ai>
 * Licensed under the GNU GPL.
 * thanks to Philipp Rumpf, Mike Shaver and various others
 * sorry about the wall, puffin..
 */

#include <asm/asm-offsets.h>
#include <asm/unistd.h>
#include <asm/errno.h>
#include <asm/page.h>
#include <asm/psw.h>
#include <asm/thread_info.h>
#include <asm/assembly.h>
#include <asm/processor.h>

#include <linux/linkage.h>

	/* We fill the empty parts of the gateway page with
 	 * something that will kill the kernel or a
 	 * userspace application.
	 */
#define KILL_INSN	break	0,0

	.level          LEVEL

	.text

	.import syscall_exit,code
	.import syscall_exit_rfi,code

	/* Linux gateway page is aliased to virtual page 0 in the kernel
	 * address space. Since it is a gateway page it cannot be
	 * dereferenced, so null pointers will still fault. We start
	 * the actual entry point at 0x100. We put break instructions
	 * at the beginning of the page to trap null indirect function
	 * pointers.
	 */

	.align PAGE_SIZE
ENTRY(linux_gateway_page)

        /* ADDRESS 0x00 to 0xb0 = 176 bytes / 4 bytes per insn = 44 insns */
	.rept 44
	KILL_INSN
	.endr

	/* ADDRESS 0xb0 to 0xb4, lws uses 1 insns for entry */
	/* Light-weight-syscall entry must always be located at 0xb0 */
	/* WARNING: Keep this number updated with table size changes */
#define __NR_lws_entries (2)

lws_entry:
	/* Unconditional branch to lws_start, located on the 
	   same gateway page */
	b,n	lws_start

	/* Fill from 0xb4 to 0xe0 */
	.rept 11
	KILL_INSN
	.endr

	/* This function MUST be located at 0xe0 for glibc's threading 
	mechanism to work. DO NOT MOVE THIS CODE EVER! */
set_thread_pointer:
	gate	.+8, %r0		/* increase privilege */
	depi	3, 31, 2, %r31		/* Ensure we return into user mode. */
	be	0(%sr7,%r31)		/* return to user space */
	mtctl	%r26, %cr27		/* move arg0 to the control register */

	/* Increase the chance of trapping if random jumps occur to this
	address, fill from 0xf0 to 0x100 */
	.rept 4
	KILL_INSN
	.endr

/* This address must remain fixed at 0x100 for glibc's syscalls to work */
	.align 256
linux_gateway_entry:
	gate	.+8, %r0			/* become privileged */
	mtsp	%r0,%sr4			/* get kernel space into sr4 */
	mtsp	%r0,%sr5			/* get kernel space into sr5 */
	mtsp	%r0,%sr6			/* get kernel space into sr6 */
	mfsp    %sr7,%r1                        /* save user sr7 */
	mtsp    %r1,%sr3                        /* and store it in sr3 */

#ifdef CONFIG_64BIT
	/* for now we can *always* set the W bit on entry to the syscall
	 * since we don't support wide userland processes.  We could
	 * also save the current SM other than in r0 and restore it on
	 * exit from the syscall, and also use that value to know
	 * whether to do narrow or wide syscalls. -PB
	 */
	ssm	PSW_SM_W, %r1
	extrd,u	%r1,PSW_W_BIT,1,%r1
	/* sp must be aligned on 4, so deposit the W bit setting into
	 * the bottom of sp temporarily */
	or,ev	%r1,%r30,%r30
	b,n	1f
	/* The top halves of argument registers must be cleared on syscall
	 * entry from narrow executable.
	 */
	depdi	0, 31, 32, %r26
	depdi	0, 31, 32, %r25
	depdi	0, 31, 32, %r24
	depdi	0, 31, 32, %r23
	depdi	0, 31, 32, %r22
	depdi	0, 31, 32, %r21
1:	
#endif
	mfctl   %cr30,%r1
	xor     %r1,%r30,%r30                   /* ye olde xor trick */
	xor     %r1,%r30,%r1
	xor     %r1,%r30,%r30
	
	ldo     THREAD_SZ_ALGN+FRAME_SIZE(%r30),%r30  /* set up kernel stack */

	/* N.B.: It is critical that we don't set sr7 to 0 until r30
	 *       contains a valid kernel stack pointer. It is also
	 *       critical that we don't start using the kernel stack
	 *       until after sr7 has been set to 0.
	 */

	mtsp	%r0,%sr7			/* get kernel space into sr7 */
	STREGM	%r1,FRAME_SIZE(%r30)		/* save r1 (usp) here for now */
	mfctl	%cr30,%r1			/* get task ptr in %r1 */
	LDREG	TI_TASK(%r1),%r1

	/* Save some registers for sigcontext and potential task
	   switch (see entry.S for the details of which ones are
	   saved/restored).  TASK_PT_PSW is zeroed so we can see whether
	   a process is on a syscall or not.  For an interrupt the real
	   PSW value is stored.  This is needed for gdb and sys_ptrace. */
	STREG	%r0,  TASK_PT_PSW(%r1)
	STREG	%r2,  TASK_PT_GR2(%r1)		/* preserve rp */
	STREG	%r19, TASK_PT_GR19(%r1)

	LDREGM	-FRAME_SIZE(%r30), %r2		/* get users sp back */
#ifdef CONFIG_64BIT
	extrd,u	%r2,63,1,%r19			/* W hidden in bottom bit */
#if 0
	xor	%r19,%r2,%r2			/* clear bottom bit */
	depd,z	%r19,1,1,%r19
	std	%r19,TASK_PT_PSW(%r1)
#endif
#endif
	STREG	%r2,  TASK_PT_GR30(%r1)		/* ... and save it */
	
	STREG	%r20, TASK_PT_GR20(%r1)		/* Syscall number */
	STREG	%r21, TASK_PT_GR21(%r1)
	STREG	%r22, TASK_PT_GR22(%r1)
	STREG	%r23, TASK_PT_GR23(%r1)		/* 4th argument */
	STREG	%r24, TASK_PT_GR24(%r1)		/* 3rd argument */
	STREG	%r25, TASK_PT_GR25(%r1)		/* 2nd argument */
	STREG	%r26, TASK_PT_GR26(%r1)	 	/* 1st argument */
	STREG	%r27, TASK_PT_GR27(%r1)		/* user dp */
	STREG   %r28, TASK_PT_GR28(%r1)         /* return value 0 */
	STREG   %r28, TASK_PT_ORIG_R28(%r1)     /* return value 0 (saved for signals) */
	STREG	%r29, TASK_PT_GR29(%r1)		/* return value 1 */
	STREG	%r31, TASK_PT_GR31(%r1)		/* preserve syscall return ptr */
	
	ldo	TASK_PT_FR0(%r1), %r27		/* save fpregs from the kernel */
	save_fp	%r27				/* or potential task switch  */

	mfctl	%cr11, %r27			/* i.e. SAR */
	STREG	%r27, TASK_PT_SAR(%r1)

	loadgp

#ifdef CONFIG_64BIT
	ldo	-16(%r30),%r29			/* Reference param save area */
	copy	%r19,%r2			/* W bit back to r2 */
#else
	/* no need to save these on stack in wide mode because the first 8
	 * args are passed in registers */
	stw     %r22, -52(%r30)                 /* 5th argument */
	stw     %r21, -56(%r30)                 /* 6th argument */
#endif

	/* Are we being ptraced? */
	mfctl	%cr30, %r1
	LDREG	TI_TASK(%r1),%r1
	ldw	TASK_PTRACE(%r1), %r1
	bb,<,n	%r1,31,.Ltracesys
	
	/* Note!  We cannot use the syscall table that is mapped
	nearby since the gateway page is mapped execute-only. */

#ifdef CONFIG_64BIT
	ldil	L%sys_call_table, %r1
	or,=	%r2,%r2,%r2
	addil	L%(sys_call_table64-sys_call_table), %r1
	ldo	R%sys_call_table(%r1), %r19
	or,=	%r2,%r2,%r2
	ldo	R%sys_call_table64(%r1), %r19
#else
	ldil	L%sys_call_table, %r1
	ldo     R%sys_call_table(%r1), %r19
#endif	
	comiclr,>>	__NR_Linux_syscalls, %r20, %r0
	b,n	.Lsyscall_nosys
	
	LDREGX  %r20(%r19), %r19

	/* If this is a sys_rt_sigreturn call, and the signal was received
	 * when not in_syscall, then we want to return via syscall_exit_rfi,
	 * not syscall_exit.  Signal no. in r20, in_syscall in r25 (see
	 * trampoline code in signal.c).
	 */
	ldi	__NR_rt_sigreturn,%r2
	comb,=	%r2,%r20,.Lrt_sigreturn
.Lin_syscall:
	ldil	L%syscall_exit,%r2
	be      0(%sr7,%r19)
	ldo	R%syscall_exit(%r2),%r2
.Lrt_sigreturn:
	comib,<> 0,%r25,.Lin_syscall
	ldil	L%syscall_exit_rfi,%r2
	be      0(%sr7,%r19)
	ldo	R%syscall_exit_rfi(%r2),%r2

	/* Note!  Because we are not running where we were linked, any
	calls to functions external to this file must be indirect.  To
	be safe, we apply the opposite rule to functions within this
	file, with local labels given to them to ensure correctness. */
	
.Lsyscall_nosys:
syscall_nosys:
	ldil	L%syscall_exit,%r1
	be	R%syscall_exit(%sr7,%r1)
	ldo	-ENOSYS(%r0),%r28		   /* set errno */


/* Warning! This trace code is a virtual duplicate of the code above so be
 * sure to maintain both! */
.Ltracesys:
tracesys:
	/* Need to save more registers so the debugger can see where we
	 * are.  This saves only the lower 8 bits of PSW, so that the C
	 * bit is still clear on syscalls, and the D bit is set if this
	 * full register save path has been executed.  We check the D
	 * bit on syscall_return_rfi to determine which registers to
	 * restore.  An interrupt results in a full PSW saved with the
	 * C bit set, a non-straced syscall entry results in C and D clear
	 * in the saved PSW.
	 */
	ldo     -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1      /* get task ptr */
	LDREG	TI_TASK(%r1), %r1
	ssm	0,%r2
	STREG	%r2,TASK_PT_PSW(%r1)		/* Lower 8 bits only!! */
	mfsp	%sr0,%r2
	STREG	%r2,TASK_PT_SR0(%r1)
	mfsp	%sr1,%r2
	STREG	%r2,TASK_PT_SR1(%r1)
	mfsp	%sr2,%r2
	STREG	%r2,TASK_PT_SR2(%r1)
	mfsp	%sr3,%r2
	STREG	%r2,TASK_PT_SR3(%r1)
	STREG	%r2,TASK_PT_SR4(%r1)
	STREG	%r2,TASK_PT_SR5(%r1)
	STREG	%r2,TASK_PT_SR6(%r1)
	STREG	%r2,TASK_PT_SR7(%r1)
	STREG	%r2,TASK_PT_IASQ0(%r1)
	STREG	%r2,TASK_PT_IASQ1(%r1)
	LDREG	TASK_PT_GR31(%r1),%r2
	STREG	%r2,TASK_PT_IAOQ0(%r1)
	ldo	4(%r2),%r2
	STREG	%r2,TASK_PT_IAOQ1(%r1)
	ldo	TASK_REGS(%r1),%r2
	/* reg_save %r2 */
	STREG	%r3,PT_GR3(%r2)
	STREG	%r4,PT_GR4(%r2)
	STREG	%r5,PT_GR5(%r2)
	STREG	%r6,PT_GR6(%r2)
	STREG	%r7,PT_GR7(%r2)
	STREG	%r8,PT_GR8(%r2)
	STREG	%r9,PT_GR9(%r2)
	STREG	%r10,PT_GR10(%r2)
	STREG	%r11,PT_GR11(%r2)
	STREG	%r12,PT_GR12(%r2)
	STREG	%r13,PT_GR13(%r2)
	STREG	%r14,PT_GR14(%r2)
	STREG	%r15,PT_GR15(%r2)
	STREG	%r16,PT_GR16(%r2)
	STREG	%r17,PT_GR17(%r2)
	STREG	%r18,PT_GR18(%r2)
	/* Finished saving things for the debugger */

	ldil	L%syscall_trace,%r1
	ldil	L%tracesys_next,%r2
	be	R%syscall_trace(%sr7,%r1)
	ldo	R%tracesys_next(%r2),%r2
	
tracesys_next:	
	ldil	L%sys_call_table,%r1
	ldo     R%sys_call_table(%r1), %r19

	ldo     -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1      /* get task ptr */
	LDREG	TI_TASK(%r1), %r1
	LDREG   TASK_PT_GR20(%r1), %r20
	LDREG   TASK_PT_GR26(%r1), %r26		/* Restore the users args */
	LDREG   TASK_PT_GR25(%r1), %r25
	LDREG   TASK_PT_GR24(%r1), %r24
	LDREG   TASK_PT_GR23(%r1), %r23
#ifdef CONFIG_64BIT
	LDREG   TASK_PT_GR22(%r1), %r22
	LDREG   TASK_PT_GR21(%r1), %r21
	ldo	-16(%r30),%r29			/* Reference param save area */
#endif

	comiclr,>>=	__NR_Linux_syscalls, %r20, %r0
	b,n	.Lsyscall_nosys

	LDREGX  %r20(%r19), %r19

	/* If this is a sys_rt_sigreturn call, and the signal was received
	 * when not in_syscall, then we want to return via syscall_exit_rfi,
	 * not syscall_exit.  Signal no. in r20, in_syscall in r25 (see
	 * trampoline code in signal.c).
	 */
	ldi	__NR_rt_sigreturn,%r2
	comb,=	%r2,%r20,.Ltrace_rt_sigreturn
.Ltrace_in_syscall:
	ldil	L%tracesys_exit,%r2
	be      0(%sr7,%r19)
	ldo	R%tracesys_exit(%r2),%r2

	/* Do *not* call this function on the gateway page, because it
	makes a direct call to syscall_trace. */
	
tracesys_exit:
	ldo     -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1      /* get task ptr */
	LDREG	TI_TASK(%r1), %r1
#ifdef CONFIG_64BIT
	ldo	-16(%r30),%r29			/* Reference param save area */
#endif
	bl	syscall_trace, %r2
	STREG   %r28,TASK_PT_GR28(%r1)          /* save return value now */
	ldo     -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1      /* get task ptr */
	LDREG	TI_TASK(%r1), %r1
	LDREG   TASK_PT_GR28(%r1), %r28		/* Restore return val. */

	ldil	L%syscall_exit,%r1
	be,n	R%syscall_exit(%sr7,%r1)

.Ltrace_rt_sigreturn:
	comib,<> 0,%r25,.Ltrace_in_syscall
	ldil	L%tracesys_sigexit,%r2
	be      0(%sr7,%r19)
	ldo	R%tracesys_sigexit(%r2),%r2

tracesys_sigexit:
	ldo     -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1      /* get task ptr */
	LDREG	0(%r1), %r1
#ifdef CONFIG_64BIT
	ldo	-16(%r30),%r29			/* Reference param save area */
#endif
	bl	syscall_trace, %r2
	nop

	ldil	L%syscall_exit_rfi,%r1
	be,n	R%syscall_exit_rfi(%sr7,%r1)


	/*********************************************************
		Light-weight-syscall code

		r20 - lws number
		r26,r25,r24,r23,r22 - Input registers
		r28 - Function return register
		r21 - Error code.

		Scracth: Any of the above that aren't being
		currently used, including r1. 

		Return pointer: r31 (Not usable)

		Error codes returned by entry path:

		ENOSYS - r20 was an invalid LWS number.

	*********************************************************/
lws_start:
	/* Gate and ensure we return to userspace */
	gate	.+8, %r0
	depi	3, 31, 2, %r31	/* Ensure we return to userspace */

#ifdef CONFIG_64BIT
	/* FIXME: If we are a 64-bit kernel just
	 *        turn this on unconditionally.
	 */
	ssm	PSW_SM_W, %r1
	extrd,u	%r1,PSW_W_BIT,1,%r1
	/* sp must be aligned on 4, so deposit the W bit setting into
	 * the bottom of sp temporarily */
	or,ev	%r1,%r30,%r30

	/* Clip LWS number to a 32-bit value always */
	depdi	0, 31, 32, %r20
#endif	

        /* Is the lws entry number valid? */
	comiclr,>>=	__NR_lws_entries, %r20, %r0
	b,n	lws_exit_nosys

	/* WARNING: Trashing sr2 and sr3 */
	mfsp	%sr7,%r1			/* get userspace into sr3 */
	mtsp	%r1,%sr3
	mtsp	%r0,%sr2			/* get kernel space into sr2 */

	/* Load table start */
	ldil	L%lws_table, %r1
	ldo	R%lws_table(%r1), %r28	/* Scratch use of r28 */
	LDREGX	%r20(%sr2,r28), %r21	/* Scratch use of r21 */

	/* Jump to lws, lws table pointers already relocated */
	be,n	0(%sr2,%r21)

lws_exit_nosys:
	ldo	-ENOSYS(%r0),%r21		   /* set errno */
	/* Fall through: Return to userspace */

lws_exit:
#ifdef CONFIG_64BIT
	/* decide whether to reset the wide mode bit
	 *
	 * For a syscall, the W bit is stored in the lowest bit
	 * of sp.  Extract it and reset W if it is zero */
	extrd,u,*<>	%r30,63,1,%r1
	rsm	PSW_SM_W, %r0
	/* now reset the lowest bit of sp if it was set */
	xor	%r30,%r1,%r30
#endif
	be,n	0(%sr3, %r31)


	/***************************************************
		Implementing CAS as an atomic operation:

		%r26 - Address to examine
		%r25 - Old value to check (old)
		%r24 - New value to set (new)
		%r28 - Return prev through this register.
		%r21 - Kernel error code

		If debugging is DISabled:

		%r21 has the following meanings:

		EAGAIN - CAS is busy, ldcw failed, try again.
		EFAULT - Read or write failed.		

		If debugging is enabled:

		EDEADLOCK - CAS called recursively.
		EAGAIN && r28 == 1 - CAS is busy. Lock contended.
		EAGAIN && r28 == 2 - CAS is busy. ldcw failed.
		EFAULT - Read or write failed.

		Scratch: r20, r28, r1

	****************************************************/

	/* Do not enable LWS debugging */
#define ENABLE_LWS_DEBUG 0 

	/* ELF64 Process entry path */
lws_compare_and_swap64:
#ifdef CONFIG_64BIT
	b,n	lws_compare_and_swap
#else
	/* If we are not a 64-bit kernel, then we don't
	 * implement having 64-bit input registers
	 */
	b,n	lws_exit_nosys
#endif

	/* ELF32 Process entry path */
lws_compare_and_swap32:
#ifdef CONFIG_64BIT
	/* Clip all the input registers */
	depdi	0, 31, 32, %r26
	depdi	0, 31, 32, %r25
	depdi	0, 31, 32, %r24
#endif

lws_compare_and_swap:
#ifdef CONFIG_SMP
	/* Load start of lock table */
	ldil	L%lws_lock_start, %r20
	ldo	R%lws_lock_start(%r20), %r28

	/* Extract four bits from r26 and hash lock (Bits 4-7) */
	extru  %r26, 27, 4, %r20

	/* Find lock to use, the hash is either one of 0 to
	   15, multiplied by 16 (keep it 16-byte aligned)
	   and add to the lock table offset. */
	shlw	%r20, 4, %r20
	add	%r20, %r28, %r20

# if ENABLE_LWS_DEBUG
	/*	
		DEBUG, check for deadlock! 
		If the thread register values are the same
		then we were the one that locked it last and
		this is a recurisve call that will deadlock.
		We *must* giveup this call and fail.
	*/
	ldw	4(%sr2,%r20), %r28			/* Load thread register */
	/* WARNING: If cr27 cycles to the same value we have problems */
	mfctl	%cr27, %r21				/* Get current thread register */
	cmpb,<>,n	%r21, %r28, cas_lock		/* Called recursive? */
	b	lws_exit				/* Return error! */
	ldo	-EDEADLOCK(%r0), %r21
cas_lock:
	cmpb,=,n	%r0, %r28, cas_nocontend	/* Is nobody using it? */
	ldo	1(%r0), %r28				/* 1st case */
	b	lws_exit				/* Contended... */
	ldo	-EAGAIN(%r0), %r21			/* Spin in userspace */
cas_nocontend:
# endif
/* ENABLE_LWS_DEBUG */

	LDCW	0(%sr2,%r20), %r28			/* Try to acquire the lock */
	cmpb,<>,n	%r0, %r28, cas_action		/* Did we get it? */
cas_wouldblock:
	ldo	2(%r0), %r28				/* 2nd case */
	b	lws_exit				/* Contended... */
	ldo	-EAGAIN(%r0), %r21			/* Spin in userspace */
#endif
/* CONFIG_SMP */

	/*
		prev = *addr;
		if ( prev == old )
		  *addr = new;
		return prev;
	*/

	/* NOTES:
		This all works becuse intr_do_signal
		and schedule both check the return iasq
		and see that we are on the kernel page
		so this process is never scheduled off
		or is ever sent any signal of any sort,
		thus it is wholly atomic from usrspaces
		perspective
	*/
cas_action:
#if defined CONFIG_SMP && ENABLE_LWS_DEBUG
	/* DEBUG */
	mfctl	%cr27, %r1
	stw	%r1, 4(%sr2,%r20)
#endif
	/* The load and store could fail */
1:	ldw	0(%sr3,%r26), %r28
	sub,<>	%r28, %r25, %r0
2:	stw	%r24, 0(%sr3,%r26)
#ifdef CONFIG_SMP
	/* Free lock */
	stw	%r20, 0(%sr2,%r20)
# if ENABLE_LWS_DEBUG
	/* Clear thread register indicator */
	stw	%r0, 4(%sr2,%r20)
# endif
#endif
	/* Return to userspace, set no error */
	b	lws_exit
	copy	%r0, %r21

3:		
	/* Error occured on load or store */
#ifdef CONFIG_SMP
	/* Free lock */
	stw	%r20, 0(%sr2,%r20)
# if ENABLE_LWS_DEBUG
	stw	%r0, 4(%sr2,%r20)
# endif
#endif
	b	lws_exit
	ldo	-EFAULT(%r0),%r21	/* set errno */
	nop
	nop
	nop
	nop

	/* Two exception table entries, one for the load,
	   the other for the store. Either return -EFAULT.
	   Each of the entries must be relocated. */
	.section __ex_table,"aw"
	ASM_ULONG_INSN (1b - linux_gateway_page), (3b - linux_gateway_page)
	ASM_ULONG_INSN (2b - linux_gateway_page), (3b - linux_gateway_page)
	.previous


	/* Make sure nothing else is placed on this page */
	.align PAGE_SIZE
END(linux_gateway_page)
ENTRY(end_linux_gateway_page)

	/* Relocate symbols assuming linux_gateway_page is mapped
	   to virtual address 0x0 */

#define LWS_ENTRY(_name_) ASM_ULONG_INSN (lws_##_name_ - linux_gateway_page)

	.section .rodata,"a"

	.align PAGE_SIZE
	/* Light-weight-syscall table */
	/* Start of lws table. */
ENTRY(lws_table)
	LWS_ENTRY(compare_and_swap32)	/* 0 - ELF32 Atomic compare and swap */
	LWS_ENTRY(compare_and_swap64)	/* 1 - ELF64 Atomic compare and swap */
END(lws_table)
	/* End of lws table */

	.align PAGE_SIZE
ENTRY(sys_call_table)
#include "syscall_table.S"
END(sys_call_table)

#ifdef CONFIG_64BIT
	.align PAGE_SIZE
ENTRY(sys_call_table64)
#define SYSCALL_TABLE_64BIT
#include "syscall_table.S"
END(sys_call_table64)
#endif

#ifdef CONFIG_SMP
	/*
		All light-weight-syscall atomic operations 
		will use this set of locks 
	*/
	.section .data
	.align	PAGE_SIZE
ENTRY(lws_lock_start)
	/* lws locks */
	.align 16
	.rept 16
	/* Keep locks aligned at 16-bytes */
	.word 1
	.word 0 
	.word 0
	.word 0
	.endr
END(lws_lock_start)
	.previous
#endif
/* CONFIG_SMP for lws_lock_start */

.end
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Linux/PA-RISC Project (http://www.parisc-linux.org/)
	3	*
	4	* System call entry code Copyright (c) Matthew Wilcox 1999 <willy@bofh.ai>
	5	* Licensed under the GNU GPL.
	6	* thanks to Philipp Rumpf, Mike Shaver and various others
	7	* sorry about the wall, puffin..
	8	*/
	9
0013a854	10	#include <asm/asm-offsets.h>
1da177e4 LT	11	#include <asm/unistd.h>
1da177e4 LT	12	#include <asm/errno.h>
1c593571	13	#include <asm/page.h>
1da177e4 LT	14	#include <asm/psw.h>
1da177e4 LT	15	#include <asm/thread_info.h>
1da177e4 LT	16	#include <asm/assembly.h>
	17	#include <asm/processor.h>
	18
8e9e9844 HD	19	#include <linux/linkage.h>
8e9e9844 HD	20
1da177e4 LT	21	/* We fill the empty parts of the gateway page with
	22	* something that will kill the kernel or a
	23	* userspace application.
	24	*/
	25	#define KILL_INSN break 0,0
	26
0b3d643f	27	.level LEVEL
8e9e9844	28
dfcf753b	29	.text
1da177e4 LT	30
	31	.import syscall_exit,code
	32	.import syscall_exit_rfi,code
1da177e4 LT	33
	34	/* Linux gateway page is aliased to virtual page 0 in the kernel
	35	* address space. Since it is a gateway page it cannot be
	36	* dereferenced, so null pointers will still fault. We start
	37	* the actual entry point at 0x100. We put break instructions
	38	* at the beginning of the page to trap null indirect function
	39	* pointers.
	40	*/
	41
1c593571	42	.align PAGE_SIZE
8e9e9844	43	ENTRY(linux_gateway_page)
1da177e4 LT	44
	45	/* ADDRESS 0x00 to 0xb0 = 176 bytes / 4 bytes per insn = 44 insns */
	46	.rept 44
	47	KILL_INSN
	48	.endr
	49
	50	/* ADDRESS 0xb0 to 0xb4, lws uses 1 insns for entry */
	51	/* Light-weight-syscall entry must always be located at 0xb0 */
	52	/* WARNING: Keep this number updated with table size changes */
	53	#define __NR_lws_entries (2)
	54
	55	lws_entry:
	56	/* Unconditional branch to lws_start, located on the
	57	same gateway page */
	58	b,n lws_start
	59
	60	/* Fill from 0xb4 to 0xe0 */
	61	.rept 11
	62	KILL_INSN
	63	.endr
	64
	65	/* This function MUST be located at 0xe0 for glibc's threading
	66	mechanism to work. DO NOT MOVE THIS CODE EVER! */
	67	set_thread_pointer:
	68	gate .+8, %r0 /* increase privilege */
	69	depi 3, 31, 2, %r31 /* Ensure we return into user mode. */
	70	be 0(%sr7,%r31) /* return to user space */
	71	mtctl %r26, %cr27 /* move arg0 to the control register */
	72
	73	/* Increase the chance of trapping if random jumps occur to this
	74	address, fill from 0xf0 to 0x100 */
	75	.rept 4
	76	KILL_INSN
	77	.endr
	78
	79	/* This address must remain fixed at 0x100 for glibc's syscalls to work */
	80	.align 256
	81	linux_gateway_entry:
	82	gate .+8, %r0 /* become privileged */
	83	mtsp %r0,%sr4 /* get kernel space into sr4 */
	84	mtsp %r0,%sr5 /* get kernel space into sr5 */
	85	mtsp %r0,%sr6 /* get kernel space into sr6 */
	86	mfsp %sr7,%r1 /* save user sr7 */
	87	mtsp %r1,%sr3 /* and store it in sr3 */
	88
413059f2	89	#ifdef CONFIG_64BIT
1da177e4 LT	90	/* for now we can always set the W bit on entry to the syscall
	91	* since we don't support wide userland processes. We could
	92	* also save the current SM other than in r0 and restore it on
	93	* exit from the syscall, and also use that value to know
	94	* whether to do narrow or wide syscalls. -PB
	95	*/
	96	ssm PSW_SM_W, %r1
	97	extrd,u %r1,PSW_W_BIT,1,%r1
	98	/* sp must be aligned on 4, so deposit the W bit setting into
	99	* the bottom of sp temporarily */
	100	or,ev %r1,%r30,%r30
	101	b,n 1f
	102	/* The top halves of argument registers must be cleared on syscall
	103	* entry from narrow executable.
	104	*/
	105	depdi 0, 31, 32, %r26
	106	depdi 0, 31, 32, %r25
	107	depdi 0, 31, 32, %r24
	108	depdi 0, 31, 32, %r23
	109	depdi 0, 31, 32, %r22
	110	depdi 0, 31, 32, %r21
	111	1:
	112	#endif
	113	mfctl %cr30,%r1
	114	xor %r1,%r30,%r30 /* ye olde xor trick */
	115	xor %r1,%r30,%r1
	116	xor %r1,%r30,%r30
	117
	118	ldo THREAD_SZ_ALGN+FRAME_SIZE(%r30),%r30 /* set up kernel stack */
	119
	120	/* N.B.: It is critical that we don't set sr7 to 0 until r30
	121	* contains a valid kernel stack pointer. It is also
	122	* critical that we don't start using the kernel stack
	123	* until after sr7 has been set to 0.
	124	*/
	125
	126	mtsp %r0,%sr7 /* get kernel space into sr7 */
	127	STREGM %r1,FRAME_SIZE(%r30) /* save r1 (usp) here for now */
	128	mfctl %cr30,%r1 /* get task ptr in %r1 */
	129	LDREG TI_TASK(%r1),%r1
	130
	131	/* Save some registers for sigcontext and potential task
	132	switch (see entry.S for the details of which ones are
	133	saved/restored). TASK_PT_PSW is zeroed so we can see whether
	134	a process is on a syscall or not. For an interrupt the real
	135	PSW value is stored. This is needed for gdb and sys_ptrace. */
	136	STREG %r0, TASK_PT_PSW(%r1)
	137	STREG %r2, TASK_PT_GR2(%r1) /* preserve rp */
	138	STREG %r19, TASK_PT_GR19(%r1)
	139
	140	LDREGM -FRAME_SIZE(%r30), %r2 /* get users sp back */
413059f2	141	#ifdef CONFIG_64BIT
1da177e4 LT	142	extrd,u %r2,63,1,%r19 /* W hidden in bottom bit */
	143	#if 0
	144	xor %r19,%r2,%r2 /* clear bottom bit */
	145	depd,z %r19,1,1,%r19
	146	std %r19,TASK_PT_PSW(%r1)
	147	#endif
	148	#endif
	149	STREG %r2, TASK_PT_GR30(%r1) /* ... and save it */
	150
aa0eecb0	151	STREG %r20, TASK_PT_GR20(%r1) /* Syscall number */
1da177e4 LT	152	STREG %r21, TASK_PT_GR21(%r1)
	153	STREG %r22, TASK_PT_GR22(%r1)
	154	STREG %r23, TASK_PT_GR23(%r1) /* 4th argument */
	155	STREG %r24, TASK_PT_GR24(%r1) /* 3rd argument */
	156	STREG %r25, TASK_PT_GR25(%r1) /* 2nd argument */
	157	STREG %r26, TASK_PT_GR26(%r1) /* 1st argument */
	158	STREG %r27, TASK_PT_GR27(%r1) /* user dp */
	159	STREG %r28, TASK_PT_GR28(%r1) /* return value 0 */
	160	STREG %r28, TASK_PT_ORIG_R28(%r1) /* return value 0 (saved for signals) */
	161	STREG %r29, TASK_PT_GR29(%r1) /* return value 1 */
	162	STREG %r31, TASK_PT_GR31(%r1) /* preserve syscall return ptr */
	163
	164	ldo TASK_PT_FR0(%r1), %r27 /* save fpregs from the kernel */
	165	save_fp %r27 /* or potential task switch */
	166
	167	mfctl %cr11, %r27 /* i.e. SAR */
	168	STREG %r27, TASK_PT_SAR(%r1)
	169
	170	loadgp
	171
413059f2	172	#ifdef CONFIG_64BIT
1da177e4 LT	173	ldo -16(%r30),%r29 /* Reference param save area */
	174	copy %r19,%r2 /* W bit back to r2 */
	175	#else
	176	/* no need to save these on stack in wide mode because the first 8
	177	* args are passed in registers */
	178	stw %r22, -52(%r30) /* 5th argument */
	179	stw %r21, -56(%r30) /* 6th argument */
	180	#endif
	181
	182	/* Are we being ptraced? */
	183	mfctl %cr30, %r1
	184	LDREG TI_TASK(%r1),%r1
376e210b	185	ldw TASK_PTRACE(%r1), %r1
1da177e4 LT	186	bb,<,n %r1,31,.Ltracesys
	187
	188	/* Note! We cannot use the syscall table that is mapped
	189	nearby since the gateway page is mapped execute-only. */
	190
413059f2	191	#ifdef CONFIG_64BIT
1da177e4 LT	192	ldil L%sys_call_table, %r1
	193	or,= %r2,%r2,%r2
	194	addil L%(sys_call_table64-sys_call_table), %r1
	195	ldo R%sys_call_table(%r1), %r19
	196	or,= %r2,%r2,%r2
	197	ldo R%sys_call_table64(%r1), %r19
	198	#else
	199	ldil L%sys_call_table, %r1
	200	ldo R%sys_call_table(%r1), %r19
	201	#endif
3bb457af	202	comiclr,>> __NR_Linux_syscalls, %r20, %r0
1da177e4 LT	203	b,n .Lsyscall_nosys
	204
	205	LDREGX %r20(%r19), %r19
	206
	207	/* If this is a sys_rt_sigreturn call, and the signal was received
	208	* when not in_syscall, then we want to return via syscall_exit_rfi,
	209	* not syscall_exit. Signal no. in r20, in_syscall in r25 (see
	210	* trampoline code in signal.c).
	211	*/
	212	ldi __NR_rt_sigreturn,%r2
	213	comb,= %r2,%r20,.Lrt_sigreturn
	214	.Lin_syscall:
	215	ldil L%syscall_exit,%r2
	216	be 0(%sr7,%r19)
	217	ldo R%syscall_exit(%r2),%r2
	218	.Lrt_sigreturn:
	219	comib,<> 0,%r25,.Lin_syscall
	220	ldil L%syscall_exit_rfi,%r2
	221	be 0(%sr7,%r19)
	222	ldo R%syscall_exit_rfi(%r2),%r2
	223
	224	/* Note! Because we are not running where we were linked, any
	225	calls to functions external to this file must be indirect. To
	226	be safe, we apply the opposite rule to functions within this
	227	file, with local labels given to them to ensure correctness. */
	228
	229	.Lsyscall_nosys:
	230	syscall_nosys:
	231	ldil L%syscall_exit,%r1
	232	be R%syscall_exit(%sr7,%r1)
	233	ldo -ENOSYS(%r0),%r28 /* set errno */
	234
	235
	236	/* Warning! This trace code is a virtual duplicate of the code above so be
	237	* sure to maintain both! */
	238	.Ltracesys:
	239	tracesys:
	240	/* Need to save more registers so the debugger can see where we
	241	* are. This saves only the lower 8 bits of PSW, so that the C
	242	* bit is still clear on syscalls, and the D bit is set if this
	243	* full register save path has been executed. We check the D
	244	* bit on syscall_return_rfi to determine which registers to
	245	* restore. An interrupt results in a full PSW saved with the
	246	* C bit set, a non-straced syscall entry results in C and D clear
	247	* in the saved PSW.
	248	*/
	249	ldo -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get task ptr */
	250	LDREG TI_TASK(%r1), %r1
	251	ssm 0,%r2
	252	STREG %r2,TASK_PT_PSW(%r1) /* Lower 8 bits only!! */
	253	mfsp %sr0,%r2
	254	STREG %r2,TASK_PT_SR0(%r1)
	255	mfsp %sr1,%r2
	256	STREG %r2,TASK_PT_SR1(%r1)
	257	mfsp %sr2,%r2
	258	STREG %r2,TASK_PT_SR2(%r1)
	259	mfsp %sr3,%r2
	260	STREG %r2,TASK_PT_SR3(%r1)
	261	STREG %r2,TASK_PT_SR4(%r1)
	262	STREG %r2,TASK_PT_SR5(%r1)
	263	STREG %r2,TASK_PT_SR6(%r1)
	264	STREG %r2,TASK_PT_SR7(%r1)
	265	STREG %r2,TASK_PT_IASQ0(%r1)
	266	STREG %r2,TASK_PT_IASQ1(%r1)
267	LDREG TASK_PT_GR31(%r1),%r2
268	STREG %r2,TASK_PT_IAOQ0(%r1)
269	ldo 4(%r2),%r2
270	STREG %r2,TASK_PT_IAOQ1(%r1)
271	ldo TASK_REGS(%r1),%r2
272	/* reg_save %r2 */
273	STREG %r3,PT_GR3(%r2)
274	STREG %r4,PT_GR4(%r2)
275	STREG %r5,PT_GR5(%r2)
276	STREG %r6,PT_GR6(%r2)
277	STREG %r7,PT_GR7(%r2)
278	STREG %r8,PT_GR8(%r2)
279	STREG %r9,PT_GR9(%r2)
280	STREG %r10,PT_GR10(%r2)
281	STREG %r11,PT_GR11(%r2)
282	STREG %r12,PT_GR12(%r2)
283	STREG %r13,PT_GR13(%r2)
284	STREG %r14,PT_GR14(%r2)
285	STREG %r15,PT_GR15(%r2)
286	STREG %r16,PT_GR16(%r2)
287	STREG %r17,PT_GR17(%r2)
288	STREG %r18,PT_GR18(%r2)
289	/* Finished saving things for the debugger */
290
291	ldil L%syscall_trace,%r1
292	ldil L%tracesys_next,%r2
293	be R%syscall_trace(%sr7,%r1)
294	ldo R%tracesys_next(%r2),%r2
295
296	tracesys_next:
297	ldil L%sys_call_table,%r1
298	ldo R%sys_call_table(%r1), %r19
299
300	ldo -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get task ptr */
301	LDREG TI_TASK(%r1), %r1
302	LDREG TASK_PT_GR20(%r1), %r20
303	LDREG TASK_PT_GR26(%r1), %r26 /* Restore the users args */
304	LDREG TASK_PT_GR25(%r1), %r25
305	LDREG TASK_PT_GR24(%r1), %r24
306	LDREG TASK_PT_GR23(%r1), %r23
413059f2	307	#ifdef CONFIG_64BIT
1da177e4 LT	308	LDREG TASK_PT_GR22(%r1), %r22
	309	LDREG TASK_PT_GR21(%r1), %r21
	310	ldo -16(%r30),%r29 /* Reference param save area */
	311	#endif
	312
	313	comiclr,>>= __NR_Linux_syscalls, %r20, %r0
	314	b,n .Lsyscall_nosys
	315
	316	LDREGX %r20(%r19), %r19
	317
	318	/* If this is a sys_rt_sigreturn call, and the signal was received
	319	* when not in_syscall, then we want to return via syscall_exit_rfi,
	320	* not syscall_exit. Signal no. in r20, in_syscall in r25 (see
	321	* trampoline code in signal.c).
	322	*/
	323	ldi __NR_rt_sigreturn,%r2
	324	comb,= %r2,%r20,.Ltrace_rt_sigreturn
	325	.Ltrace_in_syscall:
	326	ldil L%tracesys_exit,%r2
	327	be 0(%sr7,%r19)
	328	ldo R%tracesys_exit(%r2),%r2
	329
	330	/* Do not call this function on the gateway page, because it
	331	makes a direct call to syscall_trace. */
	332
	333	tracesys_exit:
	334	ldo -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get task ptr */
	335	LDREG TI_TASK(%r1), %r1
413059f2	336	#ifdef CONFIG_64BIT
1da177e4 LT	337	ldo -16(%r30),%r29 /* Reference param save area */
	338	#endif
	339	bl syscall_trace, %r2
	340	STREG %r28,TASK_PT_GR28(%r1) /* save return value now */
	341	ldo -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get task ptr */
	342	LDREG TI_TASK(%r1), %r1
	343	LDREG TASK_PT_GR28(%r1), %r28 /* Restore return val. */
	344
	345	ldil L%syscall_exit,%r1
	346	be,n R%syscall_exit(%sr7,%r1)
	347
	348	.Ltrace_rt_sigreturn:
	349	comib,<> 0,%r25,.Ltrace_in_syscall
	350	ldil L%tracesys_sigexit,%r2
	351	be 0(%sr7,%r19)
	352	ldo R%tracesys_sigexit(%r2),%r2
	353
	354	tracesys_sigexit:
	355	ldo -THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get task ptr */
	356	LDREG 0(%r1), %r1
413059f2	357	#ifdef CONFIG_64BIT
1da177e4 LT	358	ldo -16(%r30),%r29 /* Reference param save area */
	359	#endif
	360	bl syscall_trace, %r2
	361	nop
	362
	363	ldil L%syscall_exit_rfi,%r1
	364	be,n R%syscall_exit_rfi(%sr7,%r1)
	365
	366
	367	/*********************************************************
	368	Light-weight-syscall code
	369
	370	r20 - lws number
	371	r26,r25,r24,r23,r22 - Input registers
	372	r28 - Function return register
	373	r21 - Error code.
	374
	375	Scracth: Any of the above that aren't being
	376	currently used, including r1.
	377
	378	Return pointer: r31 (Not usable)
	379
	380	Error codes returned by entry path:
	381
	382	ENOSYS - r20 was an invalid LWS number.
	383
	384	*********************************************************/
	385	lws_start:
	386	/* Gate and ensure we return to userspace */
	387	gate .+8, %r0
	388	depi 3, 31, 2, %r31 /* Ensure we return to userspace */
	389
413059f2	390	#ifdef CONFIG_64BIT
1da177e4 LT	391	/* FIXME: If we are a 64-bit kernel just
	392	* turn this on unconditionally.
	393	*/
	394	ssm PSW_SM_W, %r1
	395	extrd,u %r1,PSW_W_BIT,1,%r1
	396	/* sp must be aligned on 4, so deposit the W bit setting into
	397	* the bottom of sp temporarily */
	398	or,ev %r1,%r30,%r30
	399
	400	/* Clip LWS number to a 32-bit value always */
	401	depdi 0, 31, 32, %r20
	402	#endif
	403
	404	/* Is the lws entry number valid? */
	405	comiclr,>>= __NR_lws_entries, %r20, %r0
	406	b,n lws_exit_nosys
	407
	408	/* WARNING: Trashing sr2 and sr3 */
	409	mfsp %sr7,%r1 /* get userspace into sr3 */
	410	mtsp %r1,%sr3
	411	mtsp %r0,%sr2 /* get kernel space into sr2 */
	412
	413	/* Load table start */
	414	ldil L%lws_table, %r1
	415	ldo R%lws_table(%r1), %r28 /* Scratch use of r28 */
	416	LDREGX %r20(%sr2,r28), %r21 /* Scratch use of r21 */
	417
	418	/* Jump to lws, lws table pointers already relocated */
	419	be,n 0(%sr2,%r21)
	420
	421	lws_exit_nosys:
	422	ldo -ENOSYS(%r0),%r21 /* set errno */
	423	/* Fall through: Return to userspace */
	424
	425	lws_exit:
413059f2	426	#ifdef CONFIG_64BIT
1da177e4 LT	427	/* decide whether to reset the wide mode bit
	428	*
	429	* For a syscall, the W bit is stored in the lowest bit
	430	* of sp. Extract it and reset W if it is zero */
	431	extrd,u,*<> %r30,63,1,%r1
	432	rsm PSW_SM_W, %r0
	433	/* now reset the lowest bit of sp if it was set */
	434	xor %r30,%r1,%r30
	435	#endif
	436	be,n 0(%sr3, %r31)
	437
	438
	439
	440	/***************************************************
	441	Implementing CAS as an atomic operation:
	442
	443	%r26 - Address to examine
	444	%r25 - Old value to check (old)
	445	%r24 - New value to set (new)
	446	%r28 - Return prev through this register.
	447	%r21 - Kernel error code
	448
	449	If debugging is DISabled:
	450
	451	%r21 has the following meanings:
	452
	453	EAGAIN - CAS is busy, ldcw failed, try again.
	454	EFAULT - Read or write failed.
	455
	456	If debugging is enabled:
	457
	458	EDEADLOCK - CAS called recursively.
	459	EAGAIN && r28 == 1 - CAS is busy. Lock contended.
	460	EAGAIN && r28 == 2 - CAS is busy. ldcw failed.
	461	EFAULT - Read or write failed.
	462
	463	Scratch: r20, r28, r1
	464
	465	****************************************************/
	466
	467	/* Do not enable LWS debugging */
	468	#define ENABLE_LWS_DEBUG 0
	469
	470	/* ELF64 Process entry path */
	471	lws_compare_and_swap64:
413059f2	472	#ifdef CONFIG_64BIT
1da177e4 LT	473	b,n lws_compare_and_swap
	474	#else
	475	/* If we are not a 64-bit kernel, then we don't
	476	* implement having 64-bit input registers
	477	*/
	478	b,n lws_exit_nosys
	479	#endif
	480
	481	/* ELF32 Process entry path */
	482	lws_compare_and_swap32:
413059f2	483	#ifdef CONFIG_64BIT
1da177e4 LT	484	/* Clip all the input registers */
	485	depdi 0, 31, 32, %r26
	486	depdi 0, 31, 32, %r25
	487	depdi 0, 31, 32, %r24
	488	#endif
	489
	490	lws_compare_and_swap:
	491	#ifdef CONFIG_SMP
	492	/* Load start of lock table */
	493	ldil L%lws_lock_start, %r20
	494	ldo R%lws_lock_start(%r20), %r28
	495
	496	/* Extract four bits from r26 and hash lock (Bits 4-7) */
	497	extru %r26, 27, 4, %r20
	498
	499	/* Find lock to use, the hash is either one of 0 to
	500	15, multiplied by 16 (keep it 16-byte aligned)
	501	and add to the lock table offset. */
	502	shlw %r20, 4, %r20
	503	add %r20, %r28, %r20
	504
b5e8b733	505	# if ENABLE_LWS_DEBUG
1da177e4 LT	506	/*
	507	DEBUG, check for deadlock!
	508	If the thread register values are the same
	509	then we were the one that locked it last and
	510	this is a recurisve call that will deadlock.
	511	We must giveup this call and fail.
	512	*/
	513	ldw 4(%sr2,%r20), %r28 /* Load thread register */
aa0eecb0	514	/* WARNING: If cr27 cycles to the same value we have problems */
1da177e4 LT	515	mfctl %cr27, %r21 /* Get current thread register */
	516	cmpb,<>,n %r21, %r28, cas_lock /* Called recursive? */
	517	b lws_exit /* Return error! */
	518	ldo -EDEADLOCK(%r0), %r21
	519	cas_lock:
	520	cmpb,=,n %r0, %r28, cas_nocontend /* Is nobody using it? */
	521	ldo 1(%r0), %r28 /* 1st case */
	522	b lws_exit /* Contended... */
	523	ldo -EAGAIN(%r0), %r21 /* Spin in userspace */
	524	cas_nocontend:
	525	# endif
	526	/* ENABLE_LWS_DEBUG */
	527
64f49532	528	LDCW 0(%sr2,%r20), %r28 /* Try to acquire the lock */
1da177e4 LT	529	cmpb,<>,n %r0, %r28, cas_action /* Did we get it? */
	530	cas_wouldblock:
	531	ldo 2(%r0), %r28 /* 2nd case */
	532	b lws_exit /* Contended... */
	533	ldo -EAGAIN(%r0), %r21 /* Spin in userspace */
	534	#endif
	535	/* CONFIG_SMP */
	536
	537	/*
	538	prev = *addr;
	539	if ( prev == old )
	540	*addr = new;
	541	return prev;
	542	*/
	543
	544	/* NOTES:
	545	This all works becuse intr_do_signal
	546	and schedule both check the return iasq
	547	and see that we are on the kernel page
	548	so this process is never scheduled off
	549	or is ever sent any signal of any sort,
	550	thus it is wholly atomic from usrspaces
	551	perspective
	552	*/
	553	cas_action:
b5e8b733	554	#if defined CONFIG_SMP && ENABLE_LWS_DEBUG
1da177e4 LT	555	/* DEBUG */
	556	mfctl %cr27, %r1
	557	stw %r1, 4(%sr2,%r20)
	558	#endif
	559	/* The load and store could fail */
	560	1: ldw 0(%sr3,%r26), %r28
	561	sub,<> %r28, %r25, %r0
	562	2: stw %r24, 0(%sr3,%r26)
	563	#ifdef CONFIG_SMP
	564	/* Free lock */
	565	stw %r20, 0(%sr2,%r20)
b5e8b733	566	# if ENABLE_LWS_DEBUG
1da177e4 LT	567	/* Clear thread register indicator */
	568	stw %r0, 4(%sr2,%r20)
	569	# endif
	570	#endif
	571	/* Return to userspace, set no error */
	572	b lws_exit
	573	copy %r0, %r21
	574
	575	3:
	576	/* Error occured on load or store */
	577	#ifdef CONFIG_SMP
	578	/* Free lock */
	579	stw %r20, 0(%sr2,%r20)
b5e8b733	580	# if ENABLE_LWS_DEBUG
1da177e4 LT	581	stw %r0, 4(%sr2,%r20)
	582	# endif
	583	#endif
	584	b lws_exit
	585	ldo -EFAULT(%r0),%r21 /* set errno */
	586	nop
	587	nop
	588	nop
	589	nop
	590
	591	/* Two exception table entries, one for the load,
	592	the other for the store. Either return -EFAULT.
	593	Each of the entries must be relocated. */
	594	.section __ex_table,"aw"
0b3d643f HD	595	ASM_ULONG_INSN (1b - linux_gateway_page), (3b - linux_gateway_page)
0b3d643f HD	596	ASM_ULONG_INSN (2b - linux_gateway_page), (3b - linux_gateway_page)
1da177e4 LT	597	.previous
1da177e4 LT	598
1da177e4 LT	599
1da177e4 LT	600	/* Make sure nothing else is placed on this page */
1c593571	601	.align PAGE_SIZE
8e9e9844 HD	602	END(linux_gateway_page)
8e9e9844 HD	603	ENTRY(end_linux_gateway_page)
1da177e4 LT	604
	605	/* Relocate symbols assuming linux_gateway_page is mapped
	606	to virtual address 0x0 */
8e9e9844	607
0b3d643f	608	#define LWS_ENTRY(_name_) ASM_ULONG_INSN (lws_##_name_ - linux_gateway_page)
1da177e4	609
1bcdd854 HD	610	.section .rodata,"a"
1bcdd854 HD	611
1c593571	612	.align PAGE_SIZE
1da177e4 LT	613	/* Light-weight-syscall table */
1da177e4 LT	614	/* Start of lws table. */
8e9e9844	615	ENTRY(lws_table)
1da177e4 LT	616	LWS_ENTRY(compare_and_swap32) /* 0 - ELF32 Atomic compare and swap */
1da177e4 LT	617	LWS_ENTRY(compare_and_swap64) /* 1 - ELF64 Atomic compare and swap */
8e9e9844	618	END(lws_table)
1da177e4 LT	619	/* End of lws table */
1da177e4 LT	620
1c593571	621	.align PAGE_SIZE
8e9e9844	622	ENTRY(sys_call_table)
1da177e4	623	#include "syscall_table.S"
8e9e9844	624	END(sys_call_table)
1da177e4	625
413059f2	626	#ifdef CONFIG_64BIT
1c593571	627	.align PAGE_SIZE
8e9e9844	628	ENTRY(sys_call_table64)
1da177e4 LT	629	#define SYSCALL_TABLE_64BIT
1da177e4 LT	630	#include "syscall_table.S"
8e9e9844	631	END(sys_call_table64)
1da177e4 LT	632	#endif
	633
	634	#ifdef CONFIG_SMP
	635	/*
	636	All light-weight-syscall atomic operations
	637	will use this set of locks
	638	*/
dfcf753b	639	.section .data
873d50e2	640	.align PAGE_SIZE
8e9e9844	641	ENTRY(lws_lock_start)
1da177e4 LT	642	/* lws locks */
	643	.align 16
	644	.rept 16
	645	/* Keep locks aligned at 16-bytes */
	646	.word 1
	647	.word 0
	648	.word 0
	649	.word 0
	650	.endr
8e9e9844	651	END(lws_lock_start)
1da177e4 LT	652	.previous
	653	#endif
	654	/* CONFIG_SMP for lws_lock_start */
	655
	656	.end
	657
	658