/*
* 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.
*/
#include <brand_misc.h>
/*
* Each JMP must occupy 16 bytes
*/
#define JMP \
pushl $_CONST(. - brand_handler_table); \
jmp brand_handler; \
.align 16;
#define JMP4 JMP; JMP; JMP; JMP
#define JMP16 JMP4; JMP4; JMP4; JMP4
#define JMP64 JMP16; JMP16; JMP16; JMP16
#define JMP256 JMP64; JMP64; JMP64; JMP64
#if defined(lint)
void
brand_handler_table(void)
{}
void
brand_handler(void)
{
}
#else /* lint */
/*
* On entry to this table, %eax will hold the return address. The
* location where we enter the table is a function of the system
* call number. The table needs the same alignment as the individual
* entries.
*/
.align 16
ENTRY_NP(brand_handler_table)
JMP256
SET_SIZE(brand_handler_table)
#define PIC_SETUP(r) \
call 9f; \
9: \
popl r; \
addl $_GLOBAL_OFFSET_TABLE_ + [. - 9b], r
/*
* %eax - userland return address
* stack contains:
* | --------------------------------------
* v 4 | syscall arguments |
* %esp+0 | syscall number |
* --------------------------------------
*/
ENTRY_NP(brand_handler)
pushl %ebp /* allocate a stack frame */
movl %esp, %ebp
/* Save registers at the time of the syscall. */
movl $0, EH_LOCALS_GREG(TRAPNO)(%ebp)
movl $0, EH_LOCALS_GREG(ERR)(%ebp)
movl %ebx, EH_LOCALS_GREG(EBX)(%ebp)
movl %ecx, EH_LOCALS_GREG(ECX)(%ebp)
movl %edx, EH_LOCALS_GREG(EDX)(%ebp)
movl %edi, EH_LOCALS_GREG(EDI)(%ebp)
movl %esi, EH_LOCALS_GREG(ESI)(%ebp)
mov %cs, EH_LOCALS_GREG(CS)(%ebp)
mov %ds, EH_LOCALS_GREG(DS)(%ebp)
mov %es, EH_LOCALS_GREG(ES)(%ebp)
mov %fs, EH_LOCALS_GREG(FS)(%ebp)
mov %gs, EH_LOCALS_GREG(GS)(%ebp)
pushfl /* save syscall flags */
popl %ecx
movl %ecx, EH_LOCALS_GREG(EFL)(%ebp)
movl EH_ARGS_OFFSET(0)(%ebp), %ecx /* save syscall ebp */
movl %ecx, EH_LOCALS_GREG(EBP)(%ebp)
movl %ebp, %ecx /* save syscall esp */
addl $CPTRSIZE, %ecx
movl %ecx, EH_LOCALS_GREG(ESP)(%ebp)
/*
* The kernel drops us into the middle of the brand_handle_table
* above that then pushes that table offset onto the stack, and calls
* into brand_handler. That offset indicates the system call number
* while %eax holds the return address for the system call. We replace
* the value on the stack with the return address, and use the value to
* compute the system call number by dividing by the table entry size.
*/
xchgl CPTRSIZE(%ebp), %eax /* swap JMP table offset and ret addr */
shrl $4, %eax /* table_offset/size = syscall num */
movl %eax, EH_LOCALS_GREG(EAX)(%ebp) /* save syscall num */
/*
* Finish setting up our stack frame. We would normally do this
* upon entry to this function, but in this case we delayed it
* because a "sub" operation can modify flags and we wanted to
* save the flags into the gregset_t above before they get modified.
*
* Our stack frame format is documented in brand_misc.h.
*/
subl $EH_LOCALS_SIZE, %esp
/* Look up the system call's entry in the sysent table */
PIC_SETUP(%ecx)
movl brand_sysent_table@GOT(%ecx), %edx /* %edx = sysent_table */
shll $3, %eax /* each entry is 8 bytes */
add %eax, %edx /* %edx = sysent entry address */
/*
* Get the return value flag and the number of arguments from the
* sysent table.
*/
movl CPTRSIZE(%edx), %ecx /* number of args + rv flag */
andl $RV_MASK, %ecx /* strip out number of args */
movl %ecx, EH_LOCALS_RVFLAG(%ebp) /* save rv flag */
movl CPTRSIZE(%edx), %ecx /* number of args + rv flag */
andl $NARGS_MASK, %ecx /* strip out rv flag */
/*
* Setup arguments for our emulation call. Our input arguments,
* 0 to N, will become emulation call arguments 1 to N+1.
* %ecx == number of arguments.
*/
movl %ebp, %esi /* args are at 12(%ebp) */
addl $EH_ARGS_OFFSET(3), %esi
movl %esp, %edi /* copy args to 4(%esp) */
addl $EH_ARGS_OFFSET(1), %edi
rep; smovl /* copy: (%esi) -> (%edi) */
/* copy: %ecx 32-bit words */
movl EH_LOCALS_GREG(ESI)(%ebp), %esi /* restore %esi */
movl EH_LOCALS_GREG(EDI)(%ebp), %edi /* restore %edi */
/*
* The first parameter to the emulation callback function is a
* pointer to a sysret_t structure.
*/
movl %ebp, %ecx
addl $EH_LOCALS_SYSRET, %ecx
movl %ecx, EH_ARGS_OFFSET(0)(%esp) /* arg0 == sysret_t ptr */
/* invoke the emulation routine */
ALTENTRY(brand_handler_savepc)
call *(%edx) /* call emulation routine */
/* restore scratch registers */
movl EH_LOCALS_GREG(ECX)(%ebp), %ecx /* restore %ecx */
movl EH_LOCALS_GREG(EDX)(%ebp), %edx /* restore %edx */
/* Check for syscall emulation success or failure */
cmpl $0, %eax /* check for an error */
je success
stc /* failure, set carry flag */
jmp return /* return, %rax == errno */
success:
/* There is always at least one return value. */
movl EH_LOCALS_SYSRET1(%ebp), %eax /* %eax == sys_rval1 */
cmpl $RV_DEFAULT, EH_LOCALS_RVFLAG(%ebp) /* check rv flag */
je clear_carry
mov EH_LOCALS_SYSRET2(%ebp), %edx /* %edx == sys_rval2 */
clear_carry:
clc /* success, clear carry flag */
return:
movl %ebp, %esp /* restore stack */
popl %ebp
ret /* ret to instr after syscall */
SET_SIZE(brand_handler)
#endif /* lint */