1
2 /*--------------------------------------------------------------------*/
3 /*--- FreeBSD-specific syscalls, etc. syswrap-freebsd.c ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2000-2008 Nicholas Nethercote
11 njn@valgrind.org
12
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 02111-1307, USA.
27
28 The GNU General Public License is contained in the file COPYING.
29 */
30
31 #if defined(VGO_freebsd)
32
33 #include "pub_core_basics.h"
34 #include "pub_core_vki.h"
35 #include "pub_core_vkiscnums.h"
36 #include "pub_core_libcsetjmp.h" // to keep _threadstate.h happy
37 #include "pub_core_threadstate.h"
38 #include "pub_core_aspacemgr.h"
39 #include "pub_core_debuginfo.h" // VG_(di_notify_*)
40 #include "pub_core_transtab.h" // VG_(discard_translations)
41 #include "pub_core_xarray.h"
42 #include "pub_core_clientstate.h"
43 #include "pub_core_debuglog.h"
44 #include "pub_core_libcbase.h"
45 #include "pub_core_libcassert.h"
46 #include "pub_core_libcfile.h"
47 #include "pub_core_libcprint.h"
48 #include "pub_core_libcproc.h"
49 #include "pub_core_libcsignal.h"
50 #include "pub_core_machine.h"
51 #include "pub_core_mallocfree.h"
52 #include "pub_core_tooliface.h"
53 #include "pub_core_options.h"
54 #include "pub_core_scheduler.h"
55 #include "pub_core_signals.h"
56 #include "pub_core_syscall.h"
57 #include "pub_core_syswrap.h"
58
59 #include "priv_types_n_macros.h"
60 #include "priv_syswrap-generic.h"
61 #include "priv_syswrap-freebsd.h"
62
63
64 // Run a thread from beginning to end and return the thread's
65 // scheduler-return-code.
thread_wrapper(Word tidW)66 static VgSchedReturnCode thread_wrapper(Word /*ThreadId*/ tidW)
67 {
68 VgSchedReturnCode ret;
69 ThreadId tid = (ThreadId)tidW;
70 ThreadState* tst = VG_(get_ThreadState)(tid);
71
72 VG_(debugLog)(1, "syswrap-freebsd",
73 "thread_wrapper(tid=%lld): entry\n",
74 (ULong)tidW);
75
76 vg_assert(tst->status == VgTs_Init);
77
78 /* make sure we get the CPU lock before doing anything significant */
79 VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");
80
81 if (0)
82 VG_(printf)("thread tid %d started: stack = %p\n",
83 tid, &tid);
84
85 /* Make sure error reporting is enabled in the new thread. */
86 tst->err_disablement_level = 0;
87
88 VG_TRACK(pre_thread_first_insn, tid);
89
90 tst->os_state.lwpid = VG_(gettid)();
91 tst->os_state.threadgroup = VG_(getpid)();
92
93 /* Thread created with all signals blocked; scheduler will set the
94 appropriate mask */
95
96 ret = VG_(scheduler)(tid);
97
98 vg_assert(VG_(is_exiting)(tid));
99
100 vg_assert(tst->status == VgTs_Runnable);
101 vg_assert(VG_(is_running_thread)(tid));
102
103 VG_(debugLog)(1, "syswrap-freebsd",
104 "thread_wrapper(tid=%lld): exit\n",
105 (ULong)tidW);
106
107 /* Return to caller, still holding the lock. */
108 return ret;
109 }
110
111
112 /* ---------------------------------------------------------------------
113 clone-related stuff
114 ------------------------------------------------------------------ */
115
116 /* Run a thread all the way to the end, then do appropriate exit actions
117 (this is the last-one-out-turn-off-the-lights bit). */
run_a_thread_NORETURN(Word tidW)118 static void run_a_thread_NORETURN ( Word tidW )
119 {
120 ThreadId tid = (ThreadId)tidW;
121 VgSchedReturnCode src;
122 Int c;
123 ThreadState* tst;
124
125 VG_(debugLog)(1, "syswrap-freebsd",
126 "run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
127 (ULong)tidW);
128
129 tst = VG_(get_ThreadState)(tid);
130 vg_assert(tst);
131
132 /* Run the thread all the way through. */
133 src = thread_wrapper(tid);
134
135 VG_(debugLog)(1, "syswrap-freebsd",
136 "run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
137 (ULong)tidW);
138
139 c = VG_(count_living_threads)();
140 vg_assert(c >= 1); /* stay sane */
141
142 // Tell the tool this thread is exiting
143 VG_TRACK( pre_thread_ll_exit, tid );
144
145 /* If the thread is exiting with errors disabled, complain loudly;
146 doing so is bad (does the user know this has happened?) Also,
147 in all cases, be paranoid and clear the flag anyway so that the
148 thread slot is safe in this respect if later reallocated. This
149 should be unnecessary since the flag should be cleared when the
150 slot is reallocated, in thread_wrapper(). */
151 if (tst->err_disablement_level > 0) {
152 VG_(umsg)(
153 "WARNING: exiting thread has error reporting disabled.\n"
154 "WARNING: possibly as a result of some mistake in the use\n"
155 "WARNING: of the VALGRIND_DISABLE_ERROR_REPORTING macros.\n"
156 );
157 VG_(debugLog)(
158 1, "syswrap-freebsd",
159 "run_a_thread_NORETURN(tid=%lld): "
160 "WARNING: exiting thread has err_disablement_level = %u\n",
161 (ULong)tidW, tst->err_disablement_level
162 );
163 }
164 tst->err_disablement_level = 0;
165
166 if (c == 1) {
167
168 VG_(debugLog)(1, "syswrap-freebsd",
169 "run_a_thread_NORETURN(tid=%lld): "
170 "last one standing\n",
171 (ULong)tidW);
172
173 /* We are the last one standing. Keep hold of the lock and
174 carry on to show final tool results, then exit the entire system.
175 Use the continuation pointer set at startup in m_main. */
176 ( * VG_(address_of_m_main_shutdown_actions_NORETURN) ) (tid, src);
177
178 } else {
179
180 VG_(debugLog)(1, "syswrap-freebsd",
181 "run_a_thread_NORETURN(tid=%lld): "
182 "not last one standing\n",
183 (ULong)tidW);
184
185 /* OK, thread is dead, but others still exist. Just exit. */
186
187 /* This releases the run lock */
188 VG_(exit_thread)(tid);
189 vg_assert(tst->status == VgTs_Zombie);
190
191 /* We have to use this sequence to terminate the thread to
192 prevent a subtle race. If VG_(exit_thread)() had left the
193 ThreadState as Empty, then it could have been reallocated,
194 reusing the stack while we're doing these last cleanups.
195 Instead, VG_(exit_thread) leaves it as Zombie to prevent
196 reallocation. We need to make sure we don't touch the stack
197 between marking it Empty and exiting. Hence the
198 assembler. */
199 #if defined(VGP_x86_freebsd) /* FreeBSD has args on the stack */
200 asm volatile (
201 "movl %1, %0\n" /* set tst->status = VgTs_Empty */
202 "movl %2, %%eax\n" /* set %eax = __NR_thr_exit */
203 "movl %3, %%ebx\n" /* set %ebx = tst->os_state.exitcode */
204 "pushl %%ebx\n" /* arg on stack */
205 "pushl %%ebx\n" /* fake return address */
206 "int $0x80\n" /* thr_exit(tst->os_state.exitcode) */
207 "popl %%ebx\n" /* fake return address */
208 "popl %%ebx\n" /* arg off stack */
209 : "=m" (tst->status)
210 : "n" (VgTs_Empty), "n" (__NR_thr_exit), "m" (tst->os_state.exitcode)
211 : "eax", "ebx"
212 );
213 #elif defined(VGP_amd64_freebsd)
214 asm volatile (
215 "movl %1, %0\n" /* set tst->status = VgTs_Empty */
216 "movq %2, %%rax\n" /* set %rax = __NR_thr_exit */
217 "movq %3, %%rdi\n" /* set %rdi = tst->os_state.exitcode */
218 "pushq %%rdi\n" /* fake return address */
219 "syscall\n" /* thr_exit(tst->os_state.exitcode) */
220 "popq %%rdi\n" /* fake return address */
221 : "=m" (tst->status)
222 : "n" (VgTs_Empty), "n" (__NR_thr_exit), "m" (tst->os_state.exitcode)
223 : "rax", "rdi"
224 );
225 #else
226 # error Unknown platform
227 #endif
228
229 VG_(core_panic)("Thread exit failed?\n");
230 }
231
232 /*NOTREACHED*/
233 vg_assert(0);
234 }
235
ML_(start_thread_NORETURN)236 Word ML_(start_thread_NORETURN) ( void* arg )
237 {
238 ThreadState* tst = (ThreadState*)arg;
239 ThreadId tid = tst->tid;
240
241 run_a_thread_NORETURN ( (Word)tid );
242 /*NOTREACHED*/
243 vg_assert(0);
244 }
245
246 /* Allocate a stack for this thread, if it doesn't already have one.
247 They're allocated lazily, and never freed. Returns the initial stack
248 pointer value to use, or 0 if allocation failed. */
ML_(allocstack)249 Addr ML_(allocstack)(ThreadId tid)
250 {
251 ThreadState* tst = VG_(get_ThreadState)(tid);
252 VgStack* stack;
253 Addr initial_SP;
254
255 /* Either the stack_base and stack_init_SP are both zero (in which
256 case a stack hasn't been allocated) or they are both non-zero,
257 in which case it has. */
258
259 if (tst->os_state.valgrind_stack_base == 0)
260 vg_assert(tst->os_state.valgrind_stack_init_SP == 0);
261
262 if (tst->os_state.valgrind_stack_base != 0)
263 vg_assert(tst->os_state.valgrind_stack_init_SP != 0);
264
265 /* If no stack is present, allocate one. */
266
267 if (tst->os_state.valgrind_stack_base == 0) {
268 stack = VG_(am_alloc_VgStack)( &initial_SP );
269 if (stack) {
270 tst->os_state.valgrind_stack_base = (Addr)stack;
271 tst->os_state.valgrind_stack_init_SP = initial_SP;
272 }
273 }
274
275 if (0)
276 VG_(printf)( "stack for tid %d at %p; init_SP=%p\n",
277 tid,
278 (void*)tst->os_state.valgrind_stack_base,
279 (void*)tst->os_state.valgrind_stack_init_SP );
280
281 return tst->os_state.valgrind_stack_init_SP;
282 }
283
284 /* Allocate a stack for the main thread, and run it all the way to the
285 end. Although we already have a working VgStack
286 (VG_(interim_stack)) it's better to allocate a new one, so that
287 overflow detection works uniformly for all threads.
288 */
VG_(main_thread_wrapper_NORETURN)289 void VG_(main_thread_wrapper_NORETURN)(ThreadId tid)
290 {
291 Addr sp;
292 VG_(debugLog)(1, "syswrap-freebsd",
293 "entering VG_(main_thread_wrapper_NORETURN)\n");
294
295 sp = ML_(allocstack)(tid);
296
297 /* QQQ keep for amd64 redzone stuff */
298 #if defined(VGP_ppc32_linux)
299 /* make a stack frame */
300 sp -= 16;
301 sp &= ~0xF;
302 *(UWord *)sp = 0;
303 #elif defined(VGP_ppc64_linux)
304 /* make a stack frame */
305 sp -= 112;
306 sp &= ~((Addr)0xF);
307 *(UWord *)sp = 0;
308 #endif
309
310 /* If we can't even allocate the first thread's stack, we're hosed.
311 Give up. */
312 vg_assert2(sp != 0, "Cannot allocate main thread's stack.");
313
314 /* shouldn't be any other threads around yet */
315 vg_assert( VG_(count_living_threads)() == 1 );
316
317 ML_(call_on_new_stack_0_1)(
318 (Addr)sp, /* stack */
319 0, /* bogus return address */
320 run_a_thread_NORETURN, /* fn to call */
321 (Word)tid /* arg to give it */
322 );
323
324 /*NOTREACHED*/
325 vg_assert(0);
326 }
327
328
329 /* Do a fork() */
ML_(do_fork)330 SysRes ML_(do_fork) ( ThreadId tid )
331 {
332 vki_sigset_t fork_saved_mask;
333 vki_sigset_t mask;
334 SysRes res;
335
336 /* Block all signals during fork, so that we can fix things up in
337 the child without being interrupted. */
338 VG_(sigfillset)(&mask);
339 VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, &fork_saved_mask);
340
341 VG_(do_atfork_pre)(tid);
342
343 res = VG_(do_syscall0)( __NR_fork );
344
345 if (!sr_isError(res)) {
346 if (sr_Res(res) == 0) {
347 /* child */
348 VG_(do_atfork_child)(tid);
349
350 /* restore signal mask */
351 VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
352
353 }
354 else {
355 /* parent */
356 VG_(do_atfork_parent)(tid);
357
358 if (VG_(clo_trace_syscalls))
359 VG_(printf)(" clone(fork): process %d created child %ld\n",
360 VG_(getpid)(), sr_Res(res));
361
362 /* restore signal mask */
363 VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
364 }
365 }
366
367 return res;
368 }
369
370
371 /* ---------------------------------------------------------------------
372 PRE/POST wrappers for arch-generic, Linux-specific syscalls
373 ------------------------------------------------------------------ */
374
375 // Nb: See the comment above the generic PRE/POST wrappers in
376 // m_syswrap/syswrap-generic.c for notes about how they work.
377
378 #define PRE(name) DEFN_PRE_TEMPLATE(freebsd, name)
379 #define POST(name) DEFN_POST_TEMPLATE(freebsd, name)
380
381 // Combine two 32-bit values into a 64-bit value
382 #define LOHI64(lo,hi) ( (lo) | ((ULong)(hi) << 32) )
383
PRE(sys_fork)384 PRE(sys_fork)
385 {
386 PRINT("sys_fork ()");
387 PRE_REG_READ0(int, "fork");
388
389 SET_STATUS_from_SysRes( ML_(do_fork)(tid) );
390 if (SUCCESS) {
391 /* Thread creation was successful; let the child have the chance
392 to run */
393 *flags |= SfYieldAfter;
394 }
395 }
396
PRE(sys_vfork)397 PRE(sys_vfork)
398 {
399 PRINT("sys_vfork ()");
400 PRE_REG_READ0(int, "vfork");
401
402 /* Pretend vfork == fork. Not true, but will have to do. */
403 SET_STATUS_from_SysRes( ML_(do_fork)(tid) );
404 if (SUCCESS) {
405 /* Thread creation was successful; let the child have the chance
406 to run */
407 *flags |= SfYieldAfter;
408 }
409 }
410
PRE(sys_socket)411 PRE(sys_socket)
412 {
413 PRINT("sys_socket ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
414 PRE_REG_READ3(long, "socket", int, domain, int, type, int, protocol);
415 }
POST(sys_socket)416 POST(sys_socket)
417 {
418 SysRes r;
419 vg_assert(SUCCESS);
420 r = ML_(generic_POST_sys_socket)(tid, VG_(mk_SysRes_Success)(RES));
421 SET_STATUS_from_SysRes(r);
422 }
423
PRE(sys_setsockopt)424 PRE(sys_setsockopt)
425 {
426 PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5);
427 PRE_REG_READ5(long, "setsockopt",
428 int, s, int, level, int, optname,
429 const void *, optval, int, optlen);
430 ML_(generic_PRE_sys_setsockopt)(tid, ARG1,ARG2,ARG3,ARG4,ARG5);
431 }
432
PRE(sys_getsockopt)433 PRE(sys_getsockopt)
434 {
435 Addr optval_p = ARG4;
436 Addr optlen_p = ARG5;
437 PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
438 PRE_REG_READ5(long, "getsockopt",
439 int, s, int, level, int, optname,
440 void *, optval, int, *optlen);
441 if (optval_p != (Addr)NULL) {
442 ML_(buf_and_len_pre_check) ( tid, optval_p, optlen_p,
443 "getsockopt(optval)",
444 "getsockopt(optlen)" );
445 }
446 }
POST(sys_getsockopt)447 POST(sys_getsockopt)
448 {
449 Addr optval_p = ARG4;
450 Addr optlen_p = ARG5;
451 vg_assert(SUCCESS);
452 if (optval_p != (Addr)NULL) {
453 ML_(buf_and_len_post_check) ( tid, VG_(mk_SysRes_Success)(RES),
454 optval_p, optlen_p,
455 "getsockopt(optlen_out)" );
456 }
457 }
458
PRE(sys_connect)459 PRE(sys_connect)
460 {
461 *flags |= SfMayBlock;
462 PRINT("sys_connect ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
463 PRE_REG_READ3(long, "connect",
464 int, sockfd, struct sockaddr *, serv_addr, int, addrlen);
465 ML_(generic_PRE_sys_connect)(tid, ARG1,ARG2,ARG3);
466 }
467
PRE(sys_accept)468 PRE(sys_accept)
469 {
470 *flags |= SfMayBlock;
471 PRINT("sys_accept ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
472 PRE_REG_READ3(long, "accept",
473 int, s, struct sockaddr *, addr, int, *addrlen);
474 ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
475 }
POST(sys_accept)476 POST(sys_accept)
477 {
478 SysRes r;
479 vg_assert(SUCCESS);
480 r = ML_(generic_POST_sys_accept)(tid, VG_(mk_SysRes_Success)(RES),
481 ARG1,ARG2,ARG3);
482 SET_STATUS_from_SysRes(r);
483 }
484
PRE(sys_sendto)485 PRE(sys_sendto)
486 {
487 *flags |= SfMayBlock;
488 PRINT("sys_sendto ( %ld, %#lx, %ld, %lu, %#lx, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
489 PRE_REG_READ6(long, "sendto",
490 int, s, const void *, msg, int, len,
491 unsigned int, flags,
492 const struct sockaddr *, to, int, tolen);
493 ML_(generic_PRE_sys_sendto)(tid, ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
494 }
495
PRE(sys_recvfrom)496 PRE(sys_recvfrom)
497 {
498 *flags |= SfMayBlock;
499 PRINT("sys_recvfrom ( %ld, %#lx, %ld, %lu, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
500 PRE_REG_READ6(long, "recvfrom",
501 int, s, void *, buf, int, len, unsigned int, flags,
502 struct sockaddr *, from, int *, fromlen);
503 ML_(generic_PRE_sys_recvfrom)(tid, ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
504 }
POST(sys_recvfrom)505 POST(sys_recvfrom)
506 {
507 vg_assert(SUCCESS);
508 ML_(generic_POST_sys_recvfrom)(tid, VG_(mk_SysRes_Success)(RES),
509 ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
510 }
511
PRE(sys_sendmsg)512 PRE(sys_sendmsg)
513 {
514 *flags |= SfMayBlock;
515 PRINT("sys_sendmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
516 PRE_REG_READ3(long, "sendmsg",
517 int, s, const struct msghdr *, msg, int, flags);
518 ML_(generic_PRE_sys_sendmsg)(tid, "sendmsg", (struct vki_msghdr *)ARG2);
519 }
520
PRE(sys_recvmsg)521 PRE(sys_recvmsg)
522 {
523 *flags |= SfMayBlock;
524 PRINT("sys_recvmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
525 PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg, int, flags);
526 ML_(generic_PRE_sys_recvmsg)(tid, "recvmsg", (struct vki_msghdr *)ARG2);
527 }
POST(sys_recvmsg)528 POST(sys_recvmsg)
529 {
530
531 ML_(generic_POST_sys_recvmsg)(tid, "recvmsg", (struct vki_msghdr *)ARG2, RES);
532 }
533
PRE(sys_shutdown)534 PRE(sys_shutdown)
535 {
536 *flags |= SfMayBlock;
537 PRINT("sys_shutdown ( %ld, %ld )",ARG1,ARG2);
538 PRE_REG_READ2(int, "shutdown", int, s, int, how);
539 }
540
PRE(sys_bind)541 PRE(sys_bind)
542 {
543 PRINT("sys_bind ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
544 PRE_REG_READ3(long, "bind",
545 int, sockfd, struct sockaddr *, my_addr, int, addrlen);
546 ML_(generic_PRE_sys_bind)(tid, ARG1,ARG2,ARG3);
547 }
548
PRE(sys_listen)549 PRE(sys_listen)
550 {
551 PRINT("sys_listen ( %ld, %ld )",ARG1,ARG2);
552 PRE_REG_READ2(long, "listen", int, s, int, backlog);
553 }
554
PRE(sys_getsockname)555 PRE(sys_getsockname)
556 {
557 PRINT("sys_getsockname ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
558 PRE_REG_READ3(long, "getsockname",
559 int, s, struct sockaddr *, name, int *, namelen);
560 ML_(generic_PRE_sys_getsockname)(tid, ARG1,ARG2,ARG3);
561 }
POST(sys_getsockname)562 POST(sys_getsockname)
563 {
564 vg_assert(SUCCESS);
565 ML_(generic_POST_sys_getsockname)(tid, VG_(mk_SysRes_Success)(RES),
566 ARG1,ARG2,ARG3);
567 }
568
PRE(sys_getpeername)569 PRE(sys_getpeername)
570 {
571 PRINT("sys_getpeername ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
572 PRE_REG_READ3(long, "getpeername",
573 int, s, struct sockaddr *, name, int *, namelen);
574 ML_(generic_PRE_sys_getpeername)(tid, ARG1,ARG2,ARG3);
575 }
POST(sys_getpeername)576 POST(sys_getpeername)
577 {
578 vg_assert(SUCCESS);
579 ML_(generic_POST_sys_getpeername)(tid, VG_(mk_SysRes_Success)(RES),
580 ARG1,ARG2,ARG3);
581 }
582
PRE(sys_socketpair)583 PRE(sys_socketpair)
584 {
585 PRINT("sys_socketpair ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
586 PRE_REG_READ4(long, "socketpair",
587 int, d, int, type, int, protocol, int *, sv);
588 ML_(generic_PRE_sys_socketpair)(tid, ARG1,ARG2,ARG3,ARG4);
589 }
POST(sys_socketpair)590 POST(sys_socketpair)
591 {
592 vg_assert(SUCCESS);
593 ML_(generic_POST_sys_socketpair)(tid, VG_(mk_SysRes_Success)(RES),
594 ARG1,ARG2,ARG3,ARG4);
595 }
596
597 /* ---------------------------------------------------------------------
598 *mount wrappers
599 ------------------------------------------------------------------ */
600
PRE(sys_mount)601 PRE(sys_mount)
602 {
603 // Nb: depending on 'flags', the 'type' and 'data' args may be ignored.
604 // We are conservative and check everything, except the memory pointed to
605 // by 'data'.
606 *flags |= SfMayBlock;
607 PRINT( "sys_mount( %#lx, %#lx, %ld, %#lx )" ,ARG1,ARG2,ARG3,ARG4);
608 PRE_REG_READ4(long, "mount",
609 char *, type, char *, path, int, flags,
610 void *, data);
611 PRE_MEM_RASCIIZ( "mount(type)", ARG1);
612 PRE_MEM_RASCIIZ( "mount(path)", ARG2);
613 }
614
PRE(sys_unmount)615 PRE(sys_unmount)
616 {
617 PRINT("sys_umount( %#lx, %ld )", ARG1, ARG2);
618 PRE_REG_READ2(long, "unmount", char *, path, int, flags);
619 PRE_MEM_RASCIIZ( "unmount(path)", ARG1);
620 }
621
622 /* ---------------------------------------------------------------------
623 16- and 32-bit uid/gid wrappers
624 ------------------------------------------------------------------ */
625
626 #if 0
627 PRE(sys_setfsuid)
628 {
629 PRINT("sys_setfsuid ( %ld )", ARG1);
630 PRE_REG_READ1(long, "setfsuid", vki_uid_t, uid);
631 }
632
633 PRE(sys_setfsgid)
634 {
635 PRINT("sys_setfsgid ( %ld )", ARG1);
636 PRE_REG_READ1(long, "setfsgid", vki_gid_t, gid);
637 }
638 #endif
639
PRE(sys_setresuid)640 PRE(sys_setresuid)
641 {
642 PRINT("sys_setresuid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
643 PRE_REG_READ3(long, "setresuid",
644 vki_uid_t, ruid, vki_uid_t, euid, vki_uid_t, suid);
645 }
646
PRE(sys_getresuid)647 PRE(sys_getresuid)
648 {
649 PRINT("sys_getresuid ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
650 PRE_REG_READ3(long, "getresuid",
651 vki_uid_t *, ruid, vki_uid_t *, euid, vki_uid_t *, suid);
652 PRE_MEM_WRITE( "getresuid(ruid)", ARG1, sizeof(vki_uid_t) );
653 PRE_MEM_WRITE( "getresuid(euid)", ARG2, sizeof(vki_uid_t) );
654 PRE_MEM_WRITE( "getresuid(suid)", ARG3, sizeof(vki_uid_t) );
655 }
656
POST(sys_getresuid)657 POST(sys_getresuid)
658 {
659 vg_assert(SUCCESS);
660 if (RES == 0) {
661 POST_MEM_WRITE( ARG1, sizeof(vki_uid_t) );
662 POST_MEM_WRITE( ARG2, sizeof(vki_uid_t) );
663 POST_MEM_WRITE( ARG3, sizeof(vki_uid_t) );
664 }
665 }
666
PRE(sys_setresgid)667 PRE(sys_setresgid)
668 {
669 PRINT("sys_setresgid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
670 PRE_REG_READ3(long, "setresgid",
671 vki_gid_t, rgid, vki_gid_t, egid, vki_gid_t, sgid);
672 }
673
PRE(sys_getresgid)674 PRE(sys_getresgid)
675 {
676 PRINT("sys_getresgid ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
677 PRE_REG_READ3(long, "getresgid",
678 vki_gid_t *, rgid, vki_gid_t *, egid, vki_gid_t *, sgid);
679 PRE_MEM_WRITE( "getresgid(rgid)", ARG1, sizeof(vki_gid_t) );
680 PRE_MEM_WRITE( "getresgid(egid)", ARG2, sizeof(vki_gid_t) );
681 PRE_MEM_WRITE( "getresgid(sgid)", ARG3, sizeof(vki_gid_t) );
682 }
683
POST(sys_getresgid)684 POST(sys_getresgid)
685 {
686 vg_assert(SUCCESS);
687 if (RES == 0) {
688 POST_MEM_WRITE( ARG1, sizeof(vki_gid_t) );
689 POST_MEM_WRITE( ARG2, sizeof(vki_gid_t) );
690 POST_MEM_WRITE( ARG3, sizeof(vki_gid_t) );
691 }
692 }
693
694 /* ---------------------------------------------------------------------
695 miscellaneous wrappers
696 ------------------------------------------------------------------ */
697
698 #if 0
699 PRE(sys_exit_group)
700 {
701 ThreadId t;
702 ThreadState* tst;
703
704 PRINT("exit_group( %ld )", ARG1);
705 PRE_REG_READ1(void, "exit_group", int, exit_code);
706
707 tst = VG_(get_ThreadState)(tid);
708
709 /* A little complex; find all the threads with the same threadgroup
710 as this one (including this one), and mark them to exit */
711 for (t = 1; t < VG_N_THREADS; t++) {
712 if ( /* not alive */
713 VG_(threads)[t].status == VgTs_Empty
714 ||
715 /* not our group */
716 VG_(threads)[t].os_state.threadgroup != tst->os_state.threadgroup
717 )
718 continue;
719
720 VG_(threads)[t].exitreason = VgSrc_ExitSyscall;
721 VG_(threads)[t].os_state.exitcode = ARG1;
722
723 if (t != tid)
724 VG_(get_thread_out_of_syscall)(t); /* unblock it, if blocked */
725 }
726
727 /* We have to claim the syscall already succeeded. */
728 SET_STATUS_Success(0);
729 }
730 #endif
731
732 /* On FreeBSD, if any thread calls exit(2), then they are all shut down, pretty
733 * much like linux's exit_group().
734 */
PRE(sys_exit)735 PRE(sys_exit)
736 {
737 ThreadId t;
738
739 PRINT("exit( %ld )", ARG1);
740 PRE_REG_READ1(void, "exit", int, status);
741
742 /* Mark all threads (including this one) to exit. */
743 for (t = 1; t < VG_N_THREADS; t++) {
744 if ( /* not alive */ VG_(threads)[t].status == VgTs_Empty )
745 continue;
746
747 VG_(threads)[t].exitreason = VgSrc_ExitThread;
748 VG_(threads)[t].os_state.exitcode = ARG1;
749
750 if (t != tid)
751 VG_(get_thread_out_of_syscall)(t); /* unblock it, if blocked */
752 }
753
754 /* We have to claim the syscall already succeeded. */
755 SET_STATUS_Success(0);
756 }
757
758
PRE(sys_getlogin)759 PRE(sys_getlogin)
760 {
761 PRINT("sys_getlogin ( %#lx, %ld )",ARG1,ARG2);
762 PRE_REG_READ2(long, "getlogin",
763 char *, buf, int, len);
764 PRE_MEM_WRITE( "getlogin(buf, len)", ARG1, ARG2 );
765 }
POST(sys_getlogin)766 POST(sys_getlogin)
767 {
768 if (ARG1 != 0) {
769 POST_MEM_WRITE( ARG1, ARG2 );
770 }
771 }
PRE(sys_setlogin)772 PRE(sys_setlogin)
773 {
774 PRINT("sys_setlogin ( %#lx )",ARG1);
775 PRE_REG_READ1(long, "setlogin", char *, buf);
776 PRE_MEM_RASCIIZ( "setlogin(buf)", ARG1 );
777 }
PRE(sys_mkfifo)778 PRE(sys_mkfifo)
779 {
780 PRINT("sys_mkfifo ( %#lx(%s), 0x%lx, 0x%lx )", ARG1, (char *)ARG1, ARG2, ARG3 );
781 PRE_REG_READ2(long, "mkfifo", const char *, pathname, int, mode);
782 PRE_MEM_RASCIIZ( "mkfifo(pathname)", ARG1 );
783 }
784
785 /* int quotactl(const char *path, int cmd, int id, void *addr); */
786
PRE(sys_quotactl)787 PRE(sys_quotactl)
788 {
789 PRINT("sys_quotactl (%#lx, %ld, %ld, %#lx )", ARG1,ARG2,ARG3, ARG4);
790 PRE_REG_READ4(long, "quotactl",
791 const char *, path, int, cmd, int, id,
792 void *, addr);
793 PRE_MEM_RASCIIZ( "quotactl(path)", ARG1 );
794 }
795
796 /* int getdomainname(char *domainname, int len); */
PRE(sys_getdomainname)797 PRE(sys_getdomainname)
798 {
799 PRINT("sys_getdomainname ( %#lx, %ld )",ARG1,ARG2);
800 PRE_REG_READ2(long, "getdomainname",
801 char *, buf, int, len);
802 PRE_MEM_WRITE( "getdomainname(buf, len)", ARG1, ARG2 );
803 }
POST(sys_getdomainname)804 POST(sys_getdomainname)
805 {
806 if (ARG1 != 0) {
807 POST_MEM_WRITE( ARG1, ARG2 );
808 }
809 }
810 /* int setdomainname(char *domainname, int len); */
PRE(sys_setdomainname)811 PRE(sys_setdomainname)
812 {
813 PRINT("sys_setdomainname ( %#lx )",ARG1);
814 PRE_REG_READ1(long, "setdomainname", char *, buf);
815 PRE_MEM_RASCIIZ( "setdomainname(buf)", ARG1 );
816 }
817
PRE(sys_uname)818 PRE(sys_uname)
819 {
820 PRINT("sys_uname ( %#lx )", ARG1);
821 PRE_REG_READ1(long, "uname", struct utsname *, buf);
822 PRE_MEM_WRITE( "uname(buf)", ARG1, sizeof(struct vki_utsname) );
823 }
824
POST(sys_uname)825 POST(sys_uname)
826 {
827 if (ARG1 != 0) {
828 POST_MEM_WRITE( ARG1, sizeof(struct vki_utsname) );
829 }
830 }
831
PRE(sys_lstat)832 PRE(sys_lstat)
833 {
834 PRINT("sys_lstat ( %#lx(%s), %#lx )",ARG1,(char *)ARG1,ARG2);
835 PRE_REG_READ2(long, "lstat", char *, file_name, struct stat *, buf);
836 PRE_MEM_RASCIIZ( "lstat(file_name)", ARG1 );
837 PRE_MEM_WRITE( "lstat(buf)", ARG2, sizeof(struct vki_stat) );
838 }
839
POST(sys_lstat)840 POST(sys_lstat)
841 {
842 vg_assert(SUCCESS);
843 if (RES == 0) {
844 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat) );
845 }
846 }
847
PRE(sys_stat)848 PRE(sys_stat)
849 {
850 PRINT("sys_stat ( %#lx(%s), %#lx )",ARG1,(char *)ARG1,ARG2);
851 PRE_REG_READ2(long, "stat", char *, file_name, struct stat *, buf);
852 PRE_MEM_RASCIIZ( "stat(file_name)", ARG1 );
853 PRE_MEM_WRITE( "stat(buf)", ARG2, sizeof(struct vki_stat) );
854 }
855
POST(sys_stat)856 POST(sys_stat)
857 {
858 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat) );
859 }
860
PRE(sys_fstat)861 PRE(sys_fstat)
862 {
863 PRINT("sys_fstat ( %ld, %#lx )",ARG1,ARG2);
864 PRE_REG_READ2(long, "fstat", unsigned long, fd, struct stat *, buf);
865 PRE_MEM_WRITE( "fstat(buf)", ARG2, sizeof(struct vki_stat) );
866 }
867
POST(sys_fstat)868 POST(sys_fstat)
869 {
870 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat) );
871 }
872
PRE(sys_pathconf)873 PRE(sys_pathconf)
874 {
875 PRINT("sys_pathconf ( %#lx(%s), %ld )",ARG1,(char *)ARG1,ARG2);
876 PRE_REG_READ2(long, "pathconf", char *, file_name, int, name);
877 PRE_MEM_RASCIIZ( "pathconf(file_name)", ARG1 );
878 }
879
PRE(sys_fpathconf)880 PRE(sys_fpathconf)
881 {
882 PRINT("sys_fpathconf ( %ld, %ld )",ARG1,ARG2);
883 PRE_REG_READ2(long, "fpathconf", int, fd, int, name);
884 }
885
PRE(sys_lchmod)886 PRE(sys_lchmod)
887 {
888 PRINT("sys_lchmod ( %#lx(%s), %ld )", ARG1,(char *)ARG1,ARG2);
889 PRE_REG_READ2(long, "lchmod", const char *, path, vki_mode_t, mode);
890 PRE_MEM_RASCIIZ( "lchmod(path)", ARG1 );
891 }
892
PRE(sys_issetugid)893 PRE(sys_issetugid)
894 {
895 PRINT("sys_issetugid ()");
896 PRE_REG_READ0(long, "issetugid");
897 }
898
PRE(sys_revoke)899 PRE(sys_revoke)
900 {
901 PRINT("sys_vhangup ( )");
902 PRE_REG_READ0(long, "vhangup");
903 }
PRE(sys_undelete)904 PRE(sys_undelete)
905 {
906 *flags |= SfMayBlock;
907 PRINT("sys_undelete ( %#lx(%s) )", ARG1,(char *)ARG1);
908 PRE_REG_READ1(long, "undelete", const char *, pathname);
909 PRE_MEM_RASCIIZ( "undelete(pathname)", ARG1 );
910 }
PRE(sys_yield)911 PRE(sys_yield)
912 {
913 *flags |= SfMayBlock;
914 PRINT("yield()");
915 PRE_REG_READ0(long, "yield");
916 }
917
PRE(sys_sched_yield)918 PRE(sys_sched_yield)
919 {
920 *flags |= SfMayBlock;
921 PRINT("sched_yield()");
922 }
923
924 #if 0
925 PRE(sys_sysinfo)
926 {
927 PRINT("sys_sysinfo ( %#lx )",ARG1);
928 PRE_REG_READ1(long, "sysinfo", struct sysinfo *, info);
929 PRE_MEM_WRITE( "sysinfo(info)", ARG1, sizeof(struct vki_sysinfo) );
930 }
931
932 POST(sys_sysinfo)
933 {
934 POST_MEM_WRITE( ARG1, sizeof(struct vki_sysinfo) );
935 }
936 #endif
937
938 /* int __sysctl(int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen); */
939 /* ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 */
940
PRE(sys___sysctl)941 PRE(sys___sysctl)
942 {
943 PRINT("sys_sysctl ( %#lx, %ld, %#lx, %#lx, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6 );
944 PRE_REG_READ6(long, "__sysctl", int *, name, unsigned int, namelen, void *, old,
945 vki_size_t *, oldlenp, void *, new, vki_size_t, newlen);
946 PRE_MEM_READ("sysctl(name)", ARG1, ARG2 * sizeof(int));
947 if (ARG5 != (UWord)NULL)
948 PRE_MEM_READ("sysctl(new)", (Addr)ARG5, ARG6);
949 if (ARG4 != (UWord)NULL) {
950 if (ARG3 != (UWord)NULL) {
951 PRE_MEM_READ("sysctl(oldlenp)", (Addr)ARG4, sizeof(vki_size_t));
952 PRE_MEM_WRITE("sysctl(oldval)", (Addr)ARG3, *(vki_size_t *)ARG4);
953 }
954 PRE_MEM_WRITE("sysctl(oldlenp)", (Addr)ARG4, sizeof(vki_size_t));
955 }
956 }
POST(sys___sysctl)957 POST(sys___sysctl)
958 {
959 if (ARG4 != (UWord)NULL) {
960 POST_MEM_WRITE((Addr)ARG4, sizeof(vki_size_t));
961 if (ARG3 != (UWord)NULL)
962 POST_MEM_WRITE((Addr)ARG3, *(vki_size_t *)ARG4);
963 }
964 }
965
PRE(sys_sendfile)966 PRE(sys_sendfile)
967 {
968 *flags |= SfMayBlock;
969 #if defined(VGP_x86_freebsd)
970 PRINT("sys_sendfile ( %ld, %ld, %llu, %ld, %#lx, %#lx, %lu )", ARG1,ARG2,LOHI64(ARG3,ARG4),ARG5,ARG6,ARG7,ARG8);
971 PRE_REG_READ8(int, "sendfile",
972 int, fd, int, s, unsigned int, offset_low,
973 unsigned int, offset_high, size_t, nbytes,
974 void *, hdtr, vki_off_t *, sbytes, int, flags);
975 # define SF_ARG_SBYTES ARG7
976 #elif defined(VGP_amd64_freebsd)
977 PRINT("sys_sendfile ( %ld, %ld, %lu, %ld, %#lx, %#lx, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7);
978 PRE_REG_READ7(int, "sendfile",
979 int, fd, int, s, vki_off_t, offset, size_t, nbytes,
980 void *, hdtr, vki_off_t *, sbytes, int, flags);
981 # define SF_ARG_SBYTES ARG6
982 #else
983 # error Unknown platform
984 #endif
985 if (SF_ARG_SBYTES != 0)
986 PRE_MEM_WRITE( "sendfile(offset)", SF_ARG_SBYTES, sizeof(vki_off_t) );
987 }
POST(sys_sendfile)988 POST(sys_sendfile)
989 {
990 if (SF_ARG_SBYTES != 0 ) {
991 POST_MEM_WRITE( SF_ARG_SBYTES, sizeof( vki_off_t ) );
992 }
993 }
994 #undef SF_ARG_SBYTES
995
996 /* int getdirentries(int fd, char *buf, u_int count, long *basep); */
PRE(sys_getdirentries)997 PRE(sys_getdirentries)
998 {
999 *flags |= SfMayBlock;
1000 PRINT("sys_getdents ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
1001 PRE_REG_READ3(long, "getdirentries",
1002 unsigned int, fd, struct dirent *, dirp,
1003 unsigned int, count);
1004 PRE_MEM_WRITE( "getdirentries(dirp)", ARG2, ARG3 );
1005 }
1006
POST(sys_getdirentries)1007 POST(sys_getdirentries)
1008 {
1009 vg_assert(SUCCESS);
1010 if (RES > 0) {
1011 POST_MEM_WRITE( ARG2, RES );
1012 if ( ARG4 != 0 )
1013 POST_MEM_WRITE( ARG4, sizeof (long));
1014 }
1015 }
1016
PRE(sys_seteuid)1017 PRE(sys_seteuid)
1018 {
1019 PRINT("sys_seteuid ( %ld )", ARG1);
1020 PRE_REG_READ1(long, "seteuid", vki_uid_t, uid);
1021 }
1022
PRE(sys_setegid)1023 PRE(sys_setegid)
1024 {
1025 PRINT("sys_setegid ( %ld )", ARG1);
1026 PRE_REG_READ1(long, "setegid", vki_gid_t, gid);
1027 }
1028
PRE(sys_lutimes)1029 PRE(sys_lutimes)
1030 {
1031 PRINT("sys_lutimes ( %#lx(%s), %#lx )", ARG1,(char *)ARG1,ARG2);
1032 PRE_REG_READ2(long, "lutimes", char *, filename, struct timeval *, tvp);
1033 PRE_MEM_RASCIIZ( "lutimes(filename)", ARG1 );
1034 if (ARG2 != 0)
1035 PRE_MEM_READ( "lutimes(tvp)", ARG2, sizeof(struct vki_timeval) );
1036 }
1037
PRE(sys_futimes)1038 PRE(sys_futimes)
1039 {
1040 PRINT("sys_lutimes ( %ld, %#lx )", ARG1,ARG2);
1041 PRE_REG_READ2(long, "futimes", int, fd, struct timeval *, tvp);
1042 if (ARG2 != 0)
1043 PRE_MEM_READ( "futimes(tvp)", ARG2, sizeof(struct vki_timeval) );
1044 }
1045
PRE(sys_utrace)1046 PRE(sys_utrace)
1047 {
1048 PRINT("sys_utrace ( %#lx, %lu )", ARG1, ARG2);
1049 PRE_REG_READ2(long, "utrace", const void *, buf, vki_size_t, len);
1050 PRE_MEM_READ( "utrace(buf,len)", ARG2, ARG3 );
1051 }
1052
PRE(sys_getdtablesize)1053 PRE(sys_getdtablesize)
1054 {
1055 PRINT("sys_getdtablesize ( )");
1056 PRE_REG_READ0(long, "getdtablesize");
1057 }
1058
PRE(sys_kqueue)1059 PRE(sys_kqueue)
1060 {
1061 PRINT("sys_kqueue ()");
1062 }
POST(sys_kqueue)1063 POST(sys_kqueue)
1064 {
1065 if (!ML_(fd_allowed)(RES, "kqueue", tid, True)) {
1066 VG_(close)(RES);
1067 SET_STATUS_Failure( VKI_EMFILE );
1068 } else {
1069 if (VG_(clo_track_fds)) {
1070 ML_(record_fd_open_nameless)(tid, RES);
1071 }
1072 }
1073 }
1074
PRE(sys_kevent)1075 PRE(sys_kevent)
1076 {
1077 /* struct kevent {
1078 uintptr_t ident; -- identifier for this event
1079 short filter; -- filter for event
1080 u_short flags; -- action flags for kqueue
1081 u_int fflags; -- filter flag value
1082 intptr_t data; -- filter data value
1083 void *udata; -- opaque user data identifier
1084 };
1085 int kevent(int kq, const struct kevent *changelist, int nchanges,
1086 struct kevent *eventlist, int nevents,
1087 const struct timespec *timeout);
1088 */
1089 *flags |= SfMayBlock;
1090 PRINT("sys_kevent ( %ld, %#lx, %ld, %#lx, %ld, %#lx )\n", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
1091 PRE_REG_READ6(long, "kevent",
1092 int, fd, struct vki_kevent *, newev, int, num_newev,
1093 struct vki_kevent *, ret_ev, int, num_retev,
1094 struct timespec *, timeout);
1095 if (ARG2 != 0 && ARG3 != 0)
1096 PRE_MEM_READ( "kevent(changeevent)", ARG2, sizeof(struct vki_kevent)*ARG3 );
1097 if (ARG4 != 0 && ARG5 != 0)
1098 PRE_MEM_WRITE( "kevent(events)", ARG4, sizeof(struct vki_kevent)*ARG5);
1099 if (ARG6 != 0)
1100 PRE_MEM_READ( "kevent(timeout)",
1101 ARG6, sizeof(struct vki_timespec));
1102 }
1103
POST(sys_kevent)1104 POST(sys_kevent)
1105 {
1106 vg_assert(SUCCESS);
1107 if (RES > 0) {
1108 if (ARG4 != 0)
1109 POST_MEM_WRITE( ARG4, sizeof(struct vki_kevent)*RES) ;
1110 }
1111 }
1112
PRE(sys___getcwd)1113 PRE(sys___getcwd)
1114 {
1115 PRINT("sys___getcwd ( %#lx, %lu )", ARG1,ARG2);
1116 PRE_REG_READ2(long, "__getcwd", char *, buf, unsigned int, size);
1117 PRE_MEM_WRITE( "__getcwd(buf)", ARG1, ARG2 );
1118 }
1119
POST(sys___getcwd)1120 POST(sys___getcwd)
1121 {
1122 vg_assert(SUCCESS);
1123 if (RES == 0) {
1124 // QQQ it is unclear if this is legal or not, but the
1125 // QQQ kernel just wrote it there...
1126 // QQQ Why oh why didn't phk return the length from __getcwd()?
1127 UInt len = VG_(strlen) ( (char *)ARG1 ) + 1;
1128 POST_MEM_WRITE( ARG1, len );
1129 }
1130 }
1131
1132 // getfsstat() takes a length in bytes, but returns the number of structures
1133 // returned, not a length.
PRE(sys_getfsstat4)1134 PRE(sys_getfsstat4)
1135 {
1136 PRINT("sys_getfsstat ( %#lx, %ld, %ld )",ARG1,ARG2,ARG3);
1137 PRE_REG_READ3(long, "getfsstat", struct vki_statfs4 *, buf, long, len, int, flags);
1138 PRE_MEM_WRITE( "getfsstat(buf)", ARG1, ARG2 );
1139 }
POST(sys_getfsstat4)1140 POST(sys_getfsstat4)
1141 {
1142 vg_assert(SUCCESS);
1143 if (RES > 0) {
1144 POST_MEM_WRITE( ARG1, RES * sizeof(struct vki_statfs4) );
1145 }
1146 }
1147
PRE(sys_getfsstat)1148 PRE(sys_getfsstat)
1149 {
1150 PRINT("sys_getfsstat ( %#lx, %ld, %ld )",ARG1,ARG2,ARG3);
1151 PRE_REG_READ3(long, "getfsstat", struct vki_statfs *, buf, long, len, int, flags);
1152 PRE_MEM_WRITE( "getfsstat(buf)", ARG1, ARG2 );
1153 }
POST(sys_getfsstat)1154 POST(sys_getfsstat)
1155 {
1156 vg_assert(SUCCESS);
1157 if (RES > 0) {
1158 POST_MEM_WRITE( ARG1, RES * sizeof(struct vki_statfs) );
1159 }
1160 }
1161
PRE(sys_fhopen)1162 PRE(sys_fhopen)
1163 {
1164 PRINT("sys_open ( %#lx, %ld )",ARG1,ARG2);
1165 PRE_REG_READ2(long, "open",
1166 struct fhandle *, fhp, int, flags);
1167 PRE_MEM_READ( "fhopen(fhp)", ARG1, sizeof(struct vki_fhandle) );
1168
1169 /* Otherwise handle normally */
1170 *flags |= SfMayBlock;
1171 }
1172
POST(sys_fhopen)1173 POST(sys_fhopen)
1174 {
1175 vg_assert(SUCCESS);
1176 if (!ML_(fd_allowed)(RES, "fhopen", tid, True)) {
1177 VG_(close)(RES);
1178 SET_STATUS_Failure( VKI_EMFILE );
1179 } else {
1180 if (VG_(clo_track_fds))
1181 ML_(record_fd_open_nameless)(tid, RES);
1182 }
1183 }
1184
PRE(sys_fhstat)1185 PRE(sys_fhstat)
1186 {
1187 PRINT("sys_fhstat ( %#lx, %#lx )",ARG1,ARG2);
1188 PRE_REG_READ2(long, "fhstat", struct fhandle *, fhp, struct stat *, buf);
1189 PRE_MEM_READ( "fhstat(fhp)", ARG1, sizeof(struct vki_fhandle) );
1190 PRE_MEM_WRITE( "fhstat(buf)", ARG2, sizeof(struct vki_stat) );
1191 }
1192
POST(sys_fhstat)1193 POST(sys_fhstat)
1194 {
1195 POST_MEM_WRITE( ARG2, sizeof(struct vki_stat) );
1196 }
1197
PRE(sys_fhstatfs)1198 PRE(sys_fhstatfs)
1199 {
1200 PRINT("sys_fstatfs ( %#lx, %#lx )",ARG1,ARG2);
1201 PRE_REG_READ2(long, "fhstatfs",
1202 struct fhandle *, fhp, struct statfs *, buf);
1203 PRE_MEM_READ( "fhstatfs(fhp)", ARG1, sizeof(struct vki_fhandle) );
1204 PRE_MEM_WRITE( "fhstatfs(buf)", ARG2, sizeof(struct vki_statfs) );
1205 }
1206
POST(sys_fhstatfs)1207 POST(sys_fhstatfs)
1208 {
1209 POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs) );
1210 }
1211
PRE(sys_fhstatfs6)1212 PRE(sys_fhstatfs6)
1213 {
1214 PRINT("sys_fstatfs6 ( %#lx, %#lx )",ARG1,ARG2);
1215 PRE_REG_READ2(long, "fhstatfs6",
1216 struct fhandle *, fhp, struct statfs *, buf);
1217 PRE_MEM_READ( "fhstatfs6(fhp)", ARG1, sizeof(struct vki_fhandle) );
1218 PRE_MEM_WRITE( "fhstatfs6(buf)", ARG2, sizeof(struct vki_statfs6) );
1219 }
1220
POST(sys_fhstatfs6)1221 POST(sys_fhstatfs6)
1222 {
1223 POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs6) );
1224 }
1225
PRE(sys_fstatfs6)1226 PRE(sys_fstatfs6)
1227 {
1228 PRINT("sys_fstatfs6 ( %ld, %#lx )",ARG1,ARG2);
1229 PRE_REG_READ2(long, "fstatfs6",
1230 unsigned int, fd, struct statfs *, buf);
1231 PRE_MEM_WRITE( "fstatfs6(buf)", ARG2, sizeof(struct vki_statfs6) );
1232 }
1233
POST(sys_fstatfs6)1234 POST(sys_fstatfs6)
1235 {
1236 POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs6) );
1237 }
1238
PRE(sys_statfs6)1239 PRE(sys_statfs6)
1240 {
1241 PRINT("sys_statfs6 ( %#lx(%s), %#lx )",ARG1,(char *)ARG1,ARG2);
1242 PRE_REG_READ2(long, "statfs6", const char *, path, struct statfs *, buf);
1243 PRE_MEM_RASCIIZ( "statfs6(path)", ARG1 );
1244 PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct vki_statfs6) );
1245 }
POST(sys_statfs6)1246 POST(sys_statfs6)
1247 {
1248 POST_MEM_WRITE( ARG2, sizeof(struct vki_statfs6) );
1249 }
1250
1251 /* ---------------------------------------------------------------------
1252 kld* wrappers
1253 ------------------------------------------------------------------ */
1254
PRE(sys_kldload)1255 PRE(sys_kldload)
1256 {
1257 PRINT("sys_kldload ( %#lx(%s) )", ARG1, (char *)ARG1);
1258 PRE_REG_READ1(int, "kldload", const char *, "file");
1259
1260 PRE_MEM_RASCIIZ( "kldload(file)", ARG1 );
1261 }
1262
PRE(sys_kldunload)1263 PRE(sys_kldunload)
1264 {
1265 PRINT("sys_kldunload ( %ld )", ARG1);
1266 PRE_REG_READ1(int, "kldunload", int, "fileid");
1267 }
1268
PRE(sys_kldfind)1269 PRE(sys_kldfind)
1270 {
1271 PRINT("sys_kldfind ( %#lx(%s) )", ARG1, (char *)ARG1);
1272 PRE_REG_READ1(int, "kldfind", const char *, "file");
1273
1274 PRE_MEM_RASCIIZ( "kldfind(file)", ARG1 );
1275 }
1276
PRE(sys_kldnext)1277 PRE(sys_kldnext)
1278 {
1279 PRINT("sys_kldnext ( %ld )", ARG1);
1280 PRE_REG_READ1(int, "kldnext", int, "fileid");
1281 }
1282
PRE(sys_kldsym)1283 PRE(sys_kldsym)
1284 {
1285 PRINT("sys_kldsym ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3 );
1286 PRE_REG_READ3(int, "kldsym", int, "fileid", int, "command", void*, "data");
1287 PRE_MEM_READ( "kldsym(data)", ARG3, sizeof(struct vki_kld_sym_lookup) );
1288 struct vki_kld_sym_lookup *kslp = (struct vki_kld_sym_lookup *)ARG3;
1289 PRE_MEM_RASCIIZ( "kldsym(data.symname)", (Addr)kslp->symname );
1290 }
POST(sys_kldsym)1291 POST(sys_kldsym)
1292 {
1293 struct vki_kld_sym_lookup *kslp = (struct vki_kld_sym_lookup *)ARG3;
1294 POST_MEM_WRITE( (Addr)&kslp->symvalue, sizeof(kslp->symvalue) );
1295 POST_MEM_WRITE( (Addr)&kslp->symsize, sizeof(kslp->symsize) );
1296 }
1297
1298 #if 0
1299 /* ---------------------------------------------------------------------
1300 aio_* wrappers
1301 ------------------------------------------------------------------ */
1302
1303 // Nb: this wrapper has to pad/unpad memory around the syscall itself,
1304 // and this allows us to control exactly the code that gets run while
1305 // the padding is in place.
1306
1307 PRE(sys_io_setup)
1308 {
1309 PRINT("sys_io_setup ( %lu, %#lx )", ARG1,ARG2);
1310 PRE_REG_READ2(long, "io_setup",
1311 unsigned, nr_events, vki_aio_context_t *, ctxp);
1312 PRE_MEM_WRITE( "io_setup(ctxp)", ARG2, sizeof(vki_aio_context_t) );
1313 }
1314
1315 POST(sys_io_setup)
1316 {
1317 SizeT size;
1318 struct vki_aio_ring *r;
1319
1320 size = VG_PGROUNDUP(sizeof(struct vki_aio_ring) +
1321 ARG1*sizeof(struct vki_io_event));
1322 r = *(struct vki_aio_ring **)ARG2;
1323 vg_assert(ML_(valid_client_addr)((Addr)r, size, tid, "io_setup"));
1324
1325 ML_(notify_aspacem_and_tool_of_mmap)( (Addr)r, size,
1326 VKI_PROT_READ | VKI_PROT_WRITE,
1327 VKI_MAP_ANONYMOUS, -1, 0 );
1328
1329 POST_MEM_WRITE( ARG2, sizeof(vki_aio_context_t) );
1330 }
1331
1332 // Nb: This wrapper is "Special" because we need 'size' to do the unmap
1333 // after the syscall. We must get 'size' from the aio_ring structure,
1334 // before the syscall, while the aio_ring structure still exists. (And we
1335 // know that we must look at the aio_ring structure because Tom inspected the
1336 // kernel and glibc sources to see what they do, yuk.)
1337 //
1338 // XXX This segment can be implicitly unmapped when aio
1339 // file-descriptors are closed...
1340 PRE(sys_io_destroy)
1341 {
1342 struct vki_aio_ring *r;
1343 SizeT size;
1344
1345 PRINT("sys_io_destroy ( %llu )", (ULong)ARG1);
1346 PRE_REG_READ1(long, "io_destroy", vki_aio_context_t, ctx);
1347
1348 // If we are going to seg fault (due to a bogus ARG1) do it as late as
1349 // possible...
1350 r = (struct vki_aio_ring *)ARG1;
1351 size = VG_PGROUNDUP(sizeof(struct vki_aio_ring) +
1352 r->nr*sizeof(struct vki_io_event));
1353
1354 SET_STATUS_from_SysRes( VG_(do_syscall1)(SYSNO, ARG1) );
1355
1356 if (SUCCESS && RES == 0) {
1357 Bool d = VG_(am_notify_munmap)( ARG1, size );
1358 VG_TRACK( die_mem_munmap, ARG1, size );
1359 if (d)
1360 VG_(discard_translations)( (Addr64)ARG1, (ULong)size,
1361 "PRE(sys_io_destroy)" );
1362 }
1363 }
1364
1365 PRE(sys_io_getevents)
1366 {
1367 *flags |= SfMayBlock;
1368 PRINT("sys_io_getevents ( %llu, %lld, %lld, %#lx, %#lx )",
1369 (ULong)ARG1,(Long)ARG2,(Long)ARG3,ARG4,ARG5);
1370 PRE_REG_READ5(long, "io_getevents",
1371 vki_aio_context_t, ctx_id, long, min_nr, long, nr,
1372 struct io_event *, events,
1373 struct timespec *, timeout);
1374 if (ARG3 > 0)
1375 PRE_MEM_WRITE( "io_getevents(events)",
1376 ARG4, sizeof(struct vki_io_event)*ARG3 );
1377 if (ARG5 != 0)
1378 PRE_MEM_READ( "io_getevents(timeout)",
1379 ARG5, sizeof(struct vki_timespec));
1380 }
1381 POST(sys_io_getevents)
1382 {
1383 Int i;
1384 vg_assert(SUCCESS);
1385 if (RES > 0) {
1386 POST_MEM_WRITE( ARG4, sizeof(struct vki_io_event)*RES );
1387 for (i = 0; i < RES; i++) {
1388 const struct vki_io_event *vev = ((struct vki_io_event *)ARG4) + i;
1389 const struct vki_iocb *cb = (struct vki_iocb *)(Addr)vev->obj;
1390
1391 switch (cb->aio_lio_opcode) {
1392 case VKI_IOCB_CMD_PREAD:
1393 if (vev->result > 0)
1394 POST_MEM_WRITE( cb->aio_buf, vev->result );
1395 break;
1396
1397 case VKI_IOCB_CMD_PWRITE:
1398 break;
1399
1400 default:
1401 VG_(message)(Vg_DebugMsg,
1402 "Warning: unhandled io_getevents opcode: %u\n",
1403 cb->aio_lio_opcode);
1404 break;
1405 }
1406 }
1407 }
1408 }
1409
1410 PRE(sys_io_submit)
1411 {
1412 Int i;
1413
1414 PRINT("sys_io_submit ( %llu, %ld, %#lx )", (ULong)ARG1,ARG2,ARG3);
1415 PRE_REG_READ3(long, "io_submit",
1416 vki_aio_context_t, ctx_id, long, nr,
1417 struct iocb **, iocbpp);
1418 PRE_MEM_READ( "io_submit(iocbpp)", ARG3, ARG2*sizeof(struct vki_iocb *) );
1419 if (ARG3 != 0) {
1420 for (i = 0; i < ARG2; i++) {
1421 struct vki_iocb *cb = ((struct vki_iocb **)ARG3)[i];
1422 PRE_MEM_READ( "io_submit(iocb)", (Addr)cb, sizeof(struct vki_iocb) );
1423 switch (cb->aio_lio_opcode) {
1424 case VKI_IOCB_CMD_PREAD:
1425 PRE_MEM_WRITE( "io_submit(PREAD)", cb->aio_buf, cb->aio_nbytes );
1426 break;
1427
1428 case VKI_IOCB_CMD_PWRITE:
1429 PRE_MEM_READ( "io_submit(PWRITE)", cb->aio_buf, cb->aio_nbytes );
1430 break;
1431
1432 default:
1433 VG_(message)(Vg_DebugMsg,"Warning: unhandled io_submit opcode: %u\n",
1434 cb->aio_lio_opcode);
1435 break;
1436 }
1437 }
1438 }
1439 }
1440
1441 PRE(sys_io_cancel)
1442 {
1443 PRINT("sys_io_cancel ( %llu, %#lx, %#lx )", (ULong)ARG1,ARG2,ARG3);
1444 PRE_REG_READ3(long, "io_cancel",
1445 vki_aio_context_t, ctx_id, struct iocb *, iocb,
1446 struct io_event *, result);
1447 PRE_MEM_READ( "io_cancel(iocb)", ARG2, sizeof(struct vki_iocb) );
1448 PRE_MEM_WRITE( "io_cancel(result)", ARG3, sizeof(struct vki_io_event) );
1449 }
1450 POST(sys_io_cancel)
1451 {
1452 POST_MEM_WRITE( ARG3, sizeof(struct vki_io_event) );
1453 }
1454
1455 /* ---------------------------------------------------------------------
1456 inotify_* wrappers
1457 ------------------------------------------------------------------ */
1458
1459 PRE(sys_inotify_init)
1460 {
1461 PRINT("sys_inotify_init ( )");
1462 PRE_REG_READ0(long, "inotify_init");
1463 }
1464 POST(sys_inotify_init)
1465 {
1466 vg_assert(SUCCESS);
1467 if (!ML_(fd_allowed)(RES, "inotify_init", tid, True)) {
1468 VG_(close)(RES);
1469 SET_STATUS_Failure( VKI_EMFILE );
1470 } else {
1471 if (VG_(clo_track_fds))
1472 ML_(record_fd_open_nameless) (tid, RES);
1473 }
1474 }
1475
1476 PRE(sys_inotify_add_watch)
1477 {
1478 PRINT( "sys_inotify_add_watch ( %ld, %#lx, %lx )", ARG1,ARG2,ARG3);
1479 PRE_REG_READ3(long, "inotify_add_watch", int, fd, char *, path, int, mask);
1480 PRE_MEM_RASCIIZ( "inotify_add_watch(path)", ARG2 );
1481 }
1482
1483 PRE(sys_inotify_rm_watch)
1484 {
1485 PRINT( "sys_inotify_rm_watch ( %ld, %lx )", ARG1,ARG2);
1486 PRE_REG_READ2(long, "inotify_rm_watch", int, fd, int, wd);
1487 }
1488 #endif
1489
1490 /* ---------------------------------------------------------------------
1491 mq_* wrappers
1492 ------------------------------------------------------------------ */
1493
PRE(sys_mq_open)1494 PRE(sys_mq_open)
1495 {
1496 PRINT("sys_mq_open( %#lx(%s), %ld, %lld, %#lx )",
1497 ARG1,(char *)ARG1,ARG2,(ULong)ARG3,ARG4);
1498 PRE_REG_READ4(long, "mq_open",
1499 const char *, name, int, oflag, vki_mode_t, mode,
1500 struct mq_attr *, attr);
1501 PRE_MEM_RASCIIZ( "mq_open(name)", ARG1 );
1502 if ((ARG2 & VKI_O_CREAT) != 0 && ARG4 != 0) {
1503 const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG4;
1504 PRE_MEM_READ( "mq_open(attr->mq_maxmsg)",
1505 (Addr)&attr->mq_maxmsg, sizeof(attr->mq_maxmsg) );
1506 PRE_MEM_READ( "mq_open(attr->mq_msgsize)",
1507 (Addr)&attr->mq_msgsize, sizeof(attr->mq_msgsize) );
1508 }
1509 }
POST(sys_mq_open)1510 POST(sys_mq_open)
1511 {
1512 vg_assert(SUCCESS);
1513 if (!ML_(fd_allowed)(RES, "mq_open", tid, True)) {
1514 VG_(close)(RES);
1515 SET_STATUS_Failure( VKI_EMFILE );
1516 } else {
1517 if (VG_(clo_track_fds))
1518 ML_(record_fd_open_with_given_name)(tid, RES, (Char*)ARG1);
1519 }
1520 }
1521
PRE(sys_mq_unlink)1522 PRE(sys_mq_unlink)
1523 {
1524 PRINT("sys_mq_unlink ( %#lx(%s) )", ARG1,(char *)ARG1);
1525 PRE_REG_READ1(long, "mq_unlink", const char *, name);
1526 PRE_MEM_RASCIIZ( "mq_unlink(name)", ARG1 );
1527 }
1528
1529 #if 0
1530 PRE(sys_mq_timedsend)
1531 {
1532 *flags |= SfMayBlock;
1533 PRINT("sys_mq_timedsend ( %ld, %#lx, %llu, %ld, %#lx )",
1534 ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
1535 PRE_REG_READ5(long, "mq_timedsend",
1536 vki_mqd_t, mqdes, const char *, msg_ptr, vki_size_t, msg_len,
1537 unsigned int, msg_prio, const struct timespec *, abs_timeout);
1538 if (!ML_(fd_allowed)(ARG1, "mq_timedsend", tid, False)) {
1539 SET_STATUS_Failure( VKI_EBADF );
1540 } else {
1541 PRE_MEM_READ( "mq_timedsend(msg_ptr)", ARG2, ARG3 );
1542 if (ARG5 != 0)
1543 PRE_MEM_READ( "mq_timedsend(abs_timeout)", ARG5,
1544 sizeof(struct vki_timespec) );
1545 }
1546 }
1547
1548 PRE(sys_mq_timedreceive)
1549 {
1550 *flags |= SfMayBlock;
1551 PRINT("sys_mq_timedreceive( %ld, %#lx, %llu, %#lx, %#lx )",
1552 ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
1553 PRE_REG_READ5(ssize_t, "mq_timedreceive",
1554 vki_mqd_t, mqdes, char *, msg_ptr, vki_size_t, msg_len,
1555 unsigned int *, msg_prio,
1556 const struct timespec *, abs_timeout);
1557 if (!ML_(fd_allowed)(ARG1, "mq_timedreceive", tid, False)) {
1558 SET_STATUS_Failure( VKI_EBADF );
1559 } else {
1560 PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", ARG2, ARG3 );
1561 if (ARG4 != 0)
1562 PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
1563 ARG4, sizeof(unsigned int) );
1564 if (ARG5 != 0)
1565 PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
1566 ARG5, sizeof(struct vki_timespec) );
1567 }
1568 }
1569 POST(sys_mq_timedreceive)
1570 {
1571 POST_MEM_WRITE( ARG2, ARG3 );
1572 if (ARG4 != 0)
1573 POST_MEM_WRITE( ARG4, sizeof(unsigned int) );
1574 }
1575
1576 PRE(sys_mq_notify)
1577 {
1578 PRINT("sys_mq_notify( %ld, %#lx )", ARG1,ARG2 );
1579 PRE_REG_READ2(long, "mq_notify",
1580 vki_mqd_t, mqdes, const struct sigevent *, notification);
1581 if (!ML_(fd_allowed)(ARG1, "mq_notify", tid, False))
1582 SET_STATUS_Failure( VKI_EBADF );
1583 else if (ARG2 != 0)
1584 PRE_MEM_READ( "mq_notify(notification)",
1585 ARG2, sizeof(struct vki_sigevent) );
1586 }
1587
1588 PRE(sys_mq_getsetattr)
1589 {
1590 PRINT("sys_mq_getsetattr( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3 );
1591 PRE_REG_READ3(long, "mq_getsetattr",
1592 vki_mqd_t, mqdes, const struct mq_attr *, mqstat,
1593 struct mq_attr *, omqstat);
1594 if (!ML_(fd_allowed)(ARG1, "mq_getsetattr", tid, False)) {
1595 SET_STATUS_Failure( VKI_EBADF );
1596 } else {
1597 if (ARG2 != 0) {
1598 const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG2;
1599 PRE_MEM_READ( "mq_getsetattr(mqstat->mq_flags)",
1600 (Addr)&attr->mq_flags, sizeof(attr->mq_flags) );
1601 }
1602 if (ARG3 != 0)
1603 PRE_MEM_WRITE( "mq_getsetattr(omqstat)", ARG3,
1604 sizeof(struct vki_mq_attr) );
1605 }
1606 }
1607 POST(sys_mq_getsetattr)
1608 {
1609 if (ARG3 != 0)
1610 POST_MEM_WRITE( ARG3, sizeof(struct vki_mq_attr) );
1611 }
1612
1613 #endif
1614
1615 /* ---------------------------------------------------------------------
1616 clock_* wrappers
1617 ------------------------------------------------------------------ */
1618
PRE(sys_clock_settime)1619 PRE(sys_clock_settime)
1620 {
1621 PRINT("sys_clock_settime( %ld, %#lx )", ARG1,ARG2);
1622 PRE_REG_READ2(long, "clock_settime",
1623 vki_clockid_t, clk_id, const struct timespec *, tp);
1624 PRE_MEM_READ( "clock_settime(tp)", ARG2, sizeof(struct vki_timespec) );
1625 }
1626
PRE(sys_clock_gettime)1627 PRE(sys_clock_gettime)
1628 {
1629 PRINT("sys_clock_gettime( %ld, %#lx )" , ARG1,ARG2);
1630 PRE_REG_READ2(long, "clock_gettime",
1631 vki_clockid_t, clk_id, struct timespec *, tp);
1632 PRE_MEM_WRITE( "clock_gettime(tp)", ARG2, sizeof(struct vki_timespec) );
1633 }
POST(sys_clock_gettime)1634 POST(sys_clock_gettime)
1635 {
1636 POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
1637 }
1638
PRE(sys_clock_getres)1639 PRE(sys_clock_getres)
1640 {
1641 PRINT("sys_clock_getres( %ld, %#lx )" , ARG1,ARG2);
1642 // Nb: we can't use "RES" as the param name because that's a macro
1643 // defined above!
1644 PRE_REG_READ2(long, "clock_getres",
1645 vki_clockid_t, clk_id, struct timespec *, res);
1646 if (ARG2 != 0)
1647 PRE_MEM_WRITE( "clock_getres(res)", ARG2, sizeof(struct vki_timespec) );
1648 }
POST(sys_clock_getres)1649 POST(sys_clock_getres)
1650 {
1651 if (ARG2 != 0)
1652 POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
1653 }
1654
1655 #if 0
1656 PRE(sys_clock_nanosleep)
1657 {
1658 *flags |= SfMayBlock|SfPostOnFail;
1659 PRINT("sys_clock_nanosleep( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
1660 PRE_REG_READ4(int32_t, "clock_nanosleep",
1661 vki_clockid_t, clkid, int, flags,
1662 const struct timespec *, rqtp, struct timespec *, rmtp);
1663 PRE_MEM_READ( "clock_nanosleep(rqtp)", ARG3, sizeof(struct vki_timespec) );
1664 if (ARG4 != 0)
1665 PRE_MEM_WRITE( "clock_nanosleep(rmtp)", ARG4, sizeof(struct vki_timespec) );
1666 }
1667 POST(sys_clock_nanosleep)
1668 {
1669 if (ARG4 != 0 && FAILURE && RES_unchecked == VKI_EINTR)
1670 POST_MEM_WRITE( ARG4, sizeof(struct vki_timespec) );
1671 }
1672
1673 /* ---------------------------------------------------------------------
1674 timer_* wrappers
1675 ------------------------------------------------------------------ */
1676
1677 PRE(sys_timer_create)
1678 {
1679 PRINT("sys_timer_create( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
1680 PRE_REG_READ3(long, "timer_create",
1681 vki_clockid_t, clockid, struct sigevent *, evp,
1682 vki_timer_t *, timerid);
1683 if (ARG2 != 0)
1684 PRE_MEM_READ( "timer_create(evp)", ARG2, sizeof(struct vki_sigevent) );
1685 PRE_MEM_WRITE( "timer_create(timerid)", ARG3, sizeof(vki_timer_t) );
1686 }
1687 POST(sys_timer_create)
1688 {
1689 POST_MEM_WRITE( ARG3, sizeof(vki_timer_t) );
1690 }
1691
1692 PRE(sys_timer_settime)
1693 {
1694 PRINT("sys_timer_settime( %lld, %ld, %#lx, %#lx )", (ULong)ARG1,ARG2,ARG3,ARG4);
1695 PRE_REG_READ4(long, "timer_settime",
1696 vki_timer_t, timerid, int, flags,
1697 const struct itimerspec *, value,
1698 struct itimerspec *, ovalue);
1699 PRE_MEM_READ( "timer_settime(value)", ARG3,
1700 sizeof(struct vki_itimerspec) );
1701 if (ARG4 != 0)
1702 PRE_MEM_WRITE( "timer_settime(ovalue)", ARG4,
1703 sizeof(struct vki_itimerspec) );
1704 }
1705 POST(sys_timer_settime)
1706 {
1707 if (ARG4 != 0)
1708 POST_MEM_WRITE( ARG4, sizeof(struct vki_itimerspec) );
1709 }
1710
1711 PRE(sys_timer_gettime)
1712 {
1713 PRINT("sys_timer_gettime( %lld, %#lx )", (ULong)ARG1,ARG2);
1714 PRE_REG_READ2(long, "timer_gettime",
1715 vki_timer_t, timerid, struct itimerspec *, value);
1716 PRE_MEM_WRITE( "timer_gettime(value)", ARG2,
1717 sizeof(struct vki_itimerspec));
1718 }
1719 POST(sys_timer_gettime)
1720 {
1721 POST_MEM_WRITE( ARG2, sizeof(struct vki_itimerspec) );
1722 }
1723
1724 PRE(sys_timer_getoverrun)
1725 {
1726 PRINT("sys_timer_getoverrun( %#lx )", ARG1);
1727 PRE_REG_READ1(long, "timer_getoverrun", vki_timer_t, timerid);
1728 }
1729
1730 PRE(sys_timer_delete)
1731 {
1732 PRINT("sys_timer_delete( %#lx )", ARG1);
1733 PRE_REG_READ1(long, "timer_delete", vki_timer_t, timerid);
1734 }
1735
1736 /* ---------------------------------------------------------------------
1737 sched_* wrappers
1738 ------------------------------------------------------------------ */
1739
1740 PRE(sys_sched_setparam)
1741 {
1742 PRINT("sched_setparam ( %ld, %#lx )", ARG1, ARG2 );
1743 PRE_REG_READ2(long, "sched_setparam",
1744 vki_pid_t, pid, struct sched_param *, p);
1745 PRE_MEM_READ( "sched_setparam(p)", ARG2, sizeof(struct vki_sched_param) );
1746 }
1747 POST(sys_sched_setparam)
1748 {
1749 POST_MEM_WRITE( ARG2, sizeof(struct vki_sched_param) );
1750 }
1751
1752 PRE(sys_sched_getparam)
1753 {
1754 PRINT("sched_getparam ( %ld, %#lx )", ARG1, ARG2 );
1755 PRE_REG_READ2(long, "sched_getparam",
1756 vki_pid_t, pid, struct sched_param *, p);
1757 PRE_MEM_WRITE( "sched_getparam(p)", ARG2, sizeof(struct vki_sched_param) );
1758 }
1759 POST(sys_sched_getparam)
1760 {
1761 POST_MEM_WRITE( ARG2, sizeof(struct vki_sched_param) );
1762 }
1763
1764 PRE(sys_sched_getscheduler)
1765 {
1766 PRINT("sys_sched_getscheduler ( %ld )", ARG1);
1767 PRE_REG_READ1(long, "sched_getscheduler", vki_pid_t, pid);
1768 }
1769
1770 PRE(sys_sched_setscheduler)
1771 {
1772 PRINT("sys_sched_setscheduler ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
1773 PRE_REG_READ3(long, "sched_setscheduler",
1774 vki_pid_t, pid, int, policy, struct sched_param *, p);
1775 if (ARG3 != 0)
1776 PRE_MEM_READ( "sched_setscheduler(p)",
1777 ARG3, sizeof(struct vki_sched_param));
1778 }
1779
1780 PRE(sys_sched_yield)
1781 {
1782 *flags |= SfMayBlock;
1783 PRINT("sched_yield()");
1784 PRE_REG_READ0(long, "sched_yield");
1785 }
1786 #endif
1787
PRE(sys_sched_get_priority_max)1788 PRE(sys_sched_get_priority_max)
1789 {
1790 PRINT("sched_get_priority_max ( %ld )", ARG1);
1791 PRE_REG_READ1(long, "sched_get_priority_max", int, policy);
1792 }
1793
PRE(sys_sched_get_priority_min)1794 PRE(sys_sched_get_priority_min)
1795 {
1796 PRINT("sched_get_priority_min ( %ld )", ARG1);
1797 PRE_REG_READ1(long, "sched_get_priority_min", int, policy);
1798 }
1799
1800 #if 0
1801 PRE(sys_sched_setaffinity)
1802 {
1803 PRINT("sched_setaffinity ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
1804 PRE_REG_READ3(long, "sched_setaffinity",
1805 vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
1806 PRE_MEM_READ( "sched_setaffinity(mask)", ARG3, ARG2);
1807 }
1808
1809 PRE(sys_sched_getaffinity)
1810 {
1811 PRINT("sched_getaffinity ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
1812 PRE_REG_READ3(long, "sched_getaffinity",
1813 vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
1814 PRE_MEM_WRITE( "sched_getaffinity(mask)", ARG3, ARG2);
1815 }
1816 POST(sys_sched_getaffinity)
1817 {
1818 POST_MEM_WRITE(ARG3, ARG2);
1819 }
1820
1821 #endif
1822
1823 /* ---------------------------------------------------------------------
1824 miscellaneous wrappers
1825 ------------------------------------------------------------------ */
1826
PRE(sys_munlockall)1827 PRE(sys_munlockall)
1828 {
1829 *flags |= SfMayBlock;
1830 PRINT("sys_munlockall ( )");
1831 PRE_REG_READ0(long, "munlockall");
1832 }
1833
1834 // Pipe on freebsd doesn't have args, and uses dual returns!
PRE(sys_pipe)1835 PRE(sys_pipe)
1836 {
1837 PRINT("sys_pipe ()");
1838 }
POST(sys_pipe)1839 POST(sys_pipe)
1840 {
1841 if (!ML_(fd_allowed)(RES, "pipe", tid, True) ||
1842 !ML_(fd_allowed)(RESHI, "pipe", tid, True)) {
1843 VG_(close)(RES);
1844 VG_(close)(RESHI);
1845 SET_STATUS_Failure( VKI_EMFILE );
1846 } else {
1847 if (VG_(clo_track_fds)) {
1848 ML_(record_fd_open_nameless)(tid, RES);
1849 ML_(record_fd_open_nameless)(tid, RESHI);
1850 }
1851 }
1852 }
1853
PRE(sys_pipe2)1854 PRE(sys_pipe2)
1855 {
1856 PRINT("sys_pipe2 ( %#lx, %ld )", ARG1, ARG2);
1857 PRE_REG_READ2(long, "pipe2",
1858 int *, fildes, int, flags);
1859 PRE_MEM_WRITE("pipe2(fildes)", ARG1, 2 * sizeof(int));
1860
1861 }
POST(sys_pipe2)1862 POST(sys_pipe2)
1863 {
1864 int *fildes;
1865
1866 if (RES != 0)
1867 return;
1868
1869 POST_MEM_WRITE(ARG1, 2 * sizeof(int));
1870 fildes = (int *)ARG1;
1871
1872 if (!ML_(fd_allowed)(fildes[0], "pipe2", tid, True) ||
1873 !ML_(fd_allowed)(fildes[1], "pipe2", tid, True)) {
1874 VG_(close)(fildes[0]);
1875 VG_(close)(fildes[1]);
1876 SET_STATUS_Failure( VKI_EMFILE );
1877 } else if (VG_(clo_track_fds)) {
1878 ML_(record_fd_open_nameless)(tid, fildes[0]);
1879 ML_(record_fd_open_nameless)(tid, fildes[1]);
1880 }
1881 }
1882
1883 #if 0
1884 PRE(sys_quotactl)
1885 {
1886 PRINT("sys_quotactl (0x%lx, %#lx, 0x%lx, 0x%lx )", ARG1,ARG2,ARG3, ARG4);
1887 PRE_REG_READ4(long, "quotactl",
1888 unsigned int, cmd, const char *, special, vki_qid_t, id,
1889 void *, addr);
1890 PRE_MEM_RASCIIZ( "quotactl(special)", ARG2 );
1891 }
1892
1893 PRE(sys_waitid)
1894 {
1895 *flags |= SfMayBlock;
1896 PRINT("sys_waitid( %ld, %ld, %#lx, %ld, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
1897 PRE_REG_READ5(int32_t, "sys_waitid",
1898 int, which, vki_pid_t, pid, struct vki_siginfo *, infop,
1899 int, options, struct vki_rusage *, ru);
1900 PRE_MEM_WRITE( "waitid(infop)", ARG3, sizeof(struct vki_siginfo) );
1901 if (ARG5 != 0)
1902 PRE_MEM_WRITE( "waitid(ru)", ARG5, sizeof(struct vki_rusage) );
1903 }
1904 POST(sys_waitid)
1905 {
1906 POST_MEM_WRITE( ARG3, sizeof(struct vki_siginfo) );
1907 if (ARG5 != 0)
1908 POST_MEM_WRITE( ARG5, sizeof(struct vki_rusage) );
1909 }
1910
1911 /* ---------------------------------------------------------------------
1912 utime wrapper
1913 ------------------------------------------------------------------ */
1914
1915 PRE(sys_utime)
1916 {
1917 *flags |= SfMayBlock;
1918 PRINT("sys_utime ( %#lx, %#lx )", ARG1,ARG2);
1919 PRE_REG_READ2(long, "utime", char *, filename, struct utimbuf *, buf);
1920 PRE_MEM_RASCIIZ( "utime(filename)", ARG1 );
1921 if (ARG2 != 0)
1922 PRE_MEM_READ( "utime(buf)", ARG2, sizeof(struct vki_utimbuf) );
1923 }
1924
1925 #endif
1926
1927 /* ---------------------------------------------------------------------
1928 thr* wrappers
1929 ------------------------------------------------------------------ */
1930
PRE(sys_thr_self)1931 PRE(sys_thr_self)
1932 {
1933 PRINT( "sys_thr_self ( %#lx )", ARG1 );
1934 PRE_REG_READ1(long, "thr_self", long *, "id");
1935 PRE_MEM_WRITE( "thr_self()", ARG1, sizeof(long));
1936 }
POST(sys_thr_self)1937 POST(sys_thr_self)
1938 {
1939 POST_MEM_WRITE( ARG1, sizeof(long));
1940 }
1941
PRE(sys_thr_exit)1942 PRE(sys_thr_exit)
1943 {
1944 ThreadState *tst;
1945
1946 PRINT( "sys_thr_exit ( %#lx )", ARG1 );
1947 PRE_REG_READ1(long, "thr_exit", long *, "status");
1948
1949 if (ARG1)
1950 PRE_MEM_WRITE( "thr_exit(status)", ARG1, sizeof(long) );
1951 tst = VG_(get_ThreadState)(tid);
1952 tst->exitreason = VgSrc_ExitThread;
1953 tst->os_state.exitcode = ARG1;
1954 SET_STATUS_Success(0);
1955 }
1956
PRE(sys_thr_set_name)1957 PRE(sys_thr_set_name)
1958 {
1959 PRINT( "sys_thr_set_name ( %ld, %#lx )", ARG1, ARG2 );
1960 PRE_REG_READ2(long, "thr_set_name", long, "id", const char *, "name");
1961 PRE_MEM_RASCIIZ( "sys_thr_set_name(threadname)", ARG2);
1962 }
1963
PRE(sys_thr_kill)1964 PRE(sys_thr_kill)
1965 {
1966 PRINT("sys_thr_kill ( %ld, %ld )", ARG1,ARG2);
1967 PRE_REG_READ2(long, "thr_kill", long, id, int, sig);
1968 if (!ML_(client_signal_OK)(ARG2)) {
1969 SET_STATUS_Failure( VKI_EINVAL );
1970 return;
1971 }
1972
1973 /* Check to see if this kill gave us a pending signal */
1974 *flags |= SfPollAfter;
1975
1976 if (VG_(clo_trace_signals))
1977 VG_(message)(Vg_DebugMsg, "thr_kill: sending signal %ld to tid %ld\n",
1978 ARG2, ARG1);
1979
1980 /* If we're sending SIGKILL, check to see if the target is one of
1981 our threads and handle it specially. */
1982 if (ARG2 == VKI_SIGKILL && ML_(do_sigkill)(ARG1, -1)) {
1983 SET_STATUS_Success(0);
1984 return;
1985 }
1986
1987 /* Ask to handle this syscall via the slow route, since that's the
1988 only one that sets tst->status to VgTs_WaitSys. If the result
1989 of doing the syscall is an immediate run of
1990 async_signalhandler() in m_signals, then we need the thread to
1991 be properly tidied away. I have the impression the previous
1992 version of this wrapper worked on x86/amd64 only because the
1993 kernel did not immediately deliver the async signal to this
1994 thread (on ppc it did, which broke the assertion re tst->status
1995 at the top of async_signalhandler()). */
1996 *flags |= SfMayBlock;
1997 }
POST(sys_thr_kill)1998 POST(sys_thr_kill)
1999 {
2000 if (VG_(clo_trace_signals))
2001 VG_(message)(Vg_DebugMsg, "thr_kill: sent signal %ld to tid %ld\n",
2002 ARG2, ARG1);
2003 }
PRE(sys_thr_kill2)2004 PRE(sys_thr_kill2)
2005 {
2006 PRINT("sys_thr_kill2 ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
2007 PRE_REG_READ3(long, "tgkill", int, pid, long, tid, int, sig);
2008 if (!ML_(client_signal_OK)(ARG3)) {
2009 SET_STATUS_Failure( VKI_EINVAL );
2010 return;
2011 }
2012
2013 /* Check to see if this kill gave us a pending signal */
2014 *flags |= SfPollAfter;
2015
2016 if (VG_(clo_trace_signals))
2017 VG_(message)(Vg_DebugMsg, "thr_kill2: sending signal %ld to pid %ld/%ld\n",
2018 ARG3, ARG1, ARG2);
2019
2020 /* If we're sending SIGKILL, check to see if the target is one of
2021 our threads and handle it specially. */
2022 if (ARG3 == VKI_SIGKILL && ML_(do_sigkill)(ARG2, ARG1)) {
2023 SET_STATUS_Success(0);
2024 return;
2025 }
2026
2027 /* Ask to handle this syscall via the slow route, since that's the
2028 only one that sets tst->status to VgTs_WaitSys. If the result
2029 of doing the syscall is an immediate run of
2030 async_signalhandler() in m_signals, then we need the thread to
2031 be properly tidied away. I have the impression the previous
2032 version of this wrapper worked on x86/amd64 only because the
2033 kernel did not immediately deliver the async signal to this
2034 thread (on ppc it did, which broke the assertion re tst->status
2035 at the top of async_signalhandler()). */
2036 *flags |= SfMayBlock;
2037 }
POST(sys_thr_kill2)2038 POST(sys_thr_kill2)
2039 {
2040 if (VG_(clo_trace_signals))
2041 VG_(message)(Vg_DebugMsg, "thr_kill2: sent signal %ld to pid %ld/%ld\n",
2042 ARG3, ARG1, ARG2);
2043 }
2044
PRE(sys_thr_wake)2045 PRE(sys_thr_wake)
2046 {
2047 PRINT("sys_thr_wake ( %ld )", ARG1);
2048 PRE_REG_READ1(long, "thr_wake", long, id);
2049 }
2050
2051 /* ---------------------------------------------------------------------
2052 umtx* wrappers
2053 ------------------------------------------------------------------ */
2054
PRE(sys__umtx_op)2055 PRE(sys__umtx_op)
2056 {
2057 // ThreadState *tst;
2058
2059 /* 5 args are always passed through. The last two can vary, but
2060 they're always pointers. They may not be used though. */
2061 switch(ARG2) {
2062 case VKI_UMTX_OP_LOCK:
2063 PRINT( "sys__umtx_op ( %#lx, LOCK, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2064 PRE_REG_READ5(long, "_umtx_op_lock",
2065 struct umtx *, obj, int, op, unsigned long, id,
2066 void *, zero, struct vki_timespec *, timeout);
2067 PRE_MEM_READ( "_umtx_op_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
2068 if (ARG5)
2069 PRE_MEM_READ( "_umtx_op_lock(timespec)", ARG5, sizeof(struct vki_timespec) );
2070 PRE_MEM_WRITE( "_umtx_op_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
2071 *flags |= SfMayBlock;
2072 break;
2073 case VKI_UMTX_OP_UNLOCK:
2074 PRINT( "sys__umtx_op ( %#lx, UNLOCK, %ld)", ARG1, ARG3);
2075 PRE_REG_READ3(long, "_umtx_op_unlock",
2076 struct umtx *, obj, int, op, unsigned long, id);
2077 PRE_MEM_READ( "_umtx_op_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
2078 PRE_MEM_WRITE( "_umtx_op_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
2079 break;
2080 case VKI_UMTX_OP_WAIT:
2081 PRINT( "sys__umtx_op ( %#lx, WAIT, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2082 PRE_REG_READ5(long, "_umtx_op_wait",
2083 struct umtx *, obj, int, op, unsigned long, id,
2084 void *, zero, struct vki_timespec *, timeout);
2085 PRE_MEM_READ( "_umtx_op_wait(mtx)", ARG1, sizeof(struct vki_umtx) );
2086 if (ARG5)
2087 PRE_MEM_READ( "_umtx_op_wait(timespec)", ARG5, sizeof(struct vki_timespec) );
2088 *flags |= SfMayBlock;
2089 break;
2090 case VKI_UMTX_OP_WAKE:
2091 PRINT( "sys__umtx_op ( %#lx, WAKE, %ld)", ARG1, ARG3);
2092 PRE_REG_READ3(long, "_umtx_op_wake",
2093 struct umtx *, obj, int, op, unsigned long, id);
2094 PRE_MEM_READ( "_umtx_op_wake(mtx)", ARG1, sizeof(struct vki_umtx) );
2095 break;
2096 case VKI_UMTX_OP_MUTEX_TRYLOCK:
2097 PRINT( "sys__umtx_op ( %#lx, MUTEX_TRYLOCK, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2098 PRE_REG_READ5(long, "_umtx_op_mutex_trylock",
2099 struct umutex *, obj, int, op, unsigned long, noid,
2100 void *, zero, struct vki_timespec *, timeout);
2101 PRE_MEM_READ( "_umtx_op_mutex_trylock(mutex)", ARG1, sizeof(struct vki_umutex) );
2102 if (ARG5)
2103 PRE_MEM_READ( "_umtx_op_mutex_trylock(timespec)", ARG5, sizeof(struct vki_timespec) );
2104 PRE_MEM_WRITE( "_umtx_op_mutex_trylock(mutex)", ARG1, sizeof(struct vki_umutex) );
2105 break;
2106 case VKI_UMTX_OP_MUTEX_LOCK:
2107 PRINT( "sys__umtx_op ( %#lx, MUTEX_LOCK, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2108 PRE_REG_READ5(long, "_umtx_op_mutex_lock",
2109 struct umutex *, obj, int, op, unsigned long, noid,
2110 void *, zero, struct vki_timespec *, timeout);
2111 PRE_MEM_READ( "_umtx_op_mutex_lock(mutex)", ARG1, sizeof(struct vki_umutex) );
2112 if (ARG5)
2113 PRE_MEM_READ( "_umtx_op_mutex_lock(timespec)", ARG5, sizeof(struct vki_timespec) );
2114 PRE_MEM_WRITE( "_umtx_op_mutex_lock(mutex)", ARG1, sizeof(struct vki_umutex) );
2115 *flags |= SfMayBlock;
2116 break;
2117 case VKI_UMTX_OP_MUTEX_UNLOCK:
2118 PRINT( "sys__umtx_op ( %#lx, MUTEX_UNLOCK)", ARG1);
2119 PRE_REG_READ2(long, "_umtx_op_mutex_unlock",
2120 struct umutex *, obj, int, op);
2121 PRE_MEM_READ( "_umtx_op_mutex_unlock(mutex)", ARG1, sizeof(struct vki_umutex) );
2122 PRE_MEM_WRITE( "_umtx_op_mutex_unlock(mutex)", ARG1, sizeof(struct vki_umutex) );
2123 break;
2124 case VKI_UMTX_OP_SET_CEILING:
2125 PRINT( "sys__umtx_op ( %#lx, SET_CEILING, %ld, %#lx)", ARG1, ARG3, ARG4);
2126 PRE_REG_READ4(long, "_umtx_op_set_ceiling",
2127 struct umutex *, obj, int, op, unsigned int, ceiling,
2128 unsigned int *, old_ceiling);
2129 PRE_MEM_READ( "_umtx_op_set_ceiling(mutex)", ARG1, sizeof(struct vki_umutex) );
2130 PRE_MEM_WRITE( "_umtx_op_set_ceiling(mutex)", ARG1, sizeof(struct vki_umutex) );
2131 if (ARG4)
2132 PRE_MEM_WRITE( "_umtx_op_set_ceiling(old_ceiling)", ARG4, sizeof(vki_uint32_t) );
2133 break;
2134 case VKI_UMTX_OP_CV_WAIT:
2135 PRINT( "sys__umtx_op ( %#lx, CV_WAIT, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2136 PRE_REG_READ5(long, "_umtx_op_cv_wait",
2137 struct ucond *, obj, int, op, unsigned long, wflags,
2138 struct umutex *, umtx, struct vki_timespec *, timeout);
2139 PRE_MEM_READ( "_umtx_op_cv_wait(cond)", ARG1, sizeof(struct vki_ucond) );
2140 PRE_MEM_WRITE( "_umtx_op_cv_wait(cond)", ARG1, sizeof(struct vki_ucond) );
2141 PRE_MEM_READ( "_umtx_op_cv_wait(mutex)", ARG4, sizeof(struct vki_umutex) );
2142 PRE_MEM_WRITE( "_umtx_op_cv_wait(mutex)", ARG4, sizeof(struct vki_umutex) );
2143 if (ARG5)
2144 PRE_MEM_READ( "_umtx_op_cv_wait(timespec)", ARG5, sizeof(struct vki_timespec) );
2145 *flags |= SfMayBlock;
2146 break;
2147 case VKI_UMTX_OP_CV_SIGNAL:
2148 PRINT( "sys__umtx_op ( %#lx, CV_SIGNAL)", ARG1);
2149 PRE_REG_READ2(long, "_umtx_op_cv_signal",
2150 struct ucond *, obj, int, op);
2151 PRE_MEM_READ( "_umtx_op_cv_signal(cond)", ARG1, sizeof(struct vki_ucond) );
2152 PRE_MEM_WRITE( "_umtx_op_cv_signal(cond)", ARG1, sizeof(struct vki_ucond) );
2153 break;
2154 case VKI_UMTX_OP_CV_BROADCAST:
2155 PRINT( "sys__umtx_op ( %#lx, CV_BROADCAST, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2156 PRE_REG_READ2(long, "_umtx_op_cv_broadcast",
2157 struct ucond *, obj, int, op);
2158 PRE_MEM_READ( "_umtx_op_cv_broadcast(cond)", ARG1, sizeof(struct vki_ucond) );
2159 PRE_MEM_WRITE( "_umtx_op_cv_broadcast(cond)", ARG1, sizeof(struct vki_ucond) );
2160 break;
2161 case VKI_UMTX_OP_WAIT_UINT:
2162 PRINT( "sys__umtx_op ( %#lx, CV_WAIT_UINT, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2163 PRE_REG_READ5(long, "_umtx_op_wait_uint",
2164 int *, obj, int, op, unsigned long, id,
2165 void *, zero, struct vki_timespec *, timeout);
2166 PRE_MEM_READ( "_umtx_op_wait(uint)", ARG1, sizeof(int) );
2167 if (ARG5)
2168 PRE_MEM_READ( "_umtx_op_wait(timespec)", ARG5, sizeof(struct vki_timespec) );
2169 *flags |= SfMayBlock;
2170 break;
2171 case VKI_UMTX_OP_RW_RDLOCK:
2172 PRINT( "sys__umtx_op ( %#lx, RW_RDLOCK, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2173 PRE_REG_READ5(long, "_umtx_op_rw_rdlock",
2174 struct urwlock *, obj, int, op, unsigned long, noid,
2175 void *, zero, struct vki_timespec *, timeout);
2176 PRE_MEM_READ( "_umtx_op_rw_rdlock(rw)", ARG1, sizeof(struct vki_urwlock) );
2177 PRE_MEM_WRITE( "_umtx_op_rw_rdlock(rw)", ARG1, sizeof(struct vki_urwlock) );
2178 *flags |= SfMayBlock;
2179 break;
2180 case VKI_UMTX_OP_RW_WRLOCK:
2181 PRINT( "sys__umtx_op ( %#lx, RW_WRLOCK, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2182 PRE_REG_READ5(long, "_umtx_op_rw_wrlock",
2183 struct urwlock *, obj, int, op, unsigned long, noid,
2184 void *, zero, struct vki_timespec *, timeout);
2185 PRE_MEM_READ( "_umtx_op_rw_wrlock(rw)", ARG1, sizeof(struct vki_urwlock) );
2186 PRE_MEM_WRITE( "_umtx_op_rw_wrlock(rw)", ARG1, sizeof(struct vki_urwlock) );
2187 *flags |= SfMayBlock;
2188 break;
2189 case VKI_UMTX_OP_RW_UNLOCK:
2190 PRINT( "sys__umtx_op ( %#lx, RW_UNLOCK, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2191 PRE_REG_READ2(long, "_umtx_op_rw_unlock",
2192 struct urwlock *, obj, int, op);
2193 PRE_MEM_READ( "_umtx_op_rw_unlock(rw)", ARG1, sizeof(struct vki_urwlock) );
2194 PRE_MEM_WRITE( "_umtx_op_rw_unlock(rw)", ARG1, sizeof(struct vki_urwlock) );
2195 break;
2196 case VKI_UMTX_OP_WAIT_UINT_PRIVATE:
2197 PRINT( "sys__umtx_op ( %#lx, CV_WAIT_UINT_PRIVATE, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2198 PRE_REG_READ5(long, "_umtx_op_wait_uint_private",
2199 int *, obj, int, op, unsigned long, id,
2200 void *, zero, struct vki_timespec *, timeout);
2201 PRE_MEM_READ( "_umtx_op_wait_private(uint)", ARG1, sizeof(int) );
2202 if (ARG5)
2203 PRE_MEM_READ( "_umtx_op_wait_private(umtx_time)", ARG5, sizeof(struct vki_umtx_time) );
2204 *flags |= SfMayBlock;
2205 break;
2206 case VKI_UMTX_OP_WAKE_PRIVATE:
2207 PRINT( "sys__umtx_op ( %#lx, CV_WAKE_PRIVATE, %ld)", ARG1, ARG3);
2208 PRE_REG_READ3(long, "_umtx_op_wake_private",
2209 struct umtx *, obj, int, op, unsigned long, id);
2210 PRE_MEM_READ( "_umtx_op_wake_private(mtx)", ARG1, sizeof(struct vki_umtx) );
2211 break;
2212 case VKI_UMTX_OP_MUTEX_WAIT:
2213 PRINT( "sys__umtx_op ( %#lx, MUTEX_WAIT, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2214 PRE_REG_READ2(long, "_umtx_op_mutex_wait",
2215 struct umutex *, obj, int, op);
2216 PRE_MEM_READ( "_umtx_op_mutex_wait(mutex)", ARG1, sizeof(struct vki_umutex) );
2217 PRE_MEM_WRITE( "_umtx_op_mutex_wait(mutex)", ARG1, sizeof(struct vki_umutex) );
2218 *flags |= SfMayBlock;
2219 break;
2220 case VKI_UMTX_OP_MUTEX_WAKE:
2221 PRINT( "sys__umtx_op ( %#lx, MUTEX_WAKE, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2222 PRE_REG_READ2(long, "_umtx_op_mutex_wake",
2223 struct umutex *, obj, int, op);
2224 PRE_MEM_READ( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
2225 PRE_MEM_WRITE( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
2226 break;
2227 case VKI_UMTX_OP_SEM_WAIT:
2228 PRINT( "sys__umtx_op ( %#lx, SEM_WAIT, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2229 PRE_REG_READ5(long, "_umtx_op_sem_wait",
2230 struct usem *, obj, int, op, unsigned long, id,
2231 void *, zero, struct vki_timespec *, timeout);
2232 PRE_MEM_READ( "_umtx_op_sem_wait(usem)", ARG1, sizeof(struct vki_usem) );
2233 PRE_MEM_WRITE( "_umtx_op_sem_wait(usem)", ARG1, sizeof(struct vki_usem) );
2234 if (ARG5)
2235 PRE_MEM_READ( "_umtx_op_sem_wait(umtx_time)", ARG5, sizeof(struct vki_umtx_time) );
2236 *flags |= SfMayBlock;
2237 break;
2238 case VKI_UMTX_OP_SEM_WAKE:
2239 PRINT( "sys__umtx_op ( %#lx, SEM_WAKE, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2240 PRE_REG_READ2(long, "_umtx_op_sem_wake",
2241 struct umutex *, obj, int, op);
2242 PRE_MEM_READ( "_umtx_op_sem_wake(mutex)", ARG1, sizeof(struct vki_usem) );
2243 PRE_MEM_WRITE( "_umtx_op_sem_wake(mutex)", ARG1, sizeof(struct vki_usem) );
2244 break;
2245 case VKI_UMTX_OP_NWAKE_PRIVATE:
2246 PRINT( "sys__umtx_op ( %#lx, NWAKE_PRIVATE, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2247 PRE_REG_READ3(long, "_umtx_op_nwake_private",
2248 struct umutex *, obj, int, op, int, count);
2249 PRE_MEM_READ( "_umtx_op_nwake_private(mtxs)", ARG1, ARG3 * sizeof(void *) );
2250 PRE_MEM_WRITE( "_umtx_op_mutex_wake(mtxs)", ARG1, sizeof(struct vki_umutex) );
2251 break;
2252 case VKI_UMTX_OP_MUTEX_WAKE2:
2253 PRINT( "sys__umtx_op ( %#lx, MUTEX_WAKE2, %ld, %#lx, %#lx)", ARG1, ARG3, ARG4, ARG5);
2254 PRE_REG_READ3(long, "_umtx_op_mutex_wake2",
2255 struct umutex *, obj, int, op, unsigned long, flags);
2256 PRE_MEM_READ( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
2257 PRE_MEM_WRITE( "_umtx_op_mutex_wake(mutex)", ARG1, sizeof(struct vki_umutex) );
2258 break;
2259 default:
2260 PRINT( "sys__umtx_op ( %#lx, %ld(UNKNOWN), %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4, ARG5);
2261 break;
2262 }
2263 // tst = VG_(get_ThreadState)(tid);
2264 //PRINT(" [[ UMTX_OP %d: me=%d arg1 %#lx = %#lx (%ld) ]]", ARG2, tst->os_state.lwpid, ARG1, *(UWord *)ARG1, *(UWord *)ARG1 & 0x7fffffff);
2265 }
2266
POST(sys__umtx_op)2267 POST(sys__umtx_op)
2268 {
2269 //PRINT("[[ POST_UMTX_OP %d: arg1 %#lx = %#lx (%ld) ]]\n", ARG2, ARG1, *(UWord *)ARG1, *(UWord *)ARG1 & 0x7fffffff);
2270 switch(ARG2) {
2271 case VKI_UMTX_OP_LOCK:
2272 if (SUCCESS)
2273 POST_MEM_WRITE( ARG1, sizeof(struct vki_umtx) );
2274 break;
2275 case VKI_UMTX_OP_UNLOCK:
2276 if (SUCCESS)
2277 POST_MEM_WRITE( ARG1, sizeof(struct vki_umtx) );
2278 break;
2279 case VKI_UMTX_OP_WAIT:
2280 case VKI_UMTX_OP_WAKE:
2281 case VKI_UMTX_OP_WAIT_UINT:
2282 case VKI_UMTX_OP_WAIT_UINT_PRIVATE:
2283 case VKI_UMTX_OP_WAKE_PRIVATE:
2284 break;
2285 case VKI_UMTX_OP_MUTEX_TRYLOCK:
2286 case VKI_UMTX_OP_MUTEX_LOCK:
2287 case VKI_UMTX_OP_MUTEX_UNLOCK:
2288 case VKI_UMTX_OP_MUTEX_WAIT: /* Sets/clears contested bits */
2289 case VKI_UMTX_OP_MUTEX_WAKE: /* Sets/clears contested bits */
2290 if (SUCCESS)
2291 POST_MEM_WRITE( ARG1, sizeof(struct vki_umutex) );
2292 break;
2293 case VKI_UMTX_OP_SET_CEILING:
2294 if (SUCCESS) {
2295 POST_MEM_WRITE( ARG1, sizeof(struct vki_umutex) );
2296 if (ARG4)
2297 POST_MEM_WRITE( ARG4, sizeof(vki_uint32_t) );
2298 }
2299 break;
2300 case VKI_UMTX_OP_CV_WAIT:
2301 if (SUCCESS) {
2302 POST_MEM_WRITE( ARG1, sizeof(struct vki_ucond) );
2303 POST_MEM_WRITE( ARG4, sizeof(struct vki_umutex) );
2304 }
2305 break;
2306 case VKI_UMTX_OP_CV_SIGNAL:
2307 if (SUCCESS) {
2308 POST_MEM_WRITE( ARG1, sizeof(struct vki_ucond) );
2309 }
2310 break;
2311 case VKI_UMTX_OP_CV_BROADCAST:
2312 if (SUCCESS) {
2313 POST_MEM_WRITE( ARG1, sizeof(struct vki_ucond) );
2314 }
2315 break;
2316 case VKI_UMTX_OP_RW_RDLOCK:
2317 case VKI_UMTX_OP_RW_WRLOCK:
2318 case VKI_UMTX_OP_RW_UNLOCK:
2319 if (SUCCESS) {
2320 POST_MEM_WRITE( ARG1, sizeof(struct vki_urwlock) );
2321 }
2322 break;
2323 default:
2324 break;
2325 }
2326 }
2327
PRE(sys__umtx_lock)2328 PRE(sys__umtx_lock)
2329 {
2330 PRINT( "sys__umtx_lock ( %#lx )", ARG1);
2331 PRE_REG_READ1(long, "_umtx_lock", struct vki_umtx *, umtx);
2332 PRE_MEM_READ( "_umtx_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
2333 PRE_MEM_WRITE( "_umtx_lock(mtx)", ARG1, sizeof(struct vki_umtx) );
2334 }
2335
POST(sys__umtx_lock)2336 POST(sys__umtx_lock)
2337 {
2338 if (SUCCESS)
2339 POST_MEM_WRITE(ARG1, sizeof(struct vki_umtx));
2340 }
2341
PRE(sys__umtx_unlock)2342 PRE(sys__umtx_unlock)
2343 {
2344 PRINT( "sys__umtx_unlock ( %#lx )", ARG1);
2345 PRE_REG_READ1(long, "_umtx_unlock", struct vki_umtx *, umtx);
2346 PRE_MEM_READ( "_umtx_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
2347 PRE_MEM_WRITE( "_umtx_unlock(mtx)", ARG1, sizeof(struct vki_umtx) );
2348 }
2349
POST(sys__umtx_unlock)2350 POST(sys__umtx_unlock)
2351 {
2352 if (SUCCESS)
2353 POST_MEM_WRITE(ARG1, sizeof(struct vki_umtx));
2354 }
2355
PRE(sys_rtprio_thread)2356 PRE(sys_rtprio_thread)
2357 {
2358 PRINT( "sys_rtprio_thread ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3 );
2359 PRE_REG_READ3(long, "rtprio_thread",
2360 int, "function", __vki_lwpid_t, "lwpid", struct vki_rtprio *, "rtp");
2361 if (ARG1 == VKI_RTP_SET) {
2362 PRE_MEM_READ( "rtprio_thread(set)", ARG3, sizeof(struct vki_rtprio));
2363 } else if (ARG1 == VKI_RTP_LOOKUP) {
2364 PRE_MEM_WRITE( "rtprio_thread(lookup)", ARG3, sizeof(struct vki_rtprio));
2365 } else {
2366 /* PHK ?? */
2367 }
2368 }
POST(sys_rtprio_thread)2369 POST(sys_rtprio_thread)
2370 {
2371 if (ARG1 == VKI_RTP_LOOKUP && RES == 0)
2372 POST_MEM_WRITE( ARG3, sizeof(struct vki_rtprio));
2373 }
2374
2375 /* ---------------------------------------------------------------------
2376 sig* wrappers
2377 ------------------------------------------------------------------ */
2378
PRE(sys_sigpending)2379 PRE(sys_sigpending)
2380 {
2381 PRINT( "sys_sigpending ( %#lx )", ARG1 );
2382 PRE_REG_READ1(long, "sigpending", vki_sigset_t *, set);
2383 PRE_MEM_WRITE( "sigpending(set)", ARG1, sizeof(vki_sigset_t));
2384 }
POST(sys_sigpending)2385 POST(sys_sigpending)
2386 {
2387 POST_MEM_WRITE( ARG1, sizeof(vki_sigset_t) ) ;
2388 }
2389
2390 /* ---------------------------------------------------------------------
2391 rt_sig* wrappers
2392 ------------------------------------------------------------------ */
2393
2394 static int sigformat[_VKI_NSIG];
2395
PRE(sys_sigaction4)2396 PRE(sys_sigaction4)
2397 {
2398 PRINT("sys_sigaction ( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
2399 PRE_REG_READ3(long, "sigaction",
2400 int, signum, const struct sigaction *, act,
2401 struct sigaction *, oldact);
2402
2403 if (ARG2 != 0) {
2404 struct vki_sigaction *sa = (struct vki_sigaction *)ARG2;
2405 PRE_MEM_READ( "sigaction(act->sa_handler)", (Addr)&sa->ksa_handler, sizeof(sa->ksa_handler));
2406 PRE_MEM_READ( "sigaction(act->sa_mask)", (Addr)&sa->sa_mask, sizeof(sa->sa_mask));
2407 PRE_MEM_READ( "sigaction(act->sa_flags)", (Addr)&sa->sa_flags, sizeof(sa->sa_flags));
2408 if (ARG1 < _VKI_NSIG)
2409 sigformat[ARG1] = 4;
2410 }
2411 if (ARG3 != 0)
2412 PRE_MEM_WRITE( "sigaction(oldact)", ARG3, sizeof(struct vki_sigaction));
2413
2414 /* process the signal immediately. */
2415 SET_STATUS_from_SysRes(
2416 VG_(do_sys_sigaction)(ARG1, (const vki_sigaction_toK_t *)ARG2,
2417 (vki_sigaction_fromK_t *)ARG3)
2418 );
2419 }
POST(sys_sigaction4)2420 POST(sys_sigaction4)
2421 {
2422 vg_assert(SUCCESS);
2423 if (RES == 0 && ARG3 != 0)
2424 POST_MEM_WRITE( ARG3, sizeof(struct vki_sigaction));
2425 }
2426
2427 /* Identical, but warns the signal handler to expect the different sigframe */
PRE(sys_sigaction)2428 PRE(sys_sigaction)
2429 {
2430 PRINT("sys_sigaction6 ( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
2431 PRE_REG_READ3(long, "sigaction6",
2432 int, signum, const struct sigaction *, act,
2433 struct sigaction *, oldact);
2434
2435 if (ARG2 != 0) {
2436 struct vki_sigaction *sa = (struct vki_sigaction *)ARG2;
2437 PRE_MEM_READ( "sigaction6(act->sa_handler)", (Addr)&sa->ksa_handler, sizeof(sa->ksa_handler));
2438 PRE_MEM_READ( "sigaction6(act->sa_mask)", (Addr)&sa->sa_mask, sizeof(sa->sa_mask));
2439 PRE_MEM_READ( "sigaction6(act->sa_flags)", (Addr)&sa->sa_flags, sizeof(sa->sa_flags));
2440 if (ARG1 < _VKI_NSIG)
2441 sigformat[ARG1] = 6;
2442 }
2443 if (ARG3 != 0)
2444 PRE_MEM_WRITE( "sigaction6(oldact)", ARG3, sizeof(struct vki_sigaction));
2445
2446 SET_STATUS_from_SysRes(
2447 VG_(do_sys_sigaction)(ARG1, (const vki_sigaction_toK_t *)ARG2,
2448 (vki_sigaction_fromK_t *)ARG3)
2449 );
2450 }
POST(sys_sigaction)2451 POST(sys_sigaction)
2452 {
2453 vg_assert(SUCCESS);
2454 if (RES == 0 && ARG3 != 0)
2455 POST_MEM_WRITE( ARG3, sizeof(struct vki_sigaction));
2456 }
2457
2458
PRE(sys_sigprocmask)2459 PRE(sys_sigprocmask)
2460 {
2461 PRINT("sys_sigprocmask ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
2462 PRE_REG_READ3(long, "sigprocmask",
2463 int, how, vki_sigset_t *, set, vki_sigset_t *, oldset);
2464 if (ARG2 != 0)
2465 PRE_MEM_READ( "sigprocmask(set)", ARG2, sizeof(vki_sigset_t));
2466 if (ARG3 != 0)
2467 PRE_MEM_WRITE( "sigprocmask(oldset)", ARG3, sizeof(vki_sigset_t));
2468
2469 SET_STATUS_from_SysRes(
2470 VG_(do_sys_sigprocmask) ( tid, ARG1 /*how*/,
2471 (vki_sigset_t*) ARG2,
2472 (vki_sigset_t*) ARG3 )
2473 );
2474
2475 if (SUCCESS)
2476 *flags |= SfPollAfter;
2477 }
POST(sys_sigprocmask)2478 POST(sys_sigprocmask)
2479 {
2480 vg_assert(SUCCESS);
2481 if (RES == 0 && ARG3 != 0)
2482 POST_MEM_WRITE( ARG3, sizeof(vki_sigset_t));
2483 }
2484
2485 /* Not in 4.x */
PRE(sys_sigtimedwait)2486 PRE(sys_sigtimedwait)
2487 {
2488 *flags |= SfMayBlock;
2489 PRINT("sys_sigtimedwait ( %#lx, %#lx, %#lx )",
2490 ARG1,ARG2,ARG3);
2491 PRE_REG_READ3(long, "sigtimedwait",
2492 const vki_sigset_t *, set, vki_siginfo_t *, info,
2493 const struct timespec *, timeout);
2494 if (ARG1 != 0)
2495 PRE_MEM_READ( "sigtimedwait(set)", ARG1, sizeof(vki_sigset_t));
2496 if (ARG2 != 0)
2497 PRE_MEM_WRITE( "sigtimedwait(info)", ARG2, sizeof(vki_siginfo_t) );
2498 if (ARG3 != 0)
2499 PRE_MEM_READ( "sigtimedwait(timeout)",
2500 ARG3, sizeof(struct vki_timespec) );
2501 }
POST(sys_sigtimedwait)2502 POST(sys_sigtimedwait)
2503 {
2504 if (ARG2 != 0)
2505 POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );
2506 }
2507
2508 /* Not in 4.x */
PRE(sys_sigwaitinfo)2509 PRE(sys_sigwaitinfo)
2510 {
2511 *flags |= SfMayBlock;
2512 PRINT("sys_sigwaitinfo ( %#lx, %#lx )",
2513 ARG1,ARG2);
2514 PRE_REG_READ2(long, "sigwaitinfo",
2515 const vki_sigset_t *, set, vki_siginfo_t *, info);
2516 if (ARG1 != 0)
2517 PRE_MEM_READ( "sigwaitinfo(set)", ARG1, sizeof(vki_sigset_t));
2518 if (ARG2 != 0)
2519 PRE_MEM_WRITE( "sigwaitinfo(info)", ARG2, sizeof(vki_siginfo_t) );
2520 }
POST(sys_sigwaitinfo)2521 POST(sys_sigwaitinfo)
2522 {
2523 if (ARG2 != 0)
2524 POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );
2525 }
2526
2527 #if 0 /* not on freebsd 4.x */
2528 PRE(sys_rt_sigqueueinfo)
2529 {
2530 PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#lx)", ARG1, ARG2, ARG3);
2531 PRE_REG_READ3(long, "rt_sigqueueinfo",
2532 int, pid, int, sig, vki_siginfo_t *, uinfo);
2533 if (ARG2 != 0)
2534 PRE_MEM_READ( "rt_sigqueueinfo(uinfo)", ARG3, sizeof(vki_siginfo_t) );
2535 }
2536 POST(sys_rt_sigqueueinfo)
2537 {
2538 if (!ML_(client_signal_OK)(ARG2))
2539 SET_STATUS_Failure( VKI_EINVAL );
2540 }
2541 #endif
2542
PRE(sys_sigsuspend)2543 PRE(sys_sigsuspend)
2544 {
2545 *flags |= SfMayBlock;
2546 PRINT("sys_sigsuspend ( %#lx )", ARG1 );
2547 PRE_REG_READ1(int, "rt_sigsuspend", vki_sigset_t *, mask)
2548 if (ARG1 != (Addr)NULL) {
2549 PRE_MEM_READ( "rt_sigsuspend(mask)", ARG1, sizeof(vki_sigset_t) );
2550 }
2551 }
2552
2553 #if 0
2554 /* ---------------------------------------------------------------------
2555 linux msg* wrapper helpers
2556 ------------------------------------------------------------------ */
2557
2558 void
2559 ML_(linux_PRE_sys_msgsnd) ( ThreadId tid,
2560 UWord arg0, UWord arg1, UWord arg2, UWord arg3 )
2561 {
2562 /* int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg); */
2563 struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg1;
2564 PRE_MEM_READ( "msgsnd(msgp->mtype)", (Addr)&msgp->mtype, sizeof(msgp->mtype) );
2565 PRE_MEM_READ( "msgsnd(msgp->mtext)", (Addr)&msgp->mtext, arg2 );
2566 }
2567
2568 void
2569 ML_(linux_PRE_sys_msgrcv) ( ThreadId tid,
2570 UWord arg0, UWord arg1, UWord arg2,
2571 UWord arg3, UWord arg4 )
2572 {
2573 /* ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz,
2574 long msgtyp, int msgflg); */
2575 struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg1;
2576 PRE_MEM_WRITE( "msgrcv(msgp->mtype)", (Addr)&msgp->mtype, sizeof(msgp->mtype) );
2577 PRE_MEM_WRITE( "msgrcv(msgp->mtext)", (Addr)&msgp->mtext, arg2 );
2578 }
2579 void
2580 ML_(linux_POST_sys_msgrcv) ( ThreadId tid,
2581 UWord res,
2582 UWord arg0, UWord arg1, UWord arg2,
2583 UWord arg3, UWord arg4 )
2584 {
2585 struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg1;
2586 POST_MEM_WRITE( (Addr)&msgp->mtype, sizeof(msgp->mtype) );
2587 POST_MEM_WRITE( (Addr)&msgp->mtext, res );
2588 }
2589
2590 void
2591 ML_(linux_PRE_sys_msgctl) ( ThreadId tid,
2592 UWord arg0, UWord arg1, UWord arg2 )
2593 {
2594 /* int msgctl(int msqid, int cmd, struct msqid_ds *buf); */
2595 switch (arg1 /* cmd */) {
2596 case VKI_IPC_INFO:
2597 case VKI_MSG_INFO:
2598 case VKI_IPC_INFO|VKI_IPC_64:
2599 case VKI_MSG_INFO|VKI_IPC_64:
2600 PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)",
2601 arg2, sizeof(struct vki_msginfo) );
2602 break;
2603 case VKI_IPC_STAT:
2604 case VKI_MSG_STAT:
2605 PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)",
2606 arg2, sizeof(struct vki_msqid_ds) );
2607 break;
2608 case VKI_IPC_STAT|VKI_IPC_64:
2609 case VKI_MSG_STAT|VKI_IPC_64:
2610 PRE_MEM_WRITE( "msgctl(IPC_STAT, arg.buf)",
2611 arg2, sizeof(struct vki_msqid64_ds) );
2612 break;
2613 case VKI_IPC_SET:
2614 PRE_MEM_READ( "msgctl(IPC_SET, arg.buf)",
2615 arg2, sizeof(struct vki_msqid_ds) );
2616 break;
2617 case VKI_IPC_SET|VKI_IPC_64:
2618 PRE_MEM_READ( "msgctl(IPC_SET, arg.buf)",
2619 arg2, sizeof(struct vki_msqid64_ds) );
2620 break;
2621 }
2622 }
2623 void
2624 ML_(linux_POST_sys_msgctl) ( ThreadId tid,
2625 UWord res,
2626 UWord arg0, UWord arg1, UWord arg2 )
2627 {
2628 switch (arg1 /* cmd */) {
2629 case VKI_IPC_INFO:
2630 case VKI_MSG_INFO:
2631 case VKI_IPC_INFO|VKI_IPC_64:
2632 case VKI_MSG_INFO|VKI_IPC_64:
2633 POST_MEM_WRITE( arg2, sizeof(struct vki_msginfo) );
2634 break;
2635 case VKI_IPC_STAT:
2636 case VKI_MSG_STAT:
2637 POST_MEM_WRITE( arg2, sizeof(struct vki_msqid_ds) );
2638 break;
2639 case VKI_IPC_STAT|VKI_IPC_64:
2640 case VKI_MSG_STAT|VKI_IPC_64:
2641 POST_MEM_WRITE( arg2, sizeof(struct vki_msqid64_ds) );
2642 break;
2643 }
2644 }
2645
2646 #endif
2647
PRE(sys_chflags)2648 PRE(sys_chflags)
2649 {
2650 PRINT("sys_chflags ( %#lx(%s), 0x%lx )", ARG1,(char *)ARG1,ARG2);
2651 PRE_REG_READ2(long, "chown",
2652 const char *, path, vki_int32_t, flags);
2653 PRE_MEM_RASCIIZ( "chflags(path)", ARG1 );
2654 }
2655
PRE(sys_fchflags)2656 PRE(sys_fchflags)
2657 {
2658 PRINT("sys_fchflags ( %ld, %ld )", ARG1,ARG2);
2659 PRE_REG_READ2(long, "fchflags", unsigned int, fildes, vki_int32_t, flags);
2660 }
2661
2662
PRE(sys_modfind)2663 PRE(sys_modfind)
2664 {
2665 PRINT("sys_modfind ( %#lx )",ARG1);
2666 PRE_REG_READ1(long, "modfind", char *, modname);
2667 PRE_MEM_RASCIIZ( "modfind(modname)", ARG1 );
2668 }
2669
PRE(sys_modstat)2670 PRE(sys_modstat)
2671 {
2672 PRINT("sys_modstat ( %ld, %#lx )",ARG1,ARG2);
2673 PRE_REG_READ2(long, "modstat", int, modid, struct module_stat *, buf);
2674 PRE_MEM_WRITE( "modstat(buf)", ARG2, sizeof(struct vki_module_stat) );
2675 }
2676
POST(sys_modstat)2677 POST(sys_modstat)
2678 {
2679 POST_MEM_WRITE( ARG2, sizeof(struct vki_module_stat) );
2680 }
2681
PRE(sys_lkmnosys0)2682 PRE(sys_lkmnosys0)
2683 {
2684 PRINT("sys_lkmnosys0 ()");
2685 PRE_REG_READ0(long, "lkmnosys0");
2686 }
2687
PRE(sys_lkmnosys1)2688 PRE(sys_lkmnosys1)
2689 {
2690 PRINT("sys_lkmnosys1 ()");
2691 PRE_REG_READ0(long, "lkmnosys1");
2692 }
2693
PRE(sys_lkmnosys2)2694 PRE(sys_lkmnosys2)
2695 {
2696 PRINT("sys_lkmnosys2 ()");
2697 PRE_REG_READ0(long, "lkmnosys2");
2698 }
2699
PRE(sys_lkmnosys3)2700 PRE(sys_lkmnosys3)
2701 {
2702 PRINT("sys_lkmnosys3 ()");
2703 PRE_REG_READ0(long, "lkmnosys3");
2704 }
2705
PRE(sys_lkmnosys4)2706 PRE(sys_lkmnosys4)
2707 {
2708 PRINT("sys_lkmnosys4 ()");
2709 PRE_REG_READ0(long, "lkmnosys4");
2710 }
2711
PRE(sys_lkmnosys5)2712 PRE(sys_lkmnosys5)
2713 {
2714 PRINT("sys_lkmnosys5 ()");
2715 PRE_REG_READ0(long, "lkmnosys5");
2716 }
2717
PRE(sys_lkmnosys6)2718 PRE(sys_lkmnosys6)
2719 {
2720 PRINT("sys_lkmnosys6 ()");
2721 PRE_REG_READ0(long, "lkmnosys6");
2722 }
2723
PRE(sys_lkmnosys7)2724 PRE(sys_lkmnosys7)
2725 {
2726 PRINT("sys_lkmnosys7 ()");
2727 PRE_REG_READ0(long, "lkmnosys7");
2728 }
2729
PRE(sys_lkmnosys8)2730 PRE(sys_lkmnosys8)
2731 {
2732 PRINT("sys_lkmnosys8 ()");
2733 PRE_REG_READ0(long, "lkmnosys8");
2734 }
2735
PRE(sys_kenv)2736 PRE(sys_kenv)
2737 {
2738 PRINT("sys_kenv ( %ld, %#lx, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4);
2739 PRE_REG_READ4(long, "kenv",
2740 int, action, const char *, name, char *, value, int, len);
2741 switch (ARG1) {
2742 case VKI_KENV_GET:
2743 case VKI_KENV_SET:
2744 case VKI_KENV_UNSET:
2745 PRE_MEM_RASCIIZ("kenv(name)", ARG2);
2746 /* FALLTHROUGH */
2747 case VKI_KENV_DUMP:
2748 break;
2749 default:
2750 I_die_here;
2751 }
2752 }
2753
POST(sys_kenv)2754 POST(sys_kenv)
2755 {
2756 if (SUCCESS) {
2757 switch (ARG1) {
2758 case VKI_KENV_GET:
2759 POST_MEM_WRITE(ARG3, ARG4);
2760 break;
2761 case VKI_KENV_DUMP:
2762 if (ARG3 != (Addr)NULL)
2763 POST_MEM_WRITE(ARG3, ARG4);
2764 break;
2765 }
2766 }
2767 }
2768
PRE(sys_uuidgen)2769 PRE(sys_uuidgen)
2770 {
2771 PRINT("sys_uuidgen ( %#lx, %ld )", ARG1,ARG2);
2772 PRE_REG_READ2(long, "uuidgen",
2773 struct vki_uuid *, store, int, count);
2774 PRE_MEM_WRITE( "uuidgen(store)", ARG1, ARG2 * sizeof(struct vki_uuid));
2775 }
2776
POST(sys_uuidgen)2777 POST(sys_uuidgen)
2778 {
2779 if (SUCCESS)
2780 POST_MEM_WRITE( ARG1, ARG2 * sizeof(struct vki_uuid) );
2781 }
2782
2783
PRE(sys_shmget)2784 PRE(sys_shmget)
2785 {
2786 PRINT("sys_shmget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
2787 PRE_REG_READ3(long, "shmget", vki_key_t, key, vki_size_t, size, int, shmflg);
2788 }
2789
PRE(sys_shmat)2790 PRE(sys_shmat)
2791 {
2792 UWord arg2tmp;
2793 PRINT("sys_shmat ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
2794 PRE_REG_READ3(long, "shmat",
2795 int, shmid, const void *, shmaddr, int, shmflg);
2796 arg2tmp = ML_(generic_PRE_sys_shmat)(tid, ARG1,ARG2,ARG3);
2797 if (arg2tmp == 0)
2798 SET_STATUS_Failure( VKI_EINVAL );
2799 else
2800 ARG2 = arg2tmp;
2801 }
2802
POST(sys_shmat)2803 POST(sys_shmat)
2804 {
2805 ML_(generic_POST_sys_shmat)(tid, RES,ARG1,ARG2,ARG3);
2806 }
2807
PRE(sys_shmdt)2808 PRE(sys_shmdt)
2809 {
2810 PRINT("sys_shmdt ( %#lx )",ARG1);
2811 PRE_REG_READ1(long, "shmdt", const void *, shmaddr);
2812 if (!ML_(generic_PRE_sys_shmdt)(tid, ARG1))
2813 SET_STATUS_Failure( VKI_EINVAL );
2814 }
2815
POST(sys_shmdt)2816 POST(sys_shmdt)
2817 {
2818 ML_(generic_POST_sys_shmdt)(tid, RES,ARG1);
2819 }
2820
PRE(sys_shmctl)2821 PRE(sys_shmctl)
2822 {
2823 PRINT("sys_shmctl ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
2824 PRE_REG_READ3(long, "shmctl",
2825 int, shmid, int, cmd, struct vki_shmid_ds *, buf);
2826 switch (ARG2 /* cmd */) {
2827 case VKI_IPC_STAT:
2828 PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)",
2829 ARG3, sizeof(struct vki_shmid_ds) );
2830 break;
2831 case VKI_IPC_SET:
2832 PRE_MEM_READ( "shmctl(IPC_SET, buf)",
2833 ARG3, sizeof(struct vki_shmid_ds) );
2834 break;
2835 }
2836 }
2837
PRE(sys_shmctl7)2838 PRE(sys_shmctl7)
2839 {
2840 PRINT("sys_shmctl7 ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
2841 PRE_REG_READ3(long, "shmctl",
2842 int, shmid, int, cmd, struct vki_shmid_ds7 *, buf);
2843 switch (ARG2 /* cmd */) {
2844 case VKI_IPC_STAT:
2845 PRE_MEM_WRITE( "shmctl7(IPC_STAT, buf)",
2846 ARG3, sizeof(struct vki_shmid_ds7) );
2847 break;
2848 case VKI_IPC_SET:
2849 PRE_MEM_READ( "shmctl7(IPC_SET, buf)",
2850 ARG3, sizeof(struct vki_shmid_ds7) );
2851 break;
2852 }
2853 }
2854
POST(sys_shmctl)2855 POST(sys_shmctl)
2856 {
2857 if (ARG2 == VKI_IPC_STAT) {
2858 POST_MEM_WRITE( ARG3, sizeof(struct vki_shmid_ds) );
2859 }
2860 }
2861
POST(sys_shmctl7)2862 POST(sys_shmctl7)
2863 {
2864 if (ARG2 == VKI_IPC_STAT) {
2865 POST_MEM_WRITE( ARG3, sizeof(struct vki_shmid_ds7) );
2866 }
2867 }
2868
PRE(sys_semget)2869 PRE(sys_semget)
2870 {
2871 PRINT("sys_semget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
2872 PRE_REG_READ3(long, "semget", vki_key_t, key, int, nsems, int, semflg);
2873 }
2874
PRE(sys_shm_open)2875 PRE(sys_shm_open)
2876 {
2877 PRE_REG_READ3(long, "shm_open",
2878 const char *, "name", int, "flags", vki_mode_t, "mode");
2879 if (ARG1 == VKI_SHM_ANON) {
2880 PRINT("sys_shm_open(%#lx(SHM_ANON), %ld, %ld)", ARG1, ARG2, ARG3);
2881 } else {
2882 PRINT("sys_shm_open(%#lx(%s), %ld, %ld)", ARG1, (char *)ARG1, ARG2, ARG3);
2883 PRE_MEM_RASCIIZ( "shm_open(filename)", ARG1 );
2884 }
2885 *flags |= SfMayBlock;
2886 }
2887
POST(sys_shm_open)2888 POST(sys_shm_open)
2889 {
2890 vg_assert(SUCCESS);
2891 if (!ML_(fd_allowed)(RES, "shm_open", tid, True)) {
2892 VG_(close)(RES);
2893 SET_STATUS_Failure( VKI_EMFILE );
2894 } else {
2895 if (VG_(clo_track_fds))
2896 ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
2897 }
2898 }
2899
PRE(sys_shm_unlink)2900 PRE(sys_shm_unlink)
2901 {
2902 PRINT("sys_shm_unlink(%#lx(%s))", ARG1, (char *)ARG1);
2903 PRE_REG_READ1(long, "shm_unlink",
2904 const char *, "name");
2905
2906 PRE_MEM_RASCIIZ( "shm_unlink(filename)", ARG1 );
2907
2908 *flags |= SfMayBlock;
2909 }
2910
PRE(sys_semop)2911 PRE(sys_semop)
2912 {
2913 *flags |= SfMayBlock;
2914 PRINT("sys_semop ( %ld, %#lx, %lu )",ARG1,ARG2,ARG3);
2915 PRE_REG_READ3(long, "semop",
2916 int, semid, struct sembuf *, sops, unsigned, nsoops);
2917 ML_(generic_PRE_sys_semop)(tid, ARG1,ARG2,ARG3);
2918 }
2919
2920 struct ipc_perm7 {
2921 unsigned short cuid; /* creator user id */
2922 unsigned short cgid; /* creator group id */
2923 unsigned short uid; /* user id */
2924 unsigned short gid; /* group id */
2925 unsigned short mode; /* r/w permission */
2926 unsigned short seq; /* sequence # (to generate unique ipcid) */
2927 vki_key_t key; /* user specified msg/sem/shm key */
2928 };
2929
2930 struct semid_ds7 {
2931 struct ipc_perm7 sem_perm; /* operation permission struct */
2932 struct sem *sem_base; /* pointer to first semaphore in set */
2933 unsigned short sem_nsems; /* number of sems in set */
2934 vki_time_t sem_otime; /* last operation time */
2935 long sem_pad1; /* SVABI/386 says I need this here */
2936 vki_time_t sem_ctime; /* last change time */
2937 /* Times measured in secs since */
2938 /* 00:00:00 GMT, Jan. 1, 1970 */
2939 long sem_pad2; /* SVABI/386 says I need this here */
2940 long sem_pad3[4]; /* SVABI/386 says I need this here */
2941 };
2942
PRE(sys___semctl7)2943 PRE(sys___semctl7)
2944 {
2945 switch (ARG3) {
2946 case VKI_IPC_INFO:
2947 case VKI_SEM_INFO:
2948 PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
2949 PRE_REG_READ4(long, "semctl",
2950 int, semid, int, semnum, int, cmd, struct seminfo *, arg);
2951 break;
2952 case VKI_IPC_STAT:
2953 case VKI_SEM_STAT:
2954 case VKI_IPC_SET:
2955 PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
2956 PRE_REG_READ4(long, "semctl",
2957 int, semid, int, semnum, int, cmd, struct semid_ds7 *, arg);
2958 break;
2959 case VKI_GETALL:
2960 case VKI_SETALL:
2961 PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
2962 PRE_REG_READ4(long, "semctl",
2963 int, semid, int, semnum, int, cmd, unsigned short *, arg);
2964 break;
2965 default:
2966 PRINT("sys_semctl ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
2967 PRE_REG_READ3(long, "semctl",
2968 int, semid, int, semnum, int, cmd);
2969 break;
2970 }
2971 ML_(generic_PRE_sys_semctl)(tid, ARG1,ARG2,ARG3,ARG4);
2972 }
2973
POST(sys___semctl7)2974 POST(sys___semctl7)
2975 {
2976 ML_(generic_POST_sys_semctl)(tid, RES,ARG1,ARG2,ARG3,ARG4);
2977 }
2978
PRE(sys___semctl)2979 PRE(sys___semctl)
2980 {
2981 switch (ARG3) {
2982 case VKI_IPC_INFO:
2983 case VKI_SEM_INFO:
2984 PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
2985 PRE_REG_READ4(long, "semctl",
2986 int, semid, int, semnum, int, cmd, struct seminfo *, arg);
2987 break;
2988 case VKI_IPC_STAT:
2989 case VKI_SEM_STAT:
2990 case VKI_IPC_SET:
2991 PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
2992 PRE_REG_READ4(long, "semctl",
2993 int, semid, int, semnum, int, cmd, struct semid_ds *, arg);
2994 break;
2995 case VKI_GETALL:
2996 case VKI_SETALL:
2997 PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
2998 PRE_REG_READ4(long, "semctl",
2999 int, semid, int, semnum, int, cmd, unsigned short *, arg);
3000 break;
3001 default:
3002 PRINT("sys_semctl ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
3003 PRE_REG_READ3(long, "semctl",
3004 int, semid, int, semnum, int, cmd);
3005 break;
3006 }
3007 ML_(generic_PRE_sys_semctl)(tid, ARG1,ARG2,ARG3,ARG4);
3008 }
3009
POST(sys___semctl)3010 POST(sys___semctl)
3011 {
3012 ML_(generic_POST_sys_semctl)(tid, RES,ARG1,ARG2,ARG3,ARG4);
3013 }
3014
PRE(sys_eaccess)3015 PRE(sys_eaccess)
3016 {
3017 PRINT("sys_eaccess ( %#lx(%s), %ld )", ARG1,(char*)ARG1,ARG2);
3018 PRE_REG_READ2(long, "eaccess", const char *, pathname, int, mode);
3019 PRE_MEM_RASCIIZ( "eaccess(pathname)", ARG1 );
3020 }
3021
3022
3023 /* ---------------------------------------------------------------------
3024 *at wrappers
3025 ------------------------------------------------------------------ */
3026
PRE(sys_openat)3027 PRE(sys_openat)
3028 {
3029
3030 if (ARG3 & VKI_O_CREAT) {
3031 // 4-arg version
3032 PRINT("sys_openat ( %ld, %#lx(%s), %ld, %ld )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
3033 PRE_REG_READ4(int, "openat",
3034 int, dfd, const char *, filename, int, flags, vki_mode_t, mode);
3035 } else {
3036 // 3-arg version
3037 PRINT("sys_openat ( %ld, %#lx(%s), %ld )",ARG1,ARG2,(char*)ARG2,ARG3);
3038 PRE_REG_READ3(int, "openat",
3039 int, dfd, const char *, filename, int, flags);
3040 }
3041
3042 if (ARG1 != (unsigned)VKI_AT_FDCWD && !ML_(fd_allowed)(ARG1, "openat", tid, False))
3043 SET_STATUS_Failure( VKI_EBADF );
3044 else
3045 PRE_MEM_RASCIIZ( "openat(filename)", ARG2 );
3046
3047 /* Otherwise handle normally */
3048 *flags |= SfMayBlock;
3049 }
3050
POST(sys_openat)3051 POST(sys_openat)
3052 {
3053 vg_assert(SUCCESS);
3054 if (!ML_(fd_allowed)(RES, "openat", tid, True)) {
3055 VG_(close)(RES);
3056 SET_STATUS_Failure( VKI_EMFILE );
3057 } else {
3058 if (VG_(clo_track_fds))
3059 ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG2);
3060 }
3061 }
3062
PRE(sys_mkdirat)3063 PRE(sys_mkdirat)
3064 {
3065 *flags |= SfMayBlock;
3066 PRINT("sys_mkdirat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
3067 PRE_REG_READ3(long, "mkdirat",
3068 int, dfd, const char *, pathname, int, mode);
3069 PRE_MEM_RASCIIZ( "mkdirat(pathname)", ARG2 );
3070 }
3071
PRE(sys_mkfifoat)3072 PRE(sys_mkfifoat)
3073 {
3074 PRINT("sys_mkfifoat ( %ld, %#lx(%s), 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3 );
3075 PRE_REG_READ3(long, "mkfifoat",
3076 int, dfd, const char *, pathname, int, mode);
3077 PRE_MEM_RASCIIZ( "mkfifoat(pathname)", ARG2 );
3078 }
3079
PRE(sys_mknodat)3080 PRE(sys_mknodat)
3081 {
3082 PRINT("sys_mknodat ( %ld, %#lx(%s), 0x%lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4 );
3083 PRE_REG_READ4(long, "mknodat",
3084 int, dfd, const char *, pathname, int, mode, unsigned, dev);
3085 PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
3086 }
3087
PRE(sys_fchownat)3088 PRE(sys_fchownat)
3089 {
3090 PRINT("sys_fchownat ( %ld, %#lx(%s), 0x%lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
3091 PRE_REG_READ4(long, "fchownat",
3092 int, dfd, const char *, path,
3093 vki_uid_t, owner, vki_gid_t, group);
3094 PRE_MEM_RASCIIZ( "fchownat(path)", ARG2 );
3095 }
3096
PRE(sys_futimesat)3097 PRE(sys_futimesat)
3098 {
3099 PRINT("sys_futimesat ( %ld, %#lx(%s), %#lx )", ARG1,ARG2,(char*)ARG2,ARG3);
3100 PRE_REG_READ3(long, "futimesat",
3101 int, dfd, char *, filename, struct timeval *, tvp);
3102 if (ARG2 != 0)
3103 PRE_MEM_RASCIIZ( "futimesat(filename)", ARG2 );
3104 if (ARG3 != 0)
3105 PRE_MEM_READ( "futimesat(tvp)", ARG3, 2 * sizeof(struct vki_timeval) );
3106 }
3107
PRE(sys_fstatat)3108 PRE(sys_fstatat)
3109 {
3110 PRINT("sys_fstatat ( %ld, %#lx(%s), %#lx )", ARG1,ARG2,(char*)ARG2,ARG3);
3111 PRE_REG_READ3(long, "fstatat",
3112 int, dfd, char *, file_name, struct stat *, buf);
3113 PRE_MEM_RASCIIZ( "fstatat(file_name)", ARG2 );
3114 PRE_MEM_WRITE( "fstatat(buf)", ARG3, sizeof(struct vki_stat) );
3115 }
3116
POST(sys_fstatat)3117 POST(sys_fstatat)
3118 {
3119 POST_MEM_WRITE( ARG3, sizeof(struct vki_stat) );
3120 }
3121
PRE(sys_unlinkat)3122 PRE(sys_unlinkat)
3123 {
3124 *flags |= SfMayBlock;
3125 PRINT("sys_unlinkat ( %ld, %#lx(%s) )", ARG1,ARG2,(char*)ARG2);
3126 PRE_REG_READ2(long, "unlinkat", int, dfd, const char *, pathname);
3127 PRE_MEM_RASCIIZ( "unlinkat(pathname)", ARG2 );
3128 }
3129
PRE(sys_renameat)3130 PRE(sys_renameat)
3131 {
3132 PRINT("sys_renameat ( %ld, %#lx(%s), %ld, %#lx(%s) )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4);
3133 PRE_REG_READ4(long, "renameat",
3134 int, olddfd, const char *, oldpath,
3135 int, newdfd, const char *, newpath);
3136 PRE_MEM_RASCIIZ( "renameat(oldpath)", ARG2 );
3137 PRE_MEM_RASCIIZ( "renameat(newpath)", ARG4 );
3138 }
3139
PRE(sys_linkat)3140 PRE(sys_linkat)
3141 {
3142 *flags |= SfMayBlock;
3143 PRINT("sys_linkat ( %ld, %#lx(%s), %ld, %#lx(%s), %ld )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4,ARG5);
3144 PRE_REG_READ5(long, "linkat",
3145 int, olddfd, const char *, oldpath,
3146 int, newdfd, const char *, newpath,
3147 int, flags);
3148 PRE_MEM_RASCIIZ( "linkat(oldpath)", ARG2);
3149 PRE_MEM_RASCIIZ( "linkat(newpath)", ARG4);
3150 }
3151
PRE(sys_symlinkat)3152 PRE(sys_symlinkat)
3153 {
3154 *flags |= SfMayBlock;
3155 PRINT("sys_symlinkat ( %#lx(%s), %ld, %#lx(%s) )",ARG1,(char*)ARG1,ARG2,ARG3,(char*)ARG3);
3156 PRE_REG_READ3(long, "symlinkat",
3157 const char *, oldpath, int, newdfd, const char *, newpath);
3158 PRE_MEM_RASCIIZ( "symlinkat(oldpath)", ARG1 );
3159 PRE_MEM_RASCIIZ( "symlinkat(newpath)", ARG3 );
3160 }
3161
PRE(sys_readlinkat)3162 PRE(sys_readlinkat)
3163 {
3164 HChar name[25];
3165 Word saved = SYSNO;
3166
3167 PRINT("sys_readlinkat ( %ld, %#lx(%s), %#lx, %llu )", ARG1,ARG2,(char*)ARG2,ARG3,(ULong)ARG4);
3168 PRE_REG_READ4(long, "readlinkat",
3169 int, dfd, const char *, path, char *, buf, int, bufsiz);
3170 PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
3171 PRE_MEM_WRITE( "readlinkat(buf)", ARG3,ARG4 );
3172
3173 /*
3174 * Handle the case where readlinkat is looking at /proc/curproc/file or
3175 * /proc/<pid>/file.
3176 */
3177 VG_(sprintf)(name, "/proc/%d/file", VG_(getpid)());
3178 if (ML_(safe_to_deref)((void*)ARG2, 1)
3179 && (VG_(strcmp)((HChar *)ARG2, name) == 0
3180 || VG_(strcmp)((HChar *)ARG2, "/proc/curproc/file") == 0)) {
3181 VG_(sprintf)(name, "/proc/self/fd/%d", VG_(cl_exec_fd));
3182 SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, (UWord)name,
3183 ARG3, ARG4));
3184 } else {
3185 /* Normal case */
3186 SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, ARG2, ARG3, ARG4));
3187 }
3188
3189 if (SUCCESS && RES > 0)
3190 POST_MEM_WRITE( ARG3, RES );
3191 }
3192
PRE(sys_fchmodat)3193 PRE(sys_fchmodat)
3194 {
3195 PRINT("sys_fchmodat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
3196 PRE_REG_READ3(long, "fchmodat",
3197 int, dfd, const char *, path, vki_mode_t, mode);
3198 PRE_MEM_RASCIIZ( "fchmodat(path)", ARG2 );
3199 }
3200
PRE(sys_faccessat)3201 PRE(sys_faccessat)
3202 {
3203 PRINT("sys_faccessat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
3204 PRE_REG_READ3(long, "faccessat",
3205 int, dfd, const char *, pathname, int, mode);
3206 PRE_MEM_RASCIIZ( "faccessat(pathname)", ARG2 );
3207 }
3208
3209 /* ---------------------------------------------------------------------
3210 __acl* wrappers
3211 ------------------------------------------------------------------ */
3212
PRE(sys___acl_get_file)3213 PRE(sys___acl_get_file)
3214 {
3215 PRINT("sys___acl_get_file ( %#lx(%s), %ld, %#lx )", ARG1,(char *)ARG1,ARG2,ARG3);
3216 PRE_REG_READ3(long, "__acl_get_file",
3217 const char *, path, int, acltype, struct vki_acl *, aclp);
3218 PRE_MEM_WRITE( "__acl_get_file(aclp)", ARG3, sizeof(struct vki_acl) );
3219 }
3220
POST(sys___acl_get_file)3221 POST(sys___acl_get_file)
3222 {
3223 vg_assert(SUCCESS);
3224 if (RES == 0) {
3225 POST_MEM_WRITE( ARG3, sizeof(struct vki_acl) );
3226 }
3227 }
3228
PRE(sys___acl_set_file)3229 PRE(sys___acl_set_file)
3230 {
3231 PRINT("sys___acl_set_file ( %#lx(%s), %ld, %#lx )", ARG1,(char *)ARG1,ARG2,ARG3);
3232 PRE_REG_READ3(long, "__acl_set_file",
3233 const char *, path, int, acltype, struct vki_acl *, aclp);
3234 PRE_MEM_READ( "__acl_set_file(aclp)", ARG3, sizeof(struct vki_acl) );
3235 }
3236
PRE(sys___acl_get_fd)3237 PRE(sys___acl_get_fd)
3238 {
3239 PRINT("sys___acl_get_fd ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3240 PRE_REG_READ3(long, "__acl_get_fd",
3241 int, fd, int, acltype, struct vki_acl *, aclp);
3242 PRE_MEM_WRITE( "__acl_get_file(aclp)", ARG3, sizeof(struct vki_acl) );
3243 }
3244
POST(sys___acl_get_fd)3245 POST(sys___acl_get_fd)
3246 {
3247 vg_assert(SUCCESS);
3248 if (RES == 0) {
3249 POST_MEM_WRITE( ARG3, sizeof(struct vki_acl) );
3250 }
3251 }
3252
PRE(sys___acl_set_fd)3253 PRE(sys___acl_set_fd)
3254 {
3255 PRINT("sys___acl_set_fd ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3256 PRE_REG_READ3(long, "__acl_set_fd",
3257 int, fd, int, acltype, struct vki_acl *, aclp);
3258 PRE_MEM_READ( "__acl_get_file(aclp)", ARG3, sizeof(struct vki_acl) );
3259 }
3260
PRE(sys___acl_delete_file)3261 PRE(sys___acl_delete_file)
3262 {
3263 PRINT("sys___acl_delete_file ( %#lx(%s), %ld )", ARG1,(char *)ARG1,ARG2);
3264 PRE_REG_READ2(long, "__acl_delete_file",
3265 const char *, path, int, acltype);
3266 }
3267
PRE(sys___acl_delete_fd)3268 PRE(sys___acl_delete_fd)
3269 {
3270 PRINT("sys___acl_delete_fd ( %ld, %ld )", ARG1,ARG2);
3271 PRE_REG_READ2(long, "__acl_delete_fd",
3272 int, fd, int, acltype);
3273 }
3274
PRE(sys___acl_aclcheck_file)3275 PRE(sys___acl_aclcheck_file)
3276 {
3277 PRINT("sys___acl_aclcheck_file ( %#lx(%s), %ld, %#lx )", ARG1,(char *)ARG1,ARG2,ARG3);
3278 PRE_REG_READ3(long, "__acl_aclcheck_file",
3279 const char *, path, int, acltype, struct vki_acl *, aclp);
3280 PRE_MEM_READ( "__acl_aclcheck_file(aclp)", ARG3, sizeof(struct vki_acl) );
3281 }
3282
PRE(sys___acl_aclcheck_fd)3283 PRE(sys___acl_aclcheck_fd)
3284 {
3285 PRINT("sys___acl_aclcheck_fd ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3286 PRE_REG_READ3(long, "__acl_aclcheck_fd",
3287 int, fd, int, acltype, struct vki_acl *, aclp);
3288 PRE_MEM_READ( "__acl_aclcheck_fd(aclp)", ARG3, sizeof(struct vki_acl) );
3289 }
3290
PRE(sys___acl_get_link)3291 PRE(sys___acl_get_link)
3292 {
3293 PRINT("sys___acl_get_link ( %#lx(%s), %ld, %#lx )", ARG1,(char *)ARG1,ARG2,ARG3);
3294 PRE_REG_READ3(long, "__acl_get_link",
3295 const char *, path, int, acltype, struct vki_acl *, aclp);
3296 PRE_MEM_WRITE( "__acl_get_link(aclp)", ARG3, sizeof(struct vki_acl) );
3297 }
3298
POST(sys___acl_get_link)3299 POST(sys___acl_get_link)
3300 {
3301 vg_assert(SUCCESS);
3302 if (RES == 0) {
3303 POST_MEM_WRITE( ARG3, sizeof(struct vki_acl) );
3304 }
3305 }
3306
PRE(sys___acl_set_link)3307 PRE(sys___acl_set_link)
3308 {
3309 PRINT("sys___acl_set_link ( %#lx(%s), %ld, %#lx )", ARG1,(char *)ARG1,ARG2,ARG3);
3310 PRE_REG_READ3(long, "__acl_set_link",
3311 const char *, path, int, acltype, struct vki_acl *, aclp);
3312 PRE_MEM_READ( "__acl_set_link(aclp)", ARG3, sizeof(struct vki_acl) );
3313 }
3314
PRE(sys___acl_delete_link)3315 PRE(sys___acl_delete_link)
3316 {
3317 PRINT("sys___acl_delete_link ( %#lx(%s), %ld )", ARG1,(char *)ARG1,ARG2);
3318 PRE_REG_READ2(long, "__acl_delete_link",
3319 const char *, path, int, acltype);
3320 }
3321
PRE(sys___acl_aclcheck_link)3322 PRE(sys___acl_aclcheck_link)
3323 {
3324 PRINT("sys___acl_aclcheck_link ( %#lx(%s), %ld, %#lx )", ARG1,(char *)ARG1,ARG2,ARG3);
3325 PRE_REG_READ3(long, "__acl_aclcheck_link",
3326 const char *, path, int, acltype, struct vki_acl *, aclp);
3327 PRE_MEM_READ( "__acl_aclcheck_link(aclp)", ARG3, sizeof(struct vki_acl) );
3328 }
3329
POST(sys_getcontext)3330 POST(sys_getcontext)
3331 {
3332 POST_MEM_WRITE( ARG1, sizeof(struct vki_ucontext) );
3333 }
3334
POST(sys_swapcontext)3335 POST(sys_swapcontext)
3336 {
3337 if (SUCCESS)
3338 POST_MEM_WRITE( ARG1, sizeof(struct vki_ucontext) );
3339 }
3340
PRE(sys_fcntl)3341 PRE(sys_fcntl)
3342 {
3343 switch (ARG2) {
3344 // These ones ignore ARG3.
3345 case VKI_F_GETFD:
3346 case VKI_F_GETFL:
3347 case VKI_F_GETOWN:
3348 PRINT("sys_fcntl ( %ld, %ld )", ARG1,ARG2);
3349 PRE_REG_READ2(long, "fcntl", unsigned int, fd, unsigned int, cmd);
3350 break;
3351
3352 // These ones use ARG3 as "arg".
3353 case VKI_F_DUPFD:
3354 case VKI_F_DUPFD_CLOEXEC:
3355 case VKI_F_SETFD:
3356 case VKI_F_SETFL:
3357 case VKI_F_SETOWN:
3358 PRINT("sys_fcntl[ARG3=='arg'] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
3359 PRE_REG_READ3(long, "fcntl",
3360 unsigned int, fd, unsigned int, cmd, unsigned long, arg);
3361 break;
3362
3363 // These ones use ARG3 as "lock" - obsolete.
3364 case VKI_F_OSETLKW:
3365 *flags |= SfMayBlock;
3366 /* FALLTHROUGH */
3367 case VKI_F_OGETLK:
3368 case VKI_F_OSETLK:
3369 PRINT("sys_fcntl[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3370 PRE_REG_READ3(long, "fcntl",
3371 unsigned int, fd, unsigned int, cmd,
3372 struct oflock *, lock);
3373 break;
3374
3375 // This one uses ARG3 as "oldd" and ARG4 as "newd".
3376 case VKI_F_DUP2FD:
3377 PRINT("sys_fcntl[ARG3=='oldd', ARG4=='newd'] ( %ld, %ld, %ld, %ld )",
3378 ARG1,ARG2,ARG3,ARG4);
3379 PRE_REG_READ4(long, "fcntl",
3380 unsigned int, fd, unsigned int, cmd,
3381 unsigned long, oldd, unsigned long, newd);
3382 break;
3383
3384 // These ones use ARG3 as "lock".
3385 case VKI_F_SETLKW:
3386 *flags |= SfMayBlock;
3387 /* FALLTHROUGH */
3388 case VKI_F_GETLK:
3389 case VKI_F_SETLK:
3390 case VKI_F_SETLK_REMOTE:
3391 PRINT("sys_fcntl[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3392 PRE_REG_READ3(long, "fcntl",
3393 unsigned int, fd, unsigned int, cmd,
3394 struct flock *, lock);
3395 break;
3396
3397 default:
3398 PRINT("sys_fcntl[UNKNOWN] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
3399 I_die_here;
3400 break;
3401 }
3402 }
3403
POST(sys_fcntl)3404 POST(sys_fcntl)
3405 {
3406 vg_assert(SUCCESS);
3407 if (ARG2 == VKI_F_DUPFD) {
3408 if (!ML_(fd_allowed)(RES, "fcntl(DUPFD)", tid, True)) {
3409 VG_(close)(RES);
3410 SET_STATUS_Failure( VKI_EMFILE );
3411 } else {
3412 if (VG_(clo_track_fds))
3413 ML_(record_fd_open_named)(tid, RES);
3414 }
3415 }
3416 }
3417
PRE(sys_ioctl)3418 PRE(sys_ioctl)
3419 {
3420 UInt dir = _VKI_IOC_DIR(ARG2);
3421 UInt size = _VKI_IOC_SIZE(ARG2);
3422 *flags |= SfMayBlock;
3423 PRINT("sys_ioctl ( %ld, 0x%lx, %#lx )",ARG1,ARG2,ARG3);
3424 PRE_REG_READ3(long, "ioctl",
3425 unsigned int, fd, unsigned int, request, unsigned long, arg);
3426
3427 /* On FreeBSD, ALL ioctl's are IOR/IOW encoded. Just use the default decoder */
3428 if (VG_(strstr)(VG_(clo_sim_hints), "lax-ioctls") != NULL) {
3429 /*
3430 * Be very lax about ioctl handling; the only
3431 * assumption is that the size is correct. Doesn't
3432 * require the full buffer to be initialized when
3433 * writing. Without this, using some device
3434 * drivers with a large number of strange ioctl
3435 * commands becomes very tiresome.
3436 */
3437 } else if (/* size == 0 || */ dir == _VKI_IOC_NONE) {
3438 static Int moans = 3;
3439 if (moans > 0 && !VG_(clo_xml)) {
3440 moans--;
3441 VG_(message)(Vg_UserMsg,
3442 "Warning: noted but unhandled ioctl 0x%lx"
3443 " with no size/direction hints\n",
3444 ARG2);
3445 VG_(message)(Vg_UserMsg,
3446 " This could cause spurious value errors"
3447 " to appear.\n");
3448 VG_(message)(Vg_UserMsg,
3449 " See README_MISSING_SYSCALL_OR_IOCTL for "
3450 "guidance on writing a proper wrapper.\n" );
3451 }
3452 } else {
3453 if ((dir & _VKI_IOC_WRITE) && size > 0)
3454 PRE_MEM_READ( "ioctl(generic)", ARG3, size);
3455 if ((dir & _VKI_IOC_READ) && size > 0)
3456 PRE_MEM_WRITE( "ioctl(generic)", ARG3, size);
3457 }
3458 }
3459
POST(sys_ioctl)3460 POST(sys_ioctl)
3461 {
3462 UInt dir = _VKI_IOC_DIR(ARG2);
3463 UInt size = _VKI_IOC_SIZE(ARG2);
3464 vg_assert(SUCCESS);
3465 if (size > 0 && (dir & _VKI_IOC_READ)
3466 && RES == 0 && ARG3 != (Addr)NULL)
3467 POST_MEM_WRITE(ARG3, size);
3468 }
3469
PRE(sys_ptrace)3470 PRE(sys_ptrace)
3471 {
3472 struct vki_ptrace_io_desc *io_desc;
3473 PRINT("sys_ptrace ( %ld, %ld, 0x%lx, %ld)", ARG1, ARG2, ARG3, ARG4);
3474
3475 PRE_REG_READ4(int, "ptrace", int, request, int, pid, char *, addr, int, data);
3476
3477 switch (ARG1) {
3478 case VKI_PTRACE_TRACEME:
3479 break;
3480 case VKI_PTRACE_READ_I:
3481 case VKI_PTRACE_READ_D:
3482 break;
3483
3484 case VKI_PTRACE_WRITE_I:
3485 case VKI_PTRACE_WRITE_D:
3486 break;
3487
3488 case VKI_PTRACE_IO:
3489 PRE_MEM_READ("ptrace", ARG3, sizeof(struct vki_ptrace_io_desc));
3490 io_desc = (struct vki_ptrace_io_desc *)ARG3;
3491 switch (io_desc->piod_op) {
3492 case VKI_PIOD_READ_D:
3493 case VKI_PIOD_READ_I:
3494 PRE_MEM_WRITE( "ptrace", (UWord)io_desc->piod_addr, io_desc->piod_len);
3495 break;
3496 case VKI_PIOD_WRITE_D:
3497 case VKI_PIOD_WRITE_I:
3498 PRE_MEM_READ( "ptrace", (UWord)io_desc->piod_addr, io_desc->piod_len);
3499 break;
3500 }
3501 break;
3502
3503 case VKI_PTRACE_CONTINUE:
3504 break;
3505
3506 case VKI_PTRACE_STEP:
3507 break;
3508
3509 case VKI_PTRACE_KILL:
3510 break;
3511
3512 case VKI_PTRACE_ATTACH:
3513 break;
3514
3515 case VKI_PTRACE_DETACH:
3516 break;
3517
3518 case VKI_PTRACE_GETREGS:
3519 PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_reg_struct));
3520 break;
3521
3522 case VKI_PTRACE_SETREGS:
3523 PRE_MEM_READ( "ptrace", ARG3, sizeof(struct vki_reg_struct));
3524 break;
3525
3526 case VKI_PTRACE_GETFPREGS:
3527 PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_fpreg));
3528 break;
3529
3530 case VKI_PTRACE_SETFPREGS:
3531 PRE_MEM_READ( "ptrace", ARG3, sizeof(struct vki_fpreg));
3532 break;
3533
3534 case VKI_PTRACE_GETDBREGS:
3535 PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_dbreg));
3536 break;
3537
3538 case VKI_PTRACE_SETDBREGS:
3539 PRE_MEM_READ( "ptrace", ARG3, sizeof(struct vki_dbreg));
3540 break;
3541
3542 case VKI_PTRACE_LWPINFO:
3543 PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_ptrace_lwpinfo));
3544 break;
3545
3546 case VKI_PTRACE_GETNUMLWPS:
3547 break;
3548
3549 case VKI_PTRACE_GETLWPLIST:
3550 PRE_MEM_WRITE( "ptrace", ARG3, sizeof(vki_lwpid_t) * ARG4);
3551 break;
3552
3553 case VKI_PTRACE_SETSTEP:
3554 break;
3555
3556 case VKI_PTRACE_CLEARSTEP:
3557 break;
3558
3559 case VKI_PTRACE_SUSPEND:
3560 break;
3561
3562 case VKI_PTRACE_RESUME:
3563 break;
3564
3565 case VKI_PTRACE_TO_SCE:
3566 break;
3567
3568 case VKI_PTRACE_TO_SCX:
3569 break;
3570
3571 case VKI_PTRACE_SYSCALL:
3572 break;
3573
3574 case VKI_PTRACE_VM_TIMESTAMP:
3575 break;
3576
3577 case VKI_PTRACE_VM_ENTRY:
3578 PRE_MEM_WRITE( "ptrace", ARG3, sizeof(struct vki_ptrace_vm_entry));
3579 break;
3580 }
3581 }
3582
POST(sys_ptrace)3583 POST(sys_ptrace)
3584 {
3585 struct vki_ptrace_io_desc *io_desc;
3586
3587 switch (ARG1) {
3588 case VKI_PTRACE_TRACEME:
3589 break;
3590 case VKI_PTRACE_READ_I:
3591 case VKI_PTRACE_READ_D:
3592 break;
3593
3594 case VKI_PTRACE_WRITE_I:
3595 case VKI_PTRACE_WRITE_D:
3596 break;
3597
3598 case VKI_PTRACE_IO:
3599 io_desc = (struct vki_ptrace_io_desc *)ARG3;
3600 switch (io_desc->piod_op) {
3601 case VKI_PIOD_READ_D:
3602 case VKI_PIOD_READ_I:
3603 if (RES != -1)
3604 POST_MEM_WRITE((UWord)io_desc->piod_addr, io_desc->piod_len);
3605 break;
3606 case VKI_PIOD_WRITE_D:
3607 case VKI_PIOD_WRITE_I:
3608 break;
3609 }
3610 break;
3611
3612 case VKI_PTRACE_CONTINUE:
3613 break;
3614
3615 case VKI_PTRACE_STEP:
3616 break;
3617
3618 case VKI_PTRACE_KILL:
3619 break;
3620
3621 case VKI_PTRACE_ATTACH:
3622 break;
3623
3624 case VKI_PTRACE_DETACH:
3625 break;
3626
3627 case VKI_PTRACE_GETREGS:
3628 if (RES != -1)
3629 POST_MEM_WRITE(ARG3, sizeof(struct vki_reg_struct));
3630 break;
3631
3632 case VKI_PTRACE_SETREGS:
3633 break;
3634
3635 case VKI_PTRACE_GETFPREGS:
3636 if (RES != -1)
3637 POST_MEM_WRITE(ARG3, sizeof(struct vki_fpreg));
3638 break;
3639
3640 case VKI_PTRACE_SETFPREGS:
3641 break;
3642
3643 case VKI_PTRACE_GETDBREGS:
3644 if (RES != -1)
3645 POST_MEM_WRITE(ARG3, sizeof(struct vki_dbreg));
3646 break;
3647
3648 case VKI_PTRACE_SETDBREGS:
3649 break;
3650
3651 case VKI_PTRACE_LWPINFO:
3652 if (RES != -1)
3653 POST_MEM_WRITE(ARG3, sizeof(struct vki_ptrace_lwpinfo));
3654 break;
3655
3656 case VKI_PTRACE_GETNUMLWPS:
3657 break;
3658
3659 case VKI_PTRACE_GETLWPLIST:
3660 if (RES != -1)
3661 POST_MEM_WRITE(ARG3, sizeof(vki_lwpid_t) * RES);
3662 break;
3663
3664 case VKI_PTRACE_SETSTEP:
3665 break;
3666
3667 case VKI_PTRACE_CLEARSTEP:
3668 break;
3669
3670 case VKI_PTRACE_SUSPEND:
3671 break;
3672
3673 case VKI_PTRACE_RESUME:
3674 break;
3675
3676 case VKI_PTRACE_TO_SCE:
3677 break;
3678
3679 case VKI_PTRACE_TO_SCX:
3680 break;
3681
3682 case VKI_PTRACE_SYSCALL:
3683 break;
3684
3685 case VKI_PTRACE_VM_TIMESTAMP:
3686 break;
3687
3688 case VKI_PTRACE_VM_ENTRY:
3689 if (RES != -1)
3690 POST_MEM_WRITE(ARG3, sizeof(struct vki_ptrace_vm_entry));
3691 break;
3692 }
3693 }
3694
PRE(sys_cpuset_setaffinity)3695 PRE(sys_cpuset_setaffinity)
3696 {
3697
3698 PRINT("sys_cpuset_setaffinity ( %ld, %ld, %lld, %llu, %#lx )", ARG1, ARG2,
3699 ARG3, ARG4, ARG5);
3700 PRE_REG_READ5(int, "cpuset_setaffinity",
3701 int, level, int, which, long, id,
3702 size_t, setsize, void *, mask);
3703 PRE_MEM_READ("cpuset_setaffinity", ARG5, ARG4);
3704 }
3705
PRE(sys_cpuset_getaffinity)3706 PRE(sys_cpuset_getaffinity)
3707 {
3708
3709 PRINT("sys_cpuset_getaffinity ( %ld, %ld, %lld, %llu, %#lx )", ARG1, ARG2,
3710 ARG3, ARG4, ARG5);
3711 PRE_REG_READ5(int, "cpuset_getaffinity",
3712 int, level, int, which, long, id,
3713 size_t, setsize, void *, mask);
3714 PRE_MEM_WRITE("cpuset_getaffinity", ARG5, ARG4);
3715 }
3716
POST(sys_cpuset_getaffinity)3717 POST(sys_cpuset_getaffinity)
3718 {
3719 vg_assert(SUCCESS);
3720 if (RES == 0)
3721 POST_MEM_WRITE( ARG5, ARG4 );
3722 }
3723
3724 struct pselect_sized_sigset {
3725 const vki_sigset_t *ss;
3726 vki_size_t ss_len;
3727 };
3728 struct pselect_adjusted_sigset {
3729 struct pselect_sized_sigset ss; /* The actual syscall arg */
3730 vki_sigset_t adjusted_ss;
3731 };
3732
PRE(sys_pselect)3733 PRE(sys_pselect)
3734 {
3735 *flags |= SfMayBlock | SfPostOnFail;
3736 PRINT("sys_pselect ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
3737 FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
3738 SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3739 PRE_REG_READ6(long, "pselect",
3740 int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
3741 vki_fd_set *, exceptfds, struct vki_timeval *, timeout,
3742 void *, sig);
3743 // XXX: this possibly understates how much memory is read.
3744 if (ARG2 != 0)
3745 PRE_MEM_READ( "pselect(readfds)",
3746 ARG2, ARG1/8 /* __FD_SETSIZE/8 */ );
3747 if (ARG3 != 0)
3748 PRE_MEM_READ( "pselect(writefds)",
3749 ARG3, ARG1/8 /* __FD_SETSIZE/8 */ );
3750 if (ARG4 != 0)
3751 PRE_MEM_READ( "pselect(exceptfds)",
3752 ARG4, ARG1/8 /* __FD_SETSIZE/8 */ );
3753 if (ARG5 != 0)
3754 PRE_MEM_READ( "pselect(timeout)", ARG5, sizeof(struct vki_timeval) );
3755 if (ARG6 != 0) {
3756 const struct pselect_sized_sigset *pss =
3757 (struct pselect_sized_sigset *)(Addr)ARG6;
3758 PRE_MEM_READ( "pselect(sig)", ARG6, sizeof(*pss) );
3759 if (!ML_(safe_to_deref)(pss, sizeof(*pss))) {
3760 ARG6 = 1; /* Something recognisable to POST() hook. */
3761 } else {
3762 struct pselect_adjusted_sigset *pas;
3763 pas = VG_(malloc)("syswrap.pselect.1", sizeof(*pas));
3764 ARG6 = (Addr)pas;
3765 pas->ss.ss = (void *)1;
3766 pas->ss.ss_len = pss->ss_len;
3767 if (pss->ss_len == sizeof(*pss->ss)) {
3768 if (pss->ss == NULL) {
3769 pas->ss.ss = NULL;
3770 } else {
3771 PRE_MEM_READ("pselect(sig->ss)", (Addr)pss->ss, pss->ss_len);
3772 if (ML_(safe_to_deref)(pss->ss, sizeof(*pss->ss))) {
3773 pas->adjusted_ss = *pss->ss;
3774 pas->ss.ss = &pas->adjusted_ss;
3775 VG_(sanitize_client_sigmask)(&pas->adjusted_ss);
3776 }
3777 }
3778 }
3779 }
3780 }
3781 }
POST(sys_pselect)3782 POST(sys_pselect)
3783 {
3784 if (ARG6 != 0 && ARG6 != 1) {
3785 VG_(free)((struct pselect_adjusted_sigset *)(Addr)ARG6);
3786 }
3787 }
3788
3789 #undef PRE
3790 #undef POST
3791
3792 const SyscallTableEntry ML_(syscall_table)[] = {
3793 // syscall (handled specially) // 0
3794 BSDX_(__NR_exit, sys_exit), // 1
3795 BSDX_(__NR_fork, sys_fork), // 2
3796 GENXY(__NR_read, sys_read), // 3
3797
3798 GENX_(__NR_write, sys_write), // 4
3799 GENXY(__NR_open, sys_open), // 5
3800 GENXY(__NR_close, sys_close), // 6
3801 GENXY(__NR_wait4, sys_wait4), // 7
3802
3803 // 4.3 creat 8
3804 GENX_(__NR_link, sys_link), // 9
3805 GENX_(__NR_unlink, sys_unlink), // 10
3806 // obsol execv 11
3807
3808 GENX_(__NR_chdir, sys_chdir), // 12
3809 GENX_(__NR_fchdir, sys_fchdir), // 13
3810 GENX_(__NR_mknod, sys_mknod), // 14
3811 GENX_(__NR_chmod, sys_chmod), // 15
3812
3813 GENX_(__NR_chown, sys_chown), // 16
3814 GENX_(__NR_break, sys_brk), // 17
3815 BSDXY(__NR_getfsstat4, sys_getfsstat4), // 18
3816 // 4.3 lseek 19
3817
3818 GENX_(__NR_getpid, sys_getpid), // 20
3819 BSDX_(__NR_mount, sys_mount), // 21
3820 BSDX_(__NR_unmount, sys_unmount), // 22
3821 GENX_(__NR_setuid, sys_setuid), // 23
3822
3823 GENX_(__NR_getuid, sys_getuid), // 24
3824 GENX_(__NR_geteuid, sys_geteuid), // 25
3825 BSDXY(__NR_ptrace, sys_ptrace), // 26
3826 BSDXY(__NR_recvmsg, sys_recvmsg), // 27
3827
3828 BSDX_(__NR_sendmsg, sys_sendmsg), // 28
3829 BSDXY(__NR_recvfrom, sys_recvfrom), // 29
3830 BSDXY(__NR_accept, sys_accept), // 30
3831 BSDXY(__NR_getpeername, sys_getpeername), // 31
3832
3833 BSDXY(__NR_getsockname, sys_getsockname), // 32
3834 GENX_(__NR_access, sys_access), // 33
3835 BSDX_(__NR_chflags, sys_chflags), // 34
3836 BSDX_(__NR_fchflags, sys_fchflags), // 35
3837
3838 GENX_(__NR_sync, sys_sync), // 36
3839 GENX_(__NR_kill, sys_kill), // 37
3840 // 4.3 stat 38
3841 GENX_(__NR_getppid, sys_getppid), // 39
3842
3843 // 4.3 lstat 40
3844 GENXY(__NR_dup, sys_dup), // 41
3845 BSDXY(__NR_pipe, sys_pipe), // 42
3846 GENX_(__NR_getegid, sys_getegid), // 43
3847
3848 // GENX_(__NR_profil, sys_profil), // 44
3849 // BSDX_(__NR_ktrace, sys_ktrace), // 45
3850 // 4.3 sigaction 46
3851 GENX_(__NR_getgid, sys_getgid), // 47
3852
3853 // 4.3 sigaction (int sigset) 48
3854 BSDXY(__NR_getlogin, sys_getlogin), // 49
3855 BSDX_(__NR_setlogin, sys_setlogin), // 50
3856 GENX_(__NR_acct, sys_acct), // 51
3857
3858 // 4.3 sigpending 52
3859 GENXY(__NR_sigaltstack, sys_sigaltstack), // 53
3860 BSDXY(__NR_ioctl, sys_ioctl), // 54
3861 // BSDX_(__NR_reboot, sys_reboot), // 55
3862
3863 BSDX_(__NR_revoke, sys_revoke), // 56
3864 GENX_(__NR_symlink, sys_symlink), // 57
3865 GENX_(__NR_readlink, sys_readlink), // 58
3866 GENX_(__NR_execve, sys_execve), // 59
3867
3868 GENX_(__NR_umask, sys_umask), // 60
3869 GENX_(__NR_chroot, sys_chroot), // 61
3870 // 4.3 fstat 62
3871 // 4.3 getgerninfo 63
3872
3873 // 4.3 getpagesize 64
3874 GENX_(__NR_msync, sys_msync), // 65
3875 BSDX_(__NR_vfork, sys_fork), // 66
3876 // obsol vread 67
3877
3878 // obsol vwrite 68
3879 // BSDX_(__NR_sbrk, sys_sbrk), // 69
3880 // BSDX_(__NR_sstk, sys_sstk), // 70
3881 // 4.3 mmap 71
3882
3883 // 4.2 vadvise 72
3884 GENXY(__NR_munmap, sys_munmap), // 73
3885 GENXY(__NR_mprotect, sys_mprotect), // 74
3886 GENX_(__NR_madvise, sys_madvise), // 75
3887
3888 // obsol vhangup 76
3889 // obsol vlimit 77
3890 GENXY(__NR_mincore, sys_mincore), // 78
3891 GENXY(__NR_getgroups, sys_getgroups), // 79
3892
3893 GENX_(__NR_setgroups, sys_setgroups), // 80
3894 GENX_(__NR_getpgrp, sys_getpgrp), // 81
3895 GENX_(__NR_setpgid, sys_setpgid), // 82
3896 GENXY(__NR_setitimer, sys_setitimer), // 83
3897
3898 // 4.3 wait 84
3899 // BSDX_(__NR_swapon, sys_swapon), // 85
3900 GENXY(__NR_getitimer, sys_getitimer), // 86
3901 // 4.3 gethostname 87
3902
3903 // 4.3 sethostname 88
3904 BSDX_(__NR_getdtablesize, sys_getdtablesize), // 89
3905 GENXY(__NR_dup2, sys_dup2), // 90
3906 // unimpl getdopt 91
3907
3908 BSDXY(__NR_fcntl, sys_fcntl), // 92
3909 GENX_(__NR_select, sys_select), // 93
3910 // unimpl setdopt 94
3911 GENX_(__NR_fsync, sys_fsync), // 95
3912
3913 GENX_(__NR_setpriority, sys_setpriority), // 96
3914 BSDXY(__NR_socket, sys_socket), // 97
3915 BSDX_(__NR_connect, sys_connect), // 98
3916 // 4.3 accept 99
3917
3918 GENX_(__NR_getpriority, sys_getpriority), // 100
3919 // 4.3 send 101
3920 // 4.3 recv 102
3921 // 4.3 sigreturn 103
3922
3923 BSDX_(__NR_bind, sys_bind), // 104
3924 BSDX_(__NR_setsockopt, sys_setsockopt), // 105
3925 BSDX_(__NR_listen, sys_listen), // 106
3926 // obsol vtimes 107
3927
3928 // 4.3 sigvec 108
3929 // 4.3 sigblock 109
3930 // 4.3 sigsetmask 110
3931 // 4.3 sigsuspend 111
3932
3933 // 4.3 sigstack 112
3934 // 4.3 recvmsg 113
3935 // 4.3 sendmsg 114
3936 // 4.3 vtrace 115
3937
3938 GENXY(__NR_gettimeofday, sys_gettimeofday), // 116
3939 GENXY(__NR_getrusage, sys_getrusage), // 117
3940 BSDXY(__NR_getsockopt, sys_getsockopt), // 118
3941 // unimpl resuba 119
3942
3943 GENXY(__NR_readv, sys_readv), // 120
3944 GENX_(__NR_writev, sys_writev), // 121
3945 GENX_(__NR_settimeofday, sys_settimeofday), // 122
3946 GENX_(__NR_fchown, sys_fchown), // 123
3947
3948 GENX_(__NR_fchmod, sys_fchmod), // 124
3949 // 4.3 recvfrom 125
3950 GENX_(__NR_setreuid, sys_setreuid), // 126
3951 GENX_(__NR_setregid, sys_setregid), // 127
3952
3953 GENX_(__NR_rename, sys_rename), // 128
3954 // 4.3 truncate 129
3955 // 4.3 ftruncate 130
3956 GENX_(__NR_flock, sys_flock), // 131
3957
3958 BSDX_(__NR_mkfifo, sys_mkfifo), // 132
3959 BSDX_(__NR_sendto, sys_sendto), // 133
3960 BSDX_(__NR_shutdown, sys_shutdown), // 134
3961 BSDXY(__NR_socketpair, sys_socketpair), // 135
3962
3963 GENX_(__NR_mkdir, sys_mkdir), // 136
3964 GENX_(__NR_rmdir, sys_rmdir), // 137
3965 GENX_(__NR_utimes, sys_utimes), // 138
3966 // 4.2 sigreturn 139
3967
3968 // BSDXY(__NR_adjtime, sys_adjtime), // 140
3969 // 4.3 getpeername 141
3970 // 4.3 gethostid 142
3971 // 4.3 sethostid 143
3972
3973 // 4.3 getrlimit 144
3974 // 4.3 setrlimit 145
3975 // 4.3 killpg 146
3976 GENX_(__NR_setsid, sys_setsid), // 147
3977
3978 BSDX_(__NR_quotactl, sys_quotactl), // 148
3979 // 4.3 quota 149
3980 // 4.3 getsockname 150
3981 // bsd/os sem_lock 151
3982
3983 // bsd/os sem_wakeup 152
3984 // bsd/os asyncdaemon 153
3985 // nosys 154
3986 // BSDXY(__NR_nfssvc, sys_nfssvc), // 155
3987
3988 // 4.3 getdirentries 156
3989 GENXY(__NR_statfs, sys_statfs), // 157
3990 GENXY(__NR_fstatfs, sys_fstatfs), // 158
3991 // nosys 159
3992
3993 // BSDXY(__NR_lgetfh, sys_lgetfh), // 160
3994 // BSDXY(__NR_getfh, sys_getfh), // 161
3995 BSDXY(__NR_getdomainname, sys_getdomainname), // 162
3996 BSDX_(__NR_setdomainname, sys_setdomainname), // 163
3997
3998 BSDXY(__NR_uname, sys_uname), // 164
3999 BSDX_(__NR_sysarch, sys_sysarch), // 165
4000 // BSDXY(__NR_rtprio, sys_rtprio), // 166
4001 // nosys 167
4002
4003 // nosys 168
4004 // BSDXY(__NR_semsys, sys_semsys), // 169
4005 // BSDXY(__NR_msgsys, sys_msgsys), // 170
4006 // BSDXY(__NR_shmsys, sys_shmsys), // 171
4007
4008 // nosys 172
4009 BSDXY(__NR_pread6, sys_pread), // 173
4010 BSDX_(__NR_pwrite6, sys_pwrite), // 174
4011 // nosys 175
4012
4013 // BSDXY(__NR_ntp_adjtime, sys_ntp_adjtime), // 176
4014 // bsd/os sfork 177
4015 // bsd/os getdescriptor 178
4016 // bsd/os setdescriptor 179
4017
4018 // nosys 180
4019 GENX_(__NR_setgid, sys_setgid), // 181
4020 BSDX_(__NR_setegid, sys_setegid), // 182
4021 BSDX_(__NR_seteuid, sys_seteuid), // 183
4022
4023 // unimpl lfs_bmapv 184
4024 // unimpl lfs_markv 185
4025 // unimpl lfs_segclean 186
4026 // unimpl lfs_segwait 187
4027
4028 BSDXY(__NR_stat, sys_stat), // 188
4029 BSDXY(__NR_fstat, sys_fstat), // 189
4030 BSDXY(__NR_lstat, sys_lstat), // 190
4031 BSDX_(__NR_pathconf, sys_pathconf), // 191
4032
4033 BSDX_(__NR_fpathconf, sys_fpathconf), // 192
4034 // nosys 193
4035 GENXY(__NR_getrlimit, sys_getrlimit), // 194
4036 GENX_(__NR_setrlimit, sys_setrlimit), // 195
4037
4038 BSDXY(__NR_getdirentries, sys_getdirentries), // 196
4039 BSDX_(__NR_mmap6, sys_mmap7), // 197
4040 // __syscall (handled specially) // 198
4041 BSDX_(__NR_lseek6, sys_lseek), // 199
4042
4043 BSDX_(__NR_truncate, sys_truncate), // 200
4044 BSDX_(__NR_ftruncate, sys_ftruncate), // 201
4045 BSDXY(__NR___sysctl, sys___sysctl), // 202
4046 GENX_(__NR_mlock, sys_mlock), // 203
4047
4048 GENX_(__NR_munlock, sys_munlock), // 204
4049 BSDX_(__NR_undelete, sys_undelete), // 205
4050 BSDX_(__NR_futimes, sys_futimes), // 206
4051 GENX_(__NR_getpgid, sys_getpgid), // 207
4052
4053 // netbsd newreboot 208
4054 GENXY(__NR_poll, sys_poll), // 209
4055 BSDX_(__NR_lkmnosys0, sys_lkmnosys0), // 210
4056 BSDX_(__NR_lkmnosys1, sys_lkmnosys1), // 211
4057
4058 BSDX_(__NR_lkmnosys2, sys_lkmnosys2), // 212
4059 BSDX_(__NR_lkmnosys3, sys_lkmnosys3), // 213
4060 BSDX_(__NR_lkmnosys4, sys_lkmnosys4), // 214
4061 BSDX_(__NR_lkmnosys5, sys_lkmnosys5), // 215
4062
4063 BSDX_(__NR_lkmnosys6, sys_lkmnosys6), // 216
4064 BSDX_(__NR_lkmnosys7, sys_lkmnosys7), // 217
4065 BSDX_(__NR_lkmnosys8, sys_lkmnosys8), // 218
4066 // BSDXY(__NR_nfs_fhopen, sys_nfs_fhopen), // 219
4067
4068 BSDXY(__NR___semctl7, sys___semctl7), // 220
4069 BSDX_(__NR_semget, sys_semget), // 221
4070 BSDX_(__NR_semop, sys_semop), // 222
4071 // unimpl semconfig 223
4072
4073 // BSDXY(__NR_msgctl, sys_msgctl), // 224
4074 // BSDX_(__NR_msgget, sys_msgget), // 225
4075 // BSDX_(__NR_msgsnd, sys_msgsnd), // 226
4076 // BSDXY(__NR_msgrcv, sys_msgrcv), // 227
4077
4078 BSDXY(__NR_shmat, sys_shmat), // 228
4079 BSDXY(__NR_shmctl7, sys_shmctl7), // 229
4080 BSDXY(__NR_shmdt, sys_shmdt), // 230
4081 BSDX_(__NR_shmget, sys_shmget), // 231
4082
4083 BSDXY(__NR_clock_gettime, sys_clock_gettime), // 232
4084 BSDX_(__NR_clock_settime, sys_clock_settime), // 233
4085 BSDXY(__NR_clock_getres, sys_clock_getres), // 234
4086 // unimpl timer_create 235
4087
4088 // unimpl timer_delete 236
4089 // unimpl timer_settime 237
4090 // unimpl timer_gettime 238
4091 // unimpl timer_getoverrun 239
4092
4093 GENXY(__NR_nanosleep, sys_nanosleep), // 240
4094 // nosys 241
4095 // nosys 242
4096 // nosys 243
4097
4098 // nosys 244
4099 // nosys 245
4100 // nosys 246
4101 // nosys 247
4102
4103 // BSDXY(__NR_ntp_gettime, sys_ntp_gettime), // 248
4104 // nosys 249
4105 // BSDXY(__NR_minherit, sys_minherit), // 250
4106 BSDX_(__NR_rfork, sys_rfork), // 251
4107
4108 GENXY(__NR_openbsd_poll, sys_poll), // 252
4109 BSDX_(__NR_issetugid, sys_issetugid), // 253
4110 GENX_(__NR_lchown, sys_lchown), // 254
4111 // nosys 255
4112
4113 // nosys 256
4114 // nosys 257
4115 // nosys 258
4116 // nosys 259
4117
4118 // nosys 260
4119 // nosys 261
4120 // nosys 262
4121 // nosys 263
4122
4123 // nosys 264
4124 // nosys 265
4125 // nosys 266
4126 // nosys 267
4127
4128 // nosys 268
4129 // nosys 269
4130 // nosys 270
4131 // nosys 271
4132
4133 GENXY(__NR_getdents, sys_getdents), // 272
4134 // nosys 273
4135 BSDX_(__NR_lchmod, sys_lchmod), // 274
4136 GENX_(__NR_netbsd_lchown, sys_lchown), // 275
4137
4138 BSDX_(__NR_lutimes, sys_lutimes), // 276
4139 // netbsd msync 277
4140 // netbsd stat 278
4141 // netbsd fstat 279
4142
4143 // netbsd lstat 280
4144 // nosys 281
4145 // nosys 282
4146 // nosys 283
4147
4148 // nosys 284
4149 // nosys 285
4150 // nosys 286
4151 // nosys 287
4152
4153 // nosys 288
4154 // nosys 289
4155 // nosys 290
4156 // nosys 291
4157
4158 // nosys 292
4159 // nosys 293
4160 // nosys 294
4161 // nosys 295
4162
4163 // nosys 296
4164 BSDXY(__NR_fhstatfs, sys_fhstatfs), // 297
4165 BSDXY(__NR_fhopen, sys_fhopen), // 298
4166 BSDXY(__NR_fhstat, sys_fhstat), // 299
4167
4168 // BSDX_(__NR_modnext, sys_modnext), // 300
4169 BSDXY(__NR_modstat, sys_modstat), // 301
4170 // BSDX_(__NR_modfnext, sys_modfnext), // 302
4171 BSDX_(__NR_modfind, sys_modfind), // 303
4172
4173 BSDX_(__NR_kldload, sys_kldload), // 304
4174 BSDX_(__NR_kldunload, sys_kldunload), // 305
4175 BSDX_(__NR_kldfind, sys_kldfind), // 306
4176 BSDX_(__NR_kldnext, sys_kldnext), // 307
4177
4178 // BSDXY(__NR_kldstat, sys_kldstat), // 308
4179 // BSDX_(__NR_kldfirstmod, sys_kldfirstmod), // 309
4180 GENX_(__NR_getsid, sys_getsid), // 310
4181 BSDX_(__NR_setresuid, sys_setresuid), // 311
4182
4183 BSDX_(__NR_setresgid, sys_setresgid), // 312
4184 // obsol signanosleep 313
4185 // BSDXY(__NR_aio_return, sys_aio_return), // 314
4186 // BSDXY(__NR_aio_suspend, sys_aio_suspend), // 315
4187
4188 // BSDXY(__NR_aio_cancel, sys_aio_cancel), // 316
4189 // BSDXY(__NR_aio_error, sys_aio_error), // 317
4190 // BSDXY(__NR_aio_read, sys_aio_read), // 318
4191 // BSDXY(__NR_aio_write, sys_aio_write), // 319
4192
4193 // BSDXY(__NR_lio_listio, sys_lio_listio), // 320
4194 BSDX_(__NR_yield, sys_yield), // 321
4195 // nosys 322
4196 // nosys 323
4197
4198 GENX_(__NR_mlockall, sys_mlockall), // 324
4199 BSDX_(__NR_munlockall, sys_munlockall), // 325
4200 BSDXY(__NR___getcwd, sys___getcwd), // 326
4201 // BSDXY(__NR_sched_setparam, sys_sched_setparam), // 327
4202
4203 // BSDXY(__NR_sched_getparam, sys_sched_getparam), // 328
4204 // BSDX_(__NR_sched_setscheduler, sys_sched_setscheduler), // 329
4205 // BSDX_(__NR_sched_getscheduler, sys_sched_getscheduler), // 330
4206 BSDX_(__NR_sched_yield, sys_sched_yield), // 331
4207
4208 BSDX_(__NR_sched_get_priority_max, sys_sched_get_priority_max), // 332
4209 BSDX_(__NR_sched_get_priority_min, sys_sched_get_priority_min), // 333
4210 // BSDXY(__NR_sched_rr_get_interval, sys_sched_rr_get_interval), // 334
4211 BSDX_(__NR_utrace, sys_utrace), // 335
4212
4213 // compat3 sendfile 336
4214 BSDXY(__NR_kldsym, sys_kldsym), // 337
4215 // BSDX_(__NR_jail, sys_jail), // 338
4216 // unimpl pioctl 339
4217
4218 BSDXY(__NR_sigprocmask, sys_sigprocmask), // 340
4219 BSDX_(__NR_sigsuspend, sys_sigsuspend), // 341
4220 BSDXY(__NR_sigaction4, sys_sigaction4), // 342
4221 BSDXY(__NR_sigpending, sys_sigpending), // 343
4222
4223 // BSDX_(__NR_sigreturn4, sys_sigreturn4), // 344
4224 BSDXY(__NR_sigtimedwait, sys_sigtimedwait), // 345
4225 BSDXY(__NR_sigwaitinfo, sys_sigwaitinfo), // 346
4226 BSDXY(__NR___acl_get_file, sys___acl_get_file), // 347
4227
4228 BSDX_(__NR___acl_set_file, sys___acl_set_file), // 348
4229 BSDXY(__NR___acl_get_fd, sys___acl_get_fd), // 349
4230 BSDX_(__NR___acl_set_fd, sys___acl_set_fd), // 350
4231 BSDX_(__NR___acl_delete_file, sys___acl_delete_file), // 351
4232
4233 BSDX_(__NR___acl_delete_fd, sys___acl_delete_fd), // 352
4234 BSDX_(__NR___acl_aclcheck_file, sys___acl_aclcheck_file), // 353
4235 BSDX_(__NR___acl_aclcheck_fd, sys___acl_aclcheck_fd), // 354
4236 // BSDXY(__NR_extattrctl, sys_extattrctl), // 355
4237
4238 // BSDXY(__NR_extattr_set_file, sys_extattr_set_file), // 356
4239 // BSDXY(__NR_extattr_get_file, sys_extattr_get_file), // 357
4240 // BSDXY(__NR_extattr_delete_file, sys_extattr_delete_file), // 358
4241 // BSDXY(__NR_aio_waitcomplete, sys_aio_waitcomplete), // 359
4242
4243 BSDXY(__NR_getresuid, sys_getresuid), // 360
4244 BSDXY(__NR_getresgid, sys_getresgid), // 361
4245 BSDX_(__NR_kqueue, sys_kqueue), // 362
4246 BSDXY(__NR_kevent, sys_kevent), // 363
4247
4248 // nosys 364
4249 // nosys 365
4250 // nosys 366
4251 // nosys 367
4252
4253 // nosys 368
4254 // nosys 369
4255 // lkmressys 370
4256 // extattr_set_fd 371
4257
4258 // extattr_get_fd 372
4259 // extattr_delete_fd 373
4260 // __setugid 374
4261 // nfsclnt 375
4262
4263 BSDX_(__NR_eaccess, sys_eaccess), // 376
4264 // afs_syscall 377
4265 // nmount 378
4266 // kse_exit 379
4267
4268 // kse_wakeup 380
4269 // kse_create 381
4270 // kse_thr_interrupt 382
4271 // kse_release 383
4272
4273 // __mac_get_proc 384
4274 // __mac_set_proc 385
4275 // __mac_get_fd 386
4276 // __mac_get_file 387
4277
4278 // __mac_set_fd 388
4279 // __mac_set_file 389
4280 BSDXY(__NR_kenv, sys_kenv), // 390
4281 // lchflags 391
4282
4283 BSDXY(__NR_uuidgen, sys_uuidgen), // 392
4284 BSDXY(__NR_sendfile, sys_sendfile), // 393
4285 // mac_syscall 394
4286 BSDXY(__NR_getfsstat, sys_getfsstat), // 395
4287
4288 BSDXY(__NR_statfs6, sys_statfs6), // 396
4289 BSDXY(__NR_fstatfs6, sys_fstatfs6), // 397
4290 BSDXY(__NR_fhstatfs6, sys_fhstatfs6), // 398
4291 // nosys 399
4292
4293 // ksem_close 400
4294 // ksem_post 401
4295 // ksem_wait 402
4296 // ksem_trywait 403
4297
4298 // ksem_init 404
4299 // ksem_open 405
4300 // ksem_unlink 406
4301 // ksem_getvalue 407
4302
4303 // ksem_destroy 408
4304 // __mac_get_pid 409
4305 // __mac_get_link 410
4306 // __mac_set_link 411
4307
4308 // extattr_set_link 412
4309 // extattr_get_link 413
4310 // extattr_delete_link 414
4311 // __mac_execve 415
4312
4313 BSDXY(__NR_sigaction, sys_sigaction), // 416
4314 BSDX_(__NR_sigreturn, sys_sigreturn), // 417
4315 // __xstat 418
4316 // __xfstat 419
4317
4318 // __xlstat 420
4319 BSDXY(__NR_getcontext, sys_getcontext), // 421
4320 BSDX_(__NR_setcontext, sys_setcontext), // 422
4321 BSDXY(__NR_swapcontext, sys_swapcontext), // 423
4322
4323 // swapoff 424
4324 BSDXY(__NR___acl_get_link, sys___acl_get_link), // 425
4325 BSDX_(__NR___acl_set_link, sys___acl_set_link), // 426
4326 BSDX_(__NR___acl_delete_link, sys___acl_delete_link), // 427
4327
4328 BSDX_(__NR___acl_aclcheck_link, sys___acl_aclcheck_link), // 428
4329 //!sigwait 429
4330 // thr_create 430
4331 BSDX_(__NR_thr_exit, sys_thr_exit), // 431
4332
4333 BSDXY(__NR_thr_self, sys_thr_self), // 432
4334 BSDXY(__NR_thr_kill, sys_thr_kill), // 433
4335 BSDXY(__NR__umtx_lock, sys__umtx_lock), // 434
4336 BSDXY(__NR__umtx_unlock, sys__umtx_unlock), // 435
4337
4338 // jail_attach 436
4339 // extattr_list_fd 437
4340 // extattr_list_file 438
4341 // extattr_list_link 439
4342
4343 // kse_switchin 440
4344 // ksem_timedwait 441
4345 // thr_suspend 442
4346 BSDX_(__NR_thr_wake, sys_thr_wake), // 443
4347 // kldunloadf 444
4348 // audit 445
4349 // auditon 446
4350 // getauid 447
4351
4352 // setauid 448
4353 // getaudit 449
4354 // setaudit 450
4355 // getaudit_addr 451
4356
4357 // setaudit_addr 452
4358 // auditctl 453
4359 BSDXY(__NR__umtx_op, sys__umtx_op), // 454
4360 BSDX_(__NR_thr_new, sys_thr_new), // 455
4361
4362 // sigqueue 456
4363 BSDXY(__NR_kmq_open, sys_mq_open), // 457
4364 // kmq_setattr 458
4365 // kmq_timedreceive 459
4366
4367 // kmq_timedsend 460
4368 // kmq_notify 461
4369 BSDX_(__NR_kmq_unlink, sys_mq_unlink), // 462
4370 // abort2 463
4371
4372 BSDX_(__NR_thr_set_name, sys_thr_set_name), // 464
4373 // aio_fsync 465
4374 BSDXY(__NR_rtprio_thread, sys_rtprio_thread), // 466
4375 // nosys 467
4376
4377 // nosys 468
4378 // __getpath_fromfd 469
4379 // __getpath_fromaddr 470
4380 // sctp_peeloff 471
4381
4382 // sctp_generic_sendmsg 472
4383 // sctp_generic_sendmsg_iov 473
4384 // sctp_generic_recvmsg 474
4385 BSDXY(__NR_pread, sys_pread7), // 475
4386
4387 BSDX_(__NR_pwrite, sys_pwrite7), // 476
4388 BSDX_(__NR_mmap, sys_mmap7), // 477
4389 BSDX_(__NR_lseek, sys_lseek7), // 478
4390 BSDX_(__NR_truncate7, sys_truncate7), // 479
4391
4392 BSDX_(__NR_ftruncate7, sys_ftruncate7), // 480
4393 BSDXY(__NR_thr_kill2, sys_thr_kill2), // 481
4394 BSDXY(__NR_shm_open, sys_shm_open), // 482
4395 BSDX_(__NR_shm_unlink, sys_shm_unlink), // 483
4396
4397 // cpuset 484
4398 // cpuset_setid 485
4399 // cpuset_getid 486
4400
4401 BSDXY(__NR_cpuset_getaffinity, sys_cpuset_getaffinity), // 487
4402 BSDX_(__NR_cpuset_setaffinity, sys_cpuset_setaffinity), // 488
4403 BSDX_(__NR_faccessat, sys_faccessat), // 489
4404 BSDX_(__NR_fchmodat, sys_fchmodat), // 490
4405 BSDX_(__NR_fchownat, sys_fchownat), // 491
4406
4407 // fexecve 492
4408 BSDXY(__NR_fstatat, sys_fstatat), // 493
4409 BSDX_(__NR_futimesat, sys_futimesat), // 494
4410 BSDX_(__NR_linkat, sys_linkat), // 495
4411
4412 BSDX_(__NR_mkdirat, sys_mkdirat), // 496
4413 BSDX_(__NR_mkfifoat, sys_mkfifoat), // 497
4414 BSDX_(__NR_mknodat, sys_mknodat), // 498
4415 BSDXY(__NR_openat, sys_openat), // 499
4416
4417 BSDX_(__NR_readlinkat, sys_readlinkat), // 500
4418 BSDX_(__NR_renameat, sys_renameat), // 501
4419 BSDX_(__NR_symlinkat, sys_symlinkat), // 502
4420 BSDX_(__NR_unlinkat, sys_unlinkat), // 503
4421
4422 // posix_openpt 504
4423
4424 BSDXY(__NR___semctl, sys___semctl), // 510
4425 BSDXY(__NR_shmctl, sys_shmctl), // 512
4426 BSDXY(__NR_pselect, sys_pselect), // 522
4427 BSDXY(__NR_pipe2, sys_pipe2), // 542
4428
4429 BSDX_(__NR_fake_sigreturn, sys_fake_sigreturn), // 1000, fake sigreturn
4430
4431 };
4432
4433 const UInt ML_(syscall_table_size) =
4434 sizeof(ML_(syscall_table)) / sizeof(ML_(syscall_table)[0]);
4435
4436 #endif // defined(VGO_freebsd)
4437
4438 /*--------------------------------------------------------------------*/
4439 /*--- end ---*/
4440 /*--------------------------------------------------------------------*/
4441