2005-01-06 22:18:23 +00:00
|
|
|
/*-
|
2004-09-25 04:27:44 +00:00
|
|
|
* Copyright (c) 2004 Marcel Moolenaar
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
*
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
#include <sys/ktr.h>
|
|
|
|
|
#include <sys/sysproto.h>
|
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
|
#include <sys/lock.h>
|
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
|
#include <sys/pioctl.h>
|
|
|
|
|
#include <sys/proc.h>
|
2006-07-27 19:50:16 +00:00
|
|
|
#include <sys/ptrace.h>
|
2004-09-25 04:27:44 +00:00
|
|
|
#include <sys/signalvar.h>
|
|
|
|
|
#include <sys/syscall.h>
|
|
|
|
|
#include <sys/sysent.h>
|
2004-09-26 00:38:56 +00:00
|
|
|
#include <machine/cpu.h>
|
2004-09-25 04:27:44 +00:00
|
|
|
#include <machine/fpu.h>
|
|
|
|
|
#include <machine/frame.h>
|
|
|
|
|
#include <machine/md_var.h>
|
2012-03-19 21:29:57 +00:00
|
|
|
#include <x86/include/psl.h>
|
2004-09-25 04:27:44 +00:00
|
|
|
|
2006-09-16 17:03:02 +00:00
|
|
|
#include <security/audit/audit.h>
|
|
|
|
|
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
#include <compat/ia32/ia32_util.h>
|
2004-09-26 20:39:56 +00:00
|
|
|
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
void
|
|
|
|
|
ia32_set_syscall_retval(struct thread *td, int error)
|
2004-09-25 04:27:44 +00:00
|
|
|
{
|
|
|
|
|
struct proc *p;
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
struct trapframe *tf;
|
2004-09-25 04:27:44 +00:00
|
|
|
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
tf = td->td_frame;
|
2004-09-25 04:27:44 +00:00
|
|
|
|
|
|
|
|
switch (error) {
|
|
|
|
|
case 0:
|
|
|
|
|
tf->tf_scratch.gr8 = td->td_retval[0]; /* eax */
|
|
|
|
|
tf->tf_scratch.gr10 = td->td_retval[1]; /* edx */
|
|
|
|
|
ia64_set_eflag(ia64_get_eflag() & ~PSL_C);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ERESTART:
|
|
|
|
|
/*
|
|
|
|
|
* Reconstruct pc, assuming lcall $X,y is 7 bytes,
|
|
|
|
|
* int 0x80 is 2 bytes. XXX Assume int 0x80.
|
|
|
|
|
*/
|
|
|
|
|
tf->tf_special.iip -= 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case EJUSTRETURN:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
p = td->td_proc;
|
2004-09-25 04:27:44 +00:00
|
|
|
if (p->p_sysent->sv_errsize) {
|
|
|
|
|
if (error >= p->p_sysent->sv_errsize)
|
|
|
|
|
error = -1; /* XXX */
|
|
|
|
|
else
|
|
|
|
|
error = p->p_sysent->sv_errtbl[error];
|
|
|
|
|
}
|
|
|
|
|
tf->tf_scratch.gr8 = error;
|
|
|
|
|
ia64_set_eflag(ia64_get_eflag() | PSL_C);
|
|
|
|
|
break;
|
|
|
|
|
}
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
ia32_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
|
|
|
|
|
{
|
|
|
|
|
struct trapframe *tf;
|
|
|
|
|
struct proc *p;
|
|
|
|
|
uint32_t args[8];
|
|
|
|
|
caddr_t params;
|
|
|
|
|
int error, i;
|
|
|
|
|
|
|
|
|
|
tf = td->td_frame;
|
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
|
|
|
|
params = (caddr_t)(tf->tf_special.sp & ((1L<<32)-1)) +
|
|
|
|
|
sizeof(uint32_t);
|
|
|
|
|
sa->code = tf->tf_scratch.gr8; /* eax */
|
|
|
|
|
|
|
|
|
|
if (sa->code == SYS_syscall) {
|
|
|
|
|
/* Code is first argument, followed by actual args. */
|
|
|
|
|
sa->code = fuword32(params);
|
|
|
|
|
params += sizeof(int);
|
|
|
|
|
} else if (sa->code == SYS___syscall) {
|
|
|
|
|
/*
|
|
|
|
|
* Like syscall, but code is a quad, so as to maintain
|
|
|
|
|
* quad alignment for the rest of the arguments. We
|
|
|
|
|
* use a 32-bit fetch in case params is not aligned.
|
|
|
|
|
*/
|
|
|
|
|
sa->code = fuword32(params);
|
|
|
|
|
params += sizeof(quad_t);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (p->p_sysent->sv_mask)
|
|
|
|
|
sa->code &= p->p_sysent->sv_mask;
|
|
|
|
|
if (sa->code >= p->p_sysent->sv_size)
|
|
|
|
|
sa->callp = &p->p_sysent->sv_table[0];
|
|
|
|
|
else
|
|
|
|
|
sa->callp = &p->p_sysent->sv_table[sa->code];
|
|
|
|
|
sa->narg = sa->callp->sy_narg;
|
|
|
|
|
|
|
|
|
|
if (params != NULL && sa->narg != 0)
|
|
|
|
|
error = copyin(params, (caddr_t)args, sa->narg * sizeof(int));
|
|
|
|
|
else
|
|
|
|
|
error = 0;
|
2010-05-24 17:24:14 +00:00
|
|
|
sa->args = &sa->args32[0];
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
|
|
|
|
|
if (error == 0) {
|
|
|
|
|
for (i = 0; i < sa->narg; i++)
|
2010-05-24 17:24:14 +00:00
|
|
|
sa->args32[i] = args[i];
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
td->td_retval[0] = 0;
|
|
|
|
|
td->td_retval[1] = tf->tf_scratch.gr10; /* edx */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-11 16:05:09 +00:00
|
|
|
#include "../../kern/subr_syscall.c"
|
|
|
|
|
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
static void
|
|
|
|
|
ia32_syscall(struct trapframe *tf)
|
|
|
|
|
{
|
|
|
|
|
struct thread *td;
|
|
|
|
|
struct syscall_args sa;
|
|
|
|
|
register_t eflags;
|
|
|
|
|
int error;
|
|
|
|
|
ksiginfo_t ksi;
|
|
|
|
|
|
|
|
|
|
td = curthread;
|
|
|
|
|
eflags = ia64_get_eflag();
|
|
|
|
|
|
|
|
|
|
error = syscallenter(td, &sa);
|
2004-09-25 04:27:44 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Traced syscall.
|
|
|
|
|
*/
|
|
|
|
|
if ((eflags & PSL_T) && !(eflags & PSL_VM)) {
|
|
|
|
|
ia64_set_eflag(ia64_get_eflag() & ~PSL_T);
|
1. Change prototype of trapsignal and sendsig to use ksiginfo_t *, most
changes in MD code are trivial, before this change, trapsignal and
sendsig use discrete parameters, now they uses member fields of
ksiginfo_t structure. For sendsig, this change allows us to pass
POSIX realtime signal value to user code.
2. Remove cpu_thread_siginfo, it is no longer needed because we now always
generate ksiginfo_t data and feed it to libpthread.
3. Add p_sigqueue to proc structure to hold shared signals which were
blocked by all threads in the proc.
4. Add td_sigqueue to thread structure to hold all signals delivered to
thread.
5. i386 and amd64 now return POSIX standard si_code, other arches will
be fixed.
6. In this sigqueue implementation, pending signal set is kept as before,
an extra siginfo list holds additional siginfo_t data for signals.
kernel code uses psignal() still behavior as before, it won't be failed
even under memory pressure, only exception is when deleting a signal,
we should call sigqueue_delete to remove signal from sigqueue but
not SIGDELSET. Current there is no kernel code will deliver a signal
with additional data, so kernel should be as stable as before,
a ksiginfo can carry more information, for example, allow signal to
be delivered but throw away siginfo data if memory is not enough.
SIGKILL and SIGSTOP have fast path in sigqueue_add, because they can
not be caught or masked.
The sigqueue() syscall allows user code to queue a signal to target
process, if resource is unavailable, EAGAIN will be returned as
specification said.
Just before thread exits, signal queue memory will be freed by
sigqueue_flush.
Current, all signals are allowed to be queued, not only realtime signals.
Earlier patch reviewed by: jhb, deischen
Tested on: i386, amd64
2005-10-14 12:43:47 +00:00
|
|
|
ksiginfo_init_trap(&ksi);
|
|
|
|
|
ksi.ksi_signo = SIGTRAP;
|
|
|
|
|
ksi.ksi_code = TRAP_TRACE;
|
|
|
|
|
ksi.ksi_addr = (void *)tf->tf_special.iip;
|
|
|
|
|
trapsignal(td, &ksi);
|
2004-09-25 04:27:44 +00:00
|
|
|
}
|
|
|
|
|
|
Reorganize syscall entry and leave handling.
Extend struct sysvec with three new elements:
sv_fetch_syscall_args - the method to fetch syscall arguments from
usermode into struct syscall_args. The structure is machine-depended
(this might be reconsidered after all architectures are converted).
sv_set_syscall_retval - the method to set a return value for usermode
from the syscall. It is a generalization of
cpu_set_syscall_retval(9) to allow ABIs to override the way to set a
return value.
sv_syscallnames - the table of syscall names.
Use sv_set_syscall_retval in kern_sigsuspend() instead of hardcoding
the call to cpu_set_syscall_retval().
The new functions syscallenter(9) and syscallret(9) are provided that
use sv_*syscall* pointers and contain the common repeated code from
the syscall() implementations for the architecture-specific syscall
trap handlers.
Syscallenter() fetches arguments, calls syscall implementation from
ABI sysent table, and set up return frame. The end of syscall
bookkeeping is done by syscallret().
Take advantage of single place for MI syscall handling code and
implement ptrace_lwpinfo pl_flags PL_FLAG_SCE, PL_FLAG_SCX and
PL_FLAG_EXEC. The SCE and SCX flags notify the debugger that the
thread is stopped at syscall entry or return point respectively. The
EXEC flag augments SCX and notifies debugger that the process address
space was changed by one of exec(2)-family syscalls.
The i386, amd64, sparc64, sun4v, powerpc and ia64 syscall()s are
changed to use syscallenter()/syscallret(). MIPS and arm are not
converted and use the mostly unchanged syscall() implementation.
Reviewed by: jhb, marcel, marius, nwhitehorn, stas
Tested by: marcel (ia64), marius (sparc64), nwhitehorn (powerpc),
stas (mips)
MFC after: 1 month
2010-05-23 18:32:02 +00:00
|
|
|
syscallret(td, error, &sa);
|
2004-09-25 04:27:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ia32_trap() is called from exception.S to handle the IA-32 specific
|
|
|
|
|
* interruption vectors.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
ia32_trap(int vector, struct trapframe *tf)
|
|
|
|
|
{
|
|
|
|
|
struct proc *p;
|
|
|
|
|
struct thread *td;
|
|
|
|
|
uint64_t ucode;
|
|
|
|
|
int sig;
|
1. Change prototype of trapsignal and sendsig to use ksiginfo_t *, most
changes in MD code are trivial, before this change, trapsignal and
sendsig use discrete parameters, now they uses member fields of
ksiginfo_t structure. For sendsig, this change allows us to pass
POSIX realtime signal value to user code.
2. Remove cpu_thread_siginfo, it is no longer needed because we now always
generate ksiginfo_t data and feed it to libpthread.
3. Add p_sigqueue to proc structure to hold shared signals which were
blocked by all threads in the proc.
4. Add td_sigqueue to thread structure to hold all signals delivered to
thread.
5. i386 and amd64 now return POSIX standard si_code, other arches will
be fixed.
6. In this sigqueue implementation, pending signal set is kept as before,
an extra siginfo list holds additional siginfo_t data for signals.
kernel code uses psignal() still behavior as before, it won't be failed
even under memory pressure, only exception is when deleting a signal,
we should call sigqueue_delete to remove signal from sigqueue but
not SIGDELSET. Current there is no kernel code will deliver a signal
with additional data, so kernel should be as stable as before,
a ksiginfo can carry more information, for example, allow signal to
be delivered but throw away siginfo data if memory is not enough.
SIGKILL and SIGSTOP have fast path in sigqueue_add, because they can
not be caught or masked.
The sigqueue() syscall allows user code to queue a signal to target
process, if resource is unavailable, EAGAIN will be returned as
specification said.
Just before thread exits, signal queue memory will be freed by
sigqueue_flush.
Current, all signals are allowed to be queued, not only realtime signals.
Earlier patch reviewed by: jhb, deischen
Tested on: i386, amd64
2005-10-14 12:43:47 +00:00
|
|
|
ksiginfo_t ksi;
|
2004-09-25 04:27:44 +00:00
|
|
|
|
|
|
|
|
KASSERT(TRAPF_USERMODE(tf), ("%s: In kernel mode???", __func__));
|
|
|
|
|
|
|
|
|
|
ia64_set_fpsr(IA64_FPSR_DEFAULT);
|
2007-06-04 21:38:48 +00:00
|
|
|
PCPU_INC(cnt.v_trap);
|
2004-09-25 04:27:44 +00:00
|
|
|
|
|
|
|
|
td = curthread;
|
|
|
|
|
td->td_frame = tf;
|
2006-02-08 08:09:17 +00:00
|
|
|
td->td_pticks = 0;
|
2004-09-25 04:27:44 +00:00
|
|
|
p = td->td_proc;
|
|
|
|
|
if (td->td_ucred != p->p_ucred)
|
|
|
|
|
cred_update_thread(td);
|
|
|
|
|
sig = 0;
|
|
|
|
|
ucode = 0;
|
|
|
|
|
switch (vector) {
|
|
|
|
|
case IA64_VEC_IA32_EXCEPTION:
|
|
|
|
|
switch ((tf->tf_special.isr >> 16) & 0xffff) {
|
|
|
|
|
case IA32_EXCEPTION_DIVIDE:
|
|
|
|
|
ucode = FPE_INTDIV;
|
|
|
|
|
sig = SIGFPE;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_DEBUG:
|
|
|
|
|
case IA32_EXCEPTION_BREAK:
|
|
|
|
|
sig = SIGTRAP;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_OVERFLOW:
|
|
|
|
|
ucode = FPE_INTOVF;
|
|
|
|
|
sig = SIGFPE;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_BOUND:
|
|
|
|
|
ucode = FPE_FLTSUB;
|
|
|
|
|
sig = SIGFPE;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_DNA:
|
|
|
|
|
ucode = 0;
|
|
|
|
|
sig = SIGFPE;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_NOT_PRESENT:
|
|
|
|
|
case IA32_EXCEPTION_STACK_FAULT:
|
|
|
|
|
case IA32_EXCEPTION_GPFAULT:
|
|
|
|
|
ucode = (tf->tf_special.isr & 0xffff) + BUS_SEGM_FAULT;
|
|
|
|
|
sig = SIGBUS;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_FPERROR:
|
|
|
|
|
ucode = 0; /* XXX */
|
|
|
|
|
sig = SIGFPE;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_ALIGNMENT_CHECK:
|
|
|
|
|
ucode = tf->tf_special.ifa; /* VA */
|
|
|
|
|
sig = SIGBUS;
|
|
|
|
|
break;
|
|
|
|
|
case IA32_EXCEPTION_STREAMING_SIMD:
|
|
|
|
|
ucode = 0; /* XXX */
|
|
|
|
|
sig = SIGFPE;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
trap_panic(vector, tf);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case IA64_VEC_IA32_INTERCEPT:
|
|
|
|
|
/* XXX Maybe need to emulate ia32 instruction. */
|
|
|
|
|
trap_panic(vector, tf);
|
|
|
|
|
|
|
|
|
|
case IA64_VEC_IA32_INTERRUPT:
|
|
|
|
|
/* INT n instruction - probably a syscall. */
|
|
|
|
|
if (((tf->tf_special.isr >> 16) & 0xffff) == 0x80) {
|
|
|
|
|
ia32_syscall(tf);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
ucode = (tf->tf_special.isr >> 16) & 0xffff;
|
|
|
|
|
sig = SIGILL;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
/* Should never happen of course. */
|
|
|
|
|
trap_panic(vector, tf);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
KASSERT(sig != 0, ("%s: signal not set", __func__));
|
|
|
|
|
|
1. Change prototype of trapsignal and sendsig to use ksiginfo_t *, most
changes in MD code are trivial, before this change, trapsignal and
sendsig use discrete parameters, now they uses member fields of
ksiginfo_t structure. For sendsig, this change allows us to pass
POSIX realtime signal value to user code.
2. Remove cpu_thread_siginfo, it is no longer needed because we now always
generate ksiginfo_t data and feed it to libpthread.
3. Add p_sigqueue to proc structure to hold shared signals which were
blocked by all threads in the proc.
4. Add td_sigqueue to thread structure to hold all signals delivered to
thread.
5. i386 and amd64 now return POSIX standard si_code, other arches will
be fixed.
6. In this sigqueue implementation, pending signal set is kept as before,
an extra siginfo list holds additional siginfo_t data for signals.
kernel code uses psignal() still behavior as before, it won't be failed
even under memory pressure, only exception is when deleting a signal,
we should call sigqueue_delete to remove signal from sigqueue but
not SIGDELSET. Current there is no kernel code will deliver a signal
with additional data, so kernel should be as stable as before,
a ksiginfo can carry more information, for example, allow signal to
be delivered but throw away siginfo data if memory is not enough.
SIGKILL and SIGSTOP have fast path in sigqueue_add, because they can
not be caught or masked.
The sigqueue() syscall allows user code to queue a signal to target
process, if resource is unavailable, EAGAIN will be returned as
specification said.
Just before thread exits, signal queue memory will be freed by
sigqueue_flush.
Current, all signals are allowed to be queued, not only realtime signals.
Earlier patch reviewed by: jhb, deischen
Tested on: i386, amd64
2005-10-14 12:43:47 +00:00
|
|
|
ksiginfo_init_trap(&ksi);
|
|
|
|
|
ksi.ksi_signo = sig;
|
|
|
|
|
ksi.ksi_code = (int)ucode; /* XXX */
|
|
|
|
|
/* ksi.ksi_addr */
|
|
|
|
|
trapsignal(td, &ksi);
|
2004-09-25 04:27:44 +00:00
|
|
|
|
|
|
|
|
out:
|
2006-02-08 08:09:17 +00:00
|
|
|
userret(td, tf);
|
2004-09-25 04:27:44 +00:00
|
|
|
do_ast(tf);
|
|
|
|
|
}
|