
/*--------------------------------------------------------------------*/
/*--- Support for doing system calls.        syscall-x86-solaris.S ---*/
/*--------------------------------------------------------------------*/

/*
  This file is part of Valgrind, a dynamic binary instrumentation
  framework.

  Copyright (C) 2011-2015 Petr Pavlu
     setup@dagobah.cz

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  02111-1307, USA.

  The GNU General Public License is contained in the file COPYING.
*/

#include "pub_core_basics_asm.h"

#if defined(VGP_x86_solaris)

#include "pub_core_vkiscnums_asm.h"
#include "libvex_guest_offsets.h"

/* From vki-solaris.h, checked at startup by m_vki.c. */
#define VKI_SIG_SETMASK 3

/* Prototype:
   Int ML_(do_syscall_for_client_WRK)(
      Int syscallno,			// %ebp+8
      void *guest_state,		// %ebp+12
      const vki_sigset_t *sysmask,	// %ebp+16
      const vki_sigset_t *postmask,	// %ebp+20
      UChar *cflag)			// %ebp+24
*/

.macro ESTABLISH_STACKFRAME
	/* Establish stack frame. */
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%ebx				/* save %ebx */

	/* We'll use %ebx instead of %ebp to address the stack frame after the
	   door syscall is finished because %ebp is cleared by the syscall. */
	movl	%esp, %ebx			/* %ebx = %ebp - 4 */
.endm

.macro UNBLOCK_SIGNALS
	/* Set the signal mask which should be current during the syscall. */
	/* Set up for sigprocmask(SIG_SETMASK, sysmask, postmask). */
	pushl	20(%ebp)
	pushl	16(%ebp)
	pushl	$VKI_SIG_SETMASK
	pushl	$0xcafebabe			/* totally fake return address */
	movl	$__NR_sigprocmask, %eax
	int	$0x91
	jc	sigprocmask_failed		/* sigprocmask failed */
	addl	$16, %esp
.endm

.macro REBLOCK_SIGNALS
	/* Set up for sigprocmask(SIG_SETMASK, postmask, NULL). */
	pushl	$0
	pushl	20(%ebp)
	pushl	$VKI_SIG_SETMASK
	pushl	$0xcafef00d			/* totally fake return address */
	movl	$__NR_sigprocmask, %eax
	int	$0x91
	/* The syscall above changes the carry flag.  This means that if the
	   syscall fails and we receive an interrupt after it then we've got
	   an invalid carry flag value in the fixup code.  We don't care about
	   it because this syscall should never fail and if it does then we're
	   going to stop Valgrind anyway. */
	jc	sigprocmask_failed		/* sigprocmask failed */
	addl	$16, %esp
.endm

.macro SIMPLE_RETURN
	xorl	%eax, %eax			/* SUCCESS */
	movl	-4(%ebp), %ebx			/* restore %ebx */
	movl	%ebp, %esp
	popl	%ebp
	ret
.endm

sigprocmask_failed:
	/* Failure: return 0x8000 | error code. */
	/* Note that we enter here with %esp being 16 too low (4 extra words
	   on the stack).  But because we're nuking the stack frame now, that
	   doesn't matter. */
	andl	$0x7FFF, %eax
	orl	$0x8000, %eax
	movl	-4(%ebp), %ebx			/* restore %ebx */
	movl	%ebp, %esp
	popl	%ebp
	ret

.globl ML_(do_syscall_for_client_WRK)
ML_(do_syscall_for_client_WRK):
	ESTABLISH_STACKFRAME

1:	/* Even though we can't take a signal until the sigprocmask completes,
	   start the range early.  If %eip is in the range [1, 2), the syscall
	   hasn't been started yet. */
	UNBLOCK_SIGNALS

	/* Copy syscall parameters to the stack - assume no more than 8 plus
	   the return address. */
	/* do_syscall8 */
	movl	12(%ebp), %edx
	movl	OFFSET_x86_ESP(%edx), %edx	/* %edx = simulated ESP */
	movl	28+4(%edx), %eax
	pushl	%eax
	movl	24+4(%edx), %eax
	pushl	%eax
	movl	20+4(%edx), %eax
	pushl	%eax
	movl	16+4(%edx), %eax
	pushl	%eax
	movl	12+4(%edx), %eax
	pushl	%eax
	movl	8+4(%edx), %eax
	pushl	%eax
	movl	4+4(%edx), %eax
	pushl	%eax
	movl	0+4(%edx), %eax
	pushl	%eax
	/* Return address. */
	movl	0(%edx), %eax
	pushl	%eax

	/* Put syscall number in %eax. */
	movl	8(%ebp), %eax

	/* Do the syscall.  Note that the Solaris kernel doesn't directly
	   restart syscalls! */
	int	$0x91

2:	/* In the range [2, 3), the syscall result is in %eax and %edx and C,
	   but hasn't been committed to the thread state.  If we get
	   interrupted in this section then we'll just use values saved in the
	   ucontext structure.

	   Important note for this and the following section: Don't add here
	   any code that alters the carry flag or worse, call any function.
	   That would completely break the fixup after an interrupt. */
	movl	12(%ebp), %ecx
	movl	%eax, OFFSET_x86_EAX(%ecx)	/* save %eax to VEX */
	movl	%edx, OFFSET_x86_EDX(%ecx)	/* save %edx to VEX */
	movl	24(%ebp), %ecx
	setc	0(%ecx)				/* save returned carry flag */

