zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-03 10:05:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ftmemsim-valgrind/coregrind/m_syswrap/syswrap-freebsd.c
Paul Floyd 034e5d2242 Fixes for FreeBSD pdkill syscall wrapper
2022-05-24 23:40:42 +02:00

7087 lines
232 KiB
C
Raw Blame History

/*--------------------------------------------------------------------*/
/*--- FreeBSD-specific syscalls, etc. syswrap-freebsd.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2000-2008 Nicholas Nethercote
njn@valgrind.org
Copyright (C) 2018-2021 Paul Floyd
pjfloyd@wanadoo.fr
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, see <http://www.gnu.org/licenses/>.
The GNU General Public License is contained in the file COPYING.
*/
#if defined(VGO_freebsd)
#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_vkiscnums.h"
#include "pub_core_threadstate.h"
#include "pub_core_aspacemgr.h"
#include "pub_core_debuginfo.h" // VG_(di_notify_*)
#include "pub_core_transtab.h" // VG_(discard_translations)
#include "pub_core_xarray.h"
#include "pub_core_clientstate.h"
#include "pub_core_debuglog.h"
#include "pub_core_libcbase.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcfile.h"
#include "pub_core_libcprint.h"
#include "pub_core_libcproc.h"
#include "pub_core_libcsignal.h"
#include "pub_core_machine.h"
#include "pub_core_mallocfree.h"
#include "pub_core_tooliface.h"
#include "pub_core_options.h"
#include "pub_core_scheduler.h"
#include "pub_core_signals.h"
#include "pub_core_stacks.h"
#include "pub_core_syscall.h"
#include "pub_core_syswrap.h"
#include "pub_core_inner.h"
#if defined(ENABLE_INNER_CLIENT_REQUEST)
#include "pub_core_clreq.h"
#endif
#include "priv_types_n_macros.h"
#include "priv_syswrap-generic.h"
#include "priv_syswrap-main.h"
#include "priv_syswrap-freebsd.h"
static Bool capabiltyMode = False;
Bool VG_(get_capability_mode)(void)
{
return capabiltyMode;
}
// Run a thread from beginning to end and return the thread's
// scheduler-return-code.
static VgSchedReturnCode thread_wrapper(Word /*ThreadId*/ tidW)
{
VgSchedReturnCode ret;
ThreadId tid = (ThreadId)tidW;
ThreadState* tst = VG_(get_ThreadState)(tid);
VG_(debugLog)(1, "syswrap-freebsd",
"thread_wrapper(tid=%u): entry\n",
tid);
vg_assert(tst->status == VgTs_Init);
/* make sure we get the CPU lock before doing anything significant */
VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");
if (0)
VG_(printf)("thread tid %u started: stack = %p\n",
tid, (void*)&tid);
/* Make sure error reporting is enabled in the new thread. */
tst->err_disablement_level = 0;
VG_TRACK(pre_thread_first_insn, tid);
tst->os_state.lwpid = VG_(gettid)();
/* Set the threadgroup for real. This overwrites the provisional value set
in do_clone(). See comments in do_clone for background, also #226116. */
tst->os_state.threadgroup = VG_(getpid)();
/* Thread created with all signals blocked; scheduler will set the
appropriate mask */
ret = VG_(scheduler)(tid);
vg_assert(VG_(is_exiting)(tid));
vg_assert(tst->status == VgTs_Runnable);
vg_assert(VG_(is_running_thread)(tid));
VG_(debugLog)(1, "syswrap-freebsd",
"thread_wrapper(tid=%u): exit, schedreturncode %s\n",
tid, VG_(name_of_VgSchedReturnCode)(ret));
/* Return to caller, still holding the lock. */
return ret;
}
/* ---------------------------------------------------------------------
clone-related stuff
------------------------------------------------------------------ */
/* Run a thread all the way to the end, then do appropriate exit actions
(this is the last-one-out-turn-off-the-lights bit). */
__attribute__((noreturn))
static void run_a_thread_NORETURN ( Word tidW )
{
ThreadId tid = (ThreadId)tidW;
VgSchedReturnCode src;
Int c;
ThreadState* tst;
#ifdef ENABLE_INNER_CLIENT_REQUEST
Int registered_vgstack_id;
#endif
VG_(debugLog)(1, "syswrap-freebsd",
"run_a_thread_NORETURN(tid=%u): pre-thread_wrapper\n",
tid);
tst = VG_(get_ThreadState)(tid);
vg_assert(tst);
/* An thread has two stacks:
* the simulated stack (used by the synthetic cpu. Guest process
is using this stack).
* the valgrind stack (used by the real cpu. Valgrind code is running
on this stack).
When Valgrind runs as an inner, it must signals that its (real) stack
is the stack to use by the outer to e.g. do stacktraces.
*/
INNER_REQUEST
(registered_vgstack_id
= VALGRIND_STACK_REGISTER (tst->os_state.valgrind_stack_base,
tst->os_state.valgrind_stack_init_SP));
/* Run the thread all the way through. */
src = thread_wrapper(tid);
VG_(debugLog)(1, "syswrap-freebsd",
"run_a_thread_NORETURN(tid=%u): post-thread_wrapper\n",
tid);
c = VG_(count_living_threads)();
vg_assert(c >= 1); /* stay sane */
/* Deregister thread's stack. */
if (tst->os_state.stk_id != NULL_STK_ID)
VG_(deregister_stack)(tst->os_state.stk_id);
// Tell the tool this thread is exiting
VG_TRACK( pre_thread_ll_exit, tid );
/* If the thread is exiting with errors disabled, complain loudly;
doing so is bad (does the user know this has happened?) Also,
in all cases, be paranoid and clear the flag anyway so that the
thread slot is safe in this respect if later reallocated. This
should be unnecessary since the flag should be cleared when the
slot is reallocated, in thread_wrapper(). */
if (tst->err_disablement_level > 0) {
VG_(umsg)(
"WARNING: exiting thread has error reporting disabled.\n"
"WARNING: possibly as a result of some mistake in the use\n"
"WARNING: of the VALGRIND_DISABLE_ERROR_REPORTING macros.\n"
);
VG_(debugLog)(
1, "syswrap-freebsd",
"run_a_thread_NORETURN(tid=%u): "
"WARNING: exiting thread has err_disablement_level = %u\n",
tid, tst->err_disablement_level
);
}
tst->err_disablement_level = 0;
if (c == 1) {
VG_(debugLog)(1, "syswrap-freebsd",
"run_a_thread_NORETURN(tid=%u): "
"last one standing\n",
tid);
/* We are the last one standing. Keep hold of the lock and
carry on to show final tool results, then exit the entire system.
Use the continuation pointer set at startup in m_main. */
( * VG_(address_of_m_main_shutdown_actions_NORETURN) ) (tid, src);
} else {
VG_(debugLog)(1, "syswrap-freebsd",
"run_a_thread_NORETURN(tid=%u): "
"not last one standing\n",
tid);
/* OK, thread is dead, but others still exist. Just exit. */
/* This releases the run lock */
VG_(exit_thread)(tid);
vg_assert(tst->status == VgTs_Zombie);
vg_assert(sizeof(tst->status) == 4);
vg_assert(sizeof(tst->os_state.exitcode) == sizeof(Word));
INNER_REQUEST (VALGRIND_STACK_DEREGISTER (registered_vgstack_id));
/* We have to use this sequence to terminate the thread to
prevent a subtle race. If VG_(exit_thread)() had left the
ThreadState as Empty, then it could have been reallocated,
reusing the stack while we're doing these last cleanups.
Instead, VG_(exit_thread) leaves it as Zombie to prevent
reallocation. We need to make sure we don't touch the stack
between marking it Empty and exiting. Hence the
assembler. */
#if defined(VGP_x86_freebsd) /* FreeBSD has args on the stack */
asm volatile (
"movl %1, %0\n" /* set tst->status = VgTs_Empty */
"movl %2, %%eax\n" /* set %eax = __NR_thr_exit */
"movl %3, %%ebx\n" /* set %ebx = tst->os_state.exitcode */
"pushl %%ebx\n" /* arg on stack */
"pushl %%ebx\n" /* fake return address */
"int $0x80\n" /* thr_exit(tst->os_state.exitcode) */
"popl %%ebx\n" /* fake return address */
"popl %%ebx\n" /* arg off stack */
: "=m" (tst->status)
: "n" (VgTs_Empty), "n" (__NR_thr_exit), "m" (tst->os_state.exitcode)
: "eax", "ebx"
);
#elif defined(VGP_amd64_freebsd)
asm volatile (
"movl %1, %0\n" /* set tst->status = VgTs_Empty */
"movq %2, %%rax\n" /* set %rax = __NR_thr_exit */
"movq %3, %%rdi\n" /* set %rdi = tst->os_state.exitcode */
"pushq %%rdi\n" /* fake return address */
"syscall\n" /* thr_exit(tst->os_state.exitcode) */
"popq %%rdi\n" /* fake return address */
: "=m" (tst->status)
: "n" (VgTs_Empty), "n" (__NR_thr_exit), "m" (tst->os_state.exitcode)
: "rax", "rdi"
);
#else
# error Unknown platform
#endif
VG_(core_panic)("Thread exit failed?\n");
}
/*NOTREACHED*/
vg_assert(0);
}
Word ML_(start_thread_NORETURN) ( void* arg )
{
ThreadState* tst = (ThreadState*)arg;
ThreadId tid = tst->tid;
run_a_thread_NORETURN ( (Word)tid );
/*NOTREACHED*/
vg_assert(0);
}
/* Allocate a stack for this thread, if it doesn't already have one.
They're allocated lazily, and never freed. Returns the initial stack
pointer value to use, or 0 if allocation failed. */
Addr ML_(allocstack)(ThreadId tid)
{
ThreadState* tst = VG_(get_ThreadState)(tid);
VgStack* stack;
Addr initial_SP;
/* Either the stack_base and stack_init_SP are both zero (in which
case a stack hasn't been allocated) or they are both non-zero,
in which case it has. */
if (tst->os_state.valgrind_stack_base == 0)
vg_assert(tst->os_state.valgrind_stack_init_SP == 0);
if (tst->os_state.valgrind_stack_base != 0)
vg_assert(tst->os_state.valgrind_stack_init_SP != 0);
/* If no stack is present, allocate one. */
if (tst->os_state.valgrind_stack_base == 0) {
stack = VG_(am_alloc_VgStack)( &initial_SP );
if (stack) {
tst->os_state.valgrind_stack_base = (Addr)stack;
tst->os_state.valgrind_stack_init_SP = initial_SP;
}
}
if (0)
VG_(printf)( "stack for tid %u at %p; init_SP=%p\n",
tid,
(void*)tst->os_state.valgrind_stack_base,
(void*)tst->os_state.valgrind_stack_init_SP );
return tst->os_state.valgrind_stack_init_SP;
}
/* Allocate a stack for the main thread, and run it all the way to the
end. Although we already have a working VgStack
(VG_(interim_stack)) it's better to allocate a new one, so that
overflow detection works uniformly for all threads.
*/
__attribute__((noreturn))
void VG_(main_thread_wrapper_NORETURN)(ThreadId tid)
{
Addr sp;
VG_(debugLog)(1, "syswrap-freebsd",
"entering VG_(main_thread_wrapper_NORETURN)\n");
sp = ML_(allocstack)(tid);
#if defined(ENABLE_INNER_CLIENT_REQUEST)
{
// we must register the main thread stack before the call
// to ML_(call_on_new_stack_0_1), otherwise the outer valgrind
// reports 'write error' on the non registered stack.
ThreadState* tst = VG_(get_ThreadState)(tid);
INNER_REQUEST
((void)
VALGRIND_STACK_REGISTER (tst->os_state.valgrind_stack_base,
tst->os_state.valgrind_stack_init_SP));
}
#endif
/* If we can't even allocate the first thread's stack, we're hosed.
Give up. */
vg_assert2(sp != 0, "%s", "Cannot allocate main thread's stack.");
/* shouldn't be any other threads around yet */
vg_assert( VG_(count_living_threads)() == 1 );
ML_(call_on_new_stack_0_1)(
(Addr)sp, /* stack */
0, /* bogus return address */
run_a_thread_NORETURN, /* fn to call */
(Word)tid /* arg to give it */
);
/*NOTREACHED*/
vg_assert(0);
}
/* Do a fork() */
SysRes ML_(do_fork) ( ThreadId tid )
{
vki_sigset_t fork_saved_mask;
vki_sigset_t mask;
SysRes res;
/* Block all signals during fork, so that we can fix things up in
the child without being interrupted. */
VG_(sigfillset)(&mask);
VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, &fork_saved_mask);
VG_(do_atfork_pre)(tid);
res = VG_(do_syscall0)( __NR_fork );
if (!sr_isError(res)) {
if (sr_Res(res) == 0) {
/* child */
VG_(do_atfork_child)(tid);
/* restore signal mask */
VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
} else {
/* parent */
VG_(do_atfork_parent)(tid);
if (VG_(clo_trace_syscalls))
VG_(printf)(" clone(fork): process %d created child %lu\n",
VG_(getpid)(), sr_Res(res));
/* restore signal mask */
VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
}
}
return res;
}
static Addr ML_(make_safe_mask) ( const HChar* malloc_message, Addr mask_pointer )
{
vki_sigset_t* new_mask;
const vki_sigset_t* old_mask = (vki_sigset_t *)mask_pointer;
if (!ML_(safe_to_deref)(old_mask, sizeof(vki_sigset_t))) {
new_mask = (vki_sigset_t*)1; /* Something recognisable to POST() hook. */
} else {
new_mask = VG_(malloc)(malloc_message, sizeof(vki_sigset_t));
*new_mask = *old_mask;
VG_(sanitize_client_sigmask)(new_mask);
}
return (Addr)new_mask;
}
static void ML_(free_safe_mask) ( Addr mask_pointer )
{
if (mask_pointer != 0 && mask_pointer != 1) {
VG_(free)((vki_sigset_t *) mask_pointer);
}
}
/* ---------------------------------------------------------------------
PRE/POST wrappers for arch-generic, FreeBSD-specific syscalls
------------------------------------------------------------------ */
// Nb: See the comment above the generic PRE/POST wrappers in
// m_syswrap/syswrap-generic.c for notes about how they work.
#define PRE(name) DEFN_PRE_TEMPLATE(freebsd, name)
#define POST(name) DEFN_POST_TEMPLATE(freebsd, name)
/* On FreeBSD, if any thread calls exit(2), then they are all shut down, pretty
* much like linux's exit_group().
*/
// SYS_exit 1
// void exit(int status);
PRE(sys_exit)
{
ThreadId t;
PRINT("exit( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(void, "exit", int, status);
/* Mark all threads (including this one) to exit. */
for (t = 1; t < VG_N_THREADS; t++) {
if ( /* not alive */ VG_(threads)[t].status == VgTs_Empty )
continue;
//VG_(threads)[t].exitreason = VgSrc_ExitThread;
VG_(threads)[t].os_state.exitcode = ARG1;
// if (t != tid)
// VG_(get_thread_out_of_syscall)(t); /* unblock it, if blocked */
}
VG_(nuke_all_threads_except)( tid, VgSrc_ExitProcess );
VG_(reap_threads)(tid);
VG_(threads)[tid].exitreason = VgSrc_ExitThread;
/* We have to claim the syscall already succeeded. */
SET_STATUS_Success(0);
}
// SYS_fork 2
// pid_t fork(void);
PRE(sys_fork)
{
PRINT("%s", "sys_fork ()");
PRE_REG_READ0(pid_t, "fork");
SET_STATUS_from_SysRes( ML_(do_fork)(tid) );
if (SUCCESS) {
/* Thread creation was successful; let the child have the chance
to run */
*flags |= SfYieldAfter;
}
}
// SYS_read 3
// generic
// SYS_write 4
// generic
// SYS_open 5
// generic
// SYS_close 6
// generic
// SYS_wait4 7
// generic
// SYS_link 9
// generic
// SYS_unlink 10
// generic
// SYS_chdir 12
// SYS_fchdir 13
// generic
// SYS_freebsd11_mknod 14
// generic
// SYS_chmod 15
// generic
// SYS_chown 16
// generic
// SYS_break 17
// generic
// SYS_getpid 20
// generic
// SYS_mount 21
// int mount(const char *type, const char *dir, int flags, void *data);
PRE(sys_mount)
{
// Nb: depending on 'flags', the 'type' and 'data' args may be ignored.
// We are conservative and check everything, except the memory pointed to
// by 'data'.
*flags |= SfMayBlock;
PRINT( "sys_mount( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "mount",
const char *, type, char *, dir, int, flags,
void *, data);
PRE_MEM_RASCIIZ( "mount(type)", ARG1);
PRE_MEM_RASCIIZ( "mount(path)", ARG2);
}
// SYS_unmount 22
// int unmount(const char *dir, int flags);
PRE(sys_unmount)
{
PRINT("sys_umount( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(int, "unmount", const char *, dir, int, flags);
PRE_MEM_RASCIIZ( "unmount(path)", ARG1);
}
// SYS_setuid 23
// generic
// SYS_getuid 24
// generic
// SYS_geteuid 25
// generic
// SYS_ptrace 26
// int ptrace(int request, pid_t pid, caddr_t addr, int data);
PRE(sys_ptrace)
{
struct vki_ptrace_io_desc *io_desc;
PRINT("sys_ptrace ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, 0x%" FMT_REGWORD "x, %" FMT_REGWORD "u)", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "ptrace", int, request, pid_t, pid, caddr_t, addr, int, data);
switch (ARG1) {
case VKI_PTRACE_TRACEME:
break;
case VKI_PTRACE_READ_I:
case VKI_PTRACE_READ_D:
break;
case VKI_PTRACE_WRITE_I:
case VKI_PTRACE_WRITE_D:
break;
case VKI_PTRACE_IO:
PRE_MEM_READ("ptrace", ARG3, sizeof(struct vki_ptrace_io_desc));
io_desc = (struct vki_ptrace_io_desc *)ARG3;
switch (io_desc->piod_op) {
case VKI_PIOD_READ_D:
case VKI_PIOD_READ_I:
PRE_MEM_WRITE( "ptrace", (UWord)io_desc->piod_addr, io_desc->piod_len);
break;
case VKI_PIOD_WRITE_D:
case VKI_PIOD_WRITE_I:
PRE_MEM_READ( "ptrace", (UWord)io_desc->piod_addr, io_desc->piod_len);
break;
}
break;
case VKI_PTRACE_CONTINUE:
break;
case VKI_PTRACE_STEP:
break;
case VKI_PTRACE_KILL:
break;
case VKI_PTRACE_ATTACH:
break;
case VKI_PTRACE_DETACH:
break;
case VKI_PTRACE_GETREGS:
PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_user_regs_struct));
break;
case VKI_PTRACE_SETREGS:
PRE_MEM_READ( "ptrace", ARG3, sizeof(struct vki_user_regs_struct));
break;
case VKI_PTRACE_GETFPREGS:
PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_fpreg));
break;
case VKI_PTRACE_SETFPREGS:
PRE_MEM_READ( "ptrace", ARG3, sizeof(struct vki_fpreg));
break;
case VKI_PTRACE_GETDBREGS:
PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_dbreg));
break;
case VKI_PTRACE_SETDBREGS:
PRE_MEM_READ( "ptrace", ARG3, sizeof(struct vki_dbreg));
break;
case VKI_PTRACE_LWPINFO:
PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_ptrace_lwpinfo));
break;
case VKI_PTRACE_GETNUMLWPS:
break;
case VKI_PTRACE_GETLWPLIST:
PRE_MEM_WRITE( "ptrace", ARG3, sizeof(vki_lwpid_t) * ARG4);
break;
case VKI_PTRACE_SETSTEP:
break;
case VKI_PTRACE_CLEARSTEP:
break;
case VKI_PTRACE_SUSPEND:
break;
case VKI_PTRACE_RESUME:
break;
case VKI_PTRACE_TO_SCE:
break;
case VKI_PTRACE_TO_SCX:
break;
case VKI_PTRACE_SYSCALL:
break;
case VKI_PTRACE_VM_TIMESTAMP:
break;
case VKI_PTRACE_VM_ENTRY:
PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_ptrace_vm_entry));
break;
}
}
POST(sys_ptrace)
{
struct vki_ptrace_io_desc *io_desc;
switch (ARG1) {
case VKI_PTRACE_TRACEME:
break;
case VKI_PTRACE_READ_I:
case VKI_PTRACE_READ_D:
break;
case VKI_PTRACE_WRITE_I:
case VKI_PTRACE_WRITE_D:
break;
case VKI_PTRACE_IO:
io_desc = (struct vki_ptrace_io_desc *)ARG3;
switch (io_desc->piod_op) {
case VKI_PIOD_READ_D:
case VKI_PIOD_READ_I:
if ((Word)RES != -1)
POST_MEM_WRITE((UWord)io_desc->piod_addr, io_desc->piod_len);
break;
case VKI_PIOD_WRITE_D:
case VKI_PIOD_WRITE_I:
break;
}
break;
case VKI_PTRACE_CONTINUE:
break;
case VKI_PTRACE_STEP:
break;
case VKI_PTRACE_KILL:
break;
case VKI_PTRACE_ATTACH:
break;
case VKI_PTRACE_DETACH:
break;
case VKI_PTRACE_GETREGS:
if ((Word)RES != -1)
POST_MEM_WRITE(ARG3, sizeof(struct vki_user_regs_struct));
break;
case VKI_PTRACE_SETREGS:
break;
case VKI_PTRACE_GETFPREGS:
if ((Word)RES != -1)
POST_MEM_WRITE(ARG3, sizeof(struct vki_fpreg));
break;
case VKI_PTRACE_SETFPREGS:
break;
case VKI_PTRACE_GETDBREGS:
if ((Word)RES != -1)
POST_MEM_WRITE(ARG3, sizeof(struct vki_dbreg));
break;
case VKI_PTRACE_SETDBREGS:
break;
case VKI_PTRACE_LWPINFO:
if ((Word)RES != -1)
POST_MEM_WRITE(ARG3, sizeof(struct vki_ptrace_lwpinfo));
break;
case VKI_PTRACE_GETNUMLWPS:
break;
case VKI_PTRACE_GETLWPLIST:
if ((Word)RES != -1)
POST_MEM_WRITE(ARG3, sizeof(vki_lwpid_t) * RES);
break;
case VKI_PTRACE_SETSTEP:
break;
case VKI_PTRACE_CLEARSTEP:
break;
case VKI_PTRACE_SUSPEND:
break;
case VKI_PTRACE_RESUME:
break;
case VKI_PTRACE_TO_SCE:
break;
case VKI_PTRACE_TO_SCX:
break;
case VKI_PTRACE_SYSCALL:
break;
case VKI_PTRACE_VM_TIMESTAMP:
break;
case VKI_PTRACE_VM_ENTRY:
if ((Word)RES != -1)
POST_MEM_WRITE(ARG3, sizeof(struct vki_ptrace_vm_entry));
break;
}
}
// SYS_recvmsg 27
// ssize_t recvmsg(int s, struct msghdr *msg, int flags);
PRE(sys_recvmsg)
{
*flags |= SfMayBlock;
PRINT("sys_recvmsg ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "d )",SARG1,ARG2,SARG3);
PRE_REG_READ3(vki_ssize_t, "recvmsg", int, s, struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_recvmsg)(tid, "recvmsg", (struct vki_msghdr *)ARG2);
}
POST(sys_recvmsg)
{
ML_(generic_POST_sys_recvmsg)(tid, "recvmsg", (struct vki_msghdr *)ARG2, RES);
}
// SYS_sendmsg 28
// ssize_t sendmsg(int s, const struct msghdr *msg, int flags);
PRE(sys_sendmsg)
{
*flags |= SfMayBlock;
PRINT("sys_sendmsg ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(ssize_t, "sendmsg",
int, s, const struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_sendmsg)(tid, "sendmsg", (struct vki_msghdr *)ARG2);
}
// SYS_recvfrom 29
// ssize_t recvfrom(int s, void *buf, size_t len, int flags,
// struct sockaddr * restrict from, socklen_t * restrict fromlen);
PRE(sys_recvfrom)
{
*flags |= SfMayBlock;
PRINT("sys_recvfrom ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",SARG1,ARG2,ARG3,SARG4,ARG5,ARG6);
PRE_REG_READ6(ssize_t, "recvfrom",
int, s, void *, buf, size_t, len, int, flags,
struct sockaddr *, from, int *, fromlen);
ML_(generic_PRE_sys_recvfrom)(tid, ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
}
POST(sys_recvfrom)
{
vg_assert(SUCCESS);
ML_(generic_POST_sys_recvfrom)(tid, VG_(mk_SysRes_Success)(RES),
ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
}
// SYS_accept 30
// int accept(int s, struct sockaddr * restrict addr,
// socklen_t * restrict addrlen);
PRE(sys_accept)
{
*flags |= SfMayBlock;
PRINT("sys_accept ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "accept",
int, s, struct sockaddr *, addr, int, *addrlen);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
POST(sys_accept)
{
SysRes r;
vg_assert(SUCCESS);
r = ML_(generic_POST_sys_accept)(tid, VG_(mk_SysRes_Success)(RES),
ARG1,ARG2,ARG3);
SET_STATUS_from_SysRes(r);
}
// SYS_getpeername 31
// int getpeername(int s, struct sockaddr * restrict name,
// socklen_t * restrict namelen);
PRE(sys_getpeername)
{
PRINT("sys_getpeername ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "getpeername",
int, s, struct sockaddr *, name, socklen_t *, namelen);
ML_(generic_PRE_sys_getpeername)(tid, ARG1,ARG2,ARG3);
}
POST(sys_getpeername)
{
vg_assert(SUCCESS);
ML_(generic_POST_sys_getpeername)(tid, VG_(mk_SysRes_Success)(RES),
ARG1,ARG2,ARG3);
}
// SYS_getsockname 32
// int getsockname(int s, struct sockaddr * restrict name,
// socklen_t * restrict namelen);
PRE(sys_getsockname)
{
PRINT("sys_getsockname ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",SARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getsockname",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getsockname)(tid, ARG1,ARG2,ARG3);
}
POST(sys_getsockname)
{
vg_assert(SUCCESS);
ML_(generic_POST_sys_getsockname)(tid, VG_(mk_SysRes_Success)(RES),
ARG1,ARG2,ARG3);
}
// SYS_access 33
// generic
// SYS_chflags 34
// int chflags(const char *path, unsigned long flags)
PRE(sys_chflags)
{
PRINT("sys_chflags ( %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "chflags",
const char *, path, unsigned long, flags);
PRE_MEM_RASCIIZ( "chflags(path)", ARG1 );
}
// SYS_fchflags 35
// int fchflags(int fd, unsigned long flags);
PRE(sys_fchflags)
{
PRINT("sys_fchflags ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1,ARG2);
PRE_REG_READ2(int, "fchflags", int, fd, unsigned long, flags);
}
// SYS_sync 36
// generic
// SYS_kill 37
// generic
// SYS_getppid 39
// generic
// SYS_dup 41
// generic
// Pipe on freebsd doesn't have args, and uses dual returns!
// SYS_freebsd10_pipe 42
// int pipe(void);
PRE(sys_pipe)
{
PRINT("%s", "sys_pipe ()");
}
POST(sys_pipe)
{
if (!ML_(fd_allowed)(RES, "pipe", tid, True) ||
!ML_(fd_allowed)(RESHI, "pipe", tid, True)) {
VG_(close)(RES);
VG_(close)(RESHI);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds)) {
ML_(record_fd_open_nameless)(tid, RES);
ML_(record_fd_open_nameless)(tid, RESHI);
}
}
}
// SYS_getegid 43
// generic
// SYS_profil 44
// generic
// SYS_ktrace 45
// generic
// SYS_getgid 47
// generic
// SYS_getlogin 49
// syscall.master refers to namelen and namebuf for the argument names
// man getlogin has just getlogin(void) but also
// int getlogin_r(char *name, int len);
// so let's go with those names
PRE(sys_getlogin)
{
PRINT("sys_getlogin ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2);
PRE_REG_READ2(int, "getlogin", char *, buf, u_int, len);
PRE_MEM_WRITE( "getlogin(name)", ARG1, ARG2 );
}
POST(sys_getlogin)
{
POST_MEM_WRITE(ARG1, ARG2 );
}
// SYS_setlogin 50
// int setlogin(const char *name);
PRE(sys_setlogin)
{
PRINT("sys_setlogin ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(long, "setlogin", char *, buf);
PRE_MEM_RASCIIZ( "setlogin(buf)", ARG1 );
}
// SYS_acct 51
// generic
// SYS_sigaltstack 53
// generic
// SYS_ioctl 54
// int ioctl(int fd, unsigned long request, ...);
PRE(sys_ioctl)
{
UInt dir = _VKI_IOC_DIR(ARG2);
UInt size = _VKI_IOC_SIZE(ARG2);
*flags |= SfMayBlock;
// @todo PJF presumably the presence of ARG3 depends on ARG2
PRINT("sys_ioctl ( %" FMT_REGWORD "u, 0x%" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "ioctl",
int, fd, unsigned long, request, unsigned long, arg);
/* On FreeBSD, ALL ioctl's are IOR/IOW encoded. Just use the default decoder */
if (SimHintiS(SimHint_lax_ioctls, VG_(clo_sim_hints))) {
/*
* Be very lax about ioctl handling; the only
* assumption is that the size is correct. Doesn't
* require the full buffer to be initialized when
* writing. Without this, using some device
* drivers with a large number of strange ioctl
* commands becomes very tiresome.
*/
} else if ((dir == _VKI_IOC_NONE) && size > 0) {
static UWord unknown_ioctl[10];
static Int moans = sizeof(unknown_ioctl) / sizeof(unknown_ioctl[0]);
if (moans > 0 && !VG_(clo_xml)) {
/* Check if have not already moaned for this request. */
UInt i;
for (i = 0; i < sizeof(unknown_ioctl)/sizeof(unknown_ioctl[0]); i++) {
if (unknown_ioctl[i] == ARG2)
break;
if (unknown_ioctl[i] == 0) {
unknown_ioctl[i] = ARG2;
moans--;
VG_(umsg)("Warning: noted but unhandled ioctl 0x%lx"
" with no size/direction hints.\n", ARG2);
VG_(umsg)(" This could cause spurious value errors to appear.\n");
VG_(umsg)(" See README_MISSING_SYSCALL_OR_IOCTL for "
"guidance on writing a proper wrapper.\n" );
//VG_(get_and_pp_StackTrace)(tid, VG_(clo_backtrace_size));
return;
}
}
}
} else {
if ((dir & _VKI_IOC_WRITE) && size > 0)
PRE_MEM_READ( "ioctl(generic)", ARG3, size);
if ((dir & _VKI_IOC_READ) && size > 0)
PRE_MEM_WRITE( "ioctl(generic)", ARG3, size);
}
// The block below is from Ryan Stone
// https://bitbucket.org/rysto32/valgrind-freebsd/commits/5323c22be9f6c71a00e842c3ddfa1fa8a7feb279
// however it drags in hundreds of lines of headers into vki-freebsd.h.
// How stable are these structures? -> maintainability is a concern
// Also there are no testcases for this.
// Hence #if 0
#if 0
/* Handle specific ioctls which pass structures which may have pointers to other
buffers */
switch (ARG2 /* request */) {
case VKI_SIOCGIFMEDIA:
if (ARG3) {
struct vki_ifmediareq* imr = (struct vki_ifmediareq*)ARG3;
if (imr->ifm_ulist) {
PRE_MEM_WRITE("ioctl(SIOCGIFMEDIA).ifm_ulist",
(Addr)(imr->ifm_ulist), imr->ifm_count * sizeof(int));
}
}
break;
case VKI_PCIOCGETCONF:
if (ARG3) {
struct vki_pci_conf_io* pci = (struct vki_pci_conf_io*)ARG3;
PRE_MEM_READ("ioctl(PCIOCGETCONF).patterns",
(Addr)(pci->patterns), pci->pat_buf_len);
PRE_MEM_WRITE("ioctl(PCIOCGETCONF).matches",
(Addr)(pci->matches), pci->match_buf_len);
}
break;
case VKI_CAMIOCOMMAND:
if (ARG3) {
union vki_ccb* ccb = (union vki_ccb*)ARG3;
if (ccb->ccb_h.func_code == VKI_XPT_DEV_MATCH) {
PRE_MEM_WRITE("ioctl(CAMIOCOMMAND:XPT_DEV_MATCH).matches",
(Addr)(ccb->cdm.matches), ccb->cdm.match_buf_len);
} else if (ccb->ccb_h.func_code == VKI_XPT_SCSI_IO) {
struct vki_ccb_scsiio* scsiio = (struct vki_ccb_scsiio*)ccb;
if (scsiio->dxfer_len) {
if ((scsiio->ccb_h.flags & VKI_CAM_DIR_MASK) == VKI_CAM_DIR_IN) {
PRE_MEM_WRITE("ioctl(CAMIOCOMMAND:XPT_SCSI_IO).data_ptr",
(Addr)(scsiio->data_ptr), scsiio->dxfer_len);
} else if ((scsiio->ccb_h.flags & VKI_CAM_DIR_MASK) == VKI_CAM_DIR_OUT) {
PRE_MEM_READ("ioctl(CAMIOCOMMAND:XPT_SCSI_IO).data_ptr",
(Addr)(scsiio->data_ptr), scsiio->dxfer_len);
}
}
} else if (ccb->ccb_h.func_code == VKI_XPT_GDEV_TYPE ||
ccb->ccb_h.func_code == VKI_XPT_PATH_INQ ||
ccb->ccb_h.func_code == VKI_XPT_GET_TRAN_SETTINGS) {
// do nothing
} else {
VG_(message)(Vg_UserMsg,
"Warning: unhandled ioctl CAMIOCOMMAND function 0x%lx\n",
ccb->ccb_h.func_code);
}
}
break;
}
#endif
}
POST(sys_ioctl)
{
UInt dir = _VKI_IOC_DIR(ARG2);
UInt size = _VKI_IOC_SIZE(ARG2);
vg_assert(SUCCESS);
if (size > 0 && (dir & _VKI_IOC_READ)
&& RES == 0 && ARG3 != (Addr)NULL)
POST_MEM_WRITE(ARG3, size);
#if 0
/* Handle specific ioctls which pass structures which may have pointers to other
buffers */
switch (ARG2 /* request */) {
case VKI_SIOCGIFMEDIA:
if (ARG3) {
struct vki_ifmediareq* imr = (struct vki_ifmediareq*)ARG3;
if (imr->ifm_ulist) {
POST_MEM_WRITE((Addr)(imr->ifm_ulist), imr->ifm_count * sizeof(int));
}
}
break;
case VKI_PCIOCGETCONF:
if (ARG3) {
struct vki_pci_conf_io* pci = (struct vki_pci_conf_io*)ARG3;
POST_MEM_WRITE((Addr)(pci->matches), pci->num_matches * sizeof(struct vki_pci_conf));
}
break;
case VKI_CAMIOCOMMAND:
if (ARG3) {
union vki_ccb* ccb = (union vki_ccb*)ARG3;
if (ccb->ccb_h.func_code == VKI_XPT_DEV_MATCH) {
POST_MEM_WRITE((Addr)(ccb->cdm.matches), ccb->cdm.num_matches*sizeof(struct vki_dev_match_result));
} else if (ccb->ccb_h.func_code == VKI_XPT_SCSI_IO) {
struct vki_ccb_scsiio* scsiio = (struct vki_ccb_scsiio*)ccb;
if (scsiio->dxfer_len) {
if ((scsiio->ccb_h.flags & VKI_CAM_DIR_MASK) == VKI_CAM_DIR_IN) {
POST_MEM_WRITE((Addr)(scsiio->data_ptr), scsiio->dxfer_len);
}
}
}
}
break;
}
#endif
}
// SYS_reboot 55
// int reboot(int howto);
PRE(sys_reboot)
{
PRINT("sys_reboot ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "reboot", int, howto);
}
// SYS_revoke 56
// int revoke(const char *path);
PRE(sys_revoke)
{
PRINT("sys_revoke ( %#" FMT_REGWORD "x(%s) )", ARG1, (char*)ARG1);
PRE_REG_READ1(long, "revoke", const char *, path);
PRE_MEM_RASCIIZ( "revoke(path)", ARG1);
}
// SYS_symlink 57
// generic
// SYS_readlink 58
// generic
// SYS_execve 59
// generic
// SYS_umask 60
// generic
// SYS_chroot 61
// generic
// SYS_msync 65
// generic
// SYS_vfork 66
// pid_t vfork(void);
PRE(sys_vfork)
{
PRINT("%s", "sys_vfork ()");
PRE_REG_READ0(pid_t, "vfork");
/* Pretend vfork == fork. Not true, but will have to do. */
SET_STATUS_from_SysRes( ML_(do_fork)(tid) );
if (SUCCESS) {
/* Thread creation was successful; let the child have the chance
to run */
*flags |= SfYieldAfter;
}
}
// SYS_sbrk 69
// void * sbrk(intptr_t incr);
PRE(sys_sbrk)
{
PRINT("sys_sbrk ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(void*, "sbrk", vki_intptr_t, incr);
}
// SYS_freebsd11_vadvise 72
// @todo maybe
// SYS_munmap 73
// generic
// SYS_mprotect 74
// generic
// SYS_madvise 75
// generic
// SYS_mincore 78
// generic
// SYS_getgroups 79
// generic
// SYS_setgroups 80
// generic
// SYS_getpgrp 81
// generic
// SYS_setpgid 82
// generic
// SYS_setitimer 83
// generic
// SYS_swapon 85
// int swapon(const char *special);
PRE(sys_swapon)
{
PRINT("sys_swapon ( %#" FMT_REGWORD "x(%s) )", ARG1,(char*)ARG1);
PRE_REG_READ1(int, "swapon", const char*, special );
PRE_MEM_RASCIIZ( "swapon(special)", ARG1 );
}
// SYS_getitimer 86
// generic
// SYS_getdtablesize 89
// int getdtablesize(void);
PRE(sys_getdtablesize)
{
PRINT("%s", "sys_getdtablesize ( )");
PRE_REG_READ0(long, "getdtablesize");
}
// SYS_dup2 90
// generic
// SYS_fcntl 92
// int fcntl(int fd, int cmd, ...);
PRE(sys_fcntl)
{
switch (ARG2) {
// These ones ignore ARG3.
case VKI_F_GETFD:
case VKI_F_GETFL:
case VKI_F_GETOWN:
case VKI_F_GET_SEALS:
case VKI_F_ISUNIONSTACK:
PRINT("sys_fcntl ( %" FMT_REGWORD "d, %" FMT_REGWORD "d )", SARG1,SARG2);
PRE_REG_READ2(int, "fcntl", int, fd, int, cmd);
break;
// These ones use ARG3 as "arg".
case VKI_F_DUPFD:
case VKI_F_DUPFD_CLOEXEC:
case VKI_F_SETFD:
case VKI_F_SETFL:
case VKI_F_SETOWN:
case VKI_F_READAHEAD:
case VKI_F_RDAHEAD:
case VKI_F_ADD_SEALS:
PRINT("sys_fcntl[ARG3=='arg'] ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %" FMT_REGWORD "d )", SARG1,SARG2,SARG3);
PRE_REG_READ3(int, "fcntl",
int, fd, int, cmd, int, arg);
break;
// These ones use ARG3 as "lock" - obsolete.
case VKI_F_OSETLKW:
*flags |= SfMayBlock;
/* FALLTHROUGH */
case VKI_F_OGETLK:
case VKI_F_OSETLK:
PRINT("sys_fcntl[ARG3=='lock'] ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "fcntl",
int, fd, int, cmd,
struct oflock *, lock);
break;
// This one uses ARG3 as "oldd" and ARG4 as "newd".
case VKI_F_DUP2FD:
case VKI_F_DUP2FD_CLOEXEC:
PRINT("sys_fcntl[ARG3=='oldd', ARG4=='newd'] ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",
ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "fcntl",
int, fd, int, cmd,
unsigned long, oldd, unsigned long, newd);
break;
// These ones use ARG3 as "lock".
case VKI_F_SETLKW:
*flags |= SfMayBlock;
/* FALLTHROUGH */
case VKI_F_GETLK:
case VKI_F_SETLK:
case VKI_F_SETLK_REMOTE:
PRINT("sys_fcntl[ARG3=='lock'] ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "fcntl",
int, fd, int, cmd,
struct flock *, lock);
break;
case VKI_F_KINFO:
PRINT("sys_fcntl[ARG3=='kinfo_file'] ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "fcntl",
int, fd, int, cmd,
struct vki_kinfo_file *, kinfo);
if (ARG3) {
struct vki_kinfo_file* p_kinfo_file = (struct vki_kinfo_file*)ARG3;
PRE_MEM_WRITE("fcntl(ARG3=='kinfo_file)", ARG3, p_kinfo_file->vki_kf_structsize);
}
default:
PRINT("sys_fcntl[UNKNOWN] ( %lu, %lu, %lu )", ARG1,ARG2,ARG3);
I_die_here;
}
}
POST(sys_fcntl)
{
vg_assert(SUCCESS);
if (ARG2 == VKI_F_DUPFD) {
if (!ML_(fd_allowed)(RES, "fcntl(DUPFD)", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_named)(tid, RES);
}
} else if (ARG2 == VKI_F_DUPFD_CLOEXEC) {
if (!ML_(fd_allowed)(RES, "fcntl(DUPFD_CLOEXEC)", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_named)(tid, RES);
}
}
}
// SYS_select 93
// generic
// SYS_fsync 95
// generic
// SYS_setpriority 9
// generic
// SYS_socket 97
// int socket(int domain, int type, int protocol);
PRE(sys_socket)
{
PRINT("sys_socket ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %" FMT_REGWORD "d )",SARG1,SARG2,SARG3);
PRE_REG_READ3(int, "socket", int, domain, int, type, int, protocol);
}
POST(sys_socket)
{
SysRes r;
vg_assert(SUCCESS);
r = ML_(generic_POST_sys_socket)(tid, VG_(mk_SysRes_Success)(RES));
SET_STATUS_from_SysRes(r);
}
// SYS_connect 98
// int connect(int s, const struct sockaddr *name, socklen_t namelen);
PRE(sys_connect)
{
*flags |= SfMayBlock;
PRINT("sys_connect ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "connect",
int, s, const struct sockaddr *, name, int, namelen);
ML_(generic_PRE_sys_connect)(tid, ARG1,ARG2,ARG3);
}
// SYS_getpriority 100
// generic
// SYS_bind 104
// int bind(int s, const struct sockaddr *addr, socklen_t addrlen);
PRE(sys_bind)
{
PRINT("sys_bind ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "bind",
int, s, struct sockaddr *, addr, int, addrlen);
ML_(generic_PRE_sys_bind)(tid, ARG1,ARG2,ARG3);
}
// SYS_setsockopt 105
// int setsockopt(int s, int level, int optname, const void *optval,
// socklen_t optlen);
PRE(sys_setsockopt)
{
PRINT("sys_setsockopt ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",SARG1,SARG2,SARG3,ARG4,ARG5);
PRE_REG_READ5(int, "setsockopt",
int, s, int, level, int, optname,
const void *, optval, vki_socklen_t, optlen);
ML_(generic_PRE_sys_setsockopt)(tid, ARG1,ARG2,ARG3,ARG4,ARG5);
}
// SYS_listen 106
// int listen(int s, int backlog);
PRE(sys_listen)
{
PRINT("sys_listen ( %" FMT_REGWORD "d, %" FMT_REGWORD "d )",SARG1,SARG2);
PRE_REG_READ2(int, "listen", int, s, int, backlog);
}
//SYS_gettimeofday 116
// generic
// SYS_getrusage 117
// generic
// SYS_getsockopt 118
// int getsockopt(int s, int level, int optname, void * restrict optval,
// socklen_t * restrict optlen);
PRE(sys_getsockopt)
{
Addr optval_p = ARG4;
Addr optlen_p = ARG5;
PRINT("sys_getsockopt ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(int, "getsockopt",
int, s, int, level, int, optname,
void *, optval, int, *optlen);
if (optval_p != (Addr)NULL) {
ML_(buf_and_len_pre_check) ( tid, optval_p, optlen_p,
"getsockopt(optval)",
"getsockopt(optlen)" );
}
}
POST(sys_getsockopt)
{
Addr optval_p = ARG4;
Addr optlen_p = ARG5;
vg_assert(SUCCESS);
if (optval_p != (Addr)NULL) {
ML_(buf_and_len_post_check) ( tid, VG_(mk_SysRes_Success)(RES),
optval_p, optlen_p,
"getsockopt(optlen_out)" );
}
}
// SYS_readv 120
// generic
// SYS_writev 121
// generic
// SYS_settimeofday 122
// generic
// SYS_fchown 123
// generic
// SYS_fchmod 124
// generic
// SYS_setreuid 126
// generic
// SYS_setregid 127
// generic
// SYS_rename 128
// generic
// SYS_flock 131
// generic
// SYS_mkfifo 132
// int mkfifo(const char *path, mode_t mode);
PRE(sys_mkfifo)
{
PRINT("sys_mkfifo ( %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x )", ARG1, (char *)ARG1, ARG2, ARG3 );
PRE_REG_READ2(int, "mkfifo", const char *, path, int, mode);
PRE_MEM_RASCIIZ( "mkfifo(path)", ARG1 );
}
// SYS_sendto 133
// ssize_t sendto(int s, const void *msg, size_t len, int flags,
// const struct sockaddr *to, socklen_t tolen);
PRE(sys_sendto)
{
*flags |= SfMayBlock;
PRINT("sys_sendto ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
PRE_REG_READ6(ssize_t, "sendto",
int, s, const void *, msg, int, len,
int, flags,
const struct sockaddr *, to, socklen_t, tolen);
ML_(generic_PRE_sys_sendto)(tid, ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
}
// SYS_shutdown 134
// int shutdown(int s, int how);
PRE(sys_shutdown)
{
*flags |= SfMayBlock;
PRINT("sys_shutdown ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2);
PRE_REG_READ2(int, "shutdown", int, s, int, how);
}
// SYS_socketpair 135
// int socketpair(int domain, int type, int protocol, int *sv);
PRE(sys_socketpair)
{
PRINT("sys_socketpair ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "socketpair",
int, domain, int, type, int, protocol, int *, sv);
ML_(generic_PRE_sys_socketpair)(tid, ARG1,ARG2,ARG3,ARG4);
}
POST(sys_socketpair)
{
vg_assert(SUCCESS);
ML_(generic_POST_sys_socketpair)(tid, VG_(mk_SysRes_Success)(RES),
ARG1,ARG2,ARG3,ARG4);
}
// SYS_mkdir 136
// generic
// SYS_rmdir 137
// generic
// SYS_utimes 138
// generic
// SYS_adjtime 140
// int adjtime(const struct timeval *delta, struct timeval *olddelta);
PRE(sys_adjtime)
{
PRINT("sys_adjtime ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "adjtime",
const struct vki_timeval *, delta, struct vki_timeval *, olddelta);
PRE_MEM_READ("adjtime(delta)", ARG1, sizeof(struct vki_timeval));
if (ARG2) {
PRE_MEM_WRITE("adjtime(olddelta)", ARG1, sizeof(struct vki_timeval));
}
}
POST(sys_adjtime)
{
if (ARG2) {
POST_MEM_WRITE(ARG1, sizeof(struct vki_timeval));
}
}
// SYS_setsid 147
// generic
// SYS_quotactl 148
/* int quotactl(const char *path, int cmd, int id, void *addr); */
PRE(sys_quotactl)
{
PRINT("sys_quotactl ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3, ARG4);
switch (ARG2) {
case VKI_Q_QUOTAON:
case VKI_Q_SETQUOTA:
case VKI_Q_SETUSE:
case VKI_Q_GETQUOTASIZE:
PRE_REG_READ4(int, "quotactl",
const char *, path, int, cmd, int, id,
void *, addr);
PRE_MEM_RASCIIZ( "quotactl(path)", ARG1 );
break;
case VKI_Q_GETQUOTA:
if (VG_(tdict).track_pre_reg_read) {
\
PRRSN;
PRA1("quotactl",const char*,path);
PRA2("quotactl",int,cmd);
PRA4("quotactl",void*,addr);
}
break;
case VKI_Q_QUOTAOFF:
case VKI_Q_SYNC:
PRE_REG_READ2(int, "quotactl",
const char *, path, int, cmd);
break;
default:
break;
}
}
// SYS_nlm_syscall 154
// syscall.master says ; 154 is initialised by the NLM code, if present.
// @todo
// SYS_nfssvc 155
// int nfssvc(int flags, void *argstructp);
// lengthy manpage, at least 3 types of struct that argstructp can point to
// @todo
// SYS_lgetfh 160
// int lgetfh(const char *path, fhandle_t *fhp);
PRE(sys_lgetfh)
{
PRINT("sys_lgetfh ( %#" FMT_REGWORD "x, %" FMT_REGWORD "x ", ARG1, ARG2);
PRE_REG_READ2(int, "lgetfh", const char*, path, vki_fhandle_t*, fhp);
PRE_MEM_RASCIIZ( "lgetfh(path)", ARG1 );
PRE_MEM_WRITE("lgetfh(fhp)", ARG2, sizeof(vki_fhandle_t));
}
POST(sys_lgetfh)
{
POST_MEM_WRITE(ARG2, sizeof(vki_fhandle_t));
}
// SYS_getfh 161
// int getfh(const char *path, fhandle_t *fhp);
PRE(sys_getfh)
{
PRINT("sys_getfh ( %#" FMT_REGWORD "x, %" FMT_REGWORD "x ", ARG1, ARG2);
PRE_REG_READ2(int, "getfh", const char*, path, vki_fhandle_t*, fhp);
PRE_MEM_RASCIIZ( "getfh(path)", ARG1 );
PRE_MEM_WRITE("getfh(fhp)", ARG2, sizeof(vki_fhandle_t));
}
POST(sys_getfh)
{
POST_MEM_WRITE(ARG2, sizeof(vki_fhandle_t));
}
#if (FREEBSD_VERS <= FREEBSD_10)
// 162
// int getdomainname(char *domainname, int len);
PRE(sys_freebsd4_getdomainname)
{
PRINT("sys_freebsd4_getdomainname ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2);
PRE_REG_READ2(int, "getdomainname",
char *, domainname, int, len);
PRE_MEM_WRITE( "getdomainname(domainname)", ARG1, ARG2 );
}
POST(sys_freebsd4_getdomainname)
{
if (ARG1 != 0) {
POST_MEM_WRITE( ARG1, ARG2 );
}
}
// 163
// int setdomainname(char *domainname, int len);
PRE(sys_freebsd4_setdomainname)
{
PRINT("sys_freebsd4_setdomainname ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ2(int, "setdomainname", char *, domainname, int, len);
PRE_MEM_RASCIIZ( "setdomainname(domainname)", ARG1 );
}
// 164
// int uname(struct utsname *name);
PRE(sys_freebsd4_uname)
{
PRINT("sys_freebsd4_uname ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "uname", struct utsname *, name);
PRE_MEM_WRITE( "uname(name)", ARG1, sizeof(struct vki_utsname) );
}
POST(sys_freebsd4_uname)
{
if (ARG1 != 0) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_utsname) );
}
}
#endif
// SYS_sysarch 165
// x86/amd64
// SYS_rtprio 166
PRE(sys_rtprio)
{
PRINT( "sys_rtprio ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1, ARG2, ARG3 );
PRE_REG_READ3(int, "rtprio",
int, function, pid_t, pid, struct rtprio *, rtp);
if (ARG1 == VKI_RTP_SET) {
PRE_MEM_READ( "rtprio(rtp#set)", ARG3, sizeof(struct vki_rtprio));
} else if (ARG1 == VKI_RTP_LOOKUP) {
PRE_MEM_WRITE( "rtprio(rtp#lookup)", ARG3, sizeof(struct vki_rtprio));
} else {
/* PHK ?? */
}
}
POST(sys_rtprio)
{
if (ARG1 == VKI_RTP_LOOKUP && RES == 0)
POST_MEM_WRITE( ARG3, sizeof(struct vki_rtprio));
}
// freebsd6_pread 173 FREEBSD_VERS <= 10
// x86/amd64
// freebsd6_pwrite 174 FREEBSD_VERS <= 10
// x86/amd64
// SYS_setfib 175
// int setfib(int fib);
PRE(sys_setfib)
{
PRINT("sys_setfib ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "setfib", int, fib);
}
// SYS_ntp_adjtime 176
// int ntp_adjtime(struct timex *);
// @todo
// SYS_setgid 181
// generic
// SYS_setegid 182
// int setegid(gid_t egid);
PRE(sys_setegid)
{
PRINT("sys_setegid ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(int, "setegid", vki_gid_t, gid);
}
// SYS_seteuid 183
// int seteuid(uid_t euid);
PRE(sys_seteuid)
{
PRINT("sys_seteuid ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "seteuid", vki_uid_t, uid);
}
#if (FREEBSD_VERS >= FREEBSD_12)
// SYS_freebsd11_stat 188
// int stat(char *path, struct freebsd11_stat *sb);
PRE(sys_freebsd11_stat)
{
PRINT("sys_stat ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "stat", char *, path, struct freebsd11_stat *, sb);
PRE_MEM_RASCIIZ( "stat(path)", ARG1 );
PRE_MEM_WRITE( "stat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_freebsd11_stat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
// SYS_freebsd11_fstat 189
// int fstat(int fd, struct stat *sb);
PRE(sys_freebsd11_fstat)
{
PRINT("sys_freebsd11_fstat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",SARG1,ARG2);
PRE_REG_READ2(int, "fstat", int, fd, struct stat *, sb);
PRE_MEM_WRITE( "fstat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_freebsd11_fstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
// SYS_freebsd11_lstat 190
// int lstat(const char * restrict path, struct stat * restrict sb);
PRE(sys_freebsd11_lstat)
{
PRINT("sys_lstat ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(sb, "lstat", const char *, path, struct freebsd11_stat *, sb);
PRE_MEM_RASCIIZ( "lstat(path)", ARG1 );
PRE_MEM_WRITE( "lstat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_freebsd11_lstat)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
}
#else
PRE(sys_stat)
{
PRINT("sys_stat ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "stat", char *, path, struct stat *, sb);
PRE_MEM_RASCIIZ( "stat(path)", ARG1 );
PRE_MEM_WRITE( "stat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_stat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
PRE(sys_fstat)
{
PRINT("sys_fstat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",SARG1,ARG2);
PRE_REG_READ2(int, "fstat", int, fd, struct stat *, sb);
PRE_MEM_WRITE( "fstat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_fstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
PRE(sys_lstat)
{
PRINT("sys_lstat ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "lstat", const char *, path, struct stat *, sb);
PRE_MEM_RASCIIZ( "lstat(path)", ARG1 );
PRE_MEM_WRITE( "lstat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_lstat)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
}
#endif
// SYS_pathconf 191
// long pathconf(const char *path, int name);
PRE(sys_pathconf)
{
PRINT("sys_pathconf ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(long, "pathconf", char *, path, int, name);
PRE_MEM_RASCIIZ( "pathconf(path)", ARG1 );
}
// SYS_fpathconf 192
// long fpathconf(int fd, int name);
PRE(sys_fpathconf)
{
PRINT("sys_fpathconf ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2);
PRE_REG_READ2(long, "fpathconf", int, fd, int, name);
}
// SYS_getrlimit 194
// generic
// SYS_setrlimit 195
// generic
// SYS_freebsd11_getdirentries 196
// int getdirentries(int fd, char *buf, int nbytes, long *basep);
#if (FREEBSD_VERS >= FREEBSD_12)
PRE(sys_freebsd11_getdirentries)
{
*flags |= SfMayBlock;
PRINT("sys_freebsd11_getdirentries ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,ARG2,ARG3);
PRE_REG_READ4(int, "getdirentries",
int, fd, char *, buf,
int, nbytes,
long *, basep);
PRE_MEM_WRITE( "getdirentries(buf)", ARG2, ARG3 );
if (ARG4)
PRE_MEM_WRITE( "getdirentries(basep)", ARG4, sizeof(long) );
}
POST(sys_freebsd11_getdirentries)
{
vg_assert(SUCCESS);
if (RES > 0) {
POST_MEM_WRITE( ARG2, RES );
if ( ARG4 != 0 )
POST_MEM_WRITE( ARG4, sizeof (long));
}
}
#else
PRE(sys_getdirentries)
{
*flags |= SfMayBlock;
PRINT("sys_getdirentries ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,ARG2,ARG3);
PRE_REG_READ4(int, "getdirentries",
int, fd, char *, buf,
int, nbytes,
long *, basep);
PRE_MEM_WRITE( "getdirentries(buf)", ARG2, ARG3 );
if (ARG4)
PRE_MEM_WRITE( "getdirentries(basep)", ARG4, sizeof(long) );
}
POST(sys_getdirentries)
{
vg_assert(SUCCESS);
if (RES > 0) {
POST_MEM_WRITE( ARG2, RES );
if ( ARG4 != 0 )
POST_MEM_WRITE( ARG4, sizeof (long));
}
}
#endif
// SYS_freebsd6_mmap 197
// amd64 / x86
// SYS___syscall 198
// special handling
// freebsd6_lseek 199 FREEBSD_VERS <= 10
// x86/amd64
// freebsd6_truncate 200 FREEBSD_VERS <= 10
// x86/amd64
// freebsd6_ftruncate 201 FREEBSD_VERS <= 10
// x86/amd64
// SYS___sysctl 202
/* int __sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen); */
/* ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 */
PRE(sys___sysctl)
{
PRINT("sys_sysctl ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,SARG2,ARG3,ARG4,ARG5,ARG6 );
int* name = (int*)ARG1;
if (ML_(safe_to_deref)(name, sizeof(int))) {
PRINT("\nmib[0]: ");
if (SARG2 >= 1) {
switch (name[0]) {
case 0: // CTL_UNSPEC
PRINT("unspec");
break;
case 1: // CTL_KERN
PRINT("kern");
break;
case 2: // CTL_VM
PRINT("vm");
break;
case 3: // CTL_VFS
PRINT("vfs");
break;
case 4: // CTL_NET
PRINT("net");
break;
case 5: // CTL_DEBUG
PRINT("debug");
break;
case 6: // CTL_HW
PRINT("hw");
break;
case 7: // CTL_MACHDEP
PRINT("machdep");
break;
case 8: // CTL _USER
PRINT("user");
break;
case 9: //CTL_P1003_1B
PRINT("p1003_b1b");
break;
default:
PRINT("unrecognized (%d)", ((int*)ARG1)[0]);
break;
}
}
if (SARG2 >= 2 && ML_(safe_to_deref)(name, 2*sizeof(int))) {
PRINT(" mib[1]: %d\n", name[1]);
}
}
/*
* Special handling cases
*
* 1. kern.userstack
* This sysctl returns the address of the bottom of the user stack
* (that is the highest user stack address, since the stack grows
* downwards). Without any special handling this would return the
* address of the host userstack. We have created a stack for the
* guest (in aspacemgr) and that is the one that we want the guest
* to see. Aspacemgr is setup in m_main.c with the adresses and sizes
* saved to file static variables in that file, so we call
* VG_(get_usrstack)() to retrieve them from there.
*/
if (SARG2 >= 2 && ML_(safe_to_deref)(name, 2*sizeof(int))) {
if (name[0] == 1 && name[1] == 33) {
// kern.userstack
Word tmp = VG_(get_usrstack)();
size_t* out = (size_t*)ARG3;
size_t* outlen = (size_t*)ARG4;
*out = tmp;
*outlen = sizeof(size_t);
SET_STATUS_Success(0);
}
}
PRE_REG_READ6(int, "__sysctl", int *, name, vki_u_int32_t, namelen, void *, oldp,
vki_size_t *, oldlenp, void *, newp, vki_size_t, newlen);
// read number of ints specified in ARG2 from mem pointed to by ARG1
PRE_MEM_READ("sysctl(name)", (Addr)ARG1, ARG2 * sizeof(int));
// if 'newp' is not NULL can read namelen bytes from that address
if (ARG5 != (UWord)NULL)
PRE_MEM_READ("sysctl(newp)", (Addr)ARG5, ARG6);
// there are two scenarios for oldlenp/oldp
// 1. oldval is NULL and oldlenp is non-NULL
// this is a query of oldlenp so oldlenp will be written
// 2. Both are non-NULL
// this is a query of oldp, oldlenp will be read and oldp will
// be written
// is oldlenp is not NULL, can write
if (ARG4 != (UWord)NULL) {
if (ARG3 != (UWord)NULL) {
// case 2 above
PRE_MEM_READ("sysctl(oldlenp)", (Addr)ARG4, sizeof(vki_size_t));
if (ML_(safe_to_deref)((void*)(Addr)ARG4, sizeof(vki_size_t))) {
PRE_MEM_WRITE("sysctl(oldp)", (Addr)ARG3, *(vki_size_t *)ARG4);
} else {
VG_(dmsg)("Warning: Bad oldlenp address %p in sysctl\n",
(void *)(Addr)ARG4);
SET_STATUS_Failure ( VKI_EFAULT );
}
} else {
// case 1 above
PRE_MEM_WRITE("sysctl(oldlenp)", (Addr)ARG4, sizeof(vki_size_t));
}
}
}
POST(sys___sysctl)
{
if (ARG4 != (UWord)NULL) {
if (ARG3 != (UWord)NULL) {
//POST_MEM_WRITE((Addr)ARG4, sizeof(vki_size_t));
POST_MEM_WRITE((Addr)ARG3, *(vki_size_t *)ARG4);
} else
POST_MEM_WRITE((Addr)ARG4, sizeof(vki_size_t));
}
}
// SYS_mlock 203
// generic
// SYS_munlock 204
// generic
// SYS_undelete 205
// int undelete(const char *path);
PRE(sys_undelete)
{
*flags |= SfMayBlock;
PRINT("sys_undelete ( %#" FMT_REGWORD "x(%s) )", ARG1,(char *)ARG1);
PRE_REG_READ1(int, "undelete", const char *, path);
PRE_MEM_RASCIIZ( "undelete(path)", ARG1 );
}
// SYS_futimes 206
// int futimes(int fd, const struct timeval *times);
PRE(sys_futimes)
{
PRINT("sys_lutimes ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(long, "futimes", int, fd, struct timeval *, times);
if (ARG2 != 0)
PRE_MEM_READ( "futimes(times)", ARG2, sizeof(struct vki_timeval) );
}
// SYS_getpgid 207
// generic
// SYS_poll 209
// generic
// SYS_freebsd7___semctl 220
// int semctl(int semid, int semnum, int cmd, ...);
PRE(sys_freebsd7___semctl)
{
switch (ARG3) {
case VKI_IPC_INFO:
case VKI_SEM_INFO:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "semctl",
int, semid, int, semnum, int, cmd, struct seminfo *, arg);
break;
case VKI_IPC_STAT:
case VKI_SEM_STAT:
case VKI_IPC_SET:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "semctl",
int, semid, int, semnum, int, cmd, struct vki_semid_ds_old *, arg);
break;
case VKI_GETALL:
case VKI_SETALL:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "semctl",
int, semid, int, semnum, int, cmd, unsigned short *, arg);
break;
default:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "semctl",
int, semid, int, semnum, int, cmd);
break;
}
ML_(generic_PRE_sys_semctl)(tid, ARG1,ARG2,ARG3,ARG4);
}
POST(sys_freebsd7___semctl)
{
ML_(generic_POST_sys_semctl)(tid, RES,ARG1,ARG2,ARG3,ARG4);
}
// SYS_semget 221
// int semget(key_t key, int nsems, int flag);
PRE(sys_semget)
{
PRINT("sys_semget ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "semget", vki_key_t, key, int, nsems, int, flag);
}
// SYS_semop 222
// int semop(int semid, struct sembuf *array, size_t nops);
PRE(sys_semop)
{
*flags |= SfMayBlock;
PRINT("sys_semop ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "semop",
int, semid, struct sembuf *, array, unsigned, nops);
ML_(generic_PRE_sys_semop)(tid, ARG1,ARG2,ARG3);
}
// SYS_freebsd7_msgctl 224
// int msgctl(int msqid, int cmd, struct msqid_ds_old *buf);
PRE(sys_freebsd7_msgctl)
{
PRINT("sys_freebsd7_msgctl ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1,SARG2,ARG3 );
PRE_REG_READ3(int, "msgctl", int, msqid, int, cmd, struct msqid_ds_old *, buf);
switch (ARG2 /* cmd */) {
case VKI_IPC_STAT:
PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)",
ARG3, sizeof(struct vki_msqid_ds_old) );
break;
case VKI_IPC_SET:
PRE_MEM_READ( "msgctl(IPC_SET, buf)",
ARG3, sizeof(struct vki_msqid_ds_old) );
break;
}
}
POST(sys_freebsd7_msgctl)
{
switch (ARG2 /* cmd */) {
case VKI_IPC_STAT:
POST_MEM_WRITE( ARG3, sizeof(struct vki_msqid_ds_old) );
break;
}
}
// SYS_msgget 225
// int msgget(key_t key, int msgflg);
PRE(sys_msgget)
{
PRINT("sys_msgget ( %" FMT_REGWORD"d, %" FMT_REGWORD"d )",SARG1,SARG2);
PRE_REG_READ2(int, "msgget", key_t, key, int, msgflg);
}
// SYS_msgsnd 226
// int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg);
PRE(sys_msgsnd)
{
PRINT("sys_msgsnd ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %" FMT_REGWORD "d )", SARG1,ARG2,SARG3,SARG4 );
PRE_REG_READ4(int, "msgsnd", int, msqid, struct msgbuf *, msgp, size_t, msgsz, int, msgflg);
struct vki_msgbuf *msgp = (struct vki_msgbuf *)ARG2;
PRE_MEM_READ( "msgsnd(msgp->mtype)", (Addr)&msgp->mtype, sizeof(msgp->mtype) );
PRE_MEM_READ( "msgsnd(msgp->mtext)", (Addr)&msgp->mtext, ARG3 );
}
// SYS_msgrcv 227
// ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg);
PRE(sys_msgrcv)
{
*flags |= SfMayBlock;
PRINT("sys_msgrcv ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "d, %" FMT_REGWORD "d )", SARG1,ARG2,ARG3,SARG4,SARG5 );
PRE_REG_READ5(ssize_t, "msgrcv", int, msqid, struct msgbuf *, msgp, size_t, msgsz,
long, msgtyp, int, msgflg);
struct vki_msgbuf *msgp = (struct vki_msgbuf *)ARG2;
PRE_MEM_WRITE( "msgrcv(msgp->mtype)", (Addr)&msgp->mtype, sizeof(msgp->mtype) );
PRE_MEM_WRITE( "msgrcv(msgp->mtext)", (Addr)&msgp->mtext, ARG3 );
}
POST(sys_msgrcv)
{
struct vki_msgbuf *msgp = (struct vki_msgbuf *)ARG2;
POST_MEM_WRITE( (Addr)&msgp->mtype, sizeof(msgp->mtype) );
POST_MEM_WRITE( (Addr)&msgp->mtext, RES );
}
// SYS_shmat 228
// void * shmat(int shmid, const void *addr, int flag);
PRE(sys_shmat)
{
UWord arg2tmp;
PRINT("sys_shmat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(void *, "shmat",
int, shmid, const void *, addr, int, flag);
arg2tmp = ML_(generic_PRE_sys_shmat)(tid, ARG1,ARG2,ARG3);
if (arg2tmp == 0)
SET_STATUS_Failure( VKI_EINVAL );
else
ARG2 = arg2tmp;
}
POST(sys_shmat)
{
ML_(generic_POST_sys_shmat)(tid, RES,ARG1,ARG2,ARG3);
}
// SYS_freebsd7_shmctl 229
// int shmctl(int shmid, int cmd, struct shmid_ds *buf);
PRE(sys_freebsd7_shmctl)
{
PRINT("sys_freebsd7_shmctl ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",SARG1,SARG2,ARG3);
PRE_REG_READ3(int, "shmctl",
int, shmid, int, cmd, struct vki_shmid_ds_old *, buf);
switch (ARG2 /* cmd */) {
case VKI_IPC_STAT:
PRE_MEM_WRITE( "shmctl7(IPC_STAT, buf)",
ARG3, sizeof(struct vki_shmid_ds_old) );
break;
case VKI_IPC_SET:
PRE_MEM_READ( "shmctl7(IPC_SET, buf)",
ARG3, sizeof(struct vki_shmid_ds_old) );
break;
}
}
POST(sys_freebsd7_shmctl)
{
if (ARG2 == VKI_IPC_STAT) {
POST_MEM_WRITE( ARG3, sizeof(struct vki_shmid_ds_old) );
}
}
// SYS_shmdt 230
// int shmdt(const void *addr);
PRE(sys_shmdt)
{
PRINT("sys_shmdt ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(int, "shmdt", const void *, addr);
if (!ML_(generic_PRE_sys_shmdt)(tid, ARG1))
SET_STATUS_Failure( VKI_EINVAL );
}
POST(sys_shmdt)
{
ML_(generic_POST_sys_shmdt)(tid, RES,ARG1);
}
// SYS_shmget 231
// int shmget(key_t key, size_t size, int flag);
PRE(sys_shmget)
{
PRINT("sys_shmget ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "shmget", vki_key_t, key, vki_size_t, size, int, flag);
}
// SYS_clock_gettime 232
// int clock_gettime(clockid_t clock_id, struct timespec *tp);
PRE(sys_clock_gettime)
{
PRINT("sys_clock_gettime( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(int, "clock_gettime",
vki_clockid_t, clk_id, struct timespec *, tp);
PRE_MEM_WRITE( "clock_gettime(tp)", ARG2, sizeof(struct vki_timespec) );
}
POST(sys_clock_gettime)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
}
// SYS_clock_settime 233
// int clock_settime(clockid_t clock_id, const struct timespec *tp);
PRE(sys_clock_settime)
{
PRINT("sys_clock_settime( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(int, "clock_settime",
vki_clockid_t, clk_id, const struct timespec *, tp);
PRE_MEM_READ( "clock_settime(tp)", ARG2, sizeof(struct vki_timespec) );
}
// SYS_clock_getres 234
// int clock_getres(clockid_t clock_id, struct timespec *tp);
PRE(sys_clock_getres)
{
PRINT("sys_clock_getres( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2);
// Nb: we can't use "RES" as the param name because that's a macro
// defined above!
PRE_REG_READ2(int, "clock_getres",
vki_clockid_t, clock_id, struct timespec *, tp);
if (ARG2 != 0)
PRE_MEM_WRITE( "clock_getres(tp)", ARG2, sizeof(struct vki_timespec) );
}
POST(sys_clock_getres)
{
if (ARG2 != 0)
POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
}
// SYS_ktimer_create 235
// int timer_create(clockid_t clockid, struct sigevent *restrict evp,
// timer_t *restrict timerid);
PRE(sys_timer_create)
{
PRINT("sys_timer_create( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", SARG1,ARG2,ARG3);
PRE_REG_READ3(int, "timer_create",
vki_clockid_t, clockid, struct sigevent *, evp,
vki_timer_t *, timerid);
if (ARG2 != 0)
PRE_MEM_READ( "timer_create(evp)", ARG2, sizeof(struct vki_sigevent) );
PRE_MEM_WRITE( "timer_create(timerid)", ARG3, sizeof(vki_timer_t) );
}
POST(sys_timer_create)
{
POST_MEM_WRITE( ARG3, sizeof(vki_timer_t) );
}
// SYS_ktimer_delete 236
// int timer_delete(timer_t timerid);
PRE(sys_timer_delete)
{
PRINT("sys_timer_delete( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "timer_delete", vki_timer_t, timerid);
}
// SYS_ktimer_settime 237
// int timer_settime(timer_t timerid, int flags,
// const struct itimerspec *restrict value,
// struct itimerspec *restrict ovalue);
PRE(sys_timer_settime)
{
PRINT("sys_timer_settime( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,SARG2,ARG3,ARG4);
PRE_REG_READ4(int, "timer_settime",
vki_timer_t, timerid, int, flags,
const struct itimerspec *, value,
struct itimerspec *, ovalue);
PRE_MEM_READ( "timer_settime(value)", ARG3,
sizeof(struct vki_itimerspec) );
if (ARG4 != 0)
PRE_MEM_WRITE( "timer_settime(ovalue)", ARG4,
sizeof(struct vki_itimerspec) );
}
POST(sys_timer_settime)
{
if (ARG4 != 0)
POST_MEM_WRITE( ARG4, sizeof(struct vki_itimerspec) );
}
// SYS_ktimer_gettime 238
// int timer_gettime(timer_t timerid, struct itimerspec *value);
PRE(sys_timer_gettime)
{
PRINT("sys_timer_gettime( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(long, "timer_gettime",
vki_timer_t, timerid, struct itimerspec *, value);
PRE_MEM_WRITE( "timer_gettime(value)", ARG2,
sizeof(struct vki_itimerspec));
}
POST(sys_timer_gettime)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_itimerspec) );
}
// SYS_ktimer_getoverrun 239
// int timer_getoverrun(timer_t timerid);
PRE(sys_timer_getoverrun)
{
PRINT("sys_timer_getoverrun( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "timer_getoverrun", vki_timer_t, timerid);
}
// SYS_nanosleep 240
// generic
// SYS_ffclock_getcounter 241
// int ffclock_getcounter(ffcounter *ffcount);
// @todo
// SYS_ffclock_setestimate 242
// int ffclock_setestimate(struct ffclock_estimate *cest);
// @todo
// SYS_ffclock_getestimate 243
// int ffclock_getestimate(struct ffclock_estimate *cest);
// @todo
// SYS_clock_nanosleep 244
// int clock_nanosleep(clockid_t clock_id, int flags,
// const struct timespec *rqtp, struct timespec *rmtp);
PRE(sys_clock_nanosleep)
{
*flags |= SfMayBlock|SfPostOnFail;
PRINT("sys_clock_nanosleep ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "clock_nanosleep", clockid_t, clock_id, int, flags,
const struct timespec *, rqtp, struct timespec *, rmtp);
PRE_MEM_READ("clock_nanosleep(rqtp)", ARG1, sizeof(struct vki_timespec));
if (ARG2 != 0)
PRE_MEM_WRITE( "clock_nanosleep(rmtp)", ARG2, sizeof(struct vki_timespec) );
}
POST(sys_clock_nanosleep)
{
if (ARG2 != 0)
POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
}
// SYS_clock_getcpuclockid2 247
// x86/amd64
POST(sys_clock_getcpuclockid2)
{
POST_MEM_WRITE(ARG3, sizeof(vki_clockid_t));
}
// SYS_ntp_gettime 248
// int ntp_gettime(struct ntptimeval *);
// @todo
// SYS_minherit 250
// int minherit(void *addr, size_t len, int inherit);
PRE(sys_minherit)
{
PRINT("sys_minherit( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "minherit",
void *, addr, vki_size_t, len, int, inherit);
if (ARG2 != 0)
PRE_MEM_WRITE( "minherit(addr)", ARG1,ARG2 );
}
POST(sys_minherit)
{
if (ARG2 != 0)
POST_MEM_WRITE( ARG1, ARG2 );
}
// SYS_rfork 251
// x86/amd64 not functional
// SYS_issetugid 253
// int issetugid(void);
PRE(sys_issetugid)
{
PRINT("%s", "sys_issetugid ()");
PRE_REG_READ0(long, "issetugid");
}
// SYS_lchown 254
// generic
// SYS_aio_read 255
// int aio_read(struct aiocb *iocb);
PRE(sys_aio_read)
{
PRINT("sys_aio_read ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "aio_read", struct vki_aiocb *, iocb);
PRE_MEM_READ("aio_read(iocb)", ARG1, sizeof(struct vki_aiocb));
if (ML_(safe_to_deref)((struct vki_aiocb *)ARG1, sizeof(struct vki_aiocb))) {
struct vki_aiocb *iocb = (struct vki_aiocb *)ARG1;
PRE_MEM_WRITE( "aio_read(iocb->aio_offset)", (Addr)iocb, sizeof(struct vki_aiocb));
}
}
POST(sys_aio_read)
{
if (ML_(safe_to_deref)((struct vki_aiocb *)ARG1, sizeof(struct vki_aiocb))) {
struct vki_aiocb *iocb = (struct vki_aiocb *)ARG1;
POST_MEM_WRITE((Addr)iocb, sizeof(struct vki_aiocb));
}
}
// SYS_aio_write 256
// int aio_write(struct aiocb *iocb);
PRE(sys_aio_write)
{
PRINT("sys_aio_write ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "aio_write", struct vki_aiocb *, iocb);
PRE_MEM_READ("aio_read(iocb)", ARG1, sizeof(struct vki_aiocb));
if (ML_(safe_to_deref)((struct vki_aiocb *)ARG1, sizeof(struct vki_aiocb))) {
struct vki_aiocb *iocb = (struct vki_aiocb *)ARG1;
PRE_MEM_WRITE( "aio_write(iocb->aio_offset)", (Addr)iocb, sizeof(struct vki_aiocb));
}
}
POST(sys_aio_write)
{
if (ML_(safe_to_deref)((struct vki_aiocb *)ARG1, sizeof(struct vki_aiocb))) {
struct vki_aiocb *iocb = (struct vki_aiocb *)ARG1;
PRE_MEM_WRITE( "aio_write(iocb->aio_offset)", (Addr)iocb, sizeof(struct vki_aiocb));
}
}
// SYS_lio_listio 257
// int lio_listio(int mode, struct aiocb * const list[], int nent,
// struct sigevent *sig);
PRE(sys_lio_listio)
{
PRINT("sys_lio_listio ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",
SARG1, ARG2, SARG3, ARG4);
PRE_REG_READ4(int, "lio_listio", int, mode, struct aiocb * const *, list, int, nent,
struct sigevent *,sig);
PRE_MEM_READ("lio_listio(list)", ARG2, ARG3*sizeof(struct vki_aiocb *));
// loop check elements
if (ML_(safe_to_deref)((struct vki_aiocb **)ARG2, ARG3*sizeof(struct vki_aiocb *))) {
struct vki_aiocb** list = (struct vki_aiocb **)ARG2;
for (int i = 0; i < (int)ARG3; ++i) {
if (list[i]) {
PRE_MEM_READ("lio_listio(list[?])", (Addr)list[i], ARG3*sizeof(struct vki_aiocb));
}
// @todo
// figure out what gets read/written
// when list[i]->aio_lio_opcode == VKI_LIO_READ and
// when list[i]->aio_lio_opcode == VKI_LIO_WRITE
//if (ML_(safe_to_deref)(list[i], ARG3*sizeof(struct vki_aiocb))) {
//}
}
}
if (ARG1 & VKI_LIO_WAIT) {
*flags |= SfMayBlock;
}
if (ARG4 && (ARG1 == VKI_LIO_NOWAIT)) {
PRE_MEM_READ("lio_listio(sig)", ARG4, sizeof(struct vki_sigevent));
}
}
// SYS_freebsd11_getdents 272
// generic
// SYS_lchmod 274
// int lchmod(const char *path, mode_t mode);
PRE(sys_lchmod)
{
PRINT("sys_lchmod ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "lchmod", const char *, path, vki_mode_t, mode);
PRE_MEM_RASCIIZ( "lchmod(path)", ARG1 );
}
// SYS_lutimes 276
// int lutimes(const char *path, const struct timeval *times);
PRE(sys_lutimes)
{
PRINT("sys_lutimes ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "lutimes", char *, path, struct timeval *, times);
PRE_MEM_RASCIIZ( "lutimes(path)", ARG1 );
if (ARG2 != 0)
PRE_MEM_READ( "lutimes(times)", ARG2, sizeof(struct vki_timeval) );
}
// SYS_freebsd11_nstat 278
// @todo, maybe
// SYS_freebsd11_nfstat 279
// @todo, maybe
// SYS_freebsd11_nlstat 280
// @todo, maybe
// SYS_preadv 289
// amd64 / x86
// SYS_pwritev 290
// amd64 / x86
// SYS_fhopen 298
// int fhopen(const fhandle_t *fhp, int flags);
PRE(sys_fhopen)
{
PRINT("sys_open ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",ARG1,ARG2);
PRE_REG_READ2(int, "fhopen",
struct fhandle_t *, fhp, int, flags);
PRE_MEM_READ( "fhopen(fhp)", ARG1, sizeof(struct vki_fhandle) );
/* Otherwise handle normally */
*flags |= SfMayBlock;
}
POST(sys_fhopen)
{
vg_assert(SUCCESS);
if (!ML_(fd_allowed)(RES, "fhopen", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_nameless)(tid, RES);
}
}
// SYS_freebsd11_fhstat 299
// int fhstat(const fhandle_t *fhp, struct stat *sb);
#if (FREEBSD_VERS >= FREEBSD_12)
PRE(sys_freebsd11_fhstat)
{
PRINT("sys_freebsd11_fhstat ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "fhstat", struct fhandle *, fhp, struct freebd11_stat *, sb);
PRE_MEM_READ( "fhstat(fhp)", ARG1, sizeof(struct vki_fhandle) );
PRE_MEM_WRITE( "fhstat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_freebsd11_fhstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
#else
PRE(sys_fhstat)
{
PRINT("sys_fhstat ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "fhstat", struct fhandle *, fhp, struct stat *, sb);
PRE_MEM_READ( "fhstat(fhp)", ARG1, sizeof(struct vki_fhandle) );
PRE_MEM_WRITE( "fhstat(sb)", ARG2, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_fhstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_stat) );
}
#endif
// SYS_modnext 300
// int modnext(int modid);
PRE(sys_modnext)
{
PRINT("sys_modnext ( %" FMT_REGWORD "d )",SARG1);
PRE_REG_READ1(int, "modnext", int, modid);
}
// SYS_modstat 301
// int modstat(int modid, struct module_stat *stat);
PRE(sys_modstat)
{
PRINT("sys_modstat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "modstat", int, modid, struct module_stat *, buf);
PRE_MEM_WRITE( "modstat(stat)", ARG2, sizeof(struct vki_module_stat) );
}
POST(sys_modstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_module_stat) );
}
// SYS_modfnext 302
// int modfnext(int modid);
PRE(sys_modfnext)
{
PRINT("sys_modfnext ( %" FMT_REGWORD "d )",SARG1);
PRE_REG_READ1(int, "modfnext", int, modid);
}
// SYS_modfind 303
// int modfind(const char *modname);
PRE(sys_modfind)
{
PRINT("sys_modfind ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(long, "modfind", char *, modname);
PRE_MEM_RASCIIZ( "modfind(modname)", ARG1 );
}
// SYS_kldload 304
// int kldload(const char *file);
PRE(sys_kldload)
{
PRINT("sys_kldload ( %#" FMT_REGWORD "x(%s) )", ARG1, (char *)ARG1);
PRE_REG_READ1(int, "kldload", const char *, "file");
PRE_MEM_RASCIIZ( "kldload(file)", ARG1 );
}
// SYS_kldunload 305
// int kldunload(int fileid);
PRE(sys_kldunload)
{
PRINT("sys_kldunload ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(int, "kldunload", int, "fileid");
}
// SYS_kldfind 306
// int kldfind(const char *file);
PRE(sys_kldfind)
{
PRINT("sys_kldfind ( %#" FMT_REGWORD "x(%s) )", ARG1, (char *)ARG1);
PRE_REG_READ1(int, "kldfind", const char *, file);
PRE_MEM_RASCIIZ( "kldfind(file)", ARG1 );
}
// SYS_kldnext 307
// int kldnext(int fileid);
PRE(sys_kldnext)
{
PRINT("sys_kldnext ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(int, "kldnext", int, fileid);
}
// SYS_kldstat 308
// int kldstat(int fileid, struct kld_file_stat *stat);
PRE(sys_kldstat)
{
PRINT("sys_kldstat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(int, "kldstat", int, fileid, struct kld_file_stat*, stat);
PRE_MEM_WRITE("kldstat(stat)", ARG2, sizeof(struct vki_kld_file_stat));
}
POST(sys_kldstat)
{
POST_MEM_WRITE(ARG2, sizeof(struct vki_kld_file_stat));
}
// SYS_kldfirstmod 309
// int kldfirstmod(int fileid);
PRE(sys_kldfirstmod)
{
PRINT("sys_kldfirstmod ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(int, "kldfirstmod", int, fileid);
}
// SYS_setresuid 311
// int setresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
PRE(sys_setresuid)
{
PRINT("sys_setresuid ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "setresuid",
vki_uid_t, ruid, vki_uid_t, euid, vki_uid_t, suid);
}
// SYS_setresgid 312
// int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
PRE(sys_setresgid)
{
PRINT("sys_setresgid ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "setresgid",
vki_gid_t, rgid, vki_gid_t, egid, vki_gid_t, sgid);
}
// SYS_aio_return 314
// ssize_t aio_return(struct aiocb *iocb);
PRE(sys_aio_return)
{
PRINT("sys_aio_return ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(ssize_t, "aio_return", struct aiocb *, iocb);
// not too clear if this is read-only, sounds like it from the man page
// but it isn't const
PRE_MEM_READ("aio_return(iocb)", ARG1, sizeof(struct vki_aiocb));
}
// SYS_aio_suspend 315
// int aio_suspend(const struct aiocb *const iocbs[], int niocb,
// const struct timespec *timeout);
PRE(sys_aio_suspend)
{
PRINT("sys_aio_suspend ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ3(int, "aio_suspend", struct aiocb **, iocbs, int, nbiocb, const struct timespec*, timeout);
PRE_MEM_READ("aio_suspend(iocbs)", ARG1, ARG2*sizeof(struct vki_aiocb));
PRE_MEM_READ("aio_suspend(timeout)", ARG3, sizeof(struct vki_timespec));
}
// SYS_aio_cancel 316
// int aio_cancel(int fildes, struct aiocb *iocb);
PRE(sys_aio_cancel)
{
PRINT("sys_aio_cancel ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(int, "aio_cancel", int, fildex, struct aiocb *, iocb);
if (ARG2) {
PRE_MEM_READ("aio_cancel(iocb)", ARG2, sizeof(struct vki_aiocb));
}
}
// SYS_aio_error 317
// int aio_error(const struct aiocb *iocb);
PRE(sys_aio_error)
{
PRINT("sys_aio_error ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(ssize_t, "aio_error", struct aiocb *, iocb);
PRE_MEM_READ("aio_error(iocb)", ARG1, sizeof(struct vki_aiocb));
}
// SYS_yield 321
int yield(void);
PRE(sys_yield)
{
*flags |= SfMayBlock;
PRINT("%s", "yield()");
PRE_REG_READ0(long, "yield");
}
// SYS_mlockall 324
// generic
// SYS_munlockall 325
// int munlockall(void);
PRE(sys_munlockall)
{
*flags |= SfMayBlock;
PRINT("%s", "sys_munlockall ( )");
PRE_REG_READ0(int, "munlockall");
}
// SYS___getcwd 326
// int __getcwd(char *buf, size_t buflen);
PRE(sys___getcwd)
{
PRINT("sys___getcwd ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,ARG2);
PRE_REG_READ2(long, "__getcwd", char *, buf, unsigned int, buflen);
PRE_MEM_WRITE( "__getcwd(buf)", ARG1, ARG2 );
}
POST(sys___getcwd)
{
vg_assert(SUCCESS);
if (RES == 0) {
// QQQ it is unclear if this is legal or not, but the
// QQQ kernel just wrote it there...
// QQQ Why oh why didn't phk return the length from __getcwd()?
UInt len = VG_(strlen) ( (char *)ARG1 ) + 1;
POST_MEM_WRITE( ARG1, len );
}
}
//SYS_sched_setparam 327
// int sched_setparam(pid_t pid, const struct sched_param *param);
PRE(sys_sched_setparam)
{
PRINT("sched_setparam ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2 );
PRE_REG_READ2(int, "sched_setparam",
vki_pid_t, pid, struct sched_param *, param);
PRE_MEM_READ( "sched_setparam(param)", ARG2, sizeof(struct vki_sched_param) );
}
POST(sys_sched_setparam)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_sched_param) );
}
// SYS_sched_getparam 328
// int sched_getparam(pid_t pid, struct sched_param *param);
PRE(sys_sched_getparam)
{
PRINT("sched_getparam ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2 );
PRE_REG_READ2(int, "sched_getparam",
vki_pid_t, pid, struct sched_param *, param);
PRE_MEM_WRITE( "sched_getparam(param)", ARG2, sizeof(struct vki_sched_param) );
}
POST(sys_sched_getparam)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_sched_param) );
}
// SYS_sched_setscheduler 329
// int sched_setscheduler(pid_t pid, int policy,
// const struct sched_param *param);
PRE(sys_sched_setscheduler)
{
PRINT("sys_sched_setscheduler ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1,SARG2,ARG3);
PRE_REG_READ3(int, "sched_setscheduler",
vki_pid_t, pid, int, policy, struct sched_param *, param);
if (ARG3 != 0)
PRE_MEM_READ("sched_setscheduler(param)",
ARG3, sizeof(struct vki_sched_param));
}
// SYS_sched_getscheduler 330
// int sched_getscheduler(pid_t pid);
PRE(sys_sched_getscheduler)
{
PRINT("sys_sched_getscheduler ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "sched_getscheduler", vki_pid_t, pid);
}
// SYS_sched_yield 331
// int sched_yield(void);
PRE(sys_sched_yield)
{
*flags |= SfMayBlock;
PRINT("sched_yield()");
PRE_REG_READ0(int, "sched_yield");
}
// SYS_sched_get_priority_max 332
// int sched_get_priority_max(int policy);
PRE(sys_sched_get_priority_max)
{
PRINT("sched_get_priority_max ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "sched_get_priority_max", int, policy);
}
// SYS_sched_get_priority_min 333
// int sched_get_priority_min(int policy);
PRE(sys_sched_get_priority_min)
{
PRINT("sched_get_priority_min ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "sched_get_priority_min", int, policy);
}
// SYS_sched_rr_get_interval 334
// int sched_rr_get_interval(pid_t pid, struct timespec *interval);
PRE(sys_sched_rr_get_interval)
{
PRINT("sys_sched_rr_get_interval ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(int, "sched_rr_get_interval", vki_pid_t, pid, struct vki_timespec *,interval);
PRE_MEM_WRITE("sys_sched_rr_get_interval(interval)", ARG2, sizeof(struct vki_timespec));
}
POST(sys_sched_rr_get_interval)
{
POST_MEM_WRITE(ARG2, sizeof(struct vki_timespec));
}
// SYS_utrace 335
// int utrace(const void *addr, size_t len);
PRE(sys_utrace)
{
PRINT("sys_utrace ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(int, "utrace", const void *, addr, vki_size_t, len);
PRE_MEM_READ( "utrace(addr)", ARG2, ARG3 );
}
// SYS_kldsym 337
// int kldsym(int fileid, int cmd, void *data);
PRE(sys_kldsym)
{
PRINT("sys_kldsym ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3 );
PRE_REG_READ3(int, "kldsym", int, fileid, int, cmd, void*, data);
PRE_MEM_READ( "kldsym(data)", ARG3, sizeof(struct vki_kld_sym_lookup) );
struct vki_kld_sym_lookup *kslp = (struct vki_kld_sym_lookup *)ARG3;
if (ML_(safe_to_deref)(kslp, sizeof(struct vki_kld_sym_lookup))) {
PRE_MEM_RASCIIZ( "kldsym(data.symname)", (Addr)kslp->symname );
}
}
POST(sys_kldsym)
{
struct vki_kld_sym_lookup *kslp = (struct vki_kld_sym_lookup *)ARG3;
POST_MEM_WRITE( (Addr)&kslp->symvalue, sizeof(kslp->symvalue) );
POST_MEM_WRITE( (Addr)&kslp->symsize, sizeof(kslp->symsize) );
}
// SYS_jail 338
// int jail(struct jail *jail);
PRE(sys_jail)
{
PRINT("sys_jail ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "jail", struct jail *, jail);
PRE_MEM_READ( "jail(jail)", ARG1, sizeof(struct vki_jail) );
}
// SYS_nnpfs_syscall 338
// @todo
// SYS_sigprocmask 340
// int sigprocmask(int how, const sigset_t * restrict set,
// sigset_t * restrict oset);
PRE(sys_sigprocmask)
{
PRINT("sys_sigprocmask ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "sigprocmask",
int, how, vki_sigset_t *, set, vki_sigset_t *, oset);
if (ARG2 != 0)
PRE_MEM_READ( "sigprocmask(set)", ARG2, sizeof(vki_sigset_t));
if (ARG3 != 0)
PRE_MEM_WRITE( "sigprocmask(oset)", ARG3, sizeof(vki_sigset_t));
if (ARG2 != 0 &&
!ML_(safe_to_deref)((void *)(Addr)ARG2, sizeof(vki_sigset_t))) {
VG_(dmsg)("Warning: Bad set handler address %p in sigprocmask\n",
(void *)(Addr)ARG2);
SET_STATUS_Failure ( VKI_EFAULT );
} else if (ARG3 != 0 &&
!ML_(safe_to_deref)((void *)(Addr)ARG3, sizeof(vki_sigset_t))) {
VG_(dmsg)("Warning: Bad oldset address %p in sigprocmask\n",
(void *)(Addr)ARG3);
SET_STATUS_Failure ( VKI_EFAULT );
} else {
SET_STATUS_from_SysRes(VG_(do_sys_sigprocmask)(tid, ARG1 /*how*/,
(vki_sigset_t*)(Addr)ARG2,
(vki_sigset_t*)(Addr)ARG3));
}
if (SUCCESS)
*flags |= SfPollAfter;
}
POST(sys_sigprocmask)
{
vg_assert(SUCCESS);
if (RES == 0 && ARG3 != 0)
POST_MEM_WRITE( ARG3, sizeof(vki_sigset_t));
}
// SYS_sigsuspend 341
// int sigsuspend(const sigset_t *sigmask);
PRE(sys_sigsuspend)
{
*flags |= SfMayBlock;
PRINT("sys_sigsuspend ( %#" FMT_REGWORD "x )", ARG1 );
PRE_REG_READ1(int, "sigsuspend", const vki_sigset_t *, sigmask);
PRE_MEM_READ( "sigsuspend(sigmask)", ARG1, sizeof(vki_sigset_t) );
if (ARG1) {
ARG1 = ML_(make_safe_mask)("syswrap.sigsuspend.1", (Addr)ARG1);
}
}
POST(sys_sigsuspend)
{
ML_(free_safe_mask) ( (Addr)ARG1 );
}
// SYS_sigpending 343
// int sigpending(sigset_t *set);
PRE(sys_sigpending)
{
PRINT( "sys_sigpending ( %#" FMT_REGWORD "x )", ARG1 );
PRE_REG_READ1(int, "sigpending", vki_sigset_t *, set);
PRE_MEM_WRITE( "sigpending(set)", ARG1, sizeof(vki_sigset_t));
}
POST(sys_sigpending)
{
POST_MEM_WRITE( ARG1, sizeof(vki_sigset_t) ) ;
}
// SYS_sigtimedwait 345
// int sigtimedwait(const sigset_t *restrict set, siginfo_t *restrict info,
// const struct timespec *restrict timeout);
PRE(sys_sigtimedwait)
{
*flags |= SfMayBlock;
PRINT("sys_sigtimedwait ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "sigtimedwait",
const vki_sigset_t *, set, vki_siginfo_t *, info,
const struct timespec *, timeout);
if (ARG1 != 0)
PRE_MEM_READ( "sigtimedwait(set)", ARG1, sizeof(vki_sigset_t));
if (ARG2 != 0)
PRE_MEM_WRITE( "sigtimedwait(info)", ARG2, sizeof(vki_siginfo_t) );
if (ARG3 != 0)
PRE_MEM_READ( "sigtimedwait(timeout)",
ARG3, sizeof(struct vki_timespec) );
}
POST(sys_sigtimedwait)
{
if (ARG2 != 0)
POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );
}
// SYS_sigwaitinfo 346
// int sigwaitinfo(const sigset_t * restrict set, siginfo_t * restrict info);
PRE(sys_sigwaitinfo)
{
*flags |= SfMayBlock;
PRINT("sys_sigwaitinfo ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
ARG1,ARG2);
PRE_REG_READ2(int, "sigwaitinfo",
const vki_sigset_t *, set, vki_siginfo_t *, info);
if (ARG1 != 0)
PRE_MEM_READ( "sigwaitinfo(set)", ARG1, sizeof(vki_sigset_t));
if (ARG2 != 0)
PRE_MEM_WRITE( "sigwaitinfo(info)", ARG2, sizeof(vki_siginfo_t) );
}
POST(sys_sigwaitinfo)
{
if (ARG2 != 0)
POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );
}
// SYS___acl_get_file 347
// int __acl_get_file(const char *path, acl_type_t type, struct acl *aclp);
PRE(sys___acl_get_file)
{
PRINT("sys___acl_get_file ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "acl_get_file",
const char *, path, int, type, struct vki_acl *, aclp);
PRE_MEM_RASCIIZ("acl_get_file(path", ARG1);
PRE_MEM_WRITE( "acl_get_file(aclp)", ARG3, sizeof(struct vki_acl) );
}
POST(sys___acl_get_file)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG3, sizeof(struct vki_acl) );
}
}
// SYS___acl_set_file 348
// int __acl_set_file(const char *path, acl_type_t type, struct acl *aclp);
PRE(sys___acl_set_file)
{
PRINT("sys___acl_set_file ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "acl_set_file",
const char *, path, int, type, struct vki_acl *, aclp);
PRE_MEM_RASCIIZ("acl_set_file(path", ARG1);
PRE_MEM_READ("acl_set_file(aclp)", ARG3, sizeof(struct vki_acl) );
}
// SYS___acl_get_fd 349
// int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp);
PRE(sys___acl_get_fd)
{
PRINT("sys___acl_get_fd ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "acl_get_fd",
int, fd, int, type, struct vki_acl *, aclp);
PRE_MEM_WRITE( "acl_get_file(aclp)", ARG3, sizeof(struct vki_acl) );
}
POST(sys___acl_get_fd)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG3, sizeof(struct vki_acl) );
}
}
// SYS___acl_set_fd 350
// int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp);
PRE(sys___acl_set_fd)
{
PRINT("sys___acl_set_fd ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "acl_set_fd",
int, filedes, int, type, struct vki_acl *, aclp);
PRE_MEM_READ( "acl_get_file(aclp)", ARG3, sizeof(struct vki_acl) );
}
// SYS___acl_delete_file 351
// int __acl_delete_file(const char *path, acl_type_t type);
PRE(sys___acl_delete_file)
{
PRINT("sys___acl_delete_file ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,(char *)ARG1,ARG2);
PRE_MEM_RASCIIZ("acl_set_file(path", ARG1);
PRE_REG_READ2(int, "acl_delete_file",
const char *, path, int, type);
}
// SYS___acl_delete_fd 352
// int __acl_delete_fd(int filedes, acl_type_t type);
PRE(sys___acl_delete_fd)
{
PRINT("sys___acl_delete_fd ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1,ARG2);
PRE_REG_READ2(int, "acl_delete_fd",
int, filedes, int, acltype);
}
// SYS___acl_aclcheck_file 353
// int __acl_aclcheck_file(const char *path, acl_type_t type, struct acl *aclp);
PRE(sys___acl_aclcheck_file)
{
PRINT("sys___acl_aclcheck_file ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "acl_aclcheck_file",
const char *, path, int, type, struct vki_acl *, aclp);
PRE_MEM_RASCIIZ("acl_set_file(path", ARG1);
PRE_MEM_READ( "acl_aclcheck_file(aclp)", ARG3, sizeof(struct vki_acl) );
}
// SYS___acl_aclcheck_fd 354
// int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp);
PRE(sys___acl_aclcheck_fd)
{
PRINT("sys___acl_aclcheck_fd ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "acl_aclcheck_fd",
int, fd, int, type, struct vki_acl *, aclp);
PRE_MEM_READ( "acl_aclcheck_fd(aclp)", ARG3, sizeof(struct vki_acl) );
}
// SYS_extattrctl 355
// no manpage?
// syscalls.master: int extattrctl(_In_z_ const char *path, int cmd, _In_z_opt_ const char *filename, int attrnamespace, _In_z_ const char *attrname);
PRE(sys_extattrctl)
{
PRINT("sys_extattrctl ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", ARG1,SARG2,ARG3,SARG4,ARG5);
PRE_REG_READ5(ssize_t, "extattrctl",
const char *, path, int, cmd, const char *, filename, int, attrnamespace, const char *, attrname);
PRE_MEM_RASCIIZ("extattrctl(path)", ARG1);
PRE_MEM_RASCIIZ("extattrctl(filename)", ARG3);
PRE_MEM_RASCIIZ("extattrctl(attrname)", ARG5);
}
// SYS_extattr_set_file 356
// ssize_t extattr_set_file(const char *path, int attrnamespace,
// const char *attrname, const void *data, size_t nbytes);
PRE(sys_extattr_set_file)
{
PRINT("sys_extattr_set_file ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,SARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "extattr_set_file",
const char *, path, int, attrnamespace, const char *, attrname, const void *, data, size_t, nbytes);
PRE_MEM_RASCIIZ("extattr_set_file(path)", ARG1);
PRE_MEM_RASCIIZ("extattr_set_file(attrname)", ARG3);
PRE_MEM_READ("extattr_set_file(data)", ARG4, ARG5);
}
// SYS_extattr_get_file 357
// ssize_t extattr_get_file(const char *path, int attrnamespace,
// const char *attrname, void *data, size_t nbytes);
PRE(sys_extattr_get_file)
{
PRINT("sys_extattr_get_file ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,SARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "extattr_get_file",
const char *, path, int, attrnamespace, const char *, attrname, void *, data, size_t, nbytes);
PRE_MEM_RASCIIZ("extattr_get_file(path)", ARG1);
PRE_MEM_RASCIIZ("extattr_get_file(attrname)", ARG3);
if (ARG4) {
PRE_MEM_WRITE("extattr_get_file(data)", ARG4, ARG5);
}
}
POST(sys_extattr_get_file)
{
if (ARG4) {
POST_MEM_WRITE(ARG4, ARG5);
}
}
// SYS_extattr_delete_file 358
// int extattr_delete_file(const char *path, int attrnamespace,
// const char *attrname);
PRE(sys_extattr_delete_file)
{
PRINT("sys_extattr_delete_file ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", ARG1,SARG2,ARG3);
PRE_REG_READ3(ssize_t, "extattr_delete_file",
const char *, path, int, attrnamespace, const char *, attrname);
PRE_MEM_RASCIIZ("extattr_delete_file(path)", ARG1);
PRE_MEM_RASCIIZ("extattr_delete_file(attrname)", ARG3);
}
// SYS_aio_waitcomplete 359
// ssize_t aio_waitcomplete(struct aiocb **iocbp, struct timespec *timeout);
PRE(sys_aio_waitcomplete)
{
*flags |= SfMayBlock;
PRINT("sys_aio_waitcomplete ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(ssize_t, "aio_waitcomplete", struct aiocb **, iocbp, struct timespec *, timeout);
if (ARG2) {
PRE_MEM_READ("aio_waitcomplete(timeout", ARG2, sizeof(struct vki_timespec));
}
PRE_MEM_WRITE( "aio_waitcomplete(iocbp)", ARG1, sizeof(struct aiocb *));
}
POST(sys_aio_waitcomplete)
{
POST_MEM_WRITE(ARG1, sizeof(struct aiocb *));
}
// SYS_getresuid 360
// int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
PRE(sys_getresuid)
{
PRINT("sys_getresuid ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getresuid",
vki_uid_t *, ruid, vki_uid_t *, euid, vki_uid_t *, suid);
PRE_MEM_WRITE( "getresuid(ruid)", ARG1, sizeof(vki_uid_t) );
PRE_MEM_WRITE( "getresuid(euid)", ARG2, sizeof(vki_uid_t) );
PRE_MEM_WRITE( "getresuid(suid)", ARG3, sizeof(vki_uid_t) );
}
POST(sys_getresuid)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG1, sizeof(vki_uid_t) );
POST_MEM_WRITE( ARG2, sizeof(vki_uid_t) );
POST_MEM_WRITE( ARG3, sizeof(vki_uid_t) );
}
}
// SYS_getresgid 361
// int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
PRE(sys_getresgid)
{
PRINT("sys_getresgid ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getresgid",
vki_gid_t *, rgid, vki_gid_t *, egid, vki_gid_t *, sgid);
PRE_MEM_WRITE( "getresgid(rgid)", ARG1, sizeof(vki_gid_t) );
PRE_MEM_WRITE( "getresgid(egid)", ARG2, sizeof(vki_gid_t) );
PRE_MEM_WRITE( "getresgid(sgid)", ARG3, sizeof(vki_gid_t) );
}
POST(sys_getresgid)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG1, sizeof(vki_gid_t) );
POST_MEM_WRITE( ARG2, sizeof(vki_gid_t) );
POST_MEM_WRITE( ARG3, sizeof(vki_gid_t) );
}
}
// SYS_kqueue 362
// int kqueue(void);
PRE(sys_kqueue)
{
PRINT("%s", "sys_kqueue ()");
PRE_REG_READ0(omt, "kqueue");
}
POST(sys_kqueue)
{
if (!ML_(fd_allowed)(RES, "kqueue", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds)) {
ML_(record_fd_open_nameless)(tid, RES);
}
}
}
// SYS_freebsd11_kevent 363
// int kevent(int kq, const struct kevent *changelist, int nchanges,
// struct kevent *eventlist, int nevents,
// const struct timespec *timeout);
#if (FREEBSD_VERS >= FREEBSD_12)
PRE(sys_freebsd11_kevent)
{
PRINT("sys_freebsd11_kevent ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )\n", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
PRE_REG_READ6(int, "kevent",
int, fd, const struct vki_kevent_freebsd11 *, changelist, int, nchanges,
struct vki_kevent_freebsd11 *, eventlist, int, nevents,
struct timespec *, timeout);
if (ARG2 != 0 && ARG3 != 0)
PRE_MEM_READ( "kevent(changelist)", ARG2, sizeof(struct vki_kevent_freebsd11)*ARG3 );
if (ARG4 != 0 && ARG5 != 0)
PRE_MEM_WRITE( "kevent(eventlist)", ARG4, sizeof(struct vki_kevent_freebsd11)*ARG5);
if (ARG5 != 0)
*flags |= SfMayBlock;
if (ARG6 != 0)
PRE_MEM_READ( "kevent(timeout)",
ARG6, sizeof(struct vki_timespec));
}
POST(sys_freebsd11_kevent)
{
vg_assert(SUCCESS);
if ((Word)RES != -1) {
if (ARG4 != 0)
POST_MEM_WRITE( ARG4, sizeof(struct vki_kevent_freebsd11)*RES) ;
}
}
#else
PRE(sys_kevent)
{
*flags |= SfMayBlock;
PRINT("sys_kevent ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )\n", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
PRE_REG_READ6(int, "kevent",
int, fd, struct vki_kevent_freebsd11 *, changelist, int, nchanges,
struct vki_kevent_freebsd11 *, eventlist, int, nevents,
struct timespec *, timeout);
if (ARG2 != 0 && ARG3 != 0)
PRE_MEM_READ( "kevent(changelist)", ARG2, sizeof(struct vki_kevent_freebsd11)*ARG3 );
if (ARG4 != 0 && ARG5 != 0)
PRE_MEM_WRITE( "kevent(eventlist)", ARG4, sizeof(struct vki_kevent_freebsd11)*ARG5);
if (ARG6 != 0)
PRE_MEM_READ( "kevent(timeout)",
ARG6, sizeof(struct vki_timespec));
}
POST(sys_kevent)
{
vg_assert(SUCCESS);
if ((Word)RES != -1) {
if (ARG4 != 0)
POST_MEM_WRITE( ARG4, sizeof(struct vki_kevent_freebsd11)*RES) ;
}
}
#endif
// SYS_extattr_set_fd 371
// ssize_t extattr_set_fd(int fd, int attrnamespace, const char *attrname,
// const void *data, size_t nbytes);
PRE(sys_extattr_set_fd)
{
PRINT("sys_extattr_set_fd ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", SARG1,SARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(int, "extattr_set_fd", int, fd, int, attrnamespace, const char *,attrname, const void *,data, size_t, nbytes);
PRE_MEM_RASCIIZ( "extattr_set_fd(attrname)", ARG3 );
PRE_MEM_READ("extattr_set_fd(data)", ARG4, ARG5);
}
// SYS_extattr_get_fd 372
// ssize_t extattr_get_fd(int fd, int attrnamespace, const char *attrname,
// void *data, size_t nbytes);
PRE(sys_extattr_get_fd)
{
PRINT("sys_extattr_get_fd ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", SARG1,SARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(int, "extattr_get_fd", int, fd, int, attrnamespace, const char *,attrname, const void *,data, size_t, nbytes);
PRE_MEM_RASCIIZ( "extattr_get_fd(attrname)", ARG3 );
PRE_MEM_WRITE("extattr_get_fd(data)", ARG4, ARG5);
}
POST(sys_extattr_get_fd)
{
POST_MEM_WRITE(ARG4, ARG5);
}
// SYS_extattr_delete_fd 373
// int extattr_delete_fd(int fd, int attrnamespace, const char *attrname);
PRE(sys_extattr_delete_fd)
{
PRINT("sys_extattr_delete_fd ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1,SARG2,ARG3);
PRE_REG_READ3(int, "extattr_delete_fd", int, fd, int, attrnamespace, const char *,attrname);
PRE_MEM_RASCIIZ( "extattr_delete_fd(attrname)", ARG3 );
}
// SYS___setugid 374
// no manpage?
// syscalls.master: int __setugid(int flag);
PRE(sys___setugid)
{
PRINT("sys___setugid ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "__setugid", int, flag);
}
// SYS_eaccess 376
// int eaccess(const char *path, int mode);
PRE(sys_eaccess)
{
PRINT("sys_eaccess ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,(char*)ARG1,ARG2);
PRE_REG_READ2(int, "eaccess", const char *, path, int, mode);
PRE_MEM_RASCIIZ( "eaccess(path)", ARG1 );
}
// SYS_afs3_syscall 377
// @todo
// SYS_nmount 378
// int nmount(struct iovec *iov, u_int niov, int flags);
PRE(sys_nmount)
{
PRINT("sys_nmount ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "d )", ARG1, ARG2, SARG3);
PRE_REG_READ3(int, "nmount", struct iovec *, iov, u_int, niov, int, flags);
PRE_MEM_READ( "nmount(pathname)", ARG1, ARG2*sizeof(struct vki_iovec) );
}
// SYS___mac_get_proc 384
// @todo
// SYS___mac_set_proc 385
// @todo
// SYS___mac_get_fd 386
// @todo
// SYS___mac_get_file 387
// @todo
// SYS___mac_set_fd 388
// @todo
// SYS___mac_set_file 389
// @todo
// SYS_kenv 390
// int kenv(int action, const char *name, char *value, int len);
PRE(sys_kenv)
{
PRINT("sys_kenv ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "kenv",
int, action, const char *, name, char *, value, int, len);
switch (ARG1) {
case VKI_KENV_GET:
case VKI_KENV_SET:
case VKI_KENV_UNSET:
PRE_MEM_RASCIIZ("kenv(name)", ARG2);
/* FALLTHROUGH */
case VKI_KENV_DUMP:
break;
default:
VG_(dmsg)("Warning: Bad action %" FMT_REGWORD "u in kenv\n", ARG1);
}
}
POST(sys_kenv)
{
if (SUCCESS) {
switch (ARG1) {
case VKI_KENV_GET:
POST_MEM_WRITE(ARG3, ARG4);
break;
case VKI_KENV_DUMP:
if (ARG3 != (Addr)NULL)
POST_MEM_WRITE(ARG3, ARG4);
break;
}
}
}
// SYS_lchflags 391
// int lchflags(const char *path, unsigned long flags);
PRE(sys_lchflags)
{
PRINT("sys_lchflags ( %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "lchflags",
const char *, path, unsigned long, flags);
PRE_MEM_RASCIIZ( "lchflags(path)", ARG1 );
}
// SYS_uuidgen 392
// int uuidgen(struct uuid *store, int count);
PRE(sys_uuidgen)
{
PRINT("sys_uuidgen ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,ARG2);
PRE_REG_READ2(int, "uuidgen",
struct vki_uuid *, store, int, count);
PRE_MEM_WRITE( "uuidgen(store)", ARG1, ARG2 * sizeof(struct vki_uuid));
}
POST(sys_uuidgen)
{
if (SUCCESS)
POST_MEM_WRITE( ARG1, ARG2 * sizeof(struct vki_uuid) );
}
// SYS_sendfile 393
// x86/amd64
// SYS_mac_syscall 394
// @todo
#if (FREEBSD_VERS >= FREEBSD_12)
// SYS_freebsd11_getfsstat 395
// int getfsstat(struct freebsd11_statfs *buf, long bufsize, int mode);
PRE(sys_freebsd11_getfsstat)
{
PRINT("sys_freebsd11_getfsstat ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "getfsstat", struct vki_freebsd11_statfs *, buf, long, bufsize, int, mode);
PRE_MEM_WRITE( "getfsstat(buf)", ARG1, ARG2 );
}
POST(sys_freebsd11_getfsstat)
{
vg_assert(SUCCESS);
if ((Word)RES != -1) {
POST_MEM_WRITE( ARG1, RES * sizeof(struct vki_freebsd11_statfs) );
}
}
// SYS_freebsd11_statfs 396
// int statfs(const char *path, struct statfs *buf);
PRE(sys_freebsd11_statfs)
{
PRINT("sys_statfs ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "statfs", const char *, path, struct statfs *, buf);
PRE_MEM_RASCIIZ( "statfs(path)", ARG1 );
PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct vki_freebsd11_statfs) );
}
POST(sys_freebsd11_statfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_statfs) );
}
// SYS_freebsd11_fstatfs 397
// int fstatfs(int fd, struct statfs *buf);
PRE(sys_freebsd11_fstatfs)
{
PRINT("sys_fstatfs ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "fstatfs",
unsigned int, fd, struct statfs *, buf);
PRE_MEM_WRITE( "fstatfs(buf)", ARG2, sizeof(struct vki_freebsd11_statfs) );
}
POST(sys_freebsd11_fstatfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_statfs) );
}
// SYS_freebsd11_fhstatfs 398
// int fhstatfs(const fhandle_t *fhp, struct statfs *buf);
PRE(sys_freebsd11_fhstatfs)
{
PRINT("sys_fhstatfs ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "fhstatfs",
struct fhandle *, fhp, struct statfs *, buf);
PRE_MEM_READ( "fhstatfs(fhp)", ARG1, sizeof(struct vki_fhandle) );
PRE_MEM_WRITE( "fhstatfs(buf)", ARG2, sizeof(struct vki_freebsd11_statfs) );
}
POST(sys_freebsd11_fhstatfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_statfs) );
}
#else
PRE(sys_getfsstat)
{
PRINT("sys_getfsstat ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "getfsstat", struct vki_freebsd11_statfs *, buf, long, bufsize, int, mode);
PRE_MEM_WRITE( "getfsstat(buf)", ARG1, ARG2 );
}
POST(sys_getfsstat)
{
vg_assert(SUCCESS);
if ((Word)RES != -1) {
POST_MEM_WRITE( ARG1, RES * sizeof(struct vki_freebsd11_statfs) );
}
}
PRE(sys_statfs)
{
PRINT("sys_statfs ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "statfs", const char *, path, struct statfs *, buf);
PRE_MEM_RASCIIZ( "statfs(path)", ARG1 );
PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct vki_freebsd11_statfs) );
}
POST(sys_statfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_statfs) );
}
PRE(sys_fstatfs)
{
PRINT("sys_fstatfs ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "fstatfs",
unsigned int, fd, struct statfs *, buf);
PRE_MEM_WRITE( "fstatfs(buf)", ARG2, sizeof(struct vki_freebsd11_statfs) );
}
POST(sys_fstatfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_statfs) );
}
PRE(sys_fhstatfs)
{
PRINT("sys_fhstatfs ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "fhstatfs",
struct fhandle *, fhp, struct statfs *, buf);
PRE_MEM_READ( "fhstatfs(fhp)", ARG1, sizeof(struct vki_fhandle) );
PRE_MEM_WRITE( "fhstatfs(buf)", ARG2, sizeof(struct vki_freebsd11_statfs) );
}
POST(sys_fhstatfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_freebsd11_statfs) );
}
#endif
// SYS_ksem_close 400
// @todo
// SYS_ksem_post 401
// @todo
// SYS_ksem_wait 402
// @todo
// SYS_ksem_trywait 403
// @todo
// SYS_ksem_init 404
// @todo
// SYS_ksem_open 405
// @todo
// SYS_ksem_unlink 406
// @todo
// SYS_ksem_getvalue 407
// @todo
// SYS_ksem_destroy 408
// @todo
// SYS___mac_get_pid 409
// @todo
// SYS___mac_get_link 410
// @todo
// SYS___mac_set_link 411
// @todo
// SYS_extattr_set_link 412
// ssize_t extattr_set_link(const char *path, int attrnamespace,
// const char *attrname, const void *data, size_t nbytes);
PRE(sys_extattr_set_link)
{
PRINT("sys_extattr_set_link ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,SARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "extattr_set_link",
const char *, path, int, attrnamespace, const char *, attrname, const void *, data, size_t, nbytes);
PRE_MEM_RASCIIZ("extattr_set_link(path)", ARG1);
PRE_MEM_RASCIIZ("extattr_set_link(attrname)", ARG3);
PRE_MEM_READ("extattr_set_link(data)", ARG4, ARG5);
}
// SYS_extattr_get_link 413
// ssize_t extattr_get_link(const char *path, int attrnamespace,
// const char *attrname, void *data, size_t nbytes);
PRE(sys_extattr_get_link)
{
PRINT("sys_extattr_get_link ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,SARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "extattr_get_link",
const char *, path, int, attrnamespace, const char *, attrname, void *, data, size_t, nbytes);
PRE_MEM_RASCIIZ("extattr_get_link(path)", ARG1);
PRE_MEM_RASCIIZ("extattr_get_link(attrname)", ARG3);
if (ARG4) {
PRE_MEM_WRITE("extattr_get_link(data)", ARG4, ARG5);
}
}
POST(sys_extattr_get_link)
{
if (ARG4) {
POST_MEM_WRITE(ARG4, ARG5);
}
}
// SYS_extattr_delete_link 414
// int extattr_delete_link(const char *path, int attrnamespace,
// const char *attrname);
PRE(sys_extattr_delete_link)
{
PRINT("sys_extattr_delete_link ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", ARG1,SARG2,ARG3);
PRE_REG_READ3(ssize_t, "extattr_delete_link",
const char *, path, int, attrnamespace, const char *, attrname);
PRE_MEM_RASCIIZ("extattr_delete_link(path)", ARG1);
PRE_MEM_RASCIIZ("extattr_delete_link(attrname)", ARG3);
}
// SYS___mac_execve 415
// @todo
// SYS_sigaction 416
//int sigaction(int sig, const struct sigaction * restrict act,
// struct sigaction * restrict oact);
PRE(sys_sigaction)
{
vki_sigaction_toK_t new, *newp;
vki_sigaction_fromK_t old, *oldp;
PRINT("sys_sigaction ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1,ARG2,ARG3);
PRE_REG_READ3(long, "sigaction",
int, sign, const struct sigaction *, act,
struct sigaction *, oact);
newp = oldp = NULL;
if (ARG2 != 0) {
struct vki_sigaction *sa = (struct vki_sigaction *)ARG2;
PRE_MEM_READ( "sigaction(act->sa_handler)", (Addr)&sa->ksa_handler, sizeof(sa->ksa_handler));
PRE_MEM_READ( "sigaction(act->sa_mask)", (Addr)&sa->sa_mask, sizeof(sa->sa_mask));
PRE_MEM_READ( "sigaction(act->sa_flags)", (Addr)&sa->sa_flags, sizeof(sa->sa_flags));
}
if (ARG3 != 0) {
PRE_MEM_WRITE( "sigaction(oact)", ARG3, sizeof(struct vki_sigaction));
oldp = &old;
}
if (ARG2 != 0
&& ! ML_(safe_to_deref)((void *)(Addr)ARG2,
sizeof(struct vki_sigaction))) {
VG_(umsg)("Warning: bad act handler address %p in sigaction()\n",
(void *)(Addr)ARG2);
SET_STATUS_Failure ( VKI_EFAULT );
} else if ((ARG3 != 0
&& ! ML_(safe_to_deref)((void *)(Addr)ARG3,
sizeof(struct vki_sigaction)))) {
VG_(umsg)("Warning: bad oact handler address %p in sigaction()\n",
(void *)(Addr)ARG3);
SET_STATUS_Failure ( VKI_EFAULT );
} else {
if (ARG2 != 0) {
struct vki_sigaction *oldnew =
(struct vki_sigaction *)(Addr)ARG2;
new.ksa_handler = oldnew->ksa_handler;
new.sa_flags = oldnew->sa_flags;
new.sa_mask = oldnew->sa_mask;
newp = &new;
}
SET_STATUS_from_SysRes( VG_(do_sys_sigaction)(ARG1, newp, oldp) );
if (ARG3 != 0 && SUCCESS && RES == 0) {
struct vki_sigaction *oldold =
(struct vki_sigaction *)(Addr)ARG3;
oldold->ksa_handler = oldp->ksa_handler;
oldold->sa_flags = oldp->sa_flags;
oldold->sa_mask = oldp->sa_mask;
}
}
}
POST(sys_sigaction)
{
vg_assert(SUCCESS);
if (RES == 0 && ARG3 != 0)
POST_MEM_WRITE( ARG3, sizeof(struct vki_sigaction));
}
// SYS_sigreturn 417
// x86/amd64
// SYS_getcontext 421
// SYS_setcontext 422
// SYS_swapcontext 423
// PRE in x86/amd64
POST(sys_getcontext)
{
POST_MEM_WRITE( ARG1, sizeof(struct vki_ucontext) );
}
POST(sys_swapcontext)
{
if (SUCCESS)
POST_MEM_WRITE( ARG1, sizeof(struct vki_ucontext) );
}
#if (FREEBSD_VERS >= FREEBSD_13_1)
// SYS_freebsd13_swapoff 424
// int swapoff(const char *special);
PRE(sys_freebsd13_swapoff)
{
PRINT("sys_freebsd13_swapoff ( %#" FMT_REGWORD "x(%s) )", ARG1,(char *)ARG1);
PRE_REG_READ1(int, "swapoff", const char *, special);
PRE_MEM_RASCIIZ( "swapoff(special)", ARG1 );
}
#else
// SYS_swapoff 424
// int swapoff(const char *special);
PRE(sys_swapoff)
{
PRINT("sys_swapoff ( %#" FMT_REGWORD "x(%s) )", ARG1,(char *)ARG1);
PRE_REG_READ1(int, "swapoff", const char *, special);
PRE_MEM_RASCIIZ( "swapoff(special)", ARG1 );
}
#endif
// SYS___acl_get_link 425
// int __acl_get_link(const char *path, acl_type_t type, struct acl *aclp);
PRE(sys___acl_get_link)
{
PRINT("sys___acl_get_link ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "__acl_get_link",
const char *, path, int, acltype, struct vki_acl *, aclp);
PRE_MEM_RASCIIZ( "__acl_get_link(path)", ARG1 );
PRE_MEM_WRITE( "__acl_get_link(aclp)", ARG3, sizeof(struct vki_acl) );
}
POST(sys___acl_get_link)
{
vg_assert(SUCCESS);
if (RES == 0) {
POST_MEM_WRITE( ARG3, sizeof(struct vki_acl) );
}
}
// SYS___acl_set_link 426
// int __acl_set_link(const char *path, acl_type_t type, struct acl *aclp);
PRE(sys___acl_set_link)
{
PRINT("sys___acl_set_link ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "__acl_set_link",
const char *, path, int, acltype, struct vki_acl *, aclp);
PRE_MEM_RASCIIZ( "__acl_set_link(path)", ARG1 );
PRE_MEM_READ( "__acl_set_link(aclp)", ARG3, sizeof(struct vki_acl) );
}
// SYS___acl_delete_link 427
// int __acl_delete_link(const char *path, acl_type_t type);
PRE(sys___acl_delete_link)
{
PRINT("sys___acl_delete_link ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,(char *)ARG1,ARG2);
PRE_MEM_RASCIIZ( "__acl_delete_link(path)", ARG1 );
PRE_REG_READ2(int, "__acl_delete_link",
const char *, path, int, acltype);
}
// SYS___acl_aclcheck_link 428
// int __acl_aclcheck_link(const char *path, acl_type_t type, struct acl *aclp);
PRE(sys___acl_aclcheck_link)
{
PRINT("sys___acl_aclcheck_link ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,(char *)ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "__acl_aclcheck_link",
const char *, path, int, acltype, struct vki_acl *, aclp);
PRE_MEM_RASCIIZ( "__acl_check_link(path)", ARG1 );
PRE_MEM_READ( "__acl_aclcheck_link(aclp)", ARG3, sizeof(struct vki_acl) );
}
// SYS_sigwait 429
// int sigwait(const sigset_t * restrict set, int * restrict sig);
PRE(sys_sigwait)
{
*flags |= SfMayBlock;
PRINT("sys_sigwait ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
ARG1,ARG2);
PRE_REG_READ2(int, "sigwait",
const vki_sigset_t *, set, int *, sig);
if (ARG1 != 0)
PRE_MEM_READ( "sigwait(set)", ARG1, sizeof(vki_sigset_t));
if (ARG2 != 0)
PRE_MEM_WRITE( "sigwait(sig)", ARG2, sizeof(int));
}
POST(sys_sigwait)
{
if (ARG2 != 0)
POST_MEM_WRITE( ARG2, sizeof(int));
}
// SYS_thr_create 430
// no manpage?
// syscalls.master: int thr_create(_In_ ucontext_t *ctx, _Out_ long *id, int flags );
PRE(sys_thr_create)
{
PRINT( "sys_thr_create ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "d )", ARG1, ARG2, SARG3 );
PRE_REG_READ3(int, "thr_create", /*ucontext_t*/void *, ctx, long *, id, int, flags );
VG_(message)(Vg_UserMsg, "thr_create() not implemented");
VG_(unimplemented)("Valgrind does not support thr_create().");
SET_STATUS_Failure(VKI_ENOSYS);
}
// SYS_thr_exit 431
// void thr_exit(long *state);
PRE(sys_thr_exit)
{
ThreadState *tst;
PRINT( "sys_thr_exit ( %#" FMT_REGWORD "x )", ARG1 );
PRE_REG_READ1(void, "thr_exit", long *, state);
if (ARG1) {
PRE_MEM_WRITE( "thr_exit(state)", ARG1, sizeof(long) );
}
tst = VG_(get_ThreadState)(tid);
tst->exitreason = VgSrc_ExitThread;
tst->os_state.exitcode = ARG1;
SET_STATUS_Success(0);
}
// SYS_thr_self 432
// int thr_self(long *id);
PRE(sys_thr_self)
{
PRINT( "sys_thr_self ( %#" FMT_REGWORD "x )", ARG1 );
PRE_REG_READ1(int, "thr_self", long *, id);
PRE_MEM_WRITE( "thr_self()", ARG1, sizeof(long));
}
POST(sys_thr_self)
{
POST_MEM_WRITE( ARG1, sizeof(long));
}
// SYS_thr_kill 433
// int thr_kill(long id, int sig);
PRE(sys_thr_kill)
{
PRINT("sys_thr_kill ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1,ARG2);
PRE_REG_READ2(long, "thr_kill", long, id, int, sig);
if (!ML_(client_signal_OK)(ARG2)) {
SET_STATUS_Failure( VKI_EINVAL );
return;
}
/* Check to see if this kill gave us a pending signal */
*flags |= SfPollAfter;
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "thr_kill: sending signal %lu to tid %lu\n",
ARG2, ARG1);
/* If we're sending SIGKILL, check to see if the target is one of
our threads and handle it specially. */
if (ARG2 == VKI_SIGKILL && ML_(do_sigkill)(ARG1, -1)) {
SET_STATUS_Success(0);
return;
}
/* Ask to handle this syscall via the slow route, since that's the
only one that sets tst->status to VgTs_WaitSys. If the result
of doing the syscall is an immediate run of
async_signalhandler() in m_signals, then we need the thread to
be properly tidied away. I have the impression the previous
version of this wrapper worked on x86/amd64 only because the
kernel did not immediately deliver the async signal to this
thread (on ppc it did, which broke the assertion re tst->status
at the top of async_signalhandler()). */
*flags |= SfMayBlock;
}
POST(sys_thr_kill)
{
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "thr_kill: sent signal %lu to tid %lu\n",
ARG2, ARG1);
}
#if (FREEBSD_VERS <= FREEBSD_10)
// SYS__umtx_lock 434
PRE(sys__umtx_lock)
{
PRINT( "sys__umtx_lock ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "_umtx_lock", struct vki_umtx *, umtx);
PRE_MEM_READ( "_umtx_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
PRE_MEM_WRITE( "_umtx_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
}
POST(sys__umtx_lock)
{
if (SUCCESS)
POST_MEM_WRITE(ARG1, sizeof(struct vki_umtx));
}
// SYS__umtx_unlock 434
PRE(sys__umtx_unlock)
{
PRINT( "sys__umtx_unlock ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "_umtx_unlock", struct vki_umtx *, umtx);
PRE_MEM_READ( "_umtx_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
PRE_MEM_WRITE( "_umtx_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
}
POST(sys__umtx_unlock)
{
if (SUCCESS)
POST_MEM_WRITE(ARG1, sizeof(struct vki_umtx));
}
#endif
// SYS_jail_attach 436
// int jail_attach(int jid);
PRE(sys_jail_attach)
{
PRINT("sys_jail_attach ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "jail_attach", int, jid);
}
// SYS_extattr_list_fd 437
// ssize_t extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes);
PRE(sys_extattr_list_fd)
{
PRINT("extattr_list_fd ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(ssize_t, "extattr_list_fd", int, id, int, attrnamespace, void *,data, size_t, nbytes);
PRE_MEM_WRITE("extattr_list_fd(data)", ARG3, ARG4);
}
POST(sys_extattr_list_fd)
{
POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_extattr_list_file 438
// ssize_t extattr_list_file(const char *path, int attrnamespace, void *data,
// size_t nbytes);
PRE(sys_extattr_list_file)
{
PRINT("extattr_list_file ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(ssize_t, "extattr_list_file", const char *, path, int, attrnamespace, void *,data, size_t, nbytes);
PRE_MEM_RASCIIZ("extattr_list_file(path)", ARG1);
PRE_MEM_WRITE("extattr_list_file(data)", ARG3, ARG4);
}
POST(sys_extattr_list_file)
{
POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_extattr_list_link 439
// ssize_t extattr_get_link(const char *path, int attrnamespace,
// const char *attrname, void *data, size_t nbytes);
PRE(sys_extattr_list_link)
{
PRINT("extattr_list_link ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(ssize_t, "extattr_list_link", const char *, path, int, attrnamespace, void *,data, size_t, nbytes);
PRE_MEM_RASCIIZ("extattr_list_link(path)", ARG1);
PRE_MEM_WRITE("extattr_list_link(data)", ARG3, ARG4);
}
POST(sys_extattr_list_link)
{
POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_ksem_timedwait 441
// @todo
// SYS_thr_suspend 442
// int thr_suspend(struct timespec *timeout);
PRE(sys_thr_suspend)
{
PRINT("sys_thr_suspend ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "thr_suspend", struct timespec *, timeout);
PRE_MEM_READ("thr_suspend(timeout)", ARG1, sizeof(struct vki_timespec));
VG_(message)(Vg_UserMsg, "thr_supend() not implemented");
VG_(unimplemented)("Valgrind does not support thr_suspend().");
SET_STATUS_Failure(VKI_ENOSYS);
}
// SYS_thr_wake 443
// int thr_wake(long id);
PRE(sys_thr_wake)
{
PRINT("sys_thr_wake ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(long, "thr_wake", long, id);
/*
if (VG_(is_valid_tid)(ARG1)) {
VG_(threads)[ARG1].status = VgTs_Runnable;
} else {
SET_STATUS_Failure( VKI_ESRCH );
}
*/
}
// SYS_kldunloadf 444
// int kldunloadf(int fileid, int flags);
PRE(sys_kldunloadf)
{
PRINT("sys_kldunloadf ( %" FMT_REGWORD "d, %" FMT_REGWORD "d )", SARG1, SARG2);
PRE_REG_READ2(int, "kldunloadf", int, fileid, int, flags);
}
// SYS_audit 445
// int audit(const char *record, u_int length);
// @todo
// SYS_auditon 446
// int auditon(int cmd, void *data, u_int length);
// @todo
// SYS_getauid 447
// int getauid(au_id_t *auid);
// @todo
// SYS_setauid 448
// int setauid(au_id_t *auid);
// @todo
// SYS_getaudit 449
// int getaudit(auditinfo_t *auditinfo);
// @todo
// SYS_setaudit 450
// int setaudit(auditinfo_t *auditinfo);
// @todo
// SYS_getaudit_addr 451
// int getaudit_addr(auditinfo_addr_t *auditinfo_addr, u_int length);
// @todo
// SYS_setaudit_addr 452
// int setaudit_addr(auditinfo_addr_t *auditinfo_addr, u_int length);
// @todo
// SYS_auditctl 453
// @todo
// SYS__umtx_op 454
// int _umtx_op(void *obj, int op, u_long val, void *uaddr, void *uaddr2);
PRE(sys__umtx_op)
{
/* 5 args are always passed through. The last two can vary, but
they're always pointers. They may not be used though. */
switch(ARG2) {
case VKI_UMTX_OP_LOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, LOCK, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_lock",
struct umtx *, obj, int, op, unsigned long, id,
size_t, timeout_size, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_lock(timespec)", ARG5, ARG4 );
PRE_MEM_WRITE( "_umtx_op_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_UNLOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, UNLOCK, %" FMT_REGWORD "u)", ARG1, ARG3);
PRE_REG_READ3(long, "_umtx_op_unlock",
struct umtx *, obj, int, op, unsigned long, id);
PRE_MEM_READ( "_umtx_op_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
PRE_MEM_WRITE( "_umtx_op_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
break;
case VKI_UMTX_OP_WAIT:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, WAIT, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_wait",
long *, obj, int, op, unsigned long, val,
size_t, timeout_size, struct vki_timespec *, timeout);
if (ARG1) {
PRE_MEM_READ( "_umtx_op_wait(val)", ARG1, sizeof(long) );
if (*(long*)ARG1 == (long)ARG3) {
*flags |= SfMayBlock;
}
}
if (ARG5) {
PRE_MEM_READ( "_umtx_op_wait(timeout)", ARG5, ARG4 );
}
break;
case VKI_UMTX_OP_WAKE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, WAKE, %" FMT_REGWORD "u)", ARG1, ARG3);
PRE_REG_READ3(long, "_umtx_op_wake",
struct umtx *, obj, int, op, unsigned long, val);
PRE_MEM_READ( "_umtx_op_wake(mtx)", ARG1, sizeof(struct vki_umtx) );
break;
case VKI_UMTX_OP_MUTEX_TRYLOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, MUTEX_TRYLOCK, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_mutex_trylock",
struct umutex *, obj, int, op, unsigned long, noid,
size_t, timeout_size, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_mutex_trylock(mutex)", ARG1, sizeof(struct vki_umutex) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_mutex_trylock(timespec)", ARG5, ARG4 );
PRE_MEM_WRITE( "_umtx_op_mutex_trylock(mutex)", ARG1, sizeof(struct vki_umutex) );
break;
case VKI_UMTX_OP_MUTEX_LOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, MUTEX_LOCK, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_mutex_lock",
struct umutex *, obj, int, op, unsigned long, noid,
size_t, timeout_size, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_mutex_lock(mutex)", ARG1, sizeof(struct vki_umutex) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_mutex_lock(timespec)", ARG5, ARG4 );
PRE_MEM_WRITE( "_umtx_op_mutex_lock(mutex)", ARG1, sizeof(struct vki_umutex) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_MUTEX_UNLOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, MUTEX_UNLOCK)", ARG1);
PRE_REG_READ2(long, "_umtx_op_mutex_unlock",
struct umutex *, obj, int, op);
PRE_MEM_READ( "_umtx_op_mutex_unlock(mutex)", ARG1, sizeof(struct vki_umutex) );
PRE_MEM_WRITE( "_umtx_op_mutex_unlock(mutex)", ARG1, sizeof(struct vki_umutex) );
break;
case VKI_UMTX_OP_SET_CEILING:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, SET_CEILING, %" FMT_REGWORD "u, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4);
PRE_REG_READ4(long, "_umtx_op_set_ceiling",
struct umutex *, obj, int, op, unsigned int, ceiling,
unsigned int *, old_ceiling);
PRE_MEM_READ( "_umtx_op_set_ceiling(mutex)", ARG1, sizeof(struct vki_umutex) );
PRE_MEM_WRITE( "_umtx_op_set_ceiling(mutex)", ARG1, sizeof(struct vki_umutex) );
if (ARG4)
PRE_MEM_WRITE( "_umtx_op_set_ceiling(old_ceiling)", ARG4, sizeof(vki_uint32_t) );
break;
case VKI_UMTX_OP_CV_WAIT:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, CV_WAIT, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_cv_wait",
struct ucond *, obj, int, op, unsigned long, wflags,
struct umutex *, umtx, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_cv_wait(cond)", ARG1, sizeof(struct vki_ucond) );
PRE_MEM_WRITE( "_umtx_op_cv_wait(cond)", ARG1, sizeof(struct vki_ucond) );
PRE_MEM_READ( "_umtx_op_cv_wait(mutex)", ARG4, sizeof(struct vki_umutex) );
PRE_MEM_WRITE( "_umtx_op_cv_wait(mutex)", ARG4, sizeof(struct vki_umutex) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_cv_wait(timespec)", ARG5, sizeof(struct vki_timespec) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_CV_SIGNAL:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, CV_SIGNAL)", ARG1);
PRE_REG_READ2(long, "_umtx_op_cv_signal",
struct ucond *, obj, int, op);
PRE_MEM_READ( "_umtx_op_cv_signal(cond)", ARG1, sizeof(struct vki_ucond) );
PRE_MEM_WRITE( "_umtx_op_cv_signal(cond)", ARG1, sizeof(struct vki_ucond) );
break;
case VKI_UMTX_OP_CV_BROADCAST:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, CV_BROADCAST, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ2(long, "_umtx_op_cv_broadcast",
struct ucond *, obj, int, op);
PRE_MEM_READ( "_umtx_op_cv_broadcast(cond)", ARG1, sizeof(struct vki_ucond) );
PRE_MEM_WRITE( "_umtx_op_cv_broadcast(cond)", ARG1, sizeof(struct vki_ucond) );
break;
case VKI_UMTX_OP_WAIT_UINT:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, CV_WAIT_UINT, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_wait_uint",
int *, obj, int, op, unsigned long, id,
size_t, timeout_wait, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_wait(uint)", ARG1, sizeof(int) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_wait(timespec)", ARG5, ARG4 );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_RW_RDLOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, RW_RDLOCK, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_rw_rdlock",
struct urwlock *, obj, int, op, unsigned long, noid,
void *, zero, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_rw_rdlock(rw)", ARG1, sizeof(struct vki_urwlock) );
PRE_MEM_WRITE( "_umtx_op_rw_rdlock(rw)", ARG1, sizeof(struct vki_urwlock) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_RW_WRLOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, RW_WRLOCK, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_rw_wrlock",
struct urwlock *, obj, int, op, unsigned long, noid,
void *, zero, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_rw_wrlock(rw)", ARG1, sizeof(struct vki_urwlock) );
PRE_MEM_WRITE( "_umtx_op_rw_wrlock(rw)", ARG1, sizeof(struct vki_urwlock) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_RW_UNLOCK:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, RW_UNLOCK, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ2(long, "_umtx_op_rw_unlock",
struct urwlock *, obj, int, op);
PRE_MEM_READ( "_umtx_op_rw_unlock(rw)", ARG1, sizeof(struct vki_urwlock) );
PRE_MEM_WRITE( "_umtx_op_rw_unlock(rw)", ARG1, sizeof(struct vki_urwlock) );
break;
case VKI_UMTX_OP_WAIT_UINT_PRIVATE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, CV_WAIT_UINT_PRIVATE, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_wait_uint_private",
int *, obj, int, op, unsigned long, id,
size_t, timeout_size, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_wait_private(uint)", ARG1, sizeof(int) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_wait_private(umtx_time)", ARG5, ARG4 );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_WAKE_PRIVATE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, CV_WAKE_PRIVATE, %" FMT_REGWORD "u)", ARG1, ARG3);
PRE_REG_READ3(long, "_umtx_op_wake_private",
struct umtx *, obj, int, op, unsigned long, id);
PRE_MEM_READ( "_umtx_op_wake_private(mtx)", ARG1, sizeof(struct vki_umtx) );
break;
case VKI_UMTX_OP_MUTEX_WAIT:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, MUTEX_WAIT, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ2(long, "_umtx_op_mutex_wait",
struct umutex *, obj, int, op);
PRE_MEM_READ( "_umtx_op_mutex_wait(mutex)", ARG1, sizeof(struct vki_umutex) );
PRE_MEM_WRITE( "_umtx_op_mutex_wait(mutex)", ARG1, sizeof(struct vki_umutex) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_MUTEX_WAKE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, MUTEX_WAKE, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ2(long, "_umtx_op_mutex_wake",
struct umutex *, obj, int, op);
PRE_MEM_READ( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
PRE_MEM_WRITE( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
break;
case VKI_UMTX_OP_SEM_WAIT:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, SEM_WAIT, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "_umtx_op_sem_wait",
struct usem *, obj, int, op, unsigned long, id,
size_t, timeout_size, struct vki_timespec *, timeout);
PRE_MEM_READ( "_umtx_op_sem_wait(usem)", ARG1, sizeof(struct vki_usem) );
PRE_MEM_WRITE( "_umtx_op_sem_wait(usem)", ARG1, sizeof(struct vki_usem) );
if (ARG5)
PRE_MEM_READ( "_umtx_op_sem_wait(umtx_time)", ARG5, ARG4 );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_SEM_WAKE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, SEM_WAKE, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ2(long, "_umtx_op_sem_wake",
struct umutex *, obj, int, op);
PRE_MEM_READ( "_umtx_op_sem_wake(mutex)", ARG1, sizeof(struct vki_usem) );
PRE_MEM_WRITE( "_umtx_op_sem_wake(mutex)", ARG1, sizeof(struct vki_usem) );
break;
case VKI_UMTX_OP_NWAKE_PRIVATE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, NWAKE_PRIVATE, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ3(long, "_umtx_op_nwake_private",
struct umutex *, obj, int, op, int, count);
PRE_MEM_READ( "_umtx_op_nwake_private(mtxs)", ARG1, ARG3 * sizeof(void *) );
PRE_MEM_WRITE( "_umtx_op_mutex_wake(mtxs)", ARG1, sizeof(struct vki_umutex) );
break;
case VKI_UMTX_OP_MUTEX_WAKE2:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, MUTEX_WAKE2, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ3(long, "_umtx_op_mutex_wake2",
struct umutex *, obj, int, op, unsigned long, flags);
PRE_MEM_READ( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
PRE_MEM_WRITE( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
break;
case VKI_UMTX_OP_SEM2_WAIT:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, SEM2_WAIT, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ3(long, "_umtx_op_sem2_wake",
struct _usem2 *, obj, int, op, unsigned long, flags);
PRE_MEM_READ( "_umtx_op_sem2_wait(mutex)", ARG1, sizeof(struct vki_usem2) );
PRE_MEM_WRITE( "_umtx_op_sem2_wait(mutex)", ARG1, sizeof(struct vki_usem2) );
*flags |= SfMayBlock;
break;
case VKI_UMTX_OP_SEM2_WAKE:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, SEM2_WAKE, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ3(long, "_umtx_op_sem2_wake",
struct _usem2 *, obj, int, op, unsigned long, flags);
PRE_MEM_READ( "_umtx_op_sem2_wait(mutex)", ARG1, sizeof(struct vki_usem2) );
PRE_MEM_WRITE( "_umtx_op_sem2_wait(mutex)", ARG1, sizeof(struct vki_usem2) );
break;
case VKI_UMTX_OP_SHM:
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, SHM, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ4(long, "_umtx_op_shm",
void *, obj, int, op, unsigned long, val, void*, uaddr);
break;
case VKI_UMTX_OP_ROBUST_LISTS:
// val (ARG2) ought to be the same as sizeof(struct vki_umtx_robust_lists_params)
// then the structure contains a pointer to mutex structures
if (ARG1 != sizeof(struct vki_umtx_robust_lists_params))
SET_STATUS_Failure( VKI_ENOSYS );
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, ROBUST_LISTS, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x)", ARG1, ARG3, ARG4, ARG5);
PRE_REG_READ3(long, "_umtx_op_robust_lists",
struct umtx_robust_lists_params *, obj, int, op, unsigned long, flags);
PRE_MEM_READ( "_umtx_op_robust_lists(mutex)", ARG3, sizeof(struct vki_umtx_robust_lists_params) );
break;
default:
VG_(umsg)("WARNING: _umtx_op unsupported value.\n");
PRINT( "sys__umtx_op ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u(UNKNOWN), %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2, ARG3, ARG4, ARG5);
break;
}
}
POST(sys__umtx_op)
{
switch(ARG2) {
case VKI_UMTX_OP_LOCK:
if (SUCCESS)
POST_MEM_WRITE( ARG1, sizeof(struct vki_umtx) );
break;
case VKI_UMTX_OP_UNLOCK:
if (SUCCESS)
POST_MEM_WRITE( ARG1, sizeof(struct vki_umtx) );
break;
case VKI_UMTX_OP_WAIT:
case VKI_UMTX_OP_WAKE:
case VKI_UMTX_OP_WAIT_UINT:
case VKI_UMTX_OP_WAIT_UINT_PRIVATE:
case VKI_UMTX_OP_WAKE_PRIVATE:
break;
case VKI_UMTX_OP_MUTEX_TRYLOCK:
case VKI_UMTX_OP_MUTEX_LOCK:
case VKI_UMTX_OP_MUTEX_UNLOCK:
case VKI_UMTX_OP_MUTEX_WAIT: /* Sets/clears contested bits */
case VKI_UMTX_OP_MUTEX_WAKE: /* Sets/clears contested bits */
if (SUCCESS)
POST_MEM_WRITE( ARG1, sizeof(struct vki_umutex) );
break;
case VKI_UMTX_OP_SET_CEILING:
if (SUCCESS) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_umutex) );
if (ARG4)
POST_MEM_WRITE( ARG4, sizeof(vki_uint32_t) );
}
break;
case VKI_UMTX_OP_CV_WAIT:
if (SUCCESS) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_ucond) );
POST_MEM_WRITE( ARG4, sizeof(struct vki_umutex) );
}
break;
case VKI_UMTX_OP_CV_SIGNAL:
if (SUCCESS) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_ucond) );
}
break;
case VKI_UMTX_OP_CV_BROADCAST:
if (SUCCESS) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_ucond) );
}
break;
case VKI_UMTX_OP_RW_RDLOCK:
case VKI_UMTX_OP_RW_WRLOCK:
case VKI_UMTX_OP_RW_UNLOCK:
if (SUCCESS) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_urwlock) );
}
break;
case VKI_UMTX_OP_SEM2_WAIT:
case VKI_UMTX_OP_SEM2_WAKE:
if (SUCCESS) {
POST_MEM_WRITE( ARG1, sizeof(struct vki_usem2) );
}
break;
case VKI_UMTX_OP_SHM:
case VKI_UMTX_OP_ROBUST_LISTS:
default:
break;
}
}
// SYS_thr_new 455
// x86/amd64
// SYS_sigqueue 456
// int sigqueue(pid_t pid, int signo, const union sigval value);
PRE(sys_sigqueue)
{
PRINT("sys_sigqueue ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",
SARG1,SARG2,ARG3);
PRE_REG_READ3(int, "sigqueue", vki_pid_t, pid, int, signo, const union vki_sigval, value);
}
// SYS_kmq_open 457
// mqd_t mq_open(const char *name, int oflag, ...);
// int kmq_open(_In_z_ const char *path, int flags, mode_t mode, _In_opt_ const struct mq_attr *attr);
PRE(sys_kmq_open)
{
if (ARG2 & VKI_O_CREAT) {
PRINT("sys_kmq_open( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %hu, %#" FMT_REGWORD "x )",
ARG1,(char *)ARG1,ARG2,(vki_mode_t)ARG3,ARG4);
PRE_REG_READ4(long, "mq_open",
const char *, name, int, oflag, vki_mode_t, mode,
struct mq_attr *, attr);
} else {
PRINT("sys_kmq_open( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %hu)",
ARG1,(char *)ARG1,ARG2,(vki_mode_t)ARG3);
PRE_REG_READ3(long, "mq_open",
const char *, name, int, oflag, vki_mode_t, mode);
}
PRE_MEM_RASCIIZ( "mq_open(name)", ARG1 );
if (ARG2 & VKI_O_CREAT) {
PRE_MEM_READ("mq_open(attr)", ARG4, sizeof(struct vki_mq_attr));
if (ML_(safe_to_deref)((struct vki_mq_attr *)ARG4, sizeof(struct vki_mq_attr))) {
const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG4;
PRE_MEM_READ("mq_open(attr->mq_maxmsg)",
(Addr)&attr->mq_maxmsg, sizeof(attr->mq_maxmsg) );
PRE_MEM_READ("mq_open(attr->mq_msgsize)",
(Addr)&attr->mq_msgsize, sizeof(attr->mq_msgsize) );
}
}
}
POST(sys_kmq_open)
{
vg_assert(SUCCESS);
if (!ML_(fd_allowed)(RES, "mq_open", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_with_given_name)(tid, RES, (const HChar*)ARG1);
}
}
// SYS_kmq_setattr 458
// int mq_setattr(mqd_t mqdes, const struct mq_attr *restrict mqstat,
// struct mq_attr *restrict omqstat);
PRE(sys_kmq_setattr)
{
PRINT("sys_kmq_getattr( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2,ARG3 );
PRE_REG_READ3(int, "mq_setattr",
vki_mqd_t, mqdes, const struct mq_attr *, mqstat,
struct mq_attr *, omqstat);
if (!ML_(fd_allowed)(ARG1, "mq_getattr", tid, False)) {
SET_STATUS_Failure( VKI_EBADF );
} else {
if (ML_(safe_to_deref)((struct vki_mq_attr *)ARG2, sizeof(struct vki_mq_attr))) {
const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG2;
PRE_MEM_READ( "mq_setattr(mqstat->mq_flags)",
(Addr)&attr->mq_flags, sizeof(attr->mq_flags) );
}
PRE_MEM_WRITE( "mq_setattr(omqstat)", ARG3,
sizeof(struct vki_mq_attr) );
}
}
// SYS_kmq_timedreceive 459
// ssize_t mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
// unsigned *msg_prio, const struct timespec *abs_timeout);
PRE(sys_kmq_timedreceive)
{
*flags |= SfMayBlock;
PRINT("sys_kmq_timedreceive( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %llu, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "mq_timedreceive",
vki_mqd_t, mqdes, char *, msg_ptr, vki_size_t, msg_len,
unsigned int *, msg_prio,
const struct timespec *, abs_timeout);
if (!ML_(fd_allowed)(ARG1, "mq_timedreceive", tid, False)) {
SET_STATUS_Failure( VKI_EBADF );
} else {
PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", ARG2, ARG3 );
if (ARG4 != 0)
PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
ARG4, sizeof(unsigned int) );
if (ARG5 != 0)
PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
ARG5, sizeof(struct vki_timespec) );
}
}
POST(sys_kmq_timedreceive)
{
POST_MEM_WRITE( ARG2, ARG3 );
if (ARG4 != 0)
POST_MEM_WRITE( ARG4, sizeof(unsigned int) );
}
// SYS_kmq_timedsend 460
// int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
// unsigned msg_prio, const struct timespec *abs_timeout);
PRE(sys_kmq_timedsend)
{
*flags |= SfMayBlock;
PRINT("sys_kmq_timedsend ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %llu, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",
ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
PRE_REG_READ5(int, "mq_timedsend",
vki_mqd_t, mqdes, const char *, msg_ptr, vki_size_t, msg_len,
unsigned int, msg_prio, const struct timespec *, abs_timeout);
if (!ML_(fd_allowed)(ARG1, "mq_timedsend", tid, False)) {
SET_STATUS_Failure( VKI_EBADF );
} else {
PRE_MEM_READ( "mq_timedsend(msg_ptr)", ARG2, ARG3 );
if (ARG5 != 0)
PRE_MEM_READ( "mq_timedsend(abs_timeout)", ARG5,
sizeof(struct vki_timespec) );
}
}
// SYS_kmq_notify 461
// int mq_notify(mqd_t mqdes, const struct sigevent *notification);
PRE(sys_kmq_notify)
{
PRINT("sys_kmq_notify( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2 );
PRE_REG_READ2(int, "mq_notify",
vki_mqd_t, mqdes, const struct sigevent *, notification);
if (!ML_(fd_allowed)(ARG1, "mq_notify", tid, False))
SET_STATUS_Failure( VKI_EBADF );
else if (ARG2 != 0)
PRE_MEM_READ( "mq_notify(notification)",
ARG2, sizeof(struct vki_sigevent) );
}
// SYS_kmq_unlink 462
// int kmq_unlink(const char *path);
PRE(sys_kmq_unlink)
{
PRINT("sys_kmq_unlink ( %#" FMT_REGWORD "x(%s) )", ARG1,(char *)ARG1);
PRE_REG_READ1(int, "mq_unlink", const char *, name);
PRE_MEM_RASCIIZ( "mq_unlink(name)", ARG1 );
}
// SYS_abort2 463
// void abort2(const char *why, int nargs, void **args);
PRE(sys_abort2)
{
PRINT( "sys_abort2 ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", ARG1, SARG2, ARG3 );
PRE_REG_READ3(void, "abort2", const char *, why, int, nargs, void **, args);
// max length of 'why' is 128
PRE_MEM_RASCIIZ( "abort2(why)", ARG2);
// max val for nargs is 16
PRE_MEM_READ("abort2(args", ARG3, ARG2*sizeof(void*));
}
// SYS_thr_set_name 464
// int thr_set_name(long id, const char *name);
PRE(sys_thr_set_name)
{
PRINT( "sys_thr_set_name ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1, ARG2 );
PRE_REG_READ2(int, "thr_set_name", long, id, const char *, name);
PRE_MEM_RASCIIZ( "thr_set_name(name)", ARG2);
if (ML_(safe_to_deref)((void*)ARG2, 1)) {
const HChar* new_name = (const HChar*) (Addr)ARG2;
ThreadState* tst = VG_(get_ThreadState)(tid);
SizeT new_len = VG_(strnlen)(new_name, VKI_MAXCOMLEN+1);
tst->thread_name = VG_(realloc)("syswrap.thr_set_name", tst->thread_name, new_len + 1);
VG_(strlcpy)(tst->thread_name, new_name, new_len + 1);
}
}
// SYS_aio_fsync 465
// int aio_fsync(int op, struct aiocb *iocb);
PRE(sys_aio_fsync)
{
PRINT("aio_fsync ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1,ARG2);
PRE_REG_READ2(int, "aio_fsync", int, op, struct vki_aiocb *, iocb);
PRE_MEM_READ( "aio_fsync(iocb)", ARG2, sizeof(struct vki_aiocb) );
}
// SYS_rtprio_thread 466
// int rtprio_thread(int function, lwpid_t lwpid, struct rtprio *rtp);
PRE(sys_rtprio_thread)
{
PRINT( "sys_rtprio_thread ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1, ARG2, ARG3 );
PRE_REG_READ3(int, "rtprio_thread",
int, function, __vki_lwpid_t, lwpid, struct vki_rtprio *, rtp);
if (ARG1 == VKI_RTP_SET) {
PRE_MEM_READ( "rtprio_thread(rtp#set)", ARG3, sizeof(struct vki_rtprio));
} else if (ARG1 == VKI_RTP_LOOKUP) {
PRE_MEM_WRITE( "rtprio_thread(rtp#lookup)", ARG3, sizeof(struct vki_rtprio));
} else {
/* PHK ?? */
}
}
POST(sys_rtprio_thread)
{
if (ARG1 == VKI_RTP_LOOKUP && RES == 0)
POST_MEM_WRITE( ARG3, sizeof(struct vki_rtprio));
}
// SYS_sctp_peeloff 471
// int sctp_peeloff(int s, sctp_assoc_t id);
// @todo
// SYS_sctp_generic_sendmsg 472
// int sctp_generic_sendmsg(int s, void *msg, int msglen, struct sockaddr *to,
// socklen_t len, struct sctp_sndrcvinfo *sinfo, int flags);
// @tdo
// SYS_sctp_generic_sendmsg_iov 473
// int sctp_generic_sendmsg_iov(int s, struct iovec *iov, int iovlen,
// struct sockaddr *to, struct sctp_sndrcvinfo *sinfo, int flags);
// @todo
// SYS_sctp_generic_recvmsg 474
// int sctp_generic_recvmsg(int s, struct iovec *iov, int iovlen,
// struct sockaddr *from, socklen_t *fromlen,
// struct sctp_sndrcvinfo *sinfo, int *msgflags);
// @todo
// SYS_pread 475
// x86/amd64
// SYS_pwrite 476
// x86/amd64
// SYS_mmap 477
// x86/amd64
// SYS_lseek 478
// x86/amd64
//SYS_truncate 479
// x86/amd64
// SYS_ftruncate 480
// x86/amd64
// SYS_thr_kill2 481
// int thr_kill2(pid_t pid, long id, int sig);
PRE(sys_thr_kill2)
{
PRINT("sys_thr_kill2 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1,ARG2,ARG3);
PRE_REG_READ3(int, "thr_kill2", pid_t, pid, long, tid, int, sig);
if (!ML_(client_signal_OK)(ARG3)) {
SET_STATUS_Failure( VKI_EINVAL );
return;
}
/* Check to see if this kill gave us a pending signal */
*flags |= SfPollAfter;
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "thr_kill2: sending signal %lu to pid %lu/%lu\n",
ARG3, ARG1, ARG2);
/* If we're sending SIGKILL, check to see if the target is one of
our threads and handle it specially. */
if (ARG3 == VKI_SIGKILL && ML_(do_sigkill)(ARG2, ARG1)) {
SET_STATUS_Success(0);
return;
}
/* Ask to handle this syscall via the slow route, since that's the
only one that sets tst->status to VgTs_WaitSys. If the result
of doing the syscall is an immediate run of
async_signalhandler() in m_signals, then we need the thread to
be properly tidied away. I have the impression the previous
version of this wrapper worked on x86/amd64 only because the
kernel did not immediately deliver the async signal to this
thread (on ppc it did, which broke the assertion re tst->status
at the top of async_signalhandler()). */
*flags |= SfMayBlock;
}
POST(sys_thr_kill2)
{
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "thr_kill2: sent signal %lu to pid %lu/%lu\n",
ARG3, ARG1, ARG2);
}
// SYS_shm_open 482
// int shm_open(const char *path, int flags, mode_t mode);
PRE(sys_shm_open)
{
PRE_REG_READ3(int, "shm_open",
const char *, path, int, flags, vki_mode_t, mode);
if (ARG1 == VKI_SHM_ANON) {
PRINT("sys_shm_open(%#" FMT_REGWORD "x(SHM_ANON), %" FMT_REGWORD "u, %hu)", ARG1, ARG2, (vki_mode_t)ARG3);
} else {
PRINT("sys_shm_open(%#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %hu)", ARG1, (HChar *)ARG1, ARG2, (vki_mode_t)ARG3);
PRE_MEM_RASCIIZ( "shm_open(path)", ARG1 );
}
*flags |= SfMayBlock;
}
POST(sys_shm_open)
{
vg_assert(SUCCESS);
if (!ML_(fd_allowed)(RES, "shm_open", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
}
}
// SYS_shm_unlink 483
// int shm_unlink(const char *path);
PRE(sys_shm_unlink)
{
PRINT("sys_shm_unlink(%#" FMT_REGWORD "x(%s))", ARG1, (char *)ARG1);
PRE_REG_READ1(int, "shm_unlink",
const char *, path);
PRE_MEM_RASCIIZ( "shm_unlink(path)", ARG1 );
*flags |= SfMayBlock;
}
// SYS_cpuset 484
// int cpuset(cpusetid_t *setid);
PRE(sys_cpuset)
{
PRINT("sys_cpuset ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "cpuset", vki_cpusetid_t *, setid);
PRE_MEM_WRITE("cpuset(setid)", ARG1, sizeof(vki_cpusetid_t));
}
POST(sys_cpuset)
{
POST_MEM_WRITE(ARG1, sizeof(vki_cpusetid_t));
}
// SYS_cpuset_setid 485
// amd64 / x86
// SYS_cpuset_getid 486
// amd64 / x86
// SYS_cpuset_getaffinity 487
// amd64 / x86
// SYS_cpuset_setaffinity 488
// amd64 / x86
// SYS_faccessat 489
// int faccessat(int fd, const char *path, int mode, int flag);
PRE(sys_faccessat)
{
PRINT("sys_faccessat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ3(int, "faccessat",
int, fd, const char *, path, int, flag);
PRE_MEM_RASCIIZ( "faccessat(path)", ARG2 );
}
// SYS_fchmodat 490
// int fchmodat(int fd, const char *path, mode_t mode, int flag);
PRE(sys_fchmodat)
{
PRINT("sys_fchmodat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ4(int, "fchmodat",
int, fd, const char *, path, vki_mode_t, mode, int, flag);
PRE_MEM_RASCIIZ( "fchmodat(path)", ARG2 );
}
// SYS_fchownat 491
// int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag);
PRE(sys_fchownat)
{
PRINT("sys_fchownat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x, %" FMT_REGWORD "d )",
ARG1,ARG2,(char*)ARG2,ARG3,ARG4, SARG5);
PRE_REG_READ5(int, "fchownat",
int, fd, const char *, path,
vki_uid_t, owner, vki_gid_t, group, int, flag);
PRE_MEM_RASCIIZ( "fchownat(path)", ARG2 );
}
// SYS_fexecve 492
// int fexecve(int fd, char *const argv[], char *const envp[]);
PRE(sys_fexecve)
{
PRINT("sys_fexecve ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1,ARG2,ARG3);
PRE_REG_READ3(int, "fexecve",
int, fd, char * const *, argv,
char * const *, envp);
if (!ML_(fd_allowed)(ARG1, "fexecve", tid, False)) {
SET_STATUS_Failure(VKI_EBADF);
return;
}
const HChar *fname;
if (VG_(resolve_filename)(ARG1, &fname) == False) {
SET_STATUS_Failure(VKI_ENOENT);
return;
}
struct vg_stat stats;
if (VG_(fstat)(ARG1, &stats) != 0) {
SET_STATUS_Failure(VKI_EACCES);
return;
}
Int openFlags;
if (VG_(resolve_filemode)(ARG1, &openFlags) == False) {
SET_STATUS_Failure(VKI_ENOENT);
return;
}
/*
* openFlags is in kernel FFLAGS format
* (see /usr/include/sys/fcntl.h)
* which alllows us to tell if RDONLY is set
*
*/
Bool isScript = False;
SysRes res;
res = VG_(open)(fname, VKI_O_RDONLY,
VKI_S_IRUSR|VKI_S_IRGRP|VKI_S_IROTH);
if (sr_isError(res)) {
SET_STATUS_Failure(VKI_ENOENT);
return;
} else {
char buf[2];
VG_(read)((Int)sr_Res(res), buf, 2);
VG_(close)((Int)sr_Res(res));
if (buf[0] == '#' && buf[1] == '!')
{
isScript = True;
}
}
if (isScript) {
if (!(openFlags & VKI_FREAD)) {
SET_STATUS_Failure(VKI_EACCES);
return;
}
} else {
if (!((openFlags & VKI_O_EXEC) ||
(stats.mode & (VKI_S_IXUSR|VKI_S_IXGRP|VKI_S_IXOTH)))) {
SET_STATUS_Failure(VKI_EACCES);
return;
}
}
Addr arg_2 = (Addr)ARG2;
Addr arg_3 = (Addr)ARG3;
handle_pre_sys_execve(tid, status, (Addr)fname, arg_2, arg_3, FEXECVE, False);
}
// SYS_freebsd11_fstatat 493
// int fstatat(int fd, const char *path, struct stat *sb, int flag);
#if (FREEBSD_VERS >= FREEBSD_12)
PRE(sys_freebsd11_fstatat)
{
PRINT("sys_freebsd11_fstatat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )", ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ4(int, "fstatat",
int, fd, const char *, path, struct freebsd11_stat *, buf, int, flag);
PRE_MEM_RASCIIZ( "fstatat(path)", ARG2 );
PRE_MEM_WRITE( "fstatat(sb)", ARG3, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_freebsd11_fstatat)
{
POST_MEM_WRITE( ARG3, sizeof(struct vki_freebsd11_stat) );
}
#else
PRE(sys_fstatat)
{
PRINT("sys_fstatat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )", ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ4(int, "fstatat",
int, fd, const char *, path, struct stat *, buf, int, flag);
PRE_MEM_RASCIIZ( "fstatat(path)", ARG2 );
PRE_MEM_WRITE( "fstatat(sb)", ARG3, sizeof(struct vki_freebsd11_stat) );
}
POST(sys_fstatat)
{
POST_MEM_WRITE( ARG3, sizeof(struct vki_freebsd11_stat) );
}
#endif
// SYS_futimesat 494
// int futimesat(int fd, const char *path, const struct timeval times[2]);
PRE(sys_futimesat)
{
PRINT("sys_futimesat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )", ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ3(int, "futimesat",
int, fd, const char *, path, struct timeval *, times);
if (ARG2 != 0)
PRE_MEM_RASCIIZ( "futimesat(path)", ARG2 );
if (ARG3 != 0)
PRE_MEM_READ( "futimesat(times)", ARG3, 2 * sizeof(struct vki_timeval) );
}
// SYS_linkat 495
// int linkat(int fd1, const char *name1, int fd2, const char *name2, int flag);
PRE(sys_linkat)
{
*flags |= SfMayBlock;
PRINT("sys_linkat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4,ARG5);
PRE_REG_READ5(int, "linkat",
int, fd1, const char *, name1,
int, fd2, const char *, name2,
int, flag);
PRE_MEM_RASCIIZ( "linkat(name1)", ARG2);
PRE_MEM_RASCIIZ( "linkat(name2)", ARG4);
}
// SYS_mkdirat 496
// int mkdirat(int fd, const char *path, mode_t mode);
PRE(sys_mkdirat)
{
*flags |= SfMayBlock;
PRINT("sys_mkdirat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ3(int, "mkdirat",
int, fd, const char *, path, int, mode);
PRE_MEM_RASCIIZ( "mkdirat(path)", ARG2 );
}
// SYS_mkfifoat 497
// int mkfifoat(int fd, const char *path, mode_t mode);
PRE(sys_mkfifoat)
{
PRINT("sys_mkfifoat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x )",
SARG1,ARG2,(HChar*)ARG2,ARG3 );
PRE_REG_READ3(int, "mkfifoat",
int, fd, const char *, path, vki_mode_t, mode);
PRE_MEM_RASCIIZ( "mkfifoat(path)", ARG2 );
}
// SYS_freebsd11_mknodat 498
// int mknodat(int fd, const char *path, mode_t mode, dev_t dev);
#if (FREEBSD_VERS >= FREEBSD_12)
PRE(sys_freebsd11_mknodat)
{
PRINT("sys_freebsd11_mknodat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4 );
PRE_REG_READ4(long, "mknodat",
int, dfd, const char *, pathname, int, mode, unsigned, dev);
PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
}
#else
PRE(sys_mknodat)
{
PRINT("sys_mknodat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4 );
PRE_REG_READ4(long, "mknodat",
int, dfd, const char *, pathname, int, mode, unsigned, dev);
PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
}
#endif
// SYS_openat 499
// int openat(int fd, const char *path, int flags, ...);
PRE(sys_openat)
{
if (ARG3 & VKI_O_CREAT) {
// 4-arg version
PRINT("sys_openat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "openat",
int, fd, const char *, path, int, flags, vki_mode_t, mode);
} else {
// 3-arg version
PRINT("sys_openat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )",ARG1,ARG2,(char*)ARG2,ARG3);
PRE_REG_READ3(int, "openat",
int, fd, const char *, path, int, flags);
}
if (ARG1 != (unsigned)VKI_AT_FDCWD && !ML_(fd_allowed)(ARG1, "openat", tid, False))
SET_STATUS_Failure( VKI_EBADF );
else
PRE_MEM_RASCIIZ( "openat(path)", ARG2 );
/* Otherwise handle normally */
*flags |= SfMayBlock;
}
POST(sys_openat)
{
vg_assert(SUCCESS);
if (!ML_(fd_allowed)(RES, "openat", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG2);
}
}
// SYS_readlinkat 500
// ssize_t readlinkat(int fd, const char *restrict path, char *restrict buf,
// size_t bufsize);
PRE(sys_readlinkat)
{
HChar name[25];
Word saved = SYSNO;
PRINT("sys_readlinkat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %llu )", ARG1,ARG2,(char*)ARG2,ARG3,(ULong)ARG4);
PRE_REG_READ4(ssize_t, "readlinkat",
int, fd, const char *, path, char *, buf, int, bufsize);
PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
PRE_MEM_WRITE( "readlinkat(buf)", ARG3,ARG4 );
/*
* Handle the case where readlinkat is looking at /proc/curproc/file or
* /proc/<pid>/file.
*/
VG_(sprintf)(name, "/proc/%d/file", VG_(getpid)());
if (ML_(safe_to_deref)((void*)ARG2, 1)
&& (VG_(strcmp)((HChar *)ARG2, name) == 0
|| VG_(strcmp)((HChar *)ARG2, "/proc/curproc/file") == 0)) {
VG_(sprintf)(name, "/proc/self/fd/%d", VG_(cl_exec_fd));
SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, (UWord)name,
ARG3, ARG4));
} else {
/* Normal case */
SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, ARG2, ARG3, ARG4));
}
}
POST(sys_readlinkat)
{
POST_MEM_WRITE( ARG3, RES );
}
// SYS_renameat 501
// int renameat(int fromfd, const char *from, int tofd, const char *to);
PRE(sys_renameat)
{
PRINT("sys_renameat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s) )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4);
PRE_REG_READ4(int, "renameat",
int, fromfd, const char *, from,
int, tofd, const char *, to);
PRE_MEM_RASCIIZ( "renameat(oldpath)", ARG2 );
PRE_MEM_RASCIIZ( "renameat(newpath)", ARG4 );
}
// SYS_symlinkat 502
// int symlinkat(const char *name1, int fd, const char *name2);
PRE(sys_symlinkat)
{
*flags |= SfMayBlock;
PRINT("sys_symlinkat ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s) )",ARG1,(char*)ARG1,ARG2,ARG3,(char*)ARG3);
PRE_REG_READ3(int, "symlinkat",
const char *, name1, int, fd, const char *, name2);
PRE_MEM_RASCIIZ( "symlinkat(name1)", ARG1 );
PRE_MEM_RASCIIZ( "symlinkat(name2)", ARG3 );
}
// SYS_unlinkat 503
// int unlinkat(int fd, const char *path, int flag);
PRE(sys_unlinkat)
{
*flags |= SfMayBlock;
PRINT("sys_unlinkat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s) )", ARG1,ARG2,(char*)ARG2);
PRE_REG_READ3(int, "unlinkat", int, fd, const char *, path, int, flag);
PRE_MEM_RASCIIZ( "unlinkat(path)", ARG2 );
}
// SYS_posix_openpt 504
// int posix_openpt(int oflag);
PRE(sys_posix_openpt)
{
PRINT("sys_posix_openpt ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "posix_openpt", int, oflag);
}
// SYS_gssd_syscall 505
// @todo
// see https://www.freebsd.org/cgi/man.cgi?format=html&query=gssapi(3)
// syscalls.master says ; 505 is initialised by the kgssapi code, if present.
// SYS_jail_get 506
// int jail_get(struct iovec *iov, u_int niov, int flags);
PRE(sys_jail_get)
{
PRINT("sys_jail_get ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "jail_get", struct vki_iovec *, iov, unsigned int,
niov, int, flags);
PRE_MEM_READ("jail_get(iov)", ARG1, ARG2 * sizeof(struct vki_iovec));
}
// SYS_jail_set 507
// int jail_set(struct iovec *iov, u_int niov, int flags);
PRE(sys_jail_set)
{
PRINT("sys_jail_set ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "jail_set", struct vki_iovec *, iov, unsigned int,
niov, int, flags);
PRE_MEM_READ("jail_set(iovs)", ARG1, ARG2 * sizeof(struct vki_iovec));
}
// SYS_jail_remove 508
// int jail_remove(int jid);
PRE(sys_jail_remove)
{
PRINT("sys_jail_remove ( %" FMT_REGWORD "d )", SARG1);
PRE_REG_READ1(int, "jail_remove", int, jid);
}
// SYS_closefrom 509
// void closefrom(int lowfd);
PRE(sys_closefrom)
{
PRINT("sys_closefrom ( %" FMT_REGWORD "dx )", SARG1);
PRE_REG_READ1(int, "closefrom", int, lowfd);
/*
* Can't pass this on to the kernel otherwise it will close
* all of the host files like the log
*/
for (int i = ARG1; i < VG_(fd_soft_limit); ++i) {
VG_(close)(i);
}
SET_STATUS_Success(0);
}
// SYS___semctl 510
// int semctl(int semid, int semnum, int cmd, ...);
// int __semctl(int semid, int semnum, int cmd, _Inout_ union semun *arg);
PRE(sys___semctl)
{
switch (ARG3) {
case VKI_IPC_INFO:
case VKI_SEM_INFO:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "semctl",
int, semid, int, semnum, int, cmd, struct seminfo *, arg);
break;
case VKI_IPC_STAT:
case VKI_SEM_STAT:
case VKI_IPC_SET:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, struct semid_ds *, arg);
break;
case VKI_GETALL:
case VKI_SETALL:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, unsigned short *, arg);
break;
default:
PRINT("sys_semctl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "semctl",
int, semid, int, semnum, int, cmd);
break;
}
ML_(generic_PRE_sys_semctl)(tid, ARG1,ARG2,ARG3,ARG4);
}
POST(sys___semctl)
{
ML_(generic_POST_sys_semctl)(tid, RES,ARG1,ARG2,ARG3,ARG4);
}
// SYS_msgctl 511
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
PRE(sys_msgctl)
{
PRINT("sys_msgctl ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1,SARG2,ARG3 );
PRE_REG_READ3(int, "msgctl", int, msqid, int, cmd, struct msqid_ds *, buf);
switch (ARG2 /* cmd */) {
case VKI_IPC_STAT:
PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)",
ARG3, sizeof(struct vki_msqid_ds) );
break;
case VKI_IPC_SET:
PRE_MEM_READ( "msgctl(IPC_SET, buf)",
ARG3, sizeof(struct vki_msqid_ds) );
break;
}
}
POST(sys_msgctl)
{
switch (ARG2 /* cmd */) {
case VKI_IPC_STAT:
POST_MEM_WRITE( ARG3, sizeof(struct vki_msqid_ds) );
break;
}
}
// SYS_shmctl 512
// int shmctl(int shmid, int cmd, struct shmid_ds *buf);
PRE(sys_shmctl)
{
PRINT("sys_shmctl ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",SARG1,SARG2,ARG3);
PRE_REG_READ3(int, "shmctl",
int, shmid, int, cmd, struct vki_shmid_ds *, buf);
switch (ARG2 /* cmd */) {
case VKI_IPC_STAT:
PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)",
ARG3, sizeof(struct vki_shmid_ds) );
break;
case VKI_IPC_SET:
PRE_MEM_READ( "shmctl(IPC_SET, buf)",
ARG3, sizeof(struct vki_shmid_ds) );
break;
}
}
POST(sys_shmctl)
{
if (ARG2 == VKI_IPC_STAT) {
POST_MEM_WRITE( ARG3, sizeof(struct vki_shmid_ds) );
}
}
// SYS_lpathconf 513
// long lpathconf(const char *path, int name);
PRE(sys_lpathconf)
{
PRINT("sys_lpathconf ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d)", ARG1, SARG2);
PRE_REG_READ2(long, "lpathconf", const char *, path, int, name);
PRE_MEM_RASCIIZ("lpathconf(path)", ARG1);
}
// SYS___cap_rights_get 515
// note extra 1st argument for the internal function which is not present
// in the public interface
// int __cap_rights_get(int version, int fd, cap_rights_t *rights);
PRE(sys_cap_rights_get)
{
PRINT("sys_cap_rights_get ( %" FMT_REGWORD "d, %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "cap_rights_get", int, version, int, fd, vki_cap_rights_t*, rights);
PRE_MEM_WRITE("cap_rights_get(rights)", ARG3, sizeof(vki_cap_rights_t));
}
POST(sys_cap_rights_get)
{
POST_MEM_WRITE(ARG2, sizeof(vki_cap_rights_t));
}
// SYS_cap_enter 516
// int cap_enter(void);
PRE(sys_cap_enter)
{
PRINT("%s", "sys_cap_enter ( )");
PRE_REG_READ0(int, "cap_enter");
static Bool warning_given = False;
if (!warning_given) {
warning_given = True;
capabiltyMode = True;
VG_(umsg)(
"WARNING: Valgrind may not operate correctly in capability mode.\n"
" Please consider disabling capability by using the RUNNING_ON_VALGRIND mechanism.\n"
" See http://valgrind.org/docs/manual/manual-core-adv.html#manual-core-adv.clientreq\n");
}
}
// SYS_cap_getmode 517
// int cap_getmode(u_int *modep);
PRE(sys_cap_getmode)
{
PRINT("sys_cap_getmode ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "cap_getmode", u_int*, modep);
PRE_MEM_WRITE("cap_getmode(modep)", ARG1, sizeof(u_int));
}
POST(sys_cap_getmode)
{
POST_MEM_WRITE(ARG1, sizeof(u_int));
}
static vki_sigset_t pdfork_saved_mask;
// SYS_pdfork 518
// pid_t pdfork(int *fdp, int flags);
PRE(sys_pdfork)
{
Bool is_child;
Int child_pid;
vki_sigset_t mask;
PRINT("sys_pdfork ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2);
PRE_REG_READ2(pid_t, "pdfork", int*, fdp, int, flags);
/* Block all signals during fork, so that we can fix things up in
the child without being interrupted. */
VG_(sigfillset)(&mask);
VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, &pdfork_saved_mask);
VG_(do_atfork_pre)(tid);
SET_STATUS_from_SysRes( VG_(do_syscall2)(__NR_pdfork, ARG1, ARG2) );
if (!SUCCESS) return;
// RES is 0 for child, non-0 (the child's PID) for parent.
is_child = ( RES == 0 ? True : False );
child_pid = ( is_child ? -1 : RES );
if (is_child) {
VG_(do_atfork_child)(tid);
/* restore signal mask */
VG_(sigprocmask)(VKI_SIG_SETMASK, &pdfork_saved_mask, NULL);
} else {
VG_(do_atfork_parent)(tid);
PRINT(" fork: process %d created child %d\n", VG_(getpid)(), child_pid);
/* restore signal mask */
VG_(sigprocmask)(VKI_SIG_SETMASK, &pdfork_saved_mask, NULL);
}
if (ARG1) {
PRE_MEM_WRITE( "pdfork(fdp)", ARG1, sizeof(int) );
}
}
POST(sys_pdfork)
{
if (ARG1) {
POST_MEM_WRITE( ARG1, sizeof(int) );
}
}
// pdkill 519
//int pdkill(int fd, int signum)
PRE(sys_pdkill)
{
PRINT("sys_pdkill ( %" FMT_REGWORD "u, %" FMT_REGWORD "d )", ARG1, SARG2);
PRE_REG_READ2(int, "pdkill", int, fd, int, signum);
if (!ML_(client_signal_OK)(ARG2)) {
SET_STATUS_Failure( VKI_EINVAL );
return;
}
/* Ther was some code here to check if the kill is to this process
*
* But it was totally wrong
*
* It was calling ML_(do_sigkill)(Int pid, Int tgid)
*
* With a file descriptor
*
* Fortunately this will never match a real process otherwise
* it might have accidentally killed us.
*
* For a start we need the pid, obtained with pdgetpid
* Next ML_(do_sigkill) doesn't map to FreeBSD. It takes a
* pid (lwpid) and a tgid (threadgroup)
*
* On FreeBSD lwpid is the tid and threadgroup is the pid
* The kill functions operate on pids, not tids.
*
* One last thing, I don't see how pdkill could do a self
* kill 9. It neads an fd which implied pdfork whichimplies
* that the fd/pid are for a child process
*/
SET_STATUS_from_SysRes(VG_(do_syscall2)(SYSNO, ARG1, ARG2));
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "pdkill: sent signal %ld to fd %ld\n",
SARG2, SARG1);
/* This kill might have given us a pending signal. Ask for a check once
the syscall is done. */
*flags |= SfPollAfter;
}
// SYS_pdgetpid 520
// int pdgetpid(int fd, pid_t *pidp);
PRE(sys_pdgetpid)
{
PRINT("pdgetpid ( %" FMT_REGWORD "d, %#lx )", SARG1, ARG2);
PRE_REG_READ2(int, "pdgetpid",
int, fd, pid_t*, pidp);
PRE_MEM_WRITE( "pdgetpid(pidp))", ARG2, sizeof(vki_pid_t) );
}
POST(sys_pdgetpid)
{
POST_MEM_WRITE( ARG2, sizeof(vki_pid_t) );
}
// SYS_pselect 522
// int pselect(int nfds, fd_set * restrict readfds, fd_set * restrict writefds,
// fd_set * restrict exceptfds,
// const struct timespec * restrict timeout,
// const sigset_t * restrict newsigmask);
PRE(sys_pselect)
{
*flags |= SfMayBlock | SfPostOnFail;
PRINT("sys_pselect ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(int, "pselect",
int, nfds, vki_fd_set *, readfds, vki_fd_set *, writefds,
vki_fd_set *, exceptfds, struct vki_timespec *, timeout,
const sigset_t *, newsigmask);
// XXX: this possibly understates how much memory is read.
if (ARG2 != 0)
PRE_MEM_READ( "pselect(readfds)",
ARG2, ARG1/8 /* __FD_SETSIZE/8 */ );
if (ARG3 != 0)
PRE_MEM_READ( "pselect(writefds)",
ARG3, ARG1/8 /* __FD_SETSIZE/8 */ );
if (ARG4 != 0)
PRE_MEM_READ( "pselect(exceptfds)",
ARG4, ARG1/8 /* __FD_SETSIZE/8 */ );
if (ARG5 != 0)
PRE_MEM_READ( "pselect(timeout)", ARG5, sizeof(struct vki_timeval) );
if (ARG6 != 0) {
PRE_MEM_READ( "pselect(sig)", ARG6, sizeof(vki_sigset_t) );
ARG6 = ML_(make_safe_mask)("syswrap.pselect.1", (Addr)ARG6);
}
}
POST(sys_pselect)
{
ML_(free_safe_mask) ( (Addr)ARG6 );
}
// SYS_getloginclass 523
// int getloginclass(char *name, size_t len);
PRE(sys_getloginclass)
{
PRINT("sys_getloginclass ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(int, "getloginclass", char *, name, size_t, len);
// The buffer should be at least MAXLOGNAME bytes in length.
PRE_MEM_WRITE("getloginclass(name)", ARG1, ARG2);
}
POST(sys_getloginclass)
{
POST_MEM_WRITE(ARG1, ARG2);
}
// SYS_setloginclass 524
// int setloginclass(const char *name);
PRE(sys_setloginclass)
{
PRINT("sys_setloginclass ( %#" FMT_REGWORD "x(%s) )", ARG1, (HChar*)ARG1);
PRE_REG_READ1(int, "setloginclass", const char *, name);
PRE_MEM_RASCIIZ("rctl_setloginclass(name)", ARG1);
}
// SYS_rctl_get_racct 525
// int rctl_get_racct(const char *inbufp, size_t inbuflen, char *outbufp,
// size_t outbuflen);
PRE(sys_rctl_get_racct)
{
PRINT("sys_rctl_get_racct ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "xd, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "rctl_get_racct", const char *, inbufp, size_t, inbuflen, char *, outbufp,
size_t, outbuflen);
PRE_MEM_READ("rctl_get_racct(inbufp)", ARG1, ARG2);
PRE_MEM_WRITE("rctl_get_racct(outbufp)", ARG3, ARG4);
}
POST(sys_rctl_get_racct)
{
POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_rctl_get_rules 526
// int rctl_get_rules(const char *inbufp, size_t inbuflen, char *outbufp,
// size_t outbuflen);
PRE(sys_rctl_get_rules)
{
PRINT("sys_rctl_get_rules ( %#" FMT_REGWORD "xd, %" FMT_REGWORD "u, %#" FMT_REGWORD "xd, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "rctl_get_rules", const char *, inbufp, size_t, inbuflen, char *, outbufp,
size_t, outbuflen);
PRE_MEM_READ("rctl_get_rules(inbufp)", ARG1, ARG2);
PRE_MEM_WRITE("rctl_get_rules(outbufp)", ARG3, ARG4);
}
POST(sys_rctl_get_rules)
{
POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_rctl_get_limits 527
// int rctl_get_limits(const char *inbufp, size_t inbuflen, char *outbufp,
// size_t outbuflen);
PRE(sys_rctl_get_limits)
{
PRINT("sys_rctl_get_limits ( %#" FMT_REGWORD "xd, %" FMT_REGWORD "u, %#" FMT_REGWORD "xd, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "rctl_get_limits", const char *, inbufp, size_t, inbuflen, char *, outbufp,
size_t, outbuflen);
PRE_MEM_READ("rctl_get_limits(inbufp)", ARG1, ARG2);
PRE_MEM_WRITE("rctl_get_limits(outbufp)", ARG3, ARG4);
}
POST(sys_rctl_get_limits)
{
POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_rctl_add_rule 528
// int rctl_add_rule(const char *inbufp, size_t inbuflen, char *outbufp,
// size_t outbuflen);
PRE(sys_rctl_add_rule)
{
PRINT("sys_rctl_add_rule ( %#" FMT_REGWORD "xd, %" FMT_REGWORD "u, %#" FMT_REGWORD "xd, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ2(int, "rctl_add_rule", const char *, inbufp, size_t, inbuflen);
PRE_MEM_READ("rctl_add_rule(inbufp)", ARG1, ARG2);
// man page says
// The outbufp and outbuflen arguments are unused
//PRE_MEM_WRITE("rctl_add_rule(outbufp)", ARG3, ARG4);
}
POST(sys_rctl_add_rule)
{
//POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_rctl_remove_rule 529
// int rctl_remove_rule(const char *inbufp, size_t inbuflen, char *outbufp,
// size_t outbuflen);
PRE(sys_rctl_remove_rule)
{
PRINT("sys_rctl_remove_rule ( %#" FMT_REGWORD "xd, %" FMT_REGWORD "u, %#" FMT_REGWORD "xd, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ2(int, "rctl_remove_rule", const char *, inbufp, size_t, inbuflen);
PRE_MEM_READ("rctl_remove_rule(inbufp)", ARG1, ARG2);
// man page says
// The outbufp and outbuflen arguments are unused
//PRE_MEM_WRITE("rctl_remove_rule(outbufp)", ARG3, ARG4);
}
POST(sys_rctl_remove_rule)
{
//POST_MEM_WRITE(ARG3, ARG4);
}
// SYS_posix_fallocate 530
// x86/amd64
// SYS_posix_fadvise 531
// x86/amd64
// SYS_wait6 532
// amd64 / x86
// SYS_cap_rights_limit 533
//int cap_rights_limit(int fd, const cap_rights_t *rights);
PRE(sys_cap_rights_limit)
{
PRINT("sys_cap_rights_limit ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(int, "cap_rights_limit",
int, fd, const cap_rights_t *, rights);
PRE_MEM_READ( "cap_rights_limit(rights)", ARG2, sizeof(struct vki_cap_rights) );
}
// SYS_cap_ioctls_limit 534
// int cap_ioctls_limit(int fd, const unsigned long *cmds, size_t ncmds);
PRE(sys_cap_ioctls_limit)
{
PRINT("cap_ioctls_limit ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "cap_ioctls_limit",
int, fd, unsigned long*, rights, vki_size_t, ncmds);
// "can be up to 256" taking that to not be inclusive
if (ARG3 < 256 ) {
PRE_MEM_READ( "cap_ioctls_limit(cmds))", ARG2, ARG3*sizeof(unsigned long) );
}
// else fail?
}
// SYS_cap_ioctls_get 535
// int cap_ioctls_get(int fd, unsigned long *cmds, size_t maxcmds);
PRE(sys_cap_ioctls_get)
{
PRINT("sys_cap_ioctls_get ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", SARG1, ARG2, ARG3);
PRE_REG_READ3(int, "cap_ioctls_get", int, fd, unsigned long *, cmds, size_t, maxcmds);
if (ARG3 < 256) {
PRE_MEM_WRITE("cap_ioctls_get(cmds)", ARG2, ARG3*sizeof(unsigned long));
}
}
POST(sys_cap_ioctls_get)
{
if (ARG3 < 256) {
POST_MEM_WRITE(ARG2, ARG3*sizeof(unsigned long));
}
}
// SYS_cap_fcntls_limit 536
//int cap_fcntls_limit(int fd, uint32_t fcntlrights);
PRE(sys_cap_fcntls_limit)
{
PRINT("cap_fcntls_limit ( %" FMT_REGWORD "d, %" FMT_REGWORD "u )", SARG1, ARG2);
PRE_REG_READ2(long, "cap_fcntls_limit",
int, fd, vki_uint32_t, fcntlrights);
}
// SYS_cap_fcntls_get 537
// int cap_fcntls_get(int fd, uint32_t *fcntlrightsp);
PRE(sys_cap_fcntls_get)
{
PRINT("sys_cap_fcntls_get ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(int, "cap_fcntls_get", int, fd, uint32_t *, fcntlrightsp);
PRE_MEM_WRITE("cap_fcntls_get(fcntlrightsp)", ARG2, sizeof(uint32_t));
}
POST(sys_cap_fcntls_get)
{
POST_MEM_WRITE(ARG2, sizeof(uint32_t));
}
// SYS_bindat 538
// int bindat(int fd, int s, const struct sockaddr *addr, socklen_t addrlen);
PRE(sys_bindat)
{
PRINT("sys_bindat ( %" FMT_REGWORD "d, %" FMT_REGWORD "dx, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "bindat", int, fd, int, s, const struct vki_sockaddr *, name, vki_socklen_t, namelen);
PRE_MEM_READ("bindat(name)", ARG3, ARG4);
}
// SYS_connectat 539
// int connectat(int fd, int s, const struct sockaddr *name, socklen_t namelen);
PRE(sys_connectat)
{
PRINT("sys_connectat ( %" FMT_REGWORD "d, %" FMT_REGWORD "dx, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "connectat", int, fd, int, s, const struct vki_sockaddr *, name, vki_socklen_t, namelen);
PRE_MEM_READ("connectat(name)", ARG3, ARG4);
}
// SYS_chflagsat 540
// int chflagsat(int fd, const char *path, unsigned long flags, int atflag);
PRE(sys_chflagsat)
{
PRINT("sys_chglagsat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "d )",
SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(int, "chflagsat", int, fd, const char *, path, unsigned long, flags, int, atflag);
PRE_MEM_RASCIIZ("chflagsat(path)", ARG2);
}
// SYS_accept4 541
// int accept4(int s, struct sockaddr * restrict addr,
// socklen_t * restrict addrlen, int flags);
PRE(sys_accept4)
{
*flags |= SfMayBlock;
PRINT("sys_accept4 ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u)",ARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(int, "accept4",
int, s, struct sockaddr *, addr, int, *addrlen, int, flags);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
POST(sys_accept4)
{
SysRes r;
vg_assert(SUCCESS);
r = ML_(generic_POST_sys_accept)(tid, VG_(mk_SysRes_Success)(RES),
ARG1,ARG2,ARG3);
SET_STATUS_from_SysRes(r);
}
// SYS_pipe2 542
// int pipe2(int fildes[2], int flags);
PRE(sys_pipe2)
{
PRINT("sys_pipe2 ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(int, "pipe2",
int *, fildes, int, flags);
PRE_MEM_WRITE("pipe2(fildes)", ARG1, 2 * sizeof(int));
}
POST(sys_pipe2)
{
int *fildes;
if (RES != 0)
return;
POST_MEM_WRITE(ARG1, 2 * sizeof(int));
fildes = (int *)ARG1;
if (!ML_(fd_allowed)(fildes[0], "pipe2", tid, True) ||
!ML_(fd_allowed)(fildes[1], "pipe2", tid, True)) {
VG_(close)(fildes[0]);
VG_(close)(fildes[1]);
SET_STATUS_Failure( VKI_EMFILE );
} else if (VG_(clo_track_fds)) {
ML_(record_fd_open_nameless)(tid, fildes[0]);
ML_(record_fd_open_nameless)(tid, fildes[1]);
}
}
// SYS_aio_mlock 543
// int aio_mlock(struct aiocb *iocb);
PRE(sys_aio_mlock)
{
PRINT("sys_aio_mlock ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "aio_mlock", struct vki_aiocb *, iocb);
PRE_MEM_READ("aio_mlock(iocb", ARG1, sizeof(struct vki_aiocb));
// this locks memory into RAM, don't think that we need to do
// anything extra
}
// SYS_procctl 544
// amd64 / x86
// SYS_ppoll 545
// int ppoll(struct pollfd fds[], nfds_t nfds,
// const struct timespec * restrict timeout,
// const sigset_t * restrict newsigmask);
PRE(sys_ppoll)
{
PRINT("sys_ppoll ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD "x )",
ARG1, ARG2, ARG3, ARG4);
UInt i;
struct vki_pollfd* fds = (struct vki_pollfd *)(Addr)ARG1;
*flags |= SfMayBlock | SfPostOnFail;
PRE_REG_READ4(long, "ppoll",
struct vki_pollfd *, fds, unsigned int, nfds,
struct vki_timespec *, timeout, vki_sigset_t *, newsigmask);
if (ML_(safe_to_deref)(fds, ARG2*sizeof(struct vki_pollfd))) {
for (i = 0; i < ARG2; i++) {
PRE_MEM_READ( "ppoll(fds.fd)",
(Addr)(&fds[i].fd), sizeof(fds[i].fd) );
PRE_MEM_READ( "ppoll(fds.events)",
(Addr)(&fds[i].events), sizeof(fds[i].events) );
PRE_MEM_WRITE( "ppoll(fds.revents)",
(Addr)(&fds[i].revents), sizeof(fds[i].revents) );
}
}
if (ARG3) {
PRE_MEM_READ( "ppoll(timeout)", ARG3,
sizeof(struct vki_timespec) );
}
if (ARG4) {
PRE_MEM_READ( "ppoll(newsigmask)", ARG4, sizeof(vki_sigset_t));
ARG4 = ML_(make_safe_mask)("syswrap.ppoll.1", (Addr)ARG4);
}
}
POST(sys_ppoll)
{
if (SUCCESS && ((Word)RES != -1)) {
UInt i;
struct vki_pollfd* ufds = (struct vki_pollfd *)(Addr)ARG1;
for (i = 0; i < ARG2; i++)
POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
}
ML_(free_safe_mask) ( (Addr)ARG4 );
}
// SYS_futimens 546
// int futimens(int fd, const struct timespec times[2]);
PRE(sys_futimens)
{
PRINT("sys_futimens ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(int, "futimens", int, fd, const struct timespec *, times);
PRE_MEM_READ("futimens(times)", ARG2, 2*sizeof(struct vki_timespec));
}
// SYS_utimensat 547
// int utimensat(int fd, const char *path, const struct timespec times[2],
// int flag);
PRE(sys_utimensat)
{
PRINT("sys_utimensat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "d )",
SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(int, "utimensat", int, fd, const char *,path, const struct timespec *, times,
int, flag);
PRE_MEM_RASCIIZ("utimensat(path)", ARG2);
PRE_MEM_READ("utimensat(times)", ARG3, 2*sizeof(struct vki_timespec));
}
// SYS_fdatasync 550
// int fdatasync(int fd);
PRE(sys_fdatasync)
{
PRINT("sys_fdatasync ( %" FMT_REGWORD "d )",SARG1);
PRE_REG_READ1(int, "fdatasync", int, fd);
}
#if (FREEBSD_VERS >= FREEBSD_12)
// SYS_fstat 551
// int fstat(int fd, struct stat *sb);
PRE(sys_fstat)
{
PRINT("sys_fstat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",SARG1,ARG2);
PRE_REG_READ2(int, "fstat", int, fd, struct stat *, sb);
PRE_MEM_WRITE( "fstat(sb)", ARG2, sizeof(struct vki_stat) );
}
POST(sys_fstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_stat) );
}
// SYS_fstatat 552
// int fstatat(int fd, const char *path, struct stat *sb, int flag);
PRE(sys_fstatat)
{
PRINT("sys_fstatat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %" FMT_REGWORD "d )", SARG1,ARG2,(char*)ARG2,ARG3,SARG4);
PRE_REG_READ4(int, "fstatat",
int, fd, const char *, path, struct stat *, sb, int, flag);
PRE_MEM_RASCIIZ( "fstatat(path)", ARG2 );
PRE_MEM_WRITE( "fstatat(sb)", ARG3, sizeof(struct vki_stat) );
}
POST(sys_fstatat)
{
POST_MEM_WRITE( ARG3, sizeof(struct vki_stat) );
}
// SYS_fhstat 553
// int fhstat(const fhandle_t *fhp, struct stat *sb);
PRE(sys_fhstat)
{
PRINT("sys_fhstat ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(long, "fhstat", const vki_fhandle_t *, fhp, struct stat *, sb);
PRE_MEM_READ( "fhstat(fhp)", ARG1, sizeof(struct vki_fhandle) );
PRE_MEM_WRITE( "fhstat(sb)", ARG2, sizeof(struct vki_stat) );
}
POST(sys_fhstat)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_stat) );
}
// SYS_getdirentries 554
// ssize_t getdirentries(int fd, char *buf, size_t nbytes, off_t *basep);
PRE(sys_getdirentries)
{
*flags |= SfMayBlock;
PRINT("sys_getdirentries ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", SARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(ssize_t, "getdirentries",
int, fd, char *, buf,
size_t, nbytes,
off_t *, basep);
PRE_MEM_WRITE( "getdirentries(buf)", ARG2, ARG3 );
if (ARG4)
PRE_MEM_WRITE("getdirentries(basep)", ARG4, sizeof (vki_off_t));
}
POST(sys_getdirentries)
{
vg_assert(SUCCESS);
if (RES > 0) {
POST_MEM_WRITE( ARG2, RES );
if ( ARG4 != 0 )
POST_MEM_WRITE( ARG4, sizeof (vki_off_t));
}
}
// SYS_statfs 555
// int statfs(const char *path, struct statfs *buf);
PRE(sys_statfs)
{
PRINT("sys_statfs ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",ARG1,(char *)ARG1,ARG2);
PRE_REG_READ2(int, "statfs", const char *, path, struct statfs *, buf);
PRE_MEM_RASCIIZ( "statfs(path)", ARG1 );
PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct vki_statfs) );
}
POST(sys_statfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs) );
}
// SYS_fstatfs 556
// int fstatfs(int fd, struct statfs *buf);
PRE(sys_fstatfs)
{
PRINT("sys_fstatfs ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x )",SARG1,ARG2);
PRE_REG_READ2(int, "fstatfs",
int, fd, struct vki_statfs *, buf);
PRE_MEM_WRITE( "fstatfs(buf)", ARG2, sizeof(struct vki_statfs) );
}
POST(sys_fstatfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs) );
}
// SYS_getfsstat 557
// int getfsstat(struct statfs *buf, long bufsize, int mode);
PRE(sys_getfsstat)
{
PRINT("sys_getfsstat ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getfsstat", struct vki_statfs *, buf, long, len, int, flags);
PRE_MEM_WRITE( "getfsstat(buf)", ARG1, ARG2 );
}
POST(sys_getfsstat)
{
vg_assert(SUCCESS);
if ((Word)RES != -1) {
POST_MEM_WRITE( ARG1, RES * sizeof(struct vki_statfs) );
}
}
// SYS_fhstatfs 558
// int fhstatfs(const fhandle_t *fhp, struct statfs *buf);
PRE(sys_fhstatfs)
{
PRINT("sys_fhstatfs ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(long, "fhstatfs",
struct fhandle *, fhp, struct statfs *, buf);
PRE_MEM_READ( "fhstatfs(fhp)", ARG1, sizeof(struct vki_fhandle) );
PRE_MEM_WRITE( "fhstatfs(buf)", ARG2, sizeof(struct vki_statfs) );
}
POST(sys_fhstatfs)
{
POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs) );
}
// SYS_mknodat 559
// int mknodat(int fd, const char *path, mode_t mode, dev_t dev);
PRE(sys_mknodat)
{
PRINT("sys_mknodat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4 );
PRE_REG_READ4(long, "mknodat",
int, fd, const char *, path, vki_mode_t, mode, vki_dev_t, dev);
PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
}
// SYS_kevent 560
// int kevent(int kq, const struct kevent *changelist, int nchanges,
// struct kevent *eventlist, int nevents,
// const struct timespec *timeout);
PRE(sys_kevent)
{
PRINT("sys_kevent ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )\n", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
PRE_REG_READ6(int, "kevent",
int, kq, struct vki_kevent *, changelist, int, nchanges,
struct vki_kevent *, eventlist, int, nevents,
struct timespec *, timeout);
if (ARG2 != 0 && ARG3 != 0)
PRE_MEM_READ( "kevent(changelist)", ARG2, sizeof(struct vki_kevent)*ARG3 );
if (ARG4 != 0 && ARG5 != 0)
PRE_MEM_WRITE( "kevent(eventlist)", ARG4, sizeof(struct vki_kevent)*ARG5);
if (ARG5 != 0)
*flags |= SfMayBlock;
if (ARG6 != 0)
PRE_MEM_READ( "kevent(timeout)",
ARG6, sizeof(struct vki_timespec));
}
POST(sys_kevent)
{
vg_assert(SUCCESS);
if ((Word)RES != -1) {
if (ARG4 != 0)
POST_MEM_WRITE( ARG4, sizeof(struct vki_kevent)*RES) ;
}
}
// SYS_cpuset_getdomain 561
// x86 / amd64
// SYS_cpuset_setdomain 562
// x86 / amd64
// SYS_getrandom 563
// ssize_t getrandom(void *buf, size_t buflen, unsigned int flags);
PRE(sys_getrandom)
{
PRINT("sys_getrandom ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "getrandom",
void *, buf, vki_size_t, buflen, unsigned int, flags);
PRE_MEM_WRITE( "getrandom(buf)", ARG1, ARG2 );
if ((ARG3 & VKI_GRND_NONBLOCK) == 0) {
*flags |= SfMayBlock;
}
}
POST(sys_getrandom)
{
POST_MEM_WRITE( ARG1, ARG2 );
}
// SYS_getfhat 564
// int getfhat(int fd, const char *path, fhandle_t *fhp, int flag);
PRE(sys_getfhat)
{
PRINT("sys_getfhat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x, %" FMT_REGWORD "x, %" FMT_REGWORD "d ", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(int, "getfhat", int, fd, const char*, path, vki_fhandle_t*, fhp, int, flag);
PRE_MEM_RASCIIZ( "getfhat(path)", ARG2 );
PRE_MEM_WRITE("getfhat(fhp)", ARG3, sizeof(vki_fhandle_t));
}
POST(sys_getfhat)
{
POST_MEM_WRITE(ARG3, sizeof(vki_fhandle_t));
}
// SYS_fhlink 565
// int fhlink(fhandle_t *fhp, const char *to);
PRE(sys_fhlink)
{
PRINT("sys_fhlink ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2);
PRE_REG_READ2(int, "fhlink", vki_fhandle_t *, fhp, const char *, to);
PRE_MEM_READ( "fhlink(fhp)", ARG1, sizeof(vki_fhandle_t));
PRE_MEM_RASCIIZ("fhlink(buf)", ARG2);
}
// SYS_fhlinkat 566
// int fhlinkat(fhandle_t *fhp, int tofd, const char *to);
PRE(sys_fhlinkat)
{
PRINT("sys_fhlinkat ( %#" FMT_REGWORD "x, %" FMT_REGWORD "d, %#" FMT_REGWORD "xu ", ARG1, SARG2, ARG3);
PRE_REG_READ3(int, "fhlinkat", vki_fhandle_t *, fhp, int, tofd, const char *, to);
PRE_MEM_READ( "fhlinkat(fhp)", ARG1, sizeof(vki_fhandle_t));
PRE_MEM_RASCIIZ("fhreadlink(to)", ARG3);
}
// SYS_fhreadlink 567
// int fhreadlink(fhandle_t *fhp, char *buf, size_t bufsize);
PRE(sys_fhreadlink)
{
PRINT("sys_fhreadlink ( %#" FMT_REGWORD "x, %" FMT_REGWORD "x, %" FMT_REGWORD "u ", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "fhreadlink", vki_fhandle_t *, fhp, char *, buf, size_t, bufsize);
PRE_MEM_READ( "fhreadlink(fhp)", ARG1, sizeof(vki_fhandle_t));
PRE_MEM_WRITE("fhreadlink(buf)", ARG2, ARG3);
}
POST(sys_fhreadlink)
{
POST_MEM_WRITE(ARG2, ARG3);
}
#endif
#if (FREEBSD_VERS >= FREEBSD_12_2)
// SYS___sysctlbyname 570
// int sysctlbyname(const char *name, void *oldp, size_t *oldlenp,
// const void *newp, size_t newlen);
// syscalls.master:
// int __sysctlbyname(_In_reads_(namelen) const char *name, size_t namelen,
// _Out_writes_bytes_opt_(*oldlenp) void *old,
// _Inout_opt_ size_t *oldlenp, _In_reads_bytes_opt_(newlen) void *new,
// size_t newlen );
PRE(sys___sysctlbyname)
{
// this is very much like SYS___sysctl, instead of having an OID with length
// here threre is an ascii string with length
// @todo PJF factor out the common functionality of the two
PRINT("sys___sysctlbyname ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1,(const char*)ARG1,ARG2,ARG3,ARG4,ARG5 );
PRE_REG_READ6(int, "__sysctlbyname", const char *, name, vki_size_t, namelen,
void *, oldp, vki_size_t *, oldlenp,
void *, newp, vki_size_t, newlen);
// read number of ints specified in ARG2 from mem pointed to by ARG1
PRE_MEM_READ("__sysctlbyname(name)", (Addr)ARG1, ARG2 * sizeof(int));
// if 'newp' is not NULL can read namelen bytes from that addess
if (ARG5 != (UWord)NULL)
PRE_MEM_READ("__sysctlbyname(newp)", (Addr)ARG5, ARG6);
// there are two scenarios for oldlenp/oldp
// 1. oldval is NULL and oldlenp is non-NULL
// this is a query of oldlenp so oldlenp will be written
// 2. Both are non-NULL
// this is a query of oldp, oldlenp will be read and oldp will
// be written
// is oldlenp is not NULL, can write
if (ARG4 != (UWord)NULL) {
if (ARG3 != (UWord)NULL) {
// case 2 above
PRE_MEM_READ("__sysctlbyname(oldlenp)", (Addr)ARG4, sizeof(vki_size_t));
if (ML_(safe_to_deref)((void*)(Addr)ARG4, sizeof(vki_size_t))) {
PRE_MEM_WRITE("__sysctlbyname(oldp)", (Addr)ARG3, *(vki_size_t *)ARG4);
} else {
VG_(dmsg)("Warning: Bad oldlenp address %p in sysctl\n",
(void *)(Addr)ARG4);
SET_STATUS_Failure ( VKI_EFAULT );
}
} else {
// case 1 above
PRE_MEM_WRITE("__sysctlbyname(oldlenp)", (Addr)ARG4, sizeof(vki_size_t));
}
}
}
POST(sys___sysctlbyname)
{
if (ARG4 != (UWord)NULL) {
if (ARG3 != (UWord)NULL) {
//POST_MEM_WRITE((Addr)ARG4, sizeof(vki_size_t));
POST_MEM_WRITE((Addr)ARG3, *(vki_size_t *)ARG4);
} else
POST_MEM_WRITE((Addr)ARG4, sizeof(vki_size_t));
}
}
#endif // (FREEBSD_VERS >= FREEBSD_12_2)
#if (FREEBSD_VERS >= FREEBSD_13_0)
// SYS_shm_open2 571
// from syscalls.master
// int shm_open2(_In_z_ const char *path,
// int flags,
// mode_t mode,
// int shmflags,
// _In_z_ const char *name);
PRE(sys_shm_open2)
{
PRE_REG_READ5(int, "shm_open2",
const char *, path, int, flags, vki_mode_t, mode, int, shmflags, const char*, name);
if (ARG1 == VKI_SHM_ANON) {
PRINT("sys_shm_open2(%#" FMT_REGWORD "x(SHM_ANON), %" FMT_REGWORD "u, %hu, %d, %#" FMT_REGWORD "x(%s))",
ARG1, ARG2, (vki_mode_t)ARG3, (Int)ARG4, ARG5, (HChar*)ARG5);
} else {
PRINT("sys_shm_open2(%#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u, %hu, %d, %#" FMT_REGWORD "x(%s))",
ARG1, (HChar *)ARG1, ARG2, (vki_mode_t)ARG3, (Int)ARG4, ARG5, (HChar*)ARG5);
PRE_MEM_RASCIIZ( "shm_open2(path)", ARG1 );
}
if (ARG5) {
PRE_MEM_RASCIIZ( "shm_open2(name)", ARG5 );
}
*flags |= SfMayBlock;
}
POST(sys_shm_open2)
{
vg_assert(SUCCESS);
if (!ML_(fd_allowed)(RES, "shm_open2", tid, True)) {
VG_(close)(RES);
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
}
}
// SYS___realpathat 574
// from syscalls.master
// int __realpathat(int fd,
// _In_z_ const char *path,
// _Out_writes_z_(size) char *buf,
// size_t size,
// int flags)
PRE(sys___realpathat)
{
PRINT("sys___realpathat ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %" FMT_REGWORD "u %" FMT_REGWORD "d )",
SARG1,ARG2,(const char*)ARG2,ARG3,ARG4,SARG5 );
PRE_REG_READ5(int, "__realpathat", int, fd, const char *, path,
char *, buf, vki_size_t, size, int, flags);
PRE_MEM_RASCIIZ("__realpathat(path)", (Addr)ARG2);
PRE_MEM_WRITE("__realpathat(buf)", (Addr)ARG3, ARG4);
}
POST(sys___realpathat)
{
POST_MEM_WRITE((Addr)ARG3, ARG4);
}
// SYS___specialfd 577
// syscalls.master
// int __specialfd(int type,
// _In_reads_bytes_(len) const void *req,
// size_t len);
PRE(sys___specialfd)
{
PRINT("sys___specialfd ( %" FMT_REGWORD "d, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )",
SARG1,ARG2,(const char*)ARG2,ARG3 );
PRE_REG_READ3(int, "__specialfd", int, type, const void *, req, vki_size_t, len);
PRE_MEM_READ("__specialfd(req)", (Addr)ARG2, ARG3);
}
#endif // (FREEBSD_VERS >= FREEBSD_13_0)
#if (FREEBSD_VERS >= FREEBSD_13_1)
// SYS_swapoff 582
// int swapoff(const char *special, u_int flags);
PRE(sys_swapoff)
{
PRINT("sys_swapoff ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,(char *)ARG1, ARG2);
PRE_REG_READ2(int, "swapoff", const char *, special, u_int, flags);
PRE_MEM_RASCIIZ( "swapoff(special)", ARG1 );
}
#endif
#undef PRE
#undef POST
const SyscallTableEntry ML_(syscall_table)[] = {
// syscall (handled specially) // 0
BSDX_(__NR_exit, sys_exit), // 1
BSDX_(__NR_fork, sys_fork), // 2
GENXY(__NR_read, sys_read), // 3
GENX_(__NR_write, sys_write), // 4
GENXY(__NR_open, sys_open), // 5
GENXY(__NR_close, sys_close), // 6
GENXY(__NR_wait4, sys_wait4), // 7
// 4.3 creat 8
GENX_(__NR_link, sys_link), // 9
GENX_(__NR_unlink, sys_unlink), // 10
// obsol execv 11
GENX_(__NR_chdir, sys_chdir), // 12
GENX_(__NR_fchdir, sys_fchdir), // 13
GENX_(__NR_freebsd11_mknod, sys_mknod), // 14
GENX_(__NR_chmod, sys_chmod), // 15
GENX_(__NR_chown, sys_chown), // 16
GENX_(__NR_break, sys_brk), // 17
// freebsd 4 getfsstat 18
// 4.3 lseek 19
GENX_(__NR_getpid, sys_getpid), // 20
BSDX_(__NR_mount, sys_mount), // 21
BSDX_(__NR_unmount, sys_unmount), // 22
GENX_(__NR_setuid, sys_setuid), // 23
GENX_(__NR_getuid, sys_getuid), // 24
GENX_(__NR_geteuid, sys_geteuid), // 25
BSDXY(__NR_ptrace, sys_ptrace), // 26
BSDXY(__NR_recvmsg, sys_recvmsg), // 27
BSDX_(__NR_sendmsg, sys_sendmsg), // 28
BSDXY(__NR_recvfrom, sys_recvfrom), // 29
BSDXY(__NR_accept, sys_accept), // 30
BSDXY(__NR_getpeername, sys_getpeername), // 31
BSDXY(__NR_getsockname, sys_getsockname), // 32
GENX_(__NR_access, sys_access), // 33
BSDX_(__NR_chflags, sys_chflags), // 34
BSDX_(__NR_fchflags, sys_fchflags), // 35
GENX_(__NR_sync, sys_sync), // 36
GENX_(__NR_kill, sys_kill), // 37
// 4.3 stat 38
GENX_(__NR_getppid, sys_getppid), // 39
// 4.3 lstat 40
GENXY(__NR_dup, sys_dup), // 41
BSDXY(__NR_freebsd10_pipe, sys_pipe), // 42
GENX_(__NR_getegid, sys_getegid), // 43
GENX_(__NR_profil, sys_ni_syscall), // 44
GENX_(__NR_ktrace, sys_ni_syscall), // 45
// 4.3 sigaction 46
GENX_(__NR_getgid, sys_getgid), // 47
// 4.3 sigaction (int sigset) 48
BSDXY(__NR_getlogin, sys_getlogin), // 49
BSDX_(__NR_setlogin, sys_setlogin), // 50
GENX_(__NR_acct, sys_acct), // 51
// 4.3 sigpending 52
GENXY(__NR_sigaltstack, sys_sigaltstack), // 53
BSDXY(__NR_ioctl, sys_ioctl), // 54
BSDX_(__NR_reboot, sys_reboot), // 55
BSDX_(__NR_revoke, sys_revoke), // 56
GENX_(__NR_symlink, sys_symlink), // 57
GENX_(__NR_readlink, sys_readlink), // 58
GENX_(__NR_execve, sys_execve), // 59
GENX_(__NR_umask, sys_umask), // 60
GENX_(__NR_chroot, sys_chroot), // 61
// 4.3 fstat 62
// 4.3 getgerninfo 63
// 4.3 getpagesize 64
GENX_(__NR_msync, sys_msync), // 65
BSDX_(__NR_vfork, sys_vfork), // 66
// obsol vread 67
// obsol vwrite 68
BSDX_(__NR_sbrk, sys_sbrk), // 69
// not implemented in OS sstk 70
// 4.3 mmap 71
// freebsd11 vadvise 72
GENXY(__NR_munmap, sys_munmap), // 73
GENXY(__NR_mprotect, sys_mprotect), // 74
GENX_(__NR_madvise, sys_madvise), // 75
// obsol vhangup 76
// obsol vlimit 77
GENXY(__NR_mincore, sys_mincore), // 78
GENXY(__NR_getgroups, sys_getgroups), // 79
GENX_(__NR_setgroups, sys_setgroups), // 80
GENX_(__NR_getpgrp, sys_getpgrp), // 81
GENX_(__NR_setpgid, sys_setpgid), // 82
GENXY(__NR_setitimer, sys_setitimer), // 83
// 4.3 wait 84
BSDX_(__NR_swapon, sys_swapon), // 85
GENXY(__NR_getitimer, sys_getitimer), // 86
// 4.3 gethostname 87
// 4.3 sethostname 88
BSDX_(__NR_getdtablesize, sys_getdtablesize), // 89
GENXY(__NR_dup2, sys_dup2), // 90
BSDXY(__NR_fcntl, sys_fcntl), // 92
GENX_(__NR_select, sys_select), // 93
GENX_(__NR_fsync, sys_fsync), // 95
GENX_(__NR_setpriority, sys_setpriority), // 96
BSDXY(__NR_socket, sys_socket), // 97
BSDX_(__NR_connect, sys_connect), // 98
// 4.3 accept 99
GENX_(__NR_getpriority, sys_getpriority), // 100
// 4.3 send 101
// 4.3 recv 102
// 4.3 sigreturn 103
BSDX_(__NR_bind, sys_bind), // 104
BSDX_(__NR_setsockopt, sys_setsockopt), // 105
BSDX_(__NR_listen, sys_listen), // 106
// obsol vtimes 107
// 4.3 sigvec 108
// 4.3 sigblock 109
// 4.3 sigsetmask 110
// 4.3 sigsuspend 111
// 4.3 sigstack 112
// 4.3 recvmsg 113
// 4.3 sendmsg 114
// 4.3 vtrace 115
GENXY(__NR_gettimeofday, sys_gettimeofday), // 116
GENXY(__NR_getrusage, sys_getrusage), // 117
BSDXY(__NR_getsockopt, sys_getsockopt), // 118
GENXY(__NR_readv, sys_readv), // 120
GENX_(__NR_writev, sys_writev), // 121
GENX_(__NR_settimeofday, sys_settimeofday), // 122
GENX_(__NR_fchown, sys_fchown), // 123
GENX_(__NR_fchmod, sys_fchmod), // 124
// 4.3 recvfrom 125
GENX_(__NR_setreuid, sys_setreuid), // 126
GENX_(__NR_setregid, sys_setregid), // 127
GENX_(__NR_rename, sys_rename), // 128
// 4.3 truncate 129
// 4.3 ftruncate 130
GENX_(__NR_flock, sys_flock), // 131
BSDX_(__NR_mkfifo, sys_mkfifo), // 132
BSDX_(__NR_sendto, sys_sendto), // 133
BSDX_(__NR_shutdown, sys_shutdown), // 134
BSDXY(__NR_socketpair, sys_socketpair), // 135
GENX_(__NR_mkdir, sys_mkdir), // 136
GENX_(__NR_rmdir, sys_rmdir), // 137
GENX_(__NR_utimes, sys_utimes), // 138
// 4.2 sigreturn 139
BSDXY(__NR_adjtime, sys_adjtime), // 140
// 4.3 getpeername 141
// 4.3 gethostid 142
// 4.3 sethostid 143
// 4.3 getrlimit` 144
// 4.3 setrlimit 145
// 4.3 killpg 146
GENX_(__NR_setsid, sys_setsid), // 147
BSDX_(__NR_quotactl, sys_quotactl), // 148
// 4.3 quota 149
// 4.3 getsockname 150
// bsd/os sem_lock 151
// bsd/os sem_wakeup 152
// bsd/os asyncdaemon 153
// no idea what the following syscall does
// unimp SYS_nlm_syscall 154
// a somewhat complicated NFS API
// takes a flag and a void* that can point to one of
// three different types of struct depending on the flag
// unimp SYS_nfssvc 155
// 4.3 getdirentries 156
// freebsd 4 statfs 157
// freebsd 4 fstatfs 158
BSDXY(__NR_lgetfh, sys_lgetfh), // 160
BSDXY(__NR_getfh, sys_getfh), // 161
#if (FREEBSD_VERS <= FREEBSD_10)
BSDXY(__NR_freebsd4_getdomainname, sys_freebsd4_getdomainname), // 162
BSDX_(__NR_freebsd4_setdomainname, sys_freebsd4_setdomainname), // 163
BSDXY(__NR_freebsd4_uname, sys_freebsd4_uname), // 164
#endif
BSDXY(__NR_sysarch, sys_sysarch), // 165
BSDXY(__NR_rtprio, sys_rtprio), // 166
// the following 3 seem only to be defines in a header
// semsys 169
// msgsys 170
// shmsys 171
#if (FREEBSD_VERS <= FREEBSD_10)
BSDXY(__NR_freebsd6_pread, sys_freebsd6_pread), // 173
BSDX_(__NR_freebsd6_pwrite, sys_freebsd6_pwrite), // 174
#endif
BSDX_(__NR_setfib, sys_setfib), // 175
// @todo PJF this exists on Darwin and Solaris as well
// and it isn't implememented on either
// looking at the manpage there is a rather fearsome
// timex struct with a mixture of ro and rw fields
// BSDXY(__NR_ntp_adjtime, sys_ntp_adjtime), // 176
// bsd/os sfork 177
// bsd/os getdescriptor 178
// bsd/os setdescriptor 179
GENX_(__NR_setgid, sys_setgid), // 181
BSDX_(__NR_setegid, sys_setegid), // 182
BSDX_(__NR_seteuid, sys_seteuid), // 183
// obs lfs_bmapv 184
// obs lfs_markv 185
// obs lfs_segclean 186
// obs lfs_segwait 187
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_freebsd11_stat, sys_freebsd11_stat), // 188
BSDXY(__NR_freebsd11_fstat, sys_freebsd11_fstat), // 189
BSDXY(__NR_freebsd11_lstat, sys_freebsd11_lstat), // 190
#else
BSDXY(__NR_stat, sys_stat), // 188
BSDXY(__NR_fstat, sys_fstat), // 189
BSDXY(__NR_lstat, sys_lstat), // 190
#endif
BSDX_(__NR_pathconf, sys_pathconf), // 191
BSDX_(__NR_fpathconf, sys_fpathconf), // 192
GENXY(__NR_getrlimit, sys_getrlimit), // 194
GENX_(__NR_setrlimit, sys_setrlimit), // 195
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_freebsd11_getdirentries, sys_freebsd11_getdirentries), // 196
#else
BSDXY(__NR_getdirentries, sys_getdirentries), // 196
#endif
#if (FREEBSD_VERS <= FREEBSD_10)
BSDX_(__NR_freebsd6_mmap, sys_freebsd6_mmap), // 197
#endif
// __syscall (handled specially) // 198
#if (FREEBSD_VERS <= FREEBSD_10)
BSDX_(__NR_freebsd6_lseek, sys_freebsd6_lseek), // 199
BSDX_(__NR_freebsd6_truncate, sys_freebsd6_truncate), // 200
BSDX_(__NR_freebsd6_ftruncate, sys_freebsd6_ftruncate), // 201
#endif
BSDXY(__NR___sysctl, sys___sysctl), // 202
GENX_(__NR_mlock, sys_mlock), // 203
GENX_(__NR_munlock, sys_munlock), // 204
BSDX_(__NR_undelete, sys_undelete), // 205
BSDX_(__NR_futimes, sys_futimes), // 206
GENX_(__NR_getpgid, sys_getpgid), // 207
// netbsd newreboot 208
GENXY(__NR_poll, sys_poll), // 209
BSDXY(__NR_freebsd7___semctl, sys_freebsd7___semctl), // 220
BSDX_(__NR_semget, sys_semget), // 221
BSDX_(__NR_semop, sys_semop), // 222
// obs semconfig 223
BSDXY(__NR_freebsd7_msgctl, sys_freebsd7_msgctl), // 224
BSDX_(__NR_msgget, sys_msgget), // 225
BSDX_(__NR_msgsnd, sys_msgsnd), // 226
BSDXY(__NR_msgrcv, sys_msgrcv), // 227
BSDXY(__NR_shmat, sys_shmat), // 228
BSDXY(__NR_freebsd7_shmctl, sys_freebsd7_shmctl), // 229
BSDXY(__NR_shmdt, sys_shmdt), // 230
BSDX_(__NR_shmget, sys_shmget), // 231
BSDXY(__NR_clock_gettime, sys_clock_gettime), // 232
BSDX_(__NR_clock_settime, sys_clock_settime), // 233
BSDXY(__NR_clock_getres, sys_clock_getres), // 234
BSDXY(__NR_ktimer_create, sys_timer_create), // 235
BSDX_(__NR_ktimer_delete, sys_timer_delete), // 236
BSDXY(__NR_ktimer_settime, sys_timer_settime), // 237
BSDXY(__NR_ktimer_gettime, sys_timer_gettime), // 238
BSDX_(__NR_ktimer_getoverrun, sys_timer_getoverrun), // 239
GENXY(__NR_nanosleep, sys_nanosleep), // 240
// unimpl SYS_ffclock_getcounter 241
// unimpl SYS_ffclock_setestimate 242
// unimpl SYS_ffclock_getestimate 243
BSDXY(__NR_clock_nanosleep, sys_clock_nanosleep), // 244
BSDXY(__NR_clock_getcpuclockid2, sys_clock_getcpuclockid2), // 247
// unimpl SYS_ntp_gettime 248
BSDXY(__NR_minherit, sys_minherit), // 250
BSDX_(__NR_rfork, sys_rfork), // 251
// openbsd_poll // 252
BSDX_(__NR_issetugid, sys_issetugid), // 253
GENX_(__NR_lchown, sys_lchown), // 254
BSDXY(__NR_aio_read, sys_aio_read), // 255
BSDXY(__NR_aio_write, sys_aio_write), // 256
BSDX_(__NR_lio_listio, sys_lio_listio), // 257
GENXY(__NR_freebsd11_getdents, sys_getdents), // 272
BSDX_(__NR_lchmod, sys_lchmod), // 274
// netbsd_lchown // 275
BSDX_(__NR_lutimes, sys_lutimes), // 276
// netbsd msync 277
// unimpl SYS_freebsd11_nstat 278
// unimpl SYS_freebsd11_nfstat 279
// unimpl SYS_freebsd11_nlstat 280
BSDXY(__NR_preadv, sys_preadv), // 289
BSDX_(__NR_pwritev, sys_pwritev), // 290
// freebsd 4 fhstatfs 297
BSDXY(__NR_fhopen, sys_fhopen), // 298
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_freebsd11_fhstat, sys_freebsd11_fhstat), // 299
#else
BSDXY(__NR_fhstat, sys_fhstat), // 299
#endif
BSDX_(__NR_modnext, sys_modnext), // 300
BSDXY(__NR_modstat, sys_modstat), // 301
BSDX_(__NR_modfnext, sys_modfnext), // 302
BSDX_(__NR_modfind, sys_modfind), // 303
BSDX_(__NR_kldload, sys_kldload), // 304
BSDX_(__NR_kldunload, sys_kldunload), // 305
BSDX_(__NR_kldfind, sys_kldfind), // 306
BSDX_(__NR_kldnext, sys_kldnext), // 307
BSDXY(__NR_kldstat, sys_kldstat), // 308
BSDX_(__NR_kldfirstmod, sys_kldfirstmod), // 309
GENX_(__NR_getsid, sys_getsid), // 310
BSDX_(__NR_setresuid, sys_setresuid), // 311
BSDX_(__NR_setresgid, sys_setresgid), // 312
// obsol signanosleep 313
BSDX_(__NR_aio_return, sys_aio_return), // 314
BSDX_(__NR_aio_suspend, sys_aio_suspend), // 315
BSDX_(__NR_aio_cancel, sys_aio_cancel), // 316
BSDX_(__NR_aio_error, sys_aio_error), // 317
// freebsd 6 aio_read 318
// freebsd 6 aio_write 319
// freebsd 6 lio_listio 320
BSDX_(__NR_yield, sys_yield), // 321
// obs thr_sleep 322
// obs thr_wakeup 323
GENX_(__NR_mlockall, sys_mlockall), // 324
BSDX_(__NR_munlockall, sys_munlockall), // 325
BSDXY(__NR___getcwd, sys___getcwd), // 326
BSDX_(__NR_sched_setparam, sys_sched_setparam), // 327
BSDXY(__NR_sched_getparam, sys_sched_getparam), // 328
BSDX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 329
BSDX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 330
BSDX_(__NR_sched_yield, sys_sched_yield), // 331
BSDX_(__NR_sched_get_priority_max, sys_sched_get_priority_max), // 332
BSDX_(__NR_sched_get_priority_min, sys_sched_get_priority_min), // 333
BSDXY(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 334
BSDX_(__NR_utrace, sys_utrace), // 335
// freebsd 4 sendfile 336
BSDXY(__NR_kldsym, sys_kldsym), // 337
BSDX_(__NR_jail, sys_jail), // 338
// unimpl SYS_nnpfs_syscall 339
BSDXY(__NR_sigprocmask, sys_sigprocmask), // 340
BSDXY(__NR_sigsuspend, sys_sigsuspend), // 341
// freebsd 4 sigaction 342
BSDXY(__NR_sigpending, sys_sigpending), // 343
// freebsd 4 sigreturn 344
BSDXY(__NR_sigtimedwait, sys_sigtimedwait), // 345
BSDXY(__NR_sigwaitinfo, sys_sigwaitinfo), // 346
BSDXY(__NR___acl_get_file, sys___acl_get_file), // 347
BSDX_(__NR___acl_set_file, sys___acl_set_file), // 348
BSDXY(__NR___acl_get_fd, sys___acl_get_fd), // 349
BSDX_(__NR___acl_set_fd, sys___acl_set_fd), // 350
BSDX_(__NR___acl_delete_file, sys___acl_delete_file), // 351
BSDX_(__NR___acl_delete_fd, sys___acl_delete_fd), // 352
BSDX_(__NR___acl_aclcheck_file, sys___acl_aclcheck_file), // 353
BSDX_(__NR___acl_aclcheck_fd, sys___acl_aclcheck_fd), // 354
BSDX_(__NR_extattrctl, sys_extattrctl), // 355
BSDX_(__NR_extattr_set_file, sys_extattr_set_file), // 356
BSDXY(__NR_extattr_get_file, sys_extattr_get_file), // 357
BSDX_(__NR_extattr_delete_file, sys_extattr_delete_file), // 358
BSDXY(__NR_aio_waitcomplete, sys_aio_waitcomplete), // 359
BSDXY(__NR_getresuid, sys_getresuid), // 360
BSDXY(__NR_getresgid, sys_getresgid), // 361
BSDXY(__NR_kqueue, sys_kqueue), // 362
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_freebsd11_kevent, sys_freebsd11_kevent), // 363
#else
BSDXY(__NR_kevent, sys_kevent), // 363
#endif
// obs __cap_get_proc 364
// obs __cap_set_proc 365
// obs __cap_get_fd 366
// obs __cap_get_file 367
// obs __cap_set_fd 368
// obs __cap_set_file 369
BSDX_(__NR_extattr_set_fd, sys_extattr_set_fd), // 371
BSDXY(__NR_extattr_get_fd, sys_extattr_get_fd), // 372
BSDX_(__NR_extattr_delete_fd, sys_extattr_delete_fd), // 373
BSDX_(__NR___setugid, sys___setugid), // 374
// obs nfsclnt 375
BSDX_(__NR_eaccess, sys_eaccess), // 376
// unimpl afs3_syscall 377
BSDX_(__NR_nmount, sys_nmount), // 378
// obs kse_exit 379
// obs kse_wakeup 380
// obs kse_create 381
// obs kse_thr_interrupt 382
// obs kse_release 383
// unimpl __mac_get_proc 384
// unimpl __mac_set_proc 385
// unimpl __mac_get_fd 386
// unimpl __mac_get_file 387
// unimpl __mac_set_fd 388
// unimpl __mac_set_file 389
BSDXY(__NR_kenv, sys_kenv), // 390
BSDX_(__NR_lchflags, sys_lchflags), // 391
BSDXY(__NR_uuidgen, sys_uuidgen), // 392
BSDXY(__NR_sendfile, sys_sendfile), // 393
// unimpl mac_syscall 394
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_freebsd11_getfsstat, sys_freebsd11_getfsstat), // 395
BSDXY(__NR_freebsd11_statfs, sys_statfs), // 396
BSDXY(__NR_freebsd11_fstatfs, sys_fstatfs), // 397
BSDXY(__NR_freebsd11_fhstatfs, sys_fhstatfs), // 398
#else
BSDXY(__NR_getfsstat, sys_getfsstat), // 395
BSDXY(__NR_statfs, sys_statfs), // 396
BSDXY(__NR_fstatfs, sys_fstatfs), // 397
BSDXY(__NR_fhstatfs, sys_fhstatfs), // 398
#endif
// unimpl ksem_close 400
// unimpl ksem_post 401
// unimpl ksem_wait 402
// unimpl ksem_trywait 403
// unimpl ksem_init 404
// unimpl ksem_open 405
// unimpl ksem_unlink 406
// unimpl ksem_getvalue 407
// unimpl ksem_destroy 408
// unimpl __mac_get_pid 409
// unimpl __mac_get_link 410
// unimpl __mac_set_link 411
BSDX_(__NR_extattr_set_link, sys_extattr_set_link), // 412
BSDXY(__NR_extattr_get_link, sys_extattr_get_link), // 413
BSDX_(__NR_extattr_delete_link, sys_extattr_delete_link), // 414
// unimpl __mac_execve 415
BSDXY(__NR_sigaction, sys_sigaction), // 416
BSDX_(__NR_sigreturn, sys_sigreturn), // 417
BSDXY(__NR_getcontext, sys_getcontext), // 421
BSDX_(__NR_setcontext, sys_setcontext), // 422
BSDXY(__NR_swapcontext, sys_swapcontext), // 423
#if (FREEBSD_VERS >= FREEBSD_13_1)
BSDX_(__NR_freebsd13_swapoff, sys_freebsd13_swapoff), // 424
#else
BSDX_(__NR_swapoff, sys_swapoff), // 424
#endif
BSDXY(__NR___acl_get_link, sys___acl_get_link), // 425
BSDX_(__NR___acl_set_link, sys___acl_set_link), // 426
BSDX_(__NR___acl_delete_link, sys___acl_delete_link), // 427
BSDX_(__NR___acl_aclcheck_link, sys___acl_aclcheck_link), // 428
BSDXY(__NR_sigwait, sys_sigwait), // 429
BSDX_(__NR_thr_create, sys_thr_create), // 430
BSDX_(__NR_thr_exit, sys_thr_exit), // 431
BSDXY(__NR_thr_self, sys_thr_self), // 432
BSDXY(__NR_thr_kill, sys_thr_kill), // 433
#if (FREEBSD_VERS <= FREEBSD_10)
BSDXY(__NR__umtx_lock, sys__umtx_lock), // 434
BSDXY(__NR__umtx_unlock, sys__umtx_unlock), // 435
#endif
BSDX_(__NR_jail_attach, sys_jail_attach), // 436
BSDXY(__NR_extattr_list_fd, sys_extattr_list_fd), // 437
BSDXY(__NR_extattr_list_file, sys_extattr_list_file), // 438
BSDXY(__NR_extattr_list_link, sys_extattr_list_link), // 439
// obs kse_switchin 440
// unimpl ksem_timedwait 441
BSDX_(__NR_thr_suspend, sys_thr_suspend), // 442
BSDX_(__NR_thr_wake, sys_thr_wake), // 443
BSDX_(__NR_kldunloadf, sys_kldunloadf), // 444
// unimpl audit 445
// unimpl auditon 446
// unimpl getauid 447
// unimpl setauid 448
// unimpl getaudit 449
// unimpl setaudit 450
// unimpl getaudit_addr 451
// unimpl setaudit_addr 452
// unimpl auditctl 453
BSDXY(__NR__umtx_op, sys__umtx_op), // 454
BSDX_(__NR_thr_new, sys_thr_new), // 455
BSDX_(__NR_sigqueue, sys_sigqueue), // 456
BSDXY(__NR_kmq_open, sys_kmq_open), // 457
BSDX_(__NR_kmq_setattr, sys_kmq_setattr), // 458
BSDXY(__NR_kmq_timedreceive, sys_kmq_timedreceive), // 459
BSDX_(__NR_kmq_timedsend, sys_kmq_timedsend), // 460
BSDX_(__NR_kmq_notify, sys_kmq_notify), // 461
BSDX_(__NR_kmq_unlink, sys_kmq_unlink), // 462
BSDX_(__NR_abort2, sys_abort2), // 463
BSDX_(__NR_thr_set_name, sys_thr_set_name), // 464
BSDX_(__NR_aio_fsync, sys_aio_fsync), // 465
BSDXY(__NR_rtprio_thread, sys_rtprio_thread), // 466
// unimpl sctp_peeloff 471
// unimpl sctp_generic_sendmsg 472
// unimpl sctp_generic_sendmsg_iov 473
// unimpl sctp_generic_recvmsg 474
BSDXY(__NR_pread, sys_pread), // 475
BSDX_(__NR_pwrite, sys_pwrite), // 476
BSDX_(__NR_mmap, sys_mmap), // 477
BSDX_(__NR_lseek, sys_lseek), // 478
BSDX_(__NR_truncate, sys_truncate), // 479
BSDX_(__NR_ftruncate, sys_ftruncate), // 480
BSDXY(__NR_thr_kill2, sys_thr_kill2), // 481
BSDXY(__NR_shm_open, sys_shm_open), // 482
BSDX_(__NR_shm_unlink, sys_shm_unlink), // 483
BSDXY(__NR_cpuset, sys_cpuset), // 484
BSDX_(__NR_cpuset_setid, sys_cpuset_setid), // 485
BSDXY(__NR_cpuset_getid, sys_cpuset_getid), // 486
BSDXY(__NR_cpuset_getaffinity, sys_cpuset_getaffinity), // 487
BSDX_(__NR_cpuset_setaffinity, sys_cpuset_setaffinity), // 488
BSDX_(__NR_faccessat, sys_faccessat), // 489
BSDX_(__NR_fchmodat, sys_fchmodat), // 490
BSDX_(__NR_fchownat, sys_fchownat), // 491
BSDX_(__NR_fexecve, sys_fexecve), // 492
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_freebsd11_fstatat, sys_freebsd11_fstatat), // 493
#else
BSDXY(__NR_fstatat, sys_fstatat), // 493
#endif
BSDX_(__NR_futimesat, sys_futimesat), // 494
BSDX_(__NR_linkat, sys_linkat), // 495
BSDX_(__NR_mkdirat, sys_mkdirat), // 496
BSDX_(__NR_mkfifoat, sys_mkfifoat), // 497
#if (FREEBSD_VERS >= FREEBSD_12)
BSDX_(__NR_freebsd11_mknodat, sys_freebsd11_mknodat), // 498
#else
BSDX_(__NR_mknodat, sys_mknodat), // 498
#endif
BSDXY(__NR_openat, sys_openat), // 499
BSDXY(__NR_readlinkat, sys_readlinkat), // 500
BSDX_(__NR_renameat, sys_renameat), // 501
BSDX_(__NR_symlinkat, sys_symlinkat), // 502
BSDX_(__NR_unlinkat, sys_unlinkat), // 503
BSDX_(__NR_posix_openpt, sys_posix_openpt), // 504
// unimp gssd_syscall 505
BSDX_(__NR_jail_get, sys_jail_get), // 506
BSDX_(__NR_jail_set, sys_jail_set), // 507
BSDX_(__NR_jail_remove, sys_jail_remove), // 508
BSDX_(__NR_closefrom, sys_closefrom), // 509
BSDXY(__NR___semctl, sys___semctl), // 510
BSDXY(__NR_msgctl, sys_msgctl), // 511
BSDXY(__NR_shmctl, sys_shmctl), // 512
BSDX_(__NR_lpathconf, sys_lpathconf), // 513
/* 514 is obsolete cap_new */
BSDXY(__NR___cap_rights_get, sys_cap_rights_get), // 515
BSDX_(__NR_cap_enter, sys_cap_enter), // 516
BSDXY(__NR_cap_getmode, sys_cap_getmode), // 517
BSDXY(__NR_pdfork, sys_pdfork), // 518
BSDX_(__NR_pdkill, sys_pdkill), // 519
BSDXY(__NR_pdgetpid, sys_pdgetpid), // 520
BSDXY(__NR_pselect, sys_pselect), // 522
BSDXY(__NR_getloginclass, sys_getloginclass), // 523
BSDX_(__NR_setloginclass, sys_setloginclass), // 524
BSDXY(__NR_rctl_get_racct, sys_rctl_get_racct), // 525
BSDXY(__NR_rctl_get_rules, sys_rctl_get_rules), // 526
BSDXY(__NR_rctl_get_limits, sys_rctl_get_limits), // 527
BSDXY(__NR_rctl_add_rule, sys_rctl_add_rule), // 528
BSDXY(__NR_rctl_remove_rule, sys_rctl_remove_rule), // 529
BSDX_(__NR_posix_fallocate, sys_posix_fallocate), // 530
BSDX_(__NR_posix_fadvise, sys_posix_fadvise), // 531
BSDXY(__NR_wait6, sys_wait6), // 532
BSDX_(__NR_cap_rights_limit, sys_cap_rights_limit), // 533
BSDX_(__NR_cap_ioctls_limit, sys_cap_ioctls_limit), // 534
BSDXY(__NR_cap_ioctls_get, sys_cap_ioctls_get), // 535
BSDX_(__NR_cap_fcntls_limit, sys_cap_fcntls_limit), // 536
BSDXY(__NR_cap_fcntls_get, sys_cap_fcntls_get), // 537
BSDX_(__NR_bindat, sys_bindat), // 538
BSDX_(__NR_connectat, sys_connectat), // 539
BSDX_(__NR_chflagsat, sys_chflagsat), // 540
BSDXY(__NR_accept4, sys_accept4), // 541
BSDXY(__NR_pipe2, sys_pipe2), // 542
BSDX_(__NR_aio_mlock, sys_aio_mlock), // 543
BSDXY(__NR_procctl, sys_procctl), // 544
// 544 is the highest syscall on FreeBSD 9
#if (FREEBSD_VERS >= FREEBSD_10)
BSDXY(__NR_ppoll, sys_ppoll), // 545
BSDX_(__NR_futimens, sys_futimens), // 546
BSDX_(__NR_utimensat, sys_utimensat), // 547
#endif // FREEBSD_VERS >= FREEBSD_10
#if (FREEBSD_VERS >= FREEBSD_11)
/* 548 is obsolete numa_getaffinity */
/* 549 is obsolete numa_setaffinity */
BSDX_(__NR_fdatasync, sys_fdatasync), // 550
#endif // FREEBSD_VERS >= FREEBSD_11
#if (FREEBSD_VERS >= FREEBSD_12)
BSDXY(__NR_fstat, sys_fstat), // 551
BSDXY(__NR_fstatat, sys_fstatat), // 552
BSDXY(__NR_fhstat, sys_fhstat), // 553
BSDXY(__NR_getdirentries, sys_getdirentries), // 554
BSDXY(__NR_statfs, sys_statfs), // 555
BSDXY(__NR_fstatfs, sys_fstatfs), // 556
BSDXY(__NR_getfsstat, sys_getfsstat), // 557
BSDXY(__NR_fhstatfs, sys_fhstatfs), // 558
BSDX_(__NR_mknodat, sys_mknodat), // 559
BSDXY(__NR_kevent, sys_kevent), // 560
BSDXY(__NR_cpuset_getdomain, sys_cpuset_getdomain), // 561
BSDX_(__NR_cpuset_setdomain, sys_cpuset_setdomain), // 562
BSDXY(__NR_getrandom, sys_getrandom), // 563
BSDXY(__NR_getfhat, sys_getfhat), // 564
BSDX_(__NR_fhlink, sys_fhlink), // 565
BSDX_(__NR_fhlinkat, sys_fhlinkat), // 566
BSDXY(__NR_fhreadlink, sys_fhreadlink), // 567
#endif // FREEBSD_VERS >= FREEBSD_12
#if (FREEBSD_VERS >= FREEBSD_12_2)
// unimpl __NR_funlinkat 568
// unimpl __NR_copy_file_range 569
BSDXY(__NR___sysctlbyname, sys___sysctlbyname), // 570
#if (FREEBSD_VERS >= FREEBSD_13_0)
BSDXY(__NR_shm_open2, sys_shm_open2), // 571
// unimpl __NR_shm_rename 572
// unimpl __NR_sigfastblock 573
BSDXY( __NR___realpathat, sys___realpathat), // 574
#endif
// unimpl __NR_close_range 575
#endif
#if (FREEBSD_VERS >= FREEBSD_13_0)
// unimpl __NR_rpctls_syscall 576
BSDX_(__NR___specialfd, sys___specialfd), // 577
// unimpl __NR_aio_writev 578
// unimpl __NR_aio_readv 579
#endif
#if (FREEBSD_VERS >= FREEBSD_13_1)
// unimpl __NR_fspacectl 580
// unimpl __NR_sched_getcpu 581
BSDX_(__NR_swapoff, sys_swapoff), // 582
#endif
BSDX_(__NR_fake_sigreturn, sys_fake_sigreturn), // 1000, fake sigreturn
};
const SyscallTableEntry* ML_(get_freebsd_syscall_entry) ( UInt sysno )
{
const UInt syscall_table_size
= sizeof(ML_(syscall_table)) / sizeof(ML_(syscall_table)[0]);
/* Is it in the contiguous initial section of the table? */
if (sysno < syscall_table_size) {
const SyscallTableEntry* sys = &ML_(syscall_table)[sysno];
if (sys->before == NULL)
return NULL; /* no entry */
else
return sys;
}
/* Can't find a wrapper */
return NULL;
}
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/
#endif // defined(VGO_freebsd)
Reference in New Issue View Git Blame Copy Permalink