1 /*--------------------------------------------------------------------*/
2 /*--- FreeBSD-specific syscalls, etc. syswrap-freebsd.c ---*/
3 /*--------------------------------------------------------------------*/
6 This file is part of Valgrind, a dynamic binary instrumentation
9 Copyright (C) 2000-2008 Nicholas Nethercote
11 Copyright (C) 2018-2021 Paul Floyd
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, see <http://www.gnu.org/licenses/>.
27 The GNU General Public License is contained in the file COPYING.
30 #if defined(VGO_freebsd)
32 #include "pub_core_basics.h"
33 #include "pub_core_vki.h"
34 #include "pub_core_vkiscnums.h"
35 #include "pub_core_threadstate.h"
36 #include "pub_core_aspacemgr.h"
37 #include "pub_core_debuginfo.h" // VG_(di_notify_*)
38 #include "pub_core_transtab.h" // VG_(discard_translations)
39 #include "pub_core_xarray.h"
40 #include "pub_core_clientstate.h"
41 #include "pub_core_debuglog.h"
42 #include "pub_core_libcbase.h"
43 #include "pub_core_libcassert.h"
44 #include "pub_core_libcfile.h"
45 #include "pub_core_libcprint.h"
46 #include "pub_core_libcproc.h"
47 #include "pub_core_libcsignal.h"
48 #include "pub_core_machine.h"
49 #include "pub_core_mallocfree.h"
50 #include "pub_core_tooliface.h"
51 #include "pub_core_options.h"
52 #include "pub_core_scheduler.h"
53 #include "pub_core_signals.h"
54 #include "pub_core_stacks.h"
55 #include "pub_core_syscall.h"
56 #include "pub_core_syswrap.h"
57 #include "pub_core_inner.h"
58 #include "pub_core_pathscan.h"
59 #if defined(ENABLE_INNER_CLIENT_REQUEST)
60 #include "pub_core_clreq.h"
63 #include "priv_types_n_macros.h"
64 #include "priv_syswrap-generic.h"
65 #include "priv_syswrap-main.h"
66 #include "priv_syswrap-freebsd.h"
68 static Bool capabiltyMode
= False
;
70 Bool
VG_(get_capability_mode
)(void)
76 // Run a thread from beginning to end and return the thread's
77 // scheduler-return-code.
78 static VgSchedReturnCode
thread_wrapper(Word
/*ThreadId*/ tidW
)
80 VgSchedReturnCode ret
;
81 ThreadId tid
= (ThreadId
)tidW
;
82 Int lwpid
= VG_(gettid
)();
83 ThreadState
* tst
= VG_(get_ThreadState
)(tid
);
85 VG_(debugLog
)(1, "syswrap-freebsd",
86 "thread_wrapper(tid=%u,lwpid=%d): entry\n",
89 vg_assert(tst
->status
== VgTs_Init
);
91 /* make sure we get the CPU lock before doing anything significant */
92 VG_(acquire_BigLock
)(tid
, "thread_wrapper(starting new thread)");
95 VG_(printf
)("thread tid %u started: stack = %p\n",
99 /* Make sure error reporting is enabled in the new thread. */
100 tst
->err_disablement_level
= 0;
102 VG_TRACK(pre_thread_first_insn
, tid
);
104 tst
->os_state
.lwpid
= lwpid
;
105 /* Set the threadgroup for real. This overwrites the provisional value set
106 in do_clone(). See comments in do_clone for background, also #226116. */
107 tst
->os_state
.threadgroup
= VG_(getpid
)();
109 /* Thread created with all signals blocked; scheduler will set the
112 ret
= VG_(scheduler
)(tid
);
114 vg_assert(VG_(is_exiting
)(tid
));
116 vg_assert(tst
->status
== VgTs_Runnable
);
117 vg_assert(VG_(is_running_thread
)(tid
));
119 VG_(debugLog
)(1, "syswrap-freebsd",
120 "thread_wrapper(tid=%u,lwpid=%d): exit, schedreturncode %s\n",
121 tid
, lwpid
, VG_(name_of_VgSchedReturnCode
)(ret
));
123 /* Return to caller, still holding the lock. */
128 /* ---------------------------------------------------------------------
130 ------------------------------------------------------------------ */
132 /* Run a thread all the way to the end, then do appropriate exit actions
133 (this is the last-one-out-turn-off-the-lights bit). */
134 __attribute__((noreturn
))
135 static void run_a_thread_NORETURN ( Word tidW
)
137 ThreadId tid
= (ThreadId
)tidW
;
138 VgSchedReturnCode src
;
141 #ifdef ENABLE_INNER_CLIENT_REQUEST
142 Int registered_vgstack_id
;
145 VG_(debugLog
)(1, "syswrap-freebsd",
146 "run_a_thread_NORETURN(tid=%u): pre-thread_wrapper\n",
149 tst
= VG_(get_ThreadState
)(tid
);
152 /* An thread has two stacks:
153 * the simulated stack (used by the synthetic cpu. Guest process
154 is using this stack).
155 * the valgrind stack (used by the real cpu. Valgrind code is running
157 When Valgrind runs as an inner, it must signals that its (real) stack
158 is the stack to use by the outer to e.g. do stacktraces.
161 (registered_vgstack_id
162 = VALGRIND_STACK_REGISTER (tst
->os_state
.valgrind_stack_base
,
163 tst
->os_state
.valgrind_stack_init_SP
));
165 /* Run the thread all the way through. */
166 src
= thread_wrapper(tid
);
168 VG_(debugLog
)(1, "syswrap-freebsd",
169 "run_a_thread_NORETURN(tid=%u): post-thread_wrapper\n",
172 c
= VG_(count_living_threads
)();
173 vg_assert(c
>= 1); /* stay sane */
175 /* Deregister thread's stack. */
176 if (tst
->os_state
.stk_id
!= NULL_STK_ID
) {
177 VG_(deregister_stack
)(tst
->os_state
.stk_id
);
180 // Tell the tool this thread is exiting
181 VG_TRACK( pre_thread_ll_exit
, tid
);
183 /* If the thread is exiting with errors disabled, complain loudly;
184 doing so is bad (does the user know this has happened?) Also,
185 in all cases, be paranoid and clear the flag anyway so that the
186 thread slot is safe in this respect if later reallocated. This
187 should be unnecessary since the flag should be cleared when the
188 slot is reallocated, in thread_wrapper(). */
189 if (tst
->err_disablement_level
> 0) {
191 "WARNING: exiting thread has error reporting disabled.\n"
192 "WARNING: possibly as a result of some mistake in the use\n"
193 "WARNING: of the VALGRIND_DISABLE_ERROR_REPORTING macros.\n"
196 1, "syswrap-freebsd",
197 "run_a_thread_NORETURN(tid=%u): "
198 "WARNING: exiting thread has err_disablement_level = %u\n",
199 tid
, tst
->err_disablement_level
202 tst
->err_disablement_level
= 0;
206 VG_(debugLog
)(1, "syswrap-freebsd",
207 "run_a_thread_NORETURN(tid=%u): "
208 "last one standing\n",
211 /* We are the last one standing. Keep hold of the lock and
212 carry on to show final tool results, then exit the entire system.
213 Use the continuation pointer set at startup in m_main. */
214 ( * VG_(address_of_m_main_shutdown_actions_NORETURN
) ) (tid
, src
);
217 VG_(debugLog
)(1, "syswrap-freebsd",
218 "run_a_thread_NORETURN(tid=%u): "
219 "not last one standing\n",
222 /* OK, thread is dead, but others still exist. Just exit. */
224 /* This releases the run lock */
225 VG_(exit_thread
)(tid
);
226 vg_assert(tst
->status
== VgTs_Zombie
);
227 vg_assert(sizeof(tst
->status
) == 4);
228 vg_assert(sizeof(tst
->os_state
.exitcode
) == sizeof(Word
));
230 INNER_REQUEST (VALGRIND_STACK_DEREGISTER (registered_vgstack_id
));
232 /* We have to use this sequence to terminate the thread to
233 prevent a subtle race. If VG_(exit_thread)() had left the
234 ThreadState as Empty, then it could have been reallocated,
235 reusing the stack while we're doing these last cleanups.
236 Instead, VG_(exit_thread) leaves it as Zombie to prevent
237 reallocation. We need to make sure we don't touch the stack
238 between marking it Empty and exiting. Hence the
240 #if defined(VGP_x86_freebsd) /* FreeBSD has args on the stack */
242 "movl %1, %0\n" /* set tst->status = VgTs_Empty */
243 "movl %2, %%eax\n" /* set %eax = __NR_thr_exit */
244 "movl %3, %%ebx\n" /* set %ebx = tst->os_state.exitcode */
245 "pushl %%ebx\n" /* arg on stack */
246 "pushl %%ebx\n" /* fake return address */
247 "int $0x80\n" /* thr_exit(tst->os_state.exitcode) */
248 "popl %%ebx\n" /* fake return address */
249 "popl %%ebx\n" /* arg off stack */
251 : "n" (VgTs_Empty
), "n" (__NR_thr_exit
), "m" (tst
->os_state
.exitcode
)
254 #elif defined(VGP_amd64_freebsd)
256 "movl %1, %0\n" /* set tst->status = VgTs_Empty */
257 "movq %2, %%rax\n" /* set %rax = __NR_thr_exit */
258 "movq %3, %%rdi\n" /* set %rdi = tst->os_state.exitcode */
259 "pushq %%rdi\n" /* fake return address */
260 "syscall\n" /* thr_exit(tst->os_state.exitcode) */
261 "popq %%rdi\n" /* fake return address */
263 : "n" (VgTs_Empty
), "n" (__NR_thr_exit
), "m" (tst
->os_state
.exitcode
)
267 # error Unknown platform
270 VG_(core_panic
)("Thread exit failed?\n");
277 Word
ML_(start_thread_NORETURN
) ( void* arg
)
279 ThreadState
* tst
= (ThreadState
*)arg
;
280 ThreadId tid
= tst
->tid
;
282 run_a_thread_NORETURN ( (Word
)tid
);
287 /* Allocate a stack for this thread, if it doesn't already have one.
288 They're allocated lazily, and never freed. Returns the initial stack
289 pointer value to use, or 0 if allocation failed. */
290 Addr
ML_(allocstack
)(ThreadId tid
)
292 ThreadState
* tst
= VG_(get_ThreadState
)(tid
);
296 /* Either the stack_base and stack_init_SP are both zero (in which
297 case a stack hasn't been allocated) or they are both non-zero,
298 in which case it has. */
300 if (tst
->os_state
.valgrind_stack_base
== 0) {
301 vg_assert(tst
->os_state
.valgrind_stack_init_SP
== 0);
304 if (tst
->os_state
.valgrind_stack_base
!= 0) {
305 vg_assert(tst
->os_state
.valgrind_stack_init_SP
!= 0);
308 /* If no stack is present, allocate one. */
310 if (tst
->os_state
.valgrind_stack_base
== 0) {
311 stack
= VG_(am_alloc_VgStack
)( &initial_SP
);
313 tst
->os_state
.valgrind_stack_base
= (Addr
)stack
;
314 tst
->os_state
.valgrind_stack_init_SP
= initial_SP
;
319 VG_(printf
)( "stack for tid %u at %p; init_SP=%p\n",
321 (void*)tst
->os_state
.valgrind_stack_base
,
322 (void*)tst
->os_state
.valgrind_stack_init_SP
);
325 return tst
->os_state
.valgrind_stack_init_SP
;
328 /* Allocate a stack for the main thread, and run it all the way to the
329 end. Although we already have a working VgStack
330 (VG_(interim_stack)) it's better to allocate a new one, so that
331 overflow detection works uniformly for all threads.
333 __attribute__((noreturn
))
334 void VG_(main_thread_wrapper_NORETURN
)(ThreadId tid
)
337 VG_(debugLog
)(1, "syswrap-freebsd",
338 "entering VG_(main_thread_wrapper_NORETURN)\n");
340 sp
= ML_(allocstack
)(tid
);
341 #if defined(ENABLE_INNER_CLIENT_REQUEST)
343 // we must register the main thread stack before the call
344 // to ML_(call_on_new_stack_0_1), otherwise the outer valgrind
345 // reports 'write error' on the non registered stack.
346 ThreadState
* tst
= VG_(get_ThreadState
)(tid
);
349 VALGRIND_STACK_REGISTER (tst
->os_state
.valgrind_stack_base
,
350 tst
->os_state
.valgrind_stack_init_SP
));
354 /* If we can't even allocate the first thread's stack, we're hosed.
356 vg_assert2(sp
!= 0, "%s", "Cannot allocate main thread's stack.");
358 /* shouldn't be any other threads around yet */
359 vg_assert( VG_(count_living_threads
)() == 1 );
361 ML_(call_on_new_stack_0_1
)(
362 (Addr
)sp
, /* stack */
363 0, /* bogus return address */
364 run_a_thread_NORETURN
, /* fn to call */
365 (Word
)tid
/* arg to give it */
374 SysRes
ML_(do_fork
) ( ThreadId tid
)
376 vki_sigset_t fork_saved_mask
;
380 /* Block all signals during fork, so that we can fix things up in
381 the child without being interrupted. */
382 VG_(sigfillset
)(&mask
);
383 VG_(sigprocmask
)(VKI_SIG_SETMASK
, &mask
, &fork_saved_mask
);
385 VG_(do_atfork_pre
)(tid
);
387 res
= VG_(do_syscall0
)( __NR_fork
);
389 if (!sr_isError(res
)) {
390 if (sr_Res(res
) == 0) {
392 VG_(do_atfork_child
)(tid
);
394 /* restore signal mask */
395 VG_(sigprocmask
)(VKI_SIG_SETMASK
, &fork_saved_mask
, NULL
);
399 VG_(do_atfork_parent
)(tid
);
401 if (VG_(clo_trace_syscalls
)) {
402 VG_(printf
)(" clone(fork): process %d created child %lu\n",
403 VG_(getpid
)(), sr_Res(res
));
406 /* restore signal mask */
407 VG_(sigprocmask
)(VKI_SIG_SETMASK
, &fork_saved_mask
, NULL
);
414 static Addr
ML_(make_safe_mask
) ( const HChar
* malloc_message
, Addr mask_pointer
)
416 vki_sigset_t
* new_mask
;
417 const vki_sigset_t
* old_mask
= (vki_sigset_t
*)mask_pointer
;
419 if (!ML_(safe_to_deref
)(old_mask
, sizeof(vki_sigset_t
))) {
420 new_mask
= (vki_sigset_t
*)1; /* Something recognisable to POST() hook. */
422 new_mask
= VG_(malloc
)(malloc_message
, sizeof(vki_sigset_t
));
423 *new_mask
= *old_mask
;
424 VG_(sanitize_client_sigmask
)(new_mask
);
427 return (Addr
)new_mask
;
430 static void ML_(free_safe_mask
) ( Addr mask_pointer
)
432 if (mask_pointer
!= 0 && mask_pointer
!= 1) {
433 VG_(free
)((vki_sigset_t
*) mask_pointer
);
438 /* ---------------------------------------------------------------------
439 PRE/POST wrappers for arch-generic, FreeBSD-specific syscalls
440 ------------------------------------------------------------------ */
442 // Nb: See the comment above the generic PRE/POST wrappers in
443 // m_syswrap/syswrap-generic.c for notes about how they work.
445 #define PRE(name) DEFN_PRE_TEMPLATE(freebsd, name)
446 #define POST(name) DEFN_POST_TEMPLATE(freebsd, name)
448 /* On FreeBSD, if any thread calls exit(2), then they are all shut down, pretty
449 * much like linux's exit_group().
452 // void exit(int status);
457 PRINT("exit( %" FMT_REGWORD
"u )", ARG1
);
458 PRE_REG_READ1(void, "exit", int, status
);
460 /* Mark all threads (including this one) to exit. */
461 for (t
= 1; t
< VG_N_THREADS
; t
++) {
462 if ( /* not alive */ VG_(threads
)[t
].status
== VgTs_Empty
) {
466 //VG_(threads)[t].exitreason = VgSrc_ExitThread;
467 VG_(threads
)[t
].os_state
.exitcode
= ARG1
;
470 // VG_(get_thread_out_of_syscall)(t); /* unblock it, if blocked */
473 VG_(nuke_all_threads_except
)( tid
, VgSrc_ExitProcess
);
474 VG_(reap_threads
)(tid
);
475 VG_(threads
)[tid
].exitreason
= VgSrc_ExitThread
;
477 /* We have to claim the syscall already succeeded. */
478 SET_STATUS_Success(0);
485 PRINT("%s", "sys_fork ()");
486 PRE_REG_READ0(pid_t
, "fork");
488 SET_STATUS_from_SysRes( ML_(do_fork
)(tid
) );
490 /* Thread creation was successful; let the child have the chance
492 *flags
|= SfYieldAfter
;
522 // SYS_freebsd11_mknod 14
538 // int mount(const char *type, const char *dir, int flags, void *data);
541 // Nb: depending on 'flags', the 'type' and 'data' args may be ignored.
542 // We are conservative and check everything, except the memory pointed to
544 *flags
|= SfMayBlock
;
545 PRINT( "sys_mount( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
546 PRE_REG_READ4(int, "mount",
547 const char *, type
, char *, dir
, int, flags
,
549 PRE_MEM_RASCIIZ( "mount(type)", ARG1
);
550 PRE_MEM_RASCIIZ( "mount(path)", ARG2
);
554 // int unmount(const char *dir, int flags);
557 PRINT("sys_umount( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, ARG2
);
558 PRE_REG_READ2(int, "unmount", const char *, dir
, int, flags
);
559 PRE_MEM_RASCIIZ( "unmount(path)", ARG1
);
572 // int ptrace(int request, pid_t pid, caddr_t addr, int data);
575 struct vki_ptrace_io_desc
*io_desc
;
576 PRINT("sys_ptrace ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, 0x%" FMT_REGWORD
"x, %" FMT_REGWORD
"u)", ARG1
, ARG2
, ARG3
, ARG4
);
578 PRE_REG_READ4(int, "ptrace", int, request
, pid_t
, pid
, caddr_t
, addr
, int, data
);
581 case VKI_PTRACE_TRACEME
:
582 case VKI_PTRACE_READ_I
:
583 case VKI_PTRACE_READ_D
:
584 case VKI_PTRACE_WRITE_I
:
585 case VKI_PTRACE_WRITE_D
:
589 PRE_MEM_READ("ptrace", ARG3
, sizeof(struct vki_ptrace_io_desc
));
590 io_desc
= (struct vki_ptrace_io_desc
*)ARG3
;
591 switch (io_desc
->piod_op
) {
592 case VKI_PIOD_READ_D
:
593 case VKI_PIOD_READ_I
:
594 PRE_MEM_WRITE( "ptrace", (UWord
)io_desc
->piod_addr
, io_desc
->piod_len
);
596 case VKI_PIOD_WRITE_D
:
597 case VKI_PIOD_WRITE_I
:
598 PRE_MEM_READ( "ptrace", (UWord
)io_desc
->piod_addr
, io_desc
->piod_len
);
603 case VKI_PTRACE_CONTINUE
:
604 case VKI_PTRACE_STEP
:
605 case VKI_PTRACE_KILL
:
606 case VKI_PTRACE_ATTACH
:
607 case VKI_PTRACE_DETACH
:
610 case VKI_PTRACE_GETREGS
:
611 PRE_MEM_WRITE("ptrace", ARG3
, sizeof(struct vki_user_regs_struct
));
614 case VKI_PTRACE_SETREGS
:
615 PRE_MEM_READ("ptrace", ARG3
, sizeof(struct vki_user_regs_struct
));
618 case VKI_PTRACE_GETFPREGS
:
619 PRE_MEM_WRITE("ptrace", ARG3
, sizeof(struct vki_fpreg
));
622 case VKI_PTRACE_SETFPREGS
:
623 PRE_MEM_READ("ptrace", ARG3
, sizeof(struct vki_fpreg
));
626 case VKI_PTRACE_GETDBREGS
:
627 PRE_MEM_WRITE("ptrace", ARG3
, sizeof(struct vki_dbreg
));
630 case VKI_PTRACE_SETDBREGS
:
631 PRE_MEM_READ("ptrace", ARG3
, sizeof(struct vki_dbreg
));
634 case VKI_PTRACE_LWPINFO
:
635 PRE_MEM_WRITE("ptrace", ARG3
, sizeof(struct vki_ptrace_lwpinfo
));
638 case VKI_PTRACE_GETNUMLWPS
:
641 case VKI_PTRACE_GETLWPLIST
:
642 PRE_MEM_WRITE( "ptrace", ARG3
, sizeof(vki_lwpid_t
) * ARG4
);
645 case VKI_PTRACE_SETSTEP
:
646 case VKI_PTRACE_CLEARSTEP
:
647 case VKI_PTRACE_SUSPEND
:
648 case VKI_PTRACE_RESUME
:
649 case VKI_PTRACE_TO_SCE
:
650 case VKI_PTRACE_TO_SCX
:
651 case VKI_PTRACE_SYSCALL
:
652 case VKI_PTRACE_VM_TIMESTAMP
:
654 case VKI_PTRACE_VM_ENTRY
:
655 PRE_MEM_WRITE( "ptrace", ARG3
, sizeof(struct vki_ptrace_vm_entry
));
662 struct vki_ptrace_io_desc
*io_desc
;
665 case VKI_PTRACE_TRACEME
:
666 case VKI_PTRACE_READ_I
:
667 case VKI_PTRACE_READ_D
:
668 case VKI_PTRACE_WRITE_I
:
669 case VKI_PTRACE_WRITE_D
:
673 io_desc
= (struct vki_ptrace_io_desc
*)ARG3
;
674 switch (io_desc
->piod_op
) {
675 case VKI_PIOD_READ_D
:
676 case VKI_PIOD_READ_I
:
677 if ((Word
)RES
!= -1) {
678 POST_MEM_WRITE((UWord
)io_desc
->piod_addr
, io_desc
->piod_len
);
681 case VKI_PIOD_WRITE_D
:
682 case VKI_PIOD_WRITE_I
:
687 case VKI_PTRACE_CONTINUE
:
688 case VKI_PTRACE_STEP
:
689 case VKI_PTRACE_KILL
:
690 case VKI_PTRACE_ATTACH
:
691 case VKI_PTRACE_DETACH
:
694 case VKI_PTRACE_GETREGS
:
695 if ((Word
)RES
!= -1) {
696 POST_MEM_WRITE(ARG3
, sizeof(struct vki_user_regs_struct
));
700 case VKI_PTRACE_SETREGS
:
703 case VKI_PTRACE_GETFPREGS
:
704 if ((Word
)RES
!= -1) {
705 POST_MEM_WRITE(ARG3
, sizeof(struct vki_fpreg
));
709 case VKI_PTRACE_SETFPREGS
:
712 case VKI_PTRACE_GETDBREGS
:
713 if ((Word
)RES
!= -1) {
714 POST_MEM_WRITE(ARG3
, sizeof(struct vki_dbreg
));
718 case VKI_PTRACE_SETDBREGS
:
721 case VKI_PTRACE_LWPINFO
:
722 if ((Word
)RES
!= -1) {
723 POST_MEM_WRITE(ARG3
, sizeof(struct vki_ptrace_lwpinfo
));
727 case VKI_PTRACE_GETNUMLWPS
:
730 case VKI_PTRACE_GETLWPLIST
:
731 if ((Word
)RES
!= -1) {
732 POST_MEM_WRITE(ARG3
, sizeof(vki_lwpid_t
) * RES
);
736 case VKI_PTRACE_SETSTEP
:
737 case VKI_PTRACE_CLEARSTEP
:
738 case VKI_PTRACE_SUSPEND
:
739 case VKI_PTRACE_RESUME
:
740 case VKI_PTRACE_TO_SCE
:
741 case VKI_PTRACE_TO_SCX
:
742 case VKI_PTRACE_SYSCALL
:
743 case VKI_PTRACE_VM_TIMESTAMP
:
746 case VKI_PTRACE_VM_ENTRY
:
747 if ((Word
)RES
!= -1) {
748 POST_MEM_WRITE(ARG3
, sizeof(struct vki_ptrace_vm_entry
));
755 // ssize_t recvmsg(int s, struct msghdr *msg, int flags);
758 *flags
|= SfMayBlock
;
759 PRINT("sys_recvmsg ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d )",SARG1
,ARG2
,SARG3
);
760 PRE_REG_READ3(vki_ssize_t
, "recvmsg", int, s
, struct msghdr
*, msg
, int, flags
);
761 ML_(generic_PRE_sys_recvmsg
)(tid
, "recvmsg", (struct vki_msghdr
*)ARG2
);
767 ML_(generic_POST_sys_recvmsg
)(tid
, "recvmsg", (struct vki_msghdr
*)ARG2
, RES
);
771 // ssize_t sendmsg(int s, const struct msghdr *msg, int flags);
774 *flags
|= SfMayBlock
;
775 PRINT("sys_sendmsg ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
776 PRE_REG_READ3(ssize_t
, "sendmsg",
777 int, s
, const struct msghdr
*, msg
, int, flags
);
778 ML_(generic_PRE_sys_sendmsg
)(tid
, "sendmsg", (struct vki_msghdr
*)ARG2
);
782 // ssize_t recvfrom(int s, void *buf, size_t len, int flags,
783 // struct sockaddr * restrict from, socklen_t * restrict fromlen);
786 *flags
|= SfMayBlock
;
787 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
);
788 PRE_REG_READ6(ssize_t
, "recvfrom",
789 int, s
, void *, buf
, size_t, len
, int, flags
,
790 struct sockaddr
*, from
, int *, fromlen
);
791 ML_(generic_PRE_sys_recvfrom
)(tid
, ARG1
,ARG2
,ARG3
,ARG4
,ARG5
,ARG6
);
797 ML_(generic_POST_sys_recvfrom
)(tid
, VG_(mk_SysRes_Success
)(RES
),
798 ARG1
,ARG2
,ARG3
,ARG4
,ARG5
,ARG6
);
802 // int accept(int s, struct sockaddr * restrict addr,
803 // socklen_t * restrict addrlen);
806 *flags
|= SfMayBlock
;
807 PRINT("sys_accept ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
808 PRE_REG_READ3(int, "accept",
809 int, s
, struct sockaddr
*, addr
, int, *addrlen
);
810 ML_(generic_PRE_sys_accept
)(tid
, ARG1
,ARG2
,ARG3
);
817 r
= ML_(generic_POST_sys_accept
)(tid
, VG_(mk_SysRes_Success
)(RES
),
819 SET_STATUS_from_SysRes(r
);
822 // SYS_getpeername 31
823 // int getpeername(int s, struct sockaddr * restrict name,
824 // socklen_t * restrict namelen);
827 PRINT("sys_getpeername ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
);
828 PRE_REG_READ3(int, "getpeername",
829 int, s
, struct sockaddr
*, name
, socklen_t
*, namelen
);
830 ML_(generic_PRE_sys_getpeername
)(tid
, ARG1
,ARG2
,ARG3
);
833 POST(sys_getpeername
)
836 ML_(generic_POST_sys_getpeername
)(tid
, VG_(mk_SysRes_Success
)(RES
),
840 // SYS_getsockname 32
841 // int getsockname(int s, struct sockaddr * restrict name,
842 // socklen_t * restrict namelen);
845 PRINT("sys_getsockname ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",SARG1
,ARG2
,ARG3
);
846 PRE_REG_READ3(long, "getsockname",
847 int, s
, struct sockaddr
*, name
, int *, namelen
);
848 ML_(generic_PRE_sys_getsockname
)(tid
, ARG1
,ARG2
,ARG3
);
851 POST(sys_getsockname
)
854 ML_(generic_POST_sys_getsockname
)(tid
, VG_(mk_SysRes_Success
)(RES
),
862 // int chflags(const char *path, unsigned long flags)
865 PRINT("sys_chflags ( %#" FMT_REGWORD
"x(%s), 0x%" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
);
866 PRE_REG_READ2(int, "chflags",
867 const char *, path
, unsigned long, flags
);
868 PRE_MEM_RASCIIZ( "chflags(path)", ARG1
);
872 // int fchflags(int fd, unsigned long flags);
875 PRINT("sys_fchflags ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
,ARG2
);
876 PRE_REG_READ2(int, "fchflags", int, fd
, unsigned long, flags
);
891 // Pipe on freebsd doesn't have args, and uses dual returns!
892 // SYS_freebsd10_pipe 42
896 PRINT("%s", "sys_pipe ()");
901 if (!ML_(fd_allowed
)(RES
, "pipe", tid
, True
) ||
902 !ML_(fd_allowed
)(RESHI
, "pipe", tid
, True
)) {
905 SET_STATUS_Failure( VKI_EMFILE
);
907 if (VG_(clo_track_fds
)) {
908 ML_(record_fd_open_nameless
)(tid
, RES
);
909 ML_(record_fd_open_nameless
)(tid
, RESHI
);
927 // syscall.master refers to namelen and namebuf for the argument names
928 // man getlogin has just getlogin(void) but also
929 // int getlogin_r(char *name, int len);
930 // so let's go with those names
933 PRINT("sys_getlogin ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
);
934 PRE_REG_READ2(int, "getlogin", char *, buf
, u_int
, len
);
935 PRE_MEM_WRITE( "getlogin(name)", ARG1
, ARG2
);
940 POST_MEM_WRITE(ARG1
, ARG2
);
944 // int setlogin(const char *name);
947 PRINT("sys_setlogin ( %#" FMT_REGWORD
"x )",ARG1
);
948 PRE_REG_READ1(long, "setlogin", char *, buf
);
949 PRE_MEM_RASCIIZ( "setlogin(buf)", ARG1
);
955 // SYS_sigaltstack 53
959 // int ioctl(int fd, unsigned long request, ...);
962 UInt dir
= _VKI_IOC_DIR(ARG2
);
963 UInt size
= _VKI_IOC_SIZE(ARG2
);
964 *flags
|= SfMayBlock
;
965 // @todo PJF presumably the presence of ARG3 depends on ARG2
966 PRINT("sys_ioctl ( %" FMT_REGWORD
"u, 0x%" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
);
967 PRE_REG_READ3(int, "ioctl",
968 int, fd
, unsigned long, request
, unsigned long, arg
);
970 /* On FreeBSD, ALL ioctl's are IOR/IOW encoded. Just use the default decoder */
971 if (SimHintiS(SimHint_lax_ioctls
, VG_(clo_sim_hints
))) {
973 * Be very lax about ioctl handling; the only
974 * assumption is that the size is correct. Doesn't
975 * require the full buffer to be initialized when
976 * writing. Without this, using some device
977 * drivers with a large number of strange ioctl
978 * commands becomes very tiresome.
980 } else if (dir
== _VKI_IOC_NONE
&& size
> 0) {
981 static UWord unknown_ioctl
[10];
982 static Int moans
= sizeof(unknown_ioctl
) / sizeof(unknown_ioctl
[0]);
983 if (moans
> 0 && !VG_(clo_xml
)) {
984 /* Check if have not already moaned for this request. */
986 for (i
= 0; i
< sizeof(unknown_ioctl
)/sizeof(unknown_ioctl
[0]); i
++) {
987 if (unknown_ioctl
[i
] == ARG2
) {
990 if (unknown_ioctl
[i
] == 0) {
991 unknown_ioctl
[i
] = ARG2
;
993 VG_(umsg
)("Warning: noted but unhandled ioctl 0x%lx"
994 " with no direction hints.\n", ARG2
);
995 VG_(umsg
)(" This could cause spurious value errors to appear.\n");
996 VG_(umsg
)(" See README_MISSING_SYSCALL_OR_IOCTL for "
997 "guidance on writing a proper wrapper.\n" );
1003 if ((dir
& _VKI_IOC_WRITE
) && size
> 0) {
1004 PRE_MEM_READ( "ioctl(generic)", ARG3
, size
);
1006 if ((dir
& _VKI_IOC_READ
) && size
> 0) {
1007 PRE_MEM_WRITE( "ioctl(generic)", ARG3
, size
);
1011 // The block below is from Ryan Stone
1012 // https://bitbucket.org/rysto32/valgrind-freebsd/commits/5323c22be9f6c71a00e842c3ddfa1fa8a7feb279
1013 // however it drags in hundreds of lines of headers into vki-freebsd.h.
1014 // How stable are these structures? -> maintainability is a concern
1015 // Also there are no testcases for this.
1018 /* Handle specific ioctls which pass structures which may have pointers to other
1020 switch (ARG2
/* request */) {
1021 case VKI_SIOCGIFMEDIA
:
1023 struct vki_ifmediareq
* imr
= (struct vki_ifmediareq
*)ARG3
;
1024 if (imr
->ifm_ulist
) {
1025 PRE_MEM_WRITE("ioctl(SIOCGIFMEDIA).ifm_ulist",
1026 (Addr
)(imr
->ifm_ulist
), imr
->ifm_count
* sizeof(int));
1031 case VKI_PCIOCGETCONF
:
1033 struct vki_pci_conf_io
* pci
= (struct vki_pci_conf_io
*)ARG3
;
1034 PRE_MEM_READ("ioctl(PCIOCGETCONF).patterns",
1035 (Addr
)(pci
->patterns
), pci
->pat_buf_len
);
1036 PRE_MEM_WRITE("ioctl(PCIOCGETCONF).matches",
1037 (Addr
)(pci
->matches
), pci
->match_buf_len
);
1041 case VKI_CAMIOCOMMAND
:
1043 union vki_ccb
* ccb
= (union vki_ccb
*)ARG3
;
1044 if (ccb
->ccb_h
.func_code
== VKI_XPT_DEV_MATCH
) {
1045 PRE_MEM_WRITE("ioctl(CAMIOCOMMAND:XPT_DEV_MATCH).matches",
1046 (Addr
)(ccb
->cdm
.matches
), ccb
->cdm
.match_buf_len
);
1047 } else if (ccb
->ccb_h
.func_code
== VKI_XPT_SCSI_IO
) {
1048 struct vki_ccb_scsiio
* scsiio
= (struct vki_ccb_scsiio
*)ccb
;
1049 if (scsiio
->dxfer_len
) {
1050 if ((scsiio
->ccb_h
.flags
& VKI_CAM_DIR_MASK
) == VKI_CAM_DIR_IN
) {
1051 PRE_MEM_WRITE("ioctl(CAMIOCOMMAND:XPT_SCSI_IO).data_ptr",
1052 (Addr
)(scsiio
->data_ptr
), scsiio
->dxfer_len
);
1053 } else if ((scsiio
->ccb_h
.flags
& VKI_CAM_DIR_MASK
) == VKI_CAM_DIR_OUT
) {
1054 PRE_MEM_READ("ioctl(CAMIOCOMMAND:XPT_SCSI_IO).data_ptr",
1055 (Addr
)(scsiio
->data_ptr
), scsiio
->dxfer_len
);
1058 } else if (ccb
->ccb_h
.func_code
== VKI_XPT_GDEV_TYPE
||
1059 ccb
->ccb_h
.func_code
== VKI_XPT_PATH_INQ
||
1060 ccb
->ccb_h
.func_code
== VKI_XPT_GET_TRAN_SETTINGS
) {
1063 VG_(message
)(Vg_UserMsg
,
1064 "Warning: unhandled ioctl CAMIOCOMMAND function 0x%lx\n",
1065 ccb
->ccb_h
.func_code
);
1075 UInt dir
= _VKI_IOC_DIR(ARG2
);
1076 UInt size
= _VKI_IOC_SIZE(ARG2
);
1078 if (size
> 0 && (dir
& _VKI_IOC_READ
)
1079 && RES
== 0 && ARG3
!= (Addr
)NULL
) {
1080 POST_MEM_WRITE(ARG3
, size
);
1084 /* Handle specific ioctls which pass structures which may have pointers to other
1086 switch (ARG2
/* request */) {
1087 case VKI_SIOCGIFMEDIA
:
1089 struct vki_ifmediareq
* imr
= (struct vki_ifmediareq
*)ARG3
;
1090 if (imr
->ifm_ulist
) {
1091 POST_MEM_WRITE((Addr
)(imr
->ifm_ulist
), imr
->ifm_count
* sizeof(int));
1096 case VKI_PCIOCGETCONF
:
1098 struct vki_pci_conf_io
* pci
= (struct vki_pci_conf_io
*)ARG3
;
1099 POST_MEM_WRITE((Addr
)(pci
->matches
), pci
->num_matches
* sizeof(struct vki_pci_conf
));
1103 case VKI_CAMIOCOMMAND
:
1105 union vki_ccb
* ccb
= (union vki_ccb
*)ARG3
;
1106 if (ccb
->ccb_h
.func_code
== VKI_XPT_DEV_MATCH
) {
1107 POST_MEM_WRITE((Addr
)(ccb
->cdm
.matches
), ccb
->cdm
.num_matches
*sizeof(struct vki_dev_match_result
));
1108 } else if (ccb
->ccb_h
.func_code
== VKI_XPT_SCSI_IO
) {
1109 struct vki_ccb_scsiio
* scsiio
= (struct vki_ccb_scsiio
*)ccb
;
1110 if (scsiio
->dxfer_len
) {
1111 if ((scsiio
->ccb_h
.flags
& VKI_CAM_DIR_MASK
) == VKI_CAM_DIR_IN
) {
1112 POST_MEM_WRITE((Addr
)(scsiio
->data_ptr
), scsiio
->dxfer_len
);
1123 // int reboot(int howto);
1126 PRINT("sys_reboot ( %" FMT_REGWORD
"d )", SARG1
);
1127 PRE_REG_READ1(int, "reboot", int, howto
);
1131 // int revoke(const char *path);
1134 PRINT("sys_revoke ( %#" FMT_REGWORD
"x(%s) )", ARG1
, (char*)ARG1
);
1135 PRE_REG_READ1(long, "revoke", const char *, path
);
1136 PRE_MEM_RASCIIZ( "revoke(path)", ARG1
);
1142 static void do_readlink(const HChar
* path
, HChar
*buf
, SizeT bufsize
, SyscallStatus
* status
, Bool
* curproc_file
)
1145 VG_(sprintf
)(name
, "/proc/%d/file", VG_(getpid
)());
1146 if (ML_(safe_to_deref
)(path
, 1)
1147 && (VG_(strcmp
)(path
, name
) == 0
1148 || VG_(strcmp
)(path
, "/proc/curproc/file") == 0)) {
1149 vg_assert(VG_(resolved_exename
));
1150 Int len
= VG_(snprintf
)(buf
, bufsize
, "%s", VG_(resolved_exename
));
1151 SET_STATUS_Success(len
);
1152 *curproc_file
= True
;
1157 // ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsiz);
1160 FUSE_COMPATIBLE_MAY_BLOCK();
1162 Bool curproc_file
= False
;
1164 PRINT("sys_readlink ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x, %llu )",
1165 ARG1
, (char*)(Addr
)ARG1
, ARG2
, (ULong
)ARG3
);
1166 PRE_REG_READ3(long, "readlink",
1167 const char *, path
, char *, buf
, int, bufsiz
);
1168 PRE_MEM_RASCIIZ( "readlink(path)", ARG1
);
1169 PRE_MEM_WRITE( "readlink(buf)", ARG2
,ARG3
);
1171 if (VG_(have_slash_proc
) == True
)
1174 * Handle the case where readlink is looking at /proc/curproc/file or
1177 do_readlink((const HChar
*)ARG1
, (HChar
*)ARG2
, (SizeT
)ARG3
, status
, &curproc_file
);
1180 if (!curproc_file
) {
1182 SET_STATUS_from_SysRes( VG_(do_syscall3
)(saved
, ARG1
, ARG2
, ARG3
));
1184 if (SUCCESS
&& RES
> 0) {
1185 POST_MEM_WRITE( ARG2
, RES
);
1202 // pid_t vfork(void);
1205 PRINT("%s", "sys_vfork ()");
1206 PRE_REG_READ0(pid_t
, "vfork");
1208 /* Pretend vfork == fork. Not true, but will have to do. */
1209 SET_STATUS_from_SysRes( ML_(do_fork
)(tid
) );
1211 /* Thread creation was successful; let the child have the chance
1213 *flags
|= SfYieldAfter
;
1218 // void * sbrk(intptr_t incr);
1221 PRINT("sys_sbrk ( %#" FMT_REGWORD
"x )",ARG1
);
1222 PRE_REG_READ1(void*, "sbrk", vki_intptr_t
, incr
);
1225 // SYS_freebsd11_vadvise 72
1256 // int swapon(const char *special);
1259 PRINT("sys_swapon ( %#" FMT_REGWORD
"x(%s) )", ARG1
,(char*)ARG1
);
1260 PRE_REG_READ1(int, "swapon", const char*, special
);
1261 PRE_MEM_RASCIIZ( "swapon(special)", ARG1
);
1267 // SYS_getdtablesize 89
1268 // int getdtablesize(void);
1269 PRE(sys_getdtablesize
)
1271 PRINT("%s", "sys_getdtablesize ( )");
1272 PRE_REG_READ0(long, "getdtablesize");
1279 // int fcntl(int fd, int cmd, ...);
1283 // These ones ignore ARG3.
1287 case VKI_F_GET_SEALS
:
1288 case VKI_F_ISUNIONSTACK
:
1289 PRINT("sys_fcntl ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )", SARG1
,SARG2
);
1290 PRE_REG_READ2(int, "fcntl", int, fd
, int, cmd
);
1293 // These ones use ARG3 as "arg".
1295 case VKI_F_DUPFD_CLOEXEC
:
1299 case VKI_F_READAHEAD
:
1301 case VKI_F_ADD_SEALS
:
1302 PRINT("sys_fcntl[ARG3=='arg'] ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )", SARG1
,SARG2
,SARG3
);
1303 PRE_REG_READ3(int, "fcntl",
1304 int, fd
, int, cmd
, int, arg
);
1307 // These ones use ARG3 as "lock" - obsolete.
1309 *flags
|= SfMayBlock
;
1313 PRINT("sys_fcntl[ARG3=='lock'] ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
1314 PRE_REG_READ3(int, "fcntl",
1316 struct oflock
*, lock
);
1319 // This one uses ARG3 as "oldd" and ARG4 as "newd".
1321 case VKI_F_DUP2FD_CLOEXEC
:
1322 PRINT("sys_fcntl[ARG3=='oldd', ARG4=='newd'] ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",
1323 ARG1
,ARG2
,ARG3
,ARG4
);
1324 PRE_REG_READ4(int, "fcntl",
1326 unsigned long, oldd
, unsigned long, newd
);
1329 // These ones use ARG3 as "lock".
1331 *flags
|= SfMayBlock
;
1335 case VKI_F_SETLK_REMOTE
:
1336 PRINT("sys_fcntl[ARG3=='lock'] ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
1337 PRE_REG_READ3(int, "fcntl",
1339 struct flock
*, lock
);
1342 PRINT("sys_fcntl[ARG3=='kinfo_file'] ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
1343 PRE_REG_READ3(int, "fcntl",
1345 struct vki_kinfo_file
*, kinfo
);
1347 struct vki_kinfo_file
* p_kinfo_file
= (struct vki_kinfo_file
*)ARG3
;
1348 PRE_MEM_WRITE("fcntl(ARG3=='kinfo_file)", ARG3
, p_kinfo_file
->vki_kf_structsize
);
1353 PRINT("sys_fcntl[UNKNOWN] ( %lu, %lu, %lu )", ARG1
,ARG2
,ARG3
);
1361 if (ARG2
== VKI_F_DUPFD
) {
1362 if (!ML_(fd_allowed
)(RES
, "fcntl(DUPFD)", tid
, True
)) {
1364 SET_STATUS_Failure( VKI_EMFILE
);
1366 if (VG_(clo_track_fds
)) {
1367 ML_(record_fd_open_named
)(tid
, RES
);
1370 } else if (ARG2
== VKI_F_DUPFD_CLOEXEC
) {
1371 if (!ML_(fd_allowed
)(RES
, "fcntl(DUPFD_CLOEXEC)", tid
, True
)) {
1373 SET_STATUS_Failure( VKI_EMFILE
);
1375 if (VG_(clo_track_fds
)) {
1376 ML_(record_fd_open_named
)(tid
, RES
);
1388 // SYS_setpriority 9
1392 // int socket(int domain, int type, int protocol);
1395 PRINT("sys_socket ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )",SARG1
,SARG2
,SARG3
);
1396 PRE_REG_READ3(int, "socket", int, domain
, int, type
, int, protocol
);
1403 r
= ML_(generic_POST_sys_socket
)(tid
, VG_(mk_SysRes_Success
)(RES
));
1404 SET_STATUS_from_SysRes(r
);
1408 // int connect(int s, const struct sockaddr *name, socklen_t namelen);
1411 *flags
|= SfMayBlock
;
1412 PRINT("sys_connect ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
1413 PRE_REG_READ3(int, "connect",
1414 int, s
, const struct sockaddr
*, name
, int, namelen
);
1415 ML_(generic_PRE_sys_connect
)(tid
, ARG1
,ARG2
,ARG3
);
1418 // SYS_getpriority 100
1422 // int bind(int s, const struct sockaddr *addr, socklen_t addrlen);
1425 PRINT("sys_bind ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
1426 PRE_REG_READ3(int, "bind",
1427 int, s
, struct sockaddr
*, addr
, int, addrlen
);
1428 ML_(generic_PRE_sys_bind
)(tid
, ARG1
,ARG2
,ARG3
);
1431 // SYS_setsockopt 105
1432 // int setsockopt(int s, int level, int optname, const void *optval,
1433 // socklen_t optlen);
1436 PRINT("sys_setsockopt ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",SARG1
,SARG2
,SARG3
,ARG4
,ARG5
);
1437 PRE_REG_READ5(int, "setsockopt",
1438 int, s
, int, level
, int, optname
,
1439 const void *, optval
, vki_socklen_t
, optlen
);
1440 ML_(generic_PRE_sys_setsockopt
)(tid
, ARG1
,ARG2
,ARG3
,ARG4
,ARG5
);
1444 // int listen(int s, int backlog);
1447 PRINT("sys_listen ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )",SARG1
,SARG2
);
1448 PRE_REG_READ2(int, "listen", int, s
, int, backlog
);
1451 //SYS_gettimeofday 116
1454 // SYS_getrusage 117
1457 // SYS_getsockopt 118
1458 // int getsockopt(int s, int level, int optname, void * restrict optval,
1459 // socklen_t * restrict optlen);
1462 Addr optval_p
= ARG4
;
1463 Addr optlen_p
= ARG5
;
1464 PRINT("sys_getsockopt ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
,ARG5
);
1465 PRE_REG_READ5(int, "getsockopt",
1466 int, s
, int, level
, int, optname
,
1467 void *, optval
, int, *optlen
);
1468 if (optval_p
!= (Addr
)NULL
) {
1469 ML_(buf_and_len_pre_check
) ( tid
, optval_p
, optlen_p
,
1470 "getsockopt(optval)",
1471 "getsockopt(optlen)" );
1475 POST(sys_getsockopt
)
1477 Addr optval_p
= ARG4
;
1478 Addr optlen_p
= ARG5
;
1480 if (optval_p
!= (Addr
)NULL
) {
1481 ML_(buf_and_len_post_check
) ( tid
, VG_(mk_SysRes_Success
)(RES
),
1483 "getsockopt(optlen_out)" );
1493 // SYS_settimeofday 122
1515 // int mkfifo(const char *path, mode_t mode);
1518 PRINT("sys_mkfifo ( %#" FMT_REGWORD
"x(%s), 0x%" FMT_REGWORD
"x, 0x%" FMT_REGWORD
"x )", ARG1
, (char *)ARG1
, ARG2
, ARG3
);
1519 PRE_REG_READ2(int, "mkfifo", const char *, path
, int, mode
);
1520 PRE_MEM_RASCIIZ( "mkfifo(path)", ARG1
);
1524 // ssize_t sendto(int s, const void *msg, size_t len, int flags,
1525 // const struct sockaddr *to, socklen_t tolen);
1528 *flags
|= SfMayBlock
;
1529 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
);
1530 PRE_REG_READ6(ssize_t
, "sendto",
1531 int, s
, const void *, msg
, int, len
,
1533 const struct sockaddr
*, to
, socklen_t
, tolen
);
1534 ML_(generic_PRE_sys_sendto
)(tid
, ARG1
,ARG2
,ARG3
,ARG4
,ARG5
,ARG6
);
1538 // int shutdown(int s, int how);
1541 *flags
|= SfMayBlock
;
1542 PRINT("sys_shutdown ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
);
1543 PRE_REG_READ2(int, "shutdown", int, s
, int, how
);
1546 // SYS_socketpair 135
1547 // int socketpair(int domain, int type, int protocol, int *sv);
1550 PRINT("sys_socketpair ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
1551 PRE_REG_READ4(int, "socketpair",
1552 int, domain
, int, type
, int, protocol
, int *, sv
);
1553 ML_(generic_PRE_sys_socketpair
)(tid
, ARG1
,ARG2
,ARG3
,ARG4
);
1556 POST(sys_socketpair
)
1559 ML_(generic_POST_sys_socketpair
)(tid
, VG_(mk_SysRes_Success
)(RES
),
1560 ARG1
,ARG2
,ARG3
,ARG4
);
1573 // int adjtime(const struct timeval *delta, struct timeval *olddelta);
1576 PRINT("sys_adjtime ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
1577 PRE_REG_READ2(int, "adjtime",
1578 const struct vki_timeval
*, delta
, struct vki_timeval
*, olddelta
);
1579 PRE_MEM_READ("adjtime(delta)", ARG1
, sizeof(struct vki_timeval
));
1581 PRE_MEM_WRITE("adjtime(olddelta)", ARG1
, sizeof(struct vki_timeval
));
1588 POST_MEM_WRITE(ARG1
, sizeof(struct vki_timeval
));
1596 /* int quotactl(const char *path, int cmd, int id, void *addr); */
1599 PRINT("sys_quotactl ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
, ARG4
);
1602 case VKI_Q_SETQUOTA
:
1605 case VKI_Q_GETQUOTASIZE
:
1606 PRE_REG_READ4(int, "quotactl",
1607 const char *, path
, int, cmd
, int, id
,
1609 PRE_MEM_RASCIIZ( "quotactl(path)", ARG1
);
1611 case VKI_Q_GETQUOTA
:
1612 if (VG_(tdict
).track_pre_reg_read
) {
1615 PRA1("quotactl",const char*,path
);
1616 PRA2("quotactl",int,cmd
);
1617 PRA4("quotactl",void*,addr
);
1620 case VKI_Q_QUOTAOFF
:
1622 PRE_REG_READ2(int, "quotactl",
1623 const char *, path
, int, cmd
);
1630 // SYS_nlm_syscall 154
1631 // syscall.master says ; 154 is initialised by the NLM code, if present.
1635 // int nfssvc(int flags, void *argstructp);
1636 // lengthy manpage, at least 3 types of struct that argstructp can point to
1640 // int lgetfh(const char *path, fhandle_t *fhp);
1643 PRINT("sys_lgetfh ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"x ", ARG1
, ARG2
);
1644 PRE_REG_READ2(int, "lgetfh", const char*, path
, vki_fhandle_t
*, fhp
);
1645 PRE_MEM_RASCIIZ( "lgetfh(path)", ARG1
);
1646 PRE_MEM_WRITE("lgetfh(fhp)", ARG2
, sizeof(vki_fhandle_t
));
1651 POST_MEM_WRITE(ARG2
, sizeof(vki_fhandle_t
));
1655 // int getfh(const char *path, fhandle_t *fhp);
1658 PRINT("sys_getfh ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"x ", ARG1
, ARG2
);
1659 PRE_REG_READ2(int, "getfh", const char*, path
, vki_fhandle_t
*, fhp
);
1660 PRE_MEM_RASCIIZ( "getfh(path)", ARG1
);
1661 PRE_MEM_WRITE("getfh(fhp)", ARG2
, sizeof(vki_fhandle_t
));
1666 POST_MEM_WRITE(ARG2
, sizeof(vki_fhandle_t
));
1669 #if (FREEBSD_VERS <= FREEBSD_10)
1671 // int getdomainname(char *domainname, int len);
1672 PRE(sys_freebsd4_getdomainname
)
1674 PRINT("sys_freebsd4_getdomainname ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
);
1675 PRE_REG_READ2(int, "getdomainname",
1676 char *, domainname
, int, len
);
1677 PRE_MEM_WRITE( "getdomainname(domainname)", ARG1
, ARG2
);
1680 POST(sys_freebsd4_getdomainname
)
1683 POST_MEM_WRITE( ARG1
, ARG2
);
1688 // int setdomainname(char *domainname, int len);
1689 PRE(sys_freebsd4_setdomainname
)
1691 PRINT("sys_freebsd4_setdomainname ( %#" FMT_REGWORD
"x )",ARG1
);
1692 PRE_REG_READ2(int, "setdomainname", char *, domainname
, int, len
);
1693 PRE_MEM_RASCIIZ( "setdomainname(domainname)", ARG1
);
1697 // int uname(struct utsname *name);
1698 PRE(sys_freebsd4_uname
)
1700 PRINT("sys_freebsd4_uname ( %#" FMT_REGWORD
"x )", ARG1
);
1701 PRE_REG_READ1(int, "uname", struct utsname
*, name
);
1702 PRE_MEM_WRITE( "uname(name)", ARG1
, sizeof(struct vki_utsname
) );
1705 POST(sys_freebsd4_uname
)
1708 POST_MEM_WRITE( ARG1
, sizeof(struct vki_utsname
) );
1719 PRINT( "sys_rtprio ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
, ARG2
, ARG3
);
1720 PRE_REG_READ3(int, "rtprio",
1721 int, function
, pid_t
, pid
, struct rtprio
*, rtp
);
1722 if (ARG1
== VKI_RTP_SET
) {
1723 PRE_MEM_READ( "rtprio(rtp#set)", ARG3
, sizeof(struct vki_rtprio
));
1724 } else if (ARG1
== VKI_RTP_LOOKUP
) {
1725 PRE_MEM_WRITE( "rtprio(rtp#lookup)", ARG3
, sizeof(struct vki_rtprio
));
1733 if (ARG1
== VKI_RTP_LOOKUP
&& RES
== 0) {
1734 POST_MEM_WRITE( ARG3
, sizeof(struct vki_rtprio
));
1738 // freebsd6_pread 173 FREEBSD_VERS <= 10
1741 // freebsd6_pwrite 174 FREEBSD_VERS <= 10
1745 // int setfib(int fib);
1748 PRINT("sys_setfib ( %" FMT_REGWORD
"d )", SARG1
);
1749 PRE_REG_READ1(int, "setfib", int, fib
);
1752 // SYS_ntp_adjtime 176
1753 // int ntp_adjtime(struct timex *);
1760 // int setegid(gid_t egid);
1763 PRINT("sys_setegid ( %" FMT_REGWORD
"u )", ARG1
);
1764 PRE_REG_READ1(int, "setegid", vki_gid_t
, gid
);
1768 // int seteuid(uid_t euid);
1771 PRINT("sys_seteuid ( %" FMT_REGWORD
"u )", ARG1
);
1772 PRE_REG_READ1(long, "seteuid", vki_uid_t
, uid
);
1776 #if (FREEBSD_VERS >= FREEBSD_12)
1778 // SYS_freebsd11_stat 188
1779 // int stat(char *path, struct freebsd11_stat *sb);
1780 PRE(sys_freebsd11_stat
)
1782 PRINT("sys_freebsd11_stat ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
1783 PRE_REG_READ2(int, "stat", char *, path
, struct freebsd11_stat
*, sb
);
1784 PRE_MEM_RASCIIZ( "stat(path)", ARG1
);
1785 PRE_MEM_WRITE( "stat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
1788 POST(sys_freebsd11_stat
)
1790 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
1793 // SYS_freebsd11_fstat 189
1794 // int fstat(int fd, struct stat *sb);
1795 PRE(sys_freebsd11_fstat
)
1797 PRINT("sys_freebsd11_fstat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",SARG1
,ARG2
);
1798 PRE_REG_READ2(int, "fstat", int, fd
, struct stat
*, sb
);
1799 PRE_MEM_WRITE( "fstat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
1802 POST(sys_freebsd11_fstat
)
1804 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
1807 // SYS_freebsd11_lstat 190
1808 // int lstat(const char * restrict path, struct stat * restrict sb);
1809 PRE(sys_freebsd11_lstat
)
1811 PRINT("sys_freebsd11_lstat ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
1812 PRE_REG_READ2(sb
, "lstat", const char *, path
, struct freebsd11_stat
*, sb
);
1813 PRE_MEM_RASCIIZ( "lstat(path)", ARG1
);
1814 PRE_MEM_WRITE( "lstat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
1817 POST(sys_freebsd11_lstat
)
1821 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
1829 PRINT("sys_stat ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
1830 PRE_REG_READ2(int, "stat", char *, path
, struct stat
*, sb
);
1831 PRE_MEM_RASCIIZ( "stat(path)", ARG1
);
1832 PRE_MEM_WRITE( "stat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
1837 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
1843 PRINT("sys_fstat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",SARG1
,ARG2
);
1844 PRE_REG_READ2(int, "fstat", int, fd
, struct stat
*, sb
);
1845 PRE_MEM_WRITE( "fstat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
1850 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
1855 PRINT("sys_lstat ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
1856 PRE_REG_READ2(int, "lstat", const char *, path
, struct stat
*, sb
);
1857 PRE_MEM_RASCIIZ( "lstat(path)", ARG1
);
1858 PRE_MEM_WRITE( "lstat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
1865 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
1872 // long pathconf(const char *path, int name);
1875 PRINT("sys_pathconf ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )",ARG1
,(char *)ARG1
,ARG2
);
1876 PRE_REG_READ2(long, "pathconf", char *, path
, int, name
);
1877 PRE_MEM_RASCIIZ( "pathconf(path)", ARG1
);
1880 // SYS_fpathconf 192
1881 // long fpathconf(int fd, int name);
1884 PRINT("sys_fpathconf ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
);
1885 PRE_REG_READ2(long, "fpathconf", int, fd
, int, name
);
1888 // SYS_getrlimit 194
1891 // SYS_setrlimit 195
1895 // SYS_freebsd11_getdirentries 196
1896 // int getdirentries(int fd, char *buf, int nbytes, long *basep);
1897 #if (FREEBSD_VERS >= FREEBSD_12)
1898 PRE(sys_freebsd11_getdirentries
)
1900 *flags
|= SfMayBlock
;
1901 PRINT("sys_freebsd11_getdirentries ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
,ARG2
,ARG3
);
1902 PRE_REG_READ4(int, "getdirentries",
1903 int, fd
, char *, buf
,
1906 PRE_MEM_WRITE( "getdirentries(buf)", ARG2
, ARG3
);
1908 PRE_MEM_WRITE( "getdirentries(basep)", ARG4
, sizeof(long) );
1912 POST(sys_freebsd11_getdirentries
)
1916 POST_MEM_WRITE( ARG2
, RES
);
1918 POST_MEM_WRITE( ARG4
, sizeof (long));
1923 PRE(sys_getdirentries
)
1925 *flags
|= SfMayBlock
;
1926 PRINT("sys_getdirentries ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
,ARG2
,ARG3
);
1927 PRE_REG_READ4(int, "getdirentries",
1928 int, fd
, char *, buf
,
1931 PRE_MEM_WRITE( "getdirentries(buf)", ARG2
, ARG3
);
1933 PRE_MEM_WRITE( "getdirentries(basep)", ARG4
, sizeof(long) );
1936 POST(sys_getdirentries
)
1940 POST_MEM_WRITE( ARG2
, RES
);
1942 POST_MEM_WRITE( ARG4
, sizeof (long));
1947 // SYS_freebsd6_mmap 197
1951 // SYS___syscall 198
1954 // freebsd6_lseek 199 FREEBSD_VERS <= 10
1957 // freebsd6_truncate 200 FREEBSD_VERS <= 10
1960 // freebsd6_ftruncate 201 FREEBSD_VERS <= 10
1963 static Bool
sysctl_kern_ps_strings(SizeT
* out
, SizeT
* outlen
)
1966 const struct auxv
*cauxv
;
1968 for (cauxv
= (struct auxv
*)VG_(client_auxv
); cauxv
->a_type
!= VKI_AT_NULL
; cauxv
++) {
1969 if (cauxv
->a_type
== VKI_AT_PS_STRINGS
) {
1970 tmp
= (Word
)cauxv
->u
.a_ptr
;
1973 *outlen
= sizeof(size_t);
1980 static void sysctl_kern_usrstack(SizeT
* out
, SizeT
* outlen
)
1982 *out
= VG_(get_usrstack
)();
1983 *outlen
= sizeof(ULong
);
1986 static Bool
sysctl_kern_proc_pathname(HChar
*out
, SizeT
*len
)
1988 const HChar
*exe_name
= VG_(resolved_exename
);
1990 if (!VG_(realpath
)(exe_name
, out
)) {
1994 *len
= VG_(strlen
)(out
)+1;
1999 /* int __sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen); */
2000 /* ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 */
2003 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
);
2005 int* name
= (int*)ARG1
;
2006 if (ML_(safe_to_deref
)(name
, sizeof(int))) {
2007 PRINT("\nmib[0]: ");
2010 case 0: // CTL_UNSPEC
2025 case 5: // CTL_DEBUG
2031 case 7: // CTL_MACHDEP
2034 case 8: // CTL _USER
2037 case 9: //CTL_P1003_1B
2041 PRINT("unrecognized (%d)", ((int*)ARG1
)[0]);
2045 if (SARG2
>= 2 && ML_(safe_to_deref
)(name
, 2*sizeof(int))) {
2046 PRINT(" mib[1]: %d\n", name
[1]);
2051 * Special handling cases
2054 * This sysctl returns the address of the bottom of the user stack
2055 * (that is the highest user stack address, since the stack grows
2056 * downwards). Without any special handling this would return the
2057 * address of the host userstack. We have created a stack for the
2058 * guest (in aspacemgr) and that is the one that we want the guest
2059 * to see. Aspacemgr is setup in m_main.c with the adresses and sizes
2060 * saved to file static variables in that file, so we call
2061 * VG_(get_usrstack)() to retrieve them from there.
2063 if (SARG2
== 2 && ML_(safe_to_deref
)(name
, 2*sizeof(int))) {
2064 if (name
[0] == 1 && name
[1] == 33) {
2066 sysctl_kern_usrstack((SizeT
*)ARG3
, (SizeT
*)ARG4
);
2067 SET_STATUS_Success(0);
2072 * 2. kern.ps_strings
2074 if (SARG2
== 2 && ML_(safe_to_deref
)(name
, 2*sizeof(int))) {
2075 if (name
[0] == 1 && name
[1] == 32) {
2076 if (sysctl_kern_ps_strings((SizeT
*)ARG3
, (SizeT
*)ARG4
)) {
2077 SET_STATUS_Success(0);
2083 * 3. kern.proc.pathname
2085 if (SARG2
== 4 && ML_(safe_to_deref
)(name
, 4*sizeof(int))) {
2086 if (name
[0] == 1 && name
[1] == 14 && name
[2] == 12) {
2087 vki_pid_t pid
= (vki_pid_t
)name
[3];
2088 if (pid
== -1 || pid
== VG_(getpid
)()) {
2089 sysctl_kern_proc_pathname((HChar
*)ARG3
, (SizeT
*)ARG4
);
2090 SET_STATUS_Success(0);
2095 PRE_REG_READ6(int, "__sysctl", int *, name
, vki_u_int32_t
, namelen
, void *, oldp
,
2096 vki_size_t
*, oldlenp
, void *, newp
, vki_size_t
, newlen
);
2098 // read number of ints specified in ARG2 from mem pointed to by ARG1
2099 PRE_MEM_READ("sysctl(name)", (Addr
)ARG1
, ARG2
* sizeof(int));
2101 // if 'newp' is not NULL can read namelen bytes from that address
2102 if (ARG5
!= (UWord
)NULL
) {
2103 PRE_MEM_READ("sysctl(newp)", (Addr
)ARG5
, ARG6
);
2106 // there are two scenarios for oldlenp/oldp
2107 // 1. oldval is NULL and oldlenp is non-NULL
2108 // this is a query of oldlenp so oldlenp will be written
2109 // 2. Both are non-NULL
2110 // this is a query of oldp, oldlenp will be read and oldp will
2113 // More thoughts on this
2114 // if say oldp is a string buffer
2115 // oldlenp will point to the length of the buffer
2117 // but on return does oldlenp also get updated?
2119 // is oldlenp is not NULL, can write
2120 if (ARG4
!= (UWord
)NULL
) {
2121 if (ARG3
!= (UWord
)NULL
) {
2123 PRE_MEM_READ("sysctl(oldlenp)", (Addr
)ARG4
, sizeof(vki_size_t
));
2124 PRE_MEM_WRITE("sysctl(oldlenp)", (Addr
)ARG4
, sizeof(vki_size_t
));
2125 if (ML_(safe_to_deref
)((void*)(Addr
)ARG4
, sizeof(vki_size_t
))) {
2126 PRE_MEM_WRITE("sysctl(oldp)", (Addr
)ARG3
, *(vki_size_t
*)ARG4
);
2128 VG_(dmsg
)("Warning: Bad oldlenp address %p in sysctl\n",
2129 (void *)(Addr
)ARG4
);
2130 SET_STATUS_Failure ( VKI_EFAULT
);
2134 PRE_MEM_WRITE("sysctl(oldlenp)", (Addr
)ARG4
, sizeof(vki_size_t
));
2141 if (ARG4
!= (UWord
)NULL
) {
2142 if (ARG3
!= (UWord
)NULL
) {
2143 POST_MEM_WRITE((Addr
)ARG4
, sizeof(vki_size_t
));
2144 POST_MEM_WRITE((Addr
)ARG3
, *(vki_size_t
*)ARG4
);
2146 POST_MEM_WRITE((Addr
)ARG4
, sizeof(vki_size_t
));
2158 // int undelete(const char *path);
2161 *flags
|= SfMayBlock
;
2162 PRINT("sys_undelete ( %#" FMT_REGWORD
"x(%s) )", ARG1
,(char *)ARG1
);
2163 PRE_REG_READ1(int, "undelete", const char *, path
);
2164 PRE_MEM_RASCIIZ( "undelete(path)", ARG1
);
2168 // int futimes(int fd, const struct timeval *times);
2171 PRINT("sys_lutimes ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
2172 PRE_REG_READ2(long, "futimes", int, fd
, struct timeval
*, times
);
2174 PRE_MEM_READ( "futimes(times)", ARG2
, sizeof(struct vki_timeval
) );
2184 // SYS_freebsd7___semctl 220
2185 // int semctl(int semid, int semnum, int cmd, ...);
2186 PRE(sys_freebsd7___semctl
)
2191 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
2192 PRE_REG_READ4(int, "semctl",
2193 int, semid
, int, semnum
, int, cmd
, struct seminfo
*, arg
);
2198 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
2199 PRE_REG_READ4(int, "semctl",
2200 int, semid
, int, semnum
, int, cmd
, struct vki_semid_ds_old
*, arg
);
2204 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
2205 PRE_REG_READ4(int, "semctl",
2206 int, semid
, int, semnum
, int, cmd
, unsigned short *, arg
);
2209 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
2210 PRE_REG_READ3(long, "semctl",
2211 int, semid
, int, semnum
, int, cmd
);
2214 ML_(generic_PRE_sys_semctl
)(tid
, ARG1
,ARG2
,ARG3
,ARG4
);
2217 POST(sys_freebsd7___semctl
)
2219 ML_(generic_POST_sys_semctl
)(tid
, RES
,ARG1
,ARG2
,ARG3
,ARG4
);
2223 // int semget(key_t key, int nsems, int flag);
2226 PRINT("sys_semget ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
2227 PRE_REG_READ3(int, "semget", vki_key_t
, key
, int, nsems
, int, flag
);
2231 // int semop(int semid, struct sembuf *array, size_t nops);
2234 *flags
|= SfMayBlock
;
2235 PRINT("sys_semop ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
2236 PRE_REG_READ3(int, "semop",
2237 int, semid
, struct sembuf
*, array
, unsigned, nops
);
2238 ML_(generic_PRE_sys_semop
)(tid
, ARG1
,ARG2
,ARG3
);
2241 // SYS_freebsd7_msgctl 224
2242 // int msgctl(int msqid, int cmd, struct msqid_ds_old *buf);
2243 PRE(sys_freebsd7_msgctl
)
2245 PRINT("sys_freebsd7_msgctl ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
,SARG2
,ARG3
);
2247 PRE_REG_READ3(int, "msgctl", int, msqid
, int, cmd
, struct msqid_ds_old
*, buf
);
2249 switch (ARG2
/* cmd */) {
2251 PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)",
2252 ARG3
, sizeof(struct vki_msqid_ds_old
) );
2255 PRE_MEM_READ( "msgctl(IPC_SET, buf)",
2256 ARG3
, sizeof(struct vki_msqid_ds_old
) );
2261 POST(sys_freebsd7_msgctl
)
2263 switch (ARG2
/* cmd */) {
2265 POST_MEM_WRITE( ARG3
, sizeof(struct vki_msqid_ds_old
) );
2271 // int msgget(key_t key, int msgflg);
2274 PRINT("sys_msgget ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )",SARG1
,SARG2
);
2275 PRE_REG_READ2(int, "msgget", key_t
, key
, int, msgflg
);
2279 // int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg);
2282 PRINT("sys_msgsnd ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )", SARG1
,ARG2
,SARG3
,SARG4
);
2283 PRE_REG_READ4(int, "msgsnd", int, msqid
, struct msgbuf
*, msgp
, size_t, msgsz
, int, msgflg
);
2284 struct vki_msgbuf
*msgp
= (struct vki_msgbuf
*)ARG2
;
2285 PRE_MEM_READ( "msgsnd(msgp->mtype)", (Addr
)&msgp
->mtype
, sizeof(msgp
->mtype
) );
2286 PRE_MEM_READ( "msgsnd(msgp->mtext)", (Addr
)&msgp
->mtext
, ARG3
);
2289 // ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg);
2292 *flags
|= SfMayBlock
;
2294 PRINT("sys_msgrcv ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )", SARG1
,ARG2
,ARG3
,SARG4
,SARG5
);
2295 PRE_REG_READ5(ssize_t
, "msgrcv", int, msqid
, struct msgbuf
*, msgp
, size_t, msgsz
,
2296 long, msgtyp
, int, msgflg
);
2297 struct vki_msgbuf
*msgp
= (struct vki_msgbuf
*)ARG2
;
2298 PRE_MEM_WRITE( "msgrcv(msgp->mtype)", (Addr
)&msgp
->mtype
, sizeof(msgp
->mtype
) );
2299 PRE_MEM_WRITE( "msgrcv(msgp->mtext)", (Addr
)&msgp
->mtext
, ARG3
);
2304 struct vki_msgbuf
*msgp
= (struct vki_msgbuf
*)ARG2
;
2305 POST_MEM_WRITE( (Addr
)&msgp
->mtype
, sizeof(msgp
->mtype
) );
2306 POST_MEM_WRITE( (Addr
)&msgp
->mtext
, RES
);
2310 // void * shmat(int shmid, const void *addr, int flag);
2314 PRINT("sys_shmat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
2315 PRE_REG_READ3(void *, "shmat",
2316 int, shmid
, const void *, addr
, int, flag
);
2317 arg2tmp
= ML_(generic_PRE_sys_shmat
)(tid
, ARG1
,ARG2
,ARG3
);
2319 SET_STATUS_Failure( VKI_EINVAL
);
2327 ML_(generic_POST_sys_shmat
)(tid
, RES
,ARG1
,ARG2
,ARG3
);
2330 // SYS_freebsd7_shmctl 229
2331 // int shmctl(int shmid, int cmd, struct shmid_ds *buf);
2332 PRE(sys_freebsd7_shmctl
)
2334 PRINT("sys_freebsd7_shmctl ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",SARG1
,SARG2
,ARG3
);
2335 PRE_REG_READ3(int, "shmctl",
2336 int, shmid
, int, cmd
, struct vki_shmid_ds_old
*, buf
);
2337 switch (ARG2
/* cmd */) {
2339 PRE_MEM_WRITE( "shmctl7(IPC_STAT, buf)",
2340 ARG3
, sizeof(struct vki_shmid_ds_old
) );
2343 PRE_MEM_READ( "shmctl7(IPC_SET, buf)",
2344 ARG3
, sizeof(struct vki_shmid_ds_old
) );
2349 POST(sys_freebsd7_shmctl
)
2351 if (ARG2
== VKI_IPC_STAT
) {
2352 POST_MEM_WRITE( ARG3
, sizeof(struct vki_shmid_ds_old
) );
2357 // int shmdt(const void *addr);
2360 PRINT("sys_shmdt ( %#" FMT_REGWORD
"x )",ARG1
);
2361 PRE_REG_READ1(int, "shmdt", const void *, addr
);
2362 if (!ML_(generic_PRE_sys_shmdt
)(tid
, ARG1
)) {
2363 SET_STATUS_Failure( VKI_EINVAL
);
2369 ML_(generic_POST_sys_shmdt
)(tid
, RES
,ARG1
);
2373 // int shmget(key_t key, size_t size, int flag);
2376 PRINT("sys_shmget ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
2377 PRE_REG_READ3(int, "shmget", vki_key_t
, key
, vki_size_t
, size
, int, flag
);
2381 // SYS_clock_gettime 232
2382 // int clock_gettime(clockid_t clock_id, struct timespec *tp);
2383 PRE(sys_clock_gettime
)
2385 PRINT("sys_clock_gettime( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
2386 PRE_REG_READ2(int, "clock_gettime",
2387 vki_clockid_t
, clk_id
, struct timespec
*, tp
);
2388 PRE_MEM_WRITE( "clock_gettime(tp)", ARG2
, sizeof(struct vki_timespec
) );
2391 POST(sys_clock_gettime
)
2393 POST_MEM_WRITE( ARG2
, sizeof(struct vki_timespec
) );
2396 // SYS_clock_settime 233
2397 // int clock_settime(clockid_t clock_id, const struct timespec *tp);
2398 PRE(sys_clock_settime
)
2400 PRINT("sys_clock_settime( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
2401 PRE_REG_READ2(int, "clock_settime",
2402 vki_clockid_t
, clk_id
, const struct timespec
*, tp
);
2403 PRE_MEM_READ( "clock_settime(tp)", ARG2
, sizeof(struct vki_timespec
) );
2406 // SYS_clock_getres 234
2407 // int clock_getres(clockid_t clock_id, struct timespec *tp);
2408 PRE(sys_clock_getres
)
2410 PRINT("sys_clock_getres( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
2411 // Nb: we can't use "RES" as the param name because that's a macro
2413 PRE_REG_READ2(int, "clock_getres",
2414 vki_clockid_t
, clock_id
, struct timespec
*, tp
);
2416 PRE_MEM_WRITE( "clock_getres(tp)", ARG2
, sizeof(struct vki_timespec
) );
2420 POST(sys_clock_getres
)
2423 POST_MEM_WRITE( ARG2
, sizeof(struct vki_timespec
) );
2427 // SYS_ktimer_create 235
2428 // int timer_create(clockid_t clockid, struct sigevent *restrict evp,
2429 // timer_t *restrict timerid);
2430 PRE(sys_timer_create
)
2432 PRINT("sys_timer_create( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", SARG1
,ARG2
,ARG3
);
2433 PRE_REG_READ3(int, "timer_create",
2434 vki_clockid_t
, clockid
, struct sigevent
*, evp
,
2435 vki_timer_t
*, timerid
);
2437 PRE_MEM_READ( "timer_create(evp)", ARG2
, sizeof(struct vki_sigevent
) );
2439 PRE_MEM_WRITE( "timer_create(timerid)", ARG3
, sizeof(vki_timer_t
) );
2442 POST(sys_timer_create
)
2444 POST_MEM_WRITE( ARG3
, sizeof(vki_timer_t
) );
2447 // SYS_ktimer_delete 236
2448 // int timer_delete(timer_t timerid);
2449 PRE(sys_timer_delete
)
2451 PRINT("sys_timer_delete( %#" FMT_REGWORD
"x )", ARG1
);
2452 PRE_REG_READ1(long, "timer_delete", vki_timer_t
, timerid
);
2455 // SYS_ktimer_settime 237
2456 // int timer_settime(timer_t timerid, int flags,
2457 // const struct itimerspec *restrict value,
2458 // struct itimerspec *restrict ovalue);
2459 PRE(sys_timer_settime
)
2461 PRINT("sys_timer_settime( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
,SARG2
,ARG3
,ARG4
);
2462 PRE_REG_READ4(int, "timer_settime",
2463 vki_timer_t
, timerid
, int, flags
,
2464 const struct itimerspec
*, value
,
2465 struct itimerspec
*, ovalue
);
2466 PRE_MEM_READ( "timer_settime(value)", ARG3
,
2467 sizeof(struct vki_itimerspec
) );
2469 PRE_MEM_WRITE( "timer_settime(ovalue)", ARG4
,
2470 sizeof(struct vki_itimerspec
) );
2474 POST(sys_timer_settime
)
2477 POST_MEM_WRITE( ARG4
, sizeof(struct vki_itimerspec
) );
2481 // SYS_ktimer_gettime 238
2482 // int timer_gettime(timer_t timerid, struct itimerspec *value);
2483 PRE(sys_timer_gettime
)
2485 PRINT("sys_timer_gettime( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
2486 PRE_REG_READ2(long, "timer_gettime",
2487 vki_timer_t
, timerid
, struct itimerspec
*, value
);
2488 PRE_MEM_WRITE( "timer_gettime(value)", ARG2
,
2489 sizeof(struct vki_itimerspec
));
2492 POST(sys_timer_gettime
)
2494 POST_MEM_WRITE( ARG2
, sizeof(struct vki_itimerspec
) );
2497 // SYS_ktimer_getoverrun 239
2498 // int timer_getoverrun(timer_t timerid);
2499 PRE(sys_timer_getoverrun
)
2501 PRINT("sys_timer_getoverrun( %#" FMT_REGWORD
"x )", ARG1
);
2502 PRE_REG_READ1(int, "timer_getoverrun", vki_timer_t
, timerid
);
2505 // SYS_nanosleep 240
2508 // SYS_ffclock_getcounter 241
2509 // int ffclock_getcounter(ffcounter *ffcount);
2512 // SYS_ffclock_setestimate 242
2513 // int ffclock_setestimate(struct ffclock_estimate *cest);
2516 // SYS_ffclock_getestimate 243
2517 // int ffclock_getestimate(struct ffclock_estimate *cest);
2520 // SYS_clock_nanosleep 244
2521 // int clock_nanosleep(clockid_t clock_id, int flags,
2522 // const struct timespec *rqtp, struct timespec *rmtp);
2523 PRE(sys_clock_nanosleep
)
2525 *flags
|= SfMayBlock
|SfPostOnFail
;
2526 PRINT("sys_clock_nanosleep ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
2527 SARG1
, SARG2
, ARG3
, ARG4
);
2528 PRE_REG_READ4(int, "clock_nanosleep", clockid_t
, clock_id
, int, flags
,
2529 const struct timespec
*, rqtp
, struct timespec
*, rmtp
);
2530 PRE_MEM_READ("clock_nanosleep(rqtp)", ARG1
, sizeof(struct vki_timespec
));
2532 PRE_MEM_WRITE( "clock_nanosleep(rmtp)", ARG2
, sizeof(struct vki_timespec
) );
2536 POST(sys_clock_nanosleep
)
2539 POST_MEM_WRITE( ARG2
, sizeof(struct vki_timespec
) );
2543 // SYS_clock_getcpuclockid2 247
2546 POST(sys_clock_getcpuclockid2
)
2548 POST_MEM_WRITE(ARG3
, sizeof(vki_clockid_t
));
2552 // SYS_ntp_gettime 248
2553 // int ntp_gettime(struct ntptimeval *);
2557 // int minherit(void *addr, size_t len, int inherit);
2560 PRINT("sys_minherit( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
,ARG2
,ARG3
);
2561 PRE_REG_READ3(int, "minherit",
2562 void *, addr
, vki_size_t
, len
, int, inherit
);
2564 PRE_MEM_WRITE( "minherit(addr)", ARG1
,ARG2
);
2571 POST_MEM_WRITE( ARG1
, ARG2
);
2576 // x86/amd64 not functional
2578 // SYS_issetugid 253
2579 // int issetugid(void);
2582 PRINT("%s", "sys_issetugid ()");
2583 PRE_REG_READ0(long, "issetugid");
2590 // int aio_read(struct aiocb *iocb);
2593 PRINT("sys_aio_read ( %#" FMT_REGWORD
"x )", ARG1
);
2594 PRE_REG_READ1(int, "aio_read", struct vki_aiocb
*, iocb
);
2595 PRE_MEM_READ("aio_read(iocb)", ARG1
, sizeof(struct vki_aiocb
));
2596 if (ML_(safe_to_deref
)((struct vki_aiocb
*)ARG1
, sizeof(struct vki_aiocb
))) {
2597 struct vki_aiocb
*iocb
= (struct vki_aiocb
*)ARG1
;
2598 PRE_MEM_WRITE( "aio_read(iocb->aio_offset)", (Addr
)iocb
, sizeof(struct vki_aiocb
));
2604 if (ML_(safe_to_deref
)((struct vki_aiocb
*)ARG1
, sizeof(struct vki_aiocb
))) {
2605 struct vki_aiocb
*iocb
= (struct vki_aiocb
*)ARG1
;
2606 POST_MEM_WRITE((Addr
)iocb
, sizeof(struct vki_aiocb
));
2610 // SYS_aio_write 256
2611 // int aio_write(struct aiocb *iocb);
2614 PRINT("sys_aio_write ( %#" FMT_REGWORD
"x )", ARG1
);
2615 PRE_REG_READ1(int, "aio_write", struct vki_aiocb
*, iocb
);
2616 PRE_MEM_READ("aio_read(iocb)", ARG1
, sizeof(struct vki_aiocb
));
2617 if (ML_(safe_to_deref
)((struct vki_aiocb
*)ARG1
, sizeof(struct vki_aiocb
))) {
2618 struct vki_aiocb
*iocb
= (struct vki_aiocb
*)ARG1
;
2619 PRE_MEM_WRITE( "aio_write(iocb->aio_offset)", (Addr
)iocb
, sizeof(struct vki_aiocb
));
2625 if (ML_(safe_to_deref
)((struct vki_aiocb
*)ARG1
, sizeof(struct vki_aiocb
))) {
2626 struct vki_aiocb
*iocb
= (struct vki_aiocb
*)ARG1
;
2627 PRE_MEM_WRITE( "aio_write(iocb->aio_offset)", (Addr
)iocb
, sizeof(struct vki_aiocb
));
2631 // SYS_lio_listio 257
2632 // int lio_listio(int mode, struct aiocb * const list[], int nent,
2633 // struct sigevent *sig);
2636 PRINT("sys_lio_listio ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",
2637 SARG1
, ARG2
, SARG3
, ARG4
);
2638 PRE_REG_READ4(int, "lio_listio", int, mode
, struct aiocb
* const *, list
, int, nent
,
2639 struct sigevent
*,sig
);
2640 PRE_MEM_READ("lio_listio(list)", ARG2
, ARG3
*sizeof(struct vki_aiocb
*));
2641 // loop check elements
2642 if (ML_(safe_to_deref
)((struct vki_aiocb
**)ARG2
, ARG3
*sizeof(struct vki_aiocb
*))) {
2643 struct vki_aiocb
** list
= (struct vki_aiocb
**)ARG2
;
2644 for (int i
= 0; i
< (int)ARG3
; ++i
) {
2646 PRE_MEM_READ("lio_listio(list[?])", (Addr
)list
[i
], ARG3
*sizeof(struct vki_aiocb
));
2649 // figure out what gets read/written
2650 // when list[i]->aio_lio_opcode == VKI_LIO_READ and
2651 // when list[i]->aio_lio_opcode == VKI_LIO_WRITE
2652 //if (ML_(safe_to_deref)(list[i], ARG3*sizeof(struct vki_aiocb))) {
2657 if (ARG1
& VKI_LIO_WAIT
) {
2658 *flags
|= SfMayBlock
;
2661 if (ARG4
&& (ARG1
== VKI_LIO_NOWAIT
)) {
2662 PRE_MEM_READ("lio_listio(sig)", ARG4
, sizeof(struct vki_sigevent
));
2666 // SYS_freebsd11_getdents 272
2670 // int lchmod(const char *path, mode_t mode);
2673 PRINT("sys_lchmod ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,(char *)ARG1
,ARG2
);
2674 PRE_REG_READ2(int, "lchmod", const char *, path
, vki_mode_t
, mode
);
2675 PRE_MEM_RASCIIZ( "lchmod(path)", ARG1
);
2679 // int lutimes(const char *path, const struct timeval *times);
2682 PRINT("sys_lutimes ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
);
2683 PRE_REG_READ2(int, "lutimes", char *, path
, struct timeval
*, times
);
2684 PRE_MEM_RASCIIZ( "lutimes(path)", ARG1
);
2686 PRE_MEM_READ( "lutimes(times)", ARG2
, sizeof(struct vki_timeval
) );
2690 // SYS_freebsd11_nstat 278
2693 // SYS_freebsd11_nfstat 279
2696 // SYS_freebsd11_nlstat 280
2706 // int fhopen(const fhandle_t *fhp, int flags);
2709 PRINT("sys_open ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",ARG1
,ARG2
);
2710 PRE_REG_READ2(int, "fhopen",
2711 struct fhandle_t
*, fhp
, int, flags
);
2712 PRE_MEM_READ( "fhopen(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
2714 /* Otherwise handle normally */
2715 *flags
|= SfMayBlock
;
2721 if (!ML_(fd_allowed
)(RES
, "fhopen", tid
, True
)) {
2723 SET_STATUS_Failure( VKI_EMFILE
);
2725 if (VG_(clo_track_fds
)) {
2726 ML_(record_fd_open_nameless
)(tid
, RES
);
2731 // SYS_freebsd11_fhstat 299
2732 // int fhstat(const fhandle_t *fhp, struct stat *sb);
2733 #if (FREEBSD_VERS >= FREEBSD_12)
2734 PRE(sys_freebsd11_fhstat
)
2736 PRINT("sys_freebsd11_fhstat ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
2737 PRE_REG_READ2(int, "fhstat", struct fhandle
*, fhp
, struct freebd11_stat
*, sb
);
2738 PRE_MEM_READ( "fhstat(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
2739 PRE_MEM_WRITE( "fhstat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
2742 POST(sys_freebsd11_fhstat
)
2744 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
2749 PRINT("sys_fhstat ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
2750 PRE_REG_READ2(int, "fhstat", struct fhandle
*, fhp
, struct stat
*, sb
);
2751 PRE_MEM_READ( "fhstat(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
2752 PRE_MEM_WRITE( "fhstat(sb)", ARG2
, sizeof(struct vki_freebsd11_stat
) );
2757 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_stat
) );
2763 // int modnext(int modid);
2766 PRINT("sys_modnext ( %" FMT_REGWORD
"d )",SARG1
);
2767 PRE_REG_READ1(int, "modnext", int, modid
);
2771 // int modstat(int modid, struct module_stat *stat);
2774 PRINT("sys_modstat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
2775 PRE_REG_READ2(int, "modstat", int, modid
, struct module_stat
*, buf
);
2776 PRE_MEM_WRITE( "modstat(stat)", ARG2
, sizeof(struct vki_module_stat
) );
2781 POST_MEM_WRITE( ARG2
, sizeof(struct vki_module_stat
) );
2785 // int modfnext(int modid);
2788 PRINT("sys_modfnext ( %" FMT_REGWORD
"d )",SARG1
);
2789 PRE_REG_READ1(int, "modfnext", int, modid
);
2793 // int modfind(const char *modname);
2796 PRINT("sys_modfind ( %#" FMT_REGWORD
"x )",ARG1
);
2797 PRE_REG_READ1(long, "modfind", char *, modname
);
2798 PRE_MEM_RASCIIZ( "modfind(modname)", ARG1
);
2802 // int kldload(const char *file);
2805 PRINT("sys_kldload ( %#" FMT_REGWORD
"x(%s) )", ARG1
, (char *)ARG1
);
2806 PRE_REG_READ1(int, "kldload", const char *, "file");
2807 PRE_MEM_RASCIIZ( "kldload(file)", ARG1
);
2810 // SYS_kldunload 305
2811 // int kldunload(int fileid);
2814 PRINT("sys_kldunload ( %" FMT_REGWORD
"u )", ARG1
);
2815 PRE_REG_READ1(int, "kldunload", int, "fileid");
2819 // int kldfind(const char *file);
2822 PRINT("sys_kldfind ( %#" FMT_REGWORD
"x(%s) )", ARG1
, (char *)ARG1
);
2823 PRE_REG_READ1(int, "kldfind", const char *, file
);
2824 PRE_MEM_RASCIIZ( "kldfind(file)", ARG1
);
2828 // int kldnext(int fileid);
2831 PRINT("sys_kldnext ( %" FMT_REGWORD
"u )", ARG1
);
2832 PRE_REG_READ1(int, "kldnext", int, fileid
);
2836 // int kldstat(int fileid, struct kld_file_stat *stat);
2839 PRINT("sys_kldstat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
2840 PRE_REG_READ2(int, "kldstat", int, fileid
, struct kld_file_stat
*, stat
);
2841 PRE_MEM_WRITE("kldstat(stat)", ARG2
, sizeof(struct vki_kld_file_stat
));
2846 POST_MEM_WRITE(ARG2
, sizeof(struct vki_kld_file_stat
));
2849 // SYS_kldfirstmod 309
2850 // int kldfirstmod(int fileid);
2851 PRE(sys_kldfirstmod
)
2853 PRINT("sys_kldfirstmod ( %" FMT_REGWORD
"u )", ARG1
);
2854 PRE_REG_READ1(int, "kldfirstmod", int, fileid
);
2857 // SYS_setresuid 311
2858 // int setresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
2861 PRINT("sys_setresuid ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
);
2862 PRE_REG_READ3(int, "setresuid",
2863 vki_uid_t
, ruid
, vki_uid_t
, euid
, vki_uid_t
, suid
);
2866 // SYS_setresgid 312
2867 // int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
2870 PRINT("sys_setresgid ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
);
2871 PRE_REG_READ3(int, "setresgid",
2872 vki_gid_t
, rgid
, vki_gid_t
, egid
, vki_gid_t
, sgid
);
2875 // SYS_aio_return 314
2876 // ssize_t aio_return(struct aiocb *iocb);
2879 PRINT("sys_aio_return ( %#" FMT_REGWORD
"x )", ARG1
);
2880 PRE_REG_READ1(ssize_t
, "aio_return", struct aiocb
*, iocb
);
2881 // not too clear if this is read-only, sounds like it from the man page
2882 // but it isn't const
2883 PRE_MEM_READ("aio_return(iocb)", ARG1
, sizeof(struct vki_aiocb
));
2886 // SYS_aio_suspend 315
2887 // int aio_suspend(const struct aiocb *const iocbs[], int niocb,
2888 // const struct timespec *timeout);
2889 PRE(sys_aio_suspend
)
2891 PRINT("sys_aio_suspend ( %#" FMT_REGWORD
"x )", ARG1
);
2892 PRE_REG_READ3(int, "aio_suspend", struct aiocb
**, iocbs
, int, nbiocb
, const struct timespec
*, timeout
);
2893 PRE_MEM_READ("aio_suspend(iocbs)", ARG1
, ARG2
*sizeof(struct vki_aiocb
));
2894 PRE_MEM_READ("aio_suspend(timeout)", ARG3
, sizeof(struct vki_timespec
));
2897 // SYS_aio_cancel 316
2898 // int aio_cancel(int fildes, struct aiocb *iocb);
2901 PRINT("sys_aio_cancel ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
2902 PRE_REG_READ2(int, "aio_cancel", int, fildex
, struct aiocb
*, iocb
);
2904 PRE_MEM_READ("aio_cancel(iocb)", ARG2
, sizeof(struct vki_aiocb
));
2908 // SYS_aio_error 317
2909 // int aio_error(const struct aiocb *iocb);
2912 PRINT("sys_aio_error ( %#" FMT_REGWORD
"x )", ARG1
);
2913 PRE_REG_READ1(ssize_t
, "aio_error", struct aiocb
*, iocb
);
2914 PRE_MEM_READ("aio_error(iocb)", ARG1
, sizeof(struct vki_aiocb
));
2921 *flags
|= SfMayBlock
;
2922 PRINT("%s", "yield()");
2923 PRE_REG_READ0(long, "yield");
2929 // SYS_munlockall 325
2930 // int munlockall(void);
2933 *flags
|= SfMayBlock
;
2934 PRINT("%s", "sys_munlockall ( )");
2935 PRE_REG_READ0(int, "munlockall");
2939 // int __getcwd(char *buf, size_t buflen);
2942 PRINT("sys___getcwd ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
,ARG2
);
2943 PRE_REG_READ2(long, "__getcwd", char *, buf
, unsigned int, buflen
);
2944 PRE_MEM_WRITE( "__getcwd(buf)", ARG1
, ARG2
);
2951 // QQQ it is unclear if this is legal or not, but the
2952 // QQQ kernel just wrote it there...
2953 // QQQ Why oh why didn't phk return the length from __getcwd()?
2954 UInt len
= VG_(strlen
) ( (char *)ARG1
) + 1;
2955 POST_MEM_WRITE( ARG1
, len
);
2959 //SYS_sched_setparam 327
2960 // int sched_setparam(pid_t pid, const struct sched_param *param);
2961 PRE(sys_sched_setparam
)
2963 PRINT("sched_setparam ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
2964 PRE_REG_READ2(int, "sched_setparam",
2965 vki_pid_t
, pid
, struct sched_param
*, param
);
2966 PRE_MEM_READ( "sched_setparam(param)", ARG2
, sizeof(struct vki_sched_param
) );
2969 POST(sys_sched_setparam
)
2971 POST_MEM_WRITE( ARG2
, sizeof(struct vki_sched_param
) );
2974 // SYS_sched_getparam 328
2975 // int sched_getparam(pid_t pid, struct sched_param *param);
2976 PRE(sys_sched_getparam
)
2978 PRINT("sched_getparam ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
2979 PRE_REG_READ2(int, "sched_getparam",
2980 vki_pid_t
, pid
, struct sched_param
*, param
);
2981 PRE_MEM_WRITE( "sched_getparam(param)", ARG2
, sizeof(struct vki_sched_param
) );
2984 POST(sys_sched_getparam
)
2986 POST_MEM_WRITE( ARG2
, sizeof(struct vki_sched_param
) );
2989 // SYS_sched_setscheduler 329
2990 // int sched_setscheduler(pid_t pid, int policy,
2991 // const struct sched_param *param);
2992 PRE(sys_sched_setscheduler
)
2994 PRINT("sys_sched_setscheduler ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
,SARG2
,ARG3
);
2995 PRE_REG_READ3(int, "sched_setscheduler",
2996 vki_pid_t
, pid
, int, policy
, struct sched_param
*, param
);
2998 PRE_MEM_READ("sched_setscheduler(param)",
2999 ARG3
, sizeof(struct vki_sched_param
));
3003 // SYS_sched_getscheduler 330
3004 // int sched_getscheduler(pid_t pid);
3005 PRE(sys_sched_getscheduler
)
3007 PRINT("sys_sched_getscheduler ( %" FMT_REGWORD
"d )", SARG1
);
3008 PRE_REG_READ1(int, "sched_getscheduler", vki_pid_t
, pid
);
3011 // SYS_sched_yield 331
3012 // int sched_yield(void);
3013 PRE(sys_sched_yield
)
3015 *flags
|= SfMayBlock
;
3016 PRINT("sched_yield()");
3017 PRE_REG_READ0(int, "sched_yield");
3020 // SYS_sched_get_priority_max 332
3021 // int sched_get_priority_max(int policy);
3022 PRE(sys_sched_get_priority_max
)
3024 PRINT("sched_get_priority_max ( %" FMT_REGWORD
"u )", ARG1
);
3025 PRE_REG_READ1(long, "sched_get_priority_max", int, policy
);
3028 // SYS_sched_get_priority_min 333
3029 // int sched_get_priority_min(int policy);
3030 PRE(sys_sched_get_priority_min
)
3032 PRINT("sched_get_priority_min ( %" FMT_REGWORD
"u )", ARG1
);
3033 PRE_REG_READ1(long, "sched_get_priority_min", int, policy
);
3036 // SYS_sched_rr_get_interval 334
3037 // int sched_rr_get_interval(pid_t pid, struct timespec *interval);
3038 PRE(sys_sched_rr_get_interval
)
3040 PRINT("sys_sched_rr_get_interval ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
3041 PRE_REG_READ2(int, "sched_rr_get_interval", vki_pid_t
, pid
, struct vki_timespec
*,interval
);
3042 PRE_MEM_WRITE("sys_sched_rr_get_interval(interval)", ARG2
, sizeof(struct vki_timespec
));
3045 POST(sys_sched_rr_get_interval
)
3047 POST_MEM_WRITE(ARG2
, sizeof(struct vki_timespec
));
3051 // int utrace(const void *addr, size_t len);
3054 PRINT("sys_utrace ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, ARG2
);
3055 PRE_REG_READ2(int, "utrace", const void *, addr
, vki_size_t
, len
);
3056 PRE_MEM_READ( "utrace(addr)", ARG2
, ARG3
);
3060 // int kldsym(int fileid, int cmd, void *data);
3063 PRINT("sys_kldsym ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
3064 PRE_REG_READ3(int, "kldsym", int, fileid
, int, cmd
, void*, data
);
3065 PRE_MEM_READ( "kldsym(data)", ARG3
, sizeof(struct vki_kld_sym_lookup
) );
3066 struct vki_kld_sym_lookup
*kslp
= (struct vki_kld_sym_lookup
*)ARG3
;
3067 if (ML_(safe_to_deref
)(kslp
, sizeof(struct vki_kld_sym_lookup
))) {
3068 PRE_MEM_RASCIIZ( "kldsym(data.symname)", (Addr
)kslp
->symname
);
3074 struct vki_kld_sym_lookup
*kslp
= (struct vki_kld_sym_lookup
*)ARG3
;
3075 POST_MEM_WRITE( (Addr
)&kslp
->symvalue
, sizeof(kslp
->symvalue
) );
3076 POST_MEM_WRITE( (Addr
)&kslp
->symsize
, sizeof(kslp
->symsize
) );
3080 // int jail(struct jail *jail);
3083 PRINT("sys_jail ( %#" FMT_REGWORD
"x )", ARG1
);
3084 PRE_REG_READ1(int, "jail", struct jail
*, jail
);
3085 PRE_MEM_READ( "jail(jail)", ARG1
, sizeof(struct vki_jail
) );
3088 // SYS_nnpfs_syscall 338
3091 // SYS_sigprocmask 340
3092 // int sigprocmask(int how, const sigset_t * restrict set,
3093 // sigset_t * restrict oset);
3094 PRE(sys_sigprocmask
)
3096 PRINT("sys_sigprocmask ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
);
3097 PRE_REG_READ3(int, "sigprocmask",
3098 int, how
, vki_sigset_t
*, set
, vki_sigset_t
*, oset
);
3100 PRE_MEM_READ( "sigprocmask(set)", ARG2
, sizeof(vki_sigset_t
));
3103 PRE_MEM_WRITE( "sigprocmask(oset)", ARG3
, sizeof(vki_sigset_t
));
3107 !ML_(safe_to_deref
)((void *)(Addr
)ARG2
, sizeof(vki_sigset_t
))) {
3108 VG_(dmsg
)("Warning: Bad set handler address %p in sigprocmask\n",
3109 (void *)(Addr
)ARG2
);
3110 SET_STATUS_Failure ( VKI_EFAULT
);
3111 } else if (ARG3
!= 0 &&
3112 !ML_(safe_to_deref
)((void *)(Addr
)ARG3
, sizeof(vki_sigset_t
))) {
3113 VG_(dmsg
)("Warning: Bad oldset address %p in sigprocmask\n",
3114 (void *)(Addr
)ARG3
);
3115 SET_STATUS_Failure ( VKI_EFAULT
);
3117 SET_STATUS_from_SysRes(VG_(do_sys_sigprocmask
)(tid
, ARG1
/*how*/,
3118 (vki_sigset_t
*)(Addr
)ARG2
,
3119 (vki_sigset_t
*)(Addr
)ARG3
));
3123 *flags
|= SfPollAfter
;
3127 POST(sys_sigprocmask
)
3130 if (RES
== 0 && ARG3
!= 0) {
3131 POST_MEM_WRITE( ARG3
, sizeof(vki_sigset_t
));
3135 // SYS_sigsuspend 341
3136 // int sigsuspend(const sigset_t *sigmask);
3139 *flags
|= SfMayBlock
;
3140 PRINT("sys_sigsuspend ( %#" FMT_REGWORD
"x )", ARG1
);
3141 PRE_REG_READ1(int, "sigsuspend", const vki_sigset_t
*, sigmask
);
3142 PRE_MEM_READ( "sigsuspend(sigmask)", ARG1
, sizeof(vki_sigset_t
) );
3144 ARG1
= ML_(make_safe_mask
)("syswrap.sigsuspend.1", (Addr
)ARG1
);
3148 POST(sys_sigsuspend
)
3150 ML_(free_safe_mask
) ( (Addr
)ARG1
);
3153 // SYS_sigpending 343
3154 // int sigpending(sigset_t *set);
3157 PRINT( "sys_sigpending ( %#" FMT_REGWORD
"x )", ARG1
);
3158 PRE_REG_READ1(int, "sigpending", vki_sigset_t
*, set
);
3159 PRE_MEM_WRITE( "sigpending(set)", ARG1
, sizeof(vki_sigset_t
));
3162 POST(sys_sigpending
)
3164 POST_MEM_WRITE( ARG1
, sizeof(vki_sigset_t
) ) ;
3168 // SYS_sigtimedwait 345
3169 // int sigtimedwait(const sigset_t *restrict set, siginfo_t *restrict info,
3170 // const struct timespec *restrict timeout);
3171 PRE(sys_sigtimedwait
)
3173 *flags
|= SfMayBlock
;
3174 PRINT("sys_sigtimedwait ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
3176 PRE_REG_READ3(int, "sigtimedwait",
3177 const vki_sigset_t
*, set
, vki_siginfo_t
*, info
,
3178 const struct timespec
*, timeout
);
3180 PRE_MEM_READ( "sigtimedwait(set)", ARG1
, sizeof(vki_sigset_t
));
3183 PRE_MEM_WRITE( "sigtimedwait(info)", ARG2
, sizeof(vki_siginfo_t
) );
3186 PRE_MEM_READ( "sigtimedwait(timeout)",
3187 ARG3
, sizeof(struct vki_timespec
) );
3191 POST(sys_sigtimedwait
)
3194 POST_MEM_WRITE( ARG2
, sizeof(vki_siginfo_t
) );
3198 // SYS_sigwaitinfo 346
3199 // int sigwaitinfo(const sigset_t * restrict set, siginfo_t * restrict info);
3200 PRE(sys_sigwaitinfo
)
3202 *flags
|= SfMayBlock
;
3203 PRINT("sys_sigwaitinfo ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
3205 PRE_REG_READ2(int, "sigwaitinfo",
3206 const vki_sigset_t
*, set
, vki_siginfo_t
*, info
);
3208 PRE_MEM_READ( "sigwaitinfo(set)", ARG1
, sizeof(vki_sigset_t
));
3211 PRE_MEM_WRITE( "sigwaitinfo(info)", ARG2
, sizeof(vki_siginfo_t
) );
3215 POST(sys_sigwaitinfo
)
3218 POST_MEM_WRITE( ARG2
, sizeof(vki_siginfo_t
) );
3222 // SYS___acl_get_file 347
3223 // int __acl_get_file(const char *path, acl_type_t type, struct acl *aclp);
3224 PRE(sys___acl_get_file
)
3226 PRINT("sys___acl_get_file ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
,ARG3
);
3227 PRE_REG_READ3(int, "acl_get_file",
3228 const char *, path
, int, type
, struct vki_acl
*, aclp
);
3229 PRE_MEM_RASCIIZ("acl_get_file(path", ARG1
);
3230 PRE_MEM_WRITE( "acl_get_file(aclp)", ARG3
, sizeof(struct vki_acl
) );
3233 POST(sys___acl_get_file
)
3237 POST_MEM_WRITE( ARG3
, sizeof(struct vki_acl
) );
3241 // SYS___acl_set_file 348
3242 // int __acl_set_file(const char *path, acl_type_t type, struct acl *aclp);
3243 PRE(sys___acl_set_file
)
3245 PRINT("sys___acl_set_file ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
,ARG3
);
3246 PRE_REG_READ3(int, "acl_set_file",
3247 const char *, path
, int, type
, struct vki_acl
*, aclp
);
3248 PRE_MEM_RASCIIZ("acl_set_file(path", ARG1
);
3249 PRE_MEM_READ("acl_set_file(aclp)", ARG3
, sizeof(struct vki_acl
) );
3252 // SYS___acl_get_fd 349
3253 // int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp);
3254 PRE(sys___acl_get_fd
)
3256 PRINT("sys___acl_get_fd ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
3257 PRE_REG_READ3(int, "acl_get_fd",
3258 int, fd
, int, type
, struct vki_acl
*, aclp
);
3259 PRE_MEM_WRITE( "acl_get_file(aclp)", ARG3
, sizeof(struct vki_acl
) );
3262 POST(sys___acl_get_fd
)
3266 POST_MEM_WRITE( ARG3
, sizeof(struct vki_acl
) );
3270 // SYS___acl_set_fd 350
3271 // int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp);
3272 PRE(sys___acl_set_fd
)
3274 PRINT("sys___acl_set_fd ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
3275 PRE_REG_READ3(int, "acl_set_fd",
3276 int, filedes
, int, type
, struct vki_acl
*, aclp
);
3277 PRE_MEM_READ( "acl_get_file(aclp)", ARG3
, sizeof(struct vki_acl
) );
3280 // SYS___acl_delete_file 351
3281 // int __acl_delete_file(const char *path, acl_type_t type);
3282 PRE(sys___acl_delete_file
)
3284 PRINT("sys___acl_delete_file ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,(char *)ARG1
,ARG2
);
3285 PRE_MEM_RASCIIZ("acl_set_file(path", ARG1
);
3286 PRE_REG_READ2(int, "acl_delete_file",
3287 const char *, path
, int, type
);
3289 // SYS___acl_delete_fd 352
3290 // int __acl_delete_fd(int filedes, acl_type_t type);
3291 PRE(sys___acl_delete_fd
)
3293 PRINT("sys___acl_delete_fd ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
,ARG2
);
3294 PRE_REG_READ2(int, "acl_delete_fd",
3295 int, filedes
, int, acltype
);
3298 // SYS___acl_aclcheck_file 353
3299 // int __acl_aclcheck_file(const char *path, acl_type_t type, struct acl *aclp);
3300 PRE(sys___acl_aclcheck_file
)
3302 PRINT("sys___acl_aclcheck_file ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
,ARG3
);
3303 PRE_REG_READ3(int, "acl_aclcheck_file",
3304 const char *, path
, int, type
, struct vki_acl
*, aclp
);
3305 PRE_MEM_RASCIIZ("acl_set_file(path", ARG1
);
3306 PRE_MEM_READ( "acl_aclcheck_file(aclp)", ARG3
, sizeof(struct vki_acl
) );
3309 // SYS___acl_aclcheck_fd 354
3310 // int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp);
3311 PRE(sys___acl_aclcheck_fd
)
3313 PRINT("sys___acl_aclcheck_fd ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
3314 PRE_REG_READ3(int, "acl_aclcheck_fd",
3315 int, fd
, int, type
, struct vki_acl
*, aclp
);
3316 PRE_MEM_READ( "acl_aclcheck_fd(aclp)", ARG3
, sizeof(struct vki_acl
) );
3319 // SYS_extattrctl 355
3321 // syscalls.master: int extattrctl(_In_z_ const char *path, int cmd, _In_z_opt_ const char *filename, int attrnamespace, _In_z_ const char *attrname);
3324 PRINT("sys_extattrctl ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", ARG1
,SARG2
,ARG3
,SARG4
,ARG5
);
3325 PRE_REG_READ5(ssize_t
, "extattrctl",
3326 const char *, path
, int, cmd
, const char *, filename
, int, attrnamespace
, const char *, attrname
);
3327 PRE_MEM_RASCIIZ("extattrctl(path)", ARG1
);
3328 PRE_MEM_RASCIIZ("extattrctl(filename)", ARG3
);
3329 PRE_MEM_RASCIIZ("extattrctl(attrname)", ARG5
);
3332 // SYS_extattr_set_file 356
3333 // ssize_t extattr_set_file(const char *path, int attrnamespace,
3334 // const char *attrname, const void *data, size_t nbytes);
3335 PRE(sys_extattr_set_file
)
3337 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
);
3338 PRE_REG_READ5(ssize_t
, "extattr_set_file",
3339 const char *, path
, int, attrnamespace
, const char *, attrname
, const void *, data
, size_t, nbytes
);
3340 PRE_MEM_RASCIIZ("extattr_set_file(path)", ARG1
);
3341 PRE_MEM_RASCIIZ("extattr_set_file(attrname)", ARG3
);
3342 PRE_MEM_READ("extattr_set_file(data)", ARG4
, ARG5
);
3345 // SYS_extattr_get_file 357
3346 // ssize_t extattr_get_file(const char *path, int attrnamespace,
3347 // const char *attrname, void *data, size_t nbytes);
3348 PRE(sys_extattr_get_file
)
3350 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
);
3351 PRE_REG_READ5(ssize_t
, "extattr_get_file",
3352 const char *, path
, int, attrnamespace
, const char *, attrname
, void *, data
, size_t, nbytes
);
3353 PRE_MEM_RASCIIZ("extattr_get_file(path)", ARG1
);
3354 PRE_MEM_RASCIIZ("extattr_get_file(attrname)", ARG3
);
3356 PRE_MEM_WRITE("extattr_get_file(data)", ARG4
, ARG5
);
3360 POST(sys_extattr_get_file
)
3363 POST_MEM_WRITE(ARG4
, ARG5
);
3367 // SYS_extattr_delete_file 358
3368 // int extattr_delete_file(const char *path, int attrnamespace,
3369 // const char *attrname);
3370 PRE(sys_extattr_delete_file
)
3372 PRINT("sys_extattr_delete_file ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", ARG1
,SARG2
,ARG3
);
3373 PRE_REG_READ3(ssize_t
, "extattr_delete_file",
3374 const char *, path
, int, attrnamespace
, const char *, attrname
);
3375 PRE_MEM_RASCIIZ("extattr_delete_file(path)", ARG1
);
3376 PRE_MEM_RASCIIZ("extattr_delete_file(attrname)", ARG3
);
3379 // SYS_aio_waitcomplete 359
3380 // ssize_t aio_waitcomplete(struct aiocb **iocbp, struct timespec *timeout);
3381 PRE(sys_aio_waitcomplete
)
3383 *flags
|= SfMayBlock
;
3384 PRINT("sys_aio_waitcomplete ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
3385 PRE_REG_READ2(ssize_t
, "aio_waitcomplete", struct aiocb
**, iocbp
, struct timespec
*, timeout
);
3387 PRE_MEM_READ("aio_waitcomplete(timeout", ARG2
, sizeof(struct vki_timespec
));
3389 PRE_MEM_WRITE( "aio_waitcomplete(iocbp)", ARG1
, sizeof(struct aiocb
*));
3392 POST(sys_aio_waitcomplete
)
3394 POST_MEM_WRITE(ARG1
, sizeof(struct aiocb
*));
3397 // SYS_getresuid 360
3398 // int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
3401 PRINT("sys_getresuid ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
3402 PRE_REG_READ3(long, "getresuid",
3403 vki_uid_t
*, ruid
, vki_uid_t
*, euid
, vki_uid_t
*, suid
);
3404 PRE_MEM_WRITE( "getresuid(ruid)", ARG1
, sizeof(vki_uid_t
) );
3405 PRE_MEM_WRITE( "getresuid(euid)", ARG2
, sizeof(vki_uid_t
) );
3406 PRE_MEM_WRITE( "getresuid(suid)", ARG3
, sizeof(vki_uid_t
) );
3413 POST_MEM_WRITE( ARG1
, sizeof(vki_uid_t
) );
3414 POST_MEM_WRITE( ARG2
, sizeof(vki_uid_t
) );
3415 POST_MEM_WRITE( ARG3
, sizeof(vki_uid_t
) );
3419 // SYS_getresgid 361
3420 // int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
3423 PRINT("sys_getresgid ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
3424 PRE_REG_READ3(long, "getresgid",
3425 vki_gid_t
*, rgid
, vki_gid_t
*, egid
, vki_gid_t
*, sgid
);
3426 PRE_MEM_WRITE( "getresgid(rgid)", ARG1
, sizeof(vki_gid_t
) );
3427 PRE_MEM_WRITE( "getresgid(egid)", ARG2
, sizeof(vki_gid_t
) );
3428 PRE_MEM_WRITE( "getresgid(sgid)", ARG3
, sizeof(vki_gid_t
) );
3435 POST_MEM_WRITE( ARG1
, sizeof(vki_gid_t
) );
3436 POST_MEM_WRITE( ARG2
, sizeof(vki_gid_t
) );
3437 POST_MEM_WRITE( ARG3
, sizeof(vki_gid_t
) );
3442 // int kqueue(void);
3445 PRINT("%s", "sys_kqueue ()");
3446 PRE_REG_READ0(omt
, "kqueue");
3451 if (!ML_(fd_allowed
)(RES
, "kqueue", tid
, True
)) {
3453 SET_STATUS_Failure( VKI_EMFILE
);
3455 if (VG_(clo_track_fds
)) {
3456 ML_(record_fd_open_nameless
)(tid
, RES
);
3461 // SYS_freebsd11_kevent 363
3462 // int kevent(int kq, const struct kevent *changelist, int nchanges,
3463 // struct kevent *eventlist, int nevents,
3464 // const struct timespec *timeout);
3465 #if (FREEBSD_VERS >= FREEBSD_12)
3466 PRE(sys_freebsd11_kevent
)
3468 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
);
3469 PRE_REG_READ6(int, "kevent",
3470 int, fd
, const struct vki_kevent_freebsd11
*, changelist
, int, nchanges
,
3471 struct vki_kevent_freebsd11
*, eventlist
, int, nevents
,
3472 struct timespec
*, timeout
);
3473 if (ARG2
!= 0 && ARG3
!= 0) {
3474 PRE_MEM_READ( "kevent(changelist)", ARG2
, sizeof(struct vki_kevent_freebsd11
)*ARG3
);
3476 if (ARG4
!= 0 && ARG5
!= 0) {
3477 PRE_MEM_WRITE( "kevent(eventlist)", ARG4
, sizeof(struct vki_kevent_freebsd11
)*ARG5
);
3480 *flags
|= SfMayBlock
;
3483 PRE_MEM_READ( "kevent(timeout)",
3484 ARG6
, sizeof(struct vki_timespec
));
3488 POST(sys_freebsd11_kevent
)
3491 if ((Word
)RES
!= -1) {
3493 POST_MEM_WRITE( ARG4
, sizeof(struct vki_kevent_freebsd11
)*RES
) ;
3500 *flags
|= SfMayBlock
;
3501 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
);
3502 PRE_REG_READ6(int, "kevent",
3503 int, fd
, struct vki_kevent_freebsd11
*, changelist
, int, nchanges
,
3504 struct vki_kevent_freebsd11
*, eventlist
, int, nevents
,
3505 struct timespec
*, timeout
);
3506 if (ARG2
!= 0 && ARG3
!= 0)
3507 PRE_MEM_READ( "kevent(changelist)", ARG2
, sizeof(struct vki_kevent_freebsd11
)*ARG3
);
3508 if (ARG4
!= 0 && ARG5
!= 0)
3509 PRE_MEM_WRITE( "kevent(eventlist)", ARG4
, sizeof(struct vki_kevent_freebsd11
)*ARG5
);
3511 PRE_MEM_READ( "kevent(timeout)",
3512 ARG6
, sizeof(struct vki_timespec
));
3518 if ((Word
)RES
!= -1) {
3520 POST_MEM_WRITE( ARG4
, sizeof(struct vki_kevent_freebsd11
)*RES
) ;
3525 // SYS_extattr_set_fd 371
3526 // ssize_t extattr_set_fd(int fd, int attrnamespace, const char *attrname,
3527 // const void *data, size_t nbytes);
3528 PRE(sys_extattr_set_fd
)
3530 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
);
3531 PRE_REG_READ5(int, "extattr_set_fd", int, fd
, int, attrnamespace
, const char *,attrname
, const void *,data
, size_t, nbytes
);
3532 PRE_MEM_RASCIIZ( "extattr_set_fd(attrname)", ARG3
);
3533 PRE_MEM_READ("extattr_set_fd(data)", ARG4
, ARG5
);
3536 // SYS_extattr_get_fd 372
3537 // ssize_t extattr_get_fd(int fd, int attrnamespace, const char *attrname,
3538 // void *data, size_t nbytes);
3539 PRE(sys_extattr_get_fd
)
3541 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
);
3542 PRE_REG_READ5(int, "extattr_get_fd", int, fd
, int, attrnamespace
, const char *,attrname
, const void *,data
, size_t, nbytes
);
3543 PRE_MEM_RASCIIZ( "extattr_get_fd(attrname)", ARG3
);
3544 PRE_MEM_WRITE("extattr_get_fd(data)", ARG4
, ARG5
);
3547 POST(sys_extattr_get_fd
)
3549 POST_MEM_WRITE(ARG4
, ARG5
);
3552 // SYS_extattr_delete_fd 373
3553 // int extattr_delete_fd(int fd, int attrnamespace, const char *attrname);
3554 PRE(sys_extattr_delete_fd
)
3556 PRINT("sys_extattr_delete_fd ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
,SARG2
,ARG3
);
3557 PRE_REG_READ3(int, "extattr_delete_fd", int, fd
, int, attrnamespace
, const char *,attrname
);
3558 PRE_MEM_RASCIIZ( "extattr_delete_fd(attrname)", ARG3
);
3561 // SYS___setugid 374
3563 // syscalls.master: int __setugid(int flag);
3566 PRINT("sys___setugid ( %" FMT_REGWORD
"d )", SARG1
);
3567 PRE_REG_READ1(int, "__setugid", int, flag
);
3571 // int eaccess(const char *path, int mode);
3574 PRINT("sys_eaccess ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,(char*)ARG1
,ARG2
);
3575 PRE_REG_READ2(int, "eaccess", const char *, path
, int, mode
);
3576 PRE_MEM_RASCIIZ( "eaccess(path)", ARG1
);
3579 // SYS_afs3_syscall 377
3583 // int nmount(struct iovec *iov, u_int niov, int flags);
3586 PRINT("sys_nmount ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"d )", ARG1
, ARG2
, SARG3
);
3587 PRE_REG_READ3(int, "nmount", struct iovec
*, iov
, u_int
, niov
, int, flags
);
3588 PRE_MEM_READ( "nmount(pathname)", ARG1
, ARG2
*sizeof(struct vki_iovec
) );
3591 // SYS___mac_get_proc 384
3594 // SYS___mac_set_proc 385
3597 // SYS___mac_get_fd 386
3600 // SYS___mac_get_file 387
3603 // SYS___mac_set_fd 388
3606 // SYS___mac_set_file 389
3610 // int kenv(int action, const char *name, char *value, int len);
3613 PRINT("sys_kenv ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
,ARG2
,ARG3
,ARG4
);
3614 PRE_REG_READ4(int, "kenv",
3615 int, action
, const char *, name
, char *, value
, int, len
);
3619 case VKI_KENV_UNSET
:
3620 PRE_MEM_RASCIIZ("kenv(name)", ARG2
);
3625 VG_(dmsg
)("Warning: Bad action %" FMT_REGWORD
"u in kenv\n", ARG1
);
3634 POST_MEM_WRITE(ARG3
, ARG4
);
3637 if (ARG3
!= (Addr
)NULL
) {
3638 POST_MEM_WRITE(ARG3
, ARG4
);
3646 // int lchflags(const char *path, unsigned long flags);
3649 PRINT("sys_lchflags ( %#" FMT_REGWORD
"x(%s), 0x%" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
);
3650 PRE_REG_READ2(int, "lchflags",
3651 const char *, path
, unsigned long, flags
);
3652 PRE_MEM_RASCIIZ( "lchflags(path)", ARG1
);
3656 // int uuidgen(struct uuid *store, int count);
3659 PRINT("sys_uuidgen ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
,ARG2
);
3660 PRE_REG_READ2(int, "uuidgen",
3661 struct vki_uuid
*, store
, int, count
);
3662 PRE_MEM_WRITE( "uuidgen(store)", ARG1
, ARG2
* sizeof(struct vki_uuid
));
3668 POST_MEM_WRITE( ARG1
, ARG2
* sizeof(struct vki_uuid
) );
3675 // SYS_mac_syscall 394
3678 #if (FREEBSD_VERS >= FREEBSD_12)
3680 // SYS_freebsd11_getfsstat 395
3681 // int getfsstat(struct freebsd11_statfs *buf, long bufsize, int mode);
3683 PRE(sys_freebsd11_getfsstat
)
3685 PRINT("sys_freebsd11_getfsstat ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
3686 PRE_REG_READ3(int, "getfsstat", struct vki_freebsd11_statfs
*, buf
, long, bufsize
, int, mode
);
3687 PRE_MEM_WRITE( "getfsstat(buf)", ARG1
, ARG2
);
3690 POST(sys_freebsd11_getfsstat
)
3693 if ((Word
)RES
!= -1) {
3694 POST_MEM_WRITE( ARG1
, RES
* sizeof(struct vki_freebsd11_statfs
) );
3698 // SYS_freebsd11_statfs 396
3699 // int statfs(const char *path, struct statfs *buf);
3700 PRE(sys_freebsd11_statfs
)
3702 PRINT("sys_statfs ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
3703 PRE_REG_READ2(int, "statfs", const char *, path
, struct statfs
*, buf
);
3704 PRE_MEM_RASCIIZ( "statfs(path)", ARG1
);
3705 PRE_MEM_WRITE( "statfs(buf)", ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3708 POST(sys_freebsd11_statfs
)
3710 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3713 // SYS_freebsd11_fstatfs 397
3714 // int fstatfs(int fd, struct statfs *buf);
3715 PRE(sys_freebsd11_fstatfs
)
3717 PRINT("sys_fstatfs ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
3718 PRE_REG_READ2(int, "fstatfs",
3719 unsigned int, fd
, struct statfs
*, buf
);
3720 PRE_MEM_WRITE( "fstatfs(buf)", ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3723 POST(sys_freebsd11_fstatfs
)
3725 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3728 // SYS_freebsd11_fhstatfs 398
3729 // int fhstatfs(const fhandle_t *fhp, struct statfs *buf);
3730 PRE(sys_freebsd11_fhstatfs
)
3732 PRINT("sys_fhstatfs ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
3733 PRE_REG_READ2(int, "fhstatfs",
3734 struct fhandle
*, fhp
, struct statfs
*, buf
);
3735 PRE_MEM_READ( "fhstatfs(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
3736 PRE_MEM_WRITE( "fhstatfs(buf)", ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3739 POST(sys_freebsd11_fhstatfs
)
3741 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3749 PRINT("sys_getfsstat ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
3750 PRE_REG_READ3(int, "getfsstat", struct vki_freebsd11_statfs
*, buf
, long, bufsize
, int, mode
);
3751 PRE_MEM_WRITE( "getfsstat(buf)", ARG1
, ARG2
);
3757 if ((Word
)RES
!= -1) {
3758 POST_MEM_WRITE( ARG1
, RES
* sizeof(struct vki_freebsd11_statfs
) );
3764 PRINT("sys_statfs ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
3765 PRE_REG_READ2(int, "statfs", const char *, path
, struct statfs
*, buf
);
3766 PRE_MEM_RASCIIZ( "statfs(path)", ARG1
);
3767 PRE_MEM_WRITE( "statfs(buf)", ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3772 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3777 PRINT("sys_fstatfs ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
3778 PRE_REG_READ2(int, "fstatfs",
3779 unsigned int, fd
, struct statfs
*, buf
);
3780 PRE_MEM_WRITE( "fstatfs(buf)", ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3785 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3790 PRINT("sys_fhstatfs ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
3791 PRE_REG_READ2(int, "fhstatfs",
3792 struct fhandle
*, fhp
, struct statfs
*, buf
);
3793 PRE_MEM_READ( "fhstatfs(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
3794 PRE_MEM_WRITE( "fhstatfs(buf)", ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3799 POST_MEM_WRITE( ARG2
, sizeof(struct vki_freebsd11_statfs
) );
3805 // SYS_ksem_close 400
3808 // SYS_ksem_post 401
3811 // SYS_ksem_wait 402
3814 // SYS_ksem_trywait 403
3817 // SYS_ksem_init 404
3820 // SYS_ksem_open 405
3823 // SYS_ksem_unlink 406
3826 // SYS_ksem_getvalue 407
3829 // SYS_ksem_destroy 408
3832 // SYS___mac_get_pid 409
3835 // SYS___mac_get_link 410
3838 // SYS___mac_set_link 411
3841 // SYS_extattr_set_link 412
3842 // ssize_t extattr_set_link(const char *path, int attrnamespace,
3843 // const char *attrname, const void *data, size_t nbytes);
3844 PRE(sys_extattr_set_link
)
3846 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
);
3847 PRE_REG_READ5(ssize_t
, "extattr_set_link",
3848 const char *, path
, int, attrnamespace
, const char *, attrname
, const void *, data
, size_t, nbytes
);
3849 PRE_MEM_RASCIIZ("extattr_set_link(path)", ARG1
);
3850 PRE_MEM_RASCIIZ("extattr_set_link(attrname)", ARG3
);
3851 PRE_MEM_READ("extattr_set_link(data)", ARG4
, ARG5
);
3854 // SYS_extattr_get_link 413
3855 // ssize_t extattr_get_link(const char *path, int attrnamespace,
3856 // const char *attrname, void *data, size_t nbytes);
3857 PRE(sys_extattr_get_link
)
3859 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
);
3860 PRE_REG_READ5(ssize_t
, "extattr_get_link",
3861 const char *, path
, int, attrnamespace
, const char *, attrname
, void *, data
, size_t, nbytes
);
3862 PRE_MEM_RASCIIZ("extattr_get_link(path)", ARG1
);
3863 PRE_MEM_RASCIIZ("extattr_get_link(attrname)", ARG3
);
3865 PRE_MEM_WRITE("extattr_get_link(data)", ARG4
, ARG5
);
3869 POST(sys_extattr_get_link
)
3872 POST_MEM_WRITE(ARG4
, ARG5
);
3876 // SYS_extattr_delete_link 414
3877 // int extattr_delete_link(const char *path, int attrnamespace,
3878 // const char *attrname);
3879 PRE(sys_extattr_delete_link
)
3881 PRINT("sys_extattr_delete_link ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", ARG1
,SARG2
,ARG3
);
3882 PRE_REG_READ3(ssize_t
, "extattr_delete_link",
3883 const char *, path
, int, attrnamespace
, const char *, attrname
);
3884 PRE_MEM_RASCIIZ("extattr_delete_link(path)", ARG1
);
3885 PRE_MEM_RASCIIZ("extattr_delete_link(attrname)", ARG3
);
3888 // SYS___mac_execve 415
3891 // SYS_sigaction 416
3892 //int sigaction(int sig, const struct sigaction * restrict act,
3893 // struct sigaction * restrict oact);
3896 vki_sigaction_toK_t
new;
3897 vki_sigaction_toK_t
*newp
;
3898 vki_sigaction_fromK_t old
;
3899 vki_sigaction_fromK_t
*oldp
;
3901 PRINT("sys_sigaction ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
3903 PRE_REG_READ3(long, "sigaction",
3904 int, sign
, const struct sigaction
*, act
,
3905 struct sigaction
*, oact
);
3910 struct vki_sigaction
*sa
= (struct vki_sigaction
*)ARG2
;
3911 PRE_MEM_READ( "sigaction(act->sa_handler)", (Addr
)&sa
->ksa_handler
, sizeof(sa
->ksa_handler
));
3912 PRE_MEM_READ( "sigaction(act->sa_mask)", (Addr
)&sa
->sa_mask
, sizeof(sa
->sa_mask
));
3913 PRE_MEM_READ( "sigaction(act->sa_flags)", (Addr
)&sa
->sa_flags
, sizeof(sa
->sa_flags
));
3917 PRE_MEM_WRITE( "sigaction(oact)", ARG3
, sizeof(struct vki_sigaction
));
3922 && ! ML_(safe_to_deref
)((void *)(Addr
)ARG2
,
3923 sizeof(struct vki_sigaction
))) {
3924 VG_(umsg
)("Warning: bad act handler address %p in sigaction()\n",
3925 (void *)(Addr
)ARG2
);
3926 SET_STATUS_Failure ( VKI_EFAULT
);
3927 } else if ((ARG3
!= 0
3928 && ! ML_(safe_to_deref
)((void *)(Addr
)ARG3
,
3929 sizeof(struct vki_sigaction
)))) {
3930 VG_(umsg
)("Warning: bad oact handler address %p in sigaction()\n",
3931 (void *)(Addr
)ARG3
);
3932 SET_STATUS_Failure ( VKI_EFAULT
);
3935 struct vki_sigaction
*oldnew
=
3936 (struct vki_sigaction
*)(Addr
)ARG2
;
3938 new.ksa_handler
= oldnew
->ksa_handler
;
3939 new.sa_flags
= oldnew
->sa_flags
;
3940 new.sa_mask
= oldnew
->sa_mask
;
3944 SET_STATUS_from_SysRes( VG_(do_sys_sigaction
)(ARG1
, newp
, oldp
) );
3946 if (ARG3
!= 0 && SUCCESS
&& RES
== 0) {
3947 struct vki_sigaction
*oldold
=
3948 (struct vki_sigaction
*)(Addr
)ARG3
;
3950 oldold
->ksa_handler
= oldp
->ksa_handler
;
3951 oldold
->sa_flags
= oldp
->sa_flags
;
3952 oldold
->sa_mask
= oldp
->sa_mask
;
3960 if (RES
== 0 && ARG3
!= 0) {
3961 POST_MEM_WRITE( ARG3
, sizeof(struct vki_sigaction
));
3965 // SYS_sigreturn 417
3968 // SYS_getcontext 421
3969 // SYS_setcontext 422
3970 // SYS_swapcontext 423
3973 POST(sys_getcontext
)
3975 POST_MEM_WRITE( ARG1
, sizeof(struct vki_ucontext
) );
3978 POST(sys_swapcontext
)
3981 POST_MEM_WRITE( ARG1
, sizeof(struct vki_ucontext
) );
3985 #if (FREEBSD_VERS >= FREEBSD_13_1)
3986 // SYS_freebsd13_swapoff 424
3987 // int swapoff(const char *special);
3988 PRE(sys_freebsd13_swapoff
)
3990 PRINT("sys_freebsd13_swapoff ( %#" FMT_REGWORD
"x(%s) )", ARG1
,(char *)ARG1
);
3991 PRE_REG_READ1(int, "swapoff", const char *, special
);
3992 PRE_MEM_RASCIIZ( "swapoff(special)", ARG1
);
3996 // int swapoff(const char *special);
3999 PRINT("sys_swapoff ( %#" FMT_REGWORD
"x(%s) )", ARG1
,(char *)ARG1
);
4000 PRE_REG_READ1(int, "swapoff", const char *, special
);
4001 PRE_MEM_RASCIIZ( "swapoff(special)", ARG1
);
4005 // SYS___acl_get_link 425
4006 // int __acl_get_link(const char *path, acl_type_t type, struct acl *aclp);
4007 PRE(sys___acl_get_link
)
4009 PRINT("sys___acl_get_link ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
,ARG3
);
4010 PRE_REG_READ3(int, "__acl_get_link",
4011 const char *, path
, int, acltype
, struct vki_acl
*, aclp
);
4012 PRE_MEM_RASCIIZ( "__acl_get_link(path)", ARG1
);
4013 PRE_MEM_WRITE( "__acl_get_link(aclp)", ARG3
, sizeof(struct vki_acl
) );
4016 POST(sys___acl_get_link
)
4020 POST_MEM_WRITE( ARG3
, sizeof(struct vki_acl
) );
4024 // SYS___acl_set_link 426
4025 // int __acl_set_link(const char *path, acl_type_t type, struct acl *aclp);
4026 PRE(sys___acl_set_link
)
4028 PRINT("sys___acl_set_link ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
,ARG3
);
4029 PRE_REG_READ3(int, "__acl_set_link",
4030 const char *, path
, int, acltype
, struct vki_acl
*, aclp
);
4031 PRE_MEM_RASCIIZ( "__acl_set_link(path)", ARG1
);
4032 PRE_MEM_READ( "__acl_set_link(aclp)", ARG3
, sizeof(struct vki_acl
) );
4034 // SYS___acl_delete_link 427
4035 // int __acl_delete_link(const char *path, acl_type_t type);
4036 PRE(sys___acl_delete_link
)
4038 PRINT("sys___acl_delete_link ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,(char *)ARG1
,ARG2
);
4039 PRE_MEM_RASCIIZ( "__acl_delete_link(path)", ARG1
);
4040 PRE_REG_READ2(int, "__acl_delete_link",
4041 const char *, path
, int, acltype
);
4044 // SYS___acl_aclcheck_link 428
4045 // int __acl_aclcheck_link(const char *path, acl_type_t type, struct acl *aclp);
4046 PRE(sys___acl_aclcheck_link
)
4048 PRINT("sys___acl_aclcheck_link ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,(char *)ARG1
,ARG2
,ARG3
);
4049 PRE_REG_READ3(long, "__acl_aclcheck_link",
4050 const char *, path
, int, acltype
, struct vki_acl
*, aclp
);
4051 PRE_MEM_RASCIIZ( "__acl_check_link(path)", ARG1
);
4052 PRE_MEM_READ( "__acl_aclcheck_link(aclp)", ARG3
, sizeof(struct vki_acl
) );
4056 // int sigwait(const sigset_t * restrict set, int * restrict sig);
4059 *flags
|= SfMayBlock
;
4060 PRINT("sys_sigwait ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
4062 PRE_REG_READ2(int, "sigwait",
4063 const vki_sigset_t
*, set
, int *, sig
);
4065 PRE_MEM_READ( "sigwait(set)", ARG1
, sizeof(vki_sigset_t
));
4068 PRE_MEM_WRITE( "sigwait(sig)", ARG2
, sizeof(int));
4075 POST_MEM_WRITE( ARG2
, sizeof(int));
4079 // SYS_thr_create 430
4081 // syscalls.master: int thr_create(_In_ ucontext_t *ctx, _Out_ long *id, int flags );
4084 PRINT( "sys_thr_create ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d )", ARG1
, ARG2
, SARG3
);
4085 PRE_REG_READ3(int, "thr_create", /*ucontext_t*/void *, ctx
, long *, id
, int, flags
);
4087 VG_(message
)(Vg_UserMsg
, "thr_create() not implemented");
4088 VG_(unimplemented
)("Valgrind does not support thr_create().");
4090 SET_STATUS_Failure(VKI_ENOSYS
);
4094 // void thr_exit(long *state);
4099 PRINT( "sys_thr_exit ( %#" FMT_REGWORD
"x )", ARG1
);
4100 PRE_REG_READ1(void, "thr_exit", long *, state
);
4103 PRE_MEM_WRITE( "thr_exit(state)", ARG1
, sizeof(long) );
4106 tst
= VG_(get_ThreadState
)(tid
);
4107 tst
->exitreason
= VgSrc_ExitThread
;
4108 tst
->os_state
.exitcode
= ARG1
;
4109 SET_STATUS_Success(0);
4113 // int thr_self(long *id);
4116 PRINT( "sys_thr_self ( %#" FMT_REGWORD
"x )", ARG1
);
4117 PRE_REG_READ1(int, "thr_self", long *, id
);
4118 PRE_MEM_WRITE( "thr_self()", ARG1
, sizeof(long));
4123 POST_MEM_WRITE( ARG1
, sizeof(long));
4127 // int thr_kill(long id, int sig);
4130 PRINT("sys_thr_kill ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
,ARG2
);
4131 PRE_REG_READ2(long, "thr_kill", long, id
, int, sig
);
4132 if (!ML_(client_signal_OK
)(ARG2
)) {
4133 SET_STATUS_Failure( VKI_EINVAL
);
4137 /* Check to see if this kill gave us a pending signal */
4138 *flags
|= SfPollAfter
;
4140 if (VG_(clo_trace_signals
)) {
4141 VG_(message
)(Vg_DebugMsg
, "thr_kill: sending signal %lu to tid %lu\n",
4145 /* If we're sending SIGKILL, check to see if the target is one of
4146 our threads and handle it specially. */
4147 if (ARG2
== VKI_SIGKILL
&& ML_(do_sigkill
)(ARG1
, -1)) {
4148 SET_STATUS_Success(0);
4152 /* Ask to handle this syscall via the slow route, since that's the
4153 only one that sets tst->status to VgTs_WaitSys. If the result
4154 of doing the syscall is an immediate run of
4155 async_signalhandler() in m_signals, then we need the thread to
4156 be properly tidied away. I have the impression the previous
4157 version of this wrapper worked on x86/amd64 only because the
4158 kernel did not immediately deliver the async signal to this
4159 thread (on ppc it did, which broke the assertion re tst->status
4160 at the top of async_signalhandler()). */
4161 *flags
|= SfMayBlock
;
4166 if (VG_(clo_trace_signals
)) {
4167 VG_(message
)(Vg_DebugMsg
, "thr_kill: sent signal %lu to tid %lu\n",
4172 #if (FREEBSD_VERS <= FREEBSD_10)
4173 // SYS__umtx_lock 434
4176 PRINT( "sys__umtx_lock ( %#" FMT_REGWORD
"x )", ARG1
);
4177 PRE_REG_READ1(long, "_umtx_lock", struct vki_umtx
*, umtx
);
4178 PRE_MEM_READ( "_umtx_lock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4179 PRE_MEM_WRITE( "_umtx_lock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4182 POST(sys__umtx_lock
)
4185 POST_MEM_WRITE(ARG1
, sizeof(struct vki_umtx
));
4189 // SYS__umtx_unlock 434
4190 PRE(sys__umtx_unlock
)
4192 PRINT( "sys__umtx_unlock ( %#" FMT_REGWORD
"x )", ARG1
);
4193 PRE_REG_READ1(long, "_umtx_unlock", struct vki_umtx
*, umtx
);
4194 PRE_MEM_READ( "_umtx_unlock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4195 PRE_MEM_WRITE( "_umtx_unlock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4198 POST(sys__umtx_unlock
)
4201 POST_MEM_WRITE(ARG1
, sizeof(struct vki_umtx
));
4206 // SYS_jail_attach 436
4207 // int jail_attach(int jid);
4208 PRE(sys_jail_attach
)
4210 PRINT("sys_jail_attach ( %" FMT_REGWORD
"d )", SARG1
);
4211 PRE_REG_READ1(int, "jail_attach", int, jid
);
4214 // SYS_extattr_list_fd 437
4215 // ssize_t extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes);
4216 PRE(sys_extattr_list_fd
)
4218 PRINT("extattr_list_fd ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", SARG1
, SARG2
, ARG3
, ARG4
);
4219 PRE_REG_READ4(ssize_t
, "extattr_list_fd", int, id
, int, attrnamespace
, void *,data
, size_t, nbytes
);
4220 PRE_MEM_WRITE("extattr_list_fd(data)", ARG3
, ARG4
);
4223 POST(sys_extattr_list_fd
)
4225 POST_MEM_WRITE(ARG3
, ARG4
);
4228 // SYS_extattr_list_file 438
4229 // ssize_t extattr_list_file(const char *path, int attrnamespace, void *data,
4231 PRE(sys_extattr_list_file
)
4233 PRINT("extattr_list_file ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, SARG2
, ARG3
, ARG4
);
4234 PRE_REG_READ4(ssize_t
, "extattr_list_file", const char *, path
, int, attrnamespace
, void *,data
, size_t, nbytes
);
4235 PRE_MEM_RASCIIZ("extattr_list_file(path)", ARG1
);
4236 PRE_MEM_WRITE("extattr_list_file(data)", ARG3
, ARG4
);
4239 POST(sys_extattr_list_file
)
4241 POST_MEM_WRITE(ARG3
, ARG4
);
4244 // SYS_extattr_list_link 439
4245 // ssize_t extattr_get_link(const char *path, int attrnamespace,
4246 // const char *attrname, void *data, size_t nbytes);
4247 PRE(sys_extattr_list_link
)
4249 PRINT("extattr_list_link ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, SARG2
, ARG3
, ARG4
);
4250 PRE_REG_READ4(ssize_t
, "extattr_list_link", const char *, path
, int, attrnamespace
, void *,data
, size_t, nbytes
);
4251 PRE_MEM_RASCIIZ("extattr_list_link(path)", ARG1
);
4252 PRE_MEM_WRITE("extattr_list_link(data)", ARG3
, ARG4
);
4255 POST(sys_extattr_list_link
)
4257 POST_MEM_WRITE(ARG3
, ARG4
);
4260 // SYS_ksem_timedwait 441
4263 // SYS_thr_suspend 442
4264 // int thr_suspend(struct timespec *timeout);
4265 PRE(sys_thr_suspend
)
4267 PRINT("sys_thr_suspend ( %#" FMT_REGWORD
"x )", ARG1
);
4268 PRE_REG_READ1(int, "thr_suspend", struct timespec
*, timeout
);
4269 PRE_MEM_READ("thr_suspend(timeout)", ARG1
, sizeof(struct vki_timespec
));
4271 VG_(message
)(Vg_UserMsg
, "thr_supend() not implemented");
4272 VG_(unimplemented
)("Valgrind does not support thr_suspend().");
4274 SET_STATUS_Failure(VKI_ENOSYS
);
4278 // int thr_wake(long id);
4281 PRINT("sys_thr_wake ( %" FMT_REGWORD
"d )", SARG1
);
4282 PRE_REG_READ1(long, "thr_wake", long, id
);
4284 if (VG_(is_valid_tid)(ARG1)) {
4285 VG_(threads)[ARG1].status = VgTs_Runnable;
4287 SET_STATUS_Failure( VKI_ESRCH );
4292 // SYS_kldunloadf 444
4293 // int kldunloadf(int fileid, int flags);
4296 PRINT("sys_kldunloadf ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d )", SARG1
, SARG2
);
4297 PRE_REG_READ2(int, "kldunloadf", int, fileid
, int, flags
);
4301 // int audit(const char *record, u_int length);
4305 // int auditon(int cmd, void *data, u_int length);
4309 // int getauid(au_id_t *auid);
4313 // int setauid(au_id_t *auid);
4317 // int getaudit(auditinfo_t *auditinfo);
4321 // int setaudit(auditinfo_t *auditinfo);
4324 // SYS_getaudit_addr 451
4325 // int getaudit_addr(auditinfo_addr_t *auditinfo_addr, u_int length);
4328 // SYS_setaudit_addr 452
4329 // int setaudit_addr(auditinfo_addr_t *auditinfo_addr, u_int length);
4336 // int _umtx_op(void *obj, int op, u_long val, void *uaddr, void *uaddr2);
4339 /* 5 args are always passed through. The last two can vary, but
4340 they're always pointers. They may not be used though. */
4342 case VKI_UMTX_OP_LOCK
:
4343 // marked as COMPAT10
4344 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, LOCK, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4345 PRE_REG_READ5(long, "_umtx_op_lock",
4346 struct umtx
*, obj
, int, op
, unsigned long, id
,
4347 size_t, timeout_size
, struct vki_timespec
*, timeout
);
4348 PRE_MEM_READ( "_umtx_op_lock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4350 PRE_MEM_READ( "_umtx_op_lock(timespec)", ARG5
, ARG4
);
4352 PRE_MEM_WRITE( "_umtx_op_lock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4353 *flags
|= SfMayBlock
;
4355 case VKI_UMTX_OP_UNLOCK
:
4356 // marked as COMPAT10
4357 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, UNLOCK, %" FMT_REGWORD
"u)", ARG1
, ARG3
);
4358 PRE_REG_READ3(long, "_umtx_op_unlock",
4359 struct umtx
*, obj
, int, op
, unsigned long, id
);
4360 PRE_MEM_READ( "_umtx_op_unlock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4361 PRE_MEM_WRITE( "_umtx_op_unlock(mtx)", ARG1
, sizeof(struct vki_umtx
) );
4363 case VKI_UMTX_OP_WAIT
:
4364 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, WAIT, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4365 PRE_REG_READ5(long, "_umtx_op_wait",
4366 long *, obj
, int, op
, unsigned long, val
,
4367 size_t, timeout_size
, struct vki_timespec
*, timeout
);
4369 PRE_MEM_READ( "_umtx_op_wait(val)", ARG1
, sizeof(long) );
4370 if (*(long*)ARG1
== (long)ARG3
) {
4371 *flags
|= SfMayBlock
;
4376 PRE_MEM_READ( "_umtx_op_wait(timeout)", ARG5
, ARG4
);
4380 case VKI_UMTX_OP_WAKE
:
4381 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, WAKE, %" FMT_REGWORD
"u)", ARG1
, ARG3
);
4382 PRE_REG_READ3(long, "_umtx_op_wake",
4383 vki_uintptr_t
*, obj
, int, op
, int, val
);
4384 // PJF I don't think that the value of obj gets read, the address is being used as a key
4385 //PRE_MEM_READ("_umtx_op_wake(obj)", ARG1, sizeof(vki_uintptr_t));
4387 case VKI_UMTX_OP_MUTEX_TRYLOCK
:
4388 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, MUTEX_TRYLOCK, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4389 PRE_REG_READ2(long, "_umtx_op_mutex_trylock", struct umutex
*, obj
, int, op
);
4390 PRE_MEM_READ( "_umtx_op_mutex_trylock(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4391 PRE_MEM_WRITE( "_umtx_op_mutex_trylock(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4392 /* not too sure about the restart here
4393 * it's hard to test as if the mutex is locked this returns EBUSY
4394 * so there is only a small window where the syscall could be interrupted */
4395 *flags
|= SfMayBlock
| SfKernelRestart
;
4397 case VKI_UMTX_OP_MUTEX_LOCK
:
4398 // called by pthread_mutex_lock
4399 // when the atribute UMUTEX_PRIO_PROTECT or UMUTEX_PRIO_INHERIT is set
4400 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, MUTEX_LOCK, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4401 PRE_REG_READ5(long, "_umtx_op_mutex_lock",
4402 struct umutex
*, obj
, int, op
, unsigned long, noid
,
4403 size_t, timeout_size
, struct vki_timespec
*, timeout
);
4404 PRE_MEM_READ( "_umtx_op_mutex_lock(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4406 PRE_MEM_READ( "_umtx_op_mutex_lock(timespec)", ARG5
, ARG4
);
4408 *flags
|= SfKernelRestart
;
4410 PRE_MEM_WRITE( "_umtx_op_mutex_lock(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4411 *flags
|= SfMayBlock
;
4413 case VKI_UMTX_OP_MUTEX_UNLOCK
:
4414 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, MUTEX_UNLOCK)", ARG1
);
4415 PRE_REG_READ2(long, "_umtx_op_mutex_unlock",
4416 struct umutex
*, obj
, int, op
);
4417 PRE_MEM_READ( "_umtx_op_mutex_unlock(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4418 PRE_MEM_WRITE( "_umtx_op_mutex_unlock(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4420 case VKI_UMTX_OP_SET_CEILING
:
4421 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, SET_CEILING, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
);
4422 PRE_REG_READ4(long, "_umtx_op_set_ceiling",
4423 struct umutex
*, obj
, int, op
, unsigned int, ceiling
,
4424 unsigned int *, old_ceiling
);
4425 PRE_MEM_READ( "_umtx_op_set_ceiling(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4426 PRE_MEM_WRITE( "_umtx_op_set_ceiling(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4428 PRE_MEM_WRITE( "_umtx_op_set_ceiling(old_ceiling)", ARG4
, sizeof(vki_uint32_t
) );
4431 case VKI_UMTX_OP_CV_WAIT
:
4432 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, CV_WAIT, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4433 PRE_REG_READ5(long, "_umtx_op_cv_wait",
4434 struct ucond
*, obj
, int, op
, unsigned long, wflags
,
4435 struct umutex
*, umtx
, struct vki_timespec
*, timeout
);
4436 PRE_MEM_READ( "_umtx_op_cv_wait(cond)", ARG1
, sizeof(struct vki_ucond
) );
4437 PRE_MEM_WRITE( "_umtx_op_cv_wait(cond)", ARG1
, sizeof(struct vki_ucond
) );
4438 PRE_MEM_READ( "_umtx_op_cv_wait(mutex)", ARG4
, sizeof(struct vki_umutex
) );
4439 PRE_MEM_WRITE( "_umtx_op_cv_wait(mutex)", ARG4
, sizeof(struct vki_umutex
) );
4441 PRE_MEM_READ( "_umtx_op_cv_wait(timespec)", ARG5
, sizeof(struct vki_timespec
) );
4443 *flags
|= SfMayBlock
;
4445 case VKI_UMTX_OP_CV_SIGNAL
:
4446 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, CV_SIGNAL)", ARG1
);
4447 PRE_REG_READ2(long, "_umtx_op_cv_signal",
4448 struct ucond
*, obj
, int, op
);
4449 PRE_MEM_READ( "_umtx_op_cv_signal(cond)", ARG1
, sizeof(struct vki_ucond
) );
4450 PRE_MEM_WRITE( "_umtx_op_cv_signal(cond)", ARG1
, sizeof(struct vki_ucond
) );
4452 case VKI_UMTX_OP_CV_BROADCAST
:
4453 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, CV_BROADCAST, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4454 PRE_REG_READ2(long, "_umtx_op_cv_broadcast",
4455 struct ucond
*, obj
, int, op
);
4456 PRE_MEM_READ( "_umtx_op_cv_broadcast(cond)", ARG1
, sizeof(struct vki_ucond
) );
4457 PRE_MEM_WRITE( "_umtx_op_cv_broadcast(cond)", ARG1
, sizeof(struct vki_ucond
) );
4459 case VKI_UMTX_OP_WAIT_UINT
:
4460 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, CV_WAIT_UINT, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4461 PRE_REG_READ5(long, "_umtx_op_wait_uint",
4462 int *, obj
, int, op
, unsigned long, id
,
4463 size_t, timeout_wait
, struct vki_timespec
*, timeout
);
4464 PRE_MEM_READ( "_umtx_op_wait(uint)", ARG1
, sizeof(int) );
4466 PRE_MEM_READ( "_umtx_op_wait(timespec)", ARG5
, ARG4
);
4468 *flags
|= SfMayBlock
;
4470 case VKI_UMTX_OP_RW_RDLOCK
:
4471 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, RW_RDLOCK, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4472 PRE_REG_READ5(long, "_umtx_op_rw_rdlock",
4473 struct urwlock
*, obj
, int, op
, unsigned long, noid
,
4474 void *, zero
, struct vki_timespec
*, timeout
);
4475 PRE_MEM_READ( "_umtx_op_rw_rdlock(rw)", ARG1
, sizeof(struct vki_urwlock
) );
4476 PRE_MEM_WRITE( "_umtx_op_rw_rdlock(rw)", ARG1
, sizeof(struct vki_urwlock
) );
4477 *flags
|= SfMayBlock
;
4479 case VKI_UMTX_OP_RW_WRLOCK
:
4480 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, RW_WRLOCK, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4481 PRE_REG_READ5(long, "_umtx_op_rw_wrlock",
4482 struct urwlock
*, obj
, int, op
, unsigned long, noid
,
4483 void *, zero
, struct vki_timespec
*, timeout
);
4484 PRE_MEM_READ( "_umtx_op_rw_wrlock(rw)", ARG1
, sizeof(struct vki_urwlock
) );
4485 PRE_MEM_WRITE( "_umtx_op_rw_wrlock(rw)", ARG1
, sizeof(struct vki_urwlock
) );
4486 *flags
|= SfMayBlock
;
4488 case VKI_UMTX_OP_RW_UNLOCK
:
4489 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, RW_UNLOCK, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4490 PRE_REG_READ2(long, "_umtx_op_rw_unlock",
4491 struct urwlock
*, obj
, int, op
);
4492 PRE_MEM_READ( "_umtx_op_rw_unlock(rw)", ARG1
, sizeof(struct vki_urwlock
) );
4493 PRE_MEM_WRITE( "_umtx_op_rw_unlock(rw)", ARG1
, sizeof(struct vki_urwlock
) );
4495 case VKI_UMTX_OP_WAIT_UINT_PRIVATE
:
4496 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, CV_WAIT_UINT_PRIVATE, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4497 PRE_REG_READ5(long, "_umtx_op_wait_uint_private",
4498 int *, obj
, int, op
, unsigned long, id
,
4499 size_t, timeout_size
, struct vki_timespec
*, timeout
);
4500 PRE_MEM_READ( "_umtx_op_wait_private(uint)", ARG1
, sizeof(int) );
4502 PRE_MEM_READ( "_umtx_op_wait_private(umtx_time)", ARG5
, ARG4
);
4504 *flags
|= SfMayBlock
;
4506 case VKI_UMTX_OP_WAKE_PRIVATE
:
4507 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, CV_WAKE_PRIVATE, %" FMT_REGWORD
"u)", ARG1
, ARG3
);
4508 PRE_REG_READ3(long, "_umtx_op_wake_private",
4509 vki_uintptr_t
*, obj
, int, op
, int, val
);
4510 // PJF like OP_WAKE contents of obj not read
4511 //PRE_MEM_READ("_umtx_op_wake_private(obj)", ARG1, sizeof(vki_uintptr_t));
4513 case VKI_UMTX_OP_MUTEX_WAIT
:
4514 // pthread_mutex_lock without prio flags
4515 // does not need to be restarted
4516 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, MUTEX_WAIT, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4517 PRE_REG_READ2(long, "_umtx_op_mutex_wait",
4518 struct umutex
*, obj
, int, op
);
4519 PRE_MEM_READ( "_umtx_op_mutex_wait(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4520 PRE_MEM_WRITE( "_umtx_op_mutex_wait(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4521 *flags
|= SfMayBlock
;
4523 case VKI_UMTX_OP_MUTEX_WAKE
:
4524 // marked as deprecated
4525 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, MUTEX_WAKE, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4526 PRE_REG_READ2(long, "_umtx_op_mutex_wake",
4527 struct umutex
*, obj
, int, op
);
4528 PRE_MEM_READ( "_umtx_op_mutex_wake(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4529 PRE_MEM_WRITE( "_umtx_op_mutex_wake(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4531 case VKI_UMTX_OP_SEM_WAIT
:
4532 // marked as deprecated
4533 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, SEM_WAIT, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4534 PRE_REG_READ5(long, "_umtx_op_sem_wait",
4535 struct usem
*, obj
, int, op
, unsigned long, id
,
4536 size_t, timeout_size
, struct vki_timespec
*, timeout
);
4537 PRE_MEM_READ( "_umtx_op_sem_wait(usem)", ARG1
, sizeof(struct vki_usem
) );
4538 PRE_MEM_WRITE( "_umtx_op_sem_wait(usem)", ARG1
, sizeof(struct vki_usem
) );
4540 PRE_MEM_READ( "_umtx_op_sem_wait(umtx_time)", ARG5
, ARG4
);
4542 *flags
|= SfMayBlock
;
4544 case VKI_UMTX_OP_SEM_WAKE
:
4545 // marked as deprecated
4546 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, SEM_WAKE, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4547 PRE_REG_READ2(long, "_umtx_op_sem_wake",
4548 struct umutex
*, obj
, int, op
);
4549 PRE_MEM_READ( "_umtx_op_sem_wake(mutex)", ARG1
, sizeof(struct vki_usem
) );
4550 PRE_MEM_WRITE( "_umtx_op_sem_wake(mutex)", ARG1
, sizeof(struct vki_usem
) );
4552 case VKI_UMTX_OP_NWAKE_PRIVATE
:
4553 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, NWAKE_PRIVATE, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4554 PRE_REG_READ3(long, "_umtx_op_nwake_private",
4555 struct umutex
*, obj
, int, op
, int, count
);
4556 PRE_MEM_READ( "_umtx_op_nwake_private(mtxs)", ARG1
, ARG3
* sizeof(void *) );
4557 PRE_MEM_WRITE( "_umtx_op_mutex_wake(mtxs)", ARG1
, sizeof(struct vki_umutex
) );
4559 case VKI_UMTX_OP_MUTEX_WAKE2
:
4560 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, MUTEX_WAKE2, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4561 PRE_REG_READ3(long, "_umtx_op_mutex_wake2",
4562 struct umutex
*, obj
, int, op
, unsigned long, flags
);
4563 PRE_MEM_READ( "_umtx_op_mutex_wake(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4564 PRE_MEM_WRITE( "_umtx_op_mutex_wake(mutex)", ARG1
, sizeof(struct vki_umutex
) );
4566 case VKI_UMTX_OP_SEM2_WAIT
:
4567 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, SEM2_WAIT, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4568 PRE_REG_READ3(long, "_umtx_op_sem2_wake",
4569 struct _usem2
*, obj
, int, op
, unsigned long, flags
);
4570 PRE_MEM_READ( "_umtx_op_sem2_wait(mutex)", ARG1
, sizeof(struct vki_usem2
) );
4571 PRE_MEM_WRITE( "_umtx_op_sem2_wait(mutex)", ARG1
, sizeof(struct vki_usem2
) );
4572 *flags
|= SfMayBlock
;
4574 case VKI_UMTX_OP_SEM2_WAKE
:
4575 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, SEM2_WAKE, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4576 PRE_REG_READ3(long, "_umtx_op_sem2_wake",
4577 struct _usem2
*, obj
, int, op
, unsigned long, flags
);
4578 PRE_MEM_READ( "_umtx_op_sem2_wait(mutex)", ARG1
, sizeof(struct vki_usem2
) );
4579 PRE_MEM_WRITE( "_umtx_op_sem2_wait(mutex)", ARG1
, sizeof(struct vki_usem2
) );
4581 case VKI_UMTX_OP_SHM
:
4582 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, SHM, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4583 PRE_REG_READ4(long, "_umtx_op_shm",
4584 void *, obj
, int, op
, unsigned long, val
, void*, uaddr
);
4586 case VKI_UMTX_OP_ROBUST_LISTS
:
4587 // val (ARG2) ought to be the same as sizeof(struct vki_umtx_robust_lists_params)
4588 // then the structure contains a pointer to mutex structures
4589 if (ARG1
!= sizeof(struct vki_umtx_robust_lists_params
)) {
4590 SET_STATUS_Failure( VKI_ENOSYS
);
4592 PRINT( "sys__umtx_op ( %#" FMT_REGWORD
"x, ROBUST_LISTS, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x)", ARG1
, ARG3
, ARG4
, ARG5
);
4593 PRE_REG_READ3(long, "_umtx_op_robust_lists",
4594 struct umtx_robust_lists_params
*, obj
, int, op
, unsigned long, flags
);
4595 PRE_MEM_READ( "_umtx_op_robust_lists(mutex)", ARG3
, sizeof(struct vki_umtx_robust_lists_params
) );
4598 VG_(umsg
)("WARNING: _umtx_op unsupported value.\n");
4599 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
);
4607 case VKI_UMTX_OP_LOCK
:
4608 case VKI_UMTX_OP_UNLOCK
:
4610 POST_MEM_WRITE( ARG1
, sizeof(struct vki_umtx
) );
4613 case VKI_UMTX_OP_WAIT
:
4614 case VKI_UMTX_OP_WAKE
:
4615 case VKI_UMTX_OP_WAIT_UINT
:
4616 case VKI_UMTX_OP_WAIT_UINT_PRIVATE
:
4617 case VKI_UMTX_OP_WAKE_PRIVATE
:
4619 case VKI_UMTX_OP_MUTEX_TRYLOCK
:
4620 case VKI_UMTX_OP_MUTEX_LOCK
:
4621 case VKI_UMTX_OP_MUTEX_UNLOCK
:
4622 case VKI_UMTX_OP_MUTEX_WAIT
: /* Sets/clears contested bits */
4623 case VKI_UMTX_OP_MUTEX_WAKE
: /* Sets/clears contested bits */
4625 POST_MEM_WRITE( ARG1
, sizeof(vki_uintptr_t
) );
4628 case VKI_UMTX_OP_SET_CEILING
:
4630 POST_MEM_WRITE( ARG1
, sizeof(struct vki_umutex
) );
4632 POST_MEM_WRITE( ARG4
, sizeof(vki_uint32_t
) );
4636 case VKI_UMTX_OP_CV_WAIT
:
4638 POST_MEM_WRITE( ARG1
, sizeof(struct vki_ucond
) );
4639 POST_MEM_WRITE( ARG4
, sizeof(struct vki_umutex
) );
4642 case VKI_UMTX_OP_CV_SIGNAL
:
4643 case VKI_UMTX_OP_CV_BROADCAST
:
4645 POST_MEM_WRITE( ARG1
, sizeof(struct vki_ucond
) );
4648 case VKI_UMTX_OP_RW_RDLOCK
:
4649 case VKI_UMTX_OP_RW_WRLOCK
:
4650 case VKI_UMTX_OP_RW_UNLOCK
:
4652 POST_MEM_WRITE( ARG1
, sizeof(struct vki_urwlock
) );
4655 case VKI_UMTX_OP_SEM2_WAIT
:
4656 case VKI_UMTX_OP_SEM2_WAKE
:
4658 POST_MEM_WRITE( ARG1
, sizeof(struct vki_usem2
) );
4661 case VKI_UMTX_OP_SHM
:
4662 case VKI_UMTX_OP_ROBUST_LISTS
:
4672 // int sigqueue(pid_t pid, int signo, const union sigval value);
4675 PRINT("sys_sigqueue ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",
4677 PRE_REG_READ3(int, "sigqueue", vki_pid_t
, pid
, int, signo
, const union vki_sigval
, value
);
4681 // mqd_t mq_open(const char *name, int oflag, ...);
4682 // int kmq_open(_In_z_ const char *path, int flags, mode_t mode, _In_opt_ const struct mq_attr *attr);
4685 if (ARG2
& VKI_O_CREAT
) {
4686 PRINT("sys_kmq_open( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %hu, %#" FMT_REGWORD
"x )",
4687 ARG1
,(char *)ARG1
,ARG2
,(vki_mode_t
)ARG3
,ARG4
);
4688 PRE_REG_READ4(long, "mq_open",
4689 const char *, name
, int, oflag
, vki_mode_t
, mode
,
4690 struct mq_attr
*, attr
);
4692 PRINT("sys_kmq_open( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %hu)",
4693 ARG1
,(char *)ARG1
,ARG2
,(vki_mode_t
)ARG3
);
4694 PRE_REG_READ3(long, "mq_open",
4695 const char *, name
, int, oflag
, vki_mode_t
, mode
);
4697 PRE_MEM_RASCIIZ( "mq_open(name)", ARG1
);
4698 if (ARG2
& VKI_O_CREAT
) {
4699 PRE_MEM_READ("mq_open(attr)", ARG4
, sizeof(struct vki_mq_attr
));
4700 if (ML_(safe_to_deref
)((struct vki_mq_attr
*)ARG4
, sizeof(struct vki_mq_attr
))) {
4701 const struct vki_mq_attr
*attr
= (struct vki_mq_attr
*)ARG4
;
4702 PRE_MEM_READ("mq_open(attr->mq_maxmsg)",
4703 (Addr
)&attr
->mq_maxmsg
, sizeof(attr
->mq_maxmsg
) );
4704 PRE_MEM_READ("mq_open(attr->mq_msgsize)",
4705 (Addr
)&attr
->mq_msgsize
, sizeof(attr
->mq_msgsize
) );
4713 if (!ML_(fd_allowed
)(RES
, "mq_open", tid
, True
)) {
4715 SET_STATUS_Failure( VKI_EMFILE
);
4717 if (VG_(clo_track_fds
)) {
4718 ML_(record_fd_open_with_given_name
)(tid
, RES
, (const HChar
*)ARG1
);
4723 // SYS_kmq_setattr 458
4724 // int mq_setattr(mqd_t mqdes, const struct mq_attr *restrict mqstat,
4725 // struct mq_attr *restrict omqstat);
4726 PRE(sys_kmq_setattr
)
4728 PRINT("sys_kmq_getattr( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
,ARG2
,ARG3
);
4729 PRE_REG_READ3(int, "mq_setattr",
4730 vki_mqd_t
, mqdes
, const struct mq_attr
*, mqstat
,
4731 struct mq_attr
*, omqstat
);
4732 if (!ML_(fd_allowed
)(ARG1
, "mq_getattr", tid
, False
)) {
4733 SET_STATUS_Failure( VKI_EBADF
);
4735 if (ML_(safe_to_deref
)((struct vki_mq_attr
*)ARG2
, sizeof(struct vki_mq_attr
))) {
4736 const struct vki_mq_attr
*attr
= (struct vki_mq_attr
*)ARG2
;
4737 PRE_MEM_READ( "mq_setattr(mqstat->mq_flags)",
4738 (Addr
)&attr
->mq_flags
, sizeof(attr
->mq_flags
) );
4740 PRE_MEM_WRITE( "mq_setattr(omqstat)", ARG3
,
4741 sizeof(struct vki_mq_attr
) );
4745 // SYS_kmq_timedreceive 459
4746 // ssize_t mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
4747 // unsigned *msg_prio, const struct timespec *abs_timeout);
4748 PRE(sys_kmq_timedreceive
)
4750 *flags
|= SfMayBlock
;
4751 PRINT("sys_kmq_timedreceive( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %llu, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
4752 ARG1
,ARG2
,(ULong
)ARG3
,ARG4
,ARG5
);
4753 PRE_REG_READ5(ssize_t
, "mq_timedreceive",
4754 vki_mqd_t
, mqdes
, char *, msg_ptr
, vki_size_t
, msg_len
,
4755 unsigned int *, msg_prio
,
4756 const struct timespec
*, abs_timeout
);
4757 if (!ML_(fd_allowed
)(ARG1
, "mq_timedreceive", tid
, False
)) {
4758 SET_STATUS_Failure( VKI_EBADF
);
4760 PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", ARG2
, ARG3
);
4762 PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
4763 ARG4
, sizeof(unsigned int) );
4766 PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
4767 ARG5
, sizeof(struct vki_timespec
) );
4772 POST(sys_kmq_timedreceive
)
4774 POST_MEM_WRITE( ARG2
, ARG3
);
4776 POST_MEM_WRITE( ARG4
, sizeof(unsigned int) );
4780 // SYS_kmq_timedsend 460
4781 // int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
4782 // unsigned msg_prio, const struct timespec *abs_timeout);
4783 PRE(sys_kmq_timedsend
)
4785 *flags
|= SfMayBlock
;
4786 PRINT("sys_kmq_timedsend ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %llu, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",
4787 ARG1
,ARG2
,(ULong
)ARG3
,ARG4
,ARG5
);
4788 PRE_REG_READ5(int, "mq_timedsend",
4789 vki_mqd_t
, mqdes
, const char *, msg_ptr
, vki_size_t
, msg_len
,
4790 unsigned int, msg_prio
, const struct timespec
*, abs_timeout
);
4791 if (!ML_(fd_allowed
)(ARG1
, "mq_timedsend", tid
, False
)) {
4792 SET_STATUS_Failure( VKI_EBADF
);
4794 PRE_MEM_READ( "mq_timedsend(msg_ptr)", ARG2
, ARG3
);
4796 PRE_MEM_READ( "mq_timedsend(abs_timeout)", ARG5
,
4797 sizeof(struct vki_timespec
) );
4802 // SYS_kmq_notify 461
4803 // int mq_notify(mqd_t mqdes, const struct sigevent *notification);
4806 PRINT("sys_kmq_notify( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
,ARG2
);
4807 PRE_REG_READ2(int, "mq_notify",
4808 vki_mqd_t
, mqdes
, const struct sigevent
*, notification
);
4809 if (!ML_(fd_allowed
)(ARG1
, "mq_notify", tid
, False
)) {
4810 SET_STATUS_Failure( VKI_EBADF
);
4812 else if (ARG2
!= 0) {
4813 PRE_MEM_READ( "mq_notify(notification)",
4814 ARG2
, sizeof(struct vki_sigevent
) );
4818 // SYS_kmq_unlink 462
4819 // int kmq_unlink(const char *path);
4822 PRINT("sys_kmq_unlink ( %#" FMT_REGWORD
"x(%s) )", ARG1
,(char *)ARG1
);
4823 PRE_REG_READ1(int, "mq_unlink", const char *, name
);
4824 PRE_MEM_RASCIIZ( "mq_unlink(name)", ARG1
);
4828 // void abort2(const char *why, int nargs, void **args);
4831 PRINT( "sys_abort2 ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", ARG1
, SARG2
, ARG3
);
4832 PRE_REG_READ3(void, "abort2", const char *, why
, int, nargs
, void **, args
);
4833 // max length of 'why' is 128
4834 PRE_MEM_RASCIIZ( "abort2(why)", ARG2
);
4835 // max val for nargs is 16
4836 PRE_MEM_READ("abort2(args", ARG3
, ARG2
*sizeof(void*));
4839 // SYS_thr_set_name 464
4840 // int thr_set_name(long id, const char *name);
4841 PRE(sys_thr_set_name
)
4843 PRINT( "sys_thr_set_name ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
, ARG2
);
4844 PRE_REG_READ2(int, "thr_set_name", long, id
, const char *, name
);
4845 PRE_MEM_RASCIIZ( "thr_set_name(name)", ARG2
);
4847 if (ML_(safe_to_deref
)((void*)ARG2
, 1)) {
4848 const HChar
* new_name
= (const HChar
*) (Addr
)ARG2
;
4849 ThreadState
* tst
= VG_(get_ThreadState
)(tid
);
4850 SizeT new_len
= VG_(strnlen
)(new_name
, VKI_MAXCOMLEN
+1);
4851 tst
->thread_name
= VG_(realloc
)("syswrap.thr_set_name", tst
->thread_name
, new_len
+ 1);
4852 VG_(strlcpy
)(tst
->thread_name
, new_name
, new_len
+ 1);
4856 // SYS_aio_fsync 465
4857 // int aio_fsync(int op, struct aiocb *iocb);
4860 PRINT("aio_fsync ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
,ARG2
);
4861 PRE_REG_READ2(int, "aio_fsync", int, op
, struct vki_aiocb
*, iocb
);
4862 PRE_MEM_READ( "aio_fsync(iocb)", ARG2
, sizeof(struct vki_aiocb
) );
4865 // SYS_rtprio_thread 466
4866 // int rtprio_thread(int function, lwpid_t lwpid, struct rtprio *rtp);
4867 PRE(sys_rtprio_thread
)
4869 PRINT( "sys_rtprio_thread ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", ARG1
, ARG2
, ARG3
);
4870 PRE_REG_READ3(int, "rtprio_thread",
4871 int, function
, __vki_lwpid_t
, lwpid
, struct vki_rtprio
*, rtp
);
4872 if (ARG1
== VKI_RTP_SET
) {
4873 PRE_MEM_READ( "rtprio_thread(rtp#set)", ARG3
, sizeof(struct vki_rtprio
));
4874 } else if (ARG1
== VKI_RTP_LOOKUP
) {
4875 PRE_MEM_WRITE( "rtprio_thread(rtp#lookup)", ARG3
, sizeof(struct vki_rtprio
));
4881 POST(sys_rtprio_thread
)
4883 if (ARG1
== VKI_RTP_LOOKUP
&& RES
== 0) {
4884 POST_MEM_WRITE( ARG3
, sizeof(struct vki_rtprio
));
4888 // SYS_sctp_peeloff 471
4889 // int sctp_peeloff(int s, sctp_assoc_t id);
4893 // SYS_sctp_generic_sendmsg 472
4894 // int sctp_generic_sendmsg(int s, void *msg, int msglen, struct sockaddr *to,
4895 // socklen_t len, struct sctp_sndrcvinfo *sinfo, int flags);
4897 // Not called directly from libc
4898 PRE(sys_sctp_generic_sendmsg
)
4900 *flags
|= SfMayBlock
;
4901 PRINT("sys_sctp_generic_sendmsg ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d )",SARG1
,ARG2
,SARG3
,ARG4
,SARG5
,ARG6
,SARG7
);
4902 PRE_REG_READ7(ssize_t
, "sctp_generic_sendmsg",
4903 int, s
, void *, msg
, int, msglen
,
4904 struct sockaddr
*, to
, socklen_t
, len
,
4905 struct sctp_sndrcvinfo
*, sinfo
, int, flags
);
4907 PRE_MEM_READ( "sctp_generic_sendmsg(msg)", ARG2
, ARG3
);
4909 ML_(pre_mem_read_sockaddr
) (tid
, "sctp_generic_sendmsg(to)", (struct vki_sockaddr
*)ARG4
, ARG5
);
4911 if (ARG6
!= (Addr
)NULL
) {
4912 PRE_MEM_READ( "sctp_generic_sendmsg(sinfo)", ARG6
, sizeof(struct vki_sctp_sndrcvinfo
));
4916 // SYS_sctp_generic_sendmsg_iov 473
4917 // int sctp_generic_sendmsg_iov(int s, struct iovec *iov, int iovlen,
4918 // struct sockaddr *to, struct sctp_sndrcvinfo *sinfo, int flags);
4921 // SYS_sctp_generic_recvmsg 474
4922 // int sctp_generic_recvmsg(int s, struct iovec *iov, int iovlen,
4923 // struct sockaddr *from, socklen_t *fromlen,
4924 // struct sctp_sndrcvinfo *sinfo, int *msgflags);
4926 // Not called directly from libc
4927 PRE(sys_sctp_generic_recvmsg
)
4929 *flags
|= SfMayBlock
;
4930 PRINT("sys_sctp_generic_recvmsg ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",SARG1
,ARG2
,SARG3
,ARG4
,ARG5
,ARG6
,ARG7
);
4931 PRE_REG_READ7(ssize_t
, "sctp_generic_recvmsg",
4932 int, s
, struct iovec
*, iov
, int, iovlen
,
4933 struct sockaddr
*, from
, socklen_t
*, fromlen
,
4934 struct sctp_sndrcvinfo
*, sinfo
, int *, msgflags
);
4936 // in the sctp_recvmsg libc wrapper this is always 1
4937 if ((Int
)ARG3
> 0) {
4938 PRE_MEM_READ( "sctp_generic_recvmsg(iov)", ARG2
, ARG3
* sizeof(struct vki_iovec
) );
4940 if (ML_(safe_to_deref
)((const void*)ARG2
, ARG3
* sizeof(struct vki_iovec
))) {
4941 struct vki_iovec
* iovec
= (struct vki_iovec
*)ARG2
;
4942 PRE_MEM_WRITE("sctp_generic_recvmsg(iov.iov_base)", (Addr
)iovec
->iov_base
, iovec
->iov_len
);
4945 if (ARG4
!= (Addr
)NULL
) {
4946 ML_(buf_and_len_pre_check
) (tid
, ARG4
, ARG5
,
4947 "sctp_generic_recvmsg(from)",
4948 "sctp_generic_recvmsg(fromlen_in)");
4951 if (ARG6
!= (Addr
)NULL
) {
4952 PRE_MEM_WRITE("sctp_generic_recvmsg(sinfo)", ARG6
, sizeof(struct vki_sctp_sndrcvinfo
));
4955 if (ARG7
!= (Addr
)NULL
) {
4956 PRE_MEM_WRITE("sctp_generic_recvmsg(msgflags)", ARG7
, sizeof(int));
4960 POST(sys_sctp_generic_recvmsg
)
4963 struct vki_iovec
* iovec
= (struct vki_iovec
*)ARG2
;
4964 POST_MEM_WRITE((Addr
)iovec
->iov_base
, iovec
->iov_len
);
4966 POST_MEM_WRITE( ARG2
, ARG3
*sizeof(struct vki_iovec
) );
4968 if (ARG4
!= (Addr
)NULL
) {
4969 ML_(buf_and_len_post_check
) (tid
, VG_(mk_SysRes_Success
)(RES
), ARG4
, ARG5
,
4970 "sctp_generic_recvmsg(fromlen_out)");
4973 if (ARG6
!= (Addr
)NULL
) {
4974 POST_MEM_WRITE(ARG6
, sizeof(struct vki_sctp_sndrcvinfo
));
4977 if (ARG7
!= (Addr
)NULL
) {
4978 POST_MEM_WRITE(ARG7
, sizeof(int));
4997 // SYS_ftruncate 480
5000 // SYS_thr_kill2 481
5001 // int thr_kill2(pid_t pid, long id, int sig);
5004 PRINT("sys_thr_kill2 ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
,ARG2
,ARG3
);
5005 PRE_REG_READ3(int, "thr_kill2", pid_t
, pid
, long, tid
, int, sig
);
5006 if (!ML_(client_signal_OK
)(ARG3
)) {
5007 SET_STATUS_Failure( VKI_EINVAL
);
5011 /* Check to see if this kill gave us a pending signal */
5012 *flags
|= SfPollAfter
;
5014 if (VG_(clo_trace_signals
)) {
5015 VG_(message
)(Vg_DebugMsg
, "thr_kill2: sending signal %lu to pid %lu/%lu\n",
5019 /* If we're sending SIGKILL, check to see if the target is one of
5020 our threads and handle it specially. */
5021 if (ARG3
== VKI_SIGKILL
&& ML_(do_sigkill
)(ARG2
, ARG1
)) {
5022 SET_STATUS_Success(0);
5026 /* Ask to handle this syscall via the slow route, since that's the
5027 only one that sets tst->status to VgTs_WaitSys. If the result
5028 of doing the syscall is an immediate run of
5029 async_signalhandler() in m_signals, then we need the thread to
5030 be properly tidied away. I have the impression the previous
5031 version of this wrapper worked on x86/amd64 only because the
5032 kernel did not immediately deliver the async signal to this
5033 thread (on ppc it did, which broke the assertion re tst->status
5034 at the top of async_signalhandler()). */
5035 *flags
|= SfMayBlock
;
5040 if (VG_(clo_trace_signals
)) {
5041 VG_(message
)(Vg_DebugMsg
, "thr_kill2: sent signal %lu to pid %lu/%lu\n",
5047 // int shm_open(const char *path, int flags, mode_t mode);
5050 PRE_REG_READ3(int, "shm_open",
5051 const char *, path
, int, flags
, vki_mode_t
, mode
);
5052 if (ARG1
== VKI_SHM_ANON
) {
5053 PRINT("sys_shm_open(%#" FMT_REGWORD
"x(SHM_ANON), %" FMT_REGWORD
"u, %hu)", ARG1
, ARG2
, (vki_mode_t
)ARG3
);
5055 PRINT("sys_shm_open(%#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %hu)", ARG1
, (HChar
*)ARG1
, ARG2
, (vki_mode_t
)ARG3
);
5056 PRE_MEM_RASCIIZ( "shm_open(path)", ARG1
);
5058 *flags
|= SfMayBlock
;
5064 if (!ML_(fd_allowed
)(RES
, "shm_open", tid
, True
)) {
5066 SET_STATUS_Failure( VKI_EMFILE
);
5068 if (VG_(clo_track_fds
)) {
5069 ML_(record_fd_open_with_given_name
)(tid
, RES
, (HChar
*)ARG1
);
5074 // SYS_shm_unlink 483
5075 // int shm_unlink(const char *path);
5078 PRINT("sys_shm_unlink(%#" FMT_REGWORD
"x(%s))", ARG1
, (char *)ARG1
);
5079 PRE_REG_READ1(int, "shm_unlink",
5080 const char *, path
);
5082 PRE_MEM_RASCIIZ( "shm_unlink(path)", ARG1
);
5084 *flags
|= SfMayBlock
;
5088 // int cpuset(cpusetid_t *setid);
5091 PRINT("sys_cpuset ( %#" FMT_REGWORD
"x )", ARG1
);
5092 PRE_REG_READ1(int, "cpuset", vki_cpusetid_t
*, setid
);
5093 PRE_MEM_WRITE("cpuset(setid)", ARG1
, sizeof(vki_cpusetid_t
));
5098 POST_MEM_WRITE(ARG1
, sizeof(vki_cpusetid_t
));
5101 // SYS_cpuset_setid 485
5104 // SYS_cpuset_getid 486
5107 // SYS_cpuset_getaffinity 487
5110 // SYS_cpuset_setaffinity 488
5113 // SYS_faccessat 489
5114 // int faccessat(int fd, const char *path, int mode, int flag);
5117 PRINT("sys_faccessat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5118 PRE_REG_READ3(int, "faccessat",
5119 int, fd
, const char *, path
, int, flag
);
5120 PRE_MEM_RASCIIZ( "faccessat(path)", ARG2
);
5124 // int fchmodat(int fd, const char *path, mode_t mode, int flag);
5127 PRINT("sys_fchmodat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5128 PRE_REG_READ4(int, "fchmodat",
5129 int, fd
, const char *, path
, vki_mode_t
, mode
, int, flag
);
5130 PRE_MEM_RASCIIZ( "fchmodat(path)", ARG2
);
5134 // int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag);
5137 PRINT("sys_fchownat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), 0x%" FMT_REGWORD
"x, 0x%" FMT_REGWORD
"x, %" FMT_REGWORD
"d )",
5138 ARG1
,ARG2
,(char*)ARG2
,ARG3
,ARG4
, SARG5
);
5139 PRE_REG_READ5(int, "fchownat",
5140 int, fd
, const char *, path
,
5141 vki_uid_t
, owner
, vki_gid_t
, group
, int, flag
);
5142 PRE_MEM_RASCIIZ( "fchownat(path)", ARG2
);
5146 // int fexecve(int fd, char *const argv[], char *const envp[]);
5149 PRINT("sys_fexecve ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
5151 PRE_REG_READ3(int, "fexecve",
5152 int, fd
, char * const *, argv
,
5153 char * const *, envp
);
5155 if (!ML_(fd_allowed
)(ARG1
, "fexecve", tid
, False
)) {
5156 SET_STATUS_Failure(VKI_EBADF
);
5162 if (VG_(resolve_filename
)(ARG1
, &fname
) == False
) {
5163 SET_STATUS_Failure(VKI_ENOENT
);
5167 struct vg_stat stats
;
5168 if (VG_(fstat
)(ARG1
, &stats
) != 0) {
5169 SET_STATUS_Failure(VKI_EACCES
);
5175 if (VG_(resolve_filemode
)(ARG1
, &openFlags
) == False
) {
5176 SET_STATUS_Failure(VKI_ENOENT
);
5181 * openFlags is in kernel FFLAGS format
5182 * (see /usr/include/sys/fcntl.h)
5183 * which alllows us to tell if RDONLY is set
5187 Bool isScript
= False
;
5190 res
= VG_(open
)(fname
, VKI_O_RDONLY
,
5191 VKI_S_IRUSR
|VKI_S_IRGRP
|VKI_S_IROTH
);
5192 if (sr_isError(res
)) {
5193 SET_STATUS_Failure(VKI_ENOENT
);
5198 VG_(read
)((Int
)sr_Res(res
), buf
, 2);
5199 VG_(close
)((Int
)sr_Res(res
));
5200 if (buf
[0] == '#' && buf
[1] == '!') {
5205 if (!(openFlags
& VKI_FREAD
)) {
5206 SET_STATUS_Failure(VKI_EACCES
);
5210 if (!((openFlags
& VKI_O_EXEC
) ||
5211 (stats
.mode
& (VKI_S_IXUSR
|VKI_S_IXGRP
|VKI_S_IXOTH
)))) {
5212 SET_STATUS_Failure(VKI_EACCES
);
5217 Addr arg_2
= (Addr
)ARG2
;
5218 Addr arg_3
= (Addr
)ARG3
;
5220 handle_pre_sys_execve(tid
, status
, (Addr
)fname
, arg_2
, arg_3
, FEXECVE
, False
);
5223 // SYS_freebsd11_fstatat 493
5224 // int fstatat(int fd, const char *path, struct stat *sb, int flag);
5225 #if (FREEBSD_VERS >= FREEBSD_12)
5226 PRE(sys_freebsd11_fstatat
)
5228 PRINT("sys_freebsd11_fstatat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )", ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5229 PRE_REG_READ4(int, "fstatat",
5230 int, fd
, const char *, path
, struct freebsd11_stat
*, buf
, int, flag
);
5231 PRE_MEM_RASCIIZ( "fstatat(path)", ARG2
);
5232 PRE_MEM_WRITE( "fstatat(sb)", ARG3
, sizeof(struct vki_freebsd11_stat
) );
5235 POST(sys_freebsd11_fstatat
)
5237 POST_MEM_WRITE( ARG3
, sizeof(struct vki_freebsd11_stat
) );
5242 PRINT("sys_fstatat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )", ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5243 PRE_REG_READ4(int, "fstatat",
5244 int, fd
, const char *, path
, struct stat
*, buf
, int, flag
);
5245 PRE_MEM_RASCIIZ( "fstatat(path)", ARG2
);
5246 PRE_MEM_WRITE( "fstatat(sb)", ARG3
, sizeof(struct vki_freebsd11_stat
) );
5251 POST_MEM_WRITE( ARG3
, sizeof(struct vki_freebsd11_stat
) );
5255 // SYS_futimesat 494
5256 // int futimesat(int fd, const char *path, const struct timeval times[2]);
5259 PRINT("sys_futimesat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )", ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5260 PRE_REG_READ3(int, "futimesat",
5261 int, fd
, const char *, path
, struct timeval
*, times
);
5263 PRE_MEM_RASCIIZ( "futimesat(path)", ARG2
);
5266 PRE_MEM_READ( "futimesat(times)", ARG3
, 2 * sizeof(struct vki_timeval
) );
5271 // int linkat(int fd1, const char *name1, int fd2, const char *name2, int flag);
5274 *flags
|= SfMayBlock
;
5275 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
);
5276 PRE_REG_READ5(int, "linkat",
5277 int, fd1
, const char *, name1
,
5278 int, fd2
, const char *, name2
,
5280 PRE_MEM_RASCIIZ( "linkat(name1)", ARG2
);
5281 PRE_MEM_RASCIIZ( "linkat(name2)", ARG4
);
5285 // int mkdirat(int fd, const char *path, mode_t mode);
5288 *flags
|= SfMayBlock
;
5289 PRINT("sys_mkdirat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5290 PRE_REG_READ3(int, "mkdirat",
5291 int, fd
, const char *, path
, int, mode
);
5292 PRE_MEM_RASCIIZ( "mkdirat(path)", ARG2
);
5296 // int mkfifoat(int fd, const char *path, mode_t mode);
5299 PRINT("sys_mkfifoat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x(%s), 0x%" FMT_REGWORD
"x )",
5300 SARG1
,ARG2
,(HChar
*)ARG2
,ARG3
);
5301 PRE_REG_READ3(int, "mkfifoat",
5302 int, fd
, const char *, path
, vki_mode_t
, mode
);
5303 PRE_MEM_RASCIIZ( "mkfifoat(path)", ARG2
);
5306 // SYS_freebsd11_mknodat 498
5307 // int mknodat(int fd, const char *path, mode_t mode, dev_t dev);
5308 #if (FREEBSD_VERS >= FREEBSD_12)
5309 PRE(sys_freebsd11_mknodat
)
5311 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
);
5312 PRE_REG_READ4(long, "mknodat",
5313 int, dfd
, const char *, pathname
, int, mode
, unsigned, dev
);
5314 PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2
);
5319 PRINT("sys_mknodat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), 0x%" FMT_REGWORD
"x, 0x%" FMT_REGWORD
"x )", ARG1
,ARG2
,(char*)ARG2
,ARG3
,ARG4
);
5320 PRE_REG_READ4(long, "mknodat",
5321 int, dfd
, const char *, pathname
, int, mode
, unsigned, dev
);
5322 PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2
);
5327 // int openat(int fd, const char *path, int flags, ...);
5331 if (ARG3
& VKI_O_CREAT
) {
5333 PRINT("sys_openat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,(char*)ARG2
,ARG3
,ARG4
);
5334 PRE_REG_READ4(int, "openat",
5335 int, fd
, const char *, path
, int, flags
, vki_mode_t
, mode
);
5338 PRINT("sys_openat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )",ARG1
,ARG2
,(char*)ARG2
,ARG3
);
5339 PRE_REG_READ3(int, "openat",
5340 int, fd
, const char *, path
, int, flags
);
5343 if (ARG1
!= (unsigned)VKI_AT_FDCWD
&& !ML_(fd_allowed
)(ARG1
, "openat", tid
, False
)) {
5344 SET_STATUS_Failure( VKI_EBADF
);
5346 PRE_MEM_RASCIIZ( "openat(path)", ARG2
);
5349 /* Otherwise handle normally */
5350 *flags
|= SfMayBlock
;
5356 if (!ML_(fd_allowed
)(RES
, "openat", tid
, True
)) {
5358 SET_STATUS_Failure( VKI_EMFILE
);
5360 if (VG_(clo_track_fds
)) {
5361 ML_(record_fd_open_with_given_name
)(tid
, RES
, (HChar
*)ARG2
);
5366 // SYS_readlinkat 500
5367 // ssize_t readlinkat(int fd, const char *restrict path, char *restrict buf,
5372 Bool curproc_file
= False
;
5374 PRINT("sys_readlinkat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x, %llu )", ARG1
,ARG2
,(char*)ARG2
,ARG3
,(ULong
)ARG4
);
5375 PRE_REG_READ4(ssize_t
, "readlinkat",
5376 int, fd
, const char *, path
, char *, buf
, int, bufsize
);
5377 PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2
);
5378 PRE_MEM_WRITE( "readlinkat(buf)", ARG3
,ARG4
);
5380 if (VG_(have_slash_proc
) == True
&& (Int
)ARG1
== VKI_AT_FDCWD
) {
5382 * Handle the case where readlinkat is looking at /proc/curproc/file or
5385 do_readlink((const HChar
*)ARG2
, (HChar
*)ARG3
, (SizeT
)ARG4
, status
, &curproc_file
);
5388 // @todo PJF there is still the case where fd refers to /proc or /proc/pid
5389 // or /proc/curproc and path is relative pid/file, curptoc/file or just file
5391 if (!curproc_file
) {
5393 SET_STATUS_from_SysRes( VG_(do_syscall4
)(saved
, ARG1
, ARG2
, ARG3
, ARG4
));
5395 if (SUCCESS
&& RES
> 0) {
5396 POST_MEM_WRITE( ARG3
, RES
);
5400 POST(sys_readlinkat
)
5402 POST_MEM_WRITE( ARG3
, RES
);
5406 // int renameat(int fromfd, const char *from, int tofd, const char *to);
5409 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
);
5410 PRE_REG_READ4(int, "renameat",
5411 int, fromfd
, const char *, from
,
5412 int, tofd
, const char *, to
);
5413 PRE_MEM_RASCIIZ( "renameat(oldpath)", ARG2
);
5414 PRE_MEM_RASCIIZ( "renameat(newpath)", ARG4
);
5417 // SYS_symlinkat 502
5418 // int symlinkat(const char *name1, int fd, const char *name2);
5421 *flags
|= SfMayBlock
;
5422 PRINT("sys_symlinkat ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s) )",ARG1
,(char*)ARG1
,ARG2
,ARG3
,(char*)ARG3
);
5423 PRE_REG_READ3(int, "symlinkat",
5424 const char *, name1
, int, fd
, const char *, name2
);
5425 PRE_MEM_RASCIIZ( "symlinkat(name1)", ARG1
);
5426 PRE_MEM_RASCIIZ( "symlinkat(name2)", ARG3
);
5430 // int unlinkat(int fd, const char *path, int flag);
5433 *flags
|= SfMayBlock
;
5434 PRINT("sys_unlinkat ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u ",
5435 ARG1
, ARG2
, (char*)ARG2
, ARG3
);
5436 PRE_REG_READ3(int, "unlinkat", int, fd
, const char *, path
, int, flag
);
5437 PRE_MEM_RASCIIZ( "unlinkat(path)", ARG2
);
5440 // SYS_posix_openpt 504
5441 // int posix_openpt(int oflag);
5442 PRE(sys_posix_openpt
)
5444 PRINT("sys_posix_openpt ( %" FMT_REGWORD
"d )", SARG1
);
5445 PRE_REG_READ1(int, "posix_openpt", int, oflag
);
5448 // SYS_gssd_syscall 505
5450 // see https://www.freebsd.org/cgi/man.cgi?format=html&query=gssapi(3)
5451 // syscalls.master says ; 505 is initialised by the kgssapi code, if present.
5454 // int jail_get(struct iovec *iov, u_int niov, int flags);
5457 PRINT("sys_jail_get ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
);
5458 PRE_REG_READ3(int, "jail_get", struct vki_iovec
*, iov
, unsigned int,
5460 PRE_MEM_READ("jail_get(iov)", ARG1
, ARG2
* sizeof(struct vki_iovec
));
5464 // int jail_set(struct iovec *iov, u_int niov, int flags);
5467 PRINT("sys_jail_set ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
);
5468 PRE_REG_READ3(int, "jail_set", struct vki_iovec
*, iov
, unsigned int,
5470 PRE_MEM_READ("jail_set(iovs)", ARG1
, ARG2
* sizeof(struct vki_iovec
));
5473 // SYS_jail_remove 508
5474 // int jail_remove(int jid);
5475 PRE(sys_jail_remove
)
5477 PRINT("sys_jail_remove ( %" FMT_REGWORD
"d )", SARG1
);
5478 PRE_REG_READ1(int, "jail_remove", int, jid
);
5481 // SYS_closefrom 509
5482 // void closefrom(int lowfd);
5485 PRINT("sys_closefrom ( %" FMT_REGWORD
"dx )", SARG1
);
5486 PRE_REG_READ1(int, "closefrom", int, lowfd
);
5489 * Can't pass this on to the kernel otherwise it will close
5490 * all of the host files like the log
5493 for (int i
= ARG1
; i
< VG_(fd_soft_limit
); ++i
) {
5497 SET_STATUS_Success(0);
5501 // int semctl(int semid, int semnum, int cmd, ...);
5502 // int __semctl(int semid, int semnum, int cmd, _Inout_ union semun *arg);
5508 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
5509 PRE_REG_READ4(int, "semctl",
5510 int, semid
, int, semnum
, int, cmd
, struct seminfo
*, arg
);
5515 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
5516 PRE_REG_READ4(long, "semctl",
5517 int, semid
, int, semnum
, int, cmd
, struct semid_ds
*, arg
);
5521 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )",ARG1
,ARG2
,ARG3
,ARG4
);
5522 PRE_REG_READ4(long, "semctl",
5523 int, semid
, int, semnum
, int, cmd
, unsigned short *, arg
);
5526 PRINT("sys_semctl ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
5527 PRE_REG_READ3(long, "semctl",
5528 int, semid
, int, semnum
, int, cmd
);
5531 ML_(generic_PRE_sys_semctl
)(tid
, ARG1
,ARG2
,ARG3
,ARG4
);
5536 ML_(generic_POST_sys_semctl
)(tid
, RES
,ARG1
,ARG2
,ARG3
,ARG4
);
5540 // int msgctl(int msqid, int cmd, struct msqid_ds *buf);
5543 PRINT("sys_msgctl ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
,SARG2
,ARG3
);
5545 PRE_REG_READ3(int, "msgctl", int, msqid
, int, cmd
, struct msqid_ds
*, buf
);
5547 switch (ARG2
/* cmd */) {
5549 PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)",
5550 ARG3
, sizeof(struct vki_msqid_ds
) );
5553 PRE_MEM_READ( "msgctl(IPC_SET, buf)",
5554 ARG3
, sizeof(struct vki_msqid_ds
) );
5561 switch (ARG2
/* cmd */) {
5563 POST_MEM_WRITE( ARG3
, sizeof(struct vki_msqid_ds
) );
5570 // int shmctl(int shmid, int cmd, struct shmid_ds *buf);
5573 PRINT("sys_shmctl ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",SARG1
,SARG2
,ARG3
);
5574 PRE_REG_READ3(int, "shmctl",
5575 int, shmid
, int, cmd
, struct vki_shmid_ds
*, buf
);
5576 switch (ARG2
/* cmd */) {
5578 PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)",
5579 ARG3
, sizeof(struct vki_shmid_ds
) );
5582 PRE_MEM_READ( "shmctl(IPC_SET, buf)",
5583 ARG3
, sizeof(struct vki_shmid_ds
) );
5590 if (ARG2
== VKI_IPC_STAT
) {
5591 POST_MEM_WRITE( ARG3
, sizeof(struct vki_shmid_ds
) );
5595 // SYS_lpathconf 513
5596 // long lpathconf(const char *path, int name);
5599 PRINT("sys_lpathconf ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d)", ARG1
, SARG2
);
5600 PRE_REG_READ2(long, "lpathconf", const char *, path
, int, name
);
5601 PRE_MEM_RASCIIZ("lpathconf(path)", ARG1
);
5604 // SYS___cap_rights_get 515
5605 // note extra 1st argument for the internal function which is not present
5606 // in the public interface
5607 // int __cap_rights_get(int version, int fd, cap_rights_t *rights);
5608 PRE(sys_cap_rights_get
)
5610 PRINT("sys_cap_rights_get ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, SARG2
, ARG3
);
5611 PRE_REG_READ3(long, "cap_rights_get", int, version
, int, fd
, vki_cap_rights_t
*, rights
);
5612 PRE_MEM_WRITE("cap_rights_get(rights)", ARG3
, sizeof(vki_cap_rights_t
));
5615 POST(sys_cap_rights_get
)
5617 POST_MEM_WRITE(ARG2
, sizeof(vki_cap_rights_t
));
5620 // SYS_cap_enter 516
5621 // int cap_enter(void);
5624 PRINT("%s", "sys_cap_enter ( )");
5625 PRE_REG_READ0(int, "cap_enter");
5626 static Bool warning_given
= False
;
5627 if (!warning_given
) {
5628 warning_given
= True
;
5629 capabiltyMode
= True
;
5631 "WARNING: Valgrind may not operate correctly in capability mode.\n"
5632 " Please consider disabling capability by using the RUNNING_ON_VALGRIND mechanism.\n"
5633 " See http://valgrind.org/docs/manual/manual-core-adv.html#manual-core-adv.clientreq\n");
5637 // SYS_cap_getmode 517
5638 // int cap_getmode(u_int *modep);
5639 PRE(sys_cap_getmode
)
5641 PRINT("sys_cap_getmode ( %#" FMT_REGWORD
"x )", ARG1
);
5642 PRE_REG_READ1(int, "cap_getmode", u_int
*, modep
);
5643 PRE_MEM_WRITE("cap_getmode(modep)", ARG1
, sizeof(u_int
));
5646 POST(sys_cap_getmode
)
5648 POST_MEM_WRITE(ARG1
, sizeof(u_int
));
5651 static vki_sigset_t pdfork_saved_mask
;
5654 // pid_t pdfork(int *fdp, int flags);
5661 PRINT("sys_pdfork ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
, ARG2
);
5662 PRE_REG_READ2(pid_t
, "pdfork", int*, fdp
, int, flags
);
5664 /* Block all signals during fork, so that we can fix things up in
5665 the child without being interrupted. */
5666 VG_(sigfillset
)(&mask
);
5667 VG_(sigprocmask
)(VKI_SIG_SETMASK
, &mask
, &pdfork_saved_mask
);
5669 VG_(do_atfork_pre
)(tid
);
5671 SET_STATUS_from_SysRes( VG_(do_syscall2
)(__NR_pdfork
, ARG1
, ARG2
) );
5677 // RES is 0 for child, non-0 (the child's PID) for parent.
5678 is_child
= ( RES
== 0 ? True
: False
);
5679 child_pid
= ( is_child
? -1 : (Int
)RES
);
5682 VG_(do_atfork_child
)(tid
);
5684 /* restore signal mask */
5685 VG_(sigprocmask
)(VKI_SIG_SETMASK
, &pdfork_saved_mask
, NULL
);
5687 VG_(do_atfork_parent
)(tid
);
5689 PRINT(" fork: process %d created child %d\n", VG_(getpid
)(), child_pid
);
5691 /* restore signal mask */
5692 VG_(sigprocmask
)(VKI_SIG_SETMASK
, &pdfork_saved_mask
, NULL
);
5696 PRE_MEM_WRITE( "pdfork(fdp)", ARG1
, sizeof(int) );
5703 POST_MEM_WRITE( ARG1
, sizeof(int) );
5708 //int pdkill(int fd, int signum)
5711 PRINT("sys_pdkill ( %" FMT_REGWORD
"u, %" FMT_REGWORD
"d )", ARG1
, SARG2
);
5712 PRE_REG_READ2(int, "pdkill", int, fd
, int, signum
);
5714 if (!ML_(client_signal_OK
)(ARG2
)) {
5715 SET_STATUS_Failure( VKI_EINVAL
);
5719 /* Ther was some code here to check if the kill is to this process
5721 * But it was totally wrong
5723 * It was calling ML_(do_sigkill)(Int pid, Int tgid)
5725 * With a file descriptor
5727 * Fortunately this will never match a real process otherwise
5728 * it might have accidentally killed us.
5730 * For a start we need the pid, obtained with pdgetpid
5731 * Next ML_(do_sigkill) doesn't map to FreeBSD. It takes a
5732 * pid (lwpid) and a tgid (threadgroup)
5734 * On FreeBSD lwpid is the tid and threadgroup is the pid
5735 * The kill functions operate on pids, not tids.
5737 * One last thing, I don't see how pdkill could do a self
5738 * kill 9. It neads an fd which implied pdfork whichimplies
5739 * that the fd/pid are for a child process
5742 SET_STATUS_from_SysRes(VG_(do_syscall2
)(SYSNO
, ARG1
, ARG2
));
5744 if (VG_(clo_trace_signals
)) {
5745 VG_(message
)(Vg_DebugMsg
, "pdkill: sent signal %ld to fd %ld\n",
5749 /* This kill might have given us a pending signal. Ask for a check once
5750 the syscall is done. */
5751 *flags
|= SfPollAfter
;
5756 // int pdgetpid(int fd, pid_t *pidp);
5759 PRINT("pdgetpid ( %" FMT_REGWORD
"d, %#lx )", SARG1
, ARG2
);
5760 PRE_REG_READ2(int, "pdgetpid",
5761 int, fd
, pid_t
*, pidp
);
5762 PRE_MEM_WRITE( "pdgetpid(pidp))", ARG2
, sizeof(vki_pid_t
) );
5767 POST_MEM_WRITE( ARG2
, sizeof(vki_pid_t
) );
5772 // int pselect(int nfds, fd_set * restrict readfds, fd_set * restrict writefds,
5773 // fd_set * restrict exceptfds,
5774 // const struct timespec * restrict timeout,
5775 // const sigset_t * restrict newsigmask);
5778 *flags
|= SfMayBlock
| SfPostOnFail
;
5779 PRINT("sys_pselect ( %ld, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#"
5780 FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",
5781 SARG1
, ARG2
, ARG3
, ARG4
, ARG5
, ARG6
);
5782 PRE_REG_READ6(int, "pselect",
5783 int, nfds
, vki_fd_set
*, readfds
, vki_fd_set
*, writefds
,
5784 vki_fd_set
*, exceptfds
, struct vki_timespec
*, timeout
,
5785 const sigset_t
*, newsigmask
);
5786 // XXX: this possibly understates how much memory is read.
5788 PRE_MEM_READ( "pselect(readfds)",
5789 ARG2
, ARG1
/8 /* __FD_SETSIZE/8 */ );
5792 PRE_MEM_READ( "pselect(writefds)",
5793 ARG3
, ARG1
/8 /* __FD_SETSIZE/8 */ );
5796 PRE_MEM_READ( "pselect(exceptfds)",
5797 ARG4
, ARG1
/8 /* __FD_SETSIZE/8 */ );
5800 PRE_MEM_READ( "pselect(timeout)", ARG5
, sizeof(struct vki_timeval
) );
5804 PRE_MEM_READ( "pselect(sig)", ARG6
, sizeof(vki_sigset_t
) );
5805 ARG6
= ML_(make_safe_mask
)("syswrap.pselect.1", (Addr
)ARG6
);
5811 ML_(free_safe_mask
) ( (Addr
)ARG6
);
5814 // SYS_getloginclass 523
5815 // int getloginclass(char *name, size_t len);
5816 PRE(sys_getloginclass
)
5818 PRINT("sys_getloginclass ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, ARG2
);
5819 PRE_REG_READ2(int, "getloginclass", char *, name
, size_t, len
);
5820 // The buffer should be at least MAXLOGNAME bytes in length.
5821 PRE_MEM_WRITE("getloginclass(name)", ARG1
, ARG2
);
5824 POST(sys_getloginclass
)
5826 POST_MEM_WRITE(ARG1
, ARG2
);
5829 // SYS_setloginclass 524
5830 // int setloginclass(const char *name);
5831 PRE(sys_setloginclass
)
5833 PRINT("sys_setloginclass ( %#" FMT_REGWORD
"x(%s) )", ARG1
, (HChar
*)ARG1
);
5834 PRE_REG_READ1(int, "setloginclass", const char *, name
);
5835 PRE_MEM_RASCIIZ("rctl_setloginclass(name)", ARG1
);
5838 // SYS_rctl_get_racct 525
5839 // int rctl_get_racct(const char *inbufp, size_t inbuflen, char *outbufp,
5840 // size_t outbuflen);
5841 PRE(sys_rctl_get_racct
)
5843 PRINT("sys_rctl_get_racct ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
, ARG4
);
5844 PRE_REG_READ4(int, "rctl_get_racct", const char *, inbufp
, size_t, inbuflen
, char *, outbufp
,
5846 PRE_MEM_READ("rctl_get_racct(inbufp)", ARG1
, ARG2
);
5847 PRE_MEM_WRITE("rctl_get_racct(outbufp)", ARG3
, ARG4
);
5850 POST(sys_rctl_get_racct
)
5852 POST_MEM_WRITE(ARG3
, ARG4
);
5855 // SYS_rctl_get_rules 526
5856 // int rctl_get_rules(const char *inbufp, size_t inbuflen, char *outbufp,
5857 // size_t outbuflen);
5858 PRE(sys_rctl_get_rules
)
5860 PRINT("sys_rctl_get_rules ( %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
, ARG4
);
5861 PRE_REG_READ4(int, "rctl_get_rules", const char *, inbufp
, size_t, inbuflen
, char *, outbufp
,
5863 PRE_MEM_READ("rctl_get_rules(inbufp)", ARG1
, ARG2
);
5864 PRE_MEM_WRITE("rctl_get_rules(outbufp)", ARG3
, ARG4
);
5867 POST(sys_rctl_get_rules
)
5869 POST_MEM_WRITE(ARG3
, ARG4
);
5872 // SYS_rctl_get_limits 527
5873 // int rctl_get_limits(const char *inbufp, size_t inbuflen, char *outbufp,
5874 // size_t outbuflen);
5875 PRE(sys_rctl_get_limits
)
5877 PRINT("sys_rctl_get_limits ( %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
, ARG4
);
5878 PRE_REG_READ4(int, "rctl_get_limits", const char *, inbufp
, size_t, inbuflen
, char *, outbufp
,
5880 PRE_MEM_READ("rctl_get_limits(inbufp)", ARG1
, ARG2
);
5881 PRE_MEM_WRITE("rctl_get_limits(outbufp)", ARG3
, ARG4
);
5884 POST(sys_rctl_get_limits
)
5886 POST_MEM_WRITE(ARG3
, ARG4
);
5889 // SYS_rctl_add_rule 528
5890 // int rctl_add_rule(const char *inbufp, size_t inbuflen, char *outbufp,
5891 // size_t outbuflen);
5892 PRE(sys_rctl_add_rule
)
5894 PRINT("sys_rctl_add_rule ( %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
, ARG4
);
5895 PRE_REG_READ2(int, "rctl_add_rule", const char *, inbufp
, size_t, inbuflen
);
5896 PRE_MEM_READ("rctl_add_rule(inbufp)", ARG1
, ARG2
);
5898 // The outbufp and outbuflen arguments are unused
5899 //PRE_MEM_WRITE("rctl_add_rule(outbufp)", ARG3, ARG4);
5902 POST(sys_rctl_add_rule
)
5904 //POST_MEM_WRITE(ARG3, ARG4);
5907 // SYS_rctl_remove_rule 529
5908 // int rctl_remove_rule(const char *inbufp, size_t inbuflen, char *outbufp,
5909 // size_t outbuflen);
5910 PRE(sys_rctl_remove_rule
)
5912 PRINT("sys_rctl_remove_rule ( %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"xd, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
, ARG4
);
5913 PRE_REG_READ2(int, "rctl_remove_rule", const char *, inbufp
, size_t, inbuflen
);
5914 PRE_MEM_READ("rctl_remove_rule(inbufp)", ARG1
, ARG2
);
5916 // The outbufp and outbuflen arguments are unused
5917 //PRE_MEM_WRITE("rctl_remove_rule(outbufp)", ARG3, ARG4);
5920 POST(sys_rctl_remove_rule
)
5922 //POST_MEM_WRITE(ARG3, ARG4);
5925 // SYS_posix_fallocate 530
5928 // SYS_posix_fadvise 531
5934 // SYS_cap_rights_limit 533
5935 //int cap_rights_limit(int fd, const cap_rights_t *rights);
5936 PRE(sys_cap_rights_limit
)
5938 PRINT("sys_cap_rights_limit ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
5939 PRE_REG_READ2(int, "cap_rights_limit",
5940 int, fd
, const cap_rights_t
*, rights
);
5941 PRE_MEM_READ( "cap_rights_limit(rights)", ARG2
, sizeof(struct vki_cap_rights
) );
5944 // SYS_cap_ioctls_limit 534
5945 // int cap_ioctls_limit(int fd, const unsigned long *cmds, size_t ncmds);
5946 PRE(sys_cap_ioctls_limit
)
5948 PRINT("cap_ioctls_limit ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
);
5949 PRE_REG_READ3(int, "cap_ioctls_limit",
5950 int, fd
, unsigned long*, rights
, vki_size_t
, ncmds
);
5951 // "can be up to 256" taking that to not be inclusive
5953 PRE_MEM_READ( "cap_ioctls_limit(cmds))", ARG2
, ARG3
*sizeof(unsigned long) );
5958 // SYS_cap_ioctls_get 535
5959 // int cap_ioctls_get(int fd, unsigned long *cmds, size_t maxcmds);
5960 PRE(sys_cap_ioctls_get
)
5962 PRINT("sys_cap_ioctls_get ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", SARG1
, ARG2
, ARG3
);
5963 PRE_REG_READ3(int, "cap_ioctls_get", int, fd
, unsigned long *, cmds
, size_t, maxcmds
);
5965 PRE_MEM_WRITE("cap_ioctls_get(cmds)", ARG2
, ARG3
*sizeof(unsigned long));
5969 POST(sys_cap_ioctls_get
)
5972 POST_MEM_WRITE(ARG2
, ARG3
*sizeof(unsigned long));
5977 // SYS_cap_fcntls_limit 536
5978 //int cap_fcntls_limit(int fd, uint32_t fcntlrights);
5979 PRE(sys_cap_fcntls_limit
)
5981 PRINT("cap_fcntls_limit ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"u )", SARG1
, ARG2
);
5982 PRE_REG_READ2(long, "cap_fcntls_limit",
5983 int, fd
, vki_uint32_t
, fcntlrights
);
5986 // SYS_cap_fcntls_get 537
5987 // int cap_fcntls_get(int fd, uint32_t *fcntlrightsp);
5988 PRE(sys_cap_fcntls_get
)
5990 PRINT("sys_cap_fcntls_get ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
5991 PRE_REG_READ2(int, "cap_fcntls_get", int, fd
, uint32_t *, fcntlrightsp
);
5992 PRE_MEM_WRITE("cap_fcntls_get(fcntlrightsp)", ARG2
, sizeof(uint32_t));
5995 POST(sys_cap_fcntls_get
)
5997 POST_MEM_WRITE(ARG2
, sizeof(uint32_t));
6001 // int bindat(int fd, int s, const struct sockaddr *addr, socklen_t addrlen);
6004 PRINT("sys_bindat ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"dx, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",
6005 SARG1
, SARG2
, ARG3
, ARG4
);
6006 PRE_REG_READ4(int, "bindat", int, fd
, int, s
, const struct vki_sockaddr
*, name
, vki_socklen_t
, namelen
);
6007 PRE_MEM_READ("bindat(name)", ARG3
, ARG4
);
6010 // SYS_connectat 539
6011 // int connectat(int fd, int s, const struct sockaddr *name, socklen_t namelen);
6014 PRINT("sys_connectat ( %" FMT_REGWORD
"d, %" FMT_REGWORD
"dx, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )",
6015 SARG1
, SARG2
, ARG3
, ARG4
);
6016 PRE_REG_READ4(int, "connectat", int, fd
, int, s
, const struct vki_sockaddr
*, name
, vki_socklen_t
, namelen
);
6017 PRE_MEM_READ("connectat(name)", ARG3
, ARG4
);
6020 // SYS_chflagsat 540
6021 // int chflagsat(int fd, const char *path, unsigned long flags, int atflag);
6024 PRINT("sys_chglagsat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"d )",
6025 SARG1
, ARG2
, ARG3
, SARG4
);
6026 PRE_REG_READ4(int, "chflagsat", int, fd
, const char *, path
, unsigned long, flags
, int, atflag
);
6027 PRE_MEM_RASCIIZ("chflagsat(path)", ARG2
);
6031 // int accept4(int s, struct sockaddr * restrict addr,
6032 // socklen_t * restrict addrlen, int flags);
6035 *flags
|= SfMayBlock
;
6036 PRINT("sys_accept4 ( %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u)",ARG1
,ARG2
,ARG3
,ARG4
);
6037 PRE_REG_READ4(int, "accept4",
6038 int, s
, struct sockaddr
*, addr
, int, *addrlen
, int, flags
);
6039 ML_(generic_PRE_sys_accept
)(tid
, ARG1
,ARG2
,ARG3
);
6046 r
= ML_(generic_POST_sys_accept
)(tid
, VG_(mk_SysRes_Success
)(RES
),
6048 SET_STATUS_from_SysRes(r
);
6052 // int pipe2(int fildes[2], int flags);
6055 PRINT("sys_pipe2 ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u )", ARG1
, ARG2
);
6056 PRE_REG_READ2(int, "pipe2",
6057 int *, fildes
, int, flags
);
6058 PRE_MEM_WRITE("pipe2(fildes)", ARG1
, 2 * sizeof(int));
6070 POST_MEM_WRITE(ARG1
, 2 * sizeof(int));
6071 fildes
= (int *)ARG1
;
6073 if (!ML_(fd_allowed
)(fildes
[0], "pipe2", tid
, True
) ||
6074 !ML_(fd_allowed
)(fildes
[1], "pipe2", tid
, True
)) {
6075 VG_(close
)(fildes
[0]);
6076 VG_(close
)(fildes
[1]);
6077 SET_STATUS_Failure( VKI_EMFILE
);
6078 } else if (VG_(clo_track_fds
)) {
6079 ML_(record_fd_open_nameless
)(tid
, fildes
[0]);
6080 ML_(record_fd_open_nameless
)(tid
, fildes
[1]);
6084 // SYS_aio_mlock 543
6085 // int aio_mlock(struct aiocb *iocb);
6088 PRINT("sys_aio_mlock ( %#" FMT_REGWORD
"x )", ARG1
);
6089 PRE_REG_READ1(int, "aio_mlock", struct vki_aiocb
*, iocb
);
6090 PRE_MEM_READ("aio_mlock(iocb", ARG1
, sizeof(struct vki_aiocb
));
6091 // this locks memory into RAM, don't think that we need to do
6099 // int ppoll(struct pollfd fds[], nfds_t nfds,
6100 // const struct timespec * restrict timeout,
6101 // const sigset_t * restrict newsigmask);
6104 PRINT("sys_ppoll ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %#" FMT_REGWORD
6105 "x, %#" FMT_REGWORD
"x )",
6106 ARG1
, ARG2
, ARG3
, ARG4
);
6108 struct vki_pollfd
* fds
= (struct vki_pollfd
*)(Addr
)ARG1
;
6109 *flags
|= SfMayBlock
| SfPostOnFail
;
6110 PRE_REG_READ4(long, "ppoll",
6111 struct vki_pollfd
*, fds
, unsigned int, nfds
,
6112 struct vki_timespec
*, timeout
, vki_sigset_t
*, newsigmask
);
6114 if (ML_(safe_to_deref
)(fds
, ARG2
*sizeof(struct vki_pollfd
))) {
6115 for (i
= 0; i
< ARG2
; i
++) {
6116 PRE_MEM_READ( "ppoll(fds.fd)",
6117 (Addr
)(&fds
[i
].fd
), sizeof(fds
[i
].fd
) );
6118 PRE_MEM_READ( "ppoll(fds.events)",
6119 (Addr
)(&fds
[i
].events
), sizeof(fds
[i
].events
) );
6120 PRE_MEM_WRITE( "ppoll(fds.revents)",
6121 (Addr
)(&fds
[i
].revents
), sizeof(fds
[i
].revents
) );
6126 PRE_MEM_READ( "ppoll(timeout)", ARG3
,
6127 sizeof(struct vki_timespec
) );
6130 PRE_MEM_READ( "ppoll(newsigmask)", ARG4
, sizeof(vki_sigset_t
));
6131 ARG4
= ML_(make_safe_mask
)("syswrap.ppoll.1", (Addr
)ARG4
);
6137 if (SUCCESS
&& ((Word
)RES
!= -1)) {
6139 struct vki_pollfd
* ufds
= (struct vki_pollfd
*)(Addr
)ARG1
;
6140 for (i
= 0; i
< ARG2
; i
++) {
6141 POST_MEM_WRITE( (Addr
)(&ufds
[i
].revents
), sizeof(ufds
[i
].revents
) );
6144 ML_(free_safe_mask
) ( (Addr
)ARG4
);
6148 // int futimens(int fd, const struct timespec times[2]);
6151 PRINT("sys_futimens ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
6152 PRE_REG_READ2(int, "futimens", int, fd
, const struct timespec
*, times
);
6153 PRE_MEM_READ("futimens(times)", ARG2
, 2*sizeof(struct vki_timespec
));
6156 // SYS_utimensat 547
6157 // int utimensat(int fd, const char *path, const struct timespec times[2],
6161 PRINT("sys_utimensat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d )",
6162 SARG1
, ARG2
, ARG3
, SARG4
);
6163 PRE_REG_READ4(int, "utimensat", int, fd
, const char *,path
, const struct timespec
*, times
,
6165 PRE_MEM_RASCIIZ("utimensat(path)", ARG2
);
6166 PRE_MEM_READ("utimensat(times)", ARG3
, 2*sizeof(struct vki_timespec
));
6169 // SYS_fdatasync 550
6170 // int fdatasync(int fd);
6173 PRINT("sys_fdatasync ( %" FMT_REGWORD
"d )",SARG1
);
6174 PRE_REG_READ1(int, "fdatasync", int, fd
);
6177 #if (FREEBSD_VERS >= FREEBSD_12)
6179 // int fstat(int fd, struct stat *sb);
6182 PRINT("sys_fstat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",SARG1
,ARG2
);
6183 PRE_REG_READ2(int, "fstat", int, fd
, struct stat
*, sb
);
6184 PRE_MEM_WRITE( "fstat(sb)", ARG2
, sizeof(struct vki_stat
) );
6189 POST_MEM_WRITE( ARG2
, sizeof(struct vki_stat
) );
6193 // int fstatat(int fd, const char *path, struct stat *sb, int flag);
6196 PRINT("sys_fstatat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d )", SARG1
,ARG2
,(char*)ARG2
,ARG3
,SARG4
);
6197 PRE_REG_READ4(int, "fstatat",
6198 int, fd
, const char *, path
, struct stat
*, sb
, int, flag
);
6199 PRE_MEM_RASCIIZ( "fstatat(path)", ARG2
);
6200 PRE_MEM_WRITE( "fstatat(sb)", ARG3
, sizeof(struct vki_stat
) );
6205 POST_MEM_WRITE( ARG3
, sizeof(struct vki_stat
) );
6208 // int fhstat(const fhandle_t *fhp, struct stat *sb);
6211 PRINT("sys_fhstat ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
6212 PRE_REG_READ2(long, "fhstat", const vki_fhandle_t
*, fhp
, struct stat
*, sb
);
6213 PRE_MEM_READ( "fhstat(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
6214 PRE_MEM_WRITE( "fhstat(sb)", ARG2
, sizeof(struct vki_stat
) );
6219 POST_MEM_WRITE( ARG2
, sizeof(struct vki_stat
) );
6222 // SYS_getdirentries 554
6223 // ssize_t getdirentries(int fd, char *buf, size_t nbytes, off_t *basep);
6224 PRE(sys_getdirentries
)
6226 *flags
|= SfMayBlock
;
6227 PRINT("sys_getdirentries ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %#" FMT_REGWORD
"x )", SARG1
,ARG2
,ARG3
,ARG4
);
6228 PRE_REG_READ4(ssize_t
, "getdirentries",
6229 int, fd
, char *, buf
,
6232 PRE_MEM_WRITE( "getdirentries(buf)", ARG2
, ARG3
);
6234 PRE_MEM_WRITE("getdirentries(basep)", ARG4
, sizeof (vki_off_t
));
6238 POST(sys_getdirentries
)
6242 POST_MEM_WRITE( ARG2
, RES
);
6244 POST_MEM_WRITE( ARG4
, sizeof (vki_off_t
));
6250 // int statfs(const char *path, struct statfs *buf);
6253 PRINT("sys_statfs ( %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x )",ARG1
,(char *)ARG1
,ARG2
);
6254 PRE_REG_READ2(int, "statfs", const char *, path
, struct statfs
*, buf
);
6255 PRE_MEM_RASCIIZ( "statfs(path)", ARG1
);
6256 PRE_MEM_WRITE( "statfs(buf)", ARG2
, sizeof(struct vki_statfs
) );
6261 POST_MEM_WRITE( ARG2
, sizeof(struct vki_statfs
) );
6265 // int fstatfs(int fd, struct statfs *buf);
6268 PRINT("sys_fstatfs ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )",SARG1
,ARG2
);
6269 PRE_REG_READ2(int, "fstatfs",
6270 int, fd
, struct vki_statfs
*, buf
);
6271 PRE_MEM_WRITE( "fstatfs(buf)", ARG2
, sizeof(struct vki_statfs
) );
6276 POST_MEM_WRITE( ARG2
, sizeof(struct vki_statfs
) );
6279 // SYS_getfsstat 557
6280 // int getfsstat(struct statfs *buf, long bufsize, int mode);
6283 PRINT("sys_getfsstat ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",ARG1
,ARG2
,ARG3
);
6284 PRE_REG_READ3(long, "getfsstat", struct vki_statfs
*, buf
, long, len
, int, flags
);
6285 PRE_MEM_WRITE( "getfsstat(buf)", ARG1
, ARG2
);
6291 if ((Word
)RES
!= -1) {
6292 POST_MEM_WRITE( ARG1
, RES
* sizeof(struct vki_statfs
) );
6297 // int fhstatfs(const fhandle_t *fhp, struct statfs *buf);
6300 PRINT("sys_fhstatfs ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )",ARG1
,ARG2
);
6301 PRE_REG_READ2(long, "fhstatfs",
6302 struct fhandle
*, fhp
, struct statfs
*, buf
);
6303 PRE_MEM_READ( "fhstatfs(fhp)", ARG1
, sizeof(struct vki_fhandle
) );
6304 PRE_MEM_WRITE( "fhstatfs(buf)", ARG2
, sizeof(struct vki_statfs
) );
6309 POST_MEM_WRITE( ARG2
, sizeof(struct vki_statfs
) );
6316 // int kevent(int kq, const struct kevent *changelist, int nchanges,
6317 // struct kevent *eventlist, int nevents,
6318 // const struct timespec *timeout);
6321 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
);
6322 PRE_REG_READ6(int, "kevent",
6323 int, kq
, struct vki_kevent
*, changelist
, int, nchanges
,
6324 struct vki_kevent
*, eventlist
, int, nevents
,
6325 struct timespec
*, timeout
);
6326 if (ARG2
!= 0 && ARG3
!= 0) {
6327 PRE_MEM_READ( "kevent(changelist)", ARG2
, sizeof(struct vki_kevent
)*ARG3
);
6329 if (ARG4
!= 0 && ARG5
!= 0) {
6330 PRE_MEM_WRITE( "kevent(eventlist)", ARG4
, sizeof(struct vki_kevent
)*ARG5
);
6333 *flags
|= SfMayBlock
;
6336 PRE_MEM_READ( "kevent(timeout)",
6337 ARG6
, sizeof(struct vki_timespec
));
6344 if ((Word
)RES
!= -1) {
6346 POST_MEM_WRITE( ARG4
, sizeof(struct vki_kevent
)*RES
) ;
6351 // SYS_cpuset_getdomain 561
6354 // SYS_cpuset_setdomain 562
6357 // SYS_getrandom 563
6358 // ssize_t getrandom(void *buf, size_t buflen, unsigned int flags);
6361 PRINT("sys_getrandom ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )", ARG1
, ARG2
, ARG3
);
6362 PRE_REG_READ3(ssize_t
, "getrandom",
6363 void *, buf
, vki_size_t
, buflen
, unsigned int, flags
);
6364 PRE_MEM_WRITE( "getrandom(buf)", ARG1
, ARG2
);
6365 if ((ARG3
& VKI_GRND_NONBLOCK
) == 0) {
6366 *flags
|= SfMayBlock
;
6372 POST_MEM_WRITE( ARG1
, ARG2
);
6376 // int getfhat(int fd, const char *path, fhandle_t *fhp, int flag);
6379 PRINT("sys_getfhat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"x, %" FMT_REGWORD
"d ", SARG1
, ARG2
, ARG3
, SARG4
);
6380 PRE_REG_READ4(int, "getfhat", int, fd
, const char*, path
, vki_fhandle_t
*, fhp
, int, flag
);
6381 PRE_MEM_RASCIIZ( "getfhat(path)", ARG2
);
6382 PRE_MEM_WRITE("getfhat(fhp)", ARG3
, sizeof(vki_fhandle_t
));
6387 POST_MEM_WRITE(ARG3
, sizeof(vki_fhandle_t
));
6391 // int fhlink(fhandle_t *fhp, const char *to);
6394 PRINT("sys_fhlink ( %#" FMT_REGWORD
"x, %#" FMT_REGWORD
"x )", ARG1
, ARG2
);
6395 PRE_REG_READ2(int, "fhlink", vki_fhandle_t
*, fhp
, const char *, to
);
6396 PRE_MEM_READ( "fhlink(fhp)", ARG1
, sizeof(vki_fhandle_t
));
6397 PRE_MEM_RASCIIZ("fhlink(buf)", ARG2
);
6401 // int fhlinkat(fhandle_t *fhp, int tofd, const char *to);
6404 PRINT("sys_fhlinkat ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"xu ", ARG1
, SARG2
, ARG3
);
6405 PRE_REG_READ3(int, "fhlinkat", vki_fhandle_t
*, fhp
, int, tofd
, const char *, to
);
6406 PRE_MEM_READ( "fhlinkat(fhp)", ARG1
, sizeof(vki_fhandle_t
));
6407 PRE_MEM_RASCIIZ("fhreadlink(to)", ARG3
);
6410 // SYS_fhreadlink 567
6411 // int fhreadlink(fhandle_t *fhp, char *buf, size_t bufsize);
6414 PRINT("sys_fhreadlink ( %#" FMT_REGWORD
"x, %" FMT_REGWORD
"x, %" FMT_REGWORD
"u ", ARG1
, ARG2
, ARG3
);
6415 PRE_REG_READ3(int, "fhreadlink", vki_fhandle_t
*, fhp
, char *, buf
, size_t, bufsize
);
6416 PRE_MEM_READ( "fhreadlink(fhp)", ARG1
, sizeof(vki_fhandle_t
));
6417 PRE_MEM_WRITE("fhreadlink(buf)", ARG2
, ARG3
);
6420 POST(sys_fhreadlink
)
6422 POST_MEM_WRITE(ARG2
, ARG3
);
6427 #if (FREEBSD_VERS >= FREEBSD_12_2)
6430 // int funlinkat(int dfd, const char *path, int fd, int flag);
6433 *flags
|= SfMayBlock
;
6434 PRINT("sys_funlinkat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %" FMT_REGWORD
"u )",
6435 SARG1
, ARG2
, (char*)ARG2
, ARG4
, ARG5
);
6436 PRE_REG_READ4(int, "funlinkat", int, dfd
, const char *, path
, int, fd
, int, flag
);
6437 PRE_MEM_RASCIIZ( "funlinkat(path)", ARG2
);
6440 // SYS_copy_file_range 569
6441 // ssize_t copy_file_range(int infd, off_t *inoffp, int outfd, off_t *outoffp,
6442 // size_t len, unsigned int flags);
6443 PRE(sys_copy_file_range
)
6445 PRINT("sys_copy_file_range (%" FMT_REGWORD
"d, %#" FMT_REGWORD
"x, %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"d, %" FMT_REGWORD
"d)",
6446 SARG1
, ARG2
, SARG3
, ARG4
, (char*)ARG4
, SARG5
, SARG6
);
6448 PRE_REG_READ6(vki_ssize_t
, "copy_file_range",
6450 vki_off_t
*, "inoffp",
6452 vki_off_t
*, "outoffp",
6454 unsigned int, "flags");
6456 /* File descriptors are "specially" tracked by valgrind.
6457 valgrind itself uses some, so make sure someone didn't
6458 put in one of our own... */
6459 if (!ML_(fd_allowed
)(ARG1
, "copy_file_range(infd)", tid
, False
) ||
6460 !ML_(fd_allowed
)(ARG3
, "copy_file_range(infd)", tid
, False
)) {
6461 SET_STATUS_Failure( VKI_EBADF
);
6463 /* Now see if the offsets are defined. PRE_MEM_READ will
6464 double check it can dereference them. */
6466 PRE_MEM_READ( "copy_file_range(inoffp)", ARG2
, sizeof(vki_off_t
));
6469 PRE_MEM_READ( "copy_file_range(outoffp)", ARG4
, sizeof(vki_off_t
));
6475 // SYS___sysctlbyname 570
6476 // int sysctlbyname(const char *name, void *oldp, size_t *oldlenp,
6477 // const void *newp, size_t newlen);
6479 // int __sysctlbyname(_In_reads_(namelen) const char *name, size_t namelen,
6480 // _Out_writes_bytes_opt_(*oldlenp) void *old,
6481 // _Inout_opt_ size_t *oldlenp, _In_reads_bytes_opt_(newlen) void *new,
6483 PRE(sys___sysctlbyname
)
6485 // this is very much like SYS___sysctl, instead of having an OID with length
6486 // here threre is an ascii string with length
6487 // @todo PJF factor out the common functionality of the two
6488 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
);
6489 PRE_REG_READ6(int, "__sysctlbyname", const char *, name
, vki_size_t
, namelen
,
6490 void *, oldp
, vki_size_t
*, oldlenp
,
6491 void *, newp
, vki_size_t
, newlen
);
6494 const char* name
= (const char*)ARG1
;
6495 if (ML_(safe_to_deref
)(name
, sizeof("kern.ps_strings")) &&
6496 VG_(strcmp
)(name
, "kern.ps_strings") == 0) {
6497 if (sysctl_kern_ps_strings((SizeT
*)ARG3
, (SizeT
*)ARG4
)) {
6498 SET_STATUS_Success(0);
6502 if (ML_(safe_to_deref
)(name
, sizeof("kern.usrstack")) &&
6503 VG_(strcmp
)(name
, "kern.usrstack") == 0) {
6504 sysctl_kern_usrstack((SizeT
*)ARG3
, (SizeT
*)ARG4
);
6505 SET_STATUS_Success(0);
6508 // kern.proc.pathname doesn't seem to be handled
6509 // makes sense as the pid is variable and using
6510 // a MIB is easier than generating a string
6512 // read number of ints specified in ARG2 from mem pointed to by ARG1
6513 PRE_MEM_READ("__sysctlbyname(name)", (Addr
)ARG1
, ARG2
* sizeof(int));
6515 // if 'newp' is not NULL can read namelen bytes from that addess
6516 if (ARG5
!= (UWord
)NULL
) {
6517 PRE_MEM_READ("__sysctlbyname(newp)", (Addr
)ARG5
, ARG6
);
6520 // there are two scenarios for oldlenp/oldp
6521 // 1. oldval is NULL and oldlenp is non-NULL
6522 // this is a query of oldlenp so oldlenp will be written
6523 // 2. Both are non-NULL
6524 // this is a query of oldp, oldlenp will be read and oldp will
6527 // is oldlenp is not NULL, can write
6528 if (ARG4
!= (UWord
)NULL
) {
6529 if (ARG3
!= (UWord
)NULL
) {
6531 PRE_MEM_READ("__sysctlbyname(oldlenp)", (Addr
)ARG4
, sizeof(vki_size_t
));
6532 if (ML_(safe_to_deref
)((void*)(Addr
)ARG4
, sizeof(vki_size_t
))) {
6533 PRE_MEM_WRITE("__sysctlbyname(oldp)", (Addr
)ARG3
, *(vki_size_t
*)ARG4
);
6535 VG_(dmsg
)("Warning: Bad oldlenp address %p in sysctlbyname\n",
6536 (void *)(Addr
)ARG4
);
6537 SET_STATUS_Failure ( VKI_EFAULT
);
6541 PRE_MEM_WRITE("__sysctlbyname(oldlenp)", (Addr
)ARG4
, sizeof(vki_size_t
));
6546 POST(sys___sysctlbyname
)
6548 if (ARG4
!= (UWord
)NULL
) {
6549 if (ARG3
!= (UWord
)NULL
) {
6550 //POST_MEM_WRITE((Addr)ARG4, sizeof(vki_size_t));
6551 POST_MEM_WRITE((Addr
)ARG3
, *(vki_size_t
*)ARG4
);
6553 POST_MEM_WRITE((Addr
)ARG4
, sizeof(vki_size_t
));
6558 #endif // (FREEBSD_VERS >= FREEBSD_12_2)
6560 #if (FREEBSD_VERS >= FREEBSD_13_0)
6562 // SYS_shm_open2 571
6563 // from syscalls.master
6564 // int shm_open2(_In_z_ const char *path,
6568 // _In_z_ const char *name);
6571 PRE_REG_READ5(int, "shm_open2",
6572 const char *, path
, int, flags
, vki_mode_t
, mode
, int, shmflags
, const char*, name
);
6573 if (ARG1
== VKI_SHM_ANON
) {
6574 PRINT("sys_shm_open2(%#" FMT_REGWORD
"x(SHM_ANON), %" FMT_REGWORD
"u, %hu, %d, %#" FMT_REGWORD
"x(%s))",
6575 ARG1
, ARG2
, (vki_mode_t
)ARG3
, (Int
)ARG4
, ARG5
, (HChar
*)ARG5
);
6577 PRINT("sys_shm_open2(%#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u, %hu, %d, %#" FMT_REGWORD
"x(%s))",
6578 ARG1
, (HChar
*)ARG1
, ARG2
, (vki_mode_t
)ARG3
, (Int
)ARG4
, ARG5
, (HChar
*)ARG5
);
6579 PRE_MEM_RASCIIZ( "shm_open2(path)", ARG1
);
6583 PRE_MEM_RASCIIZ( "shm_open2(name)", ARG5
);
6585 *flags
|= SfMayBlock
;
6591 if (!ML_(fd_allowed
)(RES
, "shm_open2", tid
, True
)) {
6593 SET_STATUS_Failure( VKI_EMFILE
);
6595 if (VG_(clo_track_fds
)) {
6596 ML_(record_fd_open_with_given_name
)(tid
, RES
, (HChar
*)ARG1
);
6602 // int sigfastblock(int cmd, void *ptr);
6603 PRE(sys_sigfastblock
)
6605 PRINT("sys_sigfastblock ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x )", SARG1
, ARG2
);
6606 PRE_REG_READ2(int, "sigfasblock", int, cmd
, void*, ptr
);
6609 // SYS___realpathat 574
6610 // from syscalls.master
6611 // int __realpathat(int fd,
6612 // _In_z_ const char *path,
6613 // _Out_writes_z_(size) char *buf,
6616 PRE(sys___realpathat
)
6618 PRINT("sys___realpathat ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x(%s), %#" FMT_REGWORD
"x, %" FMT_REGWORD
"u %" FMT_REGWORD
"d )",
6619 SARG1
,ARG2
,(const char*)ARG2
,ARG3
,ARG4
,SARG5
);
6620 PRE_REG_READ5(int, "__realpathat", int, fd
, const char *, path
,
6621 char *, buf
, vki_size_t
, size
, int, flags
);
6622 PRE_MEM_RASCIIZ("__realpathat(path)", (Addr
)ARG2
);
6623 PRE_MEM_WRITE("__realpathat(buf)", (Addr
)ARG3
, ARG4
);
6626 POST(sys___realpathat
)
6628 POST_MEM_WRITE((Addr
)ARG3
, ARG4
);
6631 // SYS___specialfd 577
6633 // int __specialfd(int type,
6634 // _In_reads_bytes_(len) const void *req,
6636 PRE(sys___specialfd
)
6638 PRINT("sys___specialfd ( %" FMT_REGWORD
"d, %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )",
6639 SARG1
,ARG2
,(const char*)ARG2
,ARG3
);
6640 PRE_REG_READ3(int, "__specialfd", int, type
, const void *, req
, vki_size_t
, len
);
6641 PRE_MEM_READ("__specialfd(req)", (Addr
)ARG2
, ARG3
);
6644 #endif // (FREEBSD_VERS >= FREEBSD_13_0)
6646 #if (FREEBSD_VERS >= FREEBSD_13_1)
6649 // int swapoff(const char *special, u_int flags);
6652 PRINT("sys_swapoff ( %#" FMT_REGWORD
"x(%s), %" FMT_REGWORD
"u )", ARG1
,(char *)ARG1
, ARG2
);
6653 PRE_REG_READ2(int, "swapoff", const char *, special
, u_int
, flags
);
6654 PRE_MEM_RASCIIZ( "swapoff(special)", ARG1
);
6662 const SyscallTableEntry
ML_(syscall_table
)[] = {
6663 // syscall (handled specially) // 0
6664 BSDX_(__NR_exit
, sys_exit
), // 1
6665 BSDX_(__NR_fork
, sys_fork
), // 2
6666 GENXY(__NR_read
, sys_read
), // 3
6668 GENX_(__NR_write
, sys_write
), // 4
6669 GENXY(__NR_open
, sys_open
), // 5
6670 GENXY(__NR_close
, sys_close
), // 6
6671 GENXY(__NR_wait4
, sys_wait4
), // 7
6674 GENX_(__NR_link
, sys_link
), // 9
6675 GENX_(__NR_unlink
, sys_unlink
), // 10
6678 GENX_(__NR_chdir
, sys_chdir
), // 12
6679 GENX_(__NR_fchdir
, sys_fchdir
), // 13
6680 GENX_(__NR_freebsd11_mknod
, sys_mknod
), // 14
6681 GENX_(__NR_chmod
, sys_chmod
), // 15
6683 GENX_(__NR_chown
, sys_chown
), // 16
6684 GENX_(__NR_break
, sys_brk
), // 17
6685 // freebsd 4 getfsstat 18
6688 GENX_(__NR_getpid
, sys_getpid
), // 20
6689 BSDX_(__NR_mount
, sys_mount
), // 21
6690 BSDX_(__NR_unmount
, sys_unmount
), // 22
6691 GENX_(__NR_setuid
, sys_setuid
), // 23
6693 GENX_(__NR_getuid
, sys_getuid
), // 24
6694 GENX_(__NR_geteuid
, sys_geteuid
), // 25
6695 BSDXY(__NR_ptrace
, sys_ptrace
), // 26
6696 BSDXY(__NR_recvmsg
, sys_recvmsg
), // 27
6698 BSDX_(__NR_sendmsg
, sys_sendmsg
), // 28
6699 BSDXY(__NR_recvfrom
, sys_recvfrom
), // 29
6700 BSDXY(__NR_accept
, sys_accept
), // 30
6701 BSDXY(__NR_getpeername
, sys_getpeername
), // 31
6703 BSDXY(__NR_getsockname
, sys_getsockname
), // 32
6704 GENX_(__NR_access
, sys_access
), // 33
6705 BSDX_(__NR_chflags
, sys_chflags
), // 34
6706 BSDX_(__NR_fchflags
, sys_fchflags
), // 35
6708 GENX_(__NR_sync
, sys_sync
), // 36
6709 GENX_(__NR_kill
, sys_kill
), // 37
6711 GENX_(__NR_getppid
, sys_getppid
), // 39
6714 GENXY(__NR_dup
, sys_dup
), // 41
6716 BSDXY(__NR_freebsd10_pipe
, sys_pipe
), // 42
6717 GENX_(__NR_getegid
, sys_getegid
), // 43
6719 GENX_(__NR_profil
, sys_ni_syscall
), // 44
6720 GENX_(__NR_ktrace
, sys_ni_syscall
), // 45
6722 GENX_(__NR_getgid
, sys_getgid
), // 47
6724 // 4.3 sigaction (int sigset) 48
6725 BSDXY(__NR_getlogin
, sys_getlogin
), // 49
6726 BSDX_(__NR_setlogin
, sys_setlogin
), // 50
6727 GENX_(__NR_acct
, sys_acct
), // 51
6729 // 4.3 sigpending 52
6730 GENXY(__NR_sigaltstack
, sys_sigaltstack
), // 53
6731 BSDXY(__NR_ioctl
, sys_ioctl
), // 54
6732 BSDX_(__NR_reboot
, sys_reboot
), // 55
6734 BSDX_(__NR_revoke
, sys_revoke
), // 56
6735 GENX_(__NR_symlink
, sys_symlink
), // 57
6736 BSDX_(__NR_readlink
, sys_readlink
), // 58
6737 GENX_(__NR_execve
, sys_execve
), // 59
6739 GENX_(__NR_umask
, sys_umask
), // 60
6740 GENX_(__NR_chroot
, sys_chroot
), // 61
6742 // 4.3 getgerninfo 63
6744 // 4.3 getpagesize 64
6745 GENX_(__NR_msync
, sys_msync
), // 65
6746 BSDX_(__NR_vfork
, sys_vfork
), // 66
6750 BSDX_(__NR_sbrk
, sys_sbrk
), // 69
6751 // not implemented in OS sstk 70
6754 // freebsd11 vadvise 72
6755 GENXY(__NR_munmap
, sys_munmap
), // 73
6756 GENXY(__NR_mprotect
, sys_mprotect
), // 74
6757 GENX_(__NR_madvise
, sys_madvise
), // 75
6761 GENXY(__NR_mincore
, sys_mincore
), // 78
6762 GENXY(__NR_getgroups
, sys_getgroups
), // 79
6764 GENX_(__NR_setgroups
, sys_setgroups
), // 80
6765 GENX_(__NR_getpgrp
, sys_getpgrp
), // 81
6766 GENX_(__NR_setpgid
, sys_setpgid
), // 82
6767 GENXY(__NR_setitimer
, sys_setitimer
), // 83
6770 BSDX_(__NR_swapon
, sys_swapon
), // 85
6771 GENXY(__NR_getitimer
, sys_getitimer
), // 86
6772 // 4.3 gethostname 87
6774 // 4.3 sethostname 88
6775 BSDX_(__NR_getdtablesize
, sys_getdtablesize
), // 89
6776 GENXY(__NR_dup2
, sys_dup2
), // 90
6778 BSDXY(__NR_fcntl
, sys_fcntl
), // 92
6779 GENX_(__NR_select
, sys_select
), // 93
6780 GENX_(__NR_fsync
, sys_fsync
), // 95
6782 GENX_(__NR_setpriority
, sys_setpriority
), // 96
6783 BSDXY(__NR_socket
, sys_socket
), // 97
6784 BSDX_(__NR_connect
, sys_connect
), // 98
6787 GENX_(__NR_getpriority
, sys_getpriority
), // 100
6790 // 4.3 sigreturn 103
6792 BSDX_(__NR_bind
, sys_bind
), // 104
6793 BSDX_(__NR_setsockopt
, sys_setsockopt
), // 105
6794 BSDX_(__NR_listen
, sys_listen
), // 106
6799 // 4.3 sigsetmask 110
6800 // 4.3 sigsuspend 111
6807 GENXY(__NR_gettimeofday
, sys_gettimeofday
), // 116
6808 GENXY(__NR_getrusage
, sys_getrusage
), // 117
6809 BSDXY(__NR_getsockopt
, sys_getsockopt
), // 118
6811 GENXY(__NR_readv
, sys_readv
), // 120
6812 GENX_(__NR_writev
, sys_writev
), // 121
6813 GENX_(__NR_settimeofday
, sys_settimeofday
), // 122
6814 GENX_(__NR_fchown
, sys_fchown
), // 123
6816 GENX_(__NR_fchmod
, sys_fchmod
), // 124
6818 GENX_(__NR_setreuid
, sys_setreuid
), // 126
6819 GENX_(__NR_setregid
, sys_setregid
), // 127
6821 GENX_(__NR_rename
, sys_rename
), // 128
6823 // 4.3 ftruncate 130
6824 GENX_(__NR_flock
, sys_flock
), // 131
6826 BSDX_(__NR_mkfifo
, sys_mkfifo
), // 132
6827 BSDX_(__NR_sendto
, sys_sendto
), // 133
6828 BSDX_(__NR_shutdown
, sys_shutdown
), // 134
6829 BSDXY(__NR_socketpair
, sys_socketpair
), // 135
6831 GENX_(__NR_mkdir
, sys_mkdir
), // 136
6832 GENX_(__NR_rmdir
, sys_rmdir
), // 137
6833 GENX_(__NR_utimes
, sys_utimes
), // 138
6834 // 4.2 sigreturn 139
6836 BSDXY(__NR_adjtime
, sys_adjtime
), // 140
6837 // 4.3 getpeername 141
6838 // 4.3 gethostid 142
6839 // 4.3 sethostid 143
6841 // 4.3 getrlimit` 144
6842 // 4.3 setrlimit 145
6844 GENX_(__NR_setsid
, sys_setsid
), // 147
6846 BSDX_(__NR_quotactl
, sys_quotactl
), // 148
6848 // 4.3 getsockname 150
6849 // bsd/os sem_lock 151
6851 // bsd/os sem_wakeup 152
6852 // bsd/os asyncdaemon 153
6854 // no idea what the following syscall does
6855 // unimp SYS_nlm_syscall 154
6857 // a somewhat complicated NFS API
6858 // takes a flag and a void* that can point to one of
6859 // three different types of struct depending on the flag
6860 // unimp SYS_nfssvc 155
6862 // 4.3 getdirentries 156
6863 // freebsd 4 statfs 157
6864 // freebsd 4 fstatfs 158
6866 BSDXY(__NR_lgetfh
, sys_lgetfh
), // 160
6867 BSDXY(__NR_getfh
, sys_getfh
), // 161
6868 #if (FREEBSD_VERS <= FREEBSD_10)
6869 BSDXY(__NR_freebsd4_getdomainname
, sys_freebsd4_getdomainname
), // 162
6870 BSDX_(__NR_freebsd4_setdomainname
, sys_freebsd4_setdomainname
), // 163
6871 BSDXY(__NR_freebsd4_uname
, sys_freebsd4_uname
), // 164
6873 BSDXY(__NR_sysarch
, sys_sysarch
), // 165
6874 BSDXY(__NR_rtprio
, sys_rtprio
), // 166
6876 // the following 3 seem only to be defines in a header
6881 #if (FREEBSD_VERS <= FREEBSD_10)
6882 BSDXY(__NR_freebsd6_pread
, sys_freebsd6_pread
), // 173
6883 BSDX_(__NR_freebsd6_pwrite
, sys_freebsd6_pwrite
), // 174
6885 BSDX_(__NR_setfib
, sys_setfib
), // 175
6887 // @todo PJF this exists on Darwin and Solaris as well
6888 // and it isn't implememented on either
6889 // looking at the manpage there is a rather fearsome
6890 // timex struct with a mixture of ro and rw fields
6891 // BSDXY(__NR_ntp_adjtime, sys_ntp_adjtime), // 176
6894 // bsd/os getdescriptor 178
6895 // bsd/os setdescriptor 179
6897 GENX_(__NR_setgid
, sys_setgid
), // 181
6898 BSDX_(__NR_setegid
, sys_setegid
), // 182
6899 BSDX_(__NR_seteuid
, sys_seteuid
), // 183
6901 // obs lfs_bmapv 184
6902 // obs lfs_markv 185
6903 // obs lfs_segclean 186
6904 // obs lfs_segwait 187
6906 #if (FREEBSD_VERS >= FREEBSD_12)
6907 BSDXY(__NR_freebsd11_stat
, sys_freebsd11_stat
), // 188
6908 BSDXY(__NR_freebsd11_fstat
, sys_freebsd11_fstat
), // 189
6909 BSDXY(__NR_freebsd11_lstat
, sys_freebsd11_lstat
), // 190
6911 BSDXY(__NR_stat
, sys_stat
), // 188
6912 BSDXY(__NR_fstat
, sys_fstat
), // 189
6913 BSDXY(__NR_lstat
, sys_lstat
), // 190
6915 BSDX_(__NR_pathconf
, sys_pathconf
), // 191
6916 BSDX_(__NR_fpathconf
, sys_fpathconf
), // 192
6917 GENXY(__NR_getrlimit
, sys_getrlimit
), // 194
6918 GENX_(__NR_setrlimit
, sys_setrlimit
), // 195
6919 #if (FREEBSD_VERS >= FREEBSD_12)
6920 BSDXY(__NR_freebsd11_getdirentries
, sys_freebsd11_getdirentries
), // 196
6922 BSDXY(__NR_getdirentries
, sys_getdirentries
), // 196
6924 #if (FREEBSD_VERS <= FREEBSD_10)
6925 BSDX_(__NR_freebsd6_mmap
, sys_freebsd6_mmap
), // 197
6927 // __syscall (handled specially) // 198
6928 #if (FREEBSD_VERS <= FREEBSD_10)
6929 BSDX_(__NR_freebsd6_lseek
, sys_freebsd6_lseek
), // 199
6930 BSDX_(__NR_freebsd6_truncate
, sys_freebsd6_truncate
), // 200
6931 BSDX_(__NR_freebsd6_ftruncate
, sys_freebsd6_ftruncate
), // 201
6933 BSDXY(__NR___sysctl
, sys___sysctl
), // 202
6934 GENX_(__NR_mlock
, sys_mlock
), // 203
6936 GENX_(__NR_munlock
, sys_munlock
), // 204
6937 BSDX_(__NR_undelete
, sys_undelete
), // 205
6938 BSDX_(__NR_futimes
, sys_futimes
), // 206
6939 GENX_(__NR_getpgid
, sys_getpgid
), // 207
6941 // netbsd newreboot 208
6942 GENXY(__NR_poll
, sys_poll
), // 209
6944 BSDXY(__NR_freebsd7___semctl
, sys_freebsd7___semctl
), // 220
6945 BSDX_(__NR_semget
, sys_semget
), // 221
6946 BSDX_(__NR_semop
, sys_semop
), // 222
6947 // obs semconfig 223
6949 BSDXY(__NR_freebsd7_msgctl
, sys_freebsd7_msgctl
), // 224
6950 BSDX_(__NR_msgget
, sys_msgget
), // 225
6951 BSDX_(__NR_msgsnd
, sys_msgsnd
), // 226
6952 BSDXY(__NR_msgrcv
, sys_msgrcv
), // 227
6954 BSDXY(__NR_shmat
, sys_shmat
), // 228
6955 BSDXY(__NR_freebsd7_shmctl
, sys_freebsd7_shmctl
), // 229
6956 BSDXY(__NR_shmdt
, sys_shmdt
), // 230
6957 BSDX_(__NR_shmget
, sys_shmget
), // 231
6959 BSDXY(__NR_clock_gettime
, sys_clock_gettime
), // 232
6960 BSDX_(__NR_clock_settime
, sys_clock_settime
), // 233
6961 BSDXY(__NR_clock_getres
, sys_clock_getres
), // 234
6962 BSDXY(__NR_ktimer_create
, sys_timer_create
), // 235
6963 BSDX_(__NR_ktimer_delete
, sys_timer_delete
), // 236
6964 BSDXY(__NR_ktimer_settime
, sys_timer_settime
), // 237
6965 BSDXY(__NR_ktimer_gettime
, sys_timer_gettime
), // 238
6966 BSDX_(__NR_ktimer_getoverrun
, sys_timer_getoverrun
), // 239
6968 GENXY(__NR_nanosleep
, sys_nanosleep
), // 240
6969 // unimpl SYS_ffclock_getcounter 241
6970 // unimpl SYS_ffclock_setestimate 242
6971 // unimpl SYS_ffclock_getestimate 243
6973 BSDXY(__NR_clock_nanosleep
, sys_clock_nanosleep
), // 244
6974 BSDXY(__NR_clock_getcpuclockid2
, sys_clock_getcpuclockid2
), // 247
6976 // unimpl SYS_ntp_gettime 248
6977 BSDXY(__NR_minherit
, sys_minherit
), // 250
6978 BSDX_(__NR_rfork
, sys_rfork
), // 251
6980 // openbsd_poll // 252
6981 BSDX_(__NR_issetugid
, sys_issetugid
), // 253
6982 GENX_(__NR_lchown
, sys_lchown
), // 254
6983 BSDXY(__NR_aio_read
, sys_aio_read
), // 255
6984 BSDXY(__NR_aio_write
, sys_aio_write
), // 256
6985 BSDX_(__NR_lio_listio
, sys_lio_listio
), // 257
6987 GENXY(__NR_freebsd11_getdents
, sys_getdents
), // 272
6988 BSDX_(__NR_lchmod
, sys_lchmod
), // 274
6989 // netbsd_lchown // 275
6991 BSDX_(__NR_lutimes
, sys_lutimes
), // 276
6993 // unimpl SYS_freebsd11_nstat 278
6994 // unimpl SYS_freebsd11_nfstat 279
6996 // unimpl SYS_freebsd11_nlstat 280
6998 BSDXY(__NR_preadv
, sys_preadv
), // 289
6999 BSDX_(__NR_pwritev
, sys_pwritev
), // 290
7001 // freebsd 4 fhstatfs 297
7002 BSDXY(__NR_fhopen
, sys_fhopen
), // 298
7003 #if (FREEBSD_VERS >= FREEBSD_12)
7004 BSDXY(__NR_freebsd11_fhstat
, sys_freebsd11_fhstat
), // 299
7006 BSDXY(__NR_fhstat
, sys_fhstat
), // 299
7009 BSDX_(__NR_modnext
, sys_modnext
), // 300
7010 BSDXY(__NR_modstat
, sys_modstat
), // 301
7011 BSDX_(__NR_modfnext
, sys_modfnext
), // 302
7012 BSDX_(__NR_modfind
, sys_modfind
), // 303
7014 BSDX_(__NR_kldload
, sys_kldload
), // 304
7015 BSDX_(__NR_kldunload
, sys_kldunload
), // 305
7016 BSDX_(__NR_kldfind
, sys_kldfind
), // 306
7017 BSDX_(__NR_kldnext
, sys_kldnext
), // 307
7019 BSDXY(__NR_kldstat
, sys_kldstat
), // 308
7020 BSDX_(__NR_kldfirstmod
, sys_kldfirstmod
), // 309
7021 GENX_(__NR_getsid
, sys_getsid
), // 310
7022 BSDX_(__NR_setresuid
, sys_setresuid
), // 311
7024 BSDX_(__NR_setresgid
, sys_setresgid
), // 312
7025 // obsol signanosleep 313
7026 BSDX_(__NR_aio_return
, sys_aio_return
), // 314
7027 BSDX_(__NR_aio_suspend
, sys_aio_suspend
), // 315
7029 BSDX_(__NR_aio_cancel
, sys_aio_cancel
), // 316
7030 BSDX_(__NR_aio_error
, sys_aio_error
), // 317
7031 // freebsd 6 aio_read 318
7032 // freebsd 6 aio_write 319
7033 // freebsd 6 lio_listio 320
7034 BSDX_(__NR_yield
, sys_yield
), // 321
7035 // obs thr_sleep 322
7036 // obs thr_wakeup 323
7038 GENX_(__NR_mlockall
, sys_mlockall
), // 324
7039 BSDX_(__NR_munlockall
, sys_munlockall
), // 325
7040 BSDXY(__NR___getcwd
, sys___getcwd
), // 326
7041 BSDX_(__NR_sched_setparam
, sys_sched_setparam
), // 327
7042 BSDXY(__NR_sched_getparam
, sys_sched_getparam
), // 328
7043 BSDX_(__NR_sched_setscheduler
, sys_sched_setscheduler
), // 329
7044 BSDX_(__NR_sched_getscheduler
, sys_sched_getscheduler
), // 330
7045 BSDX_(__NR_sched_yield
, sys_sched_yield
), // 331
7047 BSDX_(__NR_sched_get_priority_max
, sys_sched_get_priority_max
), // 332
7048 BSDX_(__NR_sched_get_priority_min
, sys_sched_get_priority_min
), // 333
7049 BSDXY(__NR_sched_rr_get_interval
, sys_sched_rr_get_interval
), // 334
7050 BSDX_(__NR_utrace
, sys_utrace
), // 335
7052 // freebsd 4 sendfile 336
7053 BSDXY(__NR_kldsym
, sys_kldsym
), // 337
7054 BSDX_(__NR_jail
, sys_jail
), // 338
7055 // unimpl SYS_nnpfs_syscall 339
7057 BSDXY(__NR_sigprocmask
, sys_sigprocmask
), // 340
7058 BSDXY(__NR_sigsuspend
, sys_sigsuspend
), // 341
7059 // freebsd 4 sigaction 342
7060 BSDXY(__NR_sigpending
, sys_sigpending
), // 343
7062 // freebsd 4 sigreturn 344
7063 BSDXY(__NR_sigtimedwait
, sys_sigtimedwait
), // 345
7064 BSDXY(__NR_sigwaitinfo
, sys_sigwaitinfo
), // 346
7065 BSDXY(__NR___acl_get_file
, sys___acl_get_file
), // 347
7067 BSDX_(__NR___acl_set_file
, sys___acl_set_file
), // 348
7068 BSDXY(__NR___acl_get_fd
, sys___acl_get_fd
), // 349
7069 BSDX_(__NR___acl_set_fd
, sys___acl_set_fd
), // 350
7070 BSDX_(__NR___acl_delete_file
, sys___acl_delete_file
), // 351
7072 BSDX_(__NR___acl_delete_fd
, sys___acl_delete_fd
), // 352
7073 BSDX_(__NR___acl_aclcheck_file
, sys___acl_aclcheck_file
), // 353
7074 BSDX_(__NR___acl_aclcheck_fd
, sys___acl_aclcheck_fd
), // 354
7075 BSDX_(__NR_extattrctl
, sys_extattrctl
), // 355
7076 BSDX_(__NR_extattr_set_file
, sys_extattr_set_file
), // 356
7077 BSDXY(__NR_extattr_get_file
, sys_extattr_get_file
), // 357
7078 BSDX_(__NR_extattr_delete_file
, sys_extattr_delete_file
), // 358
7079 BSDXY(__NR_aio_waitcomplete
, sys_aio_waitcomplete
), // 359
7081 BSDXY(__NR_getresuid
, sys_getresuid
), // 360
7082 BSDXY(__NR_getresgid
, sys_getresgid
), // 361
7083 BSDXY(__NR_kqueue
, sys_kqueue
), // 362
7084 #if (FREEBSD_VERS >= FREEBSD_12)
7085 BSDXY(__NR_freebsd11_kevent
, sys_freebsd11_kevent
), // 363
7087 BSDXY(__NR_kevent
, sys_kevent
), // 363
7089 // obs __cap_get_proc 364
7090 // obs __cap_set_proc 365
7091 // obs __cap_get_fd 366
7092 // obs __cap_get_file 367
7093 // obs __cap_set_fd 368
7094 // obs __cap_set_file 369
7096 BSDX_(__NR_extattr_set_fd
, sys_extattr_set_fd
), // 371
7097 BSDXY(__NR_extattr_get_fd
, sys_extattr_get_fd
), // 372
7098 BSDX_(__NR_extattr_delete_fd
, sys_extattr_delete_fd
), // 373
7099 BSDX_(__NR___setugid
, sys___setugid
), // 374
7102 BSDX_(__NR_eaccess
, sys_eaccess
), // 376
7103 // unimpl afs3_syscall 377
7104 BSDX_(__NR_nmount
, sys_nmount
), // 378
7106 // obs kse_wakeup 380
7107 // obs kse_create 381
7108 // obs kse_thr_interrupt 382
7109 // obs kse_release 383
7111 // unimpl __mac_get_proc 384
7112 // unimpl __mac_set_proc 385
7113 // unimpl __mac_get_fd 386
7114 // unimpl __mac_get_file 387
7115 // unimpl __mac_set_fd 388
7116 // unimpl __mac_set_file 389
7117 BSDXY(__NR_kenv
, sys_kenv
), // 390
7118 BSDX_(__NR_lchflags
, sys_lchflags
), // 391
7120 BSDXY(__NR_uuidgen
, sys_uuidgen
), // 392
7121 BSDXY(__NR_sendfile
, sys_sendfile
), // 393
7122 // unimpl mac_syscall 394
7124 #if (FREEBSD_VERS >= FREEBSD_12)
7125 BSDXY(__NR_freebsd11_getfsstat
, sys_freebsd11_getfsstat
), // 395
7126 BSDXY(__NR_freebsd11_statfs
, sys_statfs
), // 396
7127 BSDXY(__NR_freebsd11_fstatfs
, sys_fstatfs
), // 397
7128 BSDXY(__NR_freebsd11_fhstatfs
, sys_fhstatfs
), // 398
7130 BSDXY(__NR_getfsstat
, sys_getfsstat
), // 395
7131 BSDXY(__NR_statfs
, sys_statfs
), // 396
7132 BSDXY(__NR_fstatfs
, sys_fstatfs
), // 397
7133 BSDXY(__NR_fhstatfs
, sys_fhstatfs
), // 398
7136 // unimpl ksem_close 400
7137 // unimpl ksem_post 401
7138 // unimpl ksem_wait 402
7139 // unimpl ksem_trywait 403
7141 // unimpl ksem_init 404
7142 // unimpl ksem_open 405
7143 // unimpl ksem_unlink 406
7144 // unimpl ksem_getvalue 407
7146 // unimpl ksem_destroy 408
7147 // unimpl __mac_get_pid 409
7148 // unimpl __mac_get_link 410
7149 // unimpl __mac_set_link 411
7151 BSDX_(__NR_extattr_set_link
, sys_extattr_set_link
), // 412
7152 BSDXY(__NR_extattr_get_link
, sys_extattr_get_link
), // 413
7153 BSDX_(__NR_extattr_delete_link
, sys_extattr_delete_link
), // 414
7154 // unimpl __mac_execve 415
7156 BSDXY(__NR_sigaction
, sys_sigaction
), // 416
7157 BSDX_(__NR_sigreturn
, sys_sigreturn
), // 417
7159 BSDXY(__NR_getcontext
, sys_getcontext
), // 421
7160 BSDX_(__NR_setcontext
, sys_setcontext
), // 422
7161 BSDXY(__NR_swapcontext
, sys_swapcontext
), // 423
7163 #if (FREEBSD_VERS >= FREEBSD_13_1)
7164 BSDX_(__NR_freebsd13_swapoff
, sys_freebsd13_swapoff
), // 424
7166 BSDX_(__NR_swapoff
, sys_swapoff
), // 424
7168 BSDXY(__NR___acl_get_link
, sys___acl_get_link
), // 425
7169 BSDX_(__NR___acl_set_link
, sys___acl_set_link
), // 426
7170 BSDX_(__NR___acl_delete_link
, sys___acl_delete_link
), // 427
7172 BSDX_(__NR___acl_aclcheck_link
, sys___acl_aclcheck_link
), // 428
7173 BSDXY(__NR_sigwait
, sys_sigwait
), // 429
7174 BSDX_(__NR_thr_create
, sys_thr_create
), // 430
7175 BSDX_(__NR_thr_exit
, sys_thr_exit
), // 431
7177 BSDXY(__NR_thr_self
, sys_thr_self
), // 432
7178 BSDXY(__NR_thr_kill
, sys_thr_kill
), // 433
7179 #if (FREEBSD_VERS <= FREEBSD_10)
7180 BSDXY(__NR__umtx_lock
, sys__umtx_lock
), // 434
7181 BSDXY(__NR__umtx_unlock
, sys__umtx_unlock
), // 435
7184 BSDX_(__NR_jail_attach
, sys_jail_attach
), // 436
7185 BSDXY(__NR_extattr_list_fd
, sys_extattr_list_fd
), // 437
7186 BSDXY(__NR_extattr_list_file
, sys_extattr_list_file
), // 438
7187 BSDXY(__NR_extattr_list_link
, sys_extattr_list_link
), // 439
7189 // obs kse_switchin 440
7190 // unimpl ksem_timedwait 441
7191 BSDX_(__NR_thr_suspend
, sys_thr_suspend
), // 442
7192 BSDX_(__NR_thr_wake
, sys_thr_wake
), // 443
7193 BSDX_(__NR_kldunloadf
, sys_kldunloadf
), // 444
7195 // unimpl auditon 446
7196 // unimpl getauid 447
7198 // unimpl setauid 448
7199 // unimpl getaudit 449
7200 // unimpl setaudit 450
7201 // unimpl getaudit_addr 451
7202 // unimpl setaudit_addr 452
7203 // unimpl auditctl 453
7204 BSDXY(__NR__umtx_op
, sys__umtx_op
), // 454
7205 BSDX_(__NR_thr_new
, sys_thr_new
), // 455
7207 BSDX_(__NR_sigqueue
, sys_sigqueue
), // 456
7208 BSDXY(__NR_kmq_open
, sys_kmq_open
), // 457
7209 BSDX_(__NR_kmq_setattr
, sys_kmq_setattr
), // 458
7210 BSDXY(__NR_kmq_timedreceive
, sys_kmq_timedreceive
), // 459
7212 BSDX_(__NR_kmq_timedsend
, sys_kmq_timedsend
), // 460
7213 BSDX_(__NR_kmq_notify
, sys_kmq_notify
), // 461
7214 BSDX_(__NR_kmq_unlink
, sys_kmq_unlink
), // 462
7215 BSDX_(__NR_abort2
, sys_abort2
), // 463
7217 BSDX_(__NR_thr_set_name
, sys_thr_set_name
), // 464
7218 BSDX_(__NR_aio_fsync
, sys_aio_fsync
), // 465
7219 BSDXY(__NR_rtprio_thread
, sys_rtprio_thread
), // 466
7221 // unimpl sctp_peeloff 471
7222 BSDX_(__NR_sctp_generic_sendmsg
, sys_sctp_generic_sendmsg
), // 472
7223 // unimpl sctp_generic_sendmsg_iov 473
7224 BSDXY(__NR_sctp_generic_recvmsg
, sys_sctp_generic_recvmsg
), // 474
7225 BSDXY(__NR_pread
, sys_pread
), // 475
7227 BSDX_(__NR_pwrite
, sys_pwrite
), // 476
7228 BSDX_(__NR_mmap
, sys_mmap
), // 477
7229 BSDX_(__NR_lseek
, sys_lseek
), // 478
7230 BSDX_(__NR_truncate
, sys_truncate
), // 479
7231 BSDX_(__NR_ftruncate
, sys_ftruncate
), // 480
7232 BSDXY(__NR_thr_kill2
, sys_thr_kill2
), // 481
7233 BSDXY(__NR_shm_open
, sys_shm_open
), // 482
7234 BSDX_(__NR_shm_unlink
, sys_shm_unlink
), // 483
7236 BSDXY(__NR_cpuset
, sys_cpuset
), // 484
7237 BSDX_(__NR_cpuset_setid
, sys_cpuset_setid
), // 485
7238 BSDXY(__NR_cpuset_getid
, sys_cpuset_getid
), // 486
7240 BSDXY(__NR_cpuset_getaffinity
, sys_cpuset_getaffinity
), // 487
7241 BSDX_(__NR_cpuset_setaffinity
, sys_cpuset_setaffinity
), // 488
7242 BSDX_(__NR_faccessat
, sys_faccessat
), // 489
7243 BSDX_(__NR_fchmodat
, sys_fchmodat
), // 490
7244 BSDX_(__NR_fchownat
, sys_fchownat
), // 491
7246 BSDX_(__NR_fexecve
, sys_fexecve
), // 492
7247 #if (FREEBSD_VERS >= FREEBSD_12)
7248 BSDXY(__NR_freebsd11_fstatat
, sys_freebsd11_fstatat
), // 493
7250 BSDXY(__NR_fstatat
, sys_fstatat
), // 493
7252 BSDX_(__NR_futimesat
, sys_futimesat
), // 494
7253 BSDX_(__NR_linkat
, sys_linkat
), // 495
7255 BSDX_(__NR_mkdirat
, sys_mkdirat
), // 496
7256 BSDX_(__NR_mkfifoat
, sys_mkfifoat
), // 497
7258 #if (FREEBSD_VERS >= FREEBSD_12)
7259 BSDX_(__NR_freebsd11_mknodat
, sys_freebsd11_mknodat
), // 498
7261 BSDX_(__NR_mknodat
, sys_mknodat
), // 498
7264 BSDXY(__NR_openat
, sys_openat
), // 499
7266 BSDXY(__NR_readlinkat
, sys_readlinkat
), // 500
7267 BSDX_(__NR_renameat
, sys_renameat
), // 501
7268 BSDX_(__NR_symlinkat
, sys_symlinkat
), // 502
7269 BSDX_(__NR_unlinkat
, sys_unlinkat
), // 503
7271 BSDX_(__NR_posix_openpt
, sys_posix_openpt
), // 504
7272 // unimp gssd_syscall 505
7273 BSDX_(__NR_jail_get
, sys_jail_get
), // 506
7274 BSDX_(__NR_jail_set
, sys_jail_set
), // 507
7275 BSDX_(__NR_jail_remove
, sys_jail_remove
), // 508
7276 BSDX_(__NR_closefrom
, sys_closefrom
), // 509
7277 BSDXY(__NR___semctl
, sys___semctl
), // 510
7278 BSDXY(__NR_msgctl
, sys_msgctl
), // 511
7279 BSDXY(__NR_shmctl
, sys_shmctl
), // 512
7280 BSDX_(__NR_lpathconf
, sys_lpathconf
), // 513
7281 /* 514 is obsolete cap_new */
7282 BSDXY(__NR___cap_rights_get
, sys_cap_rights_get
), // 515
7283 BSDX_(__NR_cap_enter
, sys_cap_enter
), // 516
7284 BSDXY(__NR_cap_getmode
, sys_cap_getmode
), // 517
7285 BSDXY(__NR_pdfork
, sys_pdfork
), // 518
7286 BSDX_(__NR_pdkill
, sys_pdkill
), // 519
7287 BSDXY(__NR_pdgetpid
, sys_pdgetpid
), // 520
7288 BSDXY(__NR_pselect
, sys_pselect
), // 522
7289 BSDXY(__NR_getloginclass
, sys_getloginclass
), // 523
7290 BSDX_(__NR_setloginclass
, sys_setloginclass
), // 524
7291 BSDXY(__NR_rctl_get_racct
, sys_rctl_get_racct
), // 525
7292 BSDXY(__NR_rctl_get_rules
, sys_rctl_get_rules
), // 526
7293 BSDXY(__NR_rctl_get_limits
, sys_rctl_get_limits
), // 527
7294 BSDXY(__NR_rctl_add_rule
, sys_rctl_add_rule
), // 528
7295 BSDXY(__NR_rctl_remove_rule
, sys_rctl_remove_rule
), // 529
7296 BSDX_(__NR_posix_fallocate
, sys_posix_fallocate
), // 530
7297 BSDX_(__NR_posix_fadvise
, sys_posix_fadvise
), // 531
7298 BSDXY(__NR_wait6
, sys_wait6
), // 532
7299 BSDX_(__NR_cap_rights_limit
, sys_cap_rights_limit
), // 533
7300 BSDX_(__NR_cap_ioctls_limit
, sys_cap_ioctls_limit
), // 534
7301 BSDXY(__NR_cap_ioctls_get
, sys_cap_ioctls_get
), // 535
7302 BSDX_(__NR_cap_fcntls_limit
, sys_cap_fcntls_limit
), // 536
7303 BSDXY(__NR_cap_fcntls_get
, sys_cap_fcntls_get
), // 537
7304 BSDX_(__NR_bindat
, sys_bindat
), // 538
7305 BSDX_(__NR_connectat
, sys_connectat
), // 539
7306 BSDX_(__NR_chflagsat
, sys_chflagsat
), // 540
7307 BSDXY(__NR_accept4
, sys_accept4
), // 541
7308 BSDXY(__NR_pipe2
, sys_pipe2
), // 542
7309 BSDX_(__NR_aio_mlock
, sys_aio_mlock
), // 543
7310 BSDXY(__NR_procctl
, sys_procctl
), // 544
7312 // 544 is the highest syscall on FreeBSD 9
7314 #if (FREEBSD_VERS >= FREEBSD_10)
7316 BSDXY(__NR_ppoll
, sys_ppoll
), // 545
7317 BSDX_(__NR_futimens
, sys_futimens
), // 546
7318 BSDX_(__NR_utimensat
, sys_utimensat
), // 547
7320 #endif // FREEBSD_VERS >= FREEBSD_10
7322 #if (FREEBSD_VERS >= FREEBSD_11)
7324 /* 548 is obsolete numa_getaffinity */
7325 /* 549 is obsolete numa_setaffinity */
7326 BSDX_(__NR_fdatasync
, sys_fdatasync
), // 550
7328 #endif // FREEBSD_VERS >= FREEBSD_11
7330 #if (FREEBSD_VERS >= FREEBSD_12)
7331 BSDXY(__NR_fstat
, sys_fstat
), // 551
7332 BSDXY(__NR_fstatat
, sys_fstatat
), // 552
7333 BSDXY(__NR_fhstat
, sys_fhstat
), // 553
7334 BSDXY(__NR_getdirentries
, sys_getdirentries
), // 554
7335 BSDXY(__NR_statfs
, sys_statfs
), // 555
7336 BSDXY(__NR_fstatfs
, sys_fstatfs
), // 556
7337 BSDXY(__NR_getfsstat
, sys_getfsstat
), // 557
7338 BSDXY(__NR_fhstatfs
, sys_fhstatfs
), // 558
7339 BSDX_(__NR_mknodat
, sys_mknodat
), // 559
7340 BSDXY(__NR_kevent
, sys_kevent
), // 560
7341 BSDXY(__NR_cpuset_getdomain
, sys_cpuset_getdomain
), // 561
7342 BSDX_(__NR_cpuset_setdomain
, sys_cpuset_setdomain
), // 562
7343 BSDXY(__NR_getrandom
, sys_getrandom
), // 563
7344 BSDXY(__NR_getfhat
, sys_getfhat
), // 564
7345 BSDX_(__NR_fhlink
, sys_fhlink
), // 565
7346 BSDX_(__NR_fhlinkat
, sys_fhlinkat
), // 566
7347 BSDXY(__NR_fhreadlink
, sys_fhreadlink
), // 567
7348 #endif // FREEBSD_VERS >= FREEBSD_12
7350 #if (FREEBSD_VERS >= FREEBSD_12_2)
7351 BSDX_(__NR_funlinkat
, sys_funlinkat
), // 568
7352 BSDX_(__NR_copy_file_range
, sys_copy_file_range
), // 569
7353 BSDXY(__NR___sysctlbyname
, sys___sysctlbyname
), // 570
7355 #if (FREEBSD_VERS >= FREEBSD_13_0)
7356 BSDXY(__NR_shm_open2
, sys_shm_open2
), // 571
7357 // unimpl __NR_shm_rename 572
7358 BSDX_(__NR_sigfastblock
, sys_sigfastblock
), // 573
7359 BSDXY( __NR___realpathat
, sys___realpathat
), // 574
7361 // unimpl __NR_close_range 575
7364 #if (FREEBSD_VERS >= FREEBSD_13_0)
7365 // unimpl __NR_rpctls_syscall 576
7366 BSDX_(__NR___specialfd
, sys___specialfd
), // 577
7367 // unimpl __NR_aio_writev 578
7368 // unimpl __NR_aio_readv 579
7371 #if (FREEBSD_VERS >= FREEBSD_13_1)
7372 // unimpl __NR_fspacectl 580
7373 // unimpl __NR_sched_getcpu 581
7374 BSDX_(__NR_swapoff
, sys_swapoff
), // 582
7377 BSDX_(__NR_fake_sigreturn
, sys_fake_sigreturn
), // 1000, fake sigreturn
7381 const SyscallTableEntry
* ML_(get_freebsd_syscall_entry
) ( UInt sysno
)
7383 const UInt syscall_table_size
7384 = sizeof(ML_(syscall_table
)) / sizeof(ML_(syscall_table
)[0]);
7386 /* Is it in the contiguous initial section of the table? */
7387 if (sysno
< syscall_table_size
) {
7388 const SyscallTableEntry
* sys
= &ML_(syscall_table
)[sysno
];
7389 if (sys
->before
== NULL
) {
7390 return NULL
; /* no entry */
7395 /* Can't find a wrapper */
7399 /*--------------------------------------------------------------------*/
7401 /*--------------------------------------------------------------------*/
7403 #endif // defined(VGO_freebsd)