3:	/* Re-block signals. If %eip is in [3, 4), then the syscall is
	   complete and we do not need to worry about it.  We have to only
	   correctly save the carry flag.  If we get interrupted in this
	   section then we just have to propagate the carry flag from the
	   ucontext structure to the thread state, %eax and %edx values are
	   already saved. */
	REBLOCK_SIGNALS

4:	/* Now safe from signals. */
	SIMPLE_RETURN

.section .rodata
/* Export the ranges so that
   VG_(fixup_guest_state_after_syscall_interrupted) can do the right thing. */

.globl ML_(blksys_setup)
.globl ML_(blksys_complete)
.globl ML_(blksys_committed)
.globl ML_(blksys_finished)
ML_(blksys_setup):	.long 1b
ML_(blksys_complete):	.long 2b
ML_(blksys_committed):	.long 3b
ML_(blksys_finished):	.long 4b
.previous

/* Prototype:
   Int ML_(do_syscall_for_client_dret_WRK)(
      Int syscallno,			// %ebp+8 = %ebx+8+4
      void *guest_state,		// %ebp+12 = %ebx+12+4
      const vki_sigset_t *sysmask,	// %ebp+16 = %ebx+16+4
      const vki_sigset_t *postmask,	// %ebp+20 = %ebx+20+4
      UChar *cflag)			// %ebp+24 = %ebx+24+4
*/

/* Door_return is a very special call because the data are stored by the
   kernel directly on the stack and the stack pointer is appropriately
   modified by the kernel.  Therefore we switch to the client stack before
   doing the syscall, this is relatively trivial but an extra care has to be
   taken when we get interrupted at some point. */

.globl ML_(do_syscall_for_client_dret_WRK)
ML_(do_syscall_for_client_dret_WRK):
	ESTABLISH_STACKFRAME

1:	/* Even though we can't take a signal until the sigprocmask completes,
	   start the range early.  If %eip is in the range [1, 2), the syscall
	   hasn't been started yet. */
	UNBLOCK_SIGNALS

	/* Switch to the client stack. */
	movl	12(%ebp), %edx
	movl	OFFSET_x86_ESP(%edx), %esp	/* %esp = simulated ESP */
	/* Change %ebp to a client value. It will always get committed by
	   the fixup code for range [2, 3) so it needs to be set to what the
	   client expects. */
	movl	OFFSET_x86_EBP(%edx), %ebp	/* %ebp = simulated EBP */

	/* Put syscall number in %eax. */
	movl	8+4(%ebx), %eax

	/* Do the syscall.  Note that the Solaris kernel doesn't directly
	   restart syscalls! */
	int	$0x91

2:	/* In the range [2, 3), the syscall result is in %eax, %edx, %esp and
	   %ebp and C, but hasn't been committed to the thread state.  If we
	   get interrupted in this section then we'll just use values saved in
	   the ucontext structure.

	   Important note for this and the following section: Don't add here
	   any code that alters the carry flag or worse, call any function.
	   That would completely break the fixup after an interrupt. */
	movl	12+4(%ebx), %ecx
	movl	%eax, OFFSET_x86_EAX(%ecx)	/* save %eax to VEX */
	movl	%edx, OFFSET_x86_EDX(%ecx)	/* save %edx to VEX */
	movl	%esp, OFFSET_x86_ESP(%ecx)	/* save %esp to VEX */
	movl	%ebp, OFFSET_x86_EBP(%ecx)	/* save %ebp to VEX */
	movl	24+4(%ebx), %ecx
	setc	0(%ecx)				/* save returned carry flag */

	movl	%ebx, %esp			/* switch to V stack */

3:	/* Re-block signals. If %eip is in [3, 4), then the syscall is
	   complete and we do not need worry about it.  We have to only
	   correctly save the carry flag.  If we get interrupted in this
	   section then we just have to propagate the carry flag from the
	   ucontext structure to the thread state, %eax, %edx, %esp and %ebp
	   values are already saved. */
	movl	%ebx, %ebp
	addl	$4, %ebp
	REBLOCK_SIGNALS

4:	/* Now safe from signals. */
	SIMPLE_RETURN

.section .rodata
.globl ML_(blksys_setup_DRET)
.globl ML_(blksys_complete_DRET)
.globl ML_(blksys_committed_DRET)
.globl ML_(blksys_finished_DRET)
ML_(blksys_setup_DRET):		.long 1b
ML_(blksys_complete_DRET):	.long 2b
ML_(blksys_committed_DRET):	.long 3b
ML_(blksys_finished_DRET):	.long 4b
.previous

#endif // defined(VGP_x86_solaris)

/* Let the linker know we don't need an executable stack */
MARK_STACK_NO_EXEC

/*--------------------------------------------------------------------*/
/*--- end                                                          ---*/
/*--------------------------------------------------------------------*